@oharness/server 0.12.0 → 0.14.0

package/dist/page/client/tasks.js

@@ -16,11 +16,135 @@ let taskOpen = null;
 let taskSheet = null;
 /** Bumped per paint, so a slow answer never draws over a newer one. */
 let taskPaintSeq = 0;
+const taskDrafts = new Map();
+const taskSending = new Set();
+const taskKey = (session, id) => JSON.stringify([session, id]);
+function saveTaskDraft() {
+  if (taskOpen && taskSheet) taskDrafts.set(taskKey(taskOpen.session, taskOpen.id), taskSheet.querySelector(".task-input").value);
+}
 
 /**
  * Running ones first, then the newest. Ended tasks stay listed, quieter, so
  * what they said is a click away and they can still be sent a follow-up.
  */
+// Sidebar summaries deliberately do not allocate transcript panes.
+const sidebarTasks = new Map();
+let sidebarTaskRevision = 0;
+let sessionListRequest = 0;
+const taskTreeMore = new Set();
+const TASK_TREE_ENDED = 3;
+const taskTreeOpen = (() => {
+  try {
+    const value = JSON.parse(localStorage.getItem("oharness.taskTree") || "{}");
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+  } catch { return {}; }
+})();
+function saveTaskTreeOpen() {
+  try { localStorage.setItem("oharness.taskTree", JSON.stringify(taskTreeOpen)); } catch {}
+}
+function sessionBlock(s, nested) {
+  const block = el("div", "session-block" + (nested ? " nested" : ""));
+  block.dataset.session = s.id;
+  const row = sessionRow(s, nested);
+  const toggle = el("button", "task-tree-toggle");
+  toggle.type = "button";
+  toggle.appendChild(svgIcon("chevronRight"));
+  const list = el("div", "task-tree");
+  list.id = "task-tree-" + s.id;
+  toggle.setAttribute("aria-controls", list.id);
+  toggle.addEventListener("click", (e) => {
+    e.stopPropagation();
+    taskTreeOpen[s.id] = toggle.getAttribute("aria-expanded") !== "true";
+    saveTaskTreeOpen();
+    paintTaskTree(block, s);
+  });
+  toggle.addEventListener("mousedown", (e) => e.stopPropagation());
+  toggle.draggable = false;
+  // In the row's left inset, which every row in the list keeps, so titles
+  // start at one place whether or not their conversation has tasks.
+  row.prepend(toggle);
+  const count = el("span", "task-tree-count");
+  row.insertBefore(count, row.querySelector(".sub"));
+  block.append(row, list);
+  paintTaskTree(block, s);
+  return block;
+}
+function paintTaskTree(block, s) {
+  const tasks = sortedTasks((sidebarTasks.get(s.id) || {}).tasks).filter((task) => !task.dismissed);
+  const live = tasks.filter((task) => TASK_LIVE.has(task.status)).length;
+  // Only infer a default once live work appears in the current conversation.
+  if (!(s.id in taskTreeOpen) && s.id === activeId && live) {
+    taskTreeOpen[s.id] = true;
+    saveTaskTreeOpen();
+  }
+  const open = taskTreeOpen[s.id] === true;
+  const toggle = block.querySelector(".task-tree-toggle");
+  toggle.hidden = !tasks.length;
+  toggle.classList.toggle("open", open);
+  toggle.title = t(open ? "tasks.collapse" : "tasks.expand");
+  toggle.setAttribute("aria-label", toggle.title);
+  toggle.setAttribute("aria-expanded", String(open));
+  toggle.classList.toggle("quiet", !live);
+  // Only live work earns a badge; ended tasks would otherwise leave a number
+  // on every conversation that ever started one.
+  const count = block.querySelector(".task-tree-count");
+  count.hidden = !live;
+  count.textContent = t("tasks.liveCount", { n: live });
+  count.title = t("tasks.title");
+  const list = block.querySelector(".task-tree");
+  list.hidden = !open || !tasks.length;
+  if (list.hidden) return;
+  // Live tasks, then the few that ended last; older ones wait behind a button.
+  // Patch existing buttons so activity updates preserve keyboard focus.
+  const shown = taskTreeMore.has(s.id) ? tasks : tasks.slice(0, live + TASK_TREE_ENDED);
+  const keep = new Set(shown.map((task) => task.id));
+  for (const node of [...list.children]) {
+    if (!keep.has(node.dataset.task)) node.remove();
+  }
+  shown.forEach((task, index) => {
+    let button = [...list.children].find((node) => node.dataset.task === task.id);
+    if (!button) {
+      button = el("button", "task-tree-row");
+      button.type = "button";
+      button.dataset.task = task.id;
+      button.append(el("span", "task-tree-mark"), el("span", "task-tree-name"), el("span", "task-tree-status"));
+      button.addEventListener("click", async () => {
+        button.disabled = true;
+        try {
+          // Resume through the existing project-aware path, restoring task
+          // conversations before opening their input box.
+          if (activeId !== s.id) await openSession(s.id, s.cwd);
+          if (activeId === s.id) openTask(s.id, task.id);
+        } catch (err) { addNotice(String(err.message || err), "err"); }
+        finally { button.disabled = false; }
+      });
+    }
+    button.className = "task-tree-row task-" + task.status;
+    button.classList.toggle("selected", !!taskOpen && taskOpen.session === s.id && taskOpen.id === task.id);
+    button.setAttribute("aria-pressed", String(!!taskOpen && taskOpen.session === s.id && taskOpen.id === task.id));
+    button.querySelector(".task-tree-name").textContent = task.description;
+    // A dot is the same shape running and done, so the word says which.
+    const status = t("tasks.status." + task.status);
+    button.querySelector(".task-tree-status").textContent = status;
+    button.setAttribute("aria-label", task.description + ", " + status);
+    button.title = task.description + " · " + status + (task.activity ? " · " + task.activity : "");
+    if (list.children[index] !== button) list.insertBefore(button, list.children[index] || null);
+  });
+  if (shown.length < tasks.length) {
+    const more = el("button", "task-tree-more", t("tasks.older", { n: tasks.length - shown.length }));
+    more.type = "button";
+    more.addEventListener("click", () => { taskTreeMore.add(s.id); paintTaskTree(block, s); });
+    list.appendChild(more);
+  }
+}
+function refreshTaskTrees(session) {
+  for (const block of sessionList.querySelectorAll(".session-block")) {
+    if (session && block.dataset.session !== session) continue;
+    const s = sessionRows.find((row) => row.id === block.dataset.session);
+    if (s) paintTaskTree(block, s);
+  }
+}
+
 function sortedTasks(tasks) {
   return (tasks || []).slice().sort((a, b) =>
     (Number(TASK_LIVE.has(b.status)) - Number(TASK_LIVE.has(a.status))) || (b.queuedAt - a.queuedAt));
@@ -89,21 +213,30 @@ function taskCard(tasks) {
 
 /** A conversation's tasks changed: redraw what shows them. */
 function tasksChanged(session, tasks) {
-  pane(session).tasks = tasks || [];
+  sidebarTasks.set(session, { tasks: tasks || [], revision: ++sidebarTaskRevision });
+  refreshTaskTrees(session);
+  if (panes.has(session)) panes.get(session).tasks = tasks || [];
   if (session === activeId) renderQueued();
   if (taskOpen && taskOpen.session === session) void paintTask();
 }
 
 function openTask(session, id) {
+  saveTaskDraft();
   taskOpen = { session, id, stick: true };
   ensureTaskSheet();
+  taskSheet.querySelector(".task-input").value = taskDrafts.get(taskKey(session, id)) || "";
+  taskSheet.querySelector(".task-input").disabled = false;
+  taskSheet.querySelector(".task-send").disabled = true;
+  refreshTaskTrees();
   taskSheet.hidden = false;
   void paintTask();
   taskSheet.querySelector(".task-input").focus();
 }
 
 function closeTask() {
+  saveTaskDraft();
   taskOpen = null;
+  refreshTaskTrees();
   if (taskSheet) taskSheet.hidden = true;
 }
 
@@ -187,16 +320,29 @@ async function sendTask(input) {
   const text = input.value.trim();
   if (!text || !taskOpen) return;
   const { session, id } = taskOpen;
+  const key = taskKey(session, id);
+  if (taskSending.has(key)) return;
+  const draft = input.value;
+  taskSending.add(key);
+  taskDrafts.set(key, draft);
   input.disabled = true;
+  taskSheet.querySelector(".task-send").disabled = true;
   const body = await api("/task", { session, id, action: "message", text });
+  taskSending.delete(key);
+  if (!body.error && taskDrafts.get(key) === draft) taskDrafts.delete(key);
+  // A response for A must never clear or disable the input now showing B.
+  if (!taskOpen || taskOpen.session !== session || taskOpen.id !== id) {
+    if (body.error) addNotice(body.error, "err");
+    return;
+  }
   input.disabled = false;
   if (body.error) {
     taskSheet.querySelector(".task-log").appendChild(el("div", "task-error", body.error));
-    return;
+  } else {
+    if (input.value === draft) input.value = "";
+    input.focus();
+    taskOpen.stick = true;
   }
-  input.value = "";
-  input.focus();
-  if (taskOpen) taskOpen.stick = true;
   void paintTask();
 }
 
@@ -285,8 +431,8 @@ async function paintTask() {
 
   const input = taskSheet.querySelector(".task-input");
   const stopped = task.status === "cancelled";
-  input.disabled = stopped;
-  taskSheet.querySelector(".task-send").disabled = stopped;
+  input.disabled = stopped || taskSending.has(taskKey(session, id));
+  taskSheet.querySelector(".task-send").disabled = input.disabled;
   input.placeholder = t(stopped ? "tasks.placeholder.stopped" : TASK_LIVE.has(task.status) ? "tasks.placeholder.running" : "tasks.placeholder.ended");
 }
 `;

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

@@ -1 +1 @@
-{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../../src/page/client/tasks.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4R9B,CAAC"}
+{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../../src/page/client/tasks.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8a9B,CAAC"}

package/dist/page/client/usage.js

@@ -987,7 +987,11 @@ const usageMoved = (row) => usageSent(row) + (row.output || 0);
 function usageSessionRow(entry) {
   const row = el("div", "row-card usage-session");
   const line = el("div", "row-head");
-  line.appendChild(el("span", "row-title", entry.title || t("session.untitled")));
+  // A day of background calls, not a conversation: named for what it was, and
+  // opening the page that explains it rather than a transcript.
+  const background = entry.background;
+  line.appendChild(el("span", "row-title", background ? t("usage.background." + background) : entry.title || t("session.untitled")));
+  if (background) line.appendChild(el("span", "tag", t("usage.background")));
   if (entry.current) line.appendChild(el("span", "tag", t("usage.thisSession")));
   line.appendChild(el("span", "muted small usage-amount", "$" + (entry.costUsd || 0).toFixed(4)));
   row.appendChild(line);
@@ -999,6 +1003,7 @@ function usageSessionRow(entry) {
   row.tabIndex = 0;
   row.setAttribute("role", "button");
   const open = () => {
+    if (background === "dreaming") { setNav("dreaming"); void showDreaming(); return; }
     setNav(null);
     if (panes.has(entry.id)) void focusTab(entry.id);
     else void openSession(entry.id, entry.cwd);

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

@@ -1 +1 @@
-{"version":3,"file":"usage.js","sourceRoot":"","sources":["../../../src/page/client/usage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkxC3B,CAAC"}
+{"version":3,"file":"usage.js","sourceRoot":"","sources":["../../../src/page/client/usage.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAuxC3B,CAAC"}

package/dist/page/style.js

@@ -218,6 +218,53 @@ aside header{display:none;padding:8px 14px;min-height:44px;gap:8px;align-items:c
   height:30px;padding:0 8px;border-radius:7px;cursor:pointer;
   display:flex;align-items:center;gap:8px;
 }
+.session-block + .fold-row{margin-top:6px}
+/*
+ * A session's background tasks. The chevron sits in the row's left inset —
+ * one every row in the list keeps, flat or nested — so titles share a left
+ * edge whether or not a row has tasks. The tasks hang under the title with no
+ * rule, each status mark under the title's first letter.
+ *
+ * The marks stay quiet: a dashed ring for work still waiting, and a dot for
+ * everything else — breathing while it runs, still once done, fainter when
+ * stopped. Only a failure takes a colour.
+ */
+.session-block .session{position:relative}
+/* Two lit rows — the open one and the one under the pointer — must not
+   touch, or they read as one block. */
+.session-block + .session-block{margin-top:2px}
+.task-tree-row + .task-tree-row{margin-top:1px}
+.session-block:not(.nested) .session,.show-more:not(.nested){padding-left:20px}
+.task-tree-toggle{position:absolute;left:5px;top:50%;width:12px;height:16px;margin-top:-8px;display:grid;place-items:center;padding:0;border:0;background:none;color:var(--dim);cursor:pointer;opacity:.7}
+.session-block.nested .task-tree-toggle{left:14px}
+/* Above #side-panel's thinning of every 1.5 stroke, which these lose at this size. */
+#side-panel .task-tree-toggle svg{width:10px;height:10px;stroke-width:1.75;transition:transform .15s ease}
+.task-tree-toggle.open svg{transform:rotate(90deg)}
+.task-tree-toggle:hover,.session:hover .task-tree-toggle{opacity:1;color:var(--fg)}
+.task-tree-toggle.quiet{opacity:.6}
+.task-tree-toggle:focus{outline:none}
+.task-tree-count{flex:0 0 auto;font-size:10px;color:var(--dim)}
+.task-tree{margin:0 0 4px 12px}
+.session-block.nested .task-tree{margin-left:24px}
+.task-tree-row,.task-tree-more{display:flex;align-items:center;gap:7px;width:calc(100% - 4px);height:26px;padding:0 8px;border:0;border-radius:7px;background:transparent;color:var(--dim);text-align:left;cursor:pointer;font:inherit;font-size:12px}
+.task-tree-more{padding-left:29px}
+.task-tree-row:hover,.task-tree-more:hover{background:var(--hover);color:var(--fg)}
+.task-tree-row.selected{background:var(--sel);color:var(--fg)}
+.task-tree-row.task-running,.task-tree-row.task-queued{color:var(--fg)}
+.task-tree-mark{flex:0 0 14px;width:14px;height:14px;display:grid;place-items:center}
+.task-tree-mark::after{content:"";width:6px;height:6px;border-radius:50%;background:currentColor}
+.task-queued .task-tree-mark::after{width:10px;height:10px;box-sizing:border-box;background:none;border:1.25px dashed currentColor;opacity:.8}
+.task-running .task-tree-mark::after{background:var(--fg);animation:task-breathe 1.6s ease-in-out infinite}
+.task-completed .task-tree-mark::after{opacity:.7}
+.task-cancelled .task-tree-mark::after{opacity:.35}
+.task-failed .task-tree-mark::after{background:var(--err)}
+@keyframes task-breathe{50%{opacity:.25;transform:scale(.8)}}
+@media (prefers-reduced-motion:reduce){.task-running .task-tree-mark::after{animation:none}}
+.task-tree-name{flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.task-tree-status{font-size:10px;flex:0 0 auto;opacity:.8}
+.task-tree-row.task-running .task-tree-status{color:var(--fg);opacity:1}
+.task-tree-toggle:focus-visible,.task-tree-row:focus-visible,.task-tree-more:focus-visible{outline:2px solid var(--accent);outline-offset:-2px}
+.task-tree[hidden],.task-tree-toggle[hidden],.task-tree-count[hidden]{display:none}
 .session:hover{background:var(--hover)}
 .session.active{background:var(--sel)}
 .session .title{
@@ -1586,6 +1633,36 @@ button.ghost.theme-apply:disabled{opacity:.4;cursor:default}
 .memory-recent>div{padding:2px 0 2px 15px}
 .memory-backup{display:flex;align-items:center;gap:12px;padding:8px 0 8px 15px}
 .memory-backup-text{flex:1 1 auto;min-width:0;overflow-wrap:anywhere}
+.dream-card .row-head{align-items:center;gap:8px}
+.dream-head{display:flex;align-items:center;gap:10px}
+.dream-head h2{margin:0}
+.dream-spacer{flex:1 1 auto}
+.dream-auto{display:flex;align-items:center;gap:8px;color:var(--dim);cursor:pointer}
+.dream-auto-slot{display:inline-flex;align-items:center;flex:0 0 auto}
+.dream-metrics{display:grid;grid-template-columns:repeat(auto-fit,minmax(140px,1fr));gap:10px;margin:14px 0 6px}
+.dream-metric{background:var(--panel);border-radius:10px;padding:10px 12px}
+.dream-metric-value{font-size:20px;font-weight:600;margin:2px 0}
+.dream-section{margin:20px 0 6px;font-size:14px}
+.dream-line{display:flex;align-items:center;gap:8px;overflow-wrap:anywhere}
+.dream-run>summary,.dream-change>summary{cursor:pointer;padding:8px 4px;border-radius:8px}
+.dream-run>summary:hover,.dream-change>summary:hover{background:var(--hover)}
+.dream-run{margin:2px 0}
+.dream-run>:not(summary){margin-left:18px}
+.dream-change{padding:4px 0}
+.dream-grow{flex:1 1 auto;min-width:0}
+.dream-when{flex:0 0 auto;min-width:96px;color:var(--dim);font-size:12px}
+.dream-small{font-size:12px;padding:2px 8px}
+.dream-diff{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:10px;margin:6px 0}
+.memory-dream-heading{margin:14px 0 4px;font-size:13px;color:var(--dim);font-weight:600}
+.memory-dream-op{padding:6px 0 6px 15px}
+.memory-dream-op+.memory-dream-op{margin-top:4px}
+.memory-dream-op>summary{cursor:pointer;display:flex;gap:8px;align-items:baseline;overflow-wrap:anywhere}
+.memory-dream-tag{flex:0 0 auto;font-size:12px;padding:1px 6px;border-radius:6px;background:var(--field);color:var(--dim)}
+.memory-dream-tag.apply{color:var(--ok)}
+.memory-dream-tag.review{color:var(--warn)}
+.memory-dream-body{margin:4px 0 8px;background:var(--field);border-radius:8px;padding:8px 10px;font:inherit;font-size:12px;line-height:1.5;white-space:pre-wrap;overflow-wrap:anywhere}
+.memory-dream-body.before{color:var(--dim)}
+.memory-dream-evidence{margin:4px 0 0;padding-left:18px;color:var(--dim)}
 .memory-versions{display:grid;grid-template-columns:repeat(auto-fit,minmax(200px,1fr));gap:12px;margin:10px 0}
 .memory-version h4{margin:0 0 6px}
 .memory-version pre{margin:0;background:var(--field);border-radius:8px;padding:10px 12px;overflow-wrap:anywhere}
@@ -1648,6 +1725,13 @@ details.setting>summary:focus-visible{outline:none;background:var(--hover)}
    title 30px in, and a body that started at the card's edge read as a
    paragraph the row had dropped rather than the inside of it. */
 .setting-body{padding:4px 14px 16px 30px}
+.setting-stats{display:grid;grid-template-columns:repeat(auto-fit,minmax(150px,1fr));gap:8px}
+.setting-stat{background:var(--field);border-radius:10px;padding:10px 12px;min-width:0}
+.setting-stat-label{font-size:12px;color:var(--dim)}
+.setting-stat-value{font-size:15px;font-weight:600;margin-top:2px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+.setting-stat-sub{font-size:12px;color:var(--dim);margin-top:2px;overflow-wrap:anywhere}
+.setting-stat.ok .setting-stat-value{color:var(--ok)}
+.setting-stat.warn .setting-stat-value{color:var(--warn)}
 /* The shared .small breaks anywhere, which is right for a path and wrong for
    a sentence: the hint here came back as "the trail is never s / ynced". The
    prose breaks at spaces; the paths under it keep breaking anywhere. */
@@ -3533,11 +3617,16 @@ dialog::backdrop{background:rgba(0,0,0,.55)}
 /* An update question, in place of the OS's message box: the version is the
    title, the release notes scroll if there are many, and Later stays quiet. */
 .upd-dialog{width:min(440px,92vw);padding-bottom:16px}
+/* Notes get room to be read; the questions without them stay compact. */
+.upd-dialog:has(.upd-notes){width:min(560px,92vw)}
 .upd-head{display:flex;align-items:center;gap:12px;padding:22px 24px 8px}
 .upd-mark{flex:none;display:grid;place-items:center;width:30px;height:30px;border-radius:9px;background:var(--sel);color:var(--fg);font-size:15px;font-weight:600}
 .upd-dialog.important .upd-mark{background:var(--accent);color:var(--bg)}
 .upd-title{font-size:16px;font-weight:600;line-height:1.35}
-.upd-notes{margin:6px 24px 10px;padding:12px 14px;max-height:220px;overflow-y:auto;border-radius:10px;background:var(--hover);font-size:13px;line-height:1.55;white-space:pre-wrap}
+.upd-notes{margin:6px 24px 10px;padding:14px 16px;max-height:min(440px,55vh);overflow-y:auto;border-radius:10px;background:var(--hover);font-size:13px;line-height:1.55}
+/* release-notes.md is wrapped at 76 columns; a paragraph reflows to the dialog. */
+.upd-notes .md-p{white-space:normal}
+.upd-notes .md>:last-child{margin-bottom:0}
 .upd-body{padding:0 24px;color:var(--dim);font-size:13.5px;line-height:1.5;word-break:break-word}
 .upd-body.mono{font-size:12.5px}
 .upd-dialog .dlg-actions{justify-content:flex-end;padding:18px 20px 4px}

package/dist/page/style.js.map

@@ -1 +1 @@
-{"version":3,"file":"style.js","sourceRoot":"","sources":["../../src/page/style.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,0EAA0E;AAC1E,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;EAC7B,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAm0HV,CAAC"}
+{"version":3,"file":"style.js","sourceRoot":"","sources":["../../src/page/style.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,0EAA0E;AAC1E,MAAM,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,GAAG,CAAA;EAC7B,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA45HV,CAAC"}

package/dist/server.js

@@ -5,6 +5,7 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { homedir } from "node:os";
 import { Harness } from "@oharness/engine/harness.ts";
+import { BackgroundUsage } from "@oharness/engine/agent/background-usage.ts";
 import { updateUserMcpConfig } from "@oharness/engine/config-files.ts";
 import { connectorConfig, officialConnectors } from "@oharness/engine/mcp/registry.ts";
 import { findForeignServer, foreignMcpServers } from "@oharness/engine/foreign.ts";
@@ -18,6 +19,7 @@ import { PERMISSION_MODES } from "@oharness/engine/agent/permissions.ts";
 import { canDisableThinking, effectiveEffort, isEffortChoice, thinkingFor, } from "@oharness/engine/providers/types.ts";
 import { isReadable } from "@oharness/engine/agent/workspace.ts";
 import { BRANCH_TYPES, createWorktree, findWorktree, finishWorktree, listWorktrees, previewWorktree, worktreeStatus, } from "@oharness/engine/worktree/index.ts";
+import { restoredTaskView } from "@oharness/engine/agent/background.ts";
 import { within as insideAny } from "@oharness/engine/paths.ts";
 import { visibleText } from "@oharness/engine/core/types.ts";
 import { previewJson } from "@oharness/engine/util/json.ts";
@@ -305,6 +307,14 @@ export async function startWebServer(opts) {
     equipThemes(opts.agent.tools);
     const themeChanged = (state) => broadcast({ type: "theme", state });
     const runners = new Map();
+    /** Sidebar rows of sessions that are not loaded, keyed by tasks-file stamp. */
+    const storedTaskRows = new Map();
+    const sidebarTaskRows = (views) => views
+        .filter((task) => !task.dismissed)
+        .map((task) => ({
+        id: task.id, description: task.description, status: task.status,
+        queuedAt: task.queuedAt, endedAt: task.endedAt, activity: task.activity,
+    }));
     /** Agents whose background tasks are being watched; see watchTasks. */
     const watchedTasks = new WeakSet();
     // Written in the background; the page on that project swaps them in.
@@ -430,7 +440,6 @@ export async function startWebServer(opts) {
     // browser is still the same one bound by Harness.agent(session).
     initial.agent = opts.agent;
     runners.set(opts.session.id, initial);
-    adoptTasks(initial);
     let current = { session: opts.session, agent: opts.agent, harness: opts.harness };
     /**
      * Sign-ins waiting for their emailed code.
@@ -606,6 +615,8 @@ export async function startWebServer(opts) {
         for (const client of clients)
             client.write(payload);
     };
+    // Restored tasks may resolve immediately, so the broadcaster must exist.
+    adoptTasks(initial);
     const connectionSubscriptions = [];
     function watchConnections(harness) {
         connectionSubscriptions.push(harness.cloudConnectors.subscribe((card) => {
@@ -3011,13 +3022,39 @@ export async function startWebServer(opts) {
             case "GET /sessions": {
                 const prefs = await readPrefs();
                 const pinned = new Set(prefs.pinnedSessions ?? []);
+                const metas = await current.harness.listSessions(50);
+                const taskRows = new Map();
+                // Bound disk concurrency. Read stored views only: listing history must
+                // never create agents, switch projects or deliver pending results.
+                for (let offset = 0; offset < metas.length; offset += 5) {
+                    await Promise.all(metas.slice(offset, offset + 5).map(async (meta) => {
+                        const runner = runners.get(meta.id);
+                        if (runner) {
+                            taskRows.set(meta.id, sidebarTaskRows(runner.agent.backgroundTasks?.list() ?? []));
+                            return;
+                        }
+                        // The stored document carries every task's conversation; parse it
+                        // again only when it has been rewritten since the last listing.
+                        const stamp = await current.harness.store.tasksStamp(meta.id);
+                        const cached = storedTaskRows.get(meta.id);
+                        if (cached && cached.stamp === stamp)
+                            return void taskRows.set(meta.id, cached.rows);
+                        const rows = stamp === undefined ? [] : sidebarTaskRows((await current.harness.store.readTasks(meta.id)).flatMap((raw) => {
+                            const view = raw?.view;
+                            return view?.id ? [restoredTaskView(view)] : [];
+                        }));
+                        storedTaskRows.set(meta.id, { stamp, rows });
+                        taskRows.set(meta.id, rows);
+                    }));
+                }
                 return send(res, 200, {
                     // What somebody arranged by hand travels beside the list rather than
                     // being applied to it here: the sidebar groups by project and hides
                     // the tail of each group, so it is the only side that knows which
                     // rows an order has to survive.
                     order: prefs.sessionOrder ?? {},
-                    sessions: (await current.harness.listSessions(50)).map((meta) => ({
+                    sessions: metas.map((meta) => ({
+                        tasks: taskRows.get(meta.id) ?? [],
                         id: meta.id,
                         pinned: pinned.has(meta.id),
                         title: meta.title,
@@ -3085,7 +3122,8 @@ export async function startWebServer(opts) {
                         ...row,
                         current: row.id === current.session.id,
                     })),
-                    total: list.length,
+                    // Sessions, not rows: a day of background calls is listed but is not one.
+                    total: list.filter((row) => !row.background).length,
                     offset,
                     more: offset + limit < list.length,
                     truncated: stored.length >= USAGE_SESSIONS_SCAN,
@@ -3118,6 +3156,9 @@ export async function startWebServer(opts) {
                     return into;
                 };
                 const totals = list.reduce(add, { ...zero });
+                // A background row is spending, not a session: it counts toward the
+                // money and tokens, not toward how many sessions they came from.
+                const sessionCount = list.filter((row) => !row.background).length;
                 // Per model, because that is the axis a bill is read along: the same
                 // work costs an order of magnitude more on one model than another, and
                 // the only way to see that is to have them side by side.
@@ -3125,7 +3166,8 @@ export async function startWebServer(opts) {
                 for (const row of list) {
                     const bucket = byModel.get(row.model)
                         ?? { model: row.model, sessions: 0, lastUsedAt: 0, ...zero };
-                    bucket.sessions += 1;
+                    if (!row.background)
+                        bucket.sessions += 1;
                     bucket.lastUsedAt = Math.max(bucket.lastUsedAt, row.updatedAt);
                     byModel.set(row.model, add(bucket, row));
                 }
@@ -3138,7 +3180,7 @@ export async function startWebServer(opts) {
                     from: window.from,
                     to: window.to,
                     series: usageSeries(list, since || (list.length ? list[list.length - 1].updatedAt : Date.now()), until),
-                    totals: { ...totals, sessions: list.length },
+                    totals: { ...totals, sessions: sessionCount },
                     // Sorted by what was spent, not by name: the row worth seeing first
                     // is the expensive one.
                     models: [...byModel.values()].sort((a, b) => b.costUsd - a.costUsd),
@@ -3870,6 +3912,7 @@ export async function startWebServer(opts) {
                     await runners.get(id)?.agent.discardBackgroundTasks();
                     const forks = (await current.harness.store.children(id)).length;
                     const deleted = await current.harness.deleteSession(id);
+                    storedTaskRows.delete(id);
                     await removeTurnShots(id);
                     // A session nobody has spoken to has nothing on disk yet — the store
                     // writes on the first message — but it is still a session someone
@@ -5318,6 +5361,16 @@ export async function startWebServer(opts) {
                 ...tokensOf(sess.usage),
             });
         }
+        // Calls made outside any conversation (dreaming) have no transcript to sum;
+        // they are recorded per day, purpose and model, and join the totals here.
+        for (const record of await BackgroundUsage.shared.records().catch(() => [])) {
+            const id = `background:${record.purpose}:${record.day}:${record.model}`;
+            rows.set(id, {
+                id, title: record.purpose, model: record.model, updatedAt: record.updatedAt, turns: 0,
+                costUsd: record.costUsd, input: record.input, output: record.output, cacheRead: record.cacheRead, cacheWrite: record.cacheWrite,
+                background: record.purpose,
+            });
+        }
         return { stored, rows };
     }
     async function artifactCatalogue() {