@oharness/server 0.9.3 → 0.11.0

package/dist/page/client/shell.js

@@ -8,6 +8,11 @@ export const SHELL = String.raw `
 
 const projectBtn = document.getElementById("project");
 let projects = [];
+/** The server's home directory, which the picker writes as ~. */
+let projectHome = "";
+/** Session directories that are worktrees, each naming the project it came from. */
+let worktrees = [];
+const worktreeAt = (cwd) => worktrees.find((one) => one.path === cwd);
 
 /** The last path segment, which is what the directory is called. */
 function projectName(dir) {
@@ -25,6 +30,7 @@ function paintProject() {
   // it too, or it goes on advertising the tree the user just left.
   const cwdEl = document.getElementById("empty-cwd");
   if (cwdEl && active) cwdEl.textContent = active.name;
+  if (active) void paintStarters(active.path);
   // A directory added while the chip was open belongs on its list.
   refreshWorkspace();
 }
@@ -50,6 +56,8 @@ function repaintPanel() {
 async function loadProjects() {
   const body = await getJson("/projects");
   projects = body.projects || [];
+  projectHome = body.home || "";
+  worktrees = body.worktrees || [];
   projectOrder = body.order || [];
   paintProject();
   // A project's pin and its place decide how the session list is grouped, so
@@ -59,9 +67,9 @@ async function loadProjects() {
 }
 
 async function renameProjectUi(cwd, name) {
-  const next = window.prompt(t("projects.renamePrompt"), name);
-  if (!next || next.trim() === name) return;
-  const body = await api("/project", { path: cwd, rename: next.trim() });
+  const next = await askText({ title: t("projects.rename"), body: t("projects.renamePrompt"), value: name, ok: t("dialog.save") });
+  if (!next || next === name) return;
+  const body = await api("/project", { path: cwd, rename: next });
   if (body && body.error) return void addNotice(body.error, "err");
   addNotice(t("projects.renamed", { name: body.project.name }));
   // Paths key tabs, local open/closed state and drag order. Reloading after
@@ -76,73 +84,124 @@ function exportProjectUi(cwd) {
   link.click();
 }
 
+/** A project's directory as people say it: under home, from ~. */
+function projectDir(path) {
+  const home = projectHome.replace(/[\\/]+$/, "");
+  if (home && (path === home || path.startsWith(home + "/") || path.startsWith(home + "\\"))) return "~" + path.slice(home.length);
+  return path;
+}
+
 function openProjectPicker() {
   const dialog = document.getElementById("project-picker");
   const field = document.getElementById("proj-search");
   const listEl = document.getElementById("proj-list");
   field.placeholder = t("projects.search");
 
-  let first = null;
+  // The row menu lives in <body>, which a modal dialog makes inert: while the
+  // picker is open the menu is moved inside it, and put back when it closes.
+  const menuHome = rowMenu.parentNode;
+  dialog.appendChild(rowMenu);
+  dialog.addEventListener("close", () => {
+    closeRowMenu();
+    menuHome.appendChild(rowMenu);
+  }, { once: true });
+
+  /** The rows that open a project, in order, and which one Enter opens. */
+  let rows = [];
+  let active = 0;
+  const light = (index, scroll) => {
+    if (!rows.length) return;
+    active = (index + rows.length) % rows.length;
+    rows.forEach((row, i) => row.parentNode.classList.toggle("active", i === active));
+    if (scroll) rows[active].scrollIntoView({ block: "nearest" });
+  };
+
+  const menuFor = (project, more, line) => {
+    const items = [
+      menuItem(t("projects.rename"), {
+        key: "r",
+        run: () => {
+          dialog.close();
+          void renameProjectUi(project.path, project.name);
+        },
+      }),
+      menuItem(t("projects.export"), {
+        key: "e",
+        run: () => {
+          closeRowMenu();
+          exportProjectUi(project.path);
+        },
+      }),
+    ];
+    // Not offered for the project this window is standing in: the next
+    // switch calls addProject and puts it straight back, so the control
+    // would appear to do nothing. Nothing recorded is lost either way —
+    // this forgets a path, and the sessions stay where they are.
+    if (!project.current) {
+      items.push(
+        menuSep(),
+        menuItem(t("projects.forget"), {
+          danger: true,
+          run: () => {
+            closeRowMenu();
+            void api("/project", { path: project.path, remove: true }).then(async (body) => {
+              if (body && body.error) return void addNotice(body.error, "err");
+              await loadProjects();
+              paint();
+            });
+          },
+        }),
+      );
+    }
+    openRowMenu(more, line, items);
+  };
+
   const paint = () => {
     const query = field.value.trim().toLowerCase();
     listEl.replaceChildren();
-    first = null;
+    rows = [];
+    let here = 0;
     for (const project of projects) {
       if (query && !(project.name + " " + project.path).toLowerCase().includes(query)) continue;
+      const line = el("div", "proj-row" + (project.current ? " current" : ""));
       const row = el("button", "proj-item");
       row.type = "button";
+      row.title = project.path;
       row.appendChild(el("span", "avatar", project.name.slice(0, 1).toUpperCase()));
-      row.appendChild(el("span", "path", project.name));
+      const text = el("span", "proj-text");
+      text.appendChild(el("span", "path", project.name));
+      text.appendChild(el("span", "proj-dir", projectDir(project.path)));
+      row.appendChild(text);
       if (project.missing) row.appendChild(el("span", "tag", t("projects.missing")));
-      if (project.current) row.appendChild(el("span", "muted", "✓"));
+      const tick = el("span", "proj-check");
+      if (project.current) tick.appendChild(svgIcon("check"));
+      row.appendChild(tick);
       row.addEventListener("click", () => {
         dialog.close();
         if (!project.current) void chooseProject(project.path);
       });
-
-      const line = el("div", "proj-row");
+      const index = rows.length;
+      row.addEventListener("mousemove", () => { if (active !== index) light(index); });
       line.appendChild(row);
-      const rename = el("button", "proj-forget", "✎");
-      rename.type = "button";
-      rename.title = t("projects.rename");
-      rename.setAttribute("aria-label", t("projects.rename") + ": " + project.name);
-      rename.addEventListener("click", (e) => {
-        e.stopPropagation();
-        dialog.close();
-        void renameProjectUi(project.path, project.name);
-      });
-      line.appendChild(rename);
-      const archive = el("button", "proj-forget", "↓");
-      archive.type = "button";
-      archive.title = t("projects.export");
-      archive.setAttribute("aria-label", t("projects.export") + ": " + project.name);
-      archive.addEventListener("click", (e) => {
+
+      const more = el("button", "proj-more");
+      more.type = "button";
+      more.title = t("session.more");
+      more.setAttribute("aria-label", t("session.more") + ": " + project.name);
+      more.appendChild(svgIcon("more"));
+      more.addEventListener("click", (e) => {
         e.stopPropagation();
-        exportProjectUi(project.path);
+        if (menuRow === line) return closeRowMenu();
+        menuFor(project, more, line);
       });
-      line.appendChild(archive);
-      // Not offered for the project this window is standing in: the next
-      // switch calls addProject and puts it straight back, so the control
-      // would appear to do nothing. Nothing recorded is lost either way —
-      // this forgets a path, and the sessions stay where they are.
-      if (!project.current) {
-        const forget = el("button", "proj-forget", "✕");
-        forget.type = "button";
-        forget.title = t("projects.forget");
-        forget.setAttribute("aria-label", t("projects.forget") + ": " + project.name);
-        forget.addEventListener("click", (e) => {
-          e.stopPropagation();
-          void api("/project", { path: project.path, remove: true }).then(async (body) => {
-            if (body && body.error) return void addNotice(body.error, "err");
-            await loadProjects();
-            paint();
-          });
-        });
-        line.appendChild(forget);
-      }
+      line.appendChild(more);
       listEl.appendChild(line);
-      first = first || row;
+      if (project.current && !query) here = rows.length;
+      rows.push(row);
     }
+    if (!rows.length) listEl.appendChild(el("div", "proj-empty", t("projects.none")));
+    // Searching starts from the first match; an empty query from where you are.
+    light(here, true);
   };
 
   const add = document.getElementById("proj-add");
@@ -153,20 +212,38 @@ function openProjectPicker() {
   };
 
   field.value = "";
-  field.oninput = paint;
-  // Typing enough of the name and pressing Enter is what a list with a search
-  // box above it promises; without this the field swallows the key.
+  field.oninput = () => {
+    closeRowMenu();
+    paint();
+  };
+  // A list with a search box above it promises the keys of one: arrows move
+  // through what matched, Enter opens it, Escape shuts a menu before the picker.
   field.onkeydown = (e) => {
-    if (e.key !== "Enter" || !first) return;
-    e.preventDefault();
-    first.click();
+    if (e.isComposing) return;
+    if (e.key === "ArrowDown" || e.key === "ArrowUp") {
+      e.preventDefault();
+      closeRowMenu();
+      light(active + (e.key === "ArrowDown" ? 1 : -1), true);
+    } else if (e.key === "Enter" && rows[active]) {
+      e.preventDefault();
+      rows[active].click();
+    }
+  };
+  dialog.onkeydown = (e) => {
+    if (e.key === "Escape" && !rowMenu.hidden) {
+      e.preventDefault();
+      e.stopPropagation();
+      closeRowMenu();
+      field.focus();
+    }
   };
   paint();
   dialog.showModal();
   field.focus();
+  // Again now that it has a size: before showModal there is nothing to scroll.
+  light(active, true);
 }
 
-
 /**
  * A directory browser, for hosts with no folder dialog.
  *
@@ -294,6 +371,12 @@ const IS_WIN = /win/i.test(navigator.platform || navigator.userAgent || "");
 /** The rows the current query left on screen, in the order they are drawn. */
 let paletteRows = [];
 let paletteCursor = 0;
+/**
+ * Whether the palette was opened from the sidebar's "Search sessions": then it
+ * lists sessions and nothing else, and every one of them rather than the
+ * recent eight — the question asked was "where is that conversation".
+ */
+let paletteSessionsOnly = false;
 
 /** A nav item's own icon, so the palette names things the way the sidebar does. */
 function navIcon(id) {
@@ -315,6 +398,7 @@ const enLabel = (key) => (STRINGS.en && STRINGS.en[key]) || "";
 function paletteItems() {
   const items = [];
   const query = paletteField.value.trim();
+  if (paletteSessionsOnly) return sessionItems(sessionRows);
   const actions = t("palette.actions");
   const here = (projects.find((project) => project.current) || {}).path || currentCwd;
 
@@ -342,6 +426,7 @@ function paletteItems() {
   for (const [id, key] of [
     ["nav-artifacts", "nav.artifacts"],
     ["nav-sessions", "nav.sessions"],
+    ["nav-usage", "nav.usage"],
     ["nav-models", "nav.models"],
     ["nav-routines", "nav.routines"],
     ["nav-settings", "nav.settings"],
@@ -359,21 +444,7 @@ function paletteItems() {
   // Unfiltered, the list is a preview of the most recent work and the actions
   // above it still have to be visible. Once there is a query, every session in
   // every tree is fair game — that is what the field is for.
-  const sessions = t("palette.sessions");
-  for (const session of query ? sessionRows : sessionRows.slice(0, 8)) {
-    items.push({
-      kind: "session",
-      group: sessions,
-      icon: () => svgIcon("chat"),
-      label: session.title || t("session.untitled"),
-      sub: [projectName(session.cwd || ""), ago(session.updatedAt)].filter(Boolean).join(" · "),
-      keywords: session.cwd || "",
-      run: () => {
-        if (session.current) return void setNav(null);
-        void openSession(session.id, session.cwd);
-      },
-    });
-  }
+  items.push(...sessionItems(query ? sessionRows : sessionRows.slice(0, 8)));
 
   const named = t("palette.projects");
   for (const project of query ? projects : projects.slice(0, 5)) {
@@ -394,6 +465,23 @@ function paletteItems() {
   return items;
 }
 
+/** Palette rows for sessions, each reopening its own transcript. */
+function sessionItems(rows) {
+  const group = t("palette.sessions");
+  return rows.map((session) => ({
+    kind: "session",
+    group,
+    icon: () => svgIcon("chat"),
+    label: session.title || t("session.untitled"),
+    sub: [projectName(session.cwd || ""), ago(session.updatedAt)].filter(Boolean).join(" · "),
+    keywords: session.cwd || "",
+    run: () => {
+      if (session.current) return void setNav(null);
+      void openSession(session.id, session.cwd);
+    },
+  }));
+}
+
 /** Same word-by-word match the pickers use, over the row's hidden aliases too. */
 const paletteMatch = (item, query) =>
   matchesQuery(
@@ -454,12 +542,14 @@ function movePalette(step) {
   if (active) active.scrollIntoView({ block: "nearest" });
 }
 
-function openPalette() {
+function openPalette(sessionsOnly = false) {
   // One modal at a time. A permission request is a question the agent is
   // blocked on; a palette over it would answer neither.
   if (document.querySelector("dialog[open]")) return;
   closeAttachMenu();
   closeRowMenu();
+  paletteSessionsOnly = sessionsOnly === true;
+  paletteField.placeholder = t(paletteSessionsOnly ? "palette.sessionsPlaceholder" : "palette.placeholder");
   paletteField.value = "";
   paletteCursor = 0;
   paintPalette();
@@ -471,7 +561,7 @@ function openPalette() {
 // The desktop shell reaches the palette through this: a menu accelerator is
 // handled before the page ever sees the keystroke, so the menu item calls the
 // same function the key would have.
-window.openCommandPalette = openPalette;
+window.openCommandPalette = () => openPalette();
 
 paletteField.addEventListener("input", () => {
   paletteCursor = 0;
@@ -520,7 +610,8 @@ document.addEventListener("keydown", (e) => {
   openPalette();
 });
 
-document.getElementById("nav-search").addEventListener("click", openPalette);
+document.getElementById("nav-search").addEventListener("click", () => openPalette());
+document.getElementById("side-search").addEventListener("click", () => openPalette(true));
 // The chord as this machine actually spells it, in the one place a mouse user
 // will see it.
 document.getElementById("palette-hint").textContent = IS_MAC ? "⌘K" : "Ctrl K";
@@ -586,41 +677,107 @@ rail.addEventListener("focusout", hideRailTip);
 rail.addEventListener("click", hideRailTip);
 
 /**
- * What the empty state offers to do, grouped by the kind of work it is.
+ * What the empty state offers to do.
  *
- * One chip is drawn from each group, so the three on screen always span
- * writing code, getting through the day's work, and taking the thing to
- * market — three variations on "read my repo" would teach a new person that
- * this is a code-reading tool and nothing else. Each id names a label and a
- * "…prompt" string; the label is what fits on
- * a chip, the prompt is the sentence the chip actually sends.
+ * The server decides which kind: a project with no memory gets a rotating pool
+ * of everyday offers, and one the agent has notes on gets three written from
+ * those notes (see ../../starters.ts). Each chip's label is what fits on it,
+ * and the sentence it actually sends rides along in data-p.
  */
-const STARTERS = [
-  ["explain", "bugs", "tests", "review", "faster"],
-  ["plan", "docs", "digest", "automate", "backlog"],
-  ["landing", "launch", "pitch", "position", "changelog"],
-];
+const FIXED_STARTERS = ["trip", "email", "research", "savings", "japanTrip"];
+const VISIBLE_STARTERS = 3;
+const STARTER_ROTATION_MS = 6000;
+/** Which project the chips on screen were drawn for, and the newest ask. */
+let startersFor = "";
+let startersAsk = 0;
+let starterOffset = 0;
+let starterTimer;
+
+function starterChip(label, prompt) {
+  const button = el("button", "", label);
+  button.type = "button";
+  button.dataset.p = prompt;
+  // The label is a chip; the title is the sentence it will actually send.
+  button.title = prompt;
+  return button;
+}
+
+function animateStarters(box) {
+  box.classList.remove("fresh");
+  void box.offsetWidth;
+  box.classList.add("fresh");
+}
+
+function stopStarterRotation() {
+  clearInterval(starterTimer);
+  starterTimer = undefined;
+}
+
+function drawFixedStarters(box, animate = false) {
+  const ids = Array.from({ length: VISIBLE_STARTERS }, (_, index) =>
+    FIXED_STARTERS[(starterOffset + index) % FIXED_STARTERS.length]);
+  box.replaceChildren(...ids.map((id) => starterChip(t("starter." + id), t("starter." + id + ".prompt"))));
+  if (animate) animateStarters(box);
+}
+
+function startStarterRotation(box) {
+  stopStarterRotation();
+  if (FIXED_STARTERS.length <= VISIBLE_STARTERS) return;
+  starterTimer = setInterval(() => {
+    // Do not move a choice out from under a mouse pointer or keyboard focus.
+    if (!box.offsetParent || box.matches(":hover") || box.matches(":focus-within")) return;
+    starterOffset = (starterOffset + 1) % FIXED_STARTERS.length;
+    drawFixedStarters(box, true);
+  }, STARTER_ROTATION_MS);
+}
 
 /**
- * Draw one chip per group. The sentence rides along in data-p, and the click
- * is wired at the end of boot with the rest of them: a chip that submits before
- * the session it would submit to has loaded is worse than one that waits.
+ * Ask for the project's chips and draw them. Skipped when the project on
+ * screen has not changed, so a repaint of the project button does not pay for
+ * another round trip. The answer never waits on a model: a project whose set
+ * is not written yet gets the fixed three now, and the written set arrives
+ * later as a "starters" event (see startersArrived).
  */
-function paintStarters() {
+async function paintStarters(cwd) {
   const box = document.getElementById("starters");
-  if (!box) return;
+  if (!box || !cwd || cwd === startersFor) return;
+  stopStarterRotation();
+  startersFor = cwd;
+  starterOffset = 0;
+  const ask = ++startersAsk;
   box.replaceChildren();
-  for (const group of STARTERS) {
-    const id = group[Math.floor(Math.random() * group.length)];
-    const button = el("button", "", t("starter." + id));
-    button.type = "button";
-    button.dataset.p = t("starter." + id + ".prompt");
-    // The label is a chip; the title is the sentence it will actually send.
-    button.title = button.dataset.p;
-    box.appendChild(button);
+  let body;
+  try {
+    body = await getJson("/starters?cwd=" + encodeURIComponent(cwd) + "&locale=" + encodeURIComponent(LOCALE));
+  } catch {
+    body = { kind: "fixed" };
+  }
+  // A switch made while this was being written owns the box now.
+  if (ask !== startersAsk) return;
+  if (body && body.kind === "written" && Array.isArray(body.starters)) {
+    box.replaceChildren(...body.starters.map((item) => starterChip(item.label, item.prompt)));
+  } else {
+    drawFixedStarters(box);
+    startStarterRotation(box);
   }
 }
 
+/**
+ * A set written in the background for a project, pushed when it lands.
+ *
+ * Swapped in only where it still fits: the same project and language on
+ * screen, and the empty state still showing — nobody's chip is replaced while
+ * they are reading a conversation, and the next visit reads it from disk.
+ */
+function startersArrived(event) {
+  const box = document.getElementById("starters");
+  if (!box || !event || event.cwd !== startersFor || event.locale !== LOCALE || !Array.isArray(event.starters)) return;
+  if (!box.offsetParent) return;
+  stopStarterRotation();
+  box.replaceChildren(...event.starters.map((item) => starterChip(item.label, item.prompt)));
+  animateStarters(box);
+}
+
 /**
  * The desktop shell's update hint. The state lives in the main process, which
  * decides whether a release gets a dialog or only this row; the page draws it
@@ -668,11 +825,128 @@ if (IS_DESKTOP && window.oharness.updates) {
   // Asked once as well: a release found before this page loaded (or before a
   // reopened window) was announced to nobody.
   window.oharness.updates.state().then(paintUpdateHint, () => {});
+  if (window.oharness.updates.onPrompt) window.oharness.updates.onPrompt(showUpdatePrompt);
+}
+
+/**
+ * The update questions, asked in the app's own dialog rather than the OS's.
+ * The main process decides when to ask and what a button does; the page only
+ * words the question and hands back which button it was — 0 is the one that
+ * acts, and Escape answers -1, the same as Later.
+ */
+function showUpdatePrompt(prompt) {
+  const kind = prompt && prompt.kind;
+  const vars = { version: prompt.version || "", current: prompt.current || "" };
+  const dialog = el("dialog", "upd-dialog");
+  if (prompt.important) dialog.classList.add("important");
+  const head = el("div", "upd-head");
+  head.appendChild(el("span", "upd-mark", kind === "error" ? "!" : "↑"));
+  const title =
+    kind === "download"
+      ? t(prompt.important ? "update.prompt.importantTitle" : "update.prompt.availableTitle", vars)
+      : kind === "restart"
+        ? t("update.prompt.readyTitle", vars)
+        : kind === "current"
+          ? t("update.prompt.currentTitle")
+          : kind === "error"
+            ? t("update.prompt.errorTitle")
+            : t("update.prompt.devTitle");
+  head.appendChild(el("div", "upd-title", title));
+  dialog.appendChild(head);
+
+  if (kind === "download" && prompt.notes) dialog.appendChild(el("div", "upd-notes", prompt.notes));
+  const body =
+    kind === "download"
+      ? t("update.prompt.availableBody", vars)
+      : kind === "restart"
+        ? t("update.prompt.readyBody")
+        : kind === "current"
+          ? t("update.prompt.currentBody", vars)
+          : kind === "error"
+            ? prompt.detail || ""
+            : t("update.prompt.devBody");
+  if (body) dialog.appendChild(el("div", kind === "error" ? "upd-body mono" : "upd-body", body));
+
+  const actions = el("div", "dlg-actions");
+  const finish = (response) => {
+    window.oharness.updates.answer(prompt.id, response);
+    if (dialog.open) dialog.close();
+    dialog.remove();
+  };
+  let main;
+  let focus;
+  if (kind === "download" || kind === "restart") {
+    const later = el("button", "quiet", t("update.prompt.later"));
+    main = el("button", "approve", t(kind === "download" ? "update.prompt.download" : "update.prompt.restart"));
+    later.type = main.type = "button";
+    later.onclick = () => finish(1);
+    main.onclick = () => finish(0);
+    actions.append(later, main);
+    // Restarting ends whatever is running, so Enter must not do it by accident.
+    focus = kind === "restart" ? later : main;
+  } else {
+    main = el("button", "approve", t("update.prompt.ok"));
+    main.type = "button";
+    main.onclick = () => finish(0);
+    actions.append(main);
+    focus = main;
+  }
+  dialog.appendChild(actions);
+  dialog.addEventListener("cancel", (e) => {
+    e.preventDefault();
+    finish(-1);
+  });
+  document.body.appendChild(dialog);
+  dialog.showModal();
+  focus.focus();
+}
+
+/**
+ * A prompt from a link on the website — oharness://new?prompt=… — opened as a
+ * new session with the text in the composer, and nothing more.
+ *
+ * The main process checked and cleaned the text (desktop/deep-link.js), but
+ * it came from whatever page the person was on, so this page treats it as
+ * someone else's suggestion: it is never sent, no permission is changed and
+ * no card is answered. It sits in the box until the person reads it and
+ * presses send, or deletes it. A new session rather than the open one, so the
+ * suggestion never lands in the middle of a conversation as if it belonged
+ * there; and a draft already in the box is only replaced when the person says
+ * so, because the box is shared by every tab and the draft may be the only
+ * copy of what they were writing.
+ *
+ * Not before boot has finished: switching sessions while the first one is
+ * still being opened leaves the two fighting over the page. Boot takes the
+ * one that launched the app at the end; the nudge covers every later click.
+ */
+let deepLinkReady = false;
+
+async function takeDeepLink() {
+  if (!deepLinkReady || !IS_DESKTOP || !window.oharness.deepLink) return;
+  let text;
+  try {
+    text = await window.oharness.deepLink.take();
+  } catch {
+    return;
+  }
+  if (typeof text !== "string" || !text) return;
+  const draft = input.value.trim();
+  if (draft && draft !== text && !(await askConfirm({ body: t("deepLink.replaceDraft"), ok: t("dialog.replace") }))) return;
+  await switchTo({ action: "new" });
+  input.value = text;
+  // Called rather than an input event, which would also open the command
+  // menu for a prompt that starts with "/" — one Enter from running it.
+  autosize();
+  paintMirror();
+  input.focus();
+  input.setSelectionRange(input.value.length, input.value.length);
+}
+if (IS_DESKTOP && window.oharness.deepLink) {
+  window.oharness.deepLink.onArrived(() => void takeDeepLink());
 }
 
 void (async () => {
   applyStrings();
-  paintStarters();
   // The language is here because it is the one thing that decides what to
   // translate next, and the shell because a desktop window and a browser tab
   // are different products to the person using them.
@@ -727,18 +1001,26 @@ void (async () => {
   await loadSidePanels();
   await loadProjects();
 
-  for (const button of document.querySelectorAll("#starters button")) {
-    button.addEventListener("click", () => {
-      input.value = button.dataset.p;
-      paintMirror();
-      document.getElementById("composer").requestSubmit();
-    });
-  }
+  // Wired here, after the session has loaded: a chip that submits before the
+  // session it would submit to exists is worse than one that waits. Delegated,
+  // because the chips are redrawn on every project switch. Absent when the tab
+  // opened on a conversation: its first entry took the invitation off the
+  // page, and a throw here stopped everything after it, the session list too.
+  document.getElementById("starters")?.addEventListener("click", (event) => {
+    const button = event.target.closest("#starters button");
+    if (!button) return;
+    stopStarterRotation();
+    input.value = button.dataset.p;
+    paintMirror();
+    document.getElementById("composer").requestSubmit();
+  });
   await loadSessions();
   await refreshRoutineCount();
   await refreshPluginPages();
   await refreshModelCount();
   await loadAccount();
   input.focus();
+  deepLinkReady = true;
+  await takeDeepLink();
 })();`;
 //# sourceMappingURL=shell.js.map

package/dist/page/client/shell.js.map

@@ -1 +1 @@
-{"version":3,"file":"shell.js","sourceRoot":"","sources":["../../../src/page/client/shell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAiuBzB,CAAC"}
+{"version":3,"file":"shell.js","sourceRoot":"","sources":["../../../src/page/client/shell.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA2/BzB,CAAC"}