demian-cli 1.0.9 → 1.1.1

package/dist/vscode-worker.mjs

@@ -1,8 +1,8 @@
 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 { 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 +67,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());
 }
@@ -748,6 +768,8 @@ var TuiStore = class {
     blocks: [],
     activity: "starting",
     inputMode: "starting",
+    sessionOptions: [],
+    sessionCursor: 0,
     providerOptions: [],
     providerCursor: 0,
     agentOptions: [],
@@ -769,6 +791,7 @@ var TuiStore = class {
   #blockId = 0;
   #stopActiveTask;
   #promptResolve;
+  #sessionResolve;
   #queuedPrompt;
   #exitRequested = false;
   #promptHistory = [];
@@ -789,6 +812,7 @@ var TuiStore = class {
       ...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 })),
       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) })),
@@ -827,6 +851,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;
@@ -850,7 +875,7 @@ var TuiStore = class {
   }
   markTaskFailed(message) {
     const lines = [message];
-    if (this.#lastRetryPrompt()) lines.push("Press ctrl+r or type /retry to run the last task again.");
+    if (this.#lastRetryPrompt()) lines.push("Press Esc then r or type /retry to run the last task again.");
     this.#append({ kind: "warning", title: "Task Failed", lines });
     this.#state.status.reason = "error";
     this.#state.inputMode = this.#exitRequested ? "done" : "prompt";
@@ -906,6 +931,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";
@@ -963,7 +1066,45 @@ var TuiStore = class {
   currentPermissionPreset() {
     return this.#state.permissionPreset;
   }
+  requestSessionSelection(options2) {
+    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.promptInput = "";
+      this.#state.promptError = void 0;
+      this.#state.streamingText = "";
+      this.#state.streamingFinalized = true;
+      this.#state.done = false;
+      this.#state.activity = "select session";
+      this.#notify();
+    });
+  }
+  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" });
+  }
   requestPrompt(initialPrompt) {
+    if (this.#exitRequested) return Promise.resolve("");
     const prompt = (initialPrompt ?? "").trim();
     if (prompt) {
       this.#rememberPrompt(prompt);
@@ -1004,12 +1145,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;
@@ -1164,19 +1305,19 @@ var TuiStore = class {
     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;
@@ -2004,9 +2145,24 @@ var TuiStore = class {
     resolve(prompt);
     this.#notify();
   }
+  #resolveSession(selection) {
+    const resolve = this.#sessionResolve;
+    if (!resolve) return;
+    this.#sessionResolve = void 0;
+    if (selection.kind === "exit") {
+      this.#state.inputMode = "done";
+      this.#state.done = true;
+      this.#state.activity = "exiting";
+    } 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 +2174,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 = "";
@@ -2309,6 +2479,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 +2527,7 @@ function buildClaudeCodePlanExecutionPrompt(planText, requestText) {
 }
 
 // src/ui/tui/controller.ts
-import path32 from "node:path";
+import path33 from "node:path";
 
 // src/agents/types.ts
 function normalizeAgent(input2) {
@@ -25421,8 +25621,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;
 }
 
@@ -30046,8 +30246,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) {
@@ -31646,17 +31846,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;
@@ -32477,9 +32677,212 @@ function errorMessage3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 
+// src/ui/conversations.ts
+import { mkdir as mkdir14, readFile as readFile16, readdir as readdir4, rm as rm4, writeFile as writeFile13 } from "node:fs/promises";
+import path32 from "node:path";
+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: path32.resolve(input2.cwd),
+    modelHistory: cleanModelHistory(input2.history ?? []),
+    snapshot: input2.snapshot
+  };
+}
+async function loadConversationIndex(storageDir = defaultDemianStorageDir()) {
+  const index = await readJson(path32.join(storageDir, CONVERSATION_INDEX_FILE));
+  const 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 mkdir14(path32.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(path32.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 = path32.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 path32.resolve(record.cwd) === path32.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 path32.join(storageDir, CONVERSATIONS_DIR, sanitizeConversationId(id));
+}
+function conversationRecordPath(storageDir, id) {
+  return path32.join(conversationDir(storageDir, id), CONVERSATION_FILE);
+}
+async function listConversationRecordIds(storageDir) {
+  try {
+    const entries = await readdir4(path32.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 readFile16(filePath, "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+async function writeJson(filePath, value) {
+  await mkdir14(path32.dirname(filePath), { recursive: true });
+  await writeFile13(filePath, `${JSON.stringify(value, null, 2)}
+`, "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 = path33.resolve(flags.cwd ?? process.cwd());
   const eventBus = new EventBus();
   eventBus.subscribe((event) => store2.handleEvent(event));
   const loadedConfig2 = await loadConfig({ cwd, configPath: flags.configPath });
@@ -32511,10 +32914,20 @@ async function runTuiSession(flags, store2) {
     }
   });
   let nextPrompt = flags.prompt;
-  let history = flags.initialHistory ? [...flags.initialHistory] : [];
+  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,6 +32945,14 @@ 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);
     nextPrompt = void 0;
@@ -32540,11 +32961,17 @@ async function runTuiSession(flags, store2) {
       return 0;
     }
     if (!prompt) return 0;
+    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 +33123,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 +33136,7 @@ async function runTuiSession(flags, store2) {
       store2.setStopTask(void 0);
     }
     if (store2.exitRequested()) {
+      await persistCurrentConversation();
       await saveCurrentSelection();
       return 0;
     }
@@ -32716,6 +33145,161 @@ 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();
+    }
+  }
+  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: path33.resolve(record.cwd) === cwd
+    }));
+    return [...sessionOptions, { kind: "new", title: "New session", cwd, status: "ready", currentWorkspace: true }];
+  }
+  async function applyStartupSessionSelection(selection) {
+    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);
@@ -32727,18 +33311,46 @@ async function runTuiSession(flags, store2) {
 function isGoalStateClearingAction(action) {
   return action === "status" || action === "pause" || action === "resume";
 }
+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 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 path34 from "node:path";
+import path35 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 { chmod as chmod3, mkdir as mkdir15, readFile as readFile17, rename as rename6, stat as stat8, writeFile as writeFile14 } from "node:fs/promises";
 import os13 from "node:os";
-import path33 from "node:path";
+import path34 from "node:path";
 function defaultUserConfigPath() {
-  return path33.join(os13.homedir(), ".demian", "config.json");
+  return path34.join(os13.homedir(), ".demian", "config.json");
 }
 function defaultUserConfig(defaultProvider = detectDefaultProvider()) {
   return {
@@ -32859,7 +33471,7 @@ async function createUserConfig(options2 = {}) {
 `;
   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 };
+  if (existed && !options2.force) return { path: filePath, created: false, content: await readFile17(filePath, "utf8"), existed: true };
   await writeJsonAtomic(filePath, content);
   return { path: filePath, created: true, content, existed };
 }
@@ -32922,7 +33534,7 @@ async function updateConfigDefaults(options2) {
 }
 async function readConfigObject(filePath) {
   if (!await exists(filePath)) await createUserConfig({ path: filePath });
-  const raw = JSON.parse(await readFile16(filePath, "utf8"));
+  const raw = JSON.parse(await readFile17(filePath, "utf8"));
   raw.version ??= 2;
   raw.providers = objectValue(raw.providers);
   return raw;
@@ -32983,9 +33595,9 @@ function apiKeyAuthFields(options2, defaultApiKeyEnv) {
   };
 }
 async function writeJsonAtomic(filePath, content) {
-  await mkdir14(path33.dirname(filePath), { recursive: true, mode: 448 });
+  await mkdir15(path34.dirname(filePath), { recursive: true, mode: 448 });
   const temp = `${filePath}.${process.pid}.${Date.now()}.tmp`;
-  await writeFile13(temp, content, { mode: 384 });
+  await writeFile14(temp, content, { mode: 384 });
   await rename6(temp, filePath);
   await chmod3(filePath, 384).catch(() => void 0);
 }
@@ -33036,9 +33648,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);
@@ -33180,6 +33792,7 @@ if (process.argv.includes("--config-path")) {
   process.exit(0);
 }
 var options = parseOptions();
+var SNAPSHOT_DEBOUNCE_MS = 80;
 var store = new TuiStore();
 var diffState = normalizeDiffState(options.initialSnapshot?.diff);
 var restoredSnapshot = normalizeInitialPublicState(options.initialSnapshot);
@@ -33305,14 +33918,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 });
@@ -33405,7 +34018,7 @@ function scheduleSnapshot() {
   snapshotTimer = setTimeout(() => {
     snapshotTimer = void 0;
     send({ type: "snapshot", state: publicState(store.snapshot()) });
-  }, 33);
+  }, SNAPSHOT_DEBOUNCE_MS);
 }
 function sendSnapshotNow() {
   if (snapshotTimer) {