Fold away lead signal turns that end in NO_REPLY, tool calls included

docs/operations.md

@@ -142,7 +142,7 @@ Each user has one long-running lead agent, shown in the left pane. It is not tie
 
 - **Sessions.** A lead session is an `agent_sessions` row with `owner` set to the user's login, `role` `lead` and no `task_id`. Its events carry `owner` and no project or task. It runs in `leads/<login>` with `leadGuidance` (passed and re-attached the same way as a task agent's guidance) and the lead tools instead of the task tools. It has no Stop-hook bounce, no snapshots, no end-of-turn commit and no turn summary; a turn that ends in error records the error on its `session.state` event, which the pane shows as a note.
 - **Messages.** `POST /api/me/lead/messages` sends the caller's message to their lead, starting a lead session when there is none. While the lead is mid-turn the message is held in `lead_inputs`; the lead's PostToolUse hook (Codex: `turn/steer` after each completed tool item) hands held messages over after its next tool call, like a task's queued messages (see "Agent sessions"), and any still held become its next turn. Signals are never handed over mid-turn. The composer stays enabled. `GET /api/me/lead/sessions` lists the caller's lead sessions; interrupt and compact use the usual session endpoints.
-- **Signals.** Every published event goes through `Manager.Observe`. These become signals in `lead_inputs` for every user who has a lead session: `inbox.created` (a question with its choices and recommendation, an error or rate limit), `inbox.updated` when a human answered a question or error, `task.created` (naming the TODO item it was started from, if any), `task.merged`, `task.discarded`, and `turn.ended` with `summary: true` ("<task> finished a turn:" with its `result` cut to 1500 characters). The human switching the right pane is not a signal. A signal caused by the lead itself (actor `<login> (lead)`) is skipped, as is the update from an answer it gave. A task's `task.created` event carries the actor that created it, separately from its `created_by` login: tasks the lead creates with `create_task` or `start_todo` keep the human's login as `created_by` but have actor `<login> (lead)`. Whenever the lead is idle, byre sends the oldest held message from the human as its own turn, or else every held signal as one `byre` message headed "Signals since your last turn (n)". Its guidance tells it not to respond to the human's own actions, and to make its final message exactly `NO_REPLY` when a batch needs nothing from it. A transcript (`quietReply` in `web/src/task.ts`) never draws an `agent.message` whose last line is `NO_REPLY` (the model sometimes writes a sentence before it), and hides the live partial message while its text is still a prefix of it. A lead turn that byre starts without a handoff (a signal batch or a handoff continuation) is held (`ctx.held`): its `byre` message isn't drawn, the spinner stays off and its partial message stays hidden, until the lead draws something else, such as a tool call, thinking or a real message, which draws the `byre` message ahead of it. A `NO_REPLY` turn that drew nothing else ends without anything of it ever drawn; one that did keeps all of it, without the `NO_REPLY`.
+- **Signals.** Every published event goes through `Manager.Observe`. These become signals in `lead_inputs` for every user who has a lead session: `inbox.created` (a question with its choices and recommendation, an error or rate limit), `inbox.updated` when a human answered a question or error, `task.created` (naming the TODO item it was started from, if any), `task.merged`, `task.discarded`, and `turn.ended` with `summary: true` ("<task> finished a turn:" with its `result` cut to 1500 characters). The human switching the right pane is not a signal. A signal caused by the lead itself (actor `<login> (lead)`) is skipped, as is the update from an answer it gave. A task's `task.created` event carries the actor that created it, separately from its `created_by` login: tasks the lead creates with `create_task` or `start_todo` keep the human's login as `created_by` but have actor `<login> (lead)`. Whenever the lead is idle, byre sends the oldest held message from the human as its own turn, or else every held signal as one `byre` message headed "Signals since your last turn (n)". Its guidance tells it not to respond to the human's own actions, and to make its final message exactly `NO_REPLY` when a batch needs nothing from it. A transcript (`quietReply` in `web/src/task.ts`) never draws an `agent.message` whose last line is `NO_REPLY` (the model sometimes writes a sentence before it), and hides the live partial message while its text is still a prefix of it. A lead turn that byre starts without a handoff (a signal batch or a handoff continuation) is held (`ctx.held`): its `byre` message isn't drawn, the spinner stays off and its partial message stays hidden, until the lead draws something else, such as a tool call, thinking or a real message, which draws the `byre` message ahead of it. When such a turn ends in `NO_REPLY`, everything it drew is removed with it (its `byre` message, tool calls, thinking), so the transcript keeps nothing of it; a turn that ends in a real message keeps all of it.
 - **Tools.** `list_tasks` (each project's active tasks, then a line listing the titles of its `TODO.md` items on the default branch that no active task was started from), `read_transcript` (a task's events in brief, the last `limit` or those after `after_seq`), `read_inbox`, `answer_question` (an `option`, `other` or `dismiss` response recorded as the user, through the same checks as `POST /api/inbox/responses`), `send_message` (starts the task's agent if it has none; refused while it is mid-turn), `create_task`, `start_todo`, `interrupt`, `compact_task`, `merge_task`, `discard_task`, `show` and `compact_self`. The lead also has Claude Code's own tools and reads worktrees by path. Messages it sends task agents have actor `<login> (lead)`, so they don't make the user a participant; tasks, merges, discards and answers are done as the user. Its guidance says to answer a question only when the answer is clear or the human gave it, and to merge or discard only when the human asks.
 - **Focus.** `users.focus` holds what the user's right pane shows: `project_id`, `task_id`, `tabs` (the tabs put first, in order) and `tab` (the selected one). With a `task_id`, `project_id` is always that task's project, filled in by the server; with only a `project_id`, the pane shows that project with no task, which only the Project tab has anything for. `GET /api/me/focus` reads it; `PUT /api/me/focus` and the lead's `show` set it, refusing an unknown tab, a task that isn't active or an unknown project, and record a `focus.updated` event owned by the user. The page applies the focus on load and on every `focus.updated` it didn't cause itself; the human's own changes (⌘K, the right pane's task picker, clicking a tab, a task link, a notification) are sent with `PUT /api/me/focus`. The URL follows the focus: `#/task/<id>`, `#/project/<id>`, or `#/` for neither.
 - **Pane lock.** A `show` of what the pane already shows (the same task, or the same project with no task, on the same selected tab; `sameView`) tells the lead so and applies only its `tabs` order, whether or not the human is in the pane, so the human's selected tab stays selected. Otherwise, while the human is working in the right pane, the lead's `show` is refused with an error telling it to say in chat what it would have shown, unless its selected tab is `project` (the fallback the lead shows when nothing needs the human, so the human being there doesn't hold it) or the pane is finished (`Manager.paneFinished`): its task is merged or discarded, or its selected tab is `inbox` and the task has no open items. When an `inbox.updated`, `task.merged` or `task.discarded` event leaves a user's focused task finished that way, that user's signal for it gets a line "Your right pane is free: <task> has nothing left in its inbox." (or "is merged."/"is discarded."), even when the event itself makes no signal, such as a dismissed error; `inbox.updated` on a task that is no longer active adds none. The lead's guidance tells it to show the next thing that needs the human on that line, or, when nothing does, the project's Project tab with a short status in chat: one line per active task, then up to three TODO items it would start next, each with a reason, starting one only when the human picks it. It writes each item as a link to `#/todo/<project_id>/<URL-encoded title>`; Markdown views draw that (`web/src/todolink.ts`) as the title with a **Start** button that calls `POST /api/projects/{id}/todo/tasks` with the first model, as the Project tab's does, or, once an active task was started from that item, the task's colour, dot and state, linking to it. A chat view refills them whenever its transcript grows or tasks or sessions change. When that status says nothing new since its last one, it replies `NO_REPLY` instead. The page sends `PUT /api/me/pane-focus` with `focused` whenever that changes: true while the browser window has focus and the focused element is inside the right pane. The pane itself is focusable (`tabIndex` -1), so a click anywhere in it counts, not only on inputs and buttons; a re-render that removes the focused element hands focus back to the pane rather than counting as leaving. The page sends false on `pagehide` (with `keepalive`) and resends true when its event stream reconnects. byre keeps the flag in memory per user (`Manager.paneFocused`), so it starts false after a restart until the page resends it.

web/dist/task.js

@@ -148,6 +148,7 @@ export function mountChat(root, src, makeHead) {
         reviewButtons: new Map(),
         run: undefined,
         held: undefined,
+        drawn: undefined,
         quiet: false,
         handoff: undefined,
         root: src.root,
@@ -183,6 +184,7 @@ export function mountChat(root, src, makeHead) {
             return;
         }
         ctx.held = undefined;
+        ctx.drawn?.push(el);
         putBefore(el, stream?.el ?? pending[0]?.el);
         syncRunning();
     };
@@ -194,8 +196,18 @@ export function mountChat(root, src, makeHead) {
         if (!keepHeld) {
             release();
         }
+        ctx.drawn?.push(el);
         putBefore(el, pending[0]?.el);
     };
+    const fold = () => {
+        for (const el of ctx.drawn ?? []) {
+            el.remove();
+        }
+        ctx.drawn = undefined;
+        ctx.held = undefined;
+        ctx.quiet = false;
+        syncRunning();
+    };
     const renderHead = () => {
         syncRunning();
         if (!src.key()) {
@@ -268,6 +280,7 @@ export function mountChat(root, src, makeHead) {
             const body = h("div", { class: "tool-group-body" });
             const group = h("details", { class: "tool-group" }, summary, body);
             run.first.replaceWith(group);
+            ctx.drawn?.push(group);
             body.append(run.first);
             run.group = { el: group, summary, body };
         }
@@ -397,13 +410,16 @@ export function mountChat(root, src, makeHead) {
             if (ev.kind === "user.message" && p["handoff"] === true) {
                 openHandoff();
             }
-            if (ev.kind === "turn.ended" && ctx.quiet && ctx.held) {
-                ctx.held = undefined;
-                ctx.quiet = false;
+            if (ev.kind === "turn.ended" && ctx.quiet && ctx.drawn) {
+                fold();
                 continue;
             }
+            if (ev.kind === "turn.ended" || ev.kind === "user.message") {
+                ctx.drawn = undefined;
+            }
             if (ev.kind === "user.message" && ev.actor === "byre" && ev.owner && p["mid_turn"] !== true && p["handoff"] !== true) {
                 ctx.held = el;
+                ctx.drawn = [];
                 syncRunning();
                 continue;
             }

web/src/task.ts

@@ -74,6 +74,7 @@ type Ctx = {
   root: () => string;
   taskId: string | undefined;
   held: HTMLElement | undefined;
+  drawn: HTMLElement[] | undefined;
   quiet: boolean;
   handoff: { summary: HTMLElement; body: HTMLElement } | undefined;
 };
@@ -216,6 +217,7 @@ export function mountChat(root: HTMLElement, src: ChatSource, makeHead: (rerende
     reviewButtons: new Map(),
     run: undefined,
     held: undefined,
+    drawn: undefined,
     quiet: false,
     handoff: undefined,
     root: src.root,
@@ -250,6 +252,7 @@ export function mountChat(root: HTMLElement, src: ChatSource, makeHead: (rerende
       return;
     }
     ctx.held = undefined;
+    ctx.drawn?.push(el);
     putBefore(el, stream?.el ?? pending[0]?.el);
     syncRunning();
   };
@@ -261,8 +264,18 @@ export function mountChat(root: HTMLElement, src: ChatSource, makeHead: (rerende
     if (!keepHeld) {
       release();
     }
+    ctx.drawn?.push(el);
     putBefore(el, pending[0]?.el);
   };
+  const fold = () => {
+    for (const el of ctx.drawn ?? []) {
+      el.remove();
+    }
+    ctx.drawn = undefined;
+    ctx.held = undefined;
+    ctx.quiet = false;
+    syncRunning();
+  };
 
   const renderHead = () => {
     syncRunning();
@@ -345,6 +358,7 @@ export function mountChat(root: HTMLElement, src: ChatSource, makeHead: (rerende
       const body = h("div", { class: "tool-group-body" });
       const group = h("details", { class: "tool-group" }, summary, body);
       run.first.replaceWith(group);
+      ctx.drawn?.push(group);
       body.append(run.first);
       run.group = { el: group, summary, body };
     }
@@ -476,13 +490,16 @@ export function mountChat(root: HTMLElement, src: ChatSource, makeHead: (rerende
       if (ev.kind === "user.message" && p["handoff"] === true) {
         openHandoff();
       }
-      if (ev.kind === "turn.ended" && ctx.quiet && ctx.held) {
-        ctx.held = undefined;
-        ctx.quiet = false;
+      if (ev.kind === "turn.ended" && ctx.quiet && ctx.drawn) {
+        fold();
         continue;
       }
+      if (ev.kind === "turn.ended" || ev.kind === "user.message") {
+        ctx.drawn = undefined;
+      }
       if (ev.kind === "user.message" && ev.actor === "byre" && ev.owner && p["mid_turn"] !== true && p["handoff"] !== true) {
         ctx.held = el;
+        ctx.drawn = [];
         syncRunning();
         continue;
       }