@xingjisoft/neutrino 0.5.1 → 0.6.0

package/web/app.js

@@ -145,6 +145,7 @@ function showGate(message = "") {
   if (gateShown) return;
   gateShown = true;
   closeStream();
+  closeUpdateEvents();
   setStatus("locked", "offline");
   document.getElementById("settings-dialog").close();
   document.getElementById("background-dialog")?.close?.();
@@ -259,20 +260,57 @@ async function answerBackgroundPrompt(enable) {
 
 // ------------------------------------------------------------- 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.
+// The server compares the version it runs with the one npm publishes — at
+// start-up, every 30 minutes and on demand from Settings — and every answer
+// reaches the page through one announcement stream, so the notice shown when
+// the console opens and the corner badge cannot disagree about the release. A
+// Pro tab listens to the same stream under its own API prefix. 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).
+// Two dialogs never open at once: the background invitation is modal too, so a
+// release announced while it is up is offered once it is out of the way.
 
 let updatePrompted = false;
 
-function maybePromptUpdate(config) {
-  const update = config?.update;
-  if (updatePrompted || !update?.has_update) return false;
+// The release the page currently knows about. The notice and the corner badge
+// read this one value, so the reminder can never name a different version.
+let updateOffer = null;
+
+// The console's own announcement stream, and the release that arrived while the
+// background invitation was holding the screen.
+let updateSource = null;
+let pendingUpdate = null;
+
+/**
+ * Remember a release and light the corner badge. The announcement stream and a
+ * check started in Settings both report here.
+ */
+function noteUpdateAvailable(update) {
+  if (!update?.has_update) return false;
+  updateOffer = update;
+  if (el.updateBadge) {
+    const label = tr("A new version is available");
+    el.updateBadge.title = label;
+    el.updateBadge.setAttribute("aria-label", label);
+    el.updateBadge.classList.remove("hidden");
+  }
+  return true;
+}
+
+/** The release is installed or was never on offer: drop the reminder. */
+function clearUpdateBadge() {
+  updateOffer = null;
+  pendingUpdate = null;
+  el.updateBadge?.classList.add("hidden");
+}
+
+/**
+ * Offer a known release. The notice shown on load and a check started from
+ * Settings both end up here, so an update is announced with the same words and
+ * the same buttons however the user found out about it.
+ */
+function openUpdateDialog(update) {
   if (!el.updateDialog || typeof el.updateDialog.showModal !== "function") return false;
   updatePrompted = true;
   if (el.updateVersions) {
@@ -299,6 +337,56 @@ function maybePromptUpdate(config) {
   return true;
 }
 
+/**
+ * Announce a release. The console pushes what it knows when a tab connects and
+ * again whenever the 30-minute background check finds a new one, so a window
+ * that stays open is told in the same words as one that has just loaded.
+ */
+function applyUpdateStatus(update) {
+  // The badge is lit even when the notice was already shown, so a dismissed
+  // offer can still be picked up again from the corner.
+  if (!noteUpdateAvailable(update)) {
+    // The console reports no release any more, so the reminder has nothing
+    // left to stand for.
+    clearUpdateBadge();
+    return false;
+  }
+  if (updatePrompted) return false;
+  // The background invitation is a modal dialog too, and two of them must never
+  // stack: this release is offered once that one is out of the way.
+  if (el.backgroundDialog?.open) {
+    pendingUpdate = update;
+    return false;
+  }
+  return openUpdateDialog(update);
+}
+
+/**
+ * Listen for the console's announcements. EventSource reconnects by itself, so
+ * a dropped connection only leaves the page with the release it already knows.
+ */
+function openUpdateEvents() {
+  if (updateSource) return;
+  const source = new EventSource(apiPath("/api/update/events"));
+  updateSource = source;
+  source.addEventListener("update", (event) => {
+    let update;
+    try {
+      update = JSON.parse(event.data);
+    } catch {
+      return;
+    }
+    applyUpdateStatus(update);
+  });
+}
+
+/** The console is locked behind the login gate: its announcements are moot. */
+function closeUpdateEvents() {
+  if (!updateSource) return;
+  updateSource.close();
+  updateSource = null;
+}
+
 /** Run npm through the console's own server and report what happened. */
 async function runUpdate() {
   if (!el.updateNow || el.updateNow.disabled) return;
@@ -322,6 +410,7 @@ async function runUpdate() {
     // The install is done: the only thing left is to close the notice.
     el.updateLater?.classList.add("hidden");
     el.updateNow?.classList.add("hidden");
+    clearUpdateBadge();
   } catch (error) {
     if (feedback) {
       feedback.textContent = tr("Update failed: {error}", { error: error.message });
@@ -356,6 +445,9 @@ const el = {
   messages: document.getElementById("messages"),
   composer: document.getElementById("composer"),
   input: document.getElementById("input"),
+  modePicker: document.getElementById("agent-mode-picker"),
+  modeLabel: document.getElementById("agent-mode-label"),
+  modeFeedback: document.getElementById("agent-mode-feedback"),
   send: document.getElementById("send"),
   approval: document.getElementById("approval"),
   emptyNewChat: document.getElementById("empty-new-chat"),
@@ -422,6 +514,7 @@ const el = {
   updateClose: document.getElementById("update-close"),
   updateLater: document.getElementById("update-later"),
   updateNow: document.getElementById("update-now"),
+  updateBadge: document.getElementById("update-badge"),
 };
 
 if (el.backgroundCancel) {
@@ -435,6 +528,14 @@ if (el.backgroundDialog) {
     event.preventDefault();
     void answerBackgroundPrompt(false);
   });
+  // A release announced while the invitation was up is offered right after it.
+  el.backgroundDialog.addEventListener("close", () => {
+    const waiting = pendingUpdate;
+    pendingUpdate = null;
+    // The login gate closes this dialog on its way in, and nothing may sit on
+    // top of it.
+    if (waiting && !gateShown) openUpdateDialog(waiting);
+  });
 }
 
 if (el.updateNow) el.updateNow.addEventListener("click", () => { void runUpdate(); });
@@ -447,6 +548,12 @@ if (el.updateDialog) {
     el.updateDialog.close();
   });
 }
+// The corner disc reopens the same notice, so a dismissal is never final.
+if (el.updateBadge) {
+  el.updateBadge.addEventListener("click", () => {
+    if (updateOffer) openUpdateDialog(updateOffer);
+  });
+}
 
 const state = {
   overview: null,
@@ -489,12 +596,160 @@ function storedWorkspace() {
   return { key: pathKey(path), path };
 }
 
+const AGENT_MODE_LABELS = { standard: "Standard mode", ptc: "PTC mode", fast: "Fast mode", pro: "Professional mode" };
+let newAgentMode = readStorage("neutrino.agent-mode");
+if (!["standard", "ptc", "fast"].includes(newAgentMode)) newAgentMode = "standard";
+let agentModePending = Promise.resolve();
+let agentModeChanging = false;
+let workspaceNavigation = false;
+let agentModeError = "";
+
+function clearAgentModeFeedback() {
+  agentModeError = "";
+  agentModePending = Promise.resolve();
+}
+
+function currentAgentMode() {
+  if (PRO_MODE) return "pro";
+  if (state.selection?.kind === "live") return state.snapshot?.agentMode || "standard";
+  if (state.selection?.kind === "file") return state.fileData?.agent_mode || "standard";
+  return newAgentMode;
+}
+
+function renderAgentMode() {
+  if (!el.modePicker || !el.modeLabel) return;
+  const mode = currentAgentMode();
+  el.modeLabel.removeAttribute?.("data-i18n");
+  el.modeLabel.textContent = tr(AGENT_MODE_LABELS[mode] || AGENT_MODE_LABELS.standard);
+  const nextTurn = state.snapshot?.busy && state.snapshot.activeAgentMode !== state.snapshot.agentMode;
+  el.modePicker.classList.toggle("is-pending", Boolean(agentModeChanging || nextTurn));
+  for (const button of el.modePicker.querySelectorAll?.("[data-agent-mode]") || []) {
+    button.setAttribute("aria-checked", String(button.dataset.agentMode === mode));
+    button.disabled = agentModeChanging || workspaceNavigation;
+  }
+  if (el.modeFeedback) {
+    el.modeFeedback.textContent = agentModeError || (agentModeChanging ? tr("Changing mode…") : nextTurn ? tr("Applies to the next turn") : "");
+    el.modeFeedback.classList.toggle("error", Boolean(agentModeError));
+  }
+}
+
+async function chooseAgentMode(mode) {
+  if (!Object.hasOwn(AGENT_MODE_LABELS, mode) || agentModeChanging || workspaceNavigation || mode === currentAgentMode()) return;
+  const selected = state.selection;
+  agentModeChanging = true;
+  agentModeError = "";
+  if (el.modePicker) renderAgentMode();
+  el.modePicker.open = false;
+  try {
+    if (mode === "pro" || PRO_MODE) {
+      await switchWorkspaceMode(mode);
+    } else if (selected?.kind === "live") {
+      const response = await apiFetch(`/api/live/${encodeURIComponent(selected.key)}/agent-mode`, {
+        method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ mode }),
+      });
+      const body = await response.json();
+      if (!response.ok) throw new Error(apiError(body, `HTTP ${response.status}`));
+      if (state.selection === selected) { state.snapshot = body.snapshot; renderLive(); }
+    } else if (selected?.kind === "file") {
+      await continueSession(selected.id, preferences.selectionForFile(selected.id), mode);
+    } else {
+      newAgentMode = mode;
+    }
+    if (mode !== "pro") { newAgentMode = mode; writeStorage("neutrino.agent-mode", mode); }
+  } catch (error) {
+    if (state.selection !== selected) return;
+    agentModeError = tr("Could not change mode: {error}", { error: error.message });
+    throw error;
+  } finally { agentModeChanging = false; renderAgentMode(); }
+}
+
+async function switchWorkspaceMode(mode) {
+  const cwd = selectionCwd() || state.workspace?.path;
+  if (!cwd) throw new Error(tr("Select a working directory first."));
+  const targetPro = mode === "pro";
+  const response = await fetch(targetPro ? "/pro/api/conversations" : "/api/conversations", {
+    method: "POST", credentials: "same-origin", headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ cwd, ...(targetPro ? {} : { agent_mode: mode }) }),
+  });
+  const body = await response.json();
+  if (response.status === 401) showGate();
+  if (!response.ok) throw new Error(apiError(body, `HTTP ${response.status}`));
+  workspaceNavigation = true;
+  if (el.modePicker) renderAgentMode();
+  try { sessionStorage.setItem(`neutrino.workspace-draft.${body.key}`, el.input.value); } catch { /* Navigation still works without storage. */ }
+  const target = `${targetPro ? "/pro" : "/"}?live=${encodeURIComponent(body.key)}`;
+  if (targetPro) startProTransition(target);
+  else { try { location.assign(target); } catch { location.href = target; } }
+}
+
+/** A transferred chat remains reloadable until the user chooses another view. */
+function clearLinkedConversation(keepKey) {
+  const params = new URLSearchParams(location.search);
+  if (!params.has("live") || params.get("live") === keepKey) return;
+  params.delete("live");
+  const query = params.toString();
+  try { history.replaceState(history.state, "", location.pathname + (query ? `?${query}` : "") + location.hash); } catch { /* History is optional. */ }
+}
+
+async function openLinkedConversation() {
+  const key = new URLSearchParams(location.search).get("live");
+  if (!key || state.selection) return false;
+  try {
+    const response = await apiFetch(`/api/live/${encodeURIComponent(key)}`, { cache: "no-store" });
+    const body = await response.json();
+    if (!response.ok) throw new Error(apiError(body, `HTTP ${response.status}`));
+    if (state.selection) return false;
+    setWorkspace({ path: body.cwd });
+    await selectLive(key);
+    state.snapshot = body;
+    renderLive();
+    setConversationView(true);
+    try {
+      const storageKey = `neutrino.workspace-draft.${key}`;
+      el.input.value = sessionStorage.getItem(storageKey) || "";
+      sessionStorage.removeItem(storageKey);
+    } catch { /* Storage is optional. */ }
+    autosize(); el.input.focus();
+    return true;
+  } catch (error) { el.sub.textContent = error.message; return false; }
+}
+
+function initializeAgentMode() {
+  if (!el.modePicker?.querySelectorAll) return;
+  for (const button of el.modePicker.querySelectorAll("[data-agent-mode]")) {
+    button.addEventListener("click", () => {
+      agentModePending = chooseAgentMode(button.dataset.agentMode);
+      // Keep the rejection available to sendMessage while avoiding an unhandled promise.
+      void agentModePending.catch(() => {});
+    });
+  }
+  el.modePicker.addEventListener("keydown", event => {
+    if (event.key === "Escape") { el.modePicker.open = false; el.modePicker.querySelector("summary")?.focus(); event.stopPropagation(); }
+    if (!["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) return;
+    event.preventDefault(); el.modePicker.open = true;
+    const buttons = [...el.modePicker.querySelectorAll("[data-agent-mode]")];
+    let index = buttons.indexOf(document.activeElement);
+    index = event.key === "Home" ? 0 : event.key === "End" ? buttons.length - 1 : (index + (event.key === "ArrowDown" ? 1 : -1) + buttons.length) % buttons.length;
+    buttons[index]?.focus();
+  });
+  document.addEventListener("pointerdown", event => {
+    if (el.modePicker.open && !el.modePicker.contains(event.target)) el.modePicker.open = false;
+  });
+  if (el.modePicker) renderAgentMode();
+}
+
 let proUI = null;
 const preferences = createSettingsUI({
   apiFetch,
   proMode: PRO_MODE,
   onCatalogChange: (catalog) => proUI?.load(catalog),
   onLanguageChange: (language) => changeInterfaceLanguage(language),
+  // A check started from Settings offers its result through the same dialog as
+  // the notice shown on load, and lights the corner badge with it.
+  onUpdateFound: (update) => {
+    noteUpdateAvailable(update);
+    return openUpdateDialog(update);
+  },
   async applyModel(selection) {
     const current = state.selection;
     if (!current) throw new Error("Select a conversation first.");
@@ -799,20 +1054,42 @@ function renderGroup(group, options = {}) {
   wrap.className = "group";
 
   const collapsed = !options.forceOpen && state.collapsed.has(group.key);
+  // The row answers "start something here", not "how much is already here": a
+  // plus beside the folder opens a fresh conversation in it, the way Codex puts
+  // a project's own new-chat control next to the project. Two actions cannot
+  // share one button, so the row holds the folder and the plus side by side.
+  const head = document.createElement("div");
+  head.className = "group-head";
+
   const header = document.createElement("button");
   header.className = "group-header";
+  header.type = "button";
+  header.setAttribute("aria-expanded", String(!collapsed));
   header.innerHTML =
     `<span class="chevron${collapsed ? " collapsed" : ""}">` +
     '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="m9 18 6-6-6-6"/></svg>' +
     "</span>" +
-    `<span class="path" title="${escapeHtml(group.cwd)}">${escapeHtml(shortenPath(group.cwd))}</span>` +
-    `<span class="count">${group.sessions.length}</span>`;
+    `<span class="path" title="${escapeHtml(group.cwd)}">${escapeHtml(shortenPath(group.cwd))}</span>`;
   header.addEventListener("click", () => {
     if (state.collapsed.has(group.key)) state.collapsed.delete(group.key);
     else state.collapsed.add(group.key);
     renderSidebar();
   });
-  wrap.appendChild(header);
+  head.appendChild(header);
+
+  if (group.cwd) {
+    const start = document.createElement("button");
+    start.className = "icon-btn group-new";
+    start.type = "button";
+    start.title = tr("New conversation in this folder");
+    start.setAttribute("aria-label", tr("New conversation in this folder"));
+    start.innerHTML =
+      '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M12 5v14M5 12h14"/></svg>';
+    start.addEventListener("click", () => startConversationIn(group.cwd));
+    head.appendChild(start);
+  }
+
+  wrap.appendChild(head);
 
   if (collapsed) return wrap;
 
@@ -846,6 +1123,19 @@ function renderGroup(group, options = {}) {
   return wrap;
 }
 
+/**
+ * The plus on a folder header. It opens that folder's landing view, where the
+ * next message becomes a new conversation in that directory, so starting one
+ * costs a click instead of a dialog.
+ */
+function startConversationIn(cwd) {
+  const path = String(cwd ?? "").trim();
+  if (!path) return;
+  renderWorkspaceLanding(path);
+  setConversationView(true);
+  el.input?.focus?.();
+}
+
 function isSelected(session) {
   const selection = state.selection;
   if (!selection) return false;
@@ -1133,6 +1423,7 @@ function resetMessagePane(text) {
 }
 
 async function selectLive(key) {
+  if (el.modePicker) { clearAgentModeFeedback(); clearLinkedConversation(key); }
   preferences.clear();
   closeStream();
   state.selection = { kind: "live", key };
@@ -1209,6 +1500,7 @@ function closeStream() {
 }
 
 async function selectFile(id) {
+  if (el.modePicker) { clearAgentModeFeedback(); clearLinkedConversation(); }
   preferences.clear();
   closeStream();
   state.selection = { kind: "file", id };
@@ -1254,6 +1546,7 @@ function renderFile(data) {
   renderFileControls(data);
   maybeOpenPlan(data.plan);
   renderPlanCard(data);
+  if (el.modePicker) renderAgentMode();
 }
 
 /**
@@ -1300,8 +1593,10 @@ function renderFileControls(data) {
 }
 
 /** Attach to a resumed conversation, creating it server-side when needed. */
-async function continueSession(id, selection = preferences.selectionForFile(id)) {
-  const payload = PRO_MODE ? { pro_preset: currentProPreset() } : selection ? { selection } : undefined;
+async function continueSession(id, selection = preferences.selectionForFile(id), agentMode) {
+  const payload = PRO_MODE ? { pro_preset: currentProPreset() } : {
+    ...(selection ? { selection } : {}), ...(agentMode ? { agent_mode: agentMode } : {}),
+  };
   const response = await apiFetch(`/api/session/${encodeURIComponent(id)}/continue`, {
     method: "POST",
     headers: payload ? { "Content-Type": "application/json" } : undefined,
@@ -1315,6 +1610,7 @@ async function continueSession(id, selection = preferences.selectionForFile(id))
 
 function setComposerMode(mode) {
   state.composerMode = mode;
+  if (el.modePicker) renderAgentMode();
   el.agentActions.classList.add("hidden");
   el.composer.classList.remove("hidden");
   el.input.placeholder = mode === "resume"
@@ -1516,6 +1812,7 @@ function renderLive() {
   });
   maybeOpenPlan(snapshot.plan);
   renderPlanCard(snapshot);
+  if (el.modePicker) renderAgentMode();
 }
 
 async function changeApprovalMode(key, mode) {
@@ -1577,7 +1874,7 @@ function renderControls(snapshot) {
   // review callback is still winding down.
   const reviewing = snapshot.approval ? null : snapshot.reviewing;
   const subagent = snapshot.subagent;
-  badge.textContent = snapshot.paused
+  badge.textContent = snapshot.task?.state === "cancelling" ? tr("Stopping tasks…") : snapshot.paused
     ? tr("paused")
     : snapshot.busy
       ? snapshot.compressing
@@ -1592,10 +1889,10 @@ function renderControls(snapshot) {
       : tr("idle");
   el.controls.appendChild(badge);
 
-  if (snapshot.saveError) {
+  if (snapshot.saveError || snapshot.task?.persistenceError) {
     const warning = document.createElement("span");
     warning.className = "badge paused";
-    warning.textContent = tr("History save failed: {error}", { error: snapshot.saveError });
+    warning.textContent = tr("History save failed: {error}", { error: snapshot.saveError || snapshot.task?.persistenceError });
     el.controls.appendChild(warning);
   }
 
@@ -1732,6 +2029,12 @@ function renderMessage(message, index) {
       `<span class="tool-args">${escapeHtml(truncate(safeJson(message.arguments), 120))}</span>`;
     details.appendChild(summary);
 
+    if (message.name === "execute_ts" && typeof message.arguments?.code === "string") {
+      const program = document.createElement("pre");
+      program.className = "tool-result program-source";
+      program.textContent = message.arguments.code;
+      details.appendChild(program);
+    }
     const result = document.createElement("pre");
     result.className = "tool-result";
     result.textContent = message.result || "(no output)";
@@ -1871,6 +2174,7 @@ function activateComposer() {
 }
 
 async function sendMessage() {
+  try { await agentModePending; } catch (error) { el.sub.textContent = error.message; return; }
   const selection = state.selection;
   if (!selection) return;
   const text = el.input.value;
@@ -2009,6 +2313,7 @@ function showHome({ menu = true } = {}) {
 
 /** Show a folder as an empty workspace ready for its first message. */
 function renderWorkspaceLanding(path) {
+  if (el.modePicker) { clearAgentModeFeedback(); clearLinkedConversation(); }
   const sameLanding = state.selection?.kind === "new" && state.selection.cwd === path;
   state.selection = { kind: "new", cwd: path };
   state.snapshot = null;
@@ -2284,11 +2589,14 @@ async function submitNewChat() {
   }
 }
 
-/** Create a browser-owned conversation in `cwd` and reveal its folder. */
+/** Create a browser-owned conversation in `cwd` and show all sidebar directories. */
 async function createConversation(cwd, selection, approvalMode, proPreset = currentProPreset()) {
   const payload = { cwd };
   if (PRO_MODE) payload.pro_preset = proPreset;
-  else if (selection && selection.provider && selection.model) payload.selection = selection;
+  else {
+    payload.agent_mode = currentAgentMode();
+    if (selection && selection.provider && selection.model) payload.selection = selection;
+  }
   if (approvalMode === "request" || approvalMode === "auto") payload.approval_mode = approvalMode;
   const response = await apiFetch("/api/conversations", {
     method: "POST",
@@ -2297,7 +2605,7 @@ async function createConversation(cwd, selection, approvalMode, proPreset = curr
   });
   const data = await response.json().catch(() => ({}));
   if (!response.ok) throw new Error(apiError(data, `HTTP ${response.status}`));
-  setWorkspace({ path: data.cwd || cwd });
+  setWorkspace(null);
   await loadOverview({ silent: true });
   return data;
 }
@@ -2478,6 +2786,9 @@ function planStatusLabel(status) {
   if (status === "done") return tr("Done");
   if (status === "active") return tr("Active");
   if (status === "failed") return tr("Failed");
+  if (status === "blocked") return tr("Blocked");
+  if (status === "cancelled") return tr("Cancelled");
+  if (status === "skipped") return tr("Skipped");
   return tr("Pending");
 }
 
@@ -2522,7 +2833,7 @@ function renderPlanCard(source) {
     steps.className = "plan-steps";
     let done = 0;
     for (const step of plan.steps) {
-      const status = ["done", "active", "failed", "pending"].includes(step.status) ? step.status : "pending";
+      const status = ["done", "active", "failed", "pending", "blocked", "cancelled", "skipped"].includes(step.status) ? step.status : "pending";
       if (status === "done") done += 1;
       const row = document.createElement("div");
       row.className = `plan-step ${status}`;
@@ -2880,7 +3191,7 @@ function proDelay(callback, ms) {
   if (typeof setTimeout === "function") setTimeout(callback, ms);
 }
 
-function startProTransition() {
+function startProTransition(target = "/pro") {
   if (PRO_MODE || proTransitionStarted) return;
   proTransitionStarted = true;
   const started = Date.now();
@@ -2896,7 +3207,7 @@ function startProTransition() {
   curtain.classList.add("pro-curtain-visible");
 
   proDelay(() => {
-    try { location.assign("/pro"); } catch { location.href = "/pro"; }
+    try { location.assign(typeof target === "string" ? target : "/pro"); } catch { location.href = typeof target === "string" ? target : "/pro"; }
   }, PRO_TRANSITION_COVER_MS);
 }
 
@@ -2917,6 +3228,8 @@ function removeProCurtains() {
  */
 function resetProTransition({ clearRecord = true } = {}) {
   removeProCurtains();
+  if (typeof workspaceNavigation !== "undefined") workspaceNavigation = false;
+  if (typeof el !== "undefined" && el.modePicker) renderAgentMode();
   document.documentElement?.classList?.remove?.("pro-transitioning");
   proTransitionStarted = false;
   if (!clearRecord) return;
@@ -3023,7 +3336,7 @@ function initializeProWorkspace() {
   // the record and the pre-paint cover behind. Neither may ever affect the
   // regular console, so clear them before wiring the badge.
   resetProTransition();
-  el.brandLogo?.addEventListener("click", startProTransition);
+  el.brandLogo?.addEventListener("click", () => startProTransition());
   initializeProTip();
 }
 
@@ -3140,18 +3453,23 @@ forgetStaleConversationEntry();
 
 initializeLanguage();
 initializeProWorkspace();
+initializeAgentMode();
 preferences.load()
   .then(async (config) => {
     const language = config?.settings?.language;
     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);
+    // The announcement stream needs the login cookie, so it opens once the
+    // settings payload has loaded. A release it reports right away opens the
+    // notice; one that lands while the background invitation is up waits for it
+    // to close, because two modal dialogs must never stack on top of each other.
+    openUpdateEvents();
+    maybePromptBackground(config);
   })
   .catch(error => console.error(error));
-loadSeen().then(() => loadOverview()).then(() => {
+loadSeen().then(() => loadOverview()).then(async () => {
+  if (await openLinkedConversation()) return;
   // 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);

package/web/i18n.js

@@ -79,6 +79,21 @@ export function locale() {
 }
 
 const ZH = {
+  "Agent mode": "Agent 模式",
+  "Standard mode": "标准模式",
+  "PTC mode": "PTC模式",
+  "Fast mode": "快速模式",
+  "Professional mode": "专业模式",
+  "Full-featured Agent for every scenario": "功能完整的Agent，适用于所有场景",
+  "All standard capabilities, with code-based planning to save tokens": "拥有标准模式所有功能，通过代码实现规划，节省Token",
+  "Less thinking and fewer calls for quick answers": "减少思考和调用，迅速回答问题",
+  "Assign tasks to the best-suited models so multiple models complement each other": "适合需要多个模型取长补短的任务，将任务分给最适合他的模型",
+  "Applies to the next turn": "从下一轮开始生效",
+  "Changing mode…": "正在切换模式…",
+  "Could not change mode: {error}": "无法切换模式：{error}",
+  "Select a working directory first.": "请先选择工作目录。",
+  "Program": "程序",
+
   "Pro preset": "Pro 预设",
   "Preset": "预设",
   "Neutrino Pro": "Neutrino Pro",
@@ -115,6 +130,13 @@ const ZH = {
   "Updated to {version}. Restart Neutrino to use it.": "已更新到 {version}，请重新启动 Neutrino 以使用新版本。",
   "Update failed: {error}": "更新失败：{error}",
   "Update by hand with:": "也可以手动更新：",
+  "Updates": "更新",
+  "Check for updates": "检查更新",
+  "Checking for updates…": "正在检查更新…",
+  "Version {latest} is available. This install runs {current}.": "发现新版本 {latest}，当前安装为 {current}。",
+  "Neutrino {version} is up to date.": "Neutrino {version} 已是最新版本。",
+  "Update check failed: {error}": "检查更新失败：{error}",
+  "Neutrino checks npm for new releases every 30 minutes. Both workspaces share that check.": "Neutrino 每 30 分钟通过 npm 检查一次新版本，普通模式与 Pro 模式共用该检查。",
   // -- chrome -------------------------------------------------------------
   "Neutrino": "Neutrino",
   "Switch to Pro mode": "切换至Pro模式",
@@ -211,6 +233,7 @@ const ZH = {
   "Choose a conversation from the sidebar to view it.": "从侧边栏选择一个对话查看。",
   "No conversations yet.": "暂无对话。",
   "No conversations in this folder yet.": "此文件夹中暂无对话。",
+  "New conversation in this folder": "在此文件夹中新建对话",
   "Type a message below to start a conversation in this folder.": "在下方输入消息，即可在此文件夹中开始对话。",
   "Send a message to get started.": "发送一条消息开始对话。",
   "This conversation is empty.": "此对话为空。",
@@ -261,6 +284,10 @@ const ZH = {
 
   // -- live status --------------------------------------------------------
   "paused": "已暂停",
+  "Stopping tasks…": "正在停止任务…",
+  "Blocked": "受阻",
+  "Cancelled": "已取消",
+  "Skipped": "已跳过",
   "working": "处理中",
   "idle": "空闲",
   "compressing": "正在压缩上下文",