agent-yes 1.201.0 → 1.202.0

package/ts/badges.ts

@@ -11,11 +11,20 @@
 export interface BadgeDef {
   /** Stable id, used as the wire value and as the key when re-deriving the label. */
   id: string;
-  /** Short chip text, e.g. "goal". Keep it a couple of characters — the chip is tiny. */
+  /**
+   * Short chip text, e.g. "goal". Keep it a couple of characters — the chip is
+   * tiny. May contain `$1`, replaced with the pattern's first capture group
+   * (see the dynamic footer-counter defs below).
+   */
   label: string;
   /** Tooltip shown on hover, explaining what the badge means. */
   title: string;
-  /** Matched against the tail-rendered screen text (lines joined with \n). */
+  /**
+   * Matched against the tail-rendered screen text (lines joined with \n).
+   * A pattern with a capture group makes the badge DYNAMIC: the wire id
+   * becomes `id:capture` (e.g. "shells:4 shells") and `$1` in label/title is
+   * substituted with the captured text when the chip is rendered.
+   */
   pattern: RegExp;
 }
 
@@ -46,15 +55,55 @@ export const BADGE_DEFS: BadgeDef[] = [
     title: "Waiting for the API — the CLI is auto-retrying on its own backoff (no action needed)",
     pattern: /Waiting for API response[\s\S]{0,40}will retry in \d/i,
   },
+  // ---- Dynamic footer counters -------------------------------------------
+  // claude's status footer lists live counters between "·" separators, e.g.
+  //   ⏸ manual mode on · 1 shell · ctrl+t to hide tasks · ← for agents · ↓ to manage
+  //   ⏸ manual mode on · 3 monitors · esc to interrupt · ↓ to manage
+  //   ⏸ manual mode on · ? for shortcuts · ← 3 agents
+  //   ⏸ manual mode on · PR #310
+  // Each pattern anchors on that chrome (the "· " separator / the "←" arrow),
+  // not the bare phrase, so ordinary conversation text about "4 shells" can't
+  // light the chip. The capture keeps the CLI's own singular/plural wording,
+  // so the chip reads exactly like the footer ("1 shell", "4 shells").
+  {
+    id: "shells",
+    label: "$1",
+    title: "Background shells running in this session ($1 in the CLI footer)",
+    pattern: /· (\d+ shells?)(?= ·|\s*$)/m,
+  },
+  {
+    id: "monitors",
+    label: "$1",
+    title: "Active Monitor watchers in this session ($1 in the CLI footer)",
+    pattern: /· (\d+ monitors?)(?= ·|\s*$)/m,
+  },
+  {
+    id: "bg-agents",
+    label: "$1",
+    title: "Background subagents running in this session ($1 in the CLI footer)",
+    pattern: /← (\d+ agents?)(?= ·|\s*$)/m,
+  },
+  {
+    id: "pr",
+    label: "$1",
+    title: "This session is linked to a GitHub pull request ($1 in the CLI footer)",
+    pattern: /· (PR #\d+)(?= ·|\s*$)/m,
+  },
 ];
 
 /**
  * Which badge ids match the given rendered screen lines. Pure so it's
- * unit-tested without a live PTY/log file.
+ * unit-tested without a live PTY/log file. A def whose pattern captured a
+ * group yields `id:capture` (e.g. "shells:4 shells") so the count travels
+ * with the id over the wire; static defs yield the bare id as before.
  */
 export function matchBadges(lines: string[], defs: BadgeDef[] = BADGE_DEFS): string[] {
   const text = lines.join("\n");
-  return defs.filter((d) => d.pattern.test(text)).map((d) => d.id);
+  return defs.flatMap((d) => {
+    const m = d.pattern.exec(text);
+    if (!m) return [];
+    return [m[1] !== undefined ? `${d.id}:${m[1]}` : d.id];
+  });
 }
 
 /**
@@ -72,5 +121,20 @@ export const TYPING_BADGE: BadgeDef = {
 };
 
 export function badgeDef(id: string, defs: BadgeDef[] = BADGE_DEFS): BadgeDef | undefined {
-  return defs.find((d) => d.id === id) ?? (id === TYPING_BADGE.id ? TYPING_BADGE : undefined);
+  // Dynamic ids carry their captured text after a ":" ("shells:4 shells") —
+  // strip it so the base def resolves.
+  const base = id.includes(":") ? id.slice(0, id.indexOf(":")) : id;
+  return defs.find((d) => d.id === base) ?? (base === TYPING_BADGE.id ? TYPING_BADGE : undefined);
+}
+
+/**
+ * Rendered chip text for a (possibly dynamic) badge id: resolves the def and
+ * substitutes `$1` in its label with the id's captured text. Unknown ids fall
+ * back to the raw id so a newer server's badge never renders blank.
+ */
+export function badgeLabel(id: string, defs: BadgeDef[] = BADGE_DEFS): string {
+  const def = badgeDef(id, defs);
+  if (!def) return id;
+  const arg = id.includes(":") ? id.slice(id.indexOf(":") + 1) : "";
+  return def.label.includes("$1") ? def.label.replace("$1", arg) : def.label;
 }

