agent-yes 1.263.0 → 1.264.0

package/ts/subcommands.spec.ts

@@ -2670,124 +2670,11 @@ describe("subcommands.cmdWhoami", () => {
     expect(text).toMatch(/agent {5}claude #\d+ {2}\(agent_id aaaa0000bbbb\)/);
     expect(text).toMatch(/reply {5}ay send aaaa0000bbbb/);
     expect(text).toMatch(
-      /<ay-msg from claude #\d+ @ \/repo\/alpha — reply: ay send aaaa0000bbbb "\.\.\.">/,
+      /<ay-msg from claude [A-Za-z0-9._-]+@[A-Za-z0-9._-]+:\/repo\/alpha#\d+ — reply: ay send aaaa0000bbbb "\.\.\.">/,
     );
   });
 });
 
-describe("subcommands.cmdRole", () => {
-  async function registerAgent(over: Record<string, unknown> = {}) {
-    const { appendGlobalPid } = await import("./globalPidIndex.ts");
-    await appendGlobalPid({
-      pid: 910001,
-      cli: "claude",
-      prompt: null,
-      cwd: "/repo/lane",
-      log_file: null,
-      status: "active",
-      exit_code: null,
-      exit_reason: null,
-      started_at: Date.now(),
-      wrapper_pid: 515151,
-      agent_id: "eeee0000ffff",
-      ...over,
-    } as any);
-  }
-
-  function capture() {
-    const out: string[] = [];
-    const err: string[] = [];
-    const origOut = process.stdout.write.bind(process.stdout);
-    const origErr = process.stderr.write.bind(process.stderr);
-    (process.stdout as any).write = (s: any) => (out.push(String(s)), true);
-    (process.stderr as any).write = (s: any) => (err.push(String(s)), true);
-    return {
-      out,
-      err,
-      restore() {
-        process.stdout.write = origOut;
-        process.stderr.write = origErr;
-      },
-    };
-  }
-
-  async function withAgentEnv<T>(fn: () => Promise<T>): Promise<T> {
-    const saved = process.env.AGENT_YES_PID;
-    process.env.AGENT_YES_PID = "515151";
-    try {
-      return await fn();
-    } finally {
-      if (saved === undefined) delete process.env.AGENT_YES_PID;
-      else process.env.AGENT_YES_PID = saved;
-    }
-  }
-
-  it("self get/set/clear round-trips via agent context", async () => {
-    const { runSubcommand } = await loadModule();
-    await registerAgent();
-    await withAgentEnv(async () => {
-      let cap = capture();
-      try {
-        expect(await runSubcommand(["bun", "cli.js", "role", "pm"])).toBe(0);
-        expect(cap.out.join("")).toContain('role set to "pm"');
-      } finally {
-        cap.restore();
-      }
-      cap = capture();
-      try {
-        expect(await runSubcommand(["bun", "cli.js", "role"])).toBe(0);
-        expect(cap.out.join("")).toBe("pm\n");
-        expect(await runSubcommand(["bun", "cli.js", "role", "--clear"])).toBe(0);
-        expect(await runSubcommand(["bun", "cli.js", "role"])).toBe(0);
-        expect(cap.out.join("")).toContain("role cleared");
-      } finally {
-        cap.restore();
-      }
-    });
-  });
-
-  it("keyword set and keyword clear work from a human shell", async () => {
-    const { runSubcommand } = await loadModule();
-    await registerAgent();
-    let cap = capture();
-    try {
-      expect(await runSubcommand(["bun", "cli.js", "role", "910001", "crm"])).toBe(0);
-      expect(cap.out.join("")).toContain('role set to "crm"');
-      expect(await runSubcommand(["bun", "cli.js", "role", "910001", "--clear"])).toBe(0);
-      expect(cap.out.join("")).toContain("role cleared");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  it("rejects header-forging role values", async () => {
-    const { runSubcommand } = await loadModule();
-    await registerAgent();
-    const cap = capture();
-    try {
-      expect(await runSubcommand(["bun", "cli.js", "role", "910001", "a b>"])).toBe(1);
-      expect(cap.err.join("")).toContain("invalid role");
-    } finally {
-      cap.restore();
-    }
-  });
-
-  it("errors without agent context when no keyword is given", async () => {
-    const { runSubcommand } = await loadModule();
-    const saved = process.env.AGENT_YES_PID;
-    delete process.env.AGENT_YES_PID;
-    const cap = capture();
-    try {
-      expect(await runSubcommand(["bun", "cli.js", "role"])).toBe(1);
-      expect(await runSubcommand(["bun", "cli.js", "role", "somename"])).toBe(1);
-      expect(cap.err.join("")).toContain("no agent context");
-    } finally {
-      cap.restore();
-      if (saved !== undefined) process.env.AGENT_YES_PID = saved;
-    }
-  });
-});
-
 describe("subcommands.cmdSend double-envelope warning", () => {
   const itUnix = process.platform === "linux" || process.platform === "darwin";
 
@@ -2859,7 +2746,7 @@ describe("subcommands.cmdSend double-envelope warning", () => {
         const buf = Buffer.alloc(8192);
         const n = fs.readSync(rdwrFd, buf, 0, buf.length, null);
         const received = buf.subarray(0, n).toString();
-        expect(received).toMatch(/^<ay-msg [0-9a-f]{8} from claude #900001 @ /);
+        expect(received).toMatch(/^<ay-msg [0-9a-f]{8} from claude [A-Za-z0-9._-]+@[A-Za-z0-9._-]+:\/repo\/beta#900001 — /);
         expect(received).toContain("<ay-msg deadbeef");
         fs.closeSync(rdwrFd);
       } finally {
@@ -2933,16 +2820,20 @@ describe("subcommands.cmdSend double-envelope warning", () => {
     }
   });
 
-  it.skipIf(!itUnix)("a sender with a role gets it rendered into the envelope header", async () => {
+  it.skipIf(!itUnix)("the envelope header carries the standardized identity", async () => {
     const { runSubcommand } = await loadModule();
     const { appendGlobalPid } = await import("./globalPidIndex.ts");
     const { spawnSync } = await import("child_process");
     const tmp = await mkdtemp(path.join(tmpdir(), "ay-fifo-"));
     try {
-      const fifo = path.join(tmp, "role.fifo");
+      const fifo = path.join(tmp, "ident.fifo");
       if (spawnSync("mkfifo", [fifo]).status !== 0) return;
       const fs = await import("fs");
       const rdwrFd = fs.openSync(fifo, fs.constants.O_RDWR);
+      // Sender cwd IS a git checkout, so the identity carries its branch.
+      const senderCwd = path.join(tmp, "sender-repo");
+      await mkdir(path.join(senderCwd, ".git"), { recursive: true });
+      await writeFile(path.join(senderCwd, ".git", "HEAD"), "ref: refs/heads/crm-lane\n");
       await appendGlobalPid({
         pid: process.pid,
         cli: "claude",
@@ -2959,7 +2850,7 @@ describe("subcommands.cmdSend double-envelope warning", () => {
         pid: 900001,
         cli: "claude",
         prompt: null,
-        cwd: "/repo/beta",
+        cwd: senderCwd,
         log_file: null,
         status: "active",
         exit_code: null,
@@ -2967,7 +2858,6 @@ describe("subcommands.cmdSend double-envelope warning", () => {
         started_at: Date.now(),
         wrapper_pid: 424242,
         agent_id: "cccc0000dddd",
-        role: "crm",
       });
       const savedAyPid = process.env.AGENT_YES_PID;
       process.env.AGENT_YES_PID = "424242";
@@ -2991,8 +2881,9 @@ describe("subcommands.cmdSend double-envelope warning", () => {
       const buf = Buffer.alloc(4096);
       const n = fs.readSync(rdwrFd, buf, 0, buf.length, null);
       const received = buf.subarray(0, n).toString();
+      // <user>@<host>:<path>:<branch>#<pid> — reply targets the agent_id.
       expect(received).toMatch(
-        /^<ay-msg [0-9a-f]{8} from claude #900001 \(crm\) @ \/repo\/beta — reply: ay send cccc0000dddd "\.\.\.">/,
+        /^<ay-msg [0-9a-f]{8} from claude [A-Za-z0-9._-]+@[A-Za-z0-9._-]+:.+:crm-lane#900001 — reply: ay send cccc0000dddd "\.\.\.">/,
       );
       fs.closeSync(rdwrFd);
     } finally {

package/ts/subcommands.ts

@@ -18,12 +18,8 @@ import { fileURLToPath } from "node:url";
 import ms from "ms";
 import { homedir } from "os";
 import path from "path";
-import {
-  type GlobalPidRecord,
-  readGlobalPids,
-  sanitizeRole,
-  updateGlobalPidStatus,
-} from "./globalPidIndex.ts";
+import { type GlobalPidRecord, readGlobalPids, updateGlobalPidStatus } from "./globalPidIndex.ts";
+import { formatIdentity } from "./identity.ts";
 import { buildAgentForest, flattenForest } from "./agentTree.ts";
 import { parseTaskCounts, type TaskCounts } from "./todoParse.ts";
 import { agentYesHome } from "./agentYesHome.ts";
@@ -328,7 +324,8 @@ async function cmdWhoami(rest: string[]): Promise<number> {
   const ageMin = Math.max(0, Math.round((Date.now() - self.started_at) / 60_000));
   const lines = [
     `agent     ${self.cli} #${self.pid}${self.agent_id ? `  (agent_id ${self.agent_id})` : ""}`,
-    `role      ${self.role ?? "-  (set with: ay role <name>)"}`,
+    `identity  ${formatIdentity({ cwd: self.cwd, pid: self.pid })}`,
+    `title     ${self.title ?? "-"}`,
     `state     ${state}${question ? ` — ${question}` : ""}`,
     `cwd       ${self.cwd}`,
     `started   ${new Date(self.started_at).toISOString()}  (${ageMin}m ago)`,
@@ -336,7 +333,7 @@ async function cmdWhoami(rest: string[]): Promise<number> {
     `log       ${self.log_file ?? "-"}`,
     `fifo      ${self.fifo_file ?? "-"}`,
     `reply     ${reply} "..."`,
-    `envelope  <ay-msg from ${self.cli} #${self.pid}${self.role ? ` (${self.role})` : ""} @ ${self.cwd} — reply: ${reply} "...">…</ay-msg>`,
+    `envelope  <ay-msg from ${self.cli} ${formatIdentity({ cwd: self.cwd, pid: self.pid })} — reply: ${reply} "...">…</ay-msg>`,
   ];
   process.stdout.write(lines.join("\n") + "\n");
   return 0;
@@ -387,7 +384,7 @@ async function readLocalTsPids(cwd: string): Promise<GlobalPidRecord[]> {
     exit_code: d.exitCode ?? null,
     exit_reason: d.exitReason ?? null,
     started_at: d.startedAt ?? 0,
-    role: d.role ?? null,
+    title: d.title ?? null,
   }));
 }
 
@@ -422,7 +419,6 @@ const SUBCOMMANDS = new Set([
   "head",
   "send",
   "msgs",
-  "role",
   "key",
   "select",
   "spawn",
@@ -593,8 +589,6 @@ export async function runSubcommand(argv: string[]): Promise<number | null> {
         return await cmdSend(rest);
       case "msgs":
         return await cmdMsgs(rest);
-      case "role":
-        return await cmdRole(rest);
       case "key":
         return await cmdKey(rest);
       case "select":
@@ -815,7 +809,6 @@ export async function cmdHelp(managerCommands = true): Promise<number> {
       `  ay head <keyword>                   first N lines\n` +
       `  ay send <keyword> <msg>             send a message (keyword '.' = agent in this cwd)\n` +
       `  ay msgs [keyword] [--in|--out]      inter-agent message log (sent + received)\n` +
-      `  ay role [name] | ay role <kw> <name>  lane/role name shown in the send envelope\n` +
       `  ay ch mk|join|send|read|tail <topic>  local-first E2E channels: AI ↔ humans on a topic (ay ch help)\n` +
       `  ay term embed <pid>                 <script> to embed a live read-only agent terminal in a page (ay term help)\n` +
       `  ay widget ls | read selection|dom   read an opted-in page widget's context (selection/DOM) (ay widget help)\n` +
@@ -3429,13 +3422,13 @@ async function cmdSend(rest: string[]): Promise<number> {
   let nonce: string | undefined;
   if (sender.agent && !isSlashCommand(body) && !raw) {
     nonce = randomBytes(4).toString("hex");
-    // The sender's self-declared role ("pm", "crm", …) rides along when set —
-    // recipients read dozens of these a day and a pid/cwd doesn't carry the
-    // lane name (cwd → role isn't always derivable). sanitizeRole guarantees
-    // the value can't forge header syntax.
-    const senderRole = sanitizeRole(sender.agent.role);
-    const roleTag = senderRole ? ` (${senderRole})` : "";
-    prefix = `<ay-msg ${nonce} from ${sender.agent.cli} #${sender.agent.pid}${roleTag} @ ${shortenPath(sender.agent.cwd)} — reply: ay send ${replyTarget} "...">\n`;
+    // The standardized identity (<user>@<host>:<path>:<branch>#<pid>) names the
+    // sender in one token: the branch usually carries the lane name for free
+    // (worktree checkouts name their purpose), so recipients don't translate
+    // cwd/pid into a role by hand. Every segment is clamped to a header-safe
+    // charset in identity.ts — the open tag is not nonce-protected.
+    const identity = formatIdentity({ cwd: sender.agent.cwd, pid: sender.agent.pid });
+    prefix = `<ay-msg ${nonce} from ${sender.agent.cli} ${identity} — reply: ay send ${replyTarget} "...">\n`;
     suffix = `\n</ay-msg ${nonce}>`;
     // A body that itself starts with an <ay-msg …> header is usually an agent
     // hand-wrapping what this send is about to wrap again — the recipient then
@@ -3516,7 +3509,6 @@ async function cmdSend(rest: string[]): Promise<number> {
             cli: sender.agent.cli,
             cwd: sender.agent.cwd,
             agent_id: sender.agent.agent_id,
-            role: sender.agent.role ?? undefined,
           }
         : null,
       to: {
@@ -3524,7 +3516,6 @@ async function cmdSend(rest: string[]): Promise<number> {
         cli: record.cli,
         cwd: record.cwd,
         agent_id: record.agent_id,
-        role: record.role ?? undefined,
       },
       body,
       code: trailing === "\r" ? undefined : codeName,
@@ -3696,87 +3687,6 @@ async function cmdMsgs(rest: string[]): Promise<number> {
   return 0;
 }
 
-/**
- * `ay role [name]` / `ay role <keyword> <name>` — read or set an agent's
- * self-declared lane/role name ("pm", "crm", …). The role rides in the
- * `ay send` envelope header (`from claude #123 (pm) @ …`) so recipients don't
- * translate cwd/pid into a lane by hand — the emergent `[pm→qa]` body prefixes
- * exist exactly because the envelope lacked this. With no args: print the
- * calling agent's role. With one arg: set the calling agent's role (requires
- * agent context). With two args: resolve the keyword and set that agent's role.
- * `--clear` removes it. Roles are clamped by sanitizeRole (they render into the
- * non-nonce-protected open tag).
- */
-const ROLE_RESOLVE_OPTS: CommonOpts = {
-  all: false,
-  active: false,
-  cwdScope: null,
-  latest: false,
-  json: false,
-};
-
-async function cmdRole(rest: string[]): Promise<number> {
-  const y = yargs(rest)
-    .usage('Usage: ay role [name] | ay role <keyword> <name> | ay role [keyword] --clear')
-    .option("clear", { type: "boolean", default: false, description: "Remove the role" })
-    .help(false)
-    .version(false)
-    .exitProcess(false);
-  const argv = await y.parseAsync();
-  const args = argv._.slice(0).map(String);
-
-  // Figure out target + new value from arity: 0 args = self get (or self clear),
-  // 1 arg = self set (or keyword clear), 2 args = keyword set.
-  let target: GlobalPidRecord | null = null;
-  let newRole: string | undefined;
-  if (args.length === 2) {
-    target = await resolveOne(args[0]!, ROLE_RESOLVE_OPTS);
-    newRole = args[1]!;
-  } else if (args.length === 1 && argv.clear) {
-    target = await resolveOne(args[0]!, ROLE_RESOLVE_OPTS);
-  } else if (args.length === 1) {
-    target = await resolveSender();
-    if (!target) {
-      process.stderr.write(
-        "ay role: no agent context (AGENT_YES_PID unset or unregistered) — from a human shell, name the agent: ay role <keyword> <name>\n",
-      );
-      return 1;
-    }
-    newRole = args[0]!;
-  } else {
-    target = await resolveSender();
-    if (!target) {
-      process.stderr.write(
-        "ay role: no agent context — from a human shell, name the agent: ay role <keyword> [<name>|--clear]\n",
-      );
-      return 1;
-    }
-  }
-
-  if (newRole === undefined && !argv.clear) {
-    process.stdout.write(`${target.role ?? ""}\n`);
-    return 0;
-  }
-
-  let role: string | null = null;
-  if (!argv.clear) {
-    role = sanitizeRole(newRole);
-    if (!role) {
-      process.stderr.write(
-        `ay role: invalid role ${JSON.stringify(newRole)} — use 1-32 chars of [A-Za-z0-9._-]\n`,
-      );
-      return 1;
-    }
-  }
-  await updateGlobalPidStatus(target.pid, { role });
-  process.stdout.write(
-    role
-      ? `pid ${target.pid} (${target.cli}): role set to "${role}" — envelopes now read: from ${target.cli} #${target.pid} (${role}) @ ${shortenPath(target.cwd)}\n`
-      : `pid ${target.pid} (${target.cli}): role cleared\n`,
-  );
-  return 0;
-}
-
 // Resolve a keyword to one agent and return it with a writable FIFO, or throw
 // with the same guidance cmdSend gives. Shared by `ay key` / `ay select`.
 async function resolveWritableAgent(keyword: string, opts: CommonOpts): Promise<GlobalPidRecord> {

package/ts/titleScanner.spec.ts

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { TitlePublisher, TitleScanner } from "./titleScanner.ts";
+
+describe("TitleScanner", () => {
+  it("parses OSC 0 terminated by BEL", () => {
+    const s = new TitleScanner();
+    expect(s.feed("\x1b]0;✳ fixing tests\x07")).toBe("✳ fixing tests");
+  });
+
+  it("parses OSC 2 terminated by ST (ESC \\)", () => {
+    const s = new TitleScanner();
+    expect(s.feed("\x1b]2;my task\x1b\\")).toBe("my task");
+  });
+
+  it("survives a chunk split mid-sequence", () => {
+    const s = new TitleScanner();
+    expect(s.feed("text \x1b]0;ha")).toBeNull();
+    expect(s.feed("lf done\x07 more")).toBe("half done");
+  });
+
+  it("returns the last title when a chunk has several", () => {
+    const s = new TitleScanner();
+    expect(s.feed("\x1b]0;one\x07\x1b]2;two\x07")).toBe("two");
+  });
+
+  it("ignores icon-only and unrelated OSC sequences", () => {
+    const s = new TitleScanner();
+    expect(s.feed("\x1b]1;icon\x07\x1b]52;c;YWJj\x07\x1b]133;A\x07")).toBeNull();
+  });
+
+  it("ignores CSI colors and plain text", () => {
+    const s = new TitleScanner();
+    expect(s.feed("plain \x1b[31mred\x1b[0m text")).toBeNull();
+  });
+
+  it("caps runaway titles and resyncs", () => {
+    const s = new TitleScanner();
+    expect(s.feed(`\x1b]0;${"x".repeat(2000)}\x07`)).toBeNull();
+    expect(s.feed("\x1b]0;ok\x07")).toBe("ok");
+  });
+
+  it("strips control chars and rejects empty titles", () => {
+    const s = new TitleScanner();
+    expect(s.feed("\x1b]0;a\tb\x07")).toBe("ab");
+    expect(s.feed("\x1b]0;\x07")).toBeNull();
+    expect(s.feed("\x1b]0;   \x07")).toBeNull();
+  });
+});
+
+describe("TitlePublisher", () => {
+  it("writes on change, dedupes, and rate-limits within the window", () => {
+    const writes: string[] = [];
+    const p = new TitlePublisher((t) => writes.push(t), 2000);
+    p.observe("a");
+    expect(writes).toEqual(["a"]); // first write is immediate
+    p.observe("a");
+    expect(writes).toEqual(["a"]); // unchanged — no write
+    p.observe("b");
+    expect(writes).toEqual(["a"]); // changed but throttled
+    p.poll(Date.now() + 2500); // window elapsed — pending title lands
+    expect(writes).toEqual(["a", "b"]);
+    p.poll(Date.now() + 5000);
+    expect(writes).toEqual(["a", "b"]); // nothing pending — no write
+  });
+});

package/ts/titleScanner.ts

@@ -0,0 +1,137 @@
+/**
+ * Incremental scanner for terminal-title escapes (OSC 0/2) in the child CLI's
+ * PTY stream — the TS-runtime mirror of rs/src/title_scanner.rs; keep the two
+ * in sync.
+ *
+ * Coding-agent CLIs (claude, opencode, codex) continuously set the terminal
+ * title to a summary of what they are doing (`ESC ] 0 ; <title> BEL`, also
+ * terminated by `ESC \`). The wrapper observes the stream anyway, so scanning
+ * it yields a live "what is this agent doing" label for free — surfaced as
+ * `title` in the pid registry and shown by `ay whoami` / `ay ls --json`.
+ *
+ * Fed arbitrary chunk boundaries: a sequence split across reads still parses.
+ * The scanner only observes — it never modifies the stream.
+ */
+
+/** A title longer than this is a runaway OSC without terminator — discard. */
+const MAX_TITLE_LEN = 512;
+/** What we store/display. */
+const STORED_TITLE_LEN = 256;
+
+const enum State {
+  Ground,
+  Esc,
+  OscParam,
+  OscTitle,
+  OscOther,
+  OscTitleEsc,
+  OscOtherEsc,
+}
+
+export class TitleScanner {
+  private state = State.Ground;
+  private param = "";
+  private title = "";
+
+  /** Feed one output chunk; returns the LAST complete title in it, if any. */
+  feed(chunk: string): string | null {
+    let found: string | null = null;
+    for (const c of chunk) {
+      switch (this.state) {
+        case State.Ground:
+          if (c === "\x1b") this.state = State.Esc;
+          break;
+        case State.Esc:
+          if (c === "]") {
+            this.param = "";
+            this.state = State.OscParam;
+          } else if (c !== "\x1b") {
+            this.state = State.Ground;
+          }
+          break;
+        case State.OscParam:
+          if (c >= "0" && c <= "9" && this.param.length < 4) {
+            this.param += c;
+          } else if (c === ";") {
+            // OSC 0 (icon+title) and 2 (title) carry the window title; OSC 1
+            // is icon-only and everything else (8, 52, 133, …) is unrelated.
+            if (this.param === "0" || this.param === "2") {
+              this.title = "";
+              this.state = State.OscTitle;
+            } else {
+              this.state = State.OscOther;
+            }
+          } else if (c === "\x07") {
+            this.state = State.Ground;
+          } else if (c === "\x1b") {
+            this.state = State.OscOtherEsc;
+          } else {
+            this.state = State.OscOther;
+          }
+          break;
+        case State.OscTitle:
+          if (c === "\x07") {
+            found = cleanTitle(this.title);
+            this.state = State.Ground;
+          } else if (c === "\x1b") {
+            this.state = State.OscTitleEsc;
+          } else if (this.title.length >= MAX_TITLE_LEN) {
+            this.state = State.OscOther; // runaway — drop and resync
+          } else {
+            this.title += c;
+          }
+          break;
+        case State.OscTitleEsc:
+          if (c === "\\") found = cleanTitle(this.title);
+          this.state = State.Ground; // a bare ESC aborts the OSC either way
+          break;
+        case State.OscOther:
+          if (c === "\x07") this.state = State.Ground;
+          else if (c === "\x1b") this.state = State.OscOtherEsc;
+          break;
+        case State.OscOtherEsc:
+          this.state = State.Ground;
+          break;
+      }
+    }
+    return found || null;
+  }
+}
+
+/** Strip control chars (they can't be typed into a title bar) and clamp. */
+function cleanTitle(raw: string): string {
+  // eslint-disable-next-line no-control-regex
+  const trimmed = raw.replace(/[\x00-\x1f\x7f]/g, "").trim();
+  return trimmed.slice(0, STORED_TITLE_LEN);
+}
+
+/**
+ * Change-gated + rate-limited publisher: registry writes take the
+ * cross-runtime lock, while claude retitles every few seconds — the steady
+ * state must cost zero writes, and a retitle burst collapses to one write per
+ * window. Call `poll()` from any recurring point in the run loop so the final
+ * title still lands within a window after the CLI goes quiet.
+ */
+export class TitlePublisher {
+  private latest: string | null = null;
+  private written: string | null = null;
+  private writtenAt = 0;
+
+  constructor(
+    private readonly write: (title: string) => void,
+    private readonly minIntervalMs = 2_000,
+  ) {}
+
+  observe(title: string): void {
+    this.latest = title;
+    this.poll();
+  }
+
+  poll(now: number = Date.now()): void {
+    if (this.latest === null || this.latest === this.written) return;
+    if (now - this.writtenAt < this.minIntervalMs) return;
+    this.write(this.latest);
+    this.written = this.latest;
+    this.writtenAt = now;
+  }
+}

package/dist/SUPPORTED_CLIS--5E9wO4L.js

@@ -1,11 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-BTLZ3PAb.js";
-import "./ts-BSHR_dga.js";
-import "./todoAutomation-BQRW614S.js";
-import "./JsonlStore-CPGIR0Wy.js";
-import "./globalPidIndex-pwp7Vb7o.js";
-import "./pidStore-DfSm1jog.js";
-import "./messageLog-BYFwioFY.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DjFlWHpg.js";
-
-export { SUPPORTED_CLIS };

package/dist/globalPidIndex-CHA__9Xf.js

@@ -1,4 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import { a as sanitizeRole, i as readGlobalPids, n as maybeCompactGlobalPids, o as updateGlobalPidStatus, r as pruneOldLogs, t as appendGlobalPid } from "./globalPidIndex-pwp7Vb7o.js";
-
-export { readGlobalPids };

package/dist/pidStore-1PQ4ARnh.js

@@ -1,6 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./JsonlStore-CPGIR0Wy.js";
-import "./globalPidIndex-pwp7Vb7o.js";
-import { t as PidStore } from "./pidStore-DfSm1jog.js";
-
-export { PidStore };

package/dist/spawnGate-DbSHnfqA.js

@@ -1,5 +0,0 @@
-import "./logger-CDIsZ-Pp.js";
-import "./globalPidIndex-pwp7Vb7o.js";
-import { i as waitForSpawnCapacity, n as spawnGateEnabled, r as spawnRejectionReason, t as memAvailableMb } from "./spawnGate-D-68B907.js";
-
-export { waitForSpawnCapacity };

package/dist/trayApp-DrdktFnW.js

@@ -1,5 +0,0 @@
-import "./versionChecker-BTLZ3PAb.js";
-import "./rustBinary-Borvwmya.js";
-import { a as trayHiddenMarker, i as launchTray, n as hasDesktop, r as isTrayHidden, t as cmdTray } from "./trayApp-CjB5QhdV.js";
-
-export { cmdTray };