@oharness/server 0.9.3 → 0.11.0

package/dist/page/client/state.js

@@ -20,7 +20,8 @@ let currentCwd = "";
 function formatTokens(n) {
   if (n < 1000) return String(n);
   if (n < 1000000) return (n / 1000).toFixed(n < 10000 ? 1 : 0) + "k";
-  return (n / 1000000).toFixed(1) + "M";
+  // "1M", not "1.0M": a model's window is usually a round number.
+  return (n / 1000000).toFixed(1).replace(/\.0$/, "") + "M";
 }
 
 /**
@@ -44,10 +45,129 @@ function paintTokens(usage) {
     : "";
 }
 
+/*
+ * The context panel: what the ring stands for, opened by clicking it. The
+ * window split into what the model is given every time (system prompt, tool
+ * definitions), the conversation, and what is left; where automatic
+ * compaction fires; and a way to compact now instead of waiting for it.
+ */
+let ctxState = null;
+let ctxPanel = null;
+
+const CTX_PARTS = [
+  { key: "system", label: "ctx.system", color: "var(--ctx-system)" },
+  { key: "tools", label: "ctx.tools", color: "var(--ctx-tools)" },
+  { key: "messages", label: "ctx.messages", color: "var(--ctx-messages)" },
+];
+
+function paintCtxPanel() {
+  const c = ctxState;
+  const panel = ctxPanel;
+  panel.replaceChildren();
+  const pct = (n) => Math.round((n / c.window) * 1000) / 10;
+
+  const head = el("div", "ctx-head");
+  head.appendChild(el("span", "ctx-title", t("ctx.title")));
+  head.appendChild(el("span", "ctx-total", t("ctx.total", {
+    used: formatTokens(c.total),
+    total: formatTokens(c.window),
+    pct: Math.round((c.total / c.window) * 100),
+  })));
+  panel.appendChild(head);
+
+  // One bar, a segment per part, the empty rest as track. The tick marks where
+  // automatic compaction fires; it is a fill two pixels wide, not a rule.
+  const bar = el("div", "ctx-bar");
+  for (const part of CTX_PARTS) {
+    const seg = el("i");
+    seg.style.width = Math.min(100, pct(c[part.key])) + "%";
+    seg.style.background = part.color;
+    bar.appendChild(seg);
+  }
+  if (c.compactAt) {
+    const tick = el("b", "ctx-tick");
+    tick.style.left = Math.min(100, pct(c.compactAt)) + "%";
+    bar.appendChild(tick);
+  }
+  panel.appendChild(bar);
+
+  const rows = el("div", "ctx-rows");
+  const row = (color, label, value) => {
+    const r = el("div", "ctx-row");
+    const dot = el("span", "ctx-dot");
+    dot.style.background = color;
+    r.appendChild(dot);
+    r.appendChild(el("span", "ctx-label", label));
+    r.appendChild(el("span", "ctx-value", value));
+    rows.appendChild(r);
+  };
+  for (const part of CTX_PARTS) row(part.color, t(part.label), formatTokens(c[part.key]));
+  row("var(--track)", t("ctx.free"), formatTokens(Math.max(0, c.window - c.total)));
+  panel.appendChild(rows);
+
+  const notes = el("div", "ctx-notes");
+  notes.appendChild(el("div", "", c.compactAt
+    ? t("ctx.autoAt", { n: formatTokens(c.compactAt) })
+    : t("ctx.autoOff")));
+  // Said plainly, because the two numbers can disagree by a lot: a provider's
+  // count of the prompt and a character-based guess at it.
+  notes.appendChild(el("div", "", t(c.measured ? "ctx.measured" : "ctx.estimated")));
+  panel.appendChild(notes);
+
+  const compact = el("button", "menu-item ctx-compact");
+  compact.type = "button";
+  compact.appendChild(el("span", "menu-label", t("ctx.compactNow")));
+  compact.addEventListener("click", () => { closeCtxPanel(); compactConversation(); });
+  panel.appendChild(compact);
+  placeCtxPanel();
+}
+
+function placeCtxPanel() {
+  const box = ctxRing.getBoundingClientRect();
+  // Above the ring and flush with its right edge: the ring sits at the right
+  // end of the line under the composer, with the box it belongs to above it.
+  ctxPanel.style.right = Math.max(8, window.innerWidth - box.right) + "px";
+  ctxPanel.style.bottom = (window.innerHeight - box.top + 8) + "px";
+}
+
+function onCtxAway(event) {
+  if (!ctxPanel.contains(event.target) && !ctxRing.contains(event.target)) closeCtxPanel();
+}
+function onCtxKey(event) {
+  if (event.key === "Escape") { event.stopPropagation(); closeCtxPanel(); ctxRing.focus(); }
+}
+
+function closeCtxPanel() {
+  if (!ctxPanel) return;
+  ctxPanel.remove();
+  ctxPanel = null;
+  ctxRing.setAttribute("aria-expanded", "false");
+  document.removeEventListener("mousedown", onCtxAway, true);
+  document.removeEventListener("keydown", onCtxKey, true);
+  window.removeEventListener("resize", placeCtxPanel);
+}
+
+ctxRing.addEventListener("click", () => {
+  if (ctxPanel) return closeCtxPanel();
+  if (!ctxState) return;
+  ctxPanel = el("div", "menu pop ctx-panel");
+  ctxPanel.setAttribute("role", "dialog");
+  ctxPanel.setAttribute("aria-label", t("ctx.title"));
+  document.body.appendChild(ctxPanel);
+  ctxRing.setAttribute("aria-expanded", "true");
+  paintCtxPanel();
+  document.addEventListener("mousedown", onCtxAway, true);
+  document.addEventListener("keydown", onCtxKey, true);
+  window.addEventListener("resize", placeCtxPanel);
+});
+
 function applyState(s) {
   if (!s) return;
   if (s.model) modelPicker.set(modelPicker.options || [], s.model);
   if (s.mode) modePicker.set(MODES, s.mode);
+  // Kept per tab for the + menu's Plan mode row, which reads it.
+  if (s.sessionId && s.mode) pane(s.sessionId).mode = s.mode;
+  if (s.sessionId && Array.isArray(s.tasks)) tasksChanged(s.sessionId, s.tasks);
   effortPicker.set(s);
   if (s.cwd) {
     // Kept so the approval dialog can show a path the way the user thinks of
@@ -60,22 +180,37 @@ function applyState(s) {
   metaEl.textContent = s.costUsd > 0 ? "$" + s.costUsd.toFixed(4) : "";
   paintTokens(s.usage);
   const meta = document.getElementById("meta");
-  // A meter reading 0% is noise: it says nothing and takes the eye.
-  // Shown from half a window on, not from half a percent. Below that there is
-  // nothing to act on, and a bar sitting at 2% all day is a permanent piece of
-  // furniture that says the same thing every time you look at it.
-  meta.classList.toggle("has-ctx", typeof s.contextUsed === "number" && s.contextUsed >= 0.5);
-  if (typeof s.contextUsed === "number") {
+  // Shown once the conversation has anything in it: how full the window is
+  // decides when earlier detail starts being summarized away, and that is
+  // worth knowing before it happens rather than only once it is close.
+  const hasCtx = typeof s.contextUsed === "number" && s.contextTokens > 0;
+  meta.classList.toggle("has-ctx", hasCtx);
+  if (hasCtx) {
     const pct = Math.round(s.contextUsed * 100);
-    ctxBar.style.width = pct + "%";
-    ctxBar.style.background = pct >= 90 ? "var(--err)" : pct >= 70 ? "var(--warn)" : "var(--ok)";
-    ctxText.textContent = pct + "%";
+    // At least a sliver: an empty ring reads as a meter that is not working.
+    ctxRing.style.setProperty("--ctx-pct", String(Math.max(pct, 3)));
+    ctxRing.style.setProperty("--ctx-fill", pct >= 90 ? "var(--err)" : pct >= 70 ? "var(--warn)" : "var(--brand)");
+    const label = t("usage.contextOf", {
+      used: formatTokens(s.contextTokens),
+      total: formatTokens(s.contextWindow),
+      pct,
+    });
+    ctxRing.title = label;
+    ctxRing.setAttribute("aria-label", label);
   }
+  // The panel reads the latest breakdown, and redraws if it is open, so a turn
+  // finishing under it is not shown with the numbers from before.
+  ctxState = hasCtx && s.context ? s.context : null;
+  if (ctxPanel) ctxState ? paintCtxPanel() : closeCtxPanel();
   setBusy(Boolean(s.busy));
   // Addressed by session: a reload and a tab switch both land here, and the
   // pane this state describes is not always the one an event last touched.
   if (s.sessionId) pane(s.sessionId).queued = s.queued || [];
+  if (s.sessionId) pane(s.sessionId).goal = s.goal || "";
+  // Absent outside the desktop app: no helper, no grants, no row to offer.
+  if (s.sessionId) pane(s.sessionId).computer = s.computerUse || null;
   renderQueued();
+  renderAttachments();
   // The state knows the session's name; a tab opened before it had one would
   // otherwise keep the placeholder until the page reloaded.
   if (s.sessionId && s.title && pane(s.sessionId).title !== s.title) {
@@ -201,16 +336,49 @@ function routineHead(count, open) {
   return head;
 }
 
+/**
+ * The pin on a pinned row, which unpins it when clicked.
+ *
+ * It used to be a mark only, drawn inside the row's own button: clicking it
+ * folded the project or opened the session, and the way to unpin was hidden
+ * in the ⋯ menu while the thing that looked like the control did nothing of
+ * the kind. A span with a button's role rather than a <button>, because the
+ * project header it sits in is already a button and buttons do not nest.
+ */
+function pinMark(label, unpin) {
+  const mark = el("span", "pin-mark");
+  mark.appendChild(svgIcon("pin"));
+  mark.setAttribute("role", "button");
+  mark.tabIndex = 0;
+  mark.title = label;
+  mark.setAttribute("aria-label", label);
+  const act = (e) => {
+    e.preventDefault();
+    e.stopPropagation();
+    unpin();
+  };
+  mark.addEventListener("click", act);
+  mark.addEventListener("keydown", (e) => {
+    if (e.key === "Enter" || e.key === " ") act(e);
+  });
+  // A drag that starts on the pin must not carry the row away with it.
+  mark.addEventListener("mousedown", (e) => e.stopPropagation());
+  return mark;
+}
+
 /** A project header: a folder, a name, and how many sessions it holds. */
 function projectHead(cwd, name, count, open) {
-  const head = el("button", "fold" + (open ? " open" : ""));
+  const wt = worktreeAt(cwd);
+  const head = el("button", "fold" + (open ? " open" : "") + (wt ? " wt" : ""));
   head.type = "button";
   // The folder itself says which state it is in — it is the only thing on the
-  // row that can, now that there is no arrow beside it.
-  head.appendChild(svgIcon(open ? "folderOpen" : "folder"));
+  // row that can, now that there is no arrow beside it. A worktree is a branch
+  // off the project above it, and draws as one.
+  head.appendChild(svgIcon(wt ? "worktree" : open ? "folderOpen" : "folder"));
   head.appendChild(el("span", "fold-name", name));
+  if (wt) head.title = (wt.branch ? wt.branch + " · " : "") + wt.root;
   if ((projects.find((project) => project.path === cwd) || {}).pinned) {
-    head.appendChild(svgIcon("pin", "pin-mark"));
+    head.appendChild(pinMark(t("projects.unpin"), () => void togglePin("project", cwd, false)));
   }
   head.addEventListener("click", () => toggleProject(cwd, open));
 
@@ -271,7 +439,11 @@ function projectHead(cwd, name, count, open) {
     } });
 
     const pinned = (projects.find((project) => project.path === cwd) || {}).pinned === true;
+    const finish = wt
+      ? [menuItem(t("worktree.finish"), { key: "w", run: () => void showWorktreeFinish(cwd, anchor, head) }), menuSep()]
+      : [];
     const items = [
+      ...finish,
       menuItem(t("projects.open"), { key: "o", run: () => {
         closeRowMenu();
         void chooseProject(cwd);
@@ -288,6 +460,10 @@ function projectHead(cwd, name, count, open) {
         closeRowMenu();
         void openTerminalIn(cwd, true);
       } }),
+      menuItem(t("projects.claudeCode"), { key: "c", run: () => {
+        closeRowMenu();
+        void openClaudeCode(cwd);
+      } }),
       menuItem(t(IS_MAC ? "projects.revealMac" : IS_WIN ? "projects.revealWin" : "projects.reveal"), { key: "f", run: () => {
         closeRowMenu();
         void api("/reveal", { path: cwd }).then((body) => {
@@ -298,10 +474,11 @@ function projectHead(cwd, name, count, open) {
         closeRowMenu();
         exportProjectUi(cwd);
       } }),
-      menuItem(t("projects.rename"), { key: "n", run: () => {
+      // A worktree's name is the one its branch and registry entry know it by.
+      ...(wt ? [] : [menuItem(t("projects.rename"), { key: "n", run: () => {
         closeRowMenu();
         void renameProjectUi(cwd, name);
-      } }),
+      } })]),
     ];
     // Forgetting a path is only offered where it can do something: this row
     // stays on screen either way, because the sidebar groups by the tree a
@@ -491,7 +668,7 @@ function paintSessions() {
   // recent session; the rest follow by how recently they were touched — and
   // then a pin or a drag overrides both, because those were said out loud.
   const pinnedProject = (cwd) => (projects.find((p) => p.path === cwd) || {}).pinned === true;
-  const order = arrange(
+  const sorted = arrange(
     [...byProject.keys()].sort((a, b) => {
       if (a === here) return -1;
       if (b === here) return 1;
@@ -501,6 +678,23 @@ function paintSessions() {
     projectOrder,
     pinnedProject,
   );
+  /*
+   * Worktrees sit directly under the project they came from, whatever their
+   * own recency — they are that project's parallel work, not projects of
+   * their own. One with no session yet still shows, so it can be finished.
+   */
+  const order = sorted.filter((cwd) => !worktreeAt(cwd) || !sorted.includes(worktreeAt(cwd).parent));
+  for (const wt of worktrees) {
+    if (!byProject.has(wt.path)) byProject.set(wt.path, []);
+    const at = order.indexOf(wt.parent);
+    if (at === -1) {
+      if (!order.includes(wt.path) && byProject.get(wt.path).length) order.push(wt.path);
+      continue;
+    }
+    let end = at + 1;
+    while (end < order.length && worktreeAt(order[end]) && worktreeAt(order[end]).parent === wt.parent) end++;
+    order.splice(end, 0, wt.path);
+  }
 
   // Everything here belongs to the project already named at the top of the
   // sidebar: a header repeating it is noise, and the rows do not need
@@ -741,6 +935,59 @@ function pointAnchor(e) {
   return { getBoundingClientRect: () => rect };
 }
 
+/**
+ * The ways out of a worktree, in the menu it was asked from.
+ *
+ * Asked of the server each time rather than drawn from what the sidebar holds:
+ * whether there is anything to lose is the whole question, and the answer
+ * changes with every edit made in there.
+ */
+async function showWorktreeFinish(cwd, anchor, head) {
+  const body = await getJson("/worktree/status?path=" + encodeURIComponent(cwd));
+  if (body.error) return void addNotice(body.error, "notice err");
+  const wt = body.worktree;
+  const st = body.status;
+  const name = projectName(wt.root);
+  const parentName = projectName(wt.parent);
+  const facts = st.clean
+    ? t("worktree.clean")
+    : [
+        st.commits ? t("worktree.commits", { n: st.commits, branch: wt.branch || "" }) : "",
+        st.changes.length ? t("worktree.changes", { n: st.changes.length }) : "",
+      ].filter(Boolean).join(" · ");
+  const keys = { remove: "r", discard: "d", commit: "c", push: "p", merge: "m", apply: "a" };
+  const items = body.actions.map((action) =>
+    menuItem(t("worktree.action." + action, { name: parentName }), {
+      key: keys[action],
+      danger: action === "discard",
+      run: () => {
+        closeRowMenu();
+        void finishWorktreeUi(wt, action, name, st.clean);
+      },
+    }),
+  );
+  openRowMenu(anchor, head, [el("div", "menu-note", name + " — " + facts), ...items]);
+}
+
+async function finishWorktreeUi(wt, action, name, clean) {
+  const body = { path: wt.path, action };
+  if (action === "commit") {
+    const message = await askText({ title: t("worktree.commitPrompt"), value: wt.task || "", ok: t("dialog.ok") });
+    if (!message) return;
+    body.message = message;
+  }
+  if (action === "discard" && !clean && !(await askConfirm({ body: t("worktree.discardConfirm", { name }), ok: t("dialog.discard"), danger: true }))) return;
+  const answer = await api("/worktree/finish", body, 5 * 60_000);
+  if (!answer || answer.error) return void addNotice((answer && answer.error) || t("worktree.failed"), "notice err");
+  addNotice(answer.result.message);
+  if (answer.result.url) window.open(answer.result.url, "_blank", "noopener");
+  // Its tabs and harness are gone with it; reloading drops every pane and
+  // path that pointed there at once, the way a rename does.
+  if (answer.result.removed) return void window.location.reload();
+  await loadProjects();
+  await loadSessions();
+}
+
 function openRowMenu(button, row, items) {
   closeRowMenu();
   rowMenu.replaceChildren(...items);
@@ -784,7 +1031,7 @@ function sessionRow(s, nested) {
   item.appendChild(el("div", "title", s.title || t("session.untitled")));
   // Outside the title rather than in it: that line ellipsises, and a mark that
   // vanishes with the end of a long name is not a mark.
-  if (s.pinned) item.appendChild(svgIcon("pin", "pin-mark"));
+  if (s.pinned) item.appendChild(pinMark(t("session.unpin"), () => void togglePin("session", s.id, false)));
 
   draggable(item, {
     kind: "session",
@@ -1204,6 +1451,11 @@ function renderHistory(entries, into) {
   P.turn = null;
   P.streaming = null;
   for (const entry of entries || []) {
+    if (entry.tasks) {
+      P.turn = null;
+      taskCard(entry.tasks);
+      continue;
+    }
     if (entry.role === "user") {
       if (entry.text || (entry.images && entry.images.length)) {
         addUser(entry.text || "", entry.images);
@@ -1224,7 +1476,8 @@ function renderHistory(entries, into) {
     if (entry.text) assistantTurn().appendChild(renderMarkdown(entry.text));
     for (const call of entry.tools || []) toolCard(call.id, call.name, call.name, call.input);
     for (const result of entry.results || []) {
-      finishTool(result.id, [{ type: "text", text: result.text }], 0, result.isError);
+      const shots = (result.images || []).map((image) => ({ type: "image", src: image.src }));
+      finishTool(result.id, [{ type: "text", text: result.text }, ...shots], 0, result.isError);
     }
     // The cards, again. Live, these come from the "artifact" event, which a
     // replay does not produce — so a resumed conversation had every message and
@@ -1237,6 +1490,8 @@ function renderHistory(entries, into) {
       const card = replayedArtifactCard(call.input);
       if (card) assistantTurn().appendChild(card);
     }
+    if (entry.shots) turnShots(assistantTurn(), entry.shots);
+    if (entry.agent) agentReply(assistantTurn(), entry.agent);
     if (P.turn) turnActions(P.turn, entry.keepMessages);
   }
   for (const card of connectionCards.values()) {
@@ -1254,7 +1509,11 @@ function renderHistory(entries, into) {
 async function switchTo(body) {
   const state = await api("/session", body);
   if (state.error) return void addNotice(state.error, "err");
+  await openState(state);
+}
 
+/** Show a session the server has just opened, as its own focused tab. */
+async function openState(state) {
   // A tab per session, focused on arrival.
   const record = pane(state.sessionId);
   record.title = state.title || "";

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

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

package/dist/page/client/tasks.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Background tasks: their rows over the composer, and the sheet one opens
+ * into — what the subagent was told, what it did, what it said — with a way
+ * to stop it or tell it something.
+ *
+ * One part of the client script; see ./index.ts for how the parts join.
+ */
+export declare const TASKS: string;