package/ts/notifyDaemon.spec.ts

@@ -91,10 +91,7 @@ describe("notifyd singleton lock", () => {
     expect(await acquireDaemonLock(() => true)).toBe(true);
     const owner = JSON.parse(await readFile(daemonLockOwnerPath(), "utf8"));
     // Rewrite the owner to a DIFFERENT, "alive" pid to simulate another daemon.
-    await writeFile(
-      daemonLockOwnerPath(),
-      JSON.stringify({ ...owner, pid: owner.pid + 1 }),
-    );
+    await writeFile(daemonLockOwnerPath(), JSON.stringify({ ...owner, pid: owner.pid + 1 }));
     expect(await acquireDaemonLock((pid) => pid === owner.pid + 1)).toBe(false);
   });
 });
@@ -139,10 +136,7 @@ describe("notifyd identity (status/stop safety)", () => {
   it("returns null for an INCOMPLETE owner missing started_at (I1)", async () => {
     await mkdir(daemonLockDir(), { recursive: true });
     // pid alive + fresh ts, but no started_at → identity incomplete, not trusted.
-    await writeFile(
-      daemonLockOwnerPath(),
-      JSON.stringify({ pid: process.pid, ts: Date.now() }),
-    );
+    await writeFile(daemonLockOwnerPath(), JSON.stringify({ pid: process.pid, ts: Date.now() }));
     expect(await daemonStatus()).toBeNull();
   });
 

package/ts/notifyDaemon.ts

@@ -18,17 +18,8 @@
 import { execFile } from "node:child_process";
 import { randomUUID } from "node:crypto";
 import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
-import {
-  type ChildObservation,
-  type RouterState,
-  stepRouter,
-} from "./notifyRouter.ts";
-import {
-  type NotifyEvent,
-  daemonLockDir,
-  daemonLockOwnerPath,
-  notifyDir,
-} from "./notifyInbox.ts";
+import { type ChildObservation, type RouterState, stepRouter } from "./notifyRouter.ts";
+import { type NotifyEvent, daemonLockDir, daemonLockOwnerPath, notifyDir } from "./notifyInbox.ts";
 import {
   appendEvent,
   gcInboxes,
@@ -303,7 +294,12 @@ async function writeOwner(): Promise<boolean> {
   try {
     await writeFile(
       tmp,
-      JSON.stringify({ pid: process.pid, started_at: daemonStartedAt, ts: Date.now(), token: daemonToken }),
+      JSON.stringify({
+        pid: process.pid,
+        started_at: daemonStartedAt,
+        ts: Date.now(),
+        token: daemonToken,
+      }),
     );
     await rename(tmp, daemonLockOwnerPath());
     return true;
@@ -321,7 +317,9 @@ async function writeOwner(): Promise<boolean> {
  * mkdir→writeOwner window of another daemon coming up), so two concurrent starts
  * can't both "win". The liveness predicate is injectable for tests.
  */
-export async function acquireDaemonLock(isAlive: (pid: number) => boolean = isPidAlive): Promise<boolean> {
+export async function acquireDaemonLock(
+  isAlive: (pid: number) => boolean = isPidAlive,
+): Promise<boolean> {
   // The lock dir lives under notify/ — ensure that exists first, else mkdir of
   // the lock throws ENOENT which must NOT be mistaken for "someone holds it".
   await mkdir(notifyDir(), { recursive: true }).catch(() => {});
@@ -414,20 +412,23 @@ export async function runDaemon(opts: DaemonOptions = {}): Promise<number> {
   // tick — many watched children, slow log I/O — can't let the heartbeat cross
   // OWNER_TTL and have another `watch` steal the lock as "stale" → double daemon.
   // Refresh well inside the TTL; cleared on shutdown.
-  const ownerBeat = setInterval(() => {
-    void (async () => {
-      // Refresh ONLY while the owner still carries OUR token. Any other value — a
-      // different token (superseded) OR null/absent (a new daemon's mkdir→write
-      // window) — means we no longer own it, so stop rather than clobber an
-      // unknown/absent owner. Atomic writeOwner means a null read is never our own
-      // write in flight.
-      if ((await readDaemonOwnerToken()) !== daemonToken) {
-        clearInterval(ownerBeat);
-        return;
-      }
-      await writeOwner();
-    })();
-  }, Math.max(1000, Math.floor(OWNER_TTL_MS / 3)));
+  const ownerBeat = setInterval(
+    () => {
+      void (async () => {
+        // Refresh ONLY while the owner still carries OUR token. Any other value — a
+        // different token (superseded) OR null/absent (a new daemon's mkdir→write
+        // window) — means we no longer own it, so stop rather than clobber an
+        // unknown/absent owner. Atomic writeOwner means a null read is never our own
+        // write in flight.
+        if ((await readDaemonOwnerToken()) !== daemonToken) {
+          clearInterval(ownerBeat);
+          return;
+        }
+        await writeOwner();
+      })();
+    },
+    Math.max(1000, Math.floor(OWNER_TTL_MS / 3)),
+  );
   if (typeof ownerBeat.unref === "function") ownerBeat.unref();
   const cleanup = async () => {
     running = false;
@@ -443,11 +444,7 @@ export async function runDaemon(opts: DaemonOptions = {}): Promise<number> {
   // Seed the router from prior inbox state — scoped to currently-watched parents
   // and guarded against pid reuse by the current registry snapshot.
   const watchedAtStart = new Set((await liveWatchers()).keys());
-  let prev = await reconcileFromInboxes(
-    host,
-    await liveChildrenSnapshot(),
-    watchedAtStart,
-  );
+  let prev = await reconcileFromInboxes(host, await liveChildrenSnapshot(), watchedAtStart);
   let ticks = 0;
   let emptySince: number | null = null;
   // Durable across ticks: edges whose append failed, retried until they land.
@@ -556,7 +553,9 @@ async function tickState(
       pendingRetry.set(retryKey(stored), stored);
       logger.warn(`[notifyd] append failed for parent ${stored.parent_pid} — queued for retry`);
     } else {
-      logger.warn(`[notifyd] retry queue full (${RETRY_CAP}) — dropping edge for parent ${stored.parent_pid}`);
+      logger.warn(
+        `[notifyd] retry queue full (${RETRY_CAP}) — dropping edge for parent ${stored.parent_pid}`,
+      );
     }
   }
   return { next, watcherCount };

package/ts/notifyInbox.spec.ts

@@ -58,7 +58,8 @@ describe("notifyInbox — NDJSON round-trip + torn-line tolerance", () => {
   });
 
   it("skips a torn final line from a mid-append writer", () => {
-    const text = serializeEvent(ev({ seq: 1 })) + "\n" + serializeEvent(ev({ seq: 2 })) + "\n{ \"seq\": 3, \"ed";
+    const text =
+      serializeEvent(ev({ seq: 1 })) + "\n" + serializeEvent(ev({ seq: 2 })) + '\n{ "seq": 3, "ed';
     const got = parseInboxText(text);
     expect(got.map((e) => e.seq)).toEqual([1, 2]);
   });

package/ts/notifyRouter.spec.ts

@@ -1,10 +1,6 @@
 import { describe, expect, it } from "vitest";
 import { classifyNeedsInput } from "./needsInput.ts";
-import {
-  type ChildObservation,
-  type RouterState,
-  stepRouter,
-} from "./notifyRouter.ts";
+import { type ChildObservation, type RouterState, stepRouter } from "./notifyRouter.ts";
 
 // Mirror the claude `needsInput`/`working` config (rs/default.config.yaml): the
 // menu cursor sits on a NUMBERED option, and a spinner marker means "working".
@@ -75,7 +71,11 @@ describe("notifyRouter — idle hysteresis (P1)", () => {
 
 describe("notifyRouter — needs_input", () => {
   it("emits immediately on entering needs_input, with the question", () => {
-    const r = step(new Map(), [child({ state: "needs_input", question: "Approve? 1.Yes 2.No" })], 0);
+    const r = step(
+      new Map(),
+      [child({ state: "needs_input", question: "Approve? 1.Yes 2.No" })],
+      0,
+    );
     expect(r.events).toHaveLength(1);
     expect(r.events[0]!.edge).toBe("needs_input");
     expect(r.events[0]!.question).toBe("Approve? 1.Yes 2.No");
@@ -167,11 +167,7 @@ describe("notifyRouter — idle-prompt fixture (P1 regression)", () => {
   });
 
   it("an ACTIVE menu (cursor on a number) still classifies as needs_input", () => {
-    const activeMenu = [
-      "  Do you want to proceed?",
-      "❯ 1. Yes",
-      "  2. No, keep planning",
-    ];
+    const activeMenu = ["  Do you want to proceed?", "❯ 1. Yes", "  2. No, keep planning"];
     expect(classifyNeedsInput(activeMenu, CFG)).not.toBeNull();
   });
 

package/ts/notifyStore.spec.ts

@@ -176,7 +176,10 @@ describe("notifyStore (fs)", () => {
     await mkdir(inboxDir(host), { recursive: true });
     // Simulate a crash between "reserve seq 5" and "append line": the counter
     // says 5, but the inbox only has 1..3 (4 and 5 are reserved gaps).
-    await writeFile(inboxPath(host, 700), [1, 2, 3].map((s) => JSON.stringify(baseEvent("idle", { seq: s }))).join("\n") + "\n");
+    await writeFile(
+      inboxPath(host, 700),
+      [1, 2, 3].map((s) => JSON.stringify(baseEvent("idle", { seq: s }))).join("\n") + "\n",
+    );
     await writeFile(seqPath(host, 700), "5");
     const next = await appendEvent(700, baseEvent("idle"));
     expect(next).toBe(6); // continues past the reserved gap, never reuses 4 or 5

package/ts/notifyStore.ts

@@ -138,10 +138,7 @@ async function atomicWrite(file: string, data: string): Promise<boolean> {
  * deliberately NO wall-clock backstop: elapsed wait time alone never steals, so a
  * live holder is inviolable.
  */
-export async function acquireLock(
-  lockDir: string,
-  staleMs = 30_000,
-): Promise<() => Promise<void>> {
+export async function acquireLock(lockDir: string, staleMs = 30_000): Promise<() => Promise<void>> {
   const ownerFile = path.join(lockDir, "owner");
   // A fencing token unique to THIS acquisition. Everything we do to the lock is
   // gated on the owner file still carrying our token — so if we were stale-stolen
@@ -194,15 +191,18 @@ export async function acquireLock(
       // window) — means we no longer own it, so we stop rather than clobber an
       // unknown/absent owner. Atomic writes above mean a null read is never just
       // our own write in flight. Refresh well inside staleMs; cleared on release.
-      const beat = setInterval(() => {
-        void (async () => {
-          if ((await readOwnerToken()) !== token) {
-            clearInterval(beat);
-            return;
-          }
-          await stampOwner();
-        })();
-      }, Math.max(500, Math.floor(staleMs / 3)));
+      const beat = setInterval(
+        () => {
+          void (async () => {
+            if ((await readOwnerToken()) !== token) {
+              clearInterval(beat);
+              return;
+            }
+            await stampOwner();
+          })();
+        },
+        Math.max(500, Math.floor(staleMs / 3)),
+      );
       if (typeof beat.unref === "function") beat.unref();
       return async () => {
         clearInterval(beat);
@@ -296,7 +296,11 @@ export async function listInboxParents(host: string): Promise<number[]> {
   return pids;
 }
 
-export async function getCursor(host: string, parentPid: number, consumer = "parent"): Promise<number> {
+export async function getCursor(
+  host: string,
+  parentPid: number,
+  consumer = "parent",
+): Promise<number> {
   const text = await readFile(cursorPath(host, parentPid, consumer), "utf8").catch(() => null);
   return parseCursor(text).seq;
 }

package/ts/serve.spec.ts

@@ -45,9 +45,9 @@ describe("isNoNodeExecError", () => {
   });
 
   it("matches Windows cmd output", () => {
-    expect(
-      isNoNodeExecError("'node' is not recognized as an internal or external command"),
-    ).toBe(true);
+    expect(isNoNodeExecError("'node' is not recognized as an internal or external command")).toBe(
+      true,
+    );
   });
 
   it("matches localized-then-normalized output (probe pins LC_ALL=C)", () => {
@@ -58,9 +58,7 @@ describe("isNoNodeExecError", () => {
 
   it("does not match a real native/glibc failure", () => {
     expect(
-      isNoNodeExecError(
-        "oxmgr: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.39' not found",
-      ),
+      isNoNodeExecError("oxmgr: /lib/x86_64-linux-gnu/libc.so.6: version `GLIBC_2.39' not found"),
     ).toBe(false);
     expect(isNoNodeExecError("")).toBe(false);
   });

package/ts/serve.ts

@@ -3,7 +3,18 @@ import { existsSync, renameSync, watch, writeFileSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { createHash, randomBytes, timingSafeEqual } from "crypto";
-import { arch, cpus, freemem, homedir, hostname, loadavg, platform, totalmem, uptime, userInfo } from "os";
+import {
+  arch,
+  cpus,
+  freemem,
+  homedir,
+  hostname,
+  loadavg,
+  platform,
+  totalmem,
+  uptime,
+  userInfo,
+} from "os";
 import path from "path";
 import yargs from "yargs";
 import {
@@ -400,9 +411,7 @@ function resolveDaemonManager(): DaemonManager | null {
 //   - npm: `npm prefix -g` prints the prefix; the bin lives at <prefix>/bin.
 async function globalBinDir(installer: string[]): Promise<string | null> {
   const isBun = installer[1] === "add";
-  const query = isBun
-    ? [installer[0]!, "pm", "bin", "-g"]
-    : [installer[0]!, "prefix", "-g"];
+  const query = isBun ? [installer[0]!, "pm", "bin", "-g"] : [installer[0]!, "prefix", "-g"];
   const p = Bun.spawn(query, { stdout: "pipe", stderr: "ignore" });
   if ((await p.exited) !== 0) return null;
   const out = (await new Response(p.stdout).text()).trim();
@@ -1292,7 +1301,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
         // by the console's HTML escaper.
         if (title) {
           // eslint-disable-next-line no-control-regex
-          title = title.replace(/[\x00-\x1f\x7f-\x9f]/g, "").slice(0, 256).trim() || null;
+          title =
+            title
+              .replace(/[\x00-\x1f\x7f-\x9f]/g, "")
+              .slice(0, 256)
+              .trim() || null;
         }
         titleCache.set(logFile, { size, mtimeMs, title });
         return title;
@@ -1311,7 +1324,8 @@ export async function cmdServe(rest: string[]): Promise<number> {
   // the SOURCE: secret-shaped lines are dropped to "···" and long credential-ish
   // blobs masked — the feed is token-gated, but tails travel to other rgui hosts.
   const previewCache = new Map<string, { size: number; mtimeMs: number; lines: string[] | null }>();
-  const SECRETISH = /(api[-_]?key|secret|token|password|passwd|bearer|authorization|private[-_]?key)\s*[=:]/i;
+  const SECRETISH =
+    /(api[-_]?key|secret|token|password|passwd|bearer|authorization|private[-_]?key)\s*[=:]/i;
   const logPreviewLines = async (logFile: string | null | undefined): Promise<string[] | null> => {
     if (!logFile) return null;
     try {
@@ -1860,7 +1874,10 @@ export async function cmdServe(rest: string[]): Promise<number> {
             category: "agent-yes",
             owner: `agent-yes:${hostname()}`,
             status: r.status,
-            parent: r.parent_pid && byWrapper.has(r.parent_pid) ? nid(byWrapper.get(r.parent_pid)!) : undefined,
+            parent:
+              r.parent_pid && byWrapper.has(r.parent_pid)
+                ? nid(byWrapper.get(r.parent_pid)!)
+                : undefined,
             pos: { x: (i % 8) * (NODE_W + 64), y: Math.floor(i / 8) * 480 },
             size: await sizeOf(r.pid),
             inputs: [textIn, envIn],
@@ -1887,7 +1904,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
           configPublic: {
             scope: "native-device",
             runtime: "native",
-            caps: { send: true, kill: true, spawn: true, spawnHook: hasSpawnHook(), provision: hasProvisionHook() },
+            caps: {
+              send: true,
+              kill: true,
+              spawn: true,
+              spawnHook: hasSpawnHook(),
+              provision: hasProvisionHook(),
+            },
           },
         } as unknown as (typeof nodes)[number]); // configPublic is envelope-legal but absent from the agent-node literal type
         const codex = records
@@ -1936,11 +1959,19 @@ export async function cmdServe(rest: string[]): Promise<number> {
           {
             kind: "rgui-federated-graph",
             schema: "org.rgui.graph.v1",
-            producer: { app: "ay", origin, deviceId: hostname(), label: `agent-yes fleet @ ${hostname()}` },
+            producer: {
+              app: "ay",
+              origin,
+              deviceId: hostname(),
+              label: `agent-yes fleet @ ${hostname()}`,
+            },
             revision: Date.now(),
             ts: Date.now(),
             graph: { nodes, edges },
-            capabilities: { nodeTypes: [...new Set(nodes.map((n) => n.type))], portTypes: ["text", "environment"] },
+            capabilities: {
+              nodeTypes: [...new Set(nodes.map((n) => n.type))],
+              portTypes: ["text", "environment"],
+            },
           },
           { headers: { "Access-Control-Allow-Origin": "*" } },
         );
@@ -2205,7 +2236,12 @@ export async function cmdServe(rest: string[]): Promise<number> {
                   // verify before demoting: give it 100ms to fire, and only
                   // then demote this stream to the fast poll it would have used
                   // had watch() failed outright.
-                  if (viaPoll && watcher && !demoteCheck && Date.now() - lastWatcherFireAt > POLL_WATCHED - 50) {
+                  if (
+                    viaPoll &&
+                    watcher &&
+                    !demoteCheck &&
+                    Date.now() - lastWatcherFireAt > POLL_WATCHED - 50
+                  ) {
                     const suspectAt = Date.now();
                     demoteCheck = setTimeout(() => {
                       demoteCheck = null;
@@ -2673,7 +2709,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
         // Allowlist gate — only when a provision hook did NOT already gate this
         // (a configured hook overrides the allowlist). The fork runs setup-repo.sh
         // (code exec), the same risk surface as `from`.
-        if (!forkHook.ran && result.spec && !isProvisionAllowed(result.spec.owner, result.spec.repo))
+        if (
+          !forkHook.ran &&
+          result.spec &&
+          !isProvisionAllowed(result.spec.owner, result.spec.repo)
+        )
           return new Response(
             `forking '${result.spec.owner}/${result.spec.repo}' is not allowed — add the owner ` +
               `to provisionAllowlist in ~/.agent-yes/config.json (or "*" to allow all), ` +
@@ -2912,7 +2952,11 @@ export async function cmdServe(rest: string[]): Promise<number> {
         return Response.json(share);
       } catch (e) {
         const msg = (e as Error).message;
-        const status = /too many active shares/.test(msg) ? 409 : /no agent matched|no stable/.test(msg) ? 404 : 500;
+        const status = /too many active shares/.test(msg)
+          ? 409
+          : /no agent matched|no stable/.test(msg)
+            ? 404
+            : 500;
         return new Response(msg, { status });
       }
     }
@@ -2947,7 +2991,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
       try {
         const { ensureExposure } = await import("./expose.ts");
         const h = await ensureExposure(port, body.relay);
-        return Response.json({ id: h.id, port: h.port, url: h.url, claim: h.mintClaim(), createdAt: h.createdAt });
+        return Response.json({
+          id: h.id,
+          port: h.port,
+          url: h.url,
+          claim: h.mintClaim(),
+          createdAt: h.createdAt,
+        });
       } catch (e) {
         return new Response(`expose failed: ${(e as Error).message}`, { status: 502 });
       }
@@ -3000,7 +3050,10 @@ export async function cmdServe(rest: string[]): Promise<number> {
   const RGUI_CSP = CONSOLE_CSP.replace("frame-ancestors 'none'", "frame-ancestors *")
     // #feed= mirrors fetch OTHER rgui hosts' envelopes (federation consumers):
     // otoji.org in prod, localhost/loopback for wrangler-dev feeds
-    .replace("connect-src 'self'", "connect-src 'self' https://otoji.org http://127.0.0.1:* http://localhost:*");
+    .replace(
+      "connect-src 'self'",
+      "connect-src 'self' https://otoji.org http://127.0.0.1:* http://localhost:*",
+    );
   const serveUiFile = async (name: string, type: string, csp = CONSOLE_CSP): Promise<Response> => {
     try {
       const buf = await readFile(path.join(uiDir, name));
@@ -3046,8 +3099,7 @@ export async function cmdServe(rest: string[]): Promise<number> {
       return serveUiFile("sw.js", "text/javascript; charset=utf-8");
     if (req.method === "GET" && p === "/manifest.webmanifest")
       return serveUiFile("manifest.webmanifest", "application/manifest+json");
-    if (req.method === "GET" && p === "/icon.svg")
-      return serveUiFile("icon.svg", "image/svg+xml");
+    if (req.method === "GET" && p === "/icon.svg") return serveUiFile("icon.svg", "image/svg+xml");
     if (req.method === "GET" && p === "/favicon.ico") return new Response(null, { status: 204 });
     return apiFetch(req);
   };