roger-roger 0.1.4 → 0.1.8

package/README.md

@@ -97,7 +97,7 @@ There is no always-on service. `ask` starts a small watcher process, and one wat
 - **Talk to an agent**: write "sage, rerun the tests" (or "hey sage rerun the tests", or "sage: ..."). With one agent running, a plain message goes to it. With several, but only one of them listening, it goes to that one and Slack says so, with a button to redirect it. With several, the bot asks which, with a button per agent — and remembers your answer for that thread.
 - **You can hear who it is**: a spoken line starts with the agent's name — "Amber here.", "This is Rose.", "Jade speaking." — so three agents sharing one pair of speakers stay tellable apart (`setup --say-who off`).
 - **Reachable while idle**: an agent that has finished can run `listen` in the background instead of going quiet. It costs nothing to wait, and when you write, it wakes up and answers. Slack shows 👀 when an agent is listening and 💤 when your message is saved for one that isn't, so you always know which.
-- **In the tray**: `tray install` puts an icon in the system tray, started with the daemon from then on (`tray start` starts it straight away; `setup --tray off` stops it starting by itself) — every agent at a glance, a translucent panel on click, snooze on right-click. It reads the same state the daemon already keeps and runs ordinary commands, so it can be closed, killed or never installed and nothing else changes.
+- **In the tray**: `tray install` puts an icon in the system tray, started with the daemon from then on (`tray start` starts it straight away; `setup --tray off` stops it starting by itself) — every agent at a glance, a translucent panel on click, snooze on right-click, a Stop button while a voice is speaking (`roger-roger hush` from a terminal), and a log of who said what lately: every notification and question from the agents, and every message and answer from you, per agent or all together. It reads the same state the daemon already keeps and runs ordinary commands, so it can be closed, killed or never installed and nothing else changes.
 - **Questions asked in the terminal**: when the agent asks you something with its own question tool (Claude Code's question dialog, OpenCode's question tool, Codex's `request_user_input`) or wants a plan approved, it's stuck until you answer and can't tell you itself. `hooks install` hooks into each of those agents it finds: once the question has gone unanswered for a little while, it arrives in Slack with its options, and when you answer in the terminal the message turns into your answer. Claude Code gets three hooks in `~/.claude/settings.json`; OpenCode a small plugin in `~/.config/opencode/plugins/`; Codex three hooks in `~/.codex/hooks.json`, which you trust once in Codex's `/hooks`. Claude Code knows when you've stopped typing; OpenCode and Codex don't, so they wait 20 seconds first (`setup --terminal-wait`). `setup --permission-pings on` does the same for ordinary permission prompts. `hooks uninstall` takes it all out again.
 - **Quiet hours**: `setup --quiet-hours 22:00-08:00` mutes sound and speech overnight. It's off by default.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roger-roger",
-  "version": "0.1.4",
+  "version": "0.1.8",
   "description": "Bring yourself back to the conversation: your coding agents reach you by Slack, a sound or a spoken line when they finish, get stuck, or need a decision, and you answer from your phone.",
   "type": "module",
   "bin": {

package/skills/roger-roger/SKILL.md

@@ -25,7 +25,7 @@ Every command prints a single JSON object.
 
 **Your name.** The daemon gives every agent session a short colour nickname — 🌿 sage, 🌹 rose, 🍇 plum — shown on all your Slack messages with a matching colour bar down their edge. That is how the user tells three agents apart and how they address you: "sage, rerun the tests". `sessions` lists who is running; `status` tells you your own name.
 
-**In Herdr, your pane is named after you — by the skill, not by you.** When the session runs inside a [Herdr](https://herdr.dev) pane (`HERDR_ENV=1`), the first command labels the pane's tab with your badge (`🍯 amber`) and its agent with your kind and your work (`claude-build-process-improvements`: Herdr allows only lowercase letters, digits, `-` and `_` there, 32 characters at most), so the Herdr sidebar reads `code-red 🍯 amber claude-build-process-improvements` and matches your Slack messages. The work part is your `--session` name, which is one more reason to pass it, and the labels follow a `sessions rename` or a new `--session` name by themselves. Don't run `herdr tab rename` or `herdr agent rename` yourself; `status` shows what was put on under `daemon.me.herdr`, and a label Herdr refused (a name another pane already has) is in `~/.roger-roger/daemon.log`.
+**In Herdr, your pane is named after you — by the skill, not by you.** When the session runs inside a [Herdr](https://herdr.dev) pane (`HERDR_ENV=1`), the first command labels the pane's tab with your badge (`🍯 amber`) and its agent with your kind and your work (`claude-build-process-improvements`: Herdr allows only lowercase letters, digits, `-` and `_` there, 32 characters at most), so the Herdr sidebar reads `code-red 🍯 amber claude-build-process-improvements` and matches your Slack messages. The work part is your `--session` name, which is one more reason to pass it (without one, the skill falls back to your terminal title, which may be vague or out of date), and the labels follow a `sessions rename` or a new `--session` name by themselves. Don't run `herdr tab rename` or `herdr agent rename` yourself; `status` shows what was put on under `daemon.me.herdr`, and a label Herdr refused (a name another pane already has) is in `~/.roger-roger/daemon.log`.
 
 **Always pass `--session`**, the same 3–6 word name on every call. It is not only a label: for agents that don't publish a session id of their own it is *how you are recognised* between commands, so leaving it off can make one piece of work look like two. Nothing here is specific to any agent — if your environment publishes a session id (anything like `*_SESSION_ID`) it is used automatically; otherwise `--session` plus the working directory identifies you, and the terminal is the last resort. If you know better than all of that, pass `--session-id ID` (and `--agent-pid PID`, so a crash is noticed straight away).
 
@@ -78,7 +78,7 @@ roger-roger notify --kind done --message "Refactor of the billing module is fini
 |---|---|
 | `--kind` | `done`, `blocked`, `input`, `milestone`, `error`, `info`. Sets the Slack emoji. |
 | `--message` | The written message for Slack. Make it self-contained, because the user may read it on their phone without context. Say what happened and what, if anything, you need from them. Slack mrkdwn works. |
-| `--say` | The spoken line (optional). Keep it short, one or two sentences, with no paths, code, or URLs. If you leave it out, the message is spoken. Ignored when the user's speech mode is `same`. With `brief`, always pass a one-sentence `--say`. |
+| `--say` | The spoken line. Keep it short, one or two sentences, and **never put code in it**: no commands, flags, paths, URLs, hostnames or JSON. Say what the thing is and why, the way you would to someone across the room: not "ssh -o BatchMode=yes … lsblk …" but "Can I run lsblk on the server, to see which disks it has?". The command itself goes in `--message` (in a code block), where it can be read. Pass `--say` whenever the message has anything technical in it, because without it the message is what gets spoken. Ignored when the user's speech mode is `same`. With `brief`, always pass a one-sentence `--say`. |
 | `--only` | Restrict this one call to some methods, e.g. `--only sound` when the user said "just ding me when done". |
 | `--project` | Label shown in Slack. Defaults to the current directory name. |
 | `--session` | **Always pass it.** A short name for this session, made up by you from what the session is about: 3–6 plain words, e.g. `"roger-roger skill slack integration"` or `"billing refactor tests"`. It's shown in the small `machine · agent · model · session` line under Slack messages, so the user can tell sessions apart. Decide it on your first call and reuse the exact same name for every later call in this session. Never use IDs or hashes. |
@@ -173,7 +173,9 @@ Examples:
 - `--say "[positive] Deployment finished. [short pause] Everything is green."`
 - `--say "[serious] I'm blocked. I need the production database password to continue."`
 
-Tags must be separated by words or punctuation, never placed back to back. The script strips tags from Slack text and from the local-voice fallback, so they are safe to include. Very short or odd lines (a single word) are sometimes refused by Gemini, so write a natural sentence.
+Tags must be separated by words or punctuation, never placed back to back. The script strips tags from Slack text and from the local-voice fallback, so they are safe to include.
+
+Code is never read aloud. As a safety net, anything that reaches the speakers still looking like code is replaced with what it is ("an ssh command", "a file", "a link", "the details are in Slack"), but that is a fallback, not a way of writing: a line the safety net had to fix still sounds clumsy. Write the spoken line as plain speech in the first place, and name commands by what they do. Very short or odd lines (a single word) are sometimes refused by Gemini, so write a natural sentence.
 
 ## 3. Asking the user to choose
 
@@ -269,6 +271,7 @@ Judge it by what happens if you are wrong, not by whether it feels routine. A fo
 - `end [name]`: this session is finished. Do this when your work is done, so messages meant for someone else don't come to you.
 - `tray status|start|stop|install`: an icon in the system tray showing every agent, with a translucent panel behind it and snooze on the right-click menu. The native part is a separate package installed on request into `~/.roger-roger` (about 4 MB, nothing compiled); everything here works without it. Once installed, the daemon starts it by itself whenever it starts (`setup --tray off` to stop that).
 - `snooze [1h|off]`: mute sound and speech for a while; Slack keeps working. For "not now" moments that quiet hours don't cover.
+- `hush`: stop the voice or sound playing right now (the user's Stop button in the tray does the same). Only that announcement; the next one plays, and the Slack message stays. If a notification comes back with `results.interrupted`, the user stopped it: don't send it again.
 - `hooks status|install|uninstall [claude|opencode|codex|all]`: the terminal-question hooks. When you use your own question tool (Claude Code's question dialog, OpenCode's question tool, Codex's `request_user_input`) or present a plan to approve, you are frozen until it's answered and can't send anything yourself; with the hooks, the agent itself runs roger-roger, and once the question has gone unanswered for a little while the user gets it in Slack with its options. `roger-roger install` offers them; without a name, `hooks install` covers the agents on this machine. What each gets: Claude Code, three entries in `~/.claude/settings.json`; OpenCode, a small plugin at `~/.config/opencode/plugins/roger-roger.js` (restart OpenCode to load it); Codex, three entries in `~/.codex/hooks.json`, to trust in `/hooks`. They follow the user's `when`, quiet hours and snooze like any notification, and log each run to `~/.roger-roger/hooks.log`. Claude Code pings once nobody has typed for a few seconds; OpenCode and Codex can't tell, so they wait `setup --terminal-wait` (default 20s) and ping only if it's still unanswered. Ordinary permission prompts (leave to run a command) don't ping unless the user asks: `setup --permission-pings on` (Claude Code and OpenCode; Codex gives no signal when one is answered). Run `hooks install` again after the skill moves, so they point at the new copy; `hooks status` says if they don't.
 - `daemon status|start|stop`: the always-on process behind everything. It starts on demand, so this is only for checking on it or restarting it after a change to the skill's code.
 - `play [sound]`: preview a sound (defaults to the configured one).

package/skills/roger-roger/herdr-plugin.toml

@@ -6,7 +6,7 @@
 
 id = "roger-roger"
 name = "roger-roger"
-version = "0.1.4"
+version = "0.1.8"
 min_herdr_version = "0.9.0"
 description = "Slack, a sound or a spoken line from the agents in your panes, and questions you answer from your phone"
 platforms = ["linux", "macos", "windows"]

package/skills/roger-roger/scripts/activity.mjs

@@ -0,0 +1,92 @@
+// Who said what, lately: every notification and question an agent sent, and every message and
+// answer the user sent back, newest last. The tray shows it as a log, so "what did amber say an
+// hour ago, and did I answer?" has an answer without scrolling Slack.
+//
+// Kept in ~/.roger-roger/activity.json, capped, and written through a temp file so the tray never
+// reads half of it. Recording never throws: a log that can't be written is not a reason for a
+// notification to fail.
+
+import fs from "node:fs";
+import path from "node:path";
+import { rogerRogerHome, stripTags } from "./lib.mjs";
+import { colourOf } from "./names.mjs";
+
+export const MAX_ENTRIES = 200;
+const MAX_TEXT = 600;
+
+export const activityPath = (env = process.env) => path.join(rogerRogerHome(env), "activity.json");
+
+export function read(env = process.env) {
+  try {
+    const entries = JSON.parse(fs.readFileSync(activityPath(env), "utf8"));
+    return Array.isArray(entries) ? entries : [];
+  } catch {
+    return [];
+  }
+}
+
+/** Who an entry is about: the agent's name and colour, or nobody yet. */
+export function agentOf(session) {
+  if (!session?.nickname) return null;
+  const colour = colourOf(session.nickname);
+  return { nickname: session.nickname, swatch: session.swatch ?? colour.swatch, colour: session.colour ?? colour.hex, project: session.project ?? "" };
+}
+
+const clip = (text) => {
+  const s = stripTags(String(text ?? "")).replace(/\s+/g, " ").trim();
+  return s.length > MAX_TEXT ? `${s.slice(0, MAX_TEXT - 1)}…` : s;
+};
+
+/**
+ * Add one entry. `from` is "agent" or "user"; `agent` is who the agent was, or who the user wrote
+ * to (null when that isn't known yet); `kind` is what it was: notify's kind, "question", "answer",
+ * or "message".
+ */
+export function record({ from, agent = null, kind, text, detail = "", at = new Date().toISOString(), ref = "" }, env = process.env) {
+  try {
+    const entry = { at, from, kind, text: clip(text), ...(detail ? { detail: clip(detail) } : {}), ...(agent ? { agent } : {}), ...(ref ? { ref } : {}) };
+    write([...read(env), entry].slice(-MAX_ENTRIES), env);
+    return entry;
+  } catch {
+    return null;
+  }
+}
+
+/** The user picked who a message was for after it was logged: say so on its entry. */
+export function retarget(ref, agent, detail = "", env = process.env) {
+  try {
+    const entries = read(env);
+    const i = entries.findLastIndex((e) => e.ref === ref);
+    if (i < 0) return false;
+    const { detail: _old, agent: _was, ...rest } = entries[i];
+    entries[i] = { ...rest, ...(agent ? { agent } : {}), ...(detail ? { detail } : {}) };
+    write(entries, env);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function write(entries, env) {
+  const file = activityPath(env);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(entries, null, 1) + "\n", "utf8");
+  fs.renameSync(tmp, file);
+}
+
+/** The newest `n`, newest first, for the tray. */
+export function recent(n = 60, env = process.env) {
+  return read(env).slice(-n).reverse();
+}
+
+/** How an answer reads in one line: the button, the options ticked, the typed words, or what happened. */
+export function answerText(decision) {
+  const a = decision.answer ?? {};
+  if (decision.status === "cancelled") return "cancelled";
+  if (decision.status === "expired") return "expired, unanswered";
+  if (a.edited) return `edited the draft: ${a.text ?? ""}`;
+  if (Array.isArray(a.choices)) return a.choices.length ? a.choices.join(", ") : "none of them";
+  if (a.choice) return a.auto ? `${a.choice} (no answer, so the recommended one)` : a.choice;
+  return a.text ?? "";
+}

package/skills/roger-roger/scripts/audio.mjs

@@ -9,6 +9,71 @@ import { SOUNDS_DIR, duckFactor, rogerRogerHome, stripTags } from "./lib.mjs";
 import { providerOf, synthesize } from "./tts.mjs";
 import { withSpeaker } from "./speaker.mjs";
 
+// ---------------------------------------------------------------- what is playing, and stopping it
+//
+// Everything audible goes through onAir(), so the daemon knows who is speaking (the tray shows a
+// Stop button while someone is) and interruptPlayback() can cut it off: the players are killed,
+// the generation moves on, and anything that notices the generation changed under it stops
+// instead of carrying on to the next sound or falling back to the computer's voice.
+
+let generation = 0;
+const players = new Set();
+let onAirCount = 0;
+let playing = null;
+const listeners = new Set();
+
+/** Called with what is playing (or null) whenever that changes. Returns a function to stop listening. */
+export function onPlaybackChange(fn) {
+  listeners.add(fn);
+  return () => listeners.delete(fn);
+}
+const emit = () => {
+  for (const fn of listeners) {
+    try {
+      fn(playing);
+    } catch {}
+  }
+};
+
+/** Who is speaking right now, `{ who, since }`, or null. */
+export const nowPlaying = () => playing;
+
+/** True once playback started at `gen` has been interrupted. */
+export const stoppedSince = (gen) => generation !== gen;
+
+/** Mark `fn` as audible for its duration, on behalf of `who`. `fn` gets the generation to check. */
+export async function onAir(who, fn) {
+  const gen = generation;
+  onAirCount++;
+  if (!playing) {
+    playing = { who: who || null, since: new Date().toISOString() };
+    emit();
+  }
+  try {
+    return await fn(gen);
+  } finally {
+    onAirCount--;
+    if (!onAirCount) {
+      playing = null;
+      emit();
+    }
+  }
+}
+
+/** Stop whatever is playing, now. Returns whether anything was. */
+export function interruptPlayback() {
+  const was = playing;
+  if (!was) return { stopped: false };
+  generation++;
+  for (const child of players) {
+    try {
+      child.kill();
+    } catch {}
+  }
+  session?.kill();
+  return { stopped: true, who: was.who };
+}
+
 /** Run a command to completion; resolves true only on a clean exit. Never rejects. */
 function run(cmd, args, opts = {}) {
   return new Promise((resolve) => {
@@ -18,14 +83,19 @@ function run(cmd, args, opts = {}) {
     } catch {
       return resolve(false);
     }
-    child.on("error", () => resolve(false));
-    child.on("exit", (code) => resolve(code === 0));
+    players.add(child);
+    child.on("error", () => (players.delete(child), resolve(false)));
+    child.on("exit", (code) => (players.delete(child), resolve(code === 0)));
   });
 }
 
-/** Try each [cmd, args] in order; true on the first that runs cleanly. */
-async function firstThatWorks(candidates, opts) {
-  for (const [cmd, args] of candidates) if (await run(cmd, args, opts)) return true;
+/** Try each in turn, but stop trying once playback was interrupted: that exit was ours, not a failure. */
+async function firstThatWorksUnlessStopped(candidates, opts) {
+  const gen = generation;
+  for (const [cmd, args] of candidates) {
+    if (await run(cmd, args, opts)) return true;
+    if (stoppedSince(gen)) return true;
+  }
   return false;
 }
 
@@ -195,6 +265,14 @@ function windowsSession() {
       if (session === self) session = null;
       child.stdin.end();
     },
+    // PlaySync and Speak block the player, so a stop can't be asked for: the player goes, and the
+    // next request starts a new one.
+    kill() {
+      fail("interrupted");
+      try {
+        child.kill();
+      } catch {}
+    },
   };
   session = self;
   return self;
@@ -210,15 +288,26 @@ export function closeAudio() {
   session?.close();
 }
 
+/** A Windows player request that, if the player was killed to stop it, just ends: stopping isn't failing. */
+async function windowsRequest(command, gen) {
+  try {
+    await windowsSession().request(command);
+  } catch (e) {
+    if (!stoppedSince(gen)) throw e;
+  }
+}
+
+// Interrupted playback returns as if it had finished: the caller checks stoppedSince() to know.
 export async function playWav(file) {
   if (!fs.existsSync(file)) throw new Error(`no such sound file: ${file}`);
+  const gen = generation;
   let ok;
   if (process.platform === "win32") {
-    return windowsSession().request(`PLAY\t${b64(file)}`);
+    return windowsRequest(`PLAY\t${b64(file)}`, gen);
   } else if (process.platform === "darwin") {
-    ok = await run("afplay", [file]);
+    ok = (await run("afplay", [file])) || stoppedSince(gen);
   } else {
-    ok = await firstThatWorks([
+    ok = await firstThatWorksUnlessStopped([
       ["paplay", [file]],
       ["pw-play", [file]],
       ["aplay", ["-q", file]],
@@ -241,13 +330,14 @@ export async function playWavBuffer(wav) {
 
 export async function speakLocally(text) {
   const plain = stripTags(text);
+  const gen = generation;
   let ok;
   if (process.platform === "win32") {
-    return windowsSession().request(`SAY\t${b64(plain)}`);
+    return windowsRequest(`SAY\t${b64(plain)}`, gen);
   } else if (process.platform === "darwin") {
-    ok = await run("say", [plain]);
+    ok = (await run("say", [plain])) || stoppedSince(gen);
   } else {
-    ok = await firstThatWorks([
+    ok = await firstThatWorksUnlessStopped([
       ["spd-say", ["-w", plain]],
       ["espeak-ng", [plain]],
       ["espeak", [plain]],
@@ -299,7 +389,13 @@ export async function withOthersQuieter(config, fn) {
   try {
     return await fn();
   } finally {
-    await player.request("UNDUCK").catch(() => {});
+    // Stopping the voice kills this player, and with it what it saved. A fresh player reads the
+    // saved levels back from the file and puts them back, so the music doesn't stay down.
+    try {
+      await player.request("UNDUCK");
+    } catch {
+      await duckPlayer().catch(() => {});
+    }
     fs.rmSync(duckFile(), { force: true });
   }
 }
@@ -330,14 +426,18 @@ export function prepareSpeech(text, config, { local = false } = {}) {
 }
 
 /** Play prepared audio; else the local synthesiser; else (if nothing else made a noise) the ding. */
-export async function deliverSpeech(prepared, text, config, { dingIfSilent = false } = {}) {
+export async function deliverSpeech(prepared, text, config, { dingIfSilent = false, gen = generation } = {}) {
   const engine = providerOf(config).id;
   const errors = prepared.error ? [`${engine}: ${prepared.error}`] : [];
+  // Stopped by the user: that is the end of it, not a reason to try the computer's voice instead.
+  const interrupted = () => ({ ok: true, engine, interrupted: true });
+  if (stoppedSince(gen)) return interrupted();
   if (prepared.wav) {
     try {
       await playWavBuffer(prepared.wav);
-      return { ok: true, engine, voice: config.voice };
+      return stoppedSince(gen) ? interrupted() : { ok: true, engine, voice: config.voice };
     } catch (e) {
+      if (stoppedSince(gen)) return interrupted();
       errors.push(`playback: ${e.message}`);
     }
   }
@@ -366,15 +466,16 @@ export async function deliverSpeech(prepared, text, config, { dingIfSilent = fal
  * the speaker is claimed, so a queued agent waits for playback, not for the network.
  * The ding and the voice after it are one turn: another agent cannot cut between them.
  */
-export async function playAlert({ methods, config, text, prepared }) {
+export async function playAlert({ methods, config, text, prepared, who = null }) {
   const results = {};
   const wantsSpeech = methods.includes("speech");
   if (wantsSpeech || methods.includes("sound")) warmUpAudio();
   const speech = wantsSpeech ? await (prepared ?? prepareSpeech(text, config)) : null;
   if (!wantsSpeech && !methods.includes("sound")) return results;
 
-  // The ding and the voice are one announcement, so everything else goes quiet for both of them.
-  return withSpeaker((turn) => withOthersQuieter(wantsSpeech ? config : null, async () => {
+  // The ding and the voice are one announcement, so everything else goes quiet for both of them,
+  // and stopping it stops both: a stop during the ding means no voice after it.
+  return withSpeaker((turn) => onAir(who, (gen) => withOthersQuieter(wantsSpeech ? config : null, async () => {
     if (methods.includes("sound")) {
       try {
         await playWav(soundFile(config.sound));
@@ -384,9 +485,12 @@ export async function playAlert({ methods, config, text, prepared }) {
       }
     }
     if (wantsSpeech) {
-      results.speech = await deliverSpeech(speech, text, config, { dingIfSilent: !methods.includes("sound") });
+      results.speech = stoppedSince(gen)
+        ? { ok: true, interrupted: true }
+        : await deliverSpeech(speech, text, config, { dingIfSilent: !methods.includes("sound"), gen });
     }
+    if (stoppedSince(gen)) results.interrupted = true;
     if (turn.waitedMs > 0) results.queued = { waitedMs: turn.waitedMs, ...(turn.tookOver ? { tookOver: true } : {}) };
     return results;
-  }));
+  })));
 }

package/skills/roger-roger/scripts/daemon.mjs

@@ -25,7 +25,7 @@ import {
 } from "./lib.mjs";
 import { lineReader, send, socketPath, PROTOCOL_VERSION } from "./protocol.mjs";
 import { connectSocket, openModal, permalink, postToChannel, updateMessage } from "./slack.mjs";
-import { closeAudio, playAlert, warmUpAudio } from "./audio.mjs";
+import { closeAudio, nowPlaying, onPlaybackChange, playAlert, warmUpAudio } from "./audio.mjs";
 import { FROM_HOOKS, HANDLERS, owedTo, startTray } from "./handlers.mjs";
 import * as progressStore from "./progress.mjs";
 import * as tray from "./tray.mjs";
@@ -99,7 +99,7 @@ function refreshTray({ ifStaleMs = 0 } = {}) {
     snapshotTimer = null;
     snapshotAt = Date.now();
     try {
-      tray.write(tray.snapshot({ config: loadConfig(), daemon: { pid: process.pid, slackConnected: state.slackConnected } }));
+      tray.write(tray.snapshot({ config: loadConfig(), daemon: { pid: process.pid, slackConnected: state.slackConnected, speaking: nowPlaying() } }));
     } catch (e) {
       log(`could not write the tray snapshot: ${e.message}`);
     }
@@ -408,7 +408,7 @@ async function remindIfDue(decision) {
         .catch((e) => log(`${decision.id}: reminder post failed: ${e.message}`))
     : null;
   try {
-    await playAlert({ methods, config, text: "[neutral] Quick reminder. I'm still waiting for your answer in Slack." });
+    await playAlert({ methods, config, text: "[neutral] Quick reminder. I'm still waiting for your answer in Slack.", who: decision.nickname ?? null });
   } catch (e) {
     log(`${decision.id}: reminder audio failed: ${e.message}`);
   }
@@ -563,6 +563,8 @@ async function main() {
   const stamp = codeStamp();
   log(`daemon started on ${socketPath()}`);
   warmUpAudio(); // so the first announcement of the day doesn't wait for a PowerShell to start
+  // The tray shows a Stop button while something plays, so it has to hear when that starts and ends.
+  onPlaybackChange(() => changed("speaking"));
   await stopLegacyDaemon().catch((e) => log(`could not stop the old daemon: ${e.message}`));
   autostartTray();
 

package/skills/roger-roger/scripts/decisions.mjs

@@ -6,6 +6,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { rogerRogerHome, outcomeText, resolvedBlocks, stripTags } from "./lib.mjs";
 import { updateMessage } from "./slack.mjs";
+import * as activity from "./activity.mjs";
 
 const KEEP_RESOLVED_MS = 7 * 24 * 3600 * 1000;
 
@@ -114,6 +115,14 @@ export async function settle(id, patch, log = () => {}, { waiting = false } = {}
   const owed = Boolean(current.sessionId) && patch.status === "answered";
   const settled = { ...current, ...patch, resolvedAt: now, ...(owed ? { deliveredAt: waiting ? now : null } : {}) };
   write(settled);
+  const byUser = settled.status === "answered" && !settled.answer?.auto;
+  activity.record({
+    from: byUser ? "user" : "agent",
+    kind: settled.status === "answered" ? "answer" : settled.status,
+    agent: activity.agentOf({ nickname: settled.nickname, swatch: settled.swatch, colour: settled.colour }),
+    text: activity.answerText(settled),
+    detail: settled.question,
+  });
 
   try {
     const outcome = outcomeText(settled);

package/skills/roger-roger/scripts/handlers.mjs

@@ -20,7 +20,7 @@ import {
 } from "./lib.mjs";
 import {
   deliverSpeech, mapPool, playAlert, playWav, playWavBuffer, prepareSpeech, soundFile,
-  speakLocally, speechAudio, warmUpAudio, withOthersQuieter,
+  interruptPlayback, nowPlaying, onAir, speakLocally, speechAudio, stoppedSince, warmUpAudio, withOthersQuieter,
 } from "./audio.mjs";
 import { withSpeaker } from "./speaker.mjs";
 import { catalog, findVoice, keyFor, missingKey, providerOf, refreshCatalog, testSample } from "./tts.mjs";
@@ -29,6 +29,7 @@ import * as progressStore from "./progress.mjs";
 import * as sessions from "./sessions.mjs";
 import * as inbox from "./inbox.mjs";
 import * as decisions from "./decisions.mjs";
+import * as activity from "./activity.mjs";
 import { labelPane } from "./herdr.mjs";
 import { answeredNotice, isQuestion, matchRequest, permissionNotice, rememberRequest } from "./hooks.mjs";
 
@@ -179,9 +180,10 @@ export async function notify(ctx, args) {
       })().catch((e) => (results.slack = { ok: Boolean(results.slack?.ok), error: e.message }))
     : null;
 
-  Object.assign(results, await playAlert({ methods, config, text, prepared }));
+  Object.assign(results, await playAlert({ methods, config, text, prepared, who: ctx.session?.nickname }));
   await slackJob;
   const succeeded = Object.values(results).some((r) => r.ok);
+  if (succeeded) activity.record({ from: "agent", kind, agent: activity.agentOf(ctx.session), text: message });
   const body = {
     ok: succeeded,
     kind,
@@ -679,6 +681,19 @@ export async function tray(ctx, args) {
  * Quiet for a while, on purpose. Quiet hours are a schedule and a meeting is not one, so this is
  * the ad-hoc version: sound and speech off until it runs out, Slack untouched.
  */
+/**
+ * Stop the voice (or sound) playing right now: the tray's Stop button, or `roger-roger hush`. Only
+ * this announcement; the next one plays as usual, and the Slack message was posted either way.
+ * It only means anything in the daemon, which is where playback happens.
+ */
+export function hush(ctx) {
+  if (!ctx.daemon) return ok({ ok: true, stopped: false, note: "no daemon, so nothing of roger-roger's is playing" });
+  const playing = nowPlaying();
+  const result = interruptPlayback();
+  if (result.stopped) ctx.log(`hush: stopped ${playing?.who ?? "playback"}`);
+  return ok({ ok: true, stopped: result.stopped, ...(result.stopped && playing?.who ? { who: playing.who } : {}) });
+}
+
 export function snooze(ctx, args) {
   const value = (args._ ?? [])[0] ?? args.for ?? "1h";
   // Snoozing is not setting up: saving here would write the defaults and call that the user's choice.
@@ -835,8 +850,9 @@ export async function ask(ctx, args) {
   });
   sessions.bindThread(ts, ctx.session?.id);
   setState(ctx, "waiting");
+  activity.record({ from: "agent", kind: "question", agent: activity.agentOf(ctx.session), text: question, detail: choices.join(" / ") });
 
-  const audio = await playAlert({ methods: audible, config, text, prepared });
+  const audio = await playAlert({ methods: audible, config, text, prepared, who: ctx.session?.nickname });
   const extra = { audio, ...(attached ? { attached } : {}), ...(muted.length ? { mutedByQuietHours: muted } : {}) };
   if (args.wait !== undefined) return waitFor(ctx, id, parseDuration(args.wait, Infinity), extra);
   // Waiting costs the agent nothing: run it in the background and carry on. It always comes back,
@@ -956,7 +972,7 @@ export async function play(ctx, args) {
   const name = (args._ ?? [])[0] ?? ctx.config?.sound ?? DEFAULTS.sound;
   const sounds = listSounds();
   if (!sounds.includes(name)) fail(`unknown sound "${name}"; available: ${sounds.join(", ")}`);
-  await withSpeaker(() => playWav(soundFile(name)));
+  await withSpeaker(() => onAir("preview", () => playWav(soundFile(name))));
   return ok({ ok: true, played: name });
 }
 
@@ -989,11 +1005,11 @@ export async function say(ctx, args) {
     } catch (e) {
       fail(`${provider.label} failed with the key from ${key.name}: ${e.message}`);
     }
-    await withSpeaker(() => withOthersQuieter(config, () => playWavBuffer(sample.wav)));
+    await withSpeaker(() => onAir("voice test", () => withOthersQuieter(config, () => playWavBuffer(sample.wav))));
     return ok({ ok: true, engine: provider.id, voice: config.voice, model: config.model, keyVar: key.name, cached: sample.cached });
   }
   const prepared = await prepareSpeech(text, config, { local: Boolean(args.local) });
-  const result = await withSpeaker(() => deliverSpeech(prepared, text, config));
+  const result = await withSpeaker(() => onAir("preview", (gen) => deliverSpeech(prepared, text, config, { gen })));
   return ok(result, result.ok ? 0 : 1);
 }
 
@@ -1059,9 +1075,10 @@ export async function previewSounds(ctx, args) {
   const audio = args.local ? sounds.map(() => ({ error: "--local" })) : await prefetch(sounds.map(soundAnnouncement), config);
 
   // The whole run-through is one turn at the speakers, so another agent can't cut in mid-list.
-  const played = await withSpeaker(async () => {
+  const played = await withSpeaker(() => onAir("preview", async (gen) => {
     const done = [];
     for (const [i, name] of sounds.entries()) {
+      if (stoppedSince(gen)) break;
       const entry = { sound: name };
       try {
         if (audio[i].wav) await playWavBuffer(audio[i].wav);
@@ -1078,7 +1095,7 @@ export async function previewSounds(ctx, args) {
       done.push(entry);
     }
     return done;
-  });
+  }));
   const succeeded = played.some((p) => p.ok);
   return ok({ ok: succeeded, order: sounds, played }, succeeded ? 0 : 1);
 }
@@ -1097,9 +1114,10 @@ export async function previewVoices(ctx, args) {
   const audio = await mapPool(voices, 4, (voice) =>
     speechAudio(text(voice), { ...config, voice }).then((wav) => ({ wav }), (e) => ({ error: e.message })));
 
-  const played = await withSpeaker(async () => {
+  const played = await withSpeaker(() => onAir("preview", async (gen) => {
     const done = [];
     for (const [i, voice] of voices.entries()) {
+      if (stoppedSince(gen)) break;
       const entry = { voice, name: byId[voice]?.name ?? voice, ...(byId[voice]?.description ? { character: byId[voice].description } : {}) };
       if (audio[i].error) {
         Object.assign(entry, { ok: false, error: audio[i].error });
@@ -1114,7 +1132,7 @@ export async function previewVoices(ctx, args) {
       done.push(entry);
     }
     return done;
-  });
+  }));
   const succeeded = played.some((p) => p.ok);
   return ok({ ok: succeeded, order: voices, played }, succeeded ? 0 : 1);
 }
@@ -1134,6 +1152,7 @@ export const HANDLERS = {
   messages,
   listen,
   snooze,
+  hush,
   tray,
   ask,
   wait,

package/skills/roger-roger/scripts/help.mjs

@@ -66,6 +66,7 @@ export const COMMANDS = [
   { section: "Reaching the user", name: "control", usage: "[--key NAME] [--wait DURATION]", summary: "Read Pause, Stop and new messages without posting. --wait blocks while paused." },
   { section: "Reaching the user", name: "listen", usage: "[--wait 25m]", summary: "Park until the user says something. Run it in the background as the last thing you do." },
   { section: "Reaching the user", name: "snooze", usage: "[1h|off]", summary: "Sound and speech off for a while; Slack keeps working." },
+  { section: "Reaching the user", name: "hush", usage: "", summary: "Stop the voice or sound playing right now. Only this announcement: the next plays as usual, and the Slack message stays. The tray's Stop button does the same." },
 
   // ---- asking
   {

package/skills/roger-roger/scripts/herdr.mjs

@@ -110,17 +110,62 @@ function errorText(text) {
   }
 }
 
+/**
+ * What the pane's agent is working on, from its terminal title: Claude Code, Codex and others set it
+ * to the conversation's topic ("Home Assistant MCP setup"). Empty when the title is only the shell
+ * or the program's own name, which says nothing about the work.
+ */
+export function workFromTitle(title, agent = "") {
+  const t = str(title).replace(/^[^\p{L}\p{N}]+/u, "").trim();
+  if (!t) return "";
+  if (/[\\/]|\.exe$|^(powershell|pwsh|cmd|bash|zsh|fish|sh|node)$/i.test(t)) return "";
+  if (agent && t.toLowerCase() === String(agent).toLowerCase()) return "";
+  if (/^(claude( code)?|codex|opencode|gemini|cursor|copilot)$/i.test(t)) return "";
+  return t;
+}
+
+// Herdr is asked for the title at most this often per session; a label follows the topic, not keystrokes.
+const TITLE_EVERY_MS = 60_000;
+const titleAsked = new Map();
+
+/** The work to label with: the `--session` name if the agent gave one, else the pane's title. */
+async function workFor(session, run, now = Date.now()) {
+  if (str(session.name)) return str(session.name);
+  const last = titleAsked.get(session.id);
+  if (last && now - last.at < TITLE_EVERY_MS) return last.work;
+  let work = "";
+  try {
+    const out = await run(["agent", "get", session.herdr.pane], { bin: session.herdr.bin, socket: session.herdr.socket });
+    const agent = JSON.parse(out)?.result?.agent ?? {};
+    work = workFromTitle(agent.terminal_title_stripped ?? agent.terminal_title, agent.agent ?? session.agent);
+  } catch {
+    // No title is no label, not an error: the tab still gets the badge.
+  }
+  titleAsked.set(session.id, { at: now, work });
+  return work;
+}
+
 const inFlight = new Set();
 
 /**
  * Put the session's labels on its Herdr pane, if it has one and they are not there yet. Never
  * throws: a pane that can't be labelled is a line in the log, not a failed command. `touch` records
  * what was put on, so it isn't done again; `run` is the herdr invocation (replaced in tests).
+ * Without a `--session` name, the work is taken from the pane's terminal title.
  */
 export async function labelPane(session, { log = () => {}, touch = () => {}, run = runHerdr } = {}) {
-  const commands = labelCommands(session);
-  if (!commands.length || inFlight.has(session.id)) return { labelled: false };
+  if (!session?.herdr?.tab || !session?.herdr?.pane || inFlight.has(session.id)) return { labelled: false };
   inFlight.add(session.id);
+  let commands;
+  try {
+    commands = labelCommands({ ...session, name: await workFor(session, run) });
+  } catch {
+    commands = [];
+  }
+  if (!commands.length) {
+    inFlight.delete(session.id);
+    return { labelled: false };
+  }
   const done = { ...(session.herdrLabel ?? {}) };
   try {
     for (const args of commands) {

package/skills/roger-roger/scripts/inbox.mjs

@@ -18,6 +18,7 @@ import { routeMessage } from "./router.mjs";
 import * as progressStore from "./progress.mjs";
 import * as sessions from "./sessions.mjs";
 import * as decisions from "./decisions.mjs";
+import * as activity from "./activity.mjs";
 
 const KEEP = 200;
 
@@ -166,6 +167,20 @@ export async function ingest(message, { log = () => {}, live = false, waiting =
   const route = entry.route;
   const files = entry.files ?? [];
   log(`message ${message.ts} → ${route.kind}${route.key ? ` ${route.key}` : route.id ? ` ${route.id}` : ""}`);
+  // An answer in a question's thread is logged when the question settles, as the answer it is.
+  if (route.kind !== "decision") {
+    const to = route.kind === "session" ? sessions.get(route.id) : route.kind === "progress" && route.session ? sessions.get(route.session) : null;
+    const where = { progress: "a note on the progress message", ask: "asked which agent", inbox: "saved for the next agent" }[route.kind] ?? "";
+    activity.record({
+      from: "user",
+      kind: "message",
+      agent: to ? activity.agentOf(sessions.decorate(to)) : null,
+      text: text || (files.length ? files.map((f) => f.name).join(", ") : ""),
+      detail: where,
+      at: tsIso(message.ts),
+      ref: message.ts,
+    });
+  }
 
   await addReaction(channel, message.ts, reactionFor(route)).catch((e) => log(`reaction failed: ${e.message}`));
 
@@ -268,6 +283,7 @@ export async function resolvePick(messageTs, sessionId, log = () => {}) {
   const chosen = sessionId === NOBODY ? null : sessions.get(sessionId);
   const route = chosen ? { kind: "session", id: chosen.id, via: "picked" } : { kind: "inbox" };
   writeState({ ...state, messages: state.messages.map((m) => (m.ts === messageTs ? { ...m, route } : m)) });
+  activity.retarget(messageTs, chosen ? activity.agentOf(sessions.decorate(chosen)) : null, chosen ? "" : "saved for the next agent");
 
   if (chosen) {
     deliver(chosen.id, { text: entry.text, by: entry.user, at: tsIso(entry.ts), ts: entry.ts, channel: entry.channel, via: "picked" });

package/skills/roger-roger/scripts/install.mjs

@@ -111,7 +111,7 @@ const MARK_END = "<!-- roger-roger:end -->";
 /** The standing instruction, between marks so it can be replaced or removed without touching anything else. */
 export const INSTRUCTIONS = [
   MARK_START,
-  "- Always use the `roger-roger` skill (the `roger-roger` command, or `node <skill-dir>/scripts/roger-roger.mjs`): at the end of every turn, whatever its size, send a notification as the last action before the final reply, and use `ask` when blocked on a decision. Don't skip it because the task seemed quick or the user seems to be at the keyboard. Pass `--session` (three to six words about the work) and `--agent-model` on every call. If the skill isn't available, say so once.",
+  "- Always use the `roger-roger` skill (the `roger-roger` command, or `node <skill-dir>/scripts/roger-roger.mjs`): at the end of every turn, whatever its size, send a notification as the last action before the final reply, and use `ask` when blocked on a decision. Don't skip it because the task seemed quick or the user seems to be at the keyboard. On every call pass `--session` with what the work is, in three to six words (`--session \"billing refactor tests\"`), and `--agent-model`: the work names your Slack messages and your Herdr pane. Never put code, commands, paths or URLs in the spoken line (`--say`): say what the thing is and why, and leave the command itself to the written message. If the skill isn't available, say so once.",
   MARK_END,
 ].join("\n");
 

package/skills/roger-roger/scripts/lib.mjs

@@ -535,8 +535,63 @@ export function slackText({ kind = "info", message, project, mention }) {
 
 /** What gets spoken: the agent's `--say` line, unless the user wants the message read verbatim. */
 export function speechText({ mode = "auto", message, say }) {
-  if (mode === "same") return message;
-  return say || message;
+  return speakable(mode === "same" ? message : say || message);
+}
+
+// A word that only makes sense on a screen: shell punctuation, a flag, a path, a quote, a template.
+const CODEISH = /[{}$|;<>=\\`"']|^--?[a-z]|[\w.~-]\/[\w.-]|^https?:|^[\w-]+\.[a-z]{2,4}[,.]?$|^\w+\(|\)$/i;
+
+/**
+ * Does this stretch read as code rather than as a sentence? `quoted` is for text already marked as
+ * code (in backticks): there one flag or path is enough. Loose text needs two, and a fair share.
+ */
+export function looksLikeCode(text, { quoted = false } = {}) {
+  const words = String(text).trim().split(/\s+/).filter(Boolean);
+  if (!words.length) return false;
+  const codeish = words.filter((w) => CODEISH.test(w)).length;
+  if (words.length === 1) return words[0].length > 24 || /[{}$|;<>=\\/]/.test(words[0]);
+  if (quoted) return codeish >= 1;
+  return codeish >= 2 && codeish / words.length >= 0.3;
+}
+
+/** What a piece of code is, in words: "an ssh command", "a file", or just "a command". */
+function nameCode(code) {
+  const s = String(code).trim();
+  if (!/\s/.test(s) && /[\/\\]/.test(s) && !/^https?:/i.test(s)) return "a file";
+  const first = s.split(/\s+/)[0].replace(/^[^\w]+/, "");
+  // "an ssh", "an npm", "a git": a word with no vowel is spelt out, and f, h, l, m, n, r, s, x start with a vowel sound.
+  const an = /^[aeiou]/i.test(first) || (!/[aeiouy]/i.test(first) && /^[fhlmnrsx]/i.test(first));
+  if (/^[a-z][\w-]{1,15}$/i.test(first) && !/^(the|a|an|and|or|to|then)$/i.test(first)) return `${an ? "an" : "a"} ${first} command`;
+  return "a command";
+}
+
+/**
+ * The line as it should be heard. Nobody wants a voice reading out `ssh -o BatchMode=yes …` or a
+ * URL, so code is said as what it is: a fenced block becomes "the details are in Slack", inline
+ * code that is really code becomes "an lsblk command" or "a file", a link becomes "a link", and a
+ * stretch of bare command line becomes what it is too. Markdown emphasis goes; tone tags stay.
+ */
+export function speakable(text) {
+  let s = String(text ?? "");
+  s = s.replace(/```[\s\S]*?(```|$)/g, " (the details are in Slack) ");
+  s = s.replace(/`([^`\n]+)`/g, (_, code) => (looksLikeCode(code, { quoted: true }) ? nameCode(code) : code));
+  s = s.replace(/<?https?:\/\/[^\s>|]+(\|[^>]*)?>?/gi, "a link");
+  s = s
+    .split(/\n+|(?<=[.!?])\s+(?=[A-Z[])/)
+    .map((part) => {
+      // A sentence that ends in a command ("Can I run ssh -o … 'df -h'") keeps its words and names the command.
+      const words = part.trim().split(/\s+/);
+      const start = words.findIndex((w, i) => looksLikeCode(words.slice(i).join(" ")) && CODEISH.test(words[Math.min(i + 1, words.length - 1)]));
+      if (start < 0) return part;
+      return [...words.slice(0, start), nameCode(words.slice(start).join(" "))].join(" ");
+    })
+    .join(" ");
+  return s
+    .replace(/(^|\s)[*_~]+(?=\S)|(?<=\S)[*_~]+(?=\s|[,.!?;:]|$)/g, "$1")
+    .replace(/^\s*[>•-]\s+/gm, "")
+    .replace(/\s+([,.!?;:])/g, "$1")
+    .replace(/\s{2,}/g, " ")
+    .trim();
 }
 
 // Several agents share one pair of speakers, and a voice from the next room with no name on it is

package/skills/roger-roger/scripts/roger-roger.mjs

@@ -465,6 +465,7 @@ async function main() {
     case "control":
     case "listen":
     case "snooze":
+    case "hush":
     case "tray":
     case "ask":
     case "wait":

package/skills/roger-roger/scripts/tray.mjs

@@ -11,6 +11,7 @@ import {
   rogerRogerHome, inQuietHours, listSounds, snoozeUntil,
 } from "./lib.mjs";
 import * as decisions from "./decisions.mjs";
+import * as activity from "./activity.mjs";
 import * as progressStore from "./progress.mjs";
 import * as sessions from "./sessions.mjs";
 import { PROVIDERS, catalog, keyFor, providerOf } from "./tts.mjs";
@@ -46,6 +47,8 @@ export function snapshot({ config = null, daemon = null, now = Date.now() } = {}
   return {
     updatedAt: new Date(now).toISOString(),
     daemon: daemon ? { pid: daemon.pid, slackConnected: Boolean(daemon.slackConnected) } : null,
+    // Who is speaking right now ({ who, since }), so the panel can offer to stop it.
+    speaking: daemon?.speaking ?? null,
     muted: {
       snoozeUntil: snoozeUntil(config, new Date(now)),
       quietHours: config?.quietHours ?? null,
@@ -61,6 +64,8 @@ export function snapshot({ config = null, daemon = null, now = Date.now() } = {}
       expiresAt: d.expiresAt,
     })),
     working: progressStore.active(now).map((p) => ({ key: p.key, headline: p.headline, nickname: p.nickname ?? null })),
+    // Who said what lately, newest first: the Log view.
+    log: activity.recent(60),
     // Everything `setup` can change, so the panel can offer it without asking anyone. Tokens live
     // in slack.json and the environment and are deliberately not here.
     settings: config

package/skills/roger-roger/tray/main.mjs

@@ -191,6 +191,8 @@ function tooltip(state, stale) {
  */
 function menu(state, spot) {
   const items = [];
+  // While a voice plays, the first thing on the menu stops it.
+  if (state.speaking) items.push({ id: "hush", label: state.speaking.who ? `Stop ${state.speaking.who} speaking` : "Stop the voice" }, { id: "sep0", label: "-" });
   if (state.muted?.snoozeUntil) {
     items.push({ id: "snooze:off", label: "Stop snoozing" });
   } else {
@@ -203,9 +205,10 @@ function menu(state, spot) {
   return { items };
 }
 
-const menuKey = (state, spot) => `${state.muted?.snoozeUntil ? "snoozed" : "awake"}:${spot ? "spot" : "free"}`;
+const menuKey = (state, spot) => `${state.muted?.snoozeUntil ? "snoozed" : "awake"}:${spot ? "spot" : "free"}:${state.speaking ? `speaking-${state.speaking.who ?? ""}` : "silent"}`;
 
 function onMenu(id) {
+  if (id === "hush") return run("hush");
   if (id === "snooze:off") return run("snooze", "off");
   if (id?.startsWith("snooze:")) return run("snooze", id.slice("snooze:".length));
   return null;
@@ -463,6 +466,7 @@ async function main() {
         return log(`the panel said something I could not read: ${message?.body ?? message}`);
       }
       if (ask.do === "snooze") return run("snooze", ask.value || "1h");
+      if (ask.do === "hush") return run("hush");
       if (ask.do === "hide") return hidePanel();
       if (ask.do === "keep-open") {
         keepOpen = Boolean(ask.value);

package/skills/roger-roger/tray/panel.html

@@ -141,6 +141,40 @@
       .slider input[type="range"] { flex: 1; accent-color: var(--accent); padding: 0; border: 0; background: transparent; }
       .slider output { width: 40px; text-align: right; font-size: 11px; color: var(--text-dim); font-variant-numeric: tabular-nums; }
       .flash.is-ok { border-color: #7fd1a0; }
+
+      /* The log: who said what, newest first. The agent's colour runs down the left edge. */
+      .row.is-agent { cursor: pointer; }
+      .filters { display: flex; gap: 4px; flex-wrap: wrap; padding: 6px 4px 8px; }
+      .entry { position: relative; padding: 8px 8px 8px 12px; border-bottom: 1px solid var(--border-subtle); cursor: pointer; }
+      .entry::before { content: ""; position: absolute; left: 0; top: 8px; bottom: 8px; width: 2px; background: var(--edge, var(--text-muted)); }
+      .entry.from-user::before { background: var(--accent); }
+      .entry:hover { background: color-mix(in srgb, var(--bg-section) 60%, transparent); }
+      .entry .top { gap: 6px; font-size: 11px; color: var(--text-dim); }
+      .entry .name { font-weight: 600; color: var(--text); }
+      .entry .arrow { color: var(--text-muted); }
+      .entry .kind { padding: 0 5px; border: 1px solid var(--border-subtle); font-size: 10px; letter-spacing: 0.04em; text-transform: uppercase; color: var(--text-muted); }
+      .entry .kind.k-blocked, .entry .kind.k-error, .entry .kind.k-question { color: var(--accent); border-color: color-mix(in srgb, var(--accent) 50%, transparent); }
+      .entry .kind.k-done, .entry .kind.k-answer { color: #7fd1a0; border-color: #7fd1a055; }
+      .entry .text { margin-top: 4px; line-height: 1.4; color: var(--text); display: -webkit-box; -webkit-line-clamp: 3; -webkit-box-orient: vertical; overflow: hidden; overflow-wrap: anywhere; }
+      .entry.is-open .text { display: block; }
+      .entry .detail { margin-top: 3px; font-size: 11px; color: var(--text-muted); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .entry.is-open .detail { white-space: normal; }
+      .day { padding: 12px 8px 4px; font-size: 10px; letter-spacing: 0.1em; text-transform: uppercase; color: var(--text-muted); }
+
+      /* On air: shown only while a voice or sound plays, with the one thing you might want — stop it. */
+      .onair { display: flex; align-items: center; gap: 10px; padding: 8px 10px 8px 14px; border-bottom: 1px solid var(--border-subtle); background: color-mix(in srgb, var(--accent) 12%, transparent); }
+      .onair[hidden] { display: none; }
+      .onair .bars { display: flex; align-items: flex-end; gap: 2px; height: 14px; }
+      .onair .bars i { width: 3px; background: var(--accent); animation: level 900ms ease-in-out infinite; }
+      .onair .bars i:nth-child(2) { animation-delay: -300ms; }
+      .onair .bars i:nth-child(3) { animation-delay: -600ms; }
+      @keyframes level { 0%, 100% { height: 4px; } 50% { height: 14px; } }
+      @media (prefers-reduced-motion: reduce) { .onair .bars i { animation: none; height: 10px; } }
+      .onair .label { flex: 1; min-width: 0; font-size: 12px; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+      .onair .label strong { font-weight: 600; }
+      .onair button { display: inline-flex; align-items: center; gap: 6px; padding: 4px 10px; font-size: 11px; font-weight: 600; color: #101317; background: var(--accent); border-color: var(--accent); }
+      .onair button:hover { filter: brightness(1.08); }
+      .onair button svg { width: 11px; height: 11px; fill: currentColor; stroke: none; }
       svg { width: 15px; height: 15px; stroke: currentColor; fill: none; stroke-width: 2; stroke-linecap: round; stroke-linejoin: round; }
     </style>
   </head>
@@ -151,6 +185,9 @@
         <span class="count" id="count"></span>
         <span class="spacer"></span>
         <span class="badge" id="badge" hidden></span>
+        <button class="icon-btn icon-btn-sm" id="log" title="Log: who said what">
+          <svg viewBox="0 0 24 24"><path d="M21 15a2 2 0 0 1-2 2H7l-4 4V5a2 2 0 0 1 2-2h14a2 2 0 0 1 2 2z"></path><path d="M8 9h8"></path><path d="M8 13h5"></path></svg>
+        </button>
         <button class="icon-btn icon-btn-sm" id="pin" title="Keep open when I click elsewhere">
           <svg viewBox="0 0 24 24"><path d="M12 17v5"></path><path d="M9 10.76a2 2 0 0 1-1.11 1.79l-1.78.9A2 2 0 0 0 5 15.24V16a1 1 0 0 0 1 1h12a1 1 0 0 0 1-1v-.76a2 2 0 0 0-1.11-1.79l-1.78-.9A2 2 0 0 1 15 10.76V7a1 1 0 0 1 1-1 2 2 0 0 0 0-4H8a2 2 0 0 0 0 4 1 1 0 0 1 1 1z"></path></svg>
         </button>
@@ -158,6 +195,13 @@
           <svg viewBox="0 0 24 24"><circle cx="12" cy="12" r="3"></circle><path d="M19.4 15a1.65 1.65 0 0 0 .33 1.82l.06.06a2 2 0 1 1-2.83 2.83l-.06-.06a1.65 1.65 0 0 0-1.82-.33 1.65 1.65 0 0 0-1 1.51V21a2 2 0 1 1-4 0v-.09A1.65 1.65 0 0 0 9 19.4a1.65 1.65 0 0 0-1.82.33l-.06.06a2 2 0 1 1-2.83-2.83l.06-.06a1.65 1.65 0 0 0 .33-1.82 1.65 1.65 0 0 0-1.51-1H3a2 2 0 1 1 0-4h.09A1.65 1.65 0 0 0 4.6 9a1.65 1.65 0 0 0-.33-1.82l-.06-.06a2 2 0 1 1 2.83-2.83l.06.06A1.65 1.65 0 0 0 9 4.6h.09A1.65 1.65 0 0 0 10 3.09V3a2 2 0 1 1 4 0v.09A1.65 1.65 0 0 0 15 4.6a1.65 1.65 0 0 0 1.82-.33l.06-.06a2 2 0 1 1 2.83 2.83l-.06.06A1.65 1.65 0 0 0 19.4 9v.09a1.65 1.65 0 0 0 1.51 1H21a2 2 0 1 1 0 4h-.09a1.65 1.65 0 0 0-1.51 1z"></path></svg>
         </button>
       </header>
+      <div class="onair" id="onair" hidden>
+        <span class="bars" aria-hidden="true"><i></i><i></i><i></i></span>
+        <span class="label" id="onair-label"></span>
+        <button data-do="hush" title="Stop this announcement (the Slack message stays)">
+          <svg viewBox="0 0 24 24"><rect x="5" y="5" width="14" height="14"></rect></svg>Stop
+        </button>
+      </div>
       <main id="body"></main>
       <div class="flash" id="flash" hidden></div>
       <footer id="actions"></footer>
@@ -168,9 +212,15 @@
       const plural = (n, one, many) => n + " " + (n === 1 ? one : many);
       const send = (body) => window.ipc.postMessage(JSON.stringify(body));
 
-      let latest = { agents: [], questions: [], working: [] };
+      let latest = { agents: [], questions: [], working: [], log: [] };
       let settingsOpen = false;
       let advancedOpen = false;
+      // The log view, which agent it is narrowed to (null: everyone), and which entries are opened out.
+      let logOpen = false;
+      let logFilter = null;
+      // Stop was pressed: hide the strip at once rather than waiting for the daemon to say it stopped.
+      let hushedAt = 0;
+      const openEntries = new Set();
 
       function ago(ms) {
         const s = Math.round((ms ?? 0) / 1000);
@@ -197,7 +247,7 @@
         if (a.queued) bits.push(plural(a.queued, "message", "messages") + " unread");
         if (a.owes) bits.push(plural(a.owes, "answer", "answers") + " to collect");
         return (
-          '<div class="row"><div class="top">' +
+          '<div class="row is-agent" data-agent="' + esc(a.nickname) + '" title="Show what ' + esc(a.nickname) + ' said"><div class="top">' +
           '<span class="status-dot"' + colour + "></span>" +
           '<span class="who">' + esc(a.nickname) + "</span>" +
           '<span class="state">' + esc(a.state) + "</span>" +
@@ -217,6 +267,70 @@
         );
       }
 
+      // ---------------------------------------------------------------- log
+
+      const KIND_LABEL = { done: "done", blocked: "blocked", input: "needs you", milestone: "milestone", error: "error", info: "info", question: "question", answer: "answer", message: "message", cancelled: "cancelled", expired: "expired" };
+
+      function clock(iso) {
+        const d = new Date(iso);
+        return isFinite(d) ? d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "";
+      }
+
+      function dayOf(iso) {
+        const d = new Date(iso);
+        if (!isFinite(d)) return "";
+        const today = new Date();
+        const yesterday = new Date(today.getTime() - 864e5);
+        if (d.toDateString() === today.toDateString()) return "Today";
+        if (d.toDateString() === yesterday.toDateString()) return "Yesterday";
+        return d.toLocaleDateString([], { weekday: "long", day: "numeric", month: "short" });
+      }
+
+      function entryRow(e, i) {
+        const name = (a) => '<span class="name">' + esc(a ? (a.swatch ? a.swatch + " " : "") + a.nickname : "an agent") + "</span>";
+        const who = e.from === "user"
+          ? '<span class="name">you</span>' + (e.agent ? '<span class="arrow">→</span>' + name(e.agent) : "")
+          : name(e.agent) + '<span class="arrow">→</span><span class="name">you</span>';
+        const key = e.at + "|" + i;
+        const edge = e.agent && e.agent.colour ? ' style="--edge:' + esc(e.agent.colour) + '"' : "";
+        const detail = e.kind === "answer" && e.detail ? "to: " + e.detail : e.detail;
+        return (
+          '<div class="entry' + (e.from === "user" ? " from-user" : "") + (openEntries.has(key) ? " is-open" : "") + '" data-entry="' + esc(key) + '"' + edge + ">" +
+          '<div class="top">' + who +
+          '<span class="kind k-' + esc(e.kind) + '">' + esc(KIND_LABEL[e.kind] || e.kind) + "</span>" +
+          '<span class="age" title="' + esc(new Date(e.at).toLocaleString()) + '">' + clock(e.at) + "</span></div>" +
+          (e.text ? '<div class="text">' + esc(e.text) + "</div>" : "") +
+          (detail ? '<div class="detail">' + esc(detail) + "</div>" : "") +
+          "</div>"
+        );
+      }
+
+      function logView(log) {
+        const names = [...new Set(log.map((e) => e.agent && e.agent.nickname).filter(Boolean))];
+        const shown = logFilter ? log.filter((e) => e.agent && e.agent.nickname === logFilter) : log;
+        const parts = [];
+        if (names.length > 1 || logFilter) {
+          parts.push('<div class="filters">' +
+            '<button class="chip' + (logFilter ? "" : " is-active") + '" data-filter="">Everyone</button>' +
+            names.map((n) => '<button class="chip' + (logFilter === n ? " is-active" : "") + '" data-filter="' + esc(n) + '">' + esc(n) + "</button>").join("") +
+            "</div>");
+        }
+        if (!shown.length) {
+          parts.push('<p class="empty">' + (logFilter ? "Nothing from " + esc(logFilter) + " yet." : "Nothing said yet. Notifications, questions, your answers and your messages show up here.") + "</p>");
+          return parts.join("");
+        }
+        let day = "";
+        shown.forEach((e, i) => {
+          const d = dayOf(e.at);
+          if (d !== day) {
+            day = d;
+            parts.push('<p class="day">' + esc(d) + "</p>");
+          }
+          parts.push(entryRow(e, i));
+        });
+        return parts.join("");
+      }
+
       // ---------------------------------------------------------------- settings
 
       const setting = (label, control, hint) =>
@@ -363,6 +477,8 @@
 
         document.getElementById("count").textContent = settingsOpen
           ? "settings"
+          : logOpen
+            ? "log" + (logFilter ? " · " + logFilter : "")
           : agents.length
             ? plural(agents.length, "agent", "agents") + (questions.length ? " · " + plural(questions.length, "question", "questions") : "")
             : "nothing running";
@@ -371,12 +487,27 @@
         badge.hidden = !snoozed && !quiet;
         badge.textContent = snoozed ? "snoozed" : "quiet hours";
         document.getElementById("gear").classList.toggle("is-active", settingsOpen);
+        document.getElementById("log").classList.toggle("is-active", logOpen && !settingsOpen);
+
+        // Who is speaking, and the Stop button, only while something is.
+        const speaking = state.speaking;
+        const onair = document.getElementById("onair");
+        onair.hidden = !speaking || hushedAt > Date.now() - 2500;
+        if (speaking) {
+          const who = speaking.who;
+          const agent = agents.find((a) => a.nickname === who);
+          document.getElementById("onair-label").innerHTML = who && agent
+            ? "<strong>" + esc((agent.swatch ? agent.swatch + " " : "") + who) + "</strong> is speaking"
+            : who ? "Playing a " + esc(who) : "Speaking";
+        }
 
         const parts = [];
         // The tray says so when the file it reads has stopped being kept up to date.
         if (state.stale) parts.push('<p class="stale">Daemon not running — state may be old.</p>');
         if (settingsOpen) {
           parts.push(settingsView(state.settings, state.options || {}));
+        } else if (logOpen) {
+          parts.push(logView(state.log ?? []));
         } else if (!agents.length && !questions.length && !working.length) {
           parts.push('<p class="empty">Nothing is running.</p>');
         } else {
@@ -455,10 +586,40 @@
 
       document.getElementById("gear").addEventListener("click", () => {
         settingsOpen = !settingsOpen;
+        if (settingsOpen) logOpen = false;
+        draw();
+      });
+
+      document.getElementById("log").addEventListener("click", () => {
+        logOpen = settingsOpen ? true : !logOpen;
+        settingsOpen = false;
+        logFilter = null;
+        document.getElementById("body").scrollTop = 0;
         draw();
       });
 
       document.addEventListener("click", (e) => {
+        // An agent's row opens its log; a filter narrows the log; an entry opens out to its full text.
+        const agent = e.target.closest("[data-agent]");
+        if (agent) {
+          logOpen = true;
+          logFilter = agent.dataset.agent;
+          document.getElementById("body").scrollTop = 0;
+          return draw();
+        }
+        const filter = e.target.closest("[data-filter]");
+        if (filter) {
+          logFilter = filter.dataset.filter || null;
+          return draw();
+        }
+        const entry = e.target.closest("[data-entry]");
+        if (entry) {
+          const key = entry.dataset.entry;
+          if (openEntries.has(key)) openEntries.delete(key);
+          else openEntries.add(key);
+          entry.classList.toggle("is-open");
+          return;
+        }
         const action = e.target.closest("[data-do]");
         if (action) {
           e.preventDefault();
@@ -466,6 +627,10 @@
             action.disabled = true;
             action.textContent = "Speaking…";
           }
+          if (action.dataset.do === "hush") {
+            hushedAt = Date.now();
+            document.getElementById("onair").hidden = true;
+          }
           return send({ do: action.dataset.do, value: action.dataset.value });
         }
         const chip = e.target.closest("[data-chip]");