demian-cli 1.1.1 → 1.1.2

package/dist/vscode-worker.mjs

@@ -1,6 +1,7 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
 // src/vscode-worker.ts
+import { existsSync as existsSync5 } from "node:fs";
 import { mkdir as mkdir16, rm as rm5, writeFile as writeFile15 } from "node:fs/promises";
 import path36 from "node:path";
 
@@ -762,6 +763,24 @@ function isPathLikeKey(key) {
 }
 
 // src/ui/tui/store.ts
+var TUI_CONFIG_ACTION_PREFIX = "demian-config:";
+var TUI_SESSION_ACTION_PREFIX = "demian-session:";
+function parseTuiConfigAction(prompt) {
+  if (!prompt.startsWith(TUI_CONFIG_ACTION_PREFIX)) return void 0;
+  try {
+    return JSON.parse(prompt.slice(TUI_CONFIG_ACTION_PREFIX.length));
+  } catch {
+    return void 0;
+  }
+}
+function parseTuiSessionAction(prompt) {
+  if (!prompt.startsWith(TUI_SESSION_ACTION_PREFIX)) return void 0;
+  try {
+    return JSON.parse(prompt.slice(TUI_SESSION_ACTION_PREFIX.length));
+  } catch {
+    return void 0;
+  }
+}
 var TuiStore = class {
   #state = {
     status: {},
@@ -770,8 +789,14 @@ var TuiStore = class {
     inputMode: "starting",
     sessionOptions: [],
     sessionCursor: 0,
+    sessionCancelBehavior: "exit",
     providerOptions: [],
     providerCursor: 0,
+    configModelCursor: 0,
+    configAddProviderCursor: 0,
+    configModelInput: "",
+    configProviderInput: "",
+    configProviderPresets: defaultConfigProviderPresets(),
     agentOptions: [],
     agentCursor: 0,
     permissionPreset: "auto",
@@ -807,6 +832,7 @@ var TuiStore = class {
   #pendingPermissionTimeout;
   #syntheticPermissionId = 0;
   #activeClaudeCodePlan;
+  #notifyTimer;
   snapshot() {
     return {
       ...this.#state,
@@ -814,6 +840,7 @@ var TuiStore = class {
       selection: this.#state.selection ? { ...this.#state.selection } : void 0,
       sessionOptions: this.#state.sessionOptions.map((option) => ({ ...option })),
       providerOptions: this.#state.providerOptions.map((option) => ({ ...option })),
+      configProviderPresets: this.#state.configProviderPresets.map((option) => ({ ...option })),
       agentOptions: this.#state.agentOptions.map((option) => ({ ...option })),
       blocks: this.#state.blocks.map((block) => ({ ...block, lines: [...block.lines], toolDetails: cloneToolRunDetails(block.toolDetails), goalWork: cloneGoalWork(block.goalWork), cowork: cloneCoworkGroup(block.cowork) })),
       warnings: [...this.#state.warnings],
@@ -1035,6 +1062,10 @@ var TuiStore = class {
       agent: context.agent,
       cwd: context.cwd
     };
+    this.#state.configPath = context.configPath;
+    this.#state.configCreated = context.configCreated;
+    this.#state.configDefaultProvider = context.configDefaultProvider;
+    this.#state.configMessage = context.configMessage;
     if (context.contextEfficiency) {
       this.#state.contextEfficiency = {
         ...this.#state.contextEfficiency ?? { selectedTools: [] },
@@ -1066,7 +1097,7 @@ var TuiStore = class {
   currentPermissionPreset() {
     return this.#state.permissionPreset;
   }
-  requestSessionSelection(options2) {
+  requestSessionSelection(options2, behavior = {}) {
     if (this.#exitRequested) return Promise.resolve({ kind: "exit" });
     const normalized = options2.length > 0 ? options2.map((option) => ({ ...option })) : [{ kind: "new", title: "New session", status: "ready", currentWorkspace: true }];
     return new Promise((resolve) => {
@@ -1074,6 +1105,7 @@ var TuiStore = class {
       this.#state.inputMode = "session";
       this.#state.sessionOptions = normalized;
       this.#state.sessionCursor = 0;
+      this.#state.sessionCancelBehavior = behavior.cancel ?? "exit";
       this.#state.promptInput = "";
       this.#state.promptError = void 0;
       this.#state.streamingText = "";
@@ -1083,6 +1115,14 @@ var TuiStore = class {
       this.#notify();
     });
   }
+  cancelSessionSelection() {
+    if (this.#state.inputMode !== "session") return false;
+    if (this.#state.sessionCancelBehavior === "prompt") {
+      this.#resolveSession({ kind: "cancel" });
+      return false;
+    }
+    return true;
+  }
   moveSessionCursor(delta) {
     if (this.#state.inputMode !== "session" || this.#state.sessionOptions.length === 0) return;
     const count = this.#state.sessionOptions.length;
@@ -1103,6 +1143,10 @@ var TuiStore = class {
     if (this.#state.inputMode !== "session") return;
     this.#resolveSession({ kind: "new" });
   }
+  submitSessionSelectionShortcut() {
+    if (this.#state.inputMode !== "prompt" || this.#state.promptInput.trim()) return;
+    this.#resolvePrompt(`${TUI_SESSION_ACTION_PREFIX}${JSON.stringify({ type: "select" })}`);
+  }
   requestPrompt(initialPrompt) {
     if (this.#exitRequested) return Promise.resolve("");
     const prompt = (initialPrompt ?? "").trim();
@@ -1200,6 +1244,143 @@ var TuiStore = class {
     this.#state.activity = `provider ${option.name} selected`;
     this.#notify();
   }
+  openConfigManager(message) {
+    const canOpenFromConfig = this.#state.inputMode === "config" || this.#state.inputMode === "configModel" || this.#state.inputMode === "configModelInput" || this.#state.inputMode === "configProviderInput" || this.#state.inputMode === "configAddProvider";
+    if (!canOpenFromConfig && (this.#state.inputMode !== "prompt" || this.#state.promptInput.trim())) return;
+    this.#state.inputMode = "config";
+    const current = this.#state.selection?.providerName ?? this.#state.status.provider;
+    this.#state.providerCursor = Math.max(0, this.#state.providerOptions.findIndex((option) => option.name === current));
+    this.#state.configMessage = message ?? this.#state.configMessage;
+    this.#state.settingsError = void 0;
+    this.#state.activity = "configure providers and models";
+    this.#notify();
+  }
+  openConfigProviderInput(field) {
+    if (this.#state.inputMode !== "config") return;
+    const provider = this.#selectedConfigProvider();
+    if (!provider) return;
+    this.#state.inputMode = "configProviderInput";
+    this.#state.configProviderInputField = field;
+    this.#state.configProviderInput = configProviderFieldValue(provider, field);
+    this.#state.settingsError = void 0;
+    this.#state.activity = `edit ${field} for ${provider.name}`;
+    this.#notify();
+  }
+  appendConfigProviderInput(input2) {
+    if (this.#state.inputMode !== "configProviderInput") return;
+    this.#state.configProviderInput += input2;
+    this.#state.settingsError = void 0;
+    this.#notify();
+  }
+  backspaceConfigProviderInput() {
+    if (this.#state.inputMode !== "configProviderInput") return;
+    this.#state.configProviderInput = Array.from(this.#state.configProviderInput).slice(0, -1).join("");
+    this.#state.settingsError = void 0;
+    this.#notify();
+  }
+  submitConfigProviderInput() {
+    if (this.#state.inputMode !== "configProviderInput") return;
+    const provider = this.#selectedConfigProvider();
+    const field = this.#state.configProviderInputField;
+    if (!provider || !field) return;
+    this.#submitConfigAction({ type: "updateProvider", provider: provider.name, field, value: this.#state.configProviderInput });
+  }
+  moveConfigProviderCursor(delta) {
+    if (this.#state.inputMode !== "config" || this.#state.providerOptions.length === 0) return;
+    const count = this.#state.providerOptions.length;
+    this.#state.providerCursor = (this.#state.providerCursor + delta + count) % count;
+    this.#notify();
+  }
+  submitConfigDefaultProvider() {
+    if (this.#state.inputMode !== "config") return;
+    const option = this.#selectedConfigProvider();
+    if (!option) return;
+    this.#submitConfigAction({ type: "setDefaultProvider", provider: option.name });
+  }
+  openConfigModelSelector() {
+    if (this.#state.inputMode !== "config" && this.#state.inputMode !== "configModelInput") return;
+    const option = this.#selectedConfigProvider();
+    if (!option) return;
+    this.#state.inputMode = "configModel";
+    this.#state.configModelCursor = 0;
+    this.#state.settingsError = void 0;
+    this.#state.activity = `choose default model for ${option.name}`;
+    this.#notify();
+  }
+  moveConfigModelCursor(delta) {
+    if (this.#state.inputMode !== "configModel") return;
+    const profiles = this.#selectedConfigProvider()?.modelProfiles ?? [];
+    if (profiles.length === 0) return;
+    this.#state.configModelCursor = (this.#state.configModelCursor + delta + profiles.length) % profiles.length;
+    this.#notify();
+  }
+  submitConfigDefaultModel() {
+    if (this.#state.inputMode !== "configModel") return;
+    const provider = this.#selectedConfigProvider();
+    const profile = provider?.modelProfiles?.[this.#state.configModelCursor];
+    if (!provider || !profile?.model) return;
+    this.#submitConfigAction({
+      type: "setDefaultModel",
+      provider: provider.name,
+      profileName: profile.name,
+      name: profile.name,
+      displayName: profile.displayName,
+      model: profile.model
+    });
+  }
+  openConfigModelInput() {
+    if (this.#state.inputMode !== "configModel" && this.#state.inputMode !== "config") return;
+    if (!this.#selectedConfigProvider()) return;
+    this.#state.inputMode = "configModelInput";
+    this.#state.configModelInput = "";
+    this.#state.settingsError = void 0;
+    this.#state.activity = "add a model profile";
+    this.#notify();
+  }
+  appendConfigModelInput(input2) {
+    if (this.#state.inputMode !== "configModelInput") return;
+    this.#state.configModelInput += input2;
+    this.#state.settingsError = void 0;
+    this.#notify();
+  }
+  backspaceConfigModelInput() {
+    if (this.#state.inputMode !== "configModelInput") return;
+    this.#state.configModelInput = Array.from(this.#state.configModelInput).slice(0, -1).join("");
+    this.#state.settingsError = void 0;
+    this.#notify();
+  }
+  submitConfigModelInput() {
+    if (this.#state.inputMode !== "configModelInput") return;
+    const provider = this.#selectedConfigProvider();
+    const model = this.#state.configModelInput.trim();
+    if (!provider || !model) {
+      this.#state.settingsError = "Model ID is required.";
+      this.#notify();
+      return;
+    }
+    this.#submitConfigAction({ type: "setDefaultModel", provider: provider.name, model, displayName: model });
+  }
+  openConfigAddProviderSelector() {
+    if (this.#state.inputMode !== "config") return;
+    this.#state.inputMode = "configAddProvider";
+    this.#state.configAddProviderCursor = 0;
+    this.#state.settingsError = void 0;
+    this.#state.activity = "add provider preset";
+    this.#notify();
+  }
+  moveConfigAddProviderCursor(delta) {
+    if (this.#state.inputMode !== "configAddProvider") return;
+    const count = this.#state.configProviderPresets.length;
+    if (count === 0) return;
+    this.#state.configAddProviderCursor = (this.#state.configAddProviderCursor + delta + count) % count;
+    this.#notify();
+  }
+  submitConfigAddProvider() {
+    if (this.#state.inputMode !== "configAddProvider") return;
+    const preset = this.#state.configProviderPresets[this.#state.configAddProviderCursor];
+    if (!preset) return;
+    this.#submitConfigAction({ type: "addProvider", preset: preset.preset, name: preset.name, apiKeyEnv: preset.apiKeyEnv });
+  }
   openAgentSelector() {
     if (this.#state.inputMode !== "prompt" || this.#state.promptInput.trim()) return;
     if (this.#state.agentOptions.length === 0) {
@@ -1298,9 +1479,12 @@ var TuiStore = class {
     this.#notify();
   }
   closeSettings() {
-    if (this.#state.inputMode !== "provider" && this.#state.inputMode !== "model" && this.#state.inputMode !== "agent" && this.#state.inputMode !== "permissionPreset") return;
+    if (!["provider", "model", "agent", "permissionPreset", "config", "configModel", "configModelInput", "configProviderInput", "configAddProvider"].includes(this.#state.inputMode)) return;
     this.#state.inputMode = "prompt";
     this.#state.modelInput = "";
+    this.#state.configModelInput = "";
+    this.#state.configProviderInput = "";
+    this.#state.configProviderInputField = void 0;
     this.#state.settingsError = void 0;
     this.#state.activity = "waiting for first message";
     this.#notify();
@@ -1429,9 +1613,12 @@ var TuiStore = class {
       this.#state.streamingFinalized = false;
       this.#activeClaudeCodePlan = this.#isClaudeCodePlanRun(event.provider) ? { text: "", providerName: event.provider, model: event.model, createdAt: event.ts } : void 0;
     }
-    if (event.type === "model.text.delta" && !isNestedInvocationEvent(event)) {
+    if (event.type === "model.text.delta") {
+      if (isNestedInvocationEvent(event)) return;
       this.#state.streamingText += event.text;
       this.#state.streamingFinalized = false;
+      this.#notify({ deferMs: 50 });
+      return;
     }
     if (event.type === "model.text" && !isNestedInvocationEvent(event)) {
       this.#state.streamingText = event.text;
@@ -2145,14 +2332,28 @@ var TuiStore = class {
     resolve(prompt);
     this.#notify();
   }
+  #selectedConfigProvider() {
+    return this.#state.providerOptions[this.#state.providerCursor];
+  }
+  #submitConfigAction(action) {
+    this.#state.settingsError = void 0;
+    this.#state.configModelInput = "";
+    this.#state.configProviderInput = "";
+    this.#state.configProviderInputField = void 0;
+    this.#resolvePrompt(`${TUI_CONFIG_ACTION_PREFIX}${JSON.stringify(action)}`);
+  }
   #resolveSession(selection) {
     const resolve = this.#sessionResolve;
     if (!resolve) return;
     this.#sessionResolve = void 0;
+    this.#state.sessionCancelBehavior = "exit";
     if (selection.kind === "exit") {
       this.#state.inputMode = "done";
       this.#state.done = true;
       this.#state.activity = "exiting";
+    } else if (selection.kind === "cancel") {
+      this.#state.inputMode = "prompt";
+      this.#state.activity = "waiting for next message";
     } else {
       this.#state.inputMode = "starting";
       this.#state.activity = selection.kind === "new" ? "creating session" : "opening session";
@@ -2264,7 +2465,23 @@ var TuiStore = class {
       }
     };
   }
-  #notify() {
+  #notify(options2 = {}) {
+    const deferMs = options2.deferMs ?? 0;
+    if (deferMs > 0) {
+      if (this.#notifyTimer) return;
+      this.#notifyTimer = setTimeout(() => {
+        this.#notifyTimer = void 0;
+        this.#emitNotify();
+      }, deferMs);
+      return;
+    }
+    if (this.#notifyTimer) {
+      clearTimeout(this.#notifyTimer);
+      this.#notifyTimer = void 0;
+    }
+    this.#emitNotify();
+  }
+  #emitNotify() {
     for (const listener of this.#listeners) listener();
   }
 };
@@ -2427,6 +2644,25 @@ function cloneContextEfficiency(context) {
     lastCompaction: context.lastCompaction ? { ...context.lastCompaction } : void 0
   };
 }
+function configProviderFieldValue(provider, field) {
+  if (field === "baseURL") return provider.baseURL ?? "";
+  if (field === "apiKeyEnv") return provider.apiKeyEnv ?? "";
+  return provider.auth?.header ?? "";
+}
+function defaultConfigProviderPresets() {
+  return [
+    { label: "OpenAI", preset: "openai", name: "openai", apiKeyEnv: "OPENAI_API_KEY", detail: "OpenAI API" },
+    { label: "Anthropic", preset: "anthropic", name: "anthropic", apiKeyEnv: "ANTHROPIC_API_KEY", detail: "Anthropic API" },
+    { label: "Gemini", preset: "gemini", name: "gemini", apiKeyEnv: "GEMINI_API_KEY", detail: "Google Gemini OpenAI-compatible API" },
+    { label: "Groq", preset: "groq", name: "groq", apiKeyEnv: "GROQ_API_KEY", detail: "Groq Cloud" },
+    { label: "Codex", preset: "codex", name: "codex", detail: "ChatGPT Codex OAuth" },
+    { label: "Claude Code", preset: "claudecode", name: "claudecode", detail: "Local Claude Code runtime" },
+    { label: "Ollama local", preset: "ollama-local", name: "ollama-local", detail: "http://localhost:11434" },
+    { label: "LM Studio", preset: "lmstudio", name: "lmstudio", detail: "http://localhost:1234" },
+    { label: "llama.cpp", preset: "llamacpp", name: "llamacpp", detail: "http://localhost:8080" },
+    { label: "vLLM", preset: "vllm", name: "vllm", detail: "http://localhost:8000" }
+  ];
+}
 function cloneToolRunDetails(details) {
   if (!details) return void 0;
   return {
@@ -2527,7 +2763,8 @@ function buildClaudeCodePlanExecutionPrompt(planText, requestText) {
 }
 
 // src/ui/tui/controller.ts
-import path33 from "node:path";
+import path34 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
 
 // src/agents/types.ts
 function normalizeAgent(input2) {
@@ -26966,10 +27203,380 @@ function claudeCodeRuntimePolicyHash(config) {
 }
 var CLAUDE_CODE_PERMISSION_PROFILE_KEYS = ["permissionMode", "defaultDecision", "allowedTools", "disallowedTools", "tools", "allowSubagents"];
 
-// src/transcript.ts
-import { mkdir as mkdir6, appendFile, writeFile as writeFile5 } from "node:fs/promises";
+// src/config-scaffold.ts
+import { chmod as chmod3, mkdir as mkdir6, readFile as readFile7, rename as rename4, stat as stat3, writeFile as writeFile5 } from "node:fs/promises";
 import os8 from "node:os";
 import path14 from "node:path";
+function defaultUserConfigPath() {
+  return path14.join(os8.homedir(), ".demian", "config.json");
+}
+function defaultUserConfig(defaultProvider = detectDefaultProvider()) {
+  return {
+    version: 2,
+    defaultProvider,
+    providers: {
+      openai: {
+        type: "openai-compatible",
+        baseURL: "https://api.openai.com/v1",
+        apiKey: "",
+        apiKeyEnv: "OPENAI_API_KEY",
+        catalog: { type: "openai-models", endpoint: "https://api.openai.com/v1/models" }
+      },
+      anthropic: {
+        type: "anthropic",
+        baseURL: "https://api.anthropic.com/v1",
+        apiKey: "",
+        apiKeyEnv: "ANTHROPIC_API_KEY",
+        catalog: { type: "anthropic-models", endpoint: "https://api.anthropic.com/v1/models" }
+      },
+      gemini: {
+        type: "openai-compatible",
+        baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
+        apiKey: "",
+        apiKeyEnv: "GEMINI_API_KEY",
+        apiKeyEnvAliases: ["GOOGLE_API_KEY"],
+        catalog: { type: "gemini-openai-models", endpoint: "https://generativelanguage.googleapis.com/v1beta/openai/models" }
+      },
+      groq: {
+        type: "openai-compatible",
+        baseURL: "https://api.groq.com/openai/v1",
+        apiKey: "",
+        apiKeyEnv: "GROQ_API_KEY",
+        catalog: { type: "groq-models", endpoint: "https://api.groq.com/openai/v1/models" }
+      },
+      azure: {
+        type: "openai-compatible",
+        auth: { type: "api-key", header: "api-key" },
+        modelProfiles: [
+          {
+            name: "azure-example",
+            displayName: "Azure example",
+            model: "azure-deployment-name",
+            baseURL: "https://example.openai.azure.com/openai/v1",
+            apiKey: "",
+            apiKeyEnv: "AZURE_OPENAI_API_KEY"
+          }
+        ]
+      },
+      lmstudio: {
+        type: "openai-compatible",
+        baseURL: "http://localhost:1234/v1",
+        apiKey: "lm-studio",
+        modelProfiles: [],
+        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:1234/v1/models" }
+      },
+      "ollama-local": {
+        type: "openai-compatible",
+        baseURL: "http://localhost:11434/v1",
+        apiKey: "ollama",
+        modelProfiles: [],
+        quirks: { omitTemperature: true },
+        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:11434/v1/models" }
+      },
+      "ollama-cloud": {
+        type: "ollama",
+        baseURL: "https://ollama.com/api",
+        apiKey: "",
+        apiKeyEnv: "OLLAMA_API_KEY",
+        modelProfiles: [],
+        catalog: { type: "ollama-tags", endpoint: "https://ollama.com/api/tags" }
+      },
+      llamacpp: {
+        type: "openai-compatible",
+        baseURL: "http://localhost:8080/v1",
+        apiKey: "llama.cpp",
+        modelProfiles: [],
+        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:8080/v1/models" }
+      },
+      vllm: {
+        type: "openai-compatible",
+        baseURL: "http://localhost:8000/v1",
+        apiKey: "vllm",
+        modelProfiles: [],
+        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:8000/v1/models" }
+      },
+      codex: {
+        type: "codex",
+        baseURL: "https://chatgpt.com/backend-api/codex",
+        authStore: "auto",
+        allowApiKeyFallback: false,
+        promptCacheKey: "root-session",
+        catalog: { type: "codex-oauth-models" }
+      },
+      claudecode: {
+        type: "claudecode",
+        runtime: "agent-sdk",
+        cliPath: "~/.local/bin/claude",
+        cwdMode: "session",
+        historyPolicy: "passthrough-resume",
+        onInvalidResume: "fresh",
+        attachmentFallback: "block",
+        allowSubagents: false,
+        sanitizeApiKeyEnv: true,
+        authPreflight: true,
+        useBareMode: false,
+        usageLedgerScope: "process",
+        sessionLock: true,
+        abortPolicy: "record-only",
+        catalog: { type: "claudecode-supported-models" }
+      }
+    }
+  };
+}
+async function createUserConfig(options2 = {}) {
+  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
+  const content = `${JSON.stringify(defaultUserConfig(options2.defaultProvider), null, 2)}
+`;
+  if (options2.print) return { path: filePath, created: false, content };
+  const existed = await exists(filePath);
+  if (existed && !options2.force) return { path: filePath, created: false, content: await readFile7(filePath, "utf8"), existed: true };
+  await writeJsonAtomic(filePath, content);
+  return { path: filePath, created: true, content, existed };
+}
+async function addProvider(options2) {
+  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
+  const config = await readConfigObject(filePath);
+  const providers = objectValue(config.providers);
+  const name = options2.name;
+  if (providers[name] && !options2.force) throw new Error(`Provider ${name} already exists. Use --force to overwrite it.`);
+  providers[name] = providerPreset(options2);
+  config.providers = providers;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(filePath, content);
+  return { path: filePath, created: true, content };
+}
+async function addModelProfile(options2) {
+  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
+  const config = await readConfigObject(filePath);
+  const providers = objectValue(config.providers);
+  const provider = objectValue(providers[options2.provider]);
+  const profiles = Array.isArray(provider.modelProfiles) ? [...provider.modelProfiles] : [];
+  const displayName = options2.displayName ?? options2.name;
+  const previousName = normalizeOptionalName(options2.previousName);
+  const existingByPreviousName = previousName ? profiles.findIndex((entry) => entry.name === previousName) : -1;
+  const existingByName = profiles.findIndex((entry) => entry.name === options2.name);
+  const existingByDisplay = profiles.findIndex((entry) => entry.displayName === displayName);
+  const updateIndex = existingByPreviousName >= 0 ? existingByPreviousName : existingByName;
+  if (existingByName >= 0 && existingByName !== updateIndex) throw new Error(`Profile name "${options2.name}" already exists on provider ${options2.provider}. Pick a different profile name.`);
+  if (existingByName >= 0 && existingByPreviousName < 0 && !options2.force) throw new Error(`Profile name "${options2.name}" already exists on provider ${options2.provider}. Use --force to overwrite it.`);
+  if (existingByDisplay >= 0 && existingByDisplay !== updateIndex && !options2.force) {
+    throw new Error(`Profile displayName "${displayName}" already exists on provider ${options2.provider} (profile name: ${profiles[existingByDisplay].name}). Use --force or pick a different --display-name.`);
+  }
+  const next = {
+    name: options2.name,
+    displayName,
+    model: options2.model,
+    ...options2.baseURL ? { baseURL: options2.baseURL } : {},
+    ...options2.apiKey !== void 0 || options2.apiKeyEnv ? { apiKey: options2.apiKey ?? "" } : {},
+    ...options2.apiKeyEnv ? { apiKeyEnv: options2.apiKeyEnv } : {}
+  };
+  if (updateIndex >= 0) profiles[updateIndex] = next;
+  else profiles.push(next);
+  provider.modelProfiles = profiles;
+  providers[options2.provider] = provider;
+  config.providers = providers;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(filePath, content);
+  return { path: filePath, created: true, content };
+}
+async function updateConfigDefaults(options2) {
+  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
+  const config = await readConfigObject(filePath);
+  const defaultProvider = normalizeOptionalName(options2.defaultProvider);
+  const defaultAgent = normalizeOptionalName(options2.defaultAgent);
+  if (!defaultProvider && !defaultAgent) throw new Error("At least one of defaultProvider or defaultAgent is required.");
+  if (defaultProvider) config.defaultProvider = defaultProvider;
+  if (defaultAgent) config.defaultAgent = defaultAgent;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(filePath, content);
+  return { path: filePath, created: true, content };
+}
+async function setDefaultModelProfile(options2) {
+  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
+  const config = await readConfigObject(filePath);
+  const providers = objectValue(config.providers);
+  const provider = providers[options2.provider];
+  if (!provider || typeof provider !== "object" || Array.isArray(provider)) throw new Error(`Provider ${options2.provider} does not exist.`);
+  const providerConfig = { ...provider };
+  const profiles = Array.isArray(providerConfig.modelProfiles) ? [...providerConfig.modelProfiles] : [];
+  const requestedName = normalizeOptionalName(options2.profileName ?? options2.name);
+  const requestedModel = normalizeOptionalName(options2.model);
+  const requestedDisplayName = normalizeOptionalName(options2.displayName) ?? requestedModel ?? requestedName;
+  let index = profiles.findIndex((entry) => requestedName && entry.name === requestedName);
+  if (index < 0 && requestedModel) index = profiles.findIndex((entry) => entry.model === requestedModel);
+  if (index < 0 && requestedDisplayName) index = profiles.findIndex((entry) => entry.displayName === requestedDisplayName);
+  const profile = index >= 0 ? {
+    ...profiles[index],
+    ...requestedName ? { name: requestedName } : {},
+    ...requestedDisplayName ? { displayName: requestedDisplayName } : {},
+    ...requestedModel ? { model: requestedModel } : {},
+    ...options2.baseURL ? { baseURL: options2.baseURL } : {},
+    ...options2.apiKey !== void 0 || options2.apiKeyEnv ? { apiKey: options2.apiKey ?? "" } : {},
+    ...options2.apiKeyEnv ? { apiKeyEnv: options2.apiKeyEnv } : {}
+  } : newModelProfile({
+    name: requestedName,
+    displayName: requestedDisplayName,
+    model: requestedModel ?? requestedName,
+    baseURL: options2.baseURL,
+    apiKey: options2.apiKey,
+    apiKeyEnv: options2.apiKeyEnv
+  });
+  if (!profile.name || typeof profile.name !== "string") throw new Error("Model profile name is required.");
+  if (!profile.model || typeof profile.model !== "string") throw new Error("Model ID is required.");
+  if (index >= 0) profiles.splice(index, 1);
+  profiles.unshift(profile);
+  providerConfig.modelProfiles = profiles;
+  providers[options2.provider] = providerConfig;
+  config.providers = providers;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(filePath, content);
+  return { path: filePath, created: true, content };
+}
+async function updateProviderSettings(options2) {
+  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
+  const config = await readConfigObject(filePath);
+  const providers = objectValue(config.providers);
+  const provider = providers[options2.provider];
+  if (!provider || typeof provider !== "object" || Array.isArray(provider)) throw new Error(`Provider ${options2.provider} does not exist.`);
+  const providerConfig = { ...provider };
+  if (options2.baseURL !== void 0) setOrDelete(providerConfig, "baseURL", options2.baseURL);
+  if (options2.apiKey !== void 0) setOrDelete(providerConfig, "apiKey", options2.apiKey);
+  if (options2.apiKeyEnv !== void 0) setOrDelete(providerConfig, "apiKeyEnv", options2.apiKeyEnv);
+  if (options2.authHeader !== void 0) {
+    const header = options2.authHeader.trim();
+    if (header) providerConfig.auth = { type: "api-key", header };
+    else delete providerConfig.auth;
+  }
+  providers[options2.provider] = providerConfig;
+  config.providers = providers;
+  const content = `${JSON.stringify(config, null, 2)}
+`;
+  await writeJsonAtomic(filePath, content);
+  return { path: filePath, created: true, content };
+}
+async function readConfigObject(filePath) {
+  if (!await exists(filePath)) await createUserConfig({ path: filePath });
+  const raw = JSON.parse(await readFile7(filePath, "utf8"));
+  raw.version ??= 2;
+  raw.providers = objectValue(raw.providers);
+  return raw;
+}
+function providerPreset(options2) {
+  const preset = options2.preset ?? options2.name;
+  const auth = apiKeyAuthFields(options2);
+  const openAIAuth = options2.authHeader ? { auth: { type: "api-key", header: options2.authHeader } } : {};
+  if (preset === "openai") return { type: "openai-compatible", baseURL: options2.baseURL ?? "https://api.openai.com/v1", ...apiKeyAuthFields(options2, "OPENAI_API_KEY"), ...openAIAuth, catalog: { type: "openai-models", endpoint: `${(options2.baseURL ?? "https://api.openai.com/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "anthropic") return { type: "anthropic", baseURL: options2.baseURL ?? "https://api.anthropic.com/v1", ...apiKeyAuthFields(options2, "ANTHROPIC_API_KEY"), catalog: { type: "anthropic-models", endpoint: `${(options2.baseURL ?? "https://api.anthropic.com/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "gemini") {
+    const geminiBase = options2.baseURL ?? "https://generativelanguage.googleapis.com/v1beta/openai/";
+    return { type: "openai-compatible", baseURL: geminiBase, ...apiKeyAuthFields(options2, "GEMINI_API_KEY"), apiKeyEnvAliases: ["GOOGLE_API_KEY"], ...openAIAuth, catalog: { type: "gemini-openai-models", endpoint: `${geminiBase.replace(/\/+$/, "")}/models` } };
+  }
+  if (preset === "groq") return { type: "openai-compatible", baseURL: options2.baseURL ?? "https://api.groq.com/openai/v1", ...apiKeyAuthFields(options2, "GROQ_API_KEY"), ...openAIAuth, catalog: { type: "groq-models", endpoint: `${(options2.baseURL ?? "https://api.groq.com/openai/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "azure") {
+    return {
+      type: "openai-compatible",
+      auth: { type: "api-key", header: options2.authHeader ?? "api-key" },
+      ...auth,
+      modelProfiles: [
+        {
+          name: "azure-example",
+          displayName: "Azure example",
+          model: "azure-deployment-name",
+          baseURL: options2.baseURL ?? "https://example.openai.azure.com/openai/v1",
+          ...options2.apiKey ? {} : { apiKey: "" },
+          apiKeyEnv: options2.apiKeyEnv ?? "AZURE_OPENAI_API_KEY"
+        }
+      ]
+    };
+  }
+  if (preset === "lmstudio") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:1234/v1", apiKey: options2.apiKey ?? "lm-studio", modelProfiles: [], catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:1234/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "ollama-local" || preset === "ollama") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:11434/v1", apiKey: options2.apiKey ?? "ollama", modelProfiles: [], quirks: { omitTemperature: true }, catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:11434/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "ollama-cloud") return { type: "ollama", baseURL: options2.baseURL ?? "https://ollama.com/api", ...apiKeyAuthFields(options2, "OLLAMA_API_KEY"), modelProfiles: [], catalog: { type: "ollama-tags", endpoint: `${(options2.baseURL ?? "https://ollama.com/api").replace(/\/+$/, "")}/tags` } };
+  if (preset === "llamacpp") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:8080/v1", apiKey: options2.apiKey ?? "llama.cpp", modelProfiles: [], catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:8080/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "vllm") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:8000/v1", apiKey: options2.apiKey ?? "vllm", modelProfiles: [], catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:8000/v1").replace(/\/+$/, "")}/models` } };
+  if (preset === "codex") return { type: "codex", baseURL: options2.baseURL ?? "https://chatgpt.com/backend-api/codex", authStore: "auto", allowApiKeyFallback: false, promptCacheKey: "root-session", catalog: { type: "codex-oauth-models" } };
+  if (preset === "claudecode") return { type: "claudecode", runtime: "agent-sdk", cliPath: "~/.local/bin/claude", cwdMode: "session", historyPolicy: "passthrough-resume", onInvalidResume: "fresh", attachmentFallback: "block", allowSubagents: false, sanitizeApiKeyEnv: true, authPreflight: true, useBareMode: false, usageLedgerScope: "process", sessionLock: true, abortPolicy: "record-only", catalog: { type: "claudecode-supported-models" } };
+  if ((options2.type ?? preset) === "openai-compatible") {
+    const baseURL = options2.baseURL;
+    if (!baseURL) throw new Error("openai-compatible provider requires --base-url.");
+    return {
+      type: "openai-compatible",
+      baseURL,
+      ...auth,
+      ...openAIAuth,
+      catalog: { type: "openai-compatible-models", endpoint: `${baseURL.replace(/\/+$/, "")}/models` }
+    };
+  }
+  throw new Error(`Unknown provider preset: ${preset}`);
+}
+function apiKeyAuthFields(options2, defaultApiKeyEnv) {
+  const apiKeyEnv = options2.apiKeyEnv ?? defaultApiKeyEnv;
+  return {
+    ...options2.apiKey !== void 0 || apiKeyEnv ? { apiKey: options2.apiKey ?? "" } : {},
+    ...apiKeyEnv ? { apiKeyEnv } : {}
+  };
+}
+async function writeJsonAtomic(filePath, content) {
+  await mkdir6(path14.dirname(filePath), { recursive: true, mode: 448 });
+  const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+  await writeFile5(temp, content, { mode: 384 });
+  await rename4(temp, filePath);
+  await chmod3(filePath, 384).catch(() => void 0);
+}
+function detectDefaultProvider() {
+  if (process.env.OPENAI_API_KEY) return "openai";
+  if (process.env.ANTHROPIC_API_KEY) return "anthropic";
+  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) return "gemini";
+  if (process.env.GROQ_API_KEY) return "groq";
+  return "openai";
+}
+function objectValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+}
+function normalizeOptionalName(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function newModelProfile(options2) {
+  const model = options2.model?.trim();
+  if (!model) throw new Error("Model ID is required.");
+  const name = options2.name?.trim() || modelProfileNameFromModel(model);
+  return {
+    name,
+    displayName: options2.displayName?.trim() || name,
+    model,
+    ...options2.baseURL ? { baseURL: options2.baseURL } : {},
+    ...options2.apiKey !== void 0 || options2.apiKeyEnv ? { apiKey: options2.apiKey ?? "" } : {},
+    ...options2.apiKeyEnv ? { apiKeyEnv: options2.apiKeyEnv } : {}
+  };
+}
+function modelProfileNameFromModel(model) {
+  return model.trim().replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80) || "model";
+}
+function setOrDelete(target, key, value) {
+  const trimmed = value.trim();
+  if (trimmed) target[key] = trimmed;
+  else delete target[key];
+}
+async function exists(filePath) {
+  try {
+    await stat3(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function expandHome2(value) {
+  return resolveExpandedPath(value);
+}
+
+// src/transcript.ts
+import { mkdir as mkdir7, appendFile, writeFile as writeFile6 } from "node:fs/promises";
+import os9 from "node:os";
+import path15 from "node:path";
 var TranscriptWriter = class {
   filePath;
   #enabled;
@@ -26977,9 +27584,9 @@ var TranscriptWriter = class {
   #queue = Promise.resolve();
   constructor(options2) {
     this.#enabled = options2.enabled !== false;
-    const dir = path14.join(options2.storageDir ?? defaultDemianStorageDir(), "transcripts", options2.sessionId);
-    this.filePath = path14.join(dir, "session.jsonl");
-    this.#ready = this.#enabled ? mkdir6(dir, { recursive: true }).then(() => writeFile5(this.filePath, "", { flag: "a" })) : Promise.resolve();
+    const dir = path15.join(options2.storageDir ?? defaultDemianStorageDir(), "transcripts", options2.sessionId);
+    this.filePath = path15.join(dir, "session.jsonl");
+    this.#ready = this.#enabled ? mkdir7(dir, { recursive: true }).then(() => writeFile6(this.filePath, "", { flag: "a" })) : Promise.resolve();
   }
   write(event) {
     if (!this.#enabled) return Promise.resolve();
@@ -26995,14 +27602,14 @@ var TranscriptWriter = class {
   }
 };
 function defaultDemianStorageDir() {
-  return path14.join(os8.homedir(), ".demian");
+  return path15.join(os9.homedir(), ".demian");
 }
 
 // src/external-runtime/snapshot-diff.ts
 import { createHash as createHash2 } from "node:crypto";
 import { createReadStream } from "node:fs";
-import { readdir, readFile as readFile7, stat as stat3 } from "node:fs/promises";
-import path15 from "node:path";
+import { readdir, readFile as readFile8, stat as stat4 } from "node:fs/promises";
+import path16 from "node:path";
 
 // src/workspace/diff.ts
 var CONTEXT_LINES = 3;
@@ -27212,7 +27819,7 @@ async function diffWorkspaceSnapshot(before) {
 }
 async function walk(root, relativeDir, entries, options2) {
   if (entries.size >= options2.maxFiles) return;
-  const absoluteDir = path15.join(root, relativeDir);
+  const absoluteDir = path16.join(root, relativeDir);
   let items;
   try {
     items = await readdir(absoluteDir, { withFileTypes: true });
@@ -27223,8 +27830,8 @@ async function walk(root, relativeDir, entries, options2) {
     if (entries.size >= options2.maxFiles) return;
     if (item.name.startsWith(".") && item.name !== ".env.example" && SKIP_DIRS.has(item.name)) continue;
     if (SKIP_DIRS.has(item.name)) continue;
-    const relativePath = normalizeRelativePath(path15.join(relativeDir, item.name));
-    const absolutePath = path15.join(root, relativePath);
+    const relativePath = normalizeRelativePath(path16.join(relativeDir, item.name));
+    const absolutePath = path16.join(root, relativePath);
     if (item.isDirectory()) {
       await walk(root, relativePath, entries, options2);
       continue;
@@ -27235,7 +27842,7 @@ async function walk(root, relativeDir, entries, options2) {
   }
 }
 async function snapshotFile(filePath, relativePath, maxTextBytes) {
-  const info = await stat3(filePath);
+  const info = await stat4(filePath);
   const sha2562 = await sha256File(filePath);
   const content = info.size <= maxTextBytes ? await readTextContent(filePath) : void 0;
   return { path: relativePath, size: info.size, sha256: sha2562, content };
@@ -27246,7 +27853,7 @@ function snapshotDiffText(entry) {
 `;
 }
 async function readTextContent(filePath) {
-  const buffer = await readFile7(filePath);
+  const buffer = await readFile8(filePath);
   if (buffer.includes(0)) return void 0;
   return buffer.toString("utf8");
 }
@@ -27260,7 +27867,7 @@ function sha256File(filePath) {
   });
 }
 function normalizeRelativePath(value) {
-  return value.split(path15.sep).join("/");
+  return value.split(path16.sep).join("/");
 }
 
 // src/external-runtime/session-runner.ts
@@ -27695,7 +28302,7 @@ function safeJson(value) {
 }
 
 // src/hooks/dispatcher.ts
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/hooks/command.ts
 import { spawn as spawn4 } from "node:child_process";
@@ -27788,7 +28395,7 @@ var blockDangerousBashHook = {
 };
 
 // src/hooks/builtin/protect-env-files.ts
-import path16 from "node:path";
+import path17 from "node:path";
 var protectEnvFilesHook = {
   name: "protect-env-files",
   event: "PreToolUse",
@@ -27796,7 +28403,7 @@ var protectEnvFilesHook = {
   run(ctx) {
     if (ctx.toolName !== "write_file" && ctx.toolName !== "edit_file") return { decision: "allow" };
     const input2 = ctx.toolInput && typeof ctx.toolInput === "object" ? ctx.toolInput : {};
-    const filePath = typeof input2.path === "string" ? path16.resolve(ctx.cwd, input2.path) : "";
+    const filePath = typeof input2.path === "string" ? path17.resolve(ctx.cwd, input2.path) : "";
     if (filePath && isEnvFile(filePath)) {
       return {
         decision: "block",
@@ -27833,7 +28440,7 @@ var maskSecretsHook = {
 };
 
 // src/hooks/builtin/inject-env-info.ts
-import os9 from "node:os";
+import os10 from "node:os";
 var injectEnvInfoHook = {
   name: "inject-env-info",
   event: "SessionStart",
@@ -27842,7 +28449,7 @@ var injectEnvInfoHook = {
       decision: "allow",
       patch: {
         systemNote: [
-          `Environment: ${os9.type()} ${os9.release()} (${os9.platform()}/${os9.arch()})`,
+          `Environment: ${os10.type()} ${os10.release()} (${os10.platform()}/${os10.arch()})`,
           `cwd: ${ctx.cwd}`,
           `provider: ${ctx.provider ?? "unknown"}`,
           `model: ${ctx.model ?? "unknown"}`,
@@ -27911,14 +28518,14 @@ function matchesHook(match, ctx) {
     const input2 = ctx.toolInput && typeof ctx.toolInput === "object" ? ctx.toolInput : {};
     const filePath = typeof input2.path === "string" ? input2.path : typeof input2.workdir === "string" ? input2.workdir : void 0;
     if (!filePath) return false;
-    if (!matchGlob(match.pathGlob, relativeToCwd(ctx.cwd, path17.resolve(ctx.cwd, filePath)))) return false;
+    if (!matchGlob(match.pathGlob, relativeToCwd(ctx.cwd, path18.resolve(ctx.cwd, filePath)))) return false;
   }
   return true;
 }
 
 // src/multimodal.ts
-import { readFile as readFile8, stat as stat4 } from "node:fs/promises";
-import path18 from "node:path";
+import { readFile as readFile9, stat as stat5 } from "node:fs/promises";
+import path19 from "node:path";
 var DEFAULT_MAX_IMAGE_BYTES = 8 * 1024 * 1024;
 async function buildUserContent(prompt, images = [], options2) {
   if (images.length === 0) return prompt;
@@ -27937,16 +28544,16 @@ async function buildUserContent(prompt, images = [], options2) {
 async function imageToUrl(input2, options2) {
   if (/^https?:\/\//i.test(input2) || /^data:image\//i.test(input2)) return input2;
   const filePath = resolveInsideCwd(options2.cwd, input2);
-  const info = await stat4(filePath);
+  const info = await stat5(filePath);
   if (!info.isFile()) throw new Error(`Image input is not a file: ${input2}`);
   const maxImageBytes = options2.maxImageBytes ?? DEFAULT_MAX_IMAGE_BYTES;
   if (info.size > maxImageBytes) throw new Error(`Image is larger than ${maxImageBytes} bytes: ${input2}`);
   const mime = mimeFromPath(filePath);
-  const bytes = await readFile8(filePath);
+  const bytes = await readFile9(filePath);
   return `data:${mime};base64,${bytes.toString("base64")}`;
 }
 function mimeFromPath(filePath) {
-  switch (path18.extname(filePath).toLowerCase()) {
+  switch (path19.extname(filePath).toLowerCase()) {
     case ".jpg":
     case ".jpeg":
       return "image/jpeg";
@@ -27957,15 +28564,15 @@ function mimeFromPath(filePath) {
     case ".webp":
       return "image/webp";
     default:
-      throw new Error(`Unsupported image extension: ${path18.extname(filePath) || "(none)"}`);
+      throw new Error(`Unsupported image extension: ${path19.extname(filePath) || "(none)"}`);
   }
 }
 
 // src/permissions/persistent-grants.ts
-import { mkdir as mkdir7, readFile as readFile9, writeFile as writeFile6 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile10, writeFile as writeFile7 } from "node:fs/promises";
 import fs8 from "node:fs";
-import os10 from "node:os";
-import path19 from "node:path";
+import os11 from "node:os";
+import path20 from "node:path";
 var DEFAULT_TTL_MS = 7 * 24 * 60 * 60 * 1e3;
 var PersistentGrantStore = class {
   filePath;
@@ -27996,22 +28603,22 @@ var PersistentGrantStore = class {
   }
   async #read() {
     if (!fs8.existsSync(this.filePath)) return { version: 1, grants: [] };
-    const data = JSON.parse(await readFile9(this.filePath, "utf8"));
+    const data = JSON.parse(await readFile10(this.filePath, "utf8"));
     return {
       version: 1,
       grants: Array.isArray(data.grants) ? data.grants.filter(isGrantRecord) : []
     };
   }
   async #write(file) {
-    await mkdir7(path19.dirname(this.filePath), { recursive: true });
-    await writeFile6(this.filePath, `${JSON.stringify(file, null, 2)}
+    await mkdir8(path20.dirname(this.filePath), { recursive: true });
+    await writeFile7(this.filePath, `${JSON.stringify(file, null, 2)}
 `, { mode: 384 });
   }
 };
 function resolveGrantPath(cwd, config) {
-  if (config.path) return path19.resolve(cwd, config.path);
-  if ((config.scope ?? "project") === "user") return path19.join(os10.homedir(), ".demian", "grants.json");
-  return path19.join(cwd, ".demian", "grants.json");
+  if (config.path) return path20.resolve(cwd, config.path);
+  if ((config.scope ?? "project") === "user") return path20.join(os11.homedir(), ".demian", "grants.json");
+  return path20.join(cwd, ".demian", "grants.json");
 }
 function isGrantRecord(value) {
   if (!value || typeof value !== "object") return false;
@@ -28444,25 +29051,25 @@ function fail(content, metadata) {
 }
 
 // src/tools/output.ts
-import { mkdir as mkdir8, writeFile as writeFile7 } from "node:fs/promises";
-import path20 from "node:path";
+import { mkdir as mkdir9, writeFile as writeFile8 } from "node:fs/promises";
+import path21 from "node:path";
 var DEFAULT_CAP_BYTES = 32 * 1024;
 var HALF_PREVIEW_BYTES = 16 * 1024;
 async function capToolOutput(result, options2) {
   const capBytes = options2.capBytes ?? DEFAULT_CAP_BYTES;
   const bytes = Buffer.byteLength(result.content, "utf8");
   if (bytes <= capBytes) return result;
-  const dir = path20.join(options2.cwd, ".demian", "tmp");
-  await mkdir8(dir, { recursive: true });
-  const outputPath = path20.join(dir, `output-${safeCallId(options2.callId)}.txt`);
-  await writeFile7(outputPath, result.content, "utf8");
+  const dir = path21.join(options2.cwd, ".demian", "tmp");
+  await mkdir9(dir, { recursive: true });
+  const outputPath = path21.join(dir, `output-${safeCallId(options2.callId)}.txt`);
+  await writeFile8(outputPath, result.content, "utf8");
   return {
     ...result,
     content: [
       sliceUtf8(result.content, 0, HALF_PREVIEW_BYTES),
       `
 
-[Full output saved to ${path20.relative(options2.cwd, outputPath)}; showing head and tail because output exceeded ${capBytes} bytes]
+[Full output saved to ${path21.relative(options2.cwd, outputPath)}; showing head and tail because output exceeded ${capBytes} bytes]
 
 `,
       sliceUtf8(result.content, Math.max(0, bytes - HALF_PREVIEW_BYTES), bytes)
@@ -28487,8 +29094,8 @@ function sliceUtf8(text, startByte, endByte) {
 }
 
 // src/tools/read-file.ts
-import { open as open2, stat as stat5 } from "node:fs/promises";
-import path21 from "node:path";
+import { open as open2, stat as stat6 } from "node:fs/promises";
+import path22 from "node:path";
 
 // src/tools/validation.ts
 function assertObject(input2, toolName) {
@@ -28558,7 +29165,7 @@ var readFileTool = {
     const filePath = resolveInsideCwd(ctx.cwd, stringField(object2, "path"));
     const offset = positiveInteger(optionalNumberField(object2, "offset"), 1, "offset");
     const limit = positiveInteger(optionalNumberField(object2, "limit"), DEFAULT_LIMIT, "limit");
-    const info = await stat5(filePath);
+    const info = await stat6(filePath);
     if (info.isDirectory()) throw new Error(`read_file expected a file but got a directory: ${relativeToCwd(ctx.cwd, filePath)}`);
     if (info.size > MAX_BYTES) throw new Error(`File is larger than ${MAX_BYTES} bytes: ${relativeToCwd(ctx.cwd, filePath)}`);
     const sample = await readBytes(filePath, Math.min(SAMPLE_BYTES, info.size));
@@ -28572,7 +29179,7 @@ var readFileTool = {
     const truncated = start + sliced.length < lines.length;
     return ok(content + (truncated ? `
 ... (${lines.length - start - sliced.length} more lines)` : ""), {
-      path: path21.relative(ctx.cwd, filePath),
+      path: path22.relative(ctx.cwd, filePath),
       lines: sliced.length,
       totalLines: lines.length,
       truncated
@@ -28610,8 +29217,8 @@ function looksBinary(buffer) {
 }
 
 // src/tools/write-file.ts
-import { mkdir as mkdir9, readFile as readFile10, writeFile as writeFile8 } from "node:fs/promises";
-import path22 from "node:path";
+import { mkdir as mkdir10, readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import path23 from "node:path";
 var writeFileTool = {
   name: "write_file",
   description: "Create or replace a text file inside the workspace.",
@@ -28629,8 +29236,8 @@ var writeFileTool = {
     const filePath = resolveInsideCwd(ctx.cwd, stringField(object2, "path"));
     const content = stringField(object2, "content", { allowEmpty: true });
     const before = await readOptionalTextFile(filePath);
-    await mkdir9(path22.dirname(filePath), { recursive: true });
-    await writeFile8(filePath, content, "utf8");
+    await mkdir10(path23.dirname(filePath), { recursive: true });
+    await writeFile9(filePath, content, "utf8");
     const relative = relativeToCwd(ctx.cwd, filePath);
     const diff = createTextDiff(before, content, relative);
     return ok(`Wrote ${relativeToCwd(ctx.cwd, filePath)} (${Buffer.byteLength(content, "utf8")} bytes).`, {
@@ -28643,7 +29250,7 @@ var writeFileTool = {
 };
 async function readOptionalTextFile(filePath) {
   try {
-    return await readFile10(filePath, "utf8");
+    return await readFile11(filePath, "utf8");
   } catch (error) {
     if (isNotFound(error)) return void 0;
     throw error;
@@ -28654,7 +29261,7 @@ function isNotFound(error) {
 }
 
 // src/tools/edit-file.ts
-import { readFile as readFile11, writeFile as writeFile9 } from "node:fs/promises";
+import { readFile as readFile12, writeFile as writeFile10 } from "node:fs/promises";
 var editFileTool = {
   name: "edit_file",
   description: "Replace an exact string in a text file inside the workspace.",
@@ -28676,12 +29283,12 @@ var editFileTool = {
     const newString = stringField(object2, "newString", { allowEmpty: true });
     const replaceAll = optionalBooleanField(object2, "replaceAll") ?? false;
     if (oldString === newString) throw new Error("oldString and newString must be different");
-    const before = await readFile11(filePath, "utf8");
+    const before = await readFile12(filePath, "utf8");
     const matches = countMatches(before, oldString);
     if (matches === 0) throw new Error("oldString was not found");
     if (matches > 1 && !replaceAll) throw new Error(`oldString matched ${matches} times; set replaceAll=true to replace all matches`);
     const after = replaceAll ? before.split(oldString).join(newString) : before.replace(oldString, newString);
-    await writeFile9(filePath, after, "utf8");
+    await writeFile10(filePath, after, "utf8");
     const relative = relativeToCwd(ctx.cwd, filePath);
     const diff = createTextDiff(before, after, relative);
     return ok(`Edited ${relative} (${replaceAll ? matches : 1} replacement${matches === 1 ? "" : "s"}).`, {
@@ -28705,7 +29312,7 @@ function countMatches(text, needle) {
 
 // src/tools/bash.ts
 import { spawn as spawn5 } from "node:child_process";
-import path24 from "node:path";
+import path25 from "node:path";
 
 // src/sandbox/env-only.ts
 function buildEnvOnlyLaunch(command, config) {
@@ -28765,7 +29372,7 @@ function bwrapPath() {
 
 // src/sandbox/macos.ts
 import { existsSync as existsSync3 } from "node:fs";
-import path23 from "node:path";
+import path24 from "node:path";
 function canUseMacOSSandbox() {
   return process.platform === "darwin" && existsSync3("/usr/bin/sandbox-exec");
 }
@@ -28791,7 +29398,7 @@ function macosProfile(cwd, config) {
   }
   if (mode === "workspace-write") {
     lines.push("(deny file-write*)");
-    lines.push(`(allow file-write* (subpath "${escapeProfilePath(path23.resolve(cwd))}"))`);
+    lines.push(`(allow file-write* (subpath "${escapeProfilePath(path24.resolve(cwd))}"))`);
     lines.push('(allow file-write* (subpath "/tmp"))');
     lines.push('(allow file-write* (subpath "/private/tmp"))');
     lines.push('(allow file-write* (subpath "/private/var/folders"))');
@@ -28853,7 +29460,7 @@ ${result.stderr}` : ""
     ].filter(Boolean).join("\n");
     return ok(content, {
       command,
-      workdir: path24.relative(ctx.cwd, workdir) || ".",
+      workdir: path25.relative(ctx.cwd, workdir) || ".",
       exitCode: result.exitCode,
       signal: result.signal,
       timedOut: result.timedOut,
@@ -28905,8 +29512,8 @@ function runCommand(command, cwd, timeoutMs, signal, sandbox = { mode: "workspac
 
 // src/tools/grep.ts
 import { spawn as spawn6 } from "node:child_process";
-import { readdir as readdir2, readFile as readFile12, stat as stat6 } from "node:fs/promises";
-import path25 from "node:path";
+import { readdir as readdir2, readFile as readFile13, stat as stat7 } from "node:fs/promises";
+import path26 from "node:path";
 var MAX_MATCHES = 200;
 var grepTool = {
   name: "grep",
@@ -28981,7 +29588,7 @@ function runRg(cwd, base, pattern, glob, signal) {
 }
 function rewriteRgPath(cwd, line) {
   const [file, rest] = splitFirst(line, ":");
-  if (!path25.isAbsolute(file)) return line;
+  if (!path26.isAbsolute(file)) return line;
   return `${relativeToCwd(cwd, file)}:${rest}`;
 }
 function splitFirst(value, delimiter) {
@@ -28996,13 +29603,13 @@ async function fallbackSearch(cwd, base, pattern, glob) {
     if (out.length > MAX_MATCHES) return;
     const relative = relativeToCwd(cwd, item);
     if (isIgnoredPath(relative)) return;
-    const info = await stat6(item);
+    const info = await stat7(item);
     if (info.isDirectory()) {
-      for (const entry of await readdir2(item)) await walk2(path25.join(item, entry));
+      for (const entry of await readdir2(item)) await walk2(path26.join(item, entry));
       return;
     }
     if (glob && !matchGlob(glob, relative)) return;
-    const buffer = await readFile12(item);
+    const buffer = await readFile13(item);
     if (buffer.includes(0)) return;
     const lines = buffer.toString("utf8").split(/\r?\n/);
     for (let i = 0; i < lines.length; i++) {
@@ -29016,8 +29623,8 @@ async function fallbackSearch(cwd, base, pattern, glob) {
 }
 
 // src/tools/glob.ts
-import { readdir as readdir3, stat as stat7 } from "node:fs/promises";
-import path26 from "node:path";
+import { readdir as readdir3, stat as stat8 } from "node:fs/promises";
+import path27 from "node:path";
 var MAX_PATHS = 1e3;
 var globTool = {
   name: "glob",
@@ -29049,10 +29656,10 @@ async function collectPaths(cwd, root, pattern) {
   async function walk2(dir) {
     const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolute = path26.join(dir, entry.name);
+      const absolute = path27.join(dir, entry.name);
       const relative = relativeToCwd(cwd, absolute);
       if (isIgnoredPath(relative)) continue;
-      const info = await stat7(absolute);
+      const info = await stat8(absolute);
       if (matchGlob(pattern, relative)) out.push({ relative, mtimeMs: info.mtimeMs });
       if (entry.isDirectory()) await walk2(absolute);
     }
@@ -30051,14 +30658,14 @@ async function runExecutionSession(options2) {
 }
 
 // src/goals/lock.ts
-import { mkdir as mkdir11, open as open3, rm as rm2 } from "node:fs/promises";
-import path28 from "node:path";
+import { mkdir as mkdir12, open as open3, rm as rm2 } from "node:fs/promises";
+import path29 from "node:path";
 
 // src/goals/storage.ts
 import { createHash as createHash3 } from "node:crypto";
-import { mkdir as mkdir10, readFile as readFile13, rename as rename4, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir11, readFile as readFile14, rename as rename5, writeFile as writeFile11 } from "node:fs/promises";
 import fs9 from "node:fs";
-import path27 from "node:path";
+import path28 from "node:path";
 var GoalStore = class {
   cwd;
   dir;
@@ -30069,12 +30676,12 @@ var GoalStore = class {
     this.cwd = cwd;
     this.scope = normalizeGoalStoreScope(options2.scope);
     this.dir = goalStoreDir(cwd, this.scope);
-    this.activePath = path27.join(this.dir, "active.json");
-    this.archiveDir = path27.join(this.dir, "archive");
+    this.activePath = path28.join(this.dir, "active.json");
+    this.archiveDir = path28.join(this.dir, "archive");
   }
   async loadActive() {
     if (!fs9.existsSync(this.activePath)) return void 0;
-    const text = await readFile13(this.activePath, "utf8");
+    const text = await readFile14(this.activePath, "utf8");
     try {
       return JSON.parse(text);
     } catch {
@@ -30083,36 +30690,36 @@ var GoalStore = class {
     }
   }
   async saveActive(state) {
-    await mkdir10(this.dir, { recursive: true });
-    const tmp = path27.join(this.dir, `active.${process.pid}.${Date.now()}.tmp`);
-    await writeFile10(tmp, `${JSON.stringify(state, null, 2)}
+    await mkdir11(this.dir, { recursive: true });
+    const tmp = path28.join(this.dir, `active.${process.pid}.${Date.now()}.tmp`);
+    await writeFile11(tmp, `${JSON.stringify(state, null, 2)}
 `, "utf8");
-    await rename4(tmp, this.activePath);
+    await rename5(tmp, this.activePath);
   }
   async archiveActive(status = "cleared") {
     const state = await this.loadActive();
     if (!state) return void 0;
-    await mkdir10(this.archiveDir, { recursive: true });
+    await mkdir11(this.archiveDir, { recursive: true });
     const archived = {
       ...state,
       status,
       updatedAt: Date.now()
     };
-    await writeFile10(path27.join(this.archiveDir, `${archived.id}.json`), `${JSON.stringify(archived, null, 2)}
+    await writeFile11(path28.join(this.archiveDir, `${archived.id}.json`), `${JSON.stringify(archived, null, 2)}
 `, "utf8");
     await fs9.promises.rm(this.activePath, { force: true });
     return archived;
   }
   async backupCorrupted(text) {
-    await mkdir10(this.dir, { recursive: true });
-    const backup = path27.join(this.dir, `active.corrupt.${Date.now()}.json`);
-    await writeFile10(backup, text, "utf8");
+    await mkdir11(this.dir, { recursive: true });
+    const backup = path28.join(this.dir, `active.corrupt.${Date.now()}.json`);
+    await writeFile11(backup, text, "utf8");
     await fs9.promises.rm(this.activePath, { force: true });
   }
 };
 function goalStoreDir(cwd, scope) {
   const safeScope = normalizeGoalStoreScope(scope);
-  return safeScope ? path27.join(cwd, ".demian", "goals", "sessions", safeScope) : path27.join(cwd, ".demian", "goals");
+  return safeScope ? path28.join(cwd, ".demian", "goals", "sessions", safeScope) : path28.join(cwd, ".demian", "goals");
 }
 function normalizeGoalStoreScope(scope) {
   const trimmed = scope?.trim();
@@ -30126,10 +30733,10 @@ function normalizeGoalStoreScope(scope) {
 var GoalLock = class {
   path;
   constructor(cwd, scope) {
-    this.path = path28.join(goalStoreDir(cwd, scope), "active.lock");
+    this.path = path29.join(goalStoreDir(cwd, scope), "active.lock");
   }
   async acquire() {
-    await mkdir11(path28.dirname(this.path), { recursive: true });
+    await mkdir12(path29.dirname(this.path), { recursive: true });
     const handle = await open3(this.path, "wx").catch((error) => {
       const code = typeof error === "object" && error && "code" in error ? String(error.code) : "";
       if (code === "EEXIST") throw new Error("Another goal is already active in this workspace.");
@@ -30717,8 +31324,8 @@ function sha256(value) {
 
 // src/root-session.ts
 import { cp, mkdtemp, rm as rm3 } from "node:fs/promises";
-import os11 from "node:os";
-import path29 from "node:path";
+import os12 from "node:os";
+import path30 from "node:path";
 
 // src/tools/cowork.ts
 function createCoworkTool(options2) {
@@ -31541,8 +32148,8 @@ Writer changed files outside writeScope: ${outOfScope.join(", ")}` : result.erro
     }
   }
   async createCoworkIsolatedWorkspace(groupId, memberId) {
-    const root = await mkdtemp(path29.join(os11.tmpdir(), `demian-cowork-${groupId}-${memberId}-`));
-    const cwd = path29.join(root, "workspace");
+    const root = await mkdtemp(path30.join(os12.tmpdir(), `demian-cowork-${groupId}-${memberId}-`));
+    const cwd = path30.join(root, "workspace");
     await cp(this.#options.cwd, cwd, {
       recursive: true,
       filter: (source) => shouldCopyIntoCoworkWorkspace(this.#options.cwd, source)
@@ -31897,7 +32504,7 @@ function scopeStaticPrefix(pattern) {
   return prefix.replace(/\/+$/, "").split("/").filter(Boolean).join("/") || ".";
 }
 function shouldCopyIntoCoworkWorkspace(root, source) {
-  const relative = path29.relative(root, source).split(path29.sep).join("/");
+  const relative = path30.relative(root, source).split(path30.sep).join("/");
   if (!relative) return true;
   const parts = relative.split("/");
   return !parts.includes(".git") && !parts.includes("node_modules") && !parts.includes(".demian");
@@ -32109,13 +32716,13 @@ function finitePositiveInteger(value) {
 }
 
 // src/ui/preferences.ts
-import { mkdir as mkdir12, readFile as readFile14, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile15, writeFile as writeFile12 } from "node:fs/promises";
 import fs10 from "node:fs";
-import path30 from "node:path";
+import path31 from "node:path";
 var UiPreferenceStore = class {
   filePath;
   constructor(cwd, filePath) {
-    this.filePath = filePath ? path30.resolve(cwd, filePath) : path30.join(cwd, ".demian", "preferences.json");
+    this.filePath = filePath ? path31.resolve(cwd, filePath) : path31.join(cwd, ".demian", "preferences.json");
   }
   async load() {
     if (!fs10.existsSync(this.filePath)) return void 0;
@@ -32133,13 +32740,13 @@ var UiPreferenceStore = class {
       model: selection.model,
       updatedAt: Date.now()
     };
-    await mkdir12(path30.dirname(this.filePath), { recursive: true });
-    await writeFile11(this.filePath, `${JSON.stringify(file, null, 2)}
+    await mkdir13(path31.dirname(this.filePath), { recursive: true });
+    await writeFile12(this.filePath, `${JSON.stringify(file, null, 2)}
 `, { mode: 384 });
   }
   async #read() {
     try {
-      return JSON.parse(await readFile14(this.filePath, "utf8"));
+      return JSON.parse(await readFile15(this.filePath, "utf8"));
     } catch {
       return void 0;
     }
@@ -32155,9 +32762,9 @@ function preferenceKey(selection) {
 
 // src/models/catalog.ts
 import crypto6 from "node:crypto";
-import { mkdir as mkdir13, readFile as readFile15, rename as rename5, writeFile as writeFile12 } from "node:fs/promises";
-import os12 from "node:os";
-import path31 from "node:path";
+import { mkdir as mkdir14, readFile as readFile16, rename as rename6, writeFile as writeFile13 } from "node:fs/promises";
+import os13 from "node:os";
+import path32 from "node:path";
 var DEFAULT_CACHE_TTL_MS = 5 * 60 * 1e3;
 var PING_TIMEOUT_MS = 1500;
 var DEFAULT_CODEX_CLIENT_VERSION = "0.0.0";
@@ -32469,12 +33076,12 @@ async function fetchJson2(url, options2) {
   return text ? JSON.parse(text) : {};
 }
 function cachePath(cacheKey) {
-  return path31.join(os12.homedir(), ".demian", "cache", "models", `${safeCacheName(cacheKey)}.json`);
+  return path32.join(os13.homedir(), ".demian", "cache", "models", `${safeCacheName(cacheKey)}.json`);
 }
 async function readCatalogCache(cacheKey, ttlMs, allow) {
   if (!allow) return void 0;
   try {
-    const raw = JSON.parse(await readFile15(cachePath(cacheKey), "utf8"));
+    const raw = JSON.parse(await readFile16(cachePath(cacheKey), "utf8"));
     if (!raw.result) return void 0;
     if (ttlMs !== Number.POSITIVE_INFINITY && Date.now() - (raw.savedAt ?? 0) > ttlMs) return void 0;
     return { ...raw.result, source: "cache", models: raw.result.models.map((model) => ({ ...model, source: "cache" })) };
@@ -32484,10 +33091,10 @@ async function readCatalogCache(cacheKey, ttlMs, allow) {
 }
 async function writeCatalogCache(cacheKey, result) {
   const filePath = cachePath(cacheKey);
-  await mkdir13(path31.dirname(filePath), { recursive: true, mode: 448 });
+  await mkdir14(path32.dirname(filePath), { recursive: true, mode: 448 });
   const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile12(temp, JSON.stringify({ savedAt: Date.now(), result }, null, 2), { mode: 384 });
-  await rename5(temp, filePath);
+  await writeFile13(temp, JSON.stringify({ savedAt: Date.now(), result }, null, 2), { mode: 384 });
+  await rename6(temp, filePath);
 }
 function safeCacheName(providerName) {
   return providerName.replace(/[^a-zA-Z0-9_.-]+/g, "_");
@@ -32538,7 +33145,7 @@ async function codexClientVersion(override) {
 }
 async function readPackageVersion() {
   try {
-    const raw = JSON.parse(await readFile15(new URL("../package.json", import.meta.url), "utf8"));
+    const raw = JSON.parse(await readFile16(new URL("../package.json", import.meta.url), "utf8"));
     return semverLike(raw.version) ?? DEFAULT_CODEX_CLIENT_VERSION;
   } catch {
     return DEFAULT_CODEX_CLIENT_VERSION;
@@ -32602,6 +33209,9 @@ function providerOptions(config, catalogs = {}) {
       permissionMode: provider.type === "claudecode" ? provider.permissionMode : void 0,
       ga: provider.type === "claudecode" ? claudeCodeGaEnabled(provider) : void 0,
       available,
+      baseURL: typeof provider.baseURL === "string" ? provider.baseURL : void 0,
+      apiKeyEnv: typeof provider.apiKeyEnv === "string" ? provider.apiKeyEnv : void 0,
+      auth: sanitizeProviderAuth(provider.auth),
       catalog: catalog ? { status: catalog.status, source: catalog.source, message: catalog.message } : void 0
     };
   }).sort((left, right) => {
@@ -32673,13 +33283,20 @@ function providerCatalogAvailable(catalog) {
 function unavailableLabel(value) {
   return `(n/a) ${value}`;
 }
+function sanitizeProviderAuth(auth) {
+  if (!auth || typeof auth !== "object" || Array.isArray(auth)) return void 0;
+  const record = auth;
+  const type = typeof record.type === "string" ? record.type : void 0;
+  const header = typeof record.header === "string" ? record.header : void 0;
+  return type || header ? { type, header } : void 0;
+}
 function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
 // src/ui/conversations.ts
-import { mkdir as mkdir14, readFile as readFile16, readdir as readdir4, rm as rm4, writeFile as writeFile13 } from "node:fs/promises";
-import path32 from "node:path";
+import { mkdir as mkdir15, readFile as readFile17, readdir as readdir4, rm as rm4, writeFile as writeFile14 } from "node:fs/promises";
+import path33 from "node:path";
 var CONVERSATIONS_DIR = "conversations";
 var CONVERSATION_INDEX_FILE = "conversations.json";
 var CONVERSATION_FILE = "conversation.json";
@@ -32692,13 +33309,13 @@ function createConversationRecord(input2) {
     title: input2.title?.trim() || "New session",
     createdAt: timestamp,
     updatedAt: timestamp,
-    cwd: path32.resolve(input2.cwd),
+    cwd: path33.resolve(input2.cwd),
     modelHistory: cleanModelHistory(input2.history ?? []),
     snapshot: input2.snapshot
   };
 }
 async function loadConversationIndex(storageDir = defaultDemianStorageDir()) {
-  const index = await readJson(path32.join(storageDir, CONVERSATION_INDEX_FILE));
+  const index = await readJson(path33.join(storageDir, CONVERSATION_INDEX_FILE));
   const conversations = Array.isArray(index?.conversations) ? index.conversations.map((item) => {
     if (!item || typeof item !== "object") return void 0;
     const object2 = item;
@@ -32732,7 +33349,7 @@ async function loadConversationRecords(storageDir = defaultDemianStorageDir()) {
 async function saveConversationRecords(storageDir, records, selectedSessionId) {
   const root = storageDir ?? defaultDemianStorageDir();
   const kept = [...records].sort((a, b2) => b2.updatedAt - a.updatedAt).slice(0, MAX_STORED_CONVERSATIONS).map((record) => ({ ...record, id: sanitizeConversationId(record.id), modelHistory: cleanModelHistory(record.modelHistory) }));
-  await mkdir14(path32.join(root, CONVERSATIONS_DIR), { recursive: true });
+  await mkdir15(path33.join(root, CONVERSATIONS_DIR), { recursive: true });
   for (const record of kept) {
     await writeJson(conversationRecordPath(root, record.id), {
       version: 1,
@@ -32745,7 +33362,7 @@ async function saveConversationRecords(storageDir, records, selectedSessionId) {
       snapshot: record.snapshot
     });
   }
-  await writeJson(path32.join(root, CONVERSATION_INDEX_FILE), {
+  await writeJson(path33.join(root, CONVERSATION_INDEX_FILE), {
     version: 1,
     selectedSessionId,
     conversations: kept.map((record) => ({
@@ -32770,7 +33387,7 @@ function findConversation(records, target) {
   return records.find((record) => record.id === value || record.id.startsWith(value)) ?? records.find((record) => record.title.toLowerCase() === normalized) ?? records.find((record) => record.title.toLowerCase().includes(normalized));
 }
 function sortConversationRecords(records, cwd) {
-  const resolvedCwd = path32.resolve(cwd);
+  const resolvedCwd = path33.resolve(cwd);
   return [...records].sort((a, b2) => {
     const aCurrent = isConversationForCwd(a, resolvedCwd) ? 0 : 1;
     const bCurrent = isConversationForCwd(b2, resolvedCwd) ? 0 : 1;
@@ -32785,7 +33402,7 @@ function conversationRuntimeStatus(record, cwd) {
   return isConversationForCwd(record, cwd) ? "ready" : "stored";
 }
 function isConversationForCwd(record, cwd) {
-  return path32.resolve(record.cwd) === path32.resolve(cwd);
+  return path33.resolve(record.cwd) === path33.resolve(cwd);
 }
 function conversationSummaryLine(record, index, activeId) {
   const active = record.id === activeId ? "*" : " ";
@@ -32805,14 +33422,14 @@ function cleanModelHistory(history) {
   return history.filter((message) => !isInternalModelHistoryMessage(message)).slice(-MAX_MODEL_HISTORY);
 }
 function conversationDir(storageDir, id) {
-  return path32.join(storageDir, CONVERSATIONS_DIR, sanitizeConversationId(id));
+  return path33.join(storageDir, CONVERSATIONS_DIR, sanitizeConversationId(id));
 }
 function conversationRecordPath(storageDir, id) {
-  return path32.join(conversationDir(storageDir, id), CONVERSATION_FILE);
+  return path33.join(conversationDir(storageDir, id), CONVERSATION_FILE);
 }
 async function listConversationRecordIds(storageDir) {
   try {
-    const entries = await readdir4(path32.join(storageDir, CONVERSATIONS_DIR), { withFileTypes: true });
+    const entries = await readdir4(path33.join(storageDir, CONVERSATIONS_DIR), { withFileTypes: true });
     return entries.filter((entry) => entry.isDirectory()).map((entry) => sanitizeConversationId(entry.name)).filter(Boolean);
   } catch {
     return [];
@@ -32820,14 +33437,14 @@ async function listConversationRecordIds(storageDir) {
 }
 async function readJson(filePath) {
   try {
-    return JSON.parse(await readFile16(filePath, "utf8"));
+    return JSON.parse(await readFile17(filePath, "utf8"));
   } catch {
     return void 0;
   }
 }
 async function writeJson(filePath, value) {
-  await mkdir14(path32.dirname(filePath), { recursive: true });
-  await writeFile13(filePath, `${JSON.stringify(value, null, 2)}
+  await mkdir15(path33.dirname(filePath), { recursive: true });
+  await writeFile14(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function normalizeConversationRecord(value, fallbackId) {
@@ -32882,11 +33499,12 @@ function formatRelativeAge(ms2) {
 
 // src/ui/tui/controller.ts
 async function runTuiSession(flags, store2) {
-  const cwd = path33.resolve(flags.cwd ?? process.cwd());
+  const cwd = path34.resolve(flags.cwd ?? process.cwd());
   const eventBus = new EventBus();
   eventBus.subscribe((event) => store2.handleEvent(event));
-  const loadedConfig2 = await loadConfig({ cwd, configPath: flags.configPath });
-  const config = flags.context ? mergeConfig(loadedConfig2, {
+  const configInit = await ensureTuiConfigExists(flags);
+  let loadedConfig2 = await loadConfig({ cwd, configPath: flags.configPath });
+  let config = flags.context ? mergeConfig(loadedConfig2, {
     context: {
       main: flags.context
     }
@@ -32906,6 +33524,10 @@ async function runTuiSession(flags, store2) {
   store2.configureSettings(initialSelection, await providerOptionsWithCatalog(config, { timeoutMs: 1500 }), {
     agent: agentName,
     cwd,
+    configPath: configMutationPath(flags),
+    configCreated: configInit.created,
+    configDefaultProvider: config.defaultProvider,
+    configMessage: configInit.created ? `Created config at ${configInit.path}` : void 0,
     agentOptions,
     contextEfficiency: {
       maxContextTokens: config.context.main.maxContextTokens,
@@ -32914,6 +33536,7 @@ async function runTuiSession(flags, store2) {
     }
   });
   let nextPrompt = flags.prompt;
+  let openConfigOnFirstPrompt = configInit.created && !flags.prompt.trim();
   const conversationsEnabled = flags.conversationManagement === true;
   const conversationState = conversationsEnabled ? await initializeConversationState(cwd, flags) : void 0;
   let currentConversation = conversationState?.current;
@@ -32954,13 +33577,28 @@ async function runTuiSession(flags, store2) {
     await applyStartupSessionSelection(selected);
   }
   for (; ; ) {
-    const prompt = await store2.requestPrompt(nextPrompt);
+    const promptPromise = store2.requestPrompt(nextPrompt);
+    if (openConfigOnFirstPrompt) {
+      openConfigOnFirstPrompt = false;
+      store2.openConfigManager(`Created config at ${configInit.path}`);
+    }
+    const prompt = await promptPromise;
     nextPrompt = void 0;
     if (store2.exitRequested()) {
       await saveCurrentSelection();
       return 0;
     }
     if (!prompt) return 0;
+    const configAction = parseTuiConfigAction(prompt);
+    if (configAction) {
+      await handleConfigAction(configAction);
+      continue;
+    }
+    const sessionAction = parseTuiSessionAction(prompt);
+    if (sessionAction) {
+      await handleSessionSelectionShortcut();
+      continue;
+    }
     const sessionCommand = parseSessionCommand(prompt);
     if (sessionCommand) {
       await handleSessionCommand(sessionCommand);
@@ -33237,6 +33875,25 @@ ${sessionListMessage()}`);
       await persistCurrentConversation();
     }
   }
+  async function handleSessionSelectionShortcut() {
+    if (!conversationsEnabled) {
+      store2.showSystemMessage("Sessions", "Session management is available in demian-cli TUI, but this embedded runtime lets the host manage sessions.");
+      store2.prepareForPrompt("waiting for next message");
+      return;
+    }
+    if (!currentConversation) {
+      currentConversation = createConversationRecord({ id: flags.sessionId ?? createRootSessionId(), cwd });
+      conversationRecords.set(currentConversation.id, currentConversation);
+    }
+    await persistCurrentConversation();
+    const selection = await store2.requestSessionSelection(startupSessionOptions(), { cancel: "prompt" });
+    if (selection.kind === "cancel") {
+      store2.prepareForPrompt("waiting for next message");
+      return;
+    }
+    if (selection.kind === "exit" || store2.exitRequested()) return;
+    await applyStartupSessionSelection(selection);
+  }
   function startupSessionOptions() {
     const records = sortedConversations();
     const sessionOptions = records.map((record) => ({
@@ -33246,11 +33903,15 @@ ${sessionListMessage()}`);
       cwd: record.cwd,
       status: conversationRuntimeStatus(record, cwd),
       updatedAt: record.updatedAt,
-      currentWorkspace: path33.resolve(record.cwd) === cwd
+      currentWorkspace: path34.resolve(record.cwd) === cwd
     }));
     return [...sessionOptions, { kind: "new", title: "New session", cwd, status: "ready", currentWorkspace: true }];
   }
   async function applyStartupSessionSelection(selection) {
+    if (selection.kind === "cancel") {
+      store2.prepareForPrompt("waiting for next message");
+      return;
+    }
     if (selection.kind === "new") {
       const next = createConversationRecord({ id: createRootSessionId(), cwd });
       conversationRecords.set(next.id, next);
@@ -33307,6 +33968,87 @@ ${sessionListMessage()}`);
     await preferenceStore.save(selection);
     savedSelectionKey = key;
   }
+  async function handleConfigAction(action) {
+    const path37 = configMutationPath(flags);
+    try {
+      let message = "Config updated.";
+      let nextSelection = {};
+      if (action.type === "setDefaultProvider") {
+        await updateConfigDefaults({ path: path37, defaultProvider: action.provider });
+        message = `Default provider saved: ${action.provider}`;
+        nextSelection = { provider: action.provider };
+      } else if (action.type === "setDefaultModel") {
+        await setDefaultModelProfile({
+          path: path37,
+          provider: action.provider,
+          profileName: action.profileName,
+          name: action.name,
+          displayName: action.displayName,
+          model: action.model
+        });
+        message = `Default model saved for ${action.provider}: ${action.displayName ?? action.model}`;
+        nextSelection = { provider: action.provider, model: action.displayName ?? action.model };
+      } else if (action.type === "addProvider") {
+        await addProvider({ path: path37, name: action.name, preset: action.preset, apiKeyEnv: action.apiKeyEnv });
+        message = `Provider added: ${action.name}`;
+        nextSelection = { provider: action.name };
+      } else if (action.type === "updateProvider") {
+        await updateProviderSettings({
+          path: path37,
+          provider: action.provider,
+          ...action.field === "baseURL" ? { baseURL: action.value } : {},
+          ...action.field === "apiKeyEnv" ? { apiKeyEnv: action.value } : {},
+          ...action.field === "authHeader" ? { authHeader: action.value } : {}
+        });
+        message = `Provider ${action.field} saved: ${action.provider}`;
+        nextSelection = { provider: action.provider };
+      }
+      await reloadConfigSettings(message, nextSelection);
+    } catch (error) {
+      store2.prepareForPrompt("config action failed");
+      store2.showSystemMessage("Config", errorMessage(error));
+      store2.openConfigManager(errorMessage(error));
+    }
+  }
+  async function reloadConfigSettings(message, selectionFlags = {}) {
+    loadedConfig2 = await loadConfig({ cwd, configPath: flags.configPath });
+    config = flags.context ? mergeConfig(loadedConfig2, {
+      context: {
+        main: flags.context
+      }
+    }) : loadedConfig2;
+    const currentSelection = store2.currentSelection();
+    const selection = createInteractiveModelSelection(
+      config,
+      selectionFlags.provider || selectionFlags.model ? selectionFlags : { provider: currentSelection.providerName, model: currentSelection.model }
+    );
+    store2.configureSettings(selection, await providerOptionsWithCatalog(config, { timeoutMs: 1500 }), {
+      agent: store2.currentAgentName(),
+      cwd,
+      configPath: configMutationPath(flags),
+      configDefaultProvider: config.defaultProvider,
+      configMessage: message,
+      agentOptions,
+      contextEfficiency: {
+        maxContextTokens: config.context.main.maxContextTokens,
+        compactAtRatio: config.context.main.compactAtRatio ?? config.context.main.compressAtRatio ?? 0.5,
+        compactAtTokens: config.context.main.maxContextTokens ? Math.floor(config.context.main.maxContextTokens * (config.context.main.compactAtRatio ?? config.context.main.compressAtRatio ?? 0.5)) : void 0
+      }
+    });
+    store2.openConfigManager(message);
+  }
+}
+async function ensureTuiConfigExists(flags) {
+  const target = configMutationPath(flags);
+  if (!flags.configPath) {
+    const jsondPath = target.replace(/\.json$/i, ".jsond");
+    if (existsSync4(target) || existsSync4(jsondPath)) return { path: target, created: false };
+  }
+  const result = await createUserConfig({ path: target });
+  return { path: result.path, created: result.created };
+}
+function configMutationPath(flags) {
+  return flags.configPath ? path34.resolve(flags.configPath) : defaultUserConfigPath();
 }
 function isGoalStateClearingAction(action) {
   return action === "status" || action === "pause" || action === "resume";
@@ -33344,289 +34086,6 @@ function sessionUsage() {
 import { EventEmitter } from "node:events";
 import fs11 from "node:fs";
 import path35 from "node:path";
-
-// src/config-scaffold.ts
-import { chmod as chmod3, mkdir as mkdir15, readFile as readFile17, rename as rename6, stat as stat8, writeFile as writeFile14 } from "node:fs/promises";
-import os13 from "node:os";
-import path34 from "node:path";
-function defaultUserConfigPath() {
-  return path34.join(os13.homedir(), ".demian", "config.json");
-}
-function defaultUserConfig(defaultProvider = detectDefaultProvider()) {
-  return {
-    version: 2,
-    defaultProvider,
-    providers: {
-      openai: {
-        type: "openai-compatible",
-        baseURL: "https://api.openai.com/v1",
-        apiKey: "",
-        apiKeyEnv: "OPENAI_API_KEY",
-        catalog: { type: "openai-models", endpoint: "https://api.openai.com/v1/models" }
-      },
-      anthropic: {
-        type: "anthropic",
-        baseURL: "https://api.anthropic.com/v1",
-        apiKey: "",
-        apiKeyEnv: "ANTHROPIC_API_KEY",
-        catalog: { type: "anthropic-models", endpoint: "https://api.anthropic.com/v1/models" }
-      },
-      gemini: {
-        type: "openai-compatible",
-        baseURL: "https://generativelanguage.googleapis.com/v1beta/openai/",
-        apiKey: "",
-        apiKeyEnv: "GEMINI_API_KEY",
-        apiKeyEnvAliases: ["GOOGLE_API_KEY"],
-        catalog: { type: "gemini-openai-models", endpoint: "https://generativelanguage.googleapis.com/v1beta/openai/models" }
-      },
-      groq: {
-        type: "openai-compatible",
-        baseURL: "https://api.groq.com/openai/v1",
-        apiKey: "",
-        apiKeyEnv: "GROQ_API_KEY",
-        catalog: { type: "groq-models", endpoint: "https://api.groq.com/openai/v1/models" }
-      },
-      azure: {
-        type: "openai-compatible",
-        auth: { type: "api-key", header: "api-key" },
-        modelProfiles: [
-          {
-            name: "azure-example",
-            displayName: "Azure example",
-            model: "azure-deployment-name",
-            baseURL: "https://example.openai.azure.com/openai/v1",
-            apiKey: "",
-            apiKeyEnv: "AZURE_OPENAI_API_KEY"
-          }
-        ]
-      },
-      lmstudio: {
-        type: "openai-compatible",
-        baseURL: "http://localhost:1234/v1",
-        apiKey: "lm-studio",
-        modelProfiles: [],
-        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:1234/v1/models" }
-      },
-      "ollama-local": {
-        type: "openai-compatible",
-        baseURL: "http://localhost:11434/v1",
-        apiKey: "ollama",
-        modelProfiles: [],
-        quirks: { omitTemperature: true },
-        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:11434/v1/models" }
-      },
-      "ollama-cloud": {
-        type: "ollama",
-        baseURL: "https://ollama.com/api",
-        apiKey: "",
-        apiKeyEnv: "OLLAMA_API_KEY",
-        modelProfiles: [],
-        catalog: { type: "ollama-tags", endpoint: "https://ollama.com/api/tags" }
-      },
-      llamacpp: {
-        type: "openai-compatible",
-        baseURL: "http://localhost:8080/v1",
-        apiKey: "llama.cpp",
-        modelProfiles: [],
-        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:8080/v1/models" }
-      },
-      vllm: {
-        type: "openai-compatible",
-        baseURL: "http://localhost:8000/v1",
-        apiKey: "vllm",
-        modelProfiles: [],
-        catalog: { type: "openai-compatible-models", endpoint: "http://localhost:8000/v1/models" }
-      },
-      codex: {
-        type: "codex",
-        baseURL: "https://chatgpt.com/backend-api/codex",
-        authStore: "auto",
-        allowApiKeyFallback: false,
-        promptCacheKey: "root-session",
-        catalog: { type: "codex-oauth-models" }
-      },
-      claudecode: {
-        type: "claudecode",
-        runtime: "agent-sdk",
-        cliPath: "~/.local/bin/claude",
-        cwdMode: "session",
-        historyPolicy: "passthrough-resume",
-        onInvalidResume: "fresh",
-        attachmentFallback: "block",
-        allowSubagents: false,
-        sanitizeApiKeyEnv: true,
-        authPreflight: true,
-        useBareMode: false,
-        usageLedgerScope: "process",
-        sessionLock: true,
-        abortPolicy: "record-only",
-        catalog: { type: "claudecode-supported-models" }
-      }
-    }
-  };
-}
-async function createUserConfig(options2 = {}) {
-  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
-  const content = `${JSON.stringify(defaultUserConfig(options2.defaultProvider), null, 2)}
-`;
-  if (options2.print) return { path: filePath, created: false, content };
-  const existed = await exists(filePath);
-  if (existed && !options2.force) return { path: filePath, created: false, content: await readFile17(filePath, "utf8"), existed: true };
-  await writeJsonAtomic(filePath, content);
-  return { path: filePath, created: true, content, existed };
-}
-async function addProvider(options2) {
-  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
-  const config = await readConfigObject(filePath);
-  const providers = objectValue(config.providers);
-  const name = options2.name;
-  if (providers[name] && !options2.force) throw new Error(`Provider ${name} already exists. Use --force to overwrite it.`);
-  providers[name] = providerPreset(options2);
-  config.providers = providers;
-  const content = `${JSON.stringify(config, null, 2)}
-`;
-  await writeJsonAtomic(filePath, content);
-  return { path: filePath, created: true, content };
-}
-async function addModelProfile(options2) {
-  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
-  const config = await readConfigObject(filePath);
-  const providers = objectValue(config.providers);
-  const provider = objectValue(providers[options2.provider]);
-  const profiles = Array.isArray(provider.modelProfiles) ? [...provider.modelProfiles] : [];
-  const displayName = options2.displayName ?? options2.name;
-  const existingByName = profiles.findIndex((entry) => entry.name === options2.name);
-  const existingByDisplay = profiles.findIndex((entry) => entry.displayName === displayName);
-  if (existingByName >= 0 && !options2.force) throw new Error(`Profile name "${options2.name}" already exists on provider ${options2.provider}. Use --force to overwrite it.`);
-  if (existingByDisplay >= 0 && existingByDisplay !== existingByName && !options2.force) {
-    throw new Error(`Profile displayName "${displayName}" already exists on provider ${options2.provider} (profile name: ${profiles[existingByDisplay].name}). Use --force or pick a different --display-name.`);
-  }
-  const next = {
-    name: options2.name,
-    displayName,
-    model: options2.model,
-    ...options2.baseURL ? { baseURL: options2.baseURL } : {},
-    ...options2.apiKey !== void 0 || options2.apiKeyEnv ? { apiKey: options2.apiKey ?? "" } : {},
-    ...options2.apiKeyEnv ? { apiKeyEnv: options2.apiKeyEnv } : {}
-  };
-  if (existingByName >= 0) profiles[existingByName] = next;
-  else profiles.push(next);
-  provider.modelProfiles = profiles;
-  providers[options2.provider] = provider;
-  config.providers = providers;
-  const content = `${JSON.stringify(config, null, 2)}
-`;
-  await writeJsonAtomic(filePath, content);
-  return { path: filePath, created: true, content };
-}
-async function updateConfigDefaults(options2) {
-  const filePath = expandHome2(options2.path ?? defaultUserConfigPath());
-  const config = await readConfigObject(filePath);
-  const defaultProvider = normalizeOptionalName(options2.defaultProvider);
-  const defaultAgent = normalizeOptionalName(options2.defaultAgent);
-  if (!defaultProvider && !defaultAgent) throw new Error("At least one of defaultProvider or defaultAgent is required.");
-  if (defaultProvider) config.defaultProvider = defaultProvider;
-  if (defaultAgent) config.defaultAgent = defaultAgent;
-  const content = `${JSON.stringify(config, null, 2)}
-`;
-  await writeJsonAtomic(filePath, content);
-  return { path: filePath, created: true, content };
-}
-async function readConfigObject(filePath) {
-  if (!await exists(filePath)) await createUserConfig({ path: filePath });
-  const raw = JSON.parse(await readFile17(filePath, "utf8"));
-  raw.version ??= 2;
-  raw.providers = objectValue(raw.providers);
-  return raw;
-}
-function providerPreset(options2) {
-  const preset = options2.preset ?? options2.name;
-  const auth = apiKeyAuthFields(options2);
-  const openAIAuth = options2.authHeader ? { auth: { type: "api-key", header: options2.authHeader } } : {};
-  if (preset === "openai") return { type: "openai-compatible", baseURL: options2.baseURL ?? "https://api.openai.com/v1", ...apiKeyAuthFields(options2, "OPENAI_API_KEY"), ...openAIAuth, catalog: { type: "openai-models", endpoint: `${(options2.baseURL ?? "https://api.openai.com/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "anthropic") return { type: "anthropic", baseURL: options2.baseURL ?? "https://api.anthropic.com/v1", ...apiKeyAuthFields(options2, "ANTHROPIC_API_KEY"), catalog: { type: "anthropic-models", endpoint: `${(options2.baseURL ?? "https://api.anthropic.com/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "gemini") {
-    const geminiBase = options2.baseURL ?? "https://generativelanguage.googleapis.com/v1beta/openai/";
-    return { type: "openai-compatible", baseURL: geminiBase, ...apiKeyAuthFields(options2, "GEMINI_API_KEY"), apiKeyEnvAliases: ["GOOGLE_API_KEY"], ...openAIAuth, catalog: { type: "gemini-openai-models", endpoint: `${geminiBase.replace(/\/+$/, "")}/models` } };
-  }
-  if (preset === "groq") return { type: "openai-compatible", baseURL: options2.baseURL ?? "https://api.groq.com/openai/v1", ...apiKeyAuthFields(options2, "GROQ_API_KEY"), ...openAIAuth, catalog: { type: "groq-models", endpoint: `${(options2.baseURL ?? "https://api.groq.com/openai/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "azure") {
-    return {
-      type: "openai-compatible",
-      auth: { type: "api-key", header: options2.authHeader ?? "api-key" },
-      ...auth,
-      modelProfiles: [
-        {
-          name: "azure-example",
-          displayName: "Azure example",
-          model: "azure-deployment-name",
-          baseURL: options2.baseURL ?? "https://example.openai.azure.com/openai/v1",
-          ...options2.apiKey ? {} : { apiKey: "" },
-          apiKeyEnv: options2.apiKeyEnv ?? "AZURE_OPENAI_API_KEY"
-        }
-      ]
-    };
-  }
-  if (preset === "lmstudio") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:1234/v1", apiKey: options2.apiKey ?? "lm-studio", modelProfiles: [], catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:1234/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "ollama-local" || preset === "ollama") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:11434/v1", apiKey: options2.apiKey ?? "ollama", modelProfiles: [], quirks: { omitTemperature: true }, catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:11434/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "ollama-cloud") return { type: "ollama", baseURL: options2.baseURL ?? "https://ollama.com/api", ...apiKeyAuthFields(options2, "OLLAMA_API_KEY"), modelProfiles: [], catalog: { type: "ollama-tags", endpoint: `${(options2.baseURL ?? "https://ollama.com/api").replace(/\/+$/, "")}/tags` } };
-  if (preset === "llamacpp") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:8080/v1", apiKey: options2.apiKey ?? "llama.cpp", modelProfiles: [], catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:8080/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "vllm") return { type: "openai-compatible", baseURL: options2.baseURL ?? "http://localhost:8000/v1", apiKey: options2.apiKey ?? "vllm", modelProfiles: [], catalog: { type: "openai-compatible-models", endpoint: `${(options2.baseURL ?? "http://localhost:8000/v1").replace(/\/+$/, "")}/models` } };
-  if (preset === "codex") return { type: "codex", baseURL: options2.baseURL ?? "https://chatgpt.com/backend-api/codex", authStore: "auto", allowApiKeyFallback: false, promptCacheKey: "root-session", catalog: { type: "codex-oauth-models" } };
-  if (preset === "claudecode") return { type: "claudecode", runtime: "agent-sdk", cliPath: "~/.local/bin/claude", cwdMode: "session", historyPolicy: "passthrough-resume", onInvalidResume: "fresh", attachmentFallback: "block", allowSubagents: false, sanitizeApiKeyEnv: true, authPreflight: true, useBareMode: false, usageLedgerScope: "process", sessionLock: true, abortPolicy: "record-only", catalog: { type: "claudecode-supported-models" } };
-  if ((options2.type ?? preset) === "openai-compatible") {
-    const baseURL = options2.baseURL;
-    if (!baseURL) throw new Error("openai-compatible provider requires --base-url.");
-    return {
-      type: "openai-compatible",
-      baseURL,
-      ...auth,
-      ...openAIAuth,
-      catalog: { type: "openai-compatible-models", endpoint: `${baseURL.replace(/\/+$/, "")}/models` }
-    };
-  }
-  throw new Error(`Unknown provider preset: ${preset}`);
-}
-function apiKeyAuthFields(options2, defaultApiKeyEnv) {
-  const apiKeyEnv = options2.apiKeyEnv ?? defaultApiKeyEnv;
-  return {
-    ...options2.apiKey !== void 0 || apiKeyEnv ? { apiKey: options2.apiKey ?? "" } : {},
-    ...apiKeyEnv ? { apiKeyEnv } : {}
-  };
-}
-async function writeJsonAtomic(filePath, content) {
-  await mkdir15(path34.dirname(filePath), { recursive: true, mode: 448 });
-  const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile14(temp, content, { mode: 384 });
-  await rename6(temp, filePath);
-  await chmod3(filePath, 384).catch(() => void 0);
-}
-function detectDefaultProvider() {
-  if (process.env.OPENAI_API_KEY) return "openai";
-  if (process.env.ANTHROPIC_API_KEY) return "anthropic";
-  if (process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY) return "gemini";
-  if (process.env.GROQ_API_KEY) return "groq";
-  return "openai";
-}
-function objectValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
-}
-function normalizeOptionalName(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
-}
-async function exists(filePath) {
-  try {
-    await stat8(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function expandHome2(value) {
-  return resolveExpandedPath(value);
-}
-
-// src/config-watcher.ts
 var ConfigWatcher = class extends EventEmitter {
   #filePath;
   #debounceMs;
@@ -33715,6 +34174,20 @@ if (process.argv.includes("--config-template")) {
 `);
   process.exit(0);
 }
+if (process.argv.includes("--config-read")) {
+  await readConfigMeta(jsonArg("--config-read")).then(
+    (result) => {
+      process.stdout.write(`${JSON.stringify({ ok: true, ...result })}
+`);
+      process.exit(0);
+    },
+    (error) => {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+      process.exit(1);
+    }
+  );
+}
 if (process.argv.includes("--config-init")) {
   const force = process.argv.includes("--force");
   await createUserConfig({ force }).then(
@@ -33772,6 +34245,34 @@ if (process.argv.includes("--config-set-defaults")) {
     }
   );
 }
+if (process.argv.includes("--config-set-default-model")) {
+  await setDefaultModelProfile(jsonArg("--config-set-default-model")).then(
+    (result) => {
+      process.stdout.write(`${JSON.stringify({ ok: true, path: result.path })}
+`);
+      process.exit(0);
+    },
+    (error) => {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+      process.exit(1);
+    }
+  );
+}
+if (process.argv.includes("--config-update-provider")) {
+  await updateProviderSettings(jsonArg("--config-update-provider")).then(
+    (result) => {
+      process.stdout.write(`${JSON.stringify({ ok: true, path: result.path })}
+`);
+      process.exit(0);
+    },
+    (error) => {
+      process.stderr.write(`${error instanceof Error ? error.message : String(error)}
+`);
+      process.exit(1);
+    }
+  );
+}
 if (process.argv.includes("--provider-auth-check")) {
   await checkProviderAuth(jsonArg("--provider-auth-check")).then(
     (result) => {
@@ -34346,30 +34847,43 @@ function setApiKey(providerName, apiKey, opts = {}) {
 }
 async function sendConfigMeta() {
   if (!loadedConfig) return;
+  send({ type: "configMeta", config: await buildConfigMeta(loadedConfig) });
+}
+async function readConfigMeta(options2) {
+  const cwd = typeof options2.cwd === "string" && options2.cwd.trim() ? options2.cwd : process.cwd();
+  const configPath = typeof options2.configPath === "string" && options2.configPath.trim() ? options2.configPath : defaultUserConfigPath();
+  let created = false;
+  if (options2.create && !existsSync5(configPath)) {
+    const result = await createUserConfig({ path: configPath });
+    created = result.created;
+  }
+  const config = await loadConfig({ cwd, configPath: options2.configPath });
+  return { path: configPath, created, config: await buildConfigMeta(config) };
+}
+async function buildConfigMeta(config) {
   const registry = new AgentRegistry();
-  for (const agentDefinition of Object.values(loadedConfig.agents ?? {})) registry.register(agentDefinition, { scope: "user", trusted: true });
-  const providerEntries = sortProviderNames(Object.keys(loadedConfig.providers)).map((name) => [name, loadedConfig.providers[name]]).filter(([, provider]) => provider && !provider.hidden);
+  for (const agentDefinition of Object.values(config.agents ?? {})) registry.register(agentDefinition, { scope: "user", trusted: true });
+  const providerEntries = sortProviderNames(Object.keys(config.providers)).map((name) => [name, config.providers[name]]).filter(([, provider]) => provider && !provider.hidden);
   const providerOrder = new Map(providerEntries.map(([name], index) => [name, index]));
   const providers = (await Promise.all(providerEntries.map(([name, provider]) => providerMeta(name, provider)))).sort((left, right) => {
     if (left.available !== right.available) return left.available ? -1 : 1;
     return (providerOrder.get(left.name) ?? 0) - (providerOrder.get(right.name) ?? 0);
   });
-  send({
-    type: "configMeta",
-    config: {
-      defaultProvider: loadedConfig.defaultProvider,
-      defaultAgent: loadedConfig.defaultAgent,
-      context: {
-        main: loadedConfig.context?.main
-      },
-      providerOrder: providers.map((provider) => provider.name),
-      providers,
-      agents: registry.list().filter((agent) => !agent.hidden && isPrimaryAgent(agent)).map((agent) => ({ name: agent.name, description: agent.description }))
-    }
-  });
+  return {
+    defaultProvider: config.defaultProvider,
+    defaultAgent: config.defaultAgent,
+    context: {
+      main: config.context?.main
+    },
+    providerOrder: providers.map((provider) => provider.name),
+    providers,
+    agents: registry.list().filter((agent) => !agent.hidden && isPrimaryAgent(agent)).map((agent) => ({ name: agent.name, description: agent.description }))
+  };
 }
 async function providerMeta(name, provider) {
   const apiKeyEnv = typeof provider.apiKeyEnv === "string" ? provider.apiKeyEnv : void 0;
+  const configuredProfiles = configuredModelProfiles(provider);
+  const auth = sanitizeProviderAuth2(provider.auth);
   const catalog = await listProviderModelCatalog(name, provider).catch((error) => ({ status: "unavailable", providerName: name, models: [], source: "fallback", message: errorMessage4(error) }));
   const available = providerCatalogAvailable2(catalog);
   const modelProfiles = catalog.models.length ? catalog.models.map((model) => ({
@@ -34402,7 +34916,16 @@ async function providerMeta(name, provider) {
     modelLabel: available || !defaultModel ? defaultModel : unavailableLabel2(defaultModel),
     models,
     modelProfiles: labeledProfiles,
+    configuredModelProfiles: configuredProfiles,
+    configured: {
+      baseURL: provider.baseURL,
+      apiKeyEnv,
+      apiKeyEnvAliases: asStringArray(provider.apiKeyEnvAliases),
+      auth,
+      hasInlineApiKey: typeof provider.apiKey === "string" && provider.apiKey.length > 0
+    },
     baseURL: provider.baseURL,
+    auth,
     apiKeyEnv,
     apiKeyEnvAliases: asStringArray(provider.apiKeyEnvAliases),
     catalog: { status: catalog.status, source: catalog.source, message: catalog.message },
@@ -34411,6 +34934,26 @@ async function providerMeta(name, provider) {
     requiresApiKey: provider.type === "openai-compatible" || provider.type === "anthropic" || provider.type === "ollama"
   };
 }
+function configuredModelProfiles(provider) {
+  if (!Array.isArray(provider.modelProfiles)) return [];
+  return provider.modelProfiles.filter((profile) => profile && typeof profile === "object" && typeof profile.model === "string" && profile.model.trim()).map((profile, index) => {
+    const name = typeof profile.name === "string" && profile.name.trim() ? profile.name.trim() : typeof profile.displayName === "string" && profile.displayName.trim() ? profile.displayName.trim() : profile.model.trim();
+    const displayName = typeof profile.displayName === "string" && profile.displayName.trim() ? profile.displayName.trim() : name;
+    return {
+      name,
+      displayName,
+      model: profile.model.trim(),
+      description: typeof profile.description === "string" ? profile.description : void 0,
+      baseURL: typeof profile.baseURL === "string" ? profile.baseURL : void 0,
+      apiKeyEnv: typeof profile.apiKeyEnv === "string" ? profile.apiKeyEnv : void 0,
+      apiKeyEnvAliases: asStringArray(profile.apiKeyEnvAliases),
+      auth: sanitizeProviderAuth2(profile.auth),
+      hasInlineApiKey: typeof profile.apiKey === "string" && profile.apiKey.length > 0,
+      source: "config",
+      isDefault: index === 0
+    };
+  });
+}
 function providerCatalogAvailable2(catalog) {
   return catalog?.status === "ready" && Array.isArray(catalog.models) && catalog.models.length > 0;
 }
@@ -34420,6 +34963,12 @@ function unavailableLabel2(value) {
 function asStringArray(value) {
   return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
 }
+function sanitizeProviderAuth2(auth) {
+  if (!auth || typeof auth !== "object" || Array.isArray(auth)) return void 0;
+  const type = typeof auth.type === "string" ? auth.type : void 0;
+  const header = typeof auth.header === "string" ? auth.header : void 0;
+  return type || header ? { type, header } : void 0;
+}
 function contextOptions(value) {
   if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
   const context = {};