@xingjisoft/neutrino 0.4.0 → 0.5.0

package/web/app.js

@@ -147,6 +147,7 @@ function showGate(message = "") {
   closeStream();
   setStatus("locked", "offline");
   document.getElementById("settings-dialog").close();
+  document.getElementById("background-dialog")?.close?.();
 
   // A modal dialog stays above streaming repaints and traps keyboard focus.
   const gate = document.createElement("dialog");
@@ -184,6 +185,159 @@ function showGate(message = "") {
   gate.showModal();
 }
 
+// -------------------------------------------------------- background invite
+//
+// Accepting changes the running console's lifetime immediately, including
+// conversations already in flight. A resident console never offers the prompt.
+
+let backgroundPromptAnswered = false;
+
+function showBackgroundPrompt() {
+  if (backgroundPromptAnswered || !el.backgroundDialog?.showModal) return;
+  if (el.backgroundDialog.open) return;
+  if (el.backgroundFeedback) {
+    el.backgroundFeedback.textContent = "";
+    el.backgroundFeedback.classList.remove("error");
+  }
+  try {
+    el.backgroundDialog.showModal();
+  } catch {
+    // An embedder without dialog support still gets the setting in Settings.
+  }
+}
+
+function maybePromptBackground(config) {
+  if (!config?.settings?.background_prompt) return;
+  if (config.settings.background === true) return;
+  showBackgroundPrompt();
+}
+
+async function answerBackgroundPrompt(enable) {
+  if (backgroundPromptAnswered) return;
+  backgroundPromptAnswered = true;
+  const feedback = el.backgroundFeedback;
+  const cancel = el.backgroundCancel;
+  const confirm = el.backgroundEnable;
+  if (cancel) cancel.disabled = true;
+  if (confirm) confirm.disabled = true;
+  if (feedback) {
+    feedback.textContent = "";
+    feedback.classList.remove("error");
+  }
+  try {
+    if (enable) {
+      const response = await apiFetch("/api/settings", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ settings: { background: true } }),
+      });
+      const body = await response.json();
+      if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+      if (body.settings?.background_running !== true) {
+        throw new Error(tr("Background residency could not be applied. Restart the console and try again."));
+      }
+      try { await preferences.load(); } catch { /* Residency is already active. */ }
+    } else {
+      // Consume the invitation for this CLI run. A failed dismissal is
+      // harmless: the prompt simply returns on the next page load.
+      try {
+        await apiFetch("/api/background/dismiss", { method: "POST" });
+      } catch { /* Keep the close local. */ }
+    }
+    el.backgroundDialog?.close?.();
+  } catch (error) {
+    backgroundPromptAnswered = false;
+    if (feedback) {
+      feedback.textContent = tr(error.message);
+      feedback.classList.add("error");
+    }
+  } finally {
+    if (cancel) cancel.disabled = false;
+    if (confirm) confirm.disabled = false;
+  }
+}
+
+// ------------------------------------------------------------- update notice
+//
+// The server compares the version it runs with the one npm publishes, and both
+// workspaces read that from the settings payload: a Pro tab announces a new
+// release exactly like the regular console. Confirming installs it on this
+// machine; the running process keeps the old code either way, so a successful
+// update ends by telling the user to restart.
+//
+// Two dialogs never open at once: when an update is offered, the background
+// invitation waits for the next page load (it is not consumed by being skipped).
+
+let updatePrompted = false;
+
+function maybePromptUpdate(config) {
+  const update = config?.update;
+  if (updatePrompted || !update?.has_update) return false;
+  if (!el.updateDialog || typeof el.updateDialog.showModal !== "function") return false;
+  updatePrompted = true;
+  if (el.updateVersions) {
+    el.updateVersions.textContent = tr("Running {current} · published {latest}", {
+      current: update.current_version, latest: update.latest_version,
+    });
+  }
+  if (el.updateFeedback) {
+    el.updateFeedback.textContent = "";
+    el.updateFeedback.classList.remove("error");
+  }
+  el.updateCommandBlock?.classList.add("hidden");
+  el.updateLater?.classList.remove("hidden");
+  el.updateNow?.classList.remove("hidden");
+  for (const button of [el.updateLater, el.updateNow, el.updateClose]) {
+    if (button) button.disabled = false;
+  }
+  if (el.updateNow) el.updateNow.textContent = tr("Update now");
+  try {
+    if (!el.updateDialog.open) el.updateDialog.showModal();
+  } catch {
+    return false; // An embedder without modal support still gets the console.
+  }
+  return true;
+}
+
+/** Run npm through the console's own server and report what happened. */
+async function runUpdate() {
+  if (!el.updateNow || el.updateNow.disabled) return;
+  const buttons = [el.updateNow, el.updateLater, el.updateClose].filter(Boolean);
+  for (const button of buttons) button.disabled = true;
+  const feedback = el.updateFeedback;
+  if (feedback) {
+    feedback.textContent = tr("Updating with npm…");
+    feedback.classList.remove("error");
+  }
+  let body = {};
+  try {
+    const response = await apiFetch("/api/update", { method: "POST" });
+    body = await response.json().catch(() => ({}));
+    if (!response.ok || body.ok !== true) throw new Error(body.error || `HTTP ${response.status}`);
+    if (feedback) {
+      feedback.textContent = tr("Updated to {version}. Restart Neutrino to use it.", { version: body.version || "" });
+      feedback.classList.remove("error");
+    }
+    el.updateCommandBlock?.classList.add("hidden");
+    // The install is done: the only thing left is to close the notice.
+    el.updateLater?.classList.add("hidden");
+    el.updateNow?.classList.add("hidden");
+  } catch (error) {
+    if (feedback) {
+      feedback.textContent = tr("Update failed: {error}", { error: error.message });
+      feedback.classList.add("error");
+    }
+    // npm failures are usually something the user has to fix, so the dialog
+    // keeps the command that finishes the job by hand.
+    if (el.updateCommand && typeof body?.command === "string" && body.command) {
+      el.updateCommand.textContent = body.command;
+    }
+    el.updateCommandBlock?.classList.remove("hidden");
+  } finally {
+    for (const button of buttons) button.disabled = false;
+  }
+}
+
 const el = {
   app: document.getElementById("app"),
   back: document.getElementById("back-to-menu"),
@@ -195,6 +349,7 @@ const el = {
   proTip: document.getElementById("pro-tip"),
   proTipClose: document.getElementById("pro-tip-close"),
   proExit: document.getElementById("pro-exit"),
+  header: document.getElementById("main-header"),
   title: document.getElementById("session-title"),
   sub: document.getElementById("session-sub"),
   controls: document.getElementById("controls"),
@@ -252,8 +407,47 @@ const el = {
   agentsList: document.getElementById("agents-list"),
   agentsFeedback: document.getElementById("agents-feedback"),
   agentsCwd: document.getElementById("agents-cwd"),
+  agentActions: document.getElementById("agent-actions"),
+  agentMigrate: document.getElementById("agent-migrate"),
+  agentMigrateFeedback: document.getElementById("agent-migrate-feedback"),
+  backgroundDialog: document.getElementById("background-dialog"),
+  backgroundFeedback: document.getElementById("background-feedback"),
+  backgroundCancel: document.getElementById("background-cancel"),
+  backgroundEnable: document.getElementById("background-enable"),
+  updateDialog: document.getElementById("update-dialog"),
+  updateVersions: document.getElementById("update-versions"),
+  updateCommandBlock: document.getElementById("update-command-block"),
+  updateCommand: document.getElementById("update-command"),
+  updateFeedback: document.getElementById("update-feedback"),
+  updateClose: document.getElementById("update-close"),
+  updateLater: document.getElementById("update-later"),
+  updateNow: document.getElementById("update-now"),
 };
 
+if (el.backgroundCancel) {
+  el.backgroundCancel.addEventListener("click", () => { void answerBackgroundPrompt(false); });
+}
+if (el.backgroundEnable) {
+  el.backgroundEnable.addEventListener("click", () => { void answerBackgroundPrompt(true); });
+}
+if (el.backgroundDialog) {
+  el.backgroundDialog.addEventListener("cancel", (event) => {
+    event.preventDefault();
+    void answerBackgroundPrompt(false);
+  });
+}
+
+if (el.updateNow) el.updateNow.addEventListener("click", () => { void runUpdate(); });
+if (el.updateLater) el.updateLater.addEventListener("click", () => el.updateDialog?.close?.());
+if (el.updateClose) el.updateClose.addEventListener("click", () => el.updateDialog?.close?.());
+if (el.updateDialog) {
+  // Esc closes it like "Later": the notice is an offer, never a gate.
+  el.updateDialog.addEventListener("cancel", (event) => {
+    event.preventDefault();
+    el.updateDialog.close();
+  });
+}
+
 const state = {
   overview: null,
   // { kind: "live", key } | { kind: "file", id } | { kind: "new", cwd } |
@@ -272,6 +466,7 @@ const state = {
   fileData: null,
   // Last loaded read-only transcript from another agent.
   agentData: null,
+  agentMigration: null,
   // { key, path } | null — the working directory the sidebar is scoped to.
   workspace: storedWorkspace(),
   // Plan / usage card visibility and the plan it was opened for.
@@ -283,6 +478,9 @@ const state = {
   workspaces: null,
   // Translation key and colour class of the sidebar status line.
   status: { key: "connecting…", kind: "" },
+  // { identity: 1 } of finished conversations the reader has already opened,
+  // restored from the server before the first sidebar paint (see loadSeen).
+  seen: {},
 };
 
 function storedWorkspace() {
@@ -414,6 +612,11 @@ function announce(previous, next) {
   else if (previous.busy && !next.busy && !next.approval) chime("turn");
 }
 
+/** Whether a live conversation has anything to show (and so belongs in the list). */
+function liveHasContent(snapshot) {
+  return Boolean(snapshot.messages?.length || snapshot.streamingContent);
+}
+
 // ------------------------------------------------------------------ helpers
 
 function escapeHtml(value) {
@@ -650,6 +853,154 @@ function isSelected(session) {
   return !session.liveKey && session.id === selection.id;
 }
 
+// --------------------------------------------------- the "already seen" record
+//
+// A blue dot means "this conversation finished and you have not looked at it
+// since". Opening a row records that, so the dot is not a permanent decoration;
+// new activity forgets the record again, so the next finished turn gets a mark
+// of its own. The record survives a reload and a restart of the console: a
+// conversation the reader has already read must not keep asking.
+
+/**
+ * Identity of a row in the record. A conversation keeps its id while it becomes
+ * live, so the id is the stable name; a conversation with no history yet has
+ * only its live key.
+ */
+function sessionIdentity(session) {
+  if (session.id) return `id:${session.id}`;
+  return session.liveKey ? `live:${session.liveKey}` : "";
+}
+
+// Key of the record an older console kept in localStorage. It is only read once
+// now, to hand that history over to the server.
+const SEEN_KEY = "neutrino.seen";
+
+/**
+ * Turn the server's list into the lookup the renderer uses.
+ *
+ * The record lives in ~/.neutrino/web.json (src/web/clientState.ts): one file
+ * the console owns, so the terminal UI never carries data it does not read and
+ * the answer survives a restart. localStorage could not do that — it is scoped
+ * to the address and port the console happened to listen on.
+ */
+function seenMap(list) {
+  const out = {};
+  if (Array.isArray(list)) {
+    for (const identity of list) {
+      if (typeof identity === "string" && identity) out[identity] = 1;
+    }
+  }
+  return out;
+}
+
+/** Report a change. A write that fails costs one dot, so it is never surfaced. */
+async function persistSeen(identities, seen) {
+  if (!identities.length) return true;
+  try {
+    const response = await apiFetch("/api/seen", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ identities, seen }),
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+/** The record left in localStorage by an older console, if any. */
+function legacySeen() {
+  try {
+    const stored = JSON.parse(readStorage(modeStorageKey(SEEN_KEY)) || "{}");
+    return stored && typeof stored === "object" && !Array.isArray(stored) ? stored : {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Load the record before the first sidebar paint, so a reload never starts by
+ * marking every finished conversation again. The localStorage record of an
+ * older console is handed over once, and dropped as soon as the server has it.
+ */
+async function loadSeen() {
+  let stored;
+  try {
+    const response = await apiFetch("/api/seen", { cache: "no-store" });
+    if (!response.ok) throw new Error(`HTTP ${response.status}`);
+    stored = seenMap((await response.json())?.seen);
+  } catch {
+    // Without a record every finished conversation shows its dot again, which
+    // is a readable page rather than a broken one.
+    return;
+  }
+  state.seen = stored;
+  const identities = Object.keys(legacySeen());
+  if (!identities.length) return;
+  const missing = identities.filter((identity) => !stored[identity]);
+  for (const identity of missing) state.seen[identity] = 1;
+  if (await persistSeen(missing, true)) writeStorage(modeStorageKey(SEEN_KEY), "");
+}
+
+function isSeen(identity) {
+  return Boolean(identity) && Boolean(state.seen[identity]);
+}
+
+/** The reader opened this row. */
+function rememberSeen(identity) {
+  if (!identity || state.seen[identity]) return;
+  state.seen[identity] = 1;
+  // The dot is already gone from the page; the write only has to reach the disk.
+  void persistSeen([identity], true);
+}
+
+/** New activity: the turn that comes next deserves a mark of its own. */
+function forgetSeen(identity) {
+  if (!identity || !state.seen[identity]) return;
+  delete state.seen[identity];
+  void persistSeen([identity], false);
+}
+
+/**
+ * Status of a live conversation: a tool call waiting for the user's decision, a
+ * turn in flight, or nothing left to run. An automated review answers for the
+ * user, so only manual approval leaves a conversation waiting on a human.
+ */
+function statusOfLive(live) {
+  if (!live) return "done";
+  if (live.approval && (live.approvalMode ?? "request") === "request") return "approval";
+  return live.busy || live.paused || live.queued || live.compressing ? "running" : "done";
+}
+
+/** Status of a sidebar row; a saved transcript has finished by definition. */
+function sessionStatus(session) {
+  if (!session.liveKey) return "done";
+  // The open stream is newer than the last overview poll.
+  const snapshot = state.snapshot;
+  if (snapshot && snapshot.key === session.liveKey) return statusOfLive(snapshot);
+  return statusOfLive((state.overview?.live ?? []).find((entry) => entry.key === session.liveKey));
+}
+
+/**
+ * The status mark of a row: blue dot when done, ring when running, amber when
+ * waiting. The blue dot asks for attention once — opening the conversation takes
+ * it away. Running and waiting are live states, so they are always drawn, and
+ * seeing one clears the record for the turn that follows.
+ */
+function sessionStatusMark(session) {
+  const status = sessionStatus(session);
+  const identity = sessionIdentity(session);
+  if (status === "done") {
+    if (isSeen(identity)) return "";
+  } else {
+    forgetSeen(identity);
+  }
+  const label = status === "running"
+    ? tr("Running")
+    : status === "approval" ? tr("Waiting for approval") : tr("Done");
+  return `<span class="session-state ${status}" title="${escapeHtml(label)}"></span>`;
+}
+
 function renderSession(session) {
   const item = document.createElement("button");
   item.className = "session";
@@ -661,15 +1012,16 @@ function renderSession(session) {
   item.title = title;
   item.innerHTML =
     `<div class="session-top"><span class="session-title">${escapeHtml(title)}</span>` +
-    `${session.live ? `<span class="dot" title="${escapeHtml(tr("Live"))}"></span>` : ""}</div>` +
+    `${sessionStatusMark(session)}</div>` +
     `<div class="session-meta"><span class="model">${escapeHtml(session.model || "?")}</span>` +
     `<span class="time">${escapeHtml(formatTime(session.updated_at))}</span>` +
     `<span class="count">${escapeHtml(count === 1 ? tr("{n} message", { n: count }) : tr("{n} messages", { n: count }))}</span></div>`;
 
   item.addEventListener("click", () => {
+    if (!session.liveKey && !session.id) return;
+    rememberSeen(sessionIdentity(session));
     if (session.liveKey) selectLive(session.liveKey);
-    else if (session.id) selectFile(session.id);
-    else return;
+    else selectFile(session.id);
     setConversationView(true);
   });
   return item;
@@ -679,13 +1031,99 @@ function renderSession(session) {
 
 // Only explicit navigation changes the mobile pane. Background refreshes and
 // live-to-saved transitions must not take the user away from the menu.
-function setConversationView(open) {
+//
+// On a phone the two panes share one screen, so the browser's own Back button
+// has to walk the same levels as the back arrow in the header: from an open
+// conversation to the list, and Forward back into that conversation. Each
+// explicit navigation records one marked entry, and the entries beneath it are
+// the list.
+const CONVERSATION_ENTRY = "conversation";
+
+function isConversationEntry(entry) {
+  return Boolean(entry) && entry.neutrinoView === CONVERSATION_ENTRY;
+}
+
+/** The narrow layout that swaps the panes; wider screens show both at once. */
+function stackedPanes() {
+  try {
+    return typeof window !== "undefined" && typeof window.matchMedia === "function"
+      && window.matchMedia("(max-width: 760px)").matches;
+  } catch {
+    return false;
+  }
+}
+
+/** Record the open conversation as a level the browser can return from. */
+function pushConversationEntry() {
+  try {
+    // Forward restored this entry already; recording it twice would take two
+    // presses to leave the conversation.
+    if (isConversationEntry(history.state)) return;
+    history.pushState({ neutrinoView: CONVERSATION_ENTRY }, "", location.href);
+  } catch {
+    // Without history the header's back arrow still closes the pane.
+  }
+}
+
+/** The list is the entry beneath an open conversation: step back onto it. */
+function stepBackToList() {
+  try {
+    if (isConversationEntry(history.state)) history.back();
+  } catch {
+    // Without history the header's back arrow still closes the pane.
+  }
+}
+
+function setConversationView(open, { record = true } = {}) {
+  const wasOpen = el.app.classList.contains("conversation-open");
   el.app.classList.toggle("conversation-open", open);
-  if (!window.matchMedia("(max-width: 760px)").matches) return;
+  const stacked = stackedPanes();
+  // A click records one level; Back and Forward already moved the browser.
+  if (record && stacked && open !== wasOpen) {
+    if (open) pushConversationEntry();
+    else stepBackToList();
+  }
+  if (!stacked) return;
   if (open) el.back.focus();
   else (el.sessions.querySelector(".session.selected") || el.refresh).focus();
 }
 
+/** Back and Forward: show the level the browser landed on, without recording it. */
+function followViewHistory(event) {
+  setConversationView(isConversationEntry(event?.state), { record: false });
+}
+
+/**
+ * A reload starts on the list, but the browser is still on the entry that
+ * recorded a conversation. Forget the mark, so the first Back press tells the
+ * truth instead of leaving a screen that never looked like a conversation.
+ */
+function forgetStaleConversationEntry() {
+  try {
+    if (!isConversationEntry(history.state)) return;
+    history.replaceState(null, "", location.href);
+  } catch {
+    // No history in this embedder: there is nothing to correct.
+  }
+}
+
+/**
+ * Rotating a phone crosses the width that swaps the panes. A conversation
+ * opened while both panes were shown never recorded a level, so record it on
+ * the way into the single-pane layout: otherwise Back would leave the console
+ * from a screen that shows nothing but a conversation.
+ */
+function watchPanes() {
+  const query = typeof window !== "undefined" && typeof window.matchMedia === "function"
+    ? window.matchMedia("(max-width: 760px)")
+    : null;
+  if (!query || typeof query.addEventListener !== "function") return;
+  query.addEventListener("change", (event) => {
+    if (!event?.matches) return;
+    if (el.app.classList.contains("conversation-open")) pushConversationEntry();
+  });
+}
+
 function resetMessagePane(text) {
   el.messages.innerHTML = "";
   const empty = document.createElement("div");
@@ -737,6 +1175,16 @@ function openStream(key) {
     announce(previous, snapshot);
     setStatus("live", "live");
     renderLive();
+    // A turn that finishes in the conversation on screen needs no blue dot:
+    // recording it before the repaint keeps the mark off as the turn ends.
+    if (snapshot.sessionId && statusOfLive(snapshot) === "done") rememberSeen(`id:${snapshot.sessionId}`);
+    // The sidebar mirrors the open conversation, so a turn that starts, waits
+    // for approval or finishes shows there instead of on the next poll.
+    if (statusOfLive(previous) !== statusOfLive(snapshot)) renderSidebar();
+    // A conversation stays out of the sidebar until it has content; the first
+    // message makes it history, so list it now instead of on the next poll.
+    const started = previous && !liveHasContent(previous) && liveHasContent(snapshot);
+    if (started) loadOverview({ silent: true });
   });
 
   source.addEventListener("gone", () => {
@@ -746,12 +1194,14 @@ function openStream(key) {
 
   source.onopen = () => setStatus("live", "live");
   source.onerror = () => {
-    // EventSource retries automatically; just surface the state.
+    // EventSource retries automatically; wait for a fresh snapshot to flash.
+    el.header?.classList.remove("is-thinking");
     setStatus("reconnecting…", "offline");
   };
 }
 
 function closeStream() {
+  el.header?.classList.remove("is-thinking");
   if (state.eventSource) {
     state.eventSource.close();
     state.eventSource = null;
@@ -865,17 +1315,37 @@ async function continueSession(id, selection = preferences.selectionForFile(id))
 
 function setComposerMode(mode) {
   state.composerMode = mode;
+  el.agentActions.classList.add("hidden");
   el.composer.classList.remove("hidden");
   el.input.placeholder = mode === "resume"
     ? tr("Continue this conversation…")
     : mode === "new"
       ? tr("Message Neutrino in this folder…")
       : tr("Message Neutrino…");
+  renderComposerAction();
+}
+
+function canPauseFromComposer() {
+  const selection = state.selection;
+  const snapshot = state.snapshot;
+  return Boolean(selection?.kind === "live" && snapshot?.key === selection.key
+    && snapshot.busy && !snapshot.paused && !el.input.value.trim());
+}
+
+function renderComposerAction() {
+  const pause = canPauseFromComposer();
+  const label = pause ? "Pause" : "Send message";
+  el.send.classList.toggle("is-pause", pause);
+  el.send.setAttribute("data-i18n-title", label);
+  el.send.setAttribute("data-i18n-aria-label", label);
+  el.send.title = tr(label);
+  el.send.setAttribute("aria-label", tr(label));
 }
 
 function hideComposer() {
   preferences.clear();
   el.composer.classList.add("hidden");
+  el.agentActions.classList.add("hidden");
   renderApproval(null);
 }
 
@@ -1027,6 +1497,8 @@ function decideApproval(approved) {
 function renderLive() {
   const snapshot = state.snapshot;
   if (!snapshot) return;
+  renderComposerAction();
+  el.header?.classList.toggle("is-thinking", Boolean(snapshot.busy && !snapshot.paused && !snapshot.approval));
   state.fileData = null;
   state.agentData = null;
   el.title.textContent = snapshot.title || tr("New conversation");
@@ -1393,15 +1865,21 @@ async function postAction(key, action, body) {
   }
 }
 
+function activateComposer() {
+  if (canPauseFromComposer()) return postAction(state.selection.key, "pause");
+  return sendMessage();
+}
+
 async function sendMessage() {
   const selection = state.selection;
   if (!selection) return;
   const text = el.input.value;
   if (!text.trim()) return;
-  if (PRO_MODE) {
-    try { await proUI?.flush(); }
-    catch (error) { el.sub.textContent = error.message; return; }
-  }
+  try {
+    if (PRO_MODE) await proUI?.flush();
+    else await preferences.flush?.();
+  } catch (error) { el.sub.textContent = tr(error.message); return; }
+  if (state.selection !== selection) return;
 
   if (selection.kind === "live") {
     el.input.value = "";
@@ -1444,6 +1922,7 @@ async function sendMessage() {
 function autosize() {
   el.input.style.height = "auto";
   el.input.style.height = `${Math.min(el.input.scrollHeight, 220)}px`;
+  renderComposerAction();
 }
 
 // ------------------------------------------------------- workspaces & dialogs
@@ -1530,13 +2009,14 @@ function showHome({ menu = true } = {}) {
 
 /** Show a folder as an empty workspace ready for its first message. */
 function renderWorkspaceLanding(path) {
+  const sameLanding = state.selection?.kind === "new" && state.selection.cwd === path;
   state.selection = { kind: "new", cwd: path };
   state.snapshot = null;
   state.fileData = null;
   state.planOpen = false;
   state.planSeen = "";
   closeStream();
-  preferences.clear();
+  if (!sameLanding) preferences.clear();
   renderSidebar();
   renderWorkspaceChrome();
   el.controls.innerHTML = "";
@@ -1545,6 +2025,7 @@ function renderWorkspaceLanding(path) {
   el.title.textContent = workspaceName(path) || tr("Working directory");
   el.sub.textContent = path;
   setComposerMode("new");
+  preferences.showConversation({}, `new:${path}`);
   proUI?.show(null, `new:${path}`);
   el.messages.innerHTML = "";
 
@@ -2192,7 +2673,7 @@ function renderAgentList(groups) {
         "</span>";
       item.addEventListener("click", () => {
         el.agentsDialog.close();
-        void selectAgentSession(group.id, session.id, session.title || "");
+        void selectAgentSession(group.id, session.id, session.title || "", group.cwd);
       });
       section.appendChild(item);
     }
@@ -2211,7 +2692,7 @@ async function openAgentsDialog() {
       const response = await apiFetch(`/api/agents/${agent.id}/sessions?cwd=${encodeURIComponent(cwd)}`, { cache: "no-store" });
       const data = await response.json().catch(() => ({}));
       if (!response.ok) throw new Error(apiError(data, `HTTP ${response.status}`));
-      return { ...agent, sessions: Array.isArray(data.sessions) ? data.sessions : [] };
+      return { ...agent, cwd: data.cwd || cwd, sessions: Array.isArray(data.sessions) ? data.sessions : [] };
     }));
     el.agentsFeedback.textContent = "";
     renderAgentList(groups);
@@ -2238,11 +2719,53 @@ function renderAgentView(data) {
   renderApproval(null);
   renderPlanCard(null);
   hideComposer();
+  renderAgentMigration(data);
+}
+
+function renderAgentMigration(data) {
+  el.agentActions.classList.remove("hidden");
+  el.agentMigrate.disabled = Boolean(state.agentMigration) || !data.cwd || !data.messages?.length;
+  el.agentMigrate.textContent = state.agentMigration === state.selection ? tr("Migrating…") : tr("Migrate session");
+}
+
+async function migrateSelectedAgentSession() {
+  const selection = state.selection;
+  const source = state.agentData;
+  if (selection?.kind !== "agent" || !source?.cwd || !source.messages?.length || state.agentMigration) return;
+  state.agentMigration = selection;
+  el.agentMigrateFeedback.textContent = "";
+  renderAgentMigration(source);
+  try {
+    const payload = { cwd: source.cwd };
+    if (PRO_MODE) payload.pro_preset = currentProPreset();
+    const response = await apiFetch(`/api/agents/${encodeURIComponent(selection.agent)}/sessions/${encodeURIComponent(selection.id)}/migrate`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(payload),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(apiError(data, `HTTP ${response.status}`));
+    if (state.selection === selection) {
+      setWorkspace({ path: data.cwd });
+      await selectLive(data.key);
+      el.input.focus();
+    }
+    await loadOverview({ silent: true });
+  } catch (error) {
+    if (state.selection === selection) {
+      el.agentMigrateFeedback.textContent = tr("Could not migrate this session: {error}", { error: error.message });
+    }
+  } finally {
+    state.agentMigration = null;
+    if (state.selection?.kind === "agent" && state.agentData) renderAgentMigration(state.agentData);
+  }
 }
 
-async function selectAgentSession(agent, id, title) {
+async function selectAgentSession(agent, id, title, cwd) {
+  const scope = cwd || await agentsScopeCwd();
   closeStream();
-  state.selection = { kind: "agent", agent, id, title };
+  const selection = { kind: "agent", agent, id, title, cwd: scope };
+  state.selection = selection;
   state.snapshot = null;
   state.fileData = null;
   state.agentData = null;
@@ -2254,17 +2777,20 @@ async function selectAgentSession(agent, id, title) {
   renderApproval(null);
   renderPlanCard(null);
   hideComposer();
+  el.agentMigrateFeedback.textContent = "";
   el.title.textContent = tr("Loading…");
   el.sub.textContent = title || "";
   resetMessagePane(tr("Loading…"));
   setConversationView(true);
   try {
-    const response = await apiFetch(`/api/agents/${encodeURIComponent(agent)}/sessions/${encodeURIComponent(id)}`, { cache: "no-store" });
+    const response = await apiFetch(`/api/agents/${encodeURIComponent(agent)}/sessions/${encodeURIComponent(id)}?cwd=${encodeURIComponent(scope)}`, { cache: "no-store" });
     const data = await response.json().catch(() => ({}));
+    if (state.selection !== selection) return;
     if (!response.ok) throw new Error(apiError(data, `HTTP ${response.status}`));
-    state.agentData = { ...data, agent, cwd: state.agentData?.cwd || state.workspace?.path || "" };
+    state.agentData = { ...data, agent, cwd: data.cwd || scope };
     renderAgentView(state.agentData);
   } catch (error) {
+    if (state.selection !== selection) return;
     el.title.textContent = title || tr("Conversation");
     el.sub.textContent = tr("Could not load this session: {error}", { error: error.message });
     resetMessagePane(tr("Could not load this session: {error}", { error: error.message }));
@@ -2505,7 +3031,7 @@ function initializeProWorkspace() {
 
 el.refresh.addEventListener("click", () => loadOverview());
 el.back.addEventListener("click", () => setConversationView(false));
-el.send.addEventListener("click", sendMessage);
+el.send.addEventListener("click", activateComposer);
 el.input.addEventListener("input", autosize);
 el.input.addEventListener("keydown", (event) => {
   if (event.key === "Enter" && !event.shiftKey) {
@@ -2528,6 +3054,7 @@ el.workspaceAdd.addEventListener("click", () => {
   openFolderDialog({ start: state.workspace?.path || state.workspaces?.cwd || "", onPick: (path) => openWorkspace(path) });
 });
 el.agentsOpen.addEventListener("click", () => openAgentsDialog());
+el.agentMigrate.addEventListener("click", () => migrateSelectedAgentSession());
 el.agentsClose.addEventListener("click", () => el.agentsDialog.close());
 el.agentsDialog.addEventListener("cancel", (event) => {
   event.preventDefault();
@@ -2605,17 +3132,26 @@ el.folderDialog.addEventListener("cancel", (event) => {
 });
 
 window.addEventListener("beforeunload", closeStream);
+// On the phone layout the browser's Back and Forward buttons walk the same
+// levels as the header's back arrow: an open conversation returns to the list.
+window.addEventListener("popstate", followViewHistory);
+watchPanes();
+forgetStaleConversationEntry();
 
 initializeLanguage();
 initializeProWorkspace();
 preferences.load()
-  .then((config) => {
+  .then(async (config) => {
     const language = config?.settings?.language;
-    if (language && language !== uiLanguage()) return changeInterfaceLanguage(language, { persist: false });
-    return undefined;
+    if (language && language !== uiLanguage()) {
+      await changeInterfaceLanguage(language, { persist: false });
+    }
+    // Offer the update first, and only then the background invitation: two
+    // modal dialogs must never stack on top of each other.
+    if (!maybePromptUpdate(config)) maybePromptBackground(config);
   })
   .catch(error => console.error(error));
-loadOverview().then(() => {
+loadSeen().then(() => loadOverview()).then(() => {
   // Reopen the folder the user had open last time, without stealing a click
   // that landed on a saved conversation while the overview was loading.
   if (state.workspace && !state.selection) renderWorkspaceLanding(state.workspace.path);