feat(maestro): clear AwaitingInput glow once a pane has been focused

A session's rail glows AwaitingInput even after the operator has already
looked at it. Clients now report pane focus (POST /:id/focus); the daemon
clears the glow to Idle after 5s of continuous focus and keeps it cleared
until the session does new work, so a fresh Active cycle is required to
glow again.

web/src/api.ts

@@ -91,6 +91,22 @@ export async function killSession(id: Uuid, force = false): Promise<void> {
   );
 }
 
+/** Report whether this client's pane is the one currently showing `id` — not
+ * merely highlighted in a sidebar. The daemon uses this to clear an
+ * `AwaitingInput` glow once the pane has been looked at long enough
+ * (docs/SIDEBAR.md). Best-effort: a failure here only delays the glow
+ * clearing, so callers don't need to surface it. */
+export async function setSessionFocus(id: Uuid, focused: boolean): Promise<void> {
+  await jsonOrError(
+    await fetch(routes.sessionFocus(id), {
+      method: "POST",
+      credentials: "same-origin",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ focused }),
+    }),
+  );
+}
+
 /** List one directory's immediate subdirectories (NAP-329). `path` may be empty,
  * `~`, relative, or absolute — the daemon resolves it against its home dir. */
 export async function listDir(path: string): Promise<DirListing> {

web/src/connections.test.ts

@@ -0,0 +1,87 @@
+// @vitest-environment happy-dom
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+import { ConnectionPool } from "./connections.js";
+
+afterEach(() => {
+  vi.unstubAllGlobals();
+});
+
+const A = "aaaaaaaa-0000-0000-0000-0000000000ff";
+const B = "bbbbbbbb-0000-0000-0000-0000000000ff";
+
+function mockFetch() {
+  const fetchMock = vi.fn(() => Promise.resolve(new Response(null, { status: 204 })));
+  vi.stubGlobal("fetch", fetchMock);
+  return fetchMock;
+}
+
+describe("ConnectionPool.setFocus", () => {
+  it("reports the new session focused, none unfocused, the first time", () => {
+    const fetchMock = mockFetch();
+    const pool = new ConnectionPool();
+
+    pool.setFocus(A);
+
+    expect(fetchMock).toHaveBeenCalledOnce();
+    const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
+    expect(url).toBe(`/api/sessions/${A}/focus`);
+    expect(init.method).toBe("POST");
+    expect(JSON.parse(init.body as string)).toEqual({ focused: true });
+  });
+
+  it("unfocuses the previous session and focuses the new one on a switch", () => {
+    const fetchMock = mockFetch();
+    const pool = new ConnectionPool();
+    pool.setFocus(A);
+    fetchMock.mockClear();
+
+    pool.setFocus(B);
+
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    const bodies = fetchMock.mock.calls.map(([url, init]: unknown[]) => [
+      url,
+      JSON.parse((init as RequestInit).body as string),
+    ]);
+    expect(bodies).toContainEqual([`/api/sessions/${A}/focus`, { focused: false }]);
+    expect(bodies).toContainEqual([`/api/sessions/${B}/focus`, { focused: true }]);
+  });
+
+  it("reports unfocused when focus clears to null", () => {
+    const fetchMock = mockFetch();
+    const pool = new ConnectionPool();
+    pool.setFocus(A);
+    fetchMock.mockClear();
+
+    pool.setFocus(null);
+
+    expect(fetchMock).toHaveBeenCalledOnce();
+    const [url, init] = fetchMock.mock.calls[0] as unknown as [string, RequestInit];
+    expect(url).toBe(`/api/sessions/${A}/focus`);
+    expect(JSON.parse(init.body as string)).toEqual({ focused: false });
+  });
+
+  it("is a no-op when the focused session doesn't change", () => {
+    const fetchMock = mockFetch();
+    const pool = new ConnectionPool();
+    pool.setFocus(A);
+    fetchMock.mockClear();
+
+    pool.setFocus(A);
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it("does not let a fetch rejection break the pool", async () => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn(() => Promise.reject(new Error("offline"))),
+    );
+    const pool = new ConnectionPool();
+
+    expect(() => pool.setFocus(A)).not.toThrow();
+    // Let the rejected promise's `.catch` settle before the test ends.
+    await Promise.resolve();
+    await Promise.resolve();
+  });
+});

web/src/connections.ts

@@ -3,6 +3,7 @@ import {
   type AttachConnection,
   type AttachInfo,
 } from "./attach.js";
+import { setSessionFocus } from "./api.js";
 import type { Uuid } from "./types.js";
 
 /**
@@ -122,9 +123,16 @@ export class ConnectionPool {
     for (const e of entries) this.mount(e.id, e.pane, e.info);
   }
 
+  /** Also tells the daemon which pane is focused (docs/SIDEBAR.md's
+   *  `AwaitingInput` auto-clear) — the sidebar highlight never calls this,
+   *  only a pane actually becoming the visible view. Best-effort: a failed
+   *  report only delays the glow clearing. */
   setFocus(id: Uuid | null): void {
     if (id === this.focusedId) return;
+    const previous = this.focusedId;
     this.focusedId = id;
+    if (previous !== null) void setSessionFocus(previous, false).catch(() => {});
+    if (id !== null) void setSessionFocus(id, true).catch(() => {});
     this.opts.onFocusChange?.(id);
   }
 

web/src/routes.ts

@@ -33,6 +33,10 @@ export function attach(id: Uuid): string {
   return `${API_PREFIX}/attach/${encodeURIComponent(id)}`;
 }
 
+export function sessionFocus(id: Uuid): string {
+  return `${session(id)}/focus`;
+}
+
 /** Append the `path` query parameter `DIRS` and `GITROOT` accept. */
 export function withPathQuery(route: string, value: string): string {
   return `${route}?${PATH_QUERY}=${encodeURIComponent(value)}`;