demian-cli 1.1.0 → 1.1.2

package/dist/vscode-worker.mjs

@@ -1,8 +1,9 @@
 import { createRequire } from 'node:module'; const require = createRequire(import.meta.url);
 
 // src/vscode-worker.ts
-import { mkdir as mkdir15, rm as rm4, writeFile as writeFile14 } from "node:fs/promises";
-import path35 from "node:path";
+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";
 
 // src/permissions/presets.ts
 var PERMISSION_PRESETS = ["deny", "ask", "auto", "full"];
@@ -67,6 +68,26 @@ function isCompactCommand(input2) {
 function isRetryCommand(input2) {
   return input2.trim().toLowerCase() === "/retry";
 }
+function isSessionCommand(input2) {
+  return /^\/(?:session|sessions|conversation|conversations|conv)(?:\s|$)/i.test(input2.trim());
+}
+function parseSessionCommand(input2) {
+  const raw = input2.trim();
+  if (!isSessionCommand(raw)) return void 0;
+  const rest = raw.replace(/^\/(?:session|sessions|conversation|conversations|conv)\b/i, "").trim();
+  if (!rest) return { action: "help" };
+  const tokens = shellishSplit(rest);
+  const action = tokens.shift()?.toLowerCase() ?? "help";
+  if (action === "help" || action === "-h" || action === "--help") return { action: "help" };
+  if (action === "list" || action === "ls") return { action: "list" };
+  if (action === "current" || action === "status") return { action: "current" };
+  if (action === "new" || action === "create") return { action: "new", title: tokens.join(" ").trim() || void 0 };
+  if (action === "switch" || action === "select" || action === "use" || action === "open") return { action: "switch", target: tokens.join(" ").trim() || void 0 };
+  if (action === "delete" || action === "remove" || action === "rm") return { action: "delete", target: tokens.join(" ").trim() || void 0 };
+  if (action === "rename" || action === "name") return { action: "rename", title: tokens.join(" ").trim() || void 0 };
+  if (action === "clear" || action === "reset") return { action: "clear" };
+  return { action: "switch", target: [action, ...tokens].join(" ").trim() };
+}
 function isCoworkCommand(input2) {
   return /^\/cowork(?:\s|$)/i.test(input2.trim());
 }
@@ -742,14 +763,40 @@ 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: {},
     blocks: [],
     activity: "starting",
     inputMode: "starting",
+    sessionOptions: [],
+    sessionCursor: 0,
+    sessionCancelBehavior: "exit",
     providerOptions: [],
     providerCursor: 0,
+    configModelCursor: 0,
+    configAddProviderCursor: 0,
+    configModelInput: "",
+    configProviderInput: "",
+    configProviderPresets: defaultConfigProviderPresets(),
     agentOptions: [],
     agentCursor: 0,
     permissionPreset: "auto",
@@ -769,6 +816,7 @@ var TuiStore = class {
   #blockId = 0;
   #stopActiveTask;
   #promptResolve;
+  #sessionResolve;
   #queuedPrompt;
   #exitRequested = false;
   #promptHistory = [];
@@ -784,12 +832,15 @@ var TuiStore = class {
   #pendingPermissionTimeout;
   #syntheticPermissionId = 0;
   #activeClaudeCodePlan;
+  #notifyTimer;
   snapshot() {
     return {
       ...this.#state,
       status: { ...this.#state.status },
       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],
@@ -827,6 +878,7 @@ var TuiStore = class {
   requestExit() {
     this.#exitRequested = true;
     if (this.#promptResolve) this.#resolvePrompt("");
+    if (this.#sessionResolve) this.#resolveSession({ kind: "exit" });
     this.#stopActiveTask?.();
     this.#state.inputMode = "done";
     this.#state.done = true;
@@ -906,6 +958,84 @@ var TuiStore = class {
     this.#state.activity = `context compacted: ${summary.beforeTokenEstimate} -> ${summary.afterTokenEstimate}`;
     this.#notify();
   }
+  conversationSnapshot() {
+    const snapshot = this.snapshot();
+    return {
+      ...snapshot,
+      inputMode: "prompt",
+      promptInput: "",
+      promptError: void 0,
+      streamingText: "",
+      streamingFinalized: true,
+      permission: void 0,
+      done: false
+    };
+  }
+  restoreConversationSnapshot(snapshot, fallback) {
+    this.#resetTransientConversationState();
+    const currentSettings = {
+      selection: this.#state.selection,
+      providerOptions: this.#state.providerOptions,
+      providerCursor: this.#state.providerCursor,
+      agentOptions: this.#state.agentOptions,
+      agentCursor: this.#state.agentCursor,
+      selectedAgent: this.#state.selectedAgent,
+      permissionPreset: this.#state.permissionPreset,
+      permissionPresetCursor: this.#state.permissionPresetCursor,
+      contextEfficiency: this.#state.contextEfficiency
+    };
+    const restoredSelection = snapshot?.selection ? { ...snapshot.selection } : currentSettings.selection;
+    const restoredAgent = snapshot?.selectedAgent ?? snapshot?.status?.agent ?? currentSettings.selectedAgent;
+    const restoredPermissionPreset = normalizePermissionPreset(snapshot?.permissionPreset, currentSettings.permissionPreset);
+    this.#state = {
+      ...this.#state,
+      ...safeConversationSnapshot(snapshot),
+      ...currentSettings,
+      selection: restoredSelection,
+      providerCursor: Math.max(0, currentSettings.providerOptions.findIndex((option) => option.name === restoredSelection?.providerName)),
+      selectedAgent: restoredAgent,
+      agentCursor: Math.max(0, currentSettings.agentOptions.findIndex((option) => option.name === restoredAgent)),
+      permissionPreset: restoredPermissionPreset,
+      permissionPresetCursor: Math.max(0, PERMISSION_PRESETS.indexOf(restoredPermissionPreset)),
+      status: {
+        ...snapshot?.status ?? this.#state.status,
+        sessionId: fallback.sessionId,
+        cwd: fallback.cwd,
+        provider: restoredSelection?.providerName ?? snapshot?.status?.provider ?? this.#state.status.provider,
+        model: restoredSelection?.model ?? snapshot?.status?.model ?? this.#state.status.model,
+        agent: restoredAgent ?? snapshot?.status?.agent ?? this.#state.status.agent
+      },
+      inputMode: "prompt",
+      promptInput: "",
+      promptError: void 0,
+      streamingText: "",
+      streamingFinalized: true,
+      permission: void 0,
+      done: false,
+      activity: `conversation: ${fallback.title}`
+    };
+    this.#blockId = nextBlockId(this.#state.blocks);
+    this.#notify();
+  }
+  clearConversation(title = "New session") {
+    this.#resetTransientConversationState();
+    this.#state.blocks = [];
+    this.#state.streamingText = "";
+    this.#state.streamingFinalized = true;
+    this.#state.permission = void 0;
+    this.#state.warnings = [];
+    this.#state.done = false;
+    this.#state.finalAnswer = void 0;
+    this.#state.progressNotes = [];
+    this.#state.turnDiff = void 0;
+    this.#state.diffExpanded = false;
+    this.#state.workPlan = void 0;
+    this.#state.workPlanExpanded = false;
+    this.#state.goal = void 0;
+    this.#state.pendingClaudeCodePlan = void 0;
+    this.#state.activity = `cleared conversation: ${title}`;
+    this.prepareForPrompt("waiting for next message");
+  }
   prepareForPrompt(message = "waiting for next message") {
     if (this.#exitRequested) return;
     this.#state.inputMode = "prompt";
@@ -932,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: [] },
@@ -963,7 +1097,58 @@ var TuiStore = class {
   currentPermissionPreset() {
     return this.#state.permissionPreset;
   }
+  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) => {
+      this.#sessionResolve = resolve;
+      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 = "";
+      this.#state.streamingFinalized = true;
+      this.#state.done = false;
+      this.#state.activity = "select session";
+      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;
+    this.#state.sessionCursor = (this.#state.sessionCursor + delta + count) % count;
+    this.#notify();
+  }
+  submitSessionSelection() {
+    if (this.#state.inputMode !== "session") return;
+    const option = this.#state.sessionOptions[this.#state.sessionCursor];
+    if (!option) return;
+    if (option.kind === "new") {
+      this.#resolveSession({ kind: "new" });
+      return;
+    }
+    if (option.id) this.#resolveSession({ kind: "session", id: option.id });
+  }
+  submitNewSessionSelection() {
+    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();
     if (prompt) {
       this.#rememberPrompt(prompt);
@@ -1004,12 +1189,12 @@ var TuiStore = class {
       this.#notify();
     });
   }
-  appendPromptInput(input2) {
+  appendPromptInput(input2, options2 = {}) {
     if (this.#state.inputMode !== "prompt" && this.#state.inputMode !== "running") return;
     if (this.#state.inputMode === "prompt") this.#detachPromptHistory();
     this.#state.promptInput += input2;
     this.#state.promptError = void 0;
-    this.#notify();
+    if (options2.notify !== false) this.#notify();
   }
   navigatePromptHistory(delta) {
     if (this.#state.inputMode !== "prompt" || this.#promptHistory.length === 0) return;
@@ -1059,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) {
@@ -1157,26 +1479,29 @@ 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();
   }
-  backspacePromptInput() {
+  backspacePromptInput(options2 = {}) {
     if (this.#state.inputMode !== "prompt" && this.#state.inputMode !== "running") return;
     if (this.#state.inputMode === "prompt") this.#detachPromptHistory();
     this.#state.promptInput = Array.from(this.#state.promptInput).slice(0, -1).join("");
     this.#state.promptError = void 0;
-    this.#notify();
+    if (options2.notify !== false) this.#notify();
   }
-  clearPromptInput() {
+  clearPromptInput(options2 = {}) {
     if (this.#state.inputMode !== "prompt" && this.#state.inputMode !== "running") return;
     if (this.#state.inputMode === "prompt") this.#detachPromptHistory();
     this.#state.promptInput = "";
     this.#state.promptError = void 0;
-    this.#notify();
+    if (options2.notify !== false) this.#notify();
   }
   usePendingClaudeCodePlan() {
     if (this.#state.inputMode !== "prompt") return false;
@@ -1288,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;
@@ -2004,9 +2332,38 @@ 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";
+    }
+    this.#notify();
+    resolve(selection);
+  }
   #rememberPrompt(prompt) {
     const value = prompt.trim();
-    if (!value || isExitCommand(value) || isStopCommand(value) || isCompactCommand(value) || isRetryCommand(value)) return;
+    if (!value || isExitCommand(value) || isStopCommand(value) || isCompactCommand(value) || isRetryCommand(value) || isSessionCommand(value)) return;
     if (this.#promptHistory.at(-1) === value) {
       this.#state.canRetryLastPrompt = true;
       return;
@@ -2018,6 +2375,20 @@ var TuiStore = class {
   #lastRetryPrompt() {
     return this.#promptHistory.at(-1);
   }
+  #resetTransientConversationState() {
+    this.#toolRuns.clear();
+    this.#goalWorkBlocks.clear();
+    this.#coworkBlocks.clear();
+    this.#activeGoalWorkBlockId = void 0;
+    this.#currentGoalNarrationId = void 0;
+    this.#timelineProgressIds.clear();
+    this.#pendingPermissionCallId = void 0;
+    if (this.#pendingPermissionTimeout) clearTimeout(this.#pendingPermissionTimeout);
+    this.#pendingPermissionTimeout = void 0;
+    this.#activeClaudeCodePlan = void 0;
+    this.#promptHistoryCursor = void 0;
+    this.#promptDraft = "";
+  }
   #detachPromptHistory() {
     this.#promptHistoryCursor = void 0;
     this.#promptDraft = "";
@@ -2094,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();
   }
 };
@@ -2257,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 {
@@ -2309,6 +2715,36 @@ function cloneGoalToolRun(tool) {
     details: cloneToolRunDetails(tool.details)
   };
 }
+function safeConversationSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== "object") return {};
+  return {
+    status: snapshot.status ? { ...snapshot.status } : void 0,
+    blocks: Array.isArray(snapshot.blocks) ? snapshot.blocks.map((block) => ({ ...block, lines: [...block.lines ?? []], toolDetails: cloneToolRunDetails(block.toolDetails), goalWork: cloneGoalWork(block.goalWork), cowork: cloneCoworkGroup(block.cowork) })) : [],
+    activity: typeof snapshot.activity === "string" ? snapshot.activity : "restored conversation",
+    warnings: Array.isArray(snapshot.warnings) ? [...snapshot.warnings] : [],
+    finalAnswer: snapshot.finalAnswer,
+    progressNotes: Array.isArray(snapshot.progressNotes) ? snapshot.progressNotes.map((note) => ({ ...note })) : [],
+    turnDiff: snapshot.turnDiff ? cloneDiffSummary(snapshot.turnDiff) : void 0,
+    diffExpanded: snapshot.diffExpanded === true,
+    workPlan: snapshot.workPlan ? {
+      ...snapshot.workPlan,
+      steps: snapshot.workPlan.steps.map((step) => ({ ...step }))
+    } : void 0,
+    workPlanExpanded: snapshot.workPlanExpanded === true,
+    goal: snapshot.goal ? { ...snapshot.goal } : void 0,
+    contextEfficiency: snapshot.contextEfficiency ? cloneContextEfficiency(snapshot.contextEfficiency) : void 0,
+    canRetryLastPrompt: snapshot.canRetryLastPrompt === true,
+    pendingClaudeCodePlan: snapshot.pendingClaudeCodePlan ? { ...snapshot.pendingClaudeCodePlan } : void 0
+  };
+}
+function nextBlockId(blocks) {
+  let max = 0;
+  for (const block of blocks ?? []) {
+    const match = /^block_(\d+)$/.exec(block.id);
+    if (match) max = Math.max(max, Number(match[1]));
+  }
+  return max;
+}
 function formatDuration2(durationMs) {
   if (durationMs < 1e3) return `${durationMs}ms`;
   return `${Math.round(durationMs / 1e3)}s`;
@@ -2327,7 +2763,8 @@ function buildClaudeCodePlanExecutionPrompt(planText, requestText) {
 }
 
 // src/ui/tui/controller.ts
-import path32 from "node:path";
+import path34 from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
 
 // src/agents/types.ts
 function normalizeAgent(input2) {
@@ -25421,8 +25858,8 @@ function permissionLabel(req) {
   if ((req.tool === "write_file" || req.tool === "edit_file" || req.tool === "read_file") && typeof inputObject.path === "string") {
     return `${req.tool}: ${inputObject.path}`;
   }
-  const path36 = typeof inputObject.path === "string" ? inputObject.path : typeof inputObject.file_path === "string" ? inputObject.file_path : void 0;
-  if (path36) return `${tool}: ${path36}`;
+  const path37 = typeof inputObject.path === "string" ? inputObject.path : typeof inputObject.file_path === "string" ? inputObject.file_path : void 0;
+  if (path37) return `${tool}: ${path37}`;
   return tool;
 }
 
@@ -26766,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;
@@ -26777,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();
@@ -26795,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;
@@ -27012,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 });
@@ -27023,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;
@@ -27035,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 };
@@ -27046,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");
 }
@@ -27060,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
@@ -27495,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";
@@ -27588,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",
@@ -27596,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",
@@ -27633,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",
@@ -27642,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"}`,
@@ -27711,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;
@@ -27737,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";
@@ -27757,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;
@@ -27796,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;
@@ -28244,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)
@@ -28287,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) {
@@ -28358,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));
@@ -28372,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
@@ -28410,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.",
@@ -28429,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).`, {
@@ -28443,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;
@@ -28454,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.",
@@ -28476,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"}).`, {
@@ -28505,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) {
@@ -28565,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");
 }
@@ -28591,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"))');
@@ -28653,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,
@@ -28705,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",
@@ -28781,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) {
@@ -28796,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++) {
@@ -28816,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",
@@ -28849,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);
     }
@@ -29851,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;
@@ -29869,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 {
@@ -29883,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();
@@ -29926,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.");
@@ -30046,8 +30853,8 @@ async function summarizeGoalTitleWithProvider(options2) {
 }
 function normalizeGoalTitle(value, objective) {
   const raw = typeof value === "string" ? value : "";
-  const firstLine = raw.split(/\r?\n/).find((line) => line.trim()) ?? "";
-  const cleaned = stripDecorations(firstLine);
+  const firstLine2 = raw.split(/\r?\n/).find((line) => line.trim()) ?? "";
+  const cleaned = stripDecorations(firstLine2);
   return truncateGoalTitle(cleaned || fallbackGoalTitle(objective));
 }
 function fallbackGoalTitle(objective) {
@@ -30517,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) {
@@ -31341,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)
@@ -31646,17 +32453,17 @@ function findDependencyCycle(group) {
   const byId = new Map(group.map((member) => [member.memberId, member]));
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
-  const path36 = [];
+  const path37 = [];
   const visit = (id) => {
-    if (visiting.has(id)) return [...path36.slice(path36.indexOf(id)), id];
+    if (visiting.has(id)) return [...path37.slice(path37.indexOf(id)), id];
     if (visited.has(id)) return void 0;
     visiting.add(id);
-    path36.push(id);
+    path37.push(id);
     for (const dep of byId.get(id)?.dependsOn ?? []) {
       const cycle = visit(dep);
       if (cycle) return cycle;
     }
-    path36.pop();
+    path37.pop();
     visiting.delete(id);
     visited.add(id);
     return void 0;
@@ -31697,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");
@@ -31909,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;
@@ -31933,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;
     }
@@ -31955,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";
@@ -32269,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" })) };
@@ -32284,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, "_");
@@ -32338,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;
@@ -32402,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) => {
@@ -32473,17 +33283,228 @@ 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 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";
+var MAX_STORED_CONVERSATIONS = 40;
+var MAX_MODEL_HISTORY = 80;
+function createConversationRecord(input2) {
+  const timestamp = input2.now ?? Date.now();
+  return {
+    id: sanitizeConversationId(input2.id),
+    title: input2.title?.trim() || "New session",
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    cwd: path33.resolve(input2.cwd),
+    modelHistory: cleanModelHistory(input2.history ?? []),
+    snapshot: input2.snapshot
+  };
+}
+async function loadConversationIndex(storageDir = defaultDemianStorageDir()) {
+  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;
+    const id = typeof object2.id === "string" ? sanitizeConversationId(object2.id) : "";
+    if (!id) return void 0;
+    return {
+      id,
+      title: typeof object2.title === "string" && object2.title.trim() ? object2.title.trim() : "New session",
+      updatedAt: numberOrNow(object2.updatedAt),
+      cwd: typeof object2.cwd === "string" ? object2.cwd : void 0
+    };
+  }).filter((item) => Boolean(item)) : [];
+  return {
+    selectedSessionId: typeof index?.selectedSessionId === "string" ? sanitizeConversationId(index.selectedSessionId) : void 0,
+    conversations
+  };
+}
+async function loadConversationRecords(storageDir = defaultDemianStorageDir()) {
+  const index = await loadConversationIndex(storageDir);
+  const ids = new Set(index.conversations.map((item) => item.id));
+  for (const id of await listConversationRecordIds(storageDir)) ids.add(id);
+  const records = (await Promise.all(
+    [...ids].map(async (id) => {
+      const item = await readJson(conversationRecordPath(storageDir, id));
+      return normalizeConversationRecord(item, id);
+    })
+  )).filter((item) => Boolean(item));
+  records.sort((a, b2) => b2.updatedAt - a.updatedAt);
+  return { selectedSessionId: index.selectedSessionId, records };
+}
+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 mkdir15(path33.join(root, CONVERSATIONS_DIR), { recursive: true });
+  for (const record of kept) {
+    await writeJson(conversationRecordPath(root, record.id), {
+      version: 1,
+      id: record.id,
+      title: record.title,
+      createdAt: record.createdAt,
+      updatedAt: record.updatedAt,
+      cwd: record.cwd,
+      modelHistory: record.modelHistory,
+      snapshot: record.snapshot
+    });
+  }
+  await writeJson(path33.join(root, CONVERSATION_INDEX_FILE), {
+    version: 1,
+    selectedSessionId,
+    conversations: kept.map((record) => ({
+      id: record.id,
+      title: record.title,
+      updatedAt: record.updatedAt,
+      cwd: record.cwd,
+      path: conversationDir(root, record.id)
+    }))
+  });
+}
+async function deleteConversationRecord(storageDir, id) {
+  const root = storageDir ?? defaultDemianStorageDir();
+  await rm4(conversationDir(root, id), { recursive: true, force: true });
+}
+function findConversation(records, target) {
+  const value = target?.trim();
+  if (!value) return void 0;
+  const index = Number(value);
+  if (Number.isInteger(index) && index >= 1 && index <= records.length) return records[index - 1];
+  const normalized = value.toLowerCase();
+  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 = path33.resolve(cwd);
+  return [...records].sort((a, b2) => {
+    const aCurrent = isConversationForCwd(a, resolvedCwd) ? 0 : 1;
+    const bCurrent = isConversationForCwd(b2, resolvedCwd) ? 0 : 1;
+    if (aCurrent !== bCurrent) return aCurrent - bCurrent;
+    const statusDelta = conversationStatusRank(conversationRuntimeStatus(a, resolvedCwd)) - conversationStatusRank(conversationRuntimeStatus(b2, resolvedCwd));
+    if (statusDelta !== 0) return statusDelta;
+    return b2.updatedAt - a.updatedAt;
+  });
+}
+function conversationRuntimeStatus(record, cwd) {
+  if (record.snapshot?.inputMode === "running") return "running";
+  return isConversationForCwd(record, cwd) ? "ready" : "stored";
+}
+function isConversationForCwd(record, cwd) {
+  return path33.resolve(record.cwd) === path33.resolve(cwd);
+}
+function conversationSummaryLine(record, index, activeId) {
+  const active = record.id === activeId ? "*" : " ";
+  const age = formatRelativeAge(Date.now() - record.updatedAt);
+  return `${active} ${index + 1}. ${record.title}  ${record.id}  ${age}  ${record.cwd}`;
+}
+function conversationStatusRank(status) {
+  if (status === "running") return 0;
+  if (status === "ready") return 1;
+  return 2;
+}
+function titleFromHistory(history, fallback = "New session") {
+  const firstUser = history.find((message) => message.role === "user" && typeof message.content === "string");
+  return firstLine(firstUser?.content ?? fallback);
+}
+function cleanModelHistory(history) {
+  return history.filter((message) => !isInternalModelHistoryMessage(message)).slice(-MAX_MODEL_HISTORY);
+}
+function conversationDir(storageDir, id) {
+  return path33.join(storageDir, CONVERSATIONS_DIR, sanitizeConversationId(id));
+}
+function conversationRecordPath(storageDir, id) {
+  return path33.join(conversationDir(storageDir, id), CONVERSATION_FILE);
+}
+async function listConversationRecordIds(storageDir) {
+  try {
+    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 [];
+  }
+}
+async function readJson(filePath) {
+  try {
+    return JSON.parse(await readFile17(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function writeJson(filePath, value) {
+  await mkdir15(path33.dirname(filePath), { recursive: true });
+  await writeFile14(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+function normalizeConversationRecord(value, fallbackId) {
+  if (!value || typeof value !== "object") return void 0;
+  const object2 = value;
+  const id = sanitizeConversationId(typeof object2.id === "string" ? object2.id : fallbackId);
+  if (!id) return void 0;
+  const history = Array.isArray(object2.modelHistory) ? object2.modelHistory.filter(isMessage) : [];
+  const snapshot = object2.snapshot && typeof object2.snapshot === "object" && !Array.isArray(object2.snapshot) ? object2.snapshot : void 0;
+  return {
+    id,
+    title: typeof object2.title === "string" && object2.title.trim() ? object2.title.trim() : titleFromHistory(history),
+    createdAt: numberOrNow(object2.createdAt),
+    updatedAt: numberOrNow(object2.updatedAt),
+    cwd: typeof object2.cwd === "string" && object2.cwd.trim() ? object2.cwd : process.cwd(),
+    modelHistory: cleanModelHistory(history),
+    snapshot
+  };
+}
+function isMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const message = value;
+  if (message.role === "user") return typeof message.content === "string" || Array.isArray(message.content);
+  if (message.role === "assistant") return message.content === void 0 || message.content === null || typeof message.content === "string" || Array.isArray(message.toolCalls);
+  if (message.role === "tool") return typeof message.toolCallId === "string" && typeof message.name === "string" && typeof message.content === "string";
+  if (message.role === "system") return typeof message.content === "string";
+  return false;
+}
+function isInternalModelHistoryMessage(message) {
+  return message.role === "user" && typeof message.content === "string" && /^You are running as sub agent:/i.test(message.content.trim());
+}
+function sanitizeConversationId(id) {
+  return String(id || "conversation").replace(/[^a-zA-Z0-9._-]+/g, "_") || "conversation";
+}
+function numberOrNow(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : Date.now();
+}
+function firstLine(value) {
+  const line = value.replace(/\s+/g, " ").trim();
+  if (!line) return "New session";
+  return line.length > 60 ? `${line.slice(0, 57)}...` : line;
+}
+function formatRelativeAge(ms2) {
+  const seconds = Math.max(0, Math.floor(ms2 / 1e3));
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours}h ago`;
+  return `${Math.floor(hours / 24)}d ago`;
+}
+
 // src/ui/tui/controller.ts
 async function runTuiSession(flags, store2) {
-  const cwd = path32.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
     }
@@ -32503,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,
@@ -32511,10 +33536,21 @@ async function runTuiSession(flags, store2) {
     }
   });
   let nextPrompt = flags.prompt;
-  let history = flags.initialHistory ? [...flags.initialHistory] : [];
+  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;
+  const conversationRecords = conversationState?.records ?? /* @__PURE__ */ new Map();
+  const shouldShowStartupSessionSelector = conversationsEnabled && !flags.prompt.trim() && !flags.sessionId;
+  let history = flags.initialHistory ? [...flags.initialHistory] : currentConversation?.modelHistory ? [...currentConversation.modelHistory] : [];
   let lastExternalSessionKey;
-  const externalSessions = new ClaudeCodeSessionMap();
-  const rootSessionId = flags.sessionId ?? createRootSessionId();
+  let externalSessions = new ClaudeCodeSessionMap();
+  const runtimeByConversation = /* @__PURE__ */ new Map();
+  let rootSessionId = currentConversation?.id ?? flags.sessionId ?? createRootSessionId();
+  if (currentConversation && !shouldShowStartupSessionSelector) {
+    store2.restoreConversationSnapshot(currentConversation.snapshot, { sessionId: currentConversation.id, title: currentConversation.title, cwd: currentConversation.cwd });
+    runtimeByConversation.set(currentConversation.id, { externalSessions, lastExternalSessionKey });
+  }
   const goalTitleGenerator = async (input2) => {
     const selection = store2.currentSelection();
     const runtime = resolveProviderRuntimeConfig(config, selection);
@@ -32532,19 +33568,48 @@ async function runTuiSession(flags, store2) {
     if (resolved.kind === "external-agent") return input2.objective.trim().split(/\s+/).slice(0, 8).join(" ");
     return summarizeGoalTitleWithProvider({ ...input2, provider: resolved.provider, model: resolved.model });
   };
+  if (shouldShowStartupSessionSelector) {
+    const selected = await store2.requestSessionSelection(startupSessionOptions());
+    if (selected.kind === "exit" || store2.exitRequested()) {
+      await saveCurrentSelection();
+      return 0;
+    }
+    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);
+      continue;
+    }
     if (isCompactCommand(prompt)) {
       const result = compactInteractiveHistory(history, config.context.main);
       history = result.messages;
       store2.prepareForPrompt("waiting for next message");
       store2.markHistoryCompacted(result);
+      await persistCurrentConversation();
       continue;
     }
     const mode = resolveAgentMode(config, flags.mode);
@@ -32696,6 +33761,7 @@ async function runTuiSession(flags, store2) {
         history = interactiveHistoryFromRunMessages(result.messages);
         lastExternalSessionKey = externalSessionKey ?? lastExternalSessionKey;
       }
+      await persistCurrentConversation();
     } catch (error) {
       store2.setStopTask(void 0);
       if (activeAbort?.signal.aborted) {
@@ -32708,6 +33774,7 @@ async function runTuiSession(flags, store2) {
       store2.setStopTask(void 0);
     }
     if (store2.exitRequested()) {
+      await persistCurrentConversation();
       await saveCurrentSelection();
       return 0;
     }
@@ -32716,6 +33783,184 @@ async function runTuiSession(flags, store2) {
   async function saveCurrentSelection() {
     await saveSelection(store2.currentSelection());
   }
+  async function handleSessionCommand(command) {
+    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);
+    }
+    if (command.action === "help") {
+      store2.showSystemMessage("Sessions", sessionUsage());
+      store2.prepareForPrompt("waiting for next message");
+      return;
+    }
+    if (command.action === "list") {
+      store2.showSystemMessage("Sessions", sessionListMessage());
+      store2.prepareForPrompt("waiting for next message");
+      return;
+    }
+    if (command.action === "current") {
+      store2.showSystemMessage("Current Session", conversationSummaryLine(currentConversation, sortedConversations().findIndex((item) => item.id === currentConversation?.id), currentConversation.id));
+      store2.prepareForPrompt("waiting for next message");
+      return;
+    }
+    if (command.action === "new") {
+      await persistCurrentConversation();
+      const next = createConversationRecord({ id: createRootSessionId(), cwd, title: command.title });
+      conversationRecords.set(next.id, next);
+      await switchConversation(next);
+      store2.prepareForPrompt(`new session: ${next.title}`);
+      await persistCurrentConversation();
+      return;
+    }
+    if (command.action === "switch") {
+      const target = findConversation(sortedConversations(), command.target);
+      if (!target) {
+        store2.showSystemMessage("Sessions", `No session matched "${command.target ?? ""}".
+
+${sessionListMessage()}`);
+        store2.prepareForPrompt("waiting for next message");
+        return;
+      }
+      await persistCurrentConversation();
+      await switchConversation(target);
+      store2.prepareForPrompt(`switched session: ${target.title}`);
+      await persistCurrentConversation();
+      return;
+    }
+    if (command.action === "delete") {
+      const target = findConversation(sortedConversations(), command.target);
+      if (!target) {
+        store2.showSystemMessage("Sessions", `No session matched "${command.target ?? ""}".`);
+        store2.prepareForPrompt("waiting for next message");
+        return;
+      }
+      conversationRecords.delete(target.id);
+      runtimeByConversation.delete(target.id);
+      await deleteConversationRecord(flags.conversationStorageDir, target.id);
+      if (currentConversation?.id === target.id) {
+        const next = sortedConversations()[0] ?? createConversationRecord({ id: createRootSessionId(), cwd });
+        conversationRecords.set(next.id, next);
+        await switchConversation(next);
+      }
+      store2.prepareForPrompt(`deleted session: ${target.title}`);
+      await persistCurrentConversation();
+      return;
+    }
+    if (command.action === "rename") {
+      const title = command.title?.trim();
+      if (!title) {
+        store2.showSystemMessage("Sessions", "Usage: /session rename <title>");
+        store2.prepareForPrompt("waiting for next message");
+        return;
+      }
+      currentConversation.title = title;
+      currentConversation.updatedAt = Date.now();
+      store2.prepareForPrompt(`renamed session: ${title}`);
+      await persistCurrentConversation();
+      return;
+    }
+    if (command.action === "clear") {
+      history = [];
+      currentConversation.modelHistory = [];
+      currentConversation.snapshot = void 0;
+      currentConversation.title = "New session";
+      currentConversation.updatedAt = Date.now();
+      store2.clearConversation(currentConversation.title);
+      store2.prepareForPrompt("cleared current conversation");
+      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) => ({
+      kind: "session",
+      id: record.id,
+      title: record.title,
+      cwd: record.cwd,
+      status: conversationRuntimeStatus(record, cwd),
+      updatedAt: record.updatedAt,
+      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);
+      await switchConversation(next);
+      store2.prepareForPrompt("new session ready");
+      await saveConversationRecords(flags.conversationStorageDir, [...conversationRecords.values()], next.id);
+      return;
+    }
+    const target = conversationRecords.get(selection.id) ?? findConversation(sortedConversations(), selection.id);
+    if (!target) {
+      const next = createConversationRecord({ id: createRootSessionId(), cwd });
+      conversationRecords.set(next.id, next);
+      await switchConversation(next);
+      store2.prepareForPrompt("new session ready");
+      await saveConversationRecords(flags.conversationStorageDir, [...conversationRecords.values()], next.id);
+      return;
+    }
+    await switchConversation(target);
+    store2.prepareForPrompt(`session ready: ${target.title}`);
+    await saveConversationRecords(flags.conversationStorageDir, [...conversationRecords.values()], target.id);
+  }
+  async function switchConversation(record) {
+    currentConversation = record;
+    rootSessionId = record.id;
+    history = [...record.modelHistory];
+    const runtime = runtimeByConversation.get(record.id) ?? { externalSessions: new ClaudeCodeSessionMap(), lastExternalSessionKey: void 0 };
+    externalSessions = runtime.externalSessions;
+    lastExternalSessionKey = runtime.lastExternalSessionKey;
+    runtimeByConversation.set(record.id, runtime);
+    store2.restoreConversationSnapshot(record.snapshot, { sessionId: record.id, title: record.title, cwd: record.cwd || cwd });
+  }
+  async function persistCurrentConversation() {
+    if (!conversationsEnabled || !currentConversation) return;
+    currentConversation.modelHistory = cleanModelHistory(history);
+    if (currentConversation.title === "New session" && currentConversation.modelHistory.length > 0) currentConversation.title = titleFromHistory(currentConversation.modelHistory);
+    currentConversation.snapshot = store2.conversationSnapshot();
+    currentConversation.updatedAt = Date.now();
+    conversationRecords.set(currentConversation.id, currentConversation);
+    runtimeByConversation.set(currentConversation.id, { externalSessions, lastExternalSessionKey });
+    await saveConversationRecords(flags.conversationStorageDir, [...conversationRecords.values()], currentConversation.id);
+  }
+  function sortedConversations() {
+    return sortConversationRecords([...conversationRecords.values()], cwd);
+  }
+  function sessionListMessage() {
+    const records = sortedConversations();
+    if (!records.length) return "No saved sessions.";
+    return ["Saved sessions:", ...records.map((record, index) => conversationSummaryLine(record, index, currentConversation?.id)), "", "Use /session switch <number|id|title> to open one."].join("\n");
+  }
   async function saveSelection(selection) {
     if (!shouldPersistSelection(selection)) return;
     const key = preferenceKey(selection);
@@ -32723,298 +33968,124 @@ async function runTuiSession(flags, store2) {
     await preferenceStore.save(selection);
     savedSelectionKey = key;
   }
-}
-function isGoalStateClearingAction(action) {
-  return action === "status" || action === "pause" || action === "resume";
-}
-
-// src/config-watcher.ts
-import { EventEmitter } from "node:events";
-import fs11 from "node:fs";
-import path34 from "node:path";
-
-// src/config-scaffold.ts
-import { chmod as chmod3, mkdir as mkdir14, readFile as readFile16, rename as rename6, stat as stat8, writeFile as writeFile13 } from "node:fs/promises";
-import os13 from "node:os";
-import path33 from "node:path";
-function defaultUserConfigPath() {
-  return path33.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 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 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 readFile16(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 readFile16(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` }
-    };
+  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);
   }
-  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 mkdir14(path33.dirname(filePath), { recursive: true, mode: 448 });
-  const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile13(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";
+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 objectValue(value) {
-  return value && typeof value === "object" && !Array.isArray(value) ? { ...value } : {};
+function configMutationPath(flags) {
+  return flags.configPath ? path34.resolve(flags.configPath) : defaultUserConfigPath();
 }
-function normalizeOptionalName(value) {
-  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+function isGoalStateClearingAction(action) {
+  return action === "status" || action === "pause" || action === "resume";
 }
-async function exists(filePath) {
-  try {
-    await stat8(filePath);
-    return true;
-  } catch {
-    return false;
-  }
+async function initializeConversationState(cwd, flags) {
+  const loaded = await loadConversationRecords(flags.conversationStorageDir);
+  const records = new Map(loaded.records.map((record) => [record.id, record]));
+  const shouldResumeSelected = !flags.prompt.trim();
+  const orderedRecords = sortConversationRecords([...records.values()], cwd);
+  const preferred = (flags.sessionId ? findConversation(orderedRecords, flags.sessionId) : void 0) ?? (shouldResumeSelected && loaded.selectedSessionId ? findConversation(orderedRecords, loaded.selectedSessionId) : void 0) ?? (shouldResumeSelected ? orderedRecords[0] : void 0);
+  const current = preferred ?? (flags.prompt.trim() || flags.sessionId || flags.initialHistory?.length ? createConversationRecord({
+    id: flags.sessionId ?? createRootSessionId(),
+    cwd,
+    history: flags.initialHistory
+  }) : void 0);
+  if (current && flags.initialHistory?.length) current.modelHistory = cleanModelHistory(flags.initialHistory);
+  if (current) records.set(current.id, current);
+  return { records, current };
 }
-function expandHome2(value) {
-  return resolveExpandedPath(value);
+function sessionUsage() {
+  return [
+    "Usage:",
+    "  /session list",
+    "  /session new [title]",
+    "  /session switch <number|id|title>",
+    "  /session rename <title>",
+    "  /session delete <number|id|title>",
+    "  /session clear",
+    "",
+    "Aliases: /sessions, /conversation, /conversations, /conv"
+  ].join("\n");
 }
 
 // src/config-watcher.ts
+import { EventEmitter } from "node:events";
+import fs11 from "node:fs";
+import path35 from "node:path";
 var ConfigWatcher = class extends EventEmitter {
   #filePath;
   #debounceMs;
@@ -33036,9 +34107,9 @@ var ConfigWatcher = class extends EventEmitter {
     this.#started = true;
     this.#lastSeen = this.#snapshot();
     try {
-      fs11.mkdirSync(path34.dirname(this.#filePath), { recursive: true, mode: 448 });
-      this.#watcher = fs11.watch(path34.dirname(this.#filePath), { persistent: false }, (_eventType, filename) => {
-        if (filename && filename !== path34.basename(this.#filePath)) return;
+      fs11.mkdirSync(path35.dirname(this.#filePath), { recursive: true, mode: 448 });
+      this.#watcher = fs11.watch(path35.dirname(this.#filePath), { persistent: false }, (_eventType, filename) => {
+        if (filename && filename !== path35.basename(this.#filePath)) return;
         this.#schedule();
       });
       this.#watcher.on("error", () => void 0);
@@ -33103,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(
@@ -33160,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) => {
@@ -33306,14 +34419,14 @@ async function undoDiffAction(actionId) {
   if (!action) throw new Error("No diff action is available to undo.");
   if (!canUndoDiffAction(diffState, action.id)) throw new Error("Only the latest change for a file can be undone.");
   if (!hasBeforeSnapshot(action)) throw new Error("This diff was not recorded with enough content to undo safely.");
-  const target = path35.resolve(options.cwd, action.path);
-  const relative = path35.relative(options.cwd, target);
-  if (relative.startsWith("..") || path35.isAbsolute(relative)) throw new Error("Refusing to undo a file outside the workspace.");
+  const target = path36.resolve(options.cwd, action.path);
+  const relative = path36.relative(options.cwd, target);
+  if (relative.startsWith("..") || path36.isAbsolute(relative)) throw new Error("Refusing to undo a file outside the workspace.");
   if (!action.beforeExists) {
-    await rm4(target, { force: true });
+    await rm5(target, { force: true });
   } else {
-    await mkdir15(path35.dirname(target), { recursive: true });
-    await writeFile14(target, action.beforeContent ?? "", "utf8");
+    await mkdir16(path36.dirname(target), { recursive: true });
+    await writeFile15(target, action.beforeContent ?? "", "utf8");
   }
   markDiffActionUndone(action.id);
   send({ type: "diffUndoCompleted", actionId: action.id, path: action.path });
@@ -33734,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) => ({
@@ -33790,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 },
@@ -33799,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;
 }
@@ -33808,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 = {};