roger-roger 0.1.8 → 0.1.13

package/README.md

@@ -93,7 +93,7 @@ There is no always-on service. `ask` starts a small watcher process, and one wat
 - **One voice at a time**: several agents on one machine take turns at the speakers instead of talking over each other. A waiting announcement plays in full as soon as the one before it finishes.
 - **Works with any agent**: Claude Code, Codex, OpenCode, or a plain shell script. A session is recognised by whatever id the agent publishes, or by the `--session` name it passes, or by the terminal — no per-product support needed.
 - **Every agent has a name**: each session is given a colour nickname — 🌿 sage, 🌹 rose, 🍇 plum — shown on its Slack messages with a matching colour bar. `sessions` lists who is running; `sessions rename sage plum` changes one.
-- **Named in Herdr too**: an agent running in a [Herdr](https://herdr.dev) pane gets its badge on the tab (`🍯 amber`) and its kind and work on the agent (`claude-build-process-improvements`), so the Herdr sidebar and the Slack messages name the same thing. Nothing to set up: the skill sees the pane it runs in and labels it on the first command, and again after a rename. As a Herdr plugin (`roger-roger install` registers it, or `herdr plugin install code-red-app/roger-roger/skills/roger-roger`), the daemon starts with Herdr, snooze is an action, and the setup opens as a popup pane.
+- **Named in Herdr too**: an agent running in a [Herdr](https://herdr.dev) pane gets its badge and a word or two of its work on the tab (`🍯 amber | build process`) and its work on the agent (`build-process-improvements`), so the Herdr sidebar and the Slack messages name the same thing. Nothing to set up: the skill sees the pane it runs in and labels it on the first command, and again after a rename. As a Herdr plugin (`roger-roger install` registers it, or `herdr plugin install code-red-app/roger-roger/skills/roger-roger`), the daemon starts with Herdr, snooze is an action, and the setup opens as a popup pane.
 - **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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roger-roger",
-  "version": "0.1.8",
+  "version": "0.1.13",
   "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 (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`.
+**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 and the first two words of your work (`🍯 amber | build process`, so lead your `--session` with the words that say what it is) and its agent with your work (`build-process-improvements`: Herdr allows only lowercase letters, digits, `-` and `_` there, 32 characters at most), so the Herdr sidebar reads `code-red 🍯 amber 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. 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`. |
+| `--say` | The spoken line. Short, but it must **carry the point itself**: what happened and what, if anything, you need (see *What to say out loud* below). **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. |
@@ -158,6 +158,19 @@ roger-roger listen --wait 25m
 - Don't park after a quick exchange where the user is plainly at the keyboard, and don't park instead of doing work you could be doing.
 - The user sees :eyes: in Slack when an agent is listening or actually running, and :zzz: when the message is saved for one that isn't — so they know whether to expect an answer now or at your next step.
 
+### What to say out loud
+
+The user hears the line from across the room and may never look at Slack. One or two sentences, and they must be enough on their own: the actual result, the actual question, the actual next step. A line that only points somewhere else ("here is what's next", "details in Slack", "I have an update", "done, see the message") is useless out loud: it makes the user walk over to find out what you could have said.
+
+- Say the thing, not that there is a thing. Not "Here's what's next." but "Next I'd set up automatic releases, then the Herdr status pings."
+- Lead with the outcome, then what you need: "The migration is done and all tests pass. Nothing needed from you."
+- For a question, say the question and the choices in words: "Should I archive the twelve orphaned rows, or delete them?"
+- For a failure, say what broke and whether you are stuck: "The build fails on a missing Slack token. I'm blocked until it's set."
+- Numbers and names are fine ("318 tests", "the billing module"); code, paths and links are not.
+- Terse is good, empty is not: "All green." is fine when that is the whole story; "It's done, here's what's next." never is.
+
+When there is more than fits in two sentences, say the one thing that matters most, and let the written message carry the rest.
+
 ### Tone: Gemini audio tags
 
 Gemini 3.1 Flash TTS reads inline tags in square brackets and changes its delivery. Put a tag where the change should happen. Choose tags that fit the moment, and use them sparingly (one or two per line):

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

@@ -6,7 +6,7 @@
 
 id = "roger-roger"
 name = "roger-roger"
-version = "0.1.8"
+version = "0.1.13"
 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/herdr.mjs

@@ -2,8 +2,9 @@
 // `<directory> <tab label> <agent label>`. Out of the box that reads "code-red 2 claude" — the tab
 // number and the agent's kind — which says nothing about *which* claude, while the user's Slack
 // messages arrive signed "🍯 amber". This closes that gap: when a session runs inside a Herdr pane,
-// its tab is labelled with the session's badge (`🍯 amber`) and its agent with the kind and the work
-// (`claude-build-process-improvements`), so the sidebar and Slack name the same thing.
+// its tab is labelled with the session's badge and a word or two of the work (`🍯 amber | build
+// process`) and its agent with the work
+// (`build-process-improvements`), so the sidebar and Slack name the same thing.
 //
 // The pane's context comes from the environment Herdr injects into the pane (HERDR_ENV=1 and the
 // ids). The CLI runs there and passes it along with its identity; the daemon, which runs somewhere
@@ -40,20 +41,46 @@ export function herdrContext(env = process.env) {
 
 /** What the tab says: the session's badge, `🍯 amber`. */
 export function tabLabel(session) {
-  return session?.nickname ? badge(session.nickname) : "";
+  if (!session?.nickname) return "";
+  const work = shortWork(session.name);
+  return work ? `${badge(session.nickname)} | ${work}` : badge(session.nickname);
+}
+
+// Words that say nothing on their own, skipped when the work is cut down to two.
+const FILLER = new Set(["a", "an", "the", "and", "or", "of", "for", "to", "in", "on", "with", "my", "our", "some", "into", "from", "about", "new"]);
+const MAX_TAB_WORK = 24;
+
+/**
+ * The work in a word or two, for the tab: "security audit of the billing service" → "security
+ * audit", "Home Assistant MCP setup" → "home assistant". Lowercase, punctuation gone, filler words
+ * skipped, and never longer than a tab can show.
+ */
+export function shortWork(text) {
+  const words = String(text ?? "")
+    .toLowerCase()
+    .replace(/[^\p{L}\p{N}\s-]+/gu, " ")
+    .split(/\s+/)
+    .map((w) => w.replace(/^-+|-+$/g, ""))
+    .filter((w) => w && !FILLER.has(w));
+  let out = "";
+  for (const word of words.slice(0, 2)) {
+    const next = out ? `${out} ${word}` : word;
+    if (next.length > MAX_TAB_WORK) break;
+    out = next;
+  }
+  return out || (words[0] ?? "").slice(0, MAX_TAB_WORK);
 }
 
 /**
- * What the agent is called: its kind and its work, in the only shape Herdr accepts —
- * `claude-build-process-improvements`. Without a `--session` name there is nothing to add to what
+ * What the agent is called: its work, in the only shape Herdr accepts —
+ * `build-process-improvements`. Without a `--session` name there is nothing to add to what
  * Herdr already shows (the kind), so the agent is left alone.
  */
 export function agentName(session) {
-  const work = slug(session?.name);
-  if (!work) return "";
-  const kind = slug(session?.agent) || "agent";
-  const name = `${kind}-${work}`.slice(0, MAX_AGENT_NAME).replace(/[-_]+$/, "");
-  return AGENT_NAME.test(name) ? name : "";
+  // The work alone: which agent it is (claude, codex) was a guess from the environment, and Herdr
+  // already shows the kind beside it.
+  const name = slug(session?.name).slice(0, MAX_AGENT_NAME).replace(/[-_]+$/, "");
+  return name && AGENT_NAME.test(name) ? name : "";
 }
 
 function slug(text) {

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

@@ -11,8 +11,8 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import { spawnSync } from "node:child_process";
-import { SKILL_DIR, VERSION, VOICES, applySetup, configPath, listSounds, loadConfig, rogerRogerHome, saveConfig, voiceSample } from "./lib.mjs";
-import { PROVIDERS, SPEECH_SETUP, catalog } from "./tts.mjs";
+import { SKILL_DIR, VERSION, VOICES, applySetup, configPath, listSounds, loadConfig, readSlackCredentials, rogerRogerHome, saveConfig, voiceSample } from "./lib.mjs";
+import { PROVIDERS, SPEECH_SETUP, catalog, keyFor } from "./tts.mjs";
 import { envValue, hasSavedKey, saveKey } from "./speechkey.mjs";
 import { createApp, loginFinish, loginStart, setupStatus } from "./slackapp.mjs";
 import { cliInstallDir, findCli, installCli } from "./slackcli.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. 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.",
+  "- 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, and its first two words go on the Herdr tab, so lead with them (`security audit`, not `doing a security audit`). The spoken line (`--say`) is one or two sentences that carry the point itself, the result, the question or the next step in words, never just \"here is what's next\" or \"details in Slack\". No code, commands, paths or URLs in it: say what the thing is and why, and leave the command to the written message. If the skill isn't available, say so once.",
   MARK_END,
 ].join("\n");
 
@@ -471,6 +471,77 @@ async function chooseSpeech(ui, { config, persist }) {
   return { provider, voice, speech, hasKey };
 }
 
+// ---------------------------------------------------------------- what is set up already
+
+const HOOK_LABELS = { claude: "Claude Code", opencode: "OpenCode", codex: "Codex" };
+
+/**
+ * Everything an earlier setup left, read from where it lives rather than from a record of it: the
+ * settings, which agents have the skill, the standing instruction, the hooks, Herdr, the tray.
+ * `tray` is only known with a daemon to ask, so it is passed in.
+ */
+export function currentSetup({ home = os.homedir(), env = process.env, hooks = null, script = "", herdr = null, global = null, config = loadConfig(), tray = null } = {}) {
+  const hookAgents = Object.entries(hooks?.agents ?? {}).filter(([, a]) => {
+    try {
+      return a.present() && a.status({ script }).installed;
+    } catch {
+      return false;
+    }
+  }).map(([name]) => name);
+  const plugin = herdr ? herdrPlugin(herdr) : null;
+  return {
+    config,
+    // The version that set this up. Older setups didn't write it down; the global copy is the next best guess.
+    version: config?.installedVersion ?? (global?.present ? global.version : "") ?? "",
+    links: skillFootprint(home),
+    instructions: instructionFiles(home).filter((f) => f.has),
+    hooks: hookAgents,
+    herdr: plugin ? { root: plugin.plugin_root ?? "" } : null,
+    slack: Boolean(readSlackCredentials()),
+    tray,
+  };
+}
+
+const WHEN_LABELS = { auto: "when the agent judges it worth it", "done-and-blocked": "when done or blocked", "blocked-only": "only when blocked", "on-request": "only when asked" };
+const SPEECH_LABELS = { auto: "the agent decides how much", brief: "one short sentence", same: "the whole message" };
+
+/** The current setup as lines for a note: what reaches you, when, and where it is installed. */
+export function describeSetup(now, env = process.env) {
+  const c = now.config;
+  if (!c) return [];
+  const how = [];
+  if (c.methods.includes("slack")) how.push(`Slack (${c.slack?.target || "no target"})`);
+  if (c.methods.includes("sound")) how.push(`sound (${c.sound})`);
+  if (c.methods.includes("speech")) {
+    const provider = PROVIDERS[c.speechProvider] ?? PROVIDERS.gemini;
+    const key = keyFor(c);
+    how.push(`speech (${c.voice}, ${provider.label}, ${key.value ? `key in ${key.name}` : "no key"})`);
+  }
+  const list = (items) => (items.length ? items.join(", ") : "none");
+  return [
+    `Reaches you by   ${list(how)}`,
+    `Notifies         ${WHEN_LABELS[c.when] ?? c.when}${c.methods.includes("speech") ? `; ${SPEECH_LABELS[c.speech] ?? c.speech} out loud` : ""}`,
+    `Skill for        ${list(now.links.map((a) => a.label))}`,
+    `Always use it    ${now.instructions.length ? `yes, in ${now.instructions.map((f) => `${f.label}'s ${f.file}`).join(", ")}` : "not told"}`,
+    `Terminal pings   ${list(now.hooks.map((n) => HOOK_LABELS[n] ?? n))}`,
+    `Herdr plugin     ${now.herdr ? "registered" : "no"}`,
+    ...(now.tray ? [`Tray             ${now.tray.installed ? (now.tray.running ? "running" : "installed") : "no"}`] : []),
+  ];
+}
+
+/** The parts of the setup that can be gone through again, in the order they are asked. */
+export const SECTIONS = [
+  { id: "agents", label: "Which agents have the skill" },
+  { id: "instructions", label: "Telling agents to always use it" },
+  { id: "herdr", label: "The Herdr plugin" },
+  { id: "reach", label: "How you're reached", hint: "Slack, sound, speech" },
+  { id: "sound", label: "The sound" },
+  { id: "voice", label: "The voice", hint: "provider, key, voice, how much is said" },
+  { id: "when", label: "When agents notify you" },
+  { id: "hooks", label: "Pings for terminal questions" },
+  { id: "tray", label: "The tray icon" },
+];
+
 /** The whole conversation. Returns the process exit code. */
 export async function runInstall(args, { script, hooks, input = process.stdin, output = process.stdout, env = process.env, home = os.homedir() } = {}) {
   const ui = createUI({ input, output, env });
@@ -485,40 +556,74 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
 
   const summary = [];
   try {
-    ui.intro(`roger-roger ${VERSION ? c.dim(VERSION) : ""}`, "Brings you back to the conversation when you have walked away. A few questions, and your agents can reach you.");
-
     if (major < 18) {
       ui.failed(`Node ${process.versions.node} is too old`, "roger-roger needs Node 18 or newer (22 for Slack questions)");
       return 1;
     }
 
-    // ---- looking around
+    // ---- what is here, and what an earlier setup chose
     const config = loadConfig();
-    const agents = skillLinks(home).filter((a) => a.present);
     const herdr = findHerdr(env);
-    ui.done("Looking around", [
-      `Node ${process.versions.node}${major < 22 ? " (22 or newer is needed for Slack questions)" : ""}`,
-      `Agents: ${agents.filter((a) => !a.always).map((a) => a.label).join(", ") || "no agent folders found yet"}`,
-      herdr ? `Herdr ${herdr.version}` : "",
-      config ? "Settings from an earlier setup are the defaults below" : "First setup",
-    ]);
+    const global = globalCopy(env);
+    const trayStatus = config && (process.platform === "win32" || process.platform === "darwin")
+      ? (await daemon("tray", { _: ["status"] }).catch(() => null))?.data ?? null
+      : null;
+    const now = currentSetup({ home, env, hooks, script, herdr, global, config, tray: trayStatus });
+    const first = !config;
+    const from = now.version;
+    const upgrading = Boolean(from && VERSION && olderThan(from, VERSION));
+
+    ui.intro(
+      `roger-roger ${first ? (VERSION ? c.dim(VERSION) : "") : upgrading ? `${c.dim(from)} → ${c.bold(VERSION)}` : c.dim(VERSION)}`,
+      first
+        ? "Brings you back to the conversation when you have walked away. A few questions, and your agents can reach you."
+        : upgrading
+          ? `An update. Everything you chose before is kept unless you say otherwise.`
+          : "Already set up. Change what you like; everything else stays as it is.",
+    );
+
+    // ---- how much to go through: all of it the first time; on an update, what the user picks
+    let mode = "all";
+    let chosen = new Set(SECTIONS.map((s) => s.id));
+    if (!first) {
+      ui.note("Your setup now", describeSetup(now, env));
+      mode = await ui.select({
+        message: upgrading ? "How should the update go?" : "What would you like to do?",
+        initial: upgrading ? "keep" : "change",
+        choices: [
+          { value: "keep", label: upgrading ? "Keep everything, just update (recommended)" : "Keep everything, refresh what's installed", hint: "no questions: links, hooks, Herdr and the instructions are brought up to date" },
+          { value: "change", label: "Change some things", hint: "pick which parts, the rest stays as it is" },
+          { value: "all", label: "Go through everything", hint: "every question, with your current answers ready" },
+        ],
+      });
+      if (mode === "keep") chosen = new Set();
+      if (mode === "change") {
+        chosen = new Set(await ui.multiselect({
+          message: "What would you like to change?",
+          choices: SECTIONS.map((s) => ({ value: s.id, label: s.label, hint: s.hint ?? "" })),
+        }));
+      }
+    }
+    const asking = (id) => chosen.has(id);
+    if (!first && mode !== "all") ui.done(chosen.size ? `Changing: ${SECTIONS.filter((s) => chosen.has(s.id)).map((s) => s.label.toLowerCase()).join(", ")}` : "Keeping everything as it is");
 
     // ---- the copy everything points at: the global one, if there is or is about to be one
     let target = SKILL_DIR;
     let hookScript = script;
-    const global = globalCopy(env);
     const pick = pickTarget(SKILL_DIR, global);
     if (pick.reason === "global") {
-      ui.done("The roger-roger command is on your PATH", global.dir);
+      if (first || mode === "all") ui.done("The roger-roger command is on your PATH", global.dir);
     } else if (pick.offer) {
-      const yes = await ui.confirm(pick.reason === "update"
+      // An update of the global copy is what "keep everything, just update" means, so it isn't asked then.
+      const yes = pick.reason === "update" && mode === "keep" ? true : await ui.confirm(pick.reason === "update"
         ? { message: `Update the roger-roger command from ${pick.from} to ${pick.to}?`, hint: "npm install -g roger-roger@latest; the old one would keep answering" }
-        : { message: "Put the roger-roger command on your PATH?", hint: "npm install -g roger-roger, so you and your agents can run it from anywhere" });
+        : { message: "Put the roger-roger command on your PATH?", yes: "Yes (recommended)", hint: "npm install -g roger-roger, so you and your agents can run it from anywhere" });
       if (yes) {
         const done = await attempt(ui, pick.reason === "update" ? "Updating" : "Installing globally", () => ui.run(`${pick.reason === "update" ? "Updating" : "Installing"} roger-roger with npm`, () => installGlobally(env), { done: () => ({ text: `The roger-roger command is on your PATH${pick.to ? `, at ${pick.to}` : ""}`, detail: global.dir }) }), { skipLabel: "Carry on with this copy" });
         if (done !== null && fs.existsSync(path.join(global.dir, "scripts", "roger-roger.mjs"))) {
           target = global.dir;
           hookScript = path.join(global.dir, "scripts", "roger-roger.mjs");
+          if (pick.reason === "update") summary.push(`updated to ${pick.to}`);
           // The daemon should come from the copy that stays, not from the one npx will throw away.
           await daemon("stop").catch(() => {});
           spawnSync(process.execPath, [hookScript, "daemon", "start"], { encoding: "utf8", windowsHide: true, timeout: 30_000, env });
@@ -527,12 +632,22 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
     }
 
     // ---- the skill, where agents look for it
-    const wanted = await ui.multiselect({
-      message: "Which agents should have the skill?",
-      choices: agents.map((a) => ({ value: a.id, label: a.label, hint: a.hint ?? `~/${a.dir.join("/")}/skills`, checked: true })),
-    });
+    const agents = skillLinks(home).filter((a) => a.present);
+    const linkedBefore = new Set(now.links.map((a) => a.id));
+    const wanted = asking("agents")
+      ? await ui.multiselect({
+          message: "Which agents should have the skill?",
+          choices: agents.map((a) => ({ value: a.id, label: a.label, hint: a.hint ?? `~/${a.dir.join("/")}/skills`, checked: first || linkedBefore.has(a.id) })),
+        })
+      : agents.filter((a) => linkedBefore.has(a.id)).map((a) => a.id);
+    let relinked = 0;
     for (const a of agents.filter((x) => wanted.includes(x.id))) {
       const plan = planLink(a.link, target);
+      if (plan.action === "none") {
+        if (asking("agents")) ui.done(`${a.label}: ${plan.note}`, a.link);
+        summary.push(a.label);
+        continue;
+      }
       if (plan.action === "replace") {
         const yes = await ui.confirm({ message: `${a.label} has its own copy of the skill. Replace it with a link?`, hint: "the copy is moved aside, not deleted" });
         if (!yes) {
@@ -546,33 +661,53 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
       }
       try {
         const done = applyLink(a.link, target, plan);
-        ui.done(`${a.label}: ${plan.action === "none" ? plan.note : "linked"}`, `${a.link}${done.movedTo ? ` (the copy is at ${done.movedTo})` : ""}`);
+        ui.done(`${a.label}: ${plan.action === "relink" ? "now points at this copy" : "linked"}`, `${a.link}${done.movedTo ? ` (the copy is at ${done.movedTo})` : ""}`);
         summary.push(a.label);
+        relinked++;
       } catch (e) {
         ui.failed(`${a.label}: could not link`, e.message);
       }
     }
+    // Taken off an agent that had it.
+    for (const a of now.links.filter((x) => asking("agents") && !wanted.includes(x.id))) {
+      try {
+        removeSkillLink(a.link);
+        ui.done(`${a.label}: skill removed`, a.link);
+      } catch (e) {
+        ui.failed(`${a.label}: could not remove`, e.message);
+      }
+    }
+    if (!asking("agents") && linkedBefore.size && !relinked) ui.done("The skill is linked as before", now.links.map((a) => a.label).join(", "));
 
     // ---- the standing instruction, so agents use it without being told each time
     const instructionTargets = instructionFiles(home).filter((f) => f.present);
     if (instructionTargets.length) {
       const already = instructionTargets.filter((f) => f.has);
-      const yes = await ui.confirm({
-        message: already.length === instructionTargets.length ? "Keep telling your agents to always use roger-roger?" : "Tell your agents to always use roger-roger?",
-        yes: "Yes (recommended)",
-        hint: `a marked block in ${instructionTargets.map((f) => `~/${[...f.dir, f.file].join("/")}`).join(", ")}`,
-        initial: true,
-      });
+      const yes = asking("instructions")
+        ? await ui.confirm({
+            message: already.length ? "Keep telling your agents to always use roger-roger?" : "Tell your agents to always use roger-roger?",
+            yes: "Yes (recommended)",
+            hint: `a marked block in ${instructionTargets.map((f) => `~/${[...f.dir, f.file].join("/")}`).join(", ")}`,
+            initial: first || already.length > 0,
+          })
+        : already.length > 0;
       if (yes) {
-        for (const f of instructionTargets) {
+        // Kept, it is still refreshed, so a changed wording reaches every agent.
+        const files = asking("instructions") ? instructionTargets : already;
+        let refreshed = 0;
+        for (const f of files) {
           try {
+            const before = fs.readFileSync(f.path, "utf8").toString();
             const r = addInstructions(f.path);
-            ui.done(`${f.label}: ${r.added ? "instructions added" : "instructions refreshed"}`, f.path);
+            const changed = fs.readFileSync(f.path, "utf8") !== before;
+            if (r.added || changed || asking("instructions")) ui.done(`${f.label}: ${r.added ? "instructions added" : changed ? "instructions brought up to date" : "instructions already up to date"}`, f.path);
+            if (changed) refreshed++;
             summary.push(`instructions: ${f.label}`);
           } catch (e) {
             ui.failed(`${f.label}: could not write ${f.path}`, e.message);
           }
         }
+        if (!asking("instructions") && !refreshed) ui.done("Instructions unchanged", already.map((f) => f.path).join(", "));
       } else if (already.length) {
         for (const f of already) {
           try {
@@ -588,13 +723,25 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
     // ---- herdr
     let herdrDone = false;
     if (herdr) {
-      const yes = await ui.confirm({ message: "Register with Herdr as a plugin?", hint: "starts the daemon with Herdr, adds snooze to its actions" });
+      const yes = asking("herdr")
+        ? await ui.confirm({ message: "Register with Herdr as a plugin?", hint: "starts the daemon with Herdr, adds snooze to its actions", initial: first || Boolean(now.herdr) })
+        : Boolean(now.herdr);
       if (yes) {
-        const r = herdrLink(herdr, target);
-        if (r.ok) {
-          ui.done("Registered with Herdr", r.note ?? "herdr plugin list shows it");
+        // Registered elsewhere (an older copy): unlinked and linked again, so Herdr runs this one.
+        const stale = now.herdr && norm(now.herdr.root.replace(/^\\\\\?\\/, "")) !== norm(target);
+        if (stale) herdrUnlink(herdr);
+        if (!now.herdr || stale || asking("herdr")) {
+          const r = herdrLink(herdr, target);
+          if (r.ok) {
+            ui.done(stale ? "Herdr now runs this copy" : "Registered with Herdr", r.note ?? target);
+            herdrDone = true;
+          } else ui.failed("Herdr would not link the plugin", r.error);
+        } else {
           herdrDone = true;
-        } else ui.failed("Herdr would not link the plugin", r.error);
+        }
+      } else if (now.herdr) {
+        const r = herdrUnlink(herdr);
+        if (r.ok) ui.done("Herdr plugin unlinked");
       }
     }
 
@@ -607,98 +754,112 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
       return merged;
     };
 
-    let methods = await ui.multiselect({
-      message: "How should agents reach you?",
-      min: 1,
-      choices: [
-        { value: "slack", label: "Slack", hint: "a DM from the roger-roger bot, with buttons to answer", checked: config ? config.methods.includes("slack") : true },
-        { value: "sound", label: "Sound", hint: "a short sound from the speakers", checked: config ? config.methods.includes("sound") : true },
-        { value: "speech", label: "Speech", hint: "a spoken line, in a voice you choose", checked: config ? config.methods.includes("speech") : true },
-      ],
-    });
-
-    let slack = null;
-    if (methods.includes("slack")) {
-      const connected = await connectSlack(ui);
-      if (connected) {
-        slack = await slackTarget(ui, { config, userId: connected.userId });
-        setupArgs["slack-target"] = slack.target;
-        setupArgs["slack-mention"] = slack.mention;
-        summary.push(`Slack → ${slack.target === connected.userId ? `your DMs (${connected.team})` : slack.target}`);
-      } else if (config?.slack?.target) {
-        slack = { target: config.slack.target, mention: config.slack.mention ?? "" };
-        ui.done("Slack stays as it was", `messages go to ${slack.target}`);
-      } else {
-        methods = methods.filter((m) => m !== "slack");
-        ui.done("Slack left out for now", "run `roger-roger install` again to connect it");
+    let methods = config?.methods ?? [];
+    if (asking("reach")) {
+      methods = await ui.multiselect({
+        message: "How should agents reach you?",
+        min: 1,
+        choices: [
+          { value: "slack", label: "Slack", hint: "a DM from the roger-roger bot, with buttons to answer", checked: config ? config.methods.includes("slack") : true },
+          { value: "sound", label: "Sound", hint: "a short sound from the speakers", checked: config ? config.methods.includes("sound") : true },
+          { value: "speech", label: "Speech", hint: "a spoken line, in a voice you choose", checked: config ? config.methods.includes("speech") : true },
+        ],
+      });
+      if (methods.includes("slack")) {
+        const connected = await connectSlack(ui);
+        if (connected) {
+          const slack = await slackTarget(ui, { config, userId: connected.userId });
+          setupArgs["slack-target"] = slack.target;
+          setupArgs["slack-mention"] = slack.mention;
+          summary.push(`Slack → ${slack.target === connected.userId ? `your DMs (${connected.team})` : slack.target}`);
+        } else if (config?.slack?.target) {
+          ui.done("Slack stays as it was", `messages go to ${config.slack.target}`);
+        } else {
+          methods = methods.filter((m) => m !== "slack");
+          ui.done("Slack left out for now", "run `roger-roger install` again to connect it");
+        }
       }
+      await persist({ methods: methods.join(",") });
+      // Newly turned on, the parts that go with it are asked even if they weren't picked.
+      if (methods.includes("sound") && !config?.methods?.includes("sound")) chosen.add("sound");
+      if (methods.includes("speech") && !config?.methods?.includes("speech")) chosen.add("voice");
+      if (methods.includes("slack") && !config?.methods?.includes("slack")) chosen.add("hooks");
     }
-    await persist({ methods: methods.join(",") });
 
-    if (methods.includes("sound")) {
-      const sounds = listSounds();
+    if (methods.includes("sound") && asking("sound")) {
       const sound = await ui.select({
         message: "Which sound?",
         initial: config?.sound ?? "chime",
-        choices: sounds.map((s) => ({ value: s, label: s, hint: SOUND_HINTS[s] ?? "", preview: () => daemon("play", { _: [s] }), previewing: `playing ${s}…` })),
+        choices: listSounds().map((s) => ({ value: s, label: s, hint: `${SOUND_HINTS[s] ?? ""}${config?.sound === s ? " · current" : ""}`, preview: () => daemon("play", { _: [s] }), previewing: `playing ${s}…` })),
       });
       await persist({ sound });
       summary.push(`sound: ${sound}`);
     }
 
-    if (methods.includes("speech")) {
-      const chosen = await chooseSpeech(ui, { config, persist });
-      await persist({ voice: chosen.voice, speech: chosen.speech });
-      summary.push(`voice: ${chosen.voice} (${PROVIDERS[chosen.provider].label}${chosen.hasKey ? "" : ", no key yet"})`);
+    if (methods.includes("speech") && asking("voice")) {
+      const voice = await chooseSpeech(ui, { config, persist });
+      await persist({ voice: voice.voice, speech: voice.speech });
+      summary.push(`voice: ${voice.voice} (${PROVIDERS[voice.provider].label}${voice.hasKey ? "" : ", no key yet"})`);
     }
 
-    const when = await ui.select({
-      message: "When should agents notify you?",
-      initial: config?.when ?? "auto",
-      choices: [
-        { value: "auto", label: "Let the agent judge", hint: "long tasks done, blocked, failures, big milestones" },
-        { value: "done-and-blocked", label: "Done and blocked", hint: "when finished, or when it needs you" },
-        { value: "blocked-only", label: "Blocked only", hint: "only when it cannot go on without you" },
-        { value: "on-request", label: "Only when asked", hint: "when you say \"ping me\" in a conversation" },
-      ],
-    });
-    await persist({ when });
-    summary.push(`notify: ${when}`);
+    if (asking("when")) {
+      const when = await ui.select({
+        message: "When should agents notify you?",
+        initial: config?.when ?? "auto",
+        choices: [
+          { value: "auto", label: "Let the agent judge", hint: "long tasks done, blocked, failures, big milestones" },
+          { value: "done-and-blocked", label: "Done and blocked", hint: "when finished, or when it needs you" },
+          { value: "blocked-only", label: "Blocked only", hint: "only when it cannot go on without you" },
+          { value: "on-request", label: "Only when asked", hint: "when you say \"ping me\" in a conversation" },
+        ],
+      });
+      await persist({ when });
+      summary.push(`notify: ${WHEN_LABELS[when] ?? when}`);
+    }
 
     // ---- terminal questions
     const hookAgents = Object.entries(hooks?.agents ?? {}).filter(([, a]) => a.present());
     if (hookAgents.length && methods.includes("slack")) {
-      const labels = { claude: "Claude Code", opencode: "OpenCode", codex: "Codex" };
-      const installed = hookAgents.every(([, a]) => {
-        const s = a.status({ script: hookScript });
-        return s.installed && !s.note;
-      });
-      if (installed) {
-        ui.done("Terminal questions reach Slack", hookAgents.map(([n]) => labels[n] ?? n).join(", "));
-      } else {
-        const yes = await ui.confirm({
-          message: "Ping you in Slack when an agent asks a question in the terminal?",
-          hint: hookAgents.map(([n]) => labels[n] ?? n).join(", "),
-        });
-        if (yes) {
-          for (const [name, a] of hookAgents) {
-            try {
-              a.install({ script: hookScript });
-              ui.done(`${labels[name] ?? name}: hooks installed`, name === "codex" ? "open /hooks in Codex once and trust the three roger-roger hooks" : name === "opencode" ? "restart OpenCode to load the plugin" : "");
-              summary.push(`hooks: ${labels[name] ?? name}`);
-            } catch (e) {
-              ui.failed(`${labels[name] ?? name}: could not install the hooks`, e.message);
-            }
+      const had = new Set(now.hooks);
+      const names = hookAgents.map(([n]) => HOOK_LABELS[n] ?? n).join(", ");
+      const yes = asking("hooks")
+        ? await ui.confirm({ message: had.size ? "Keep pinging you in Slack for questions asked in the terminal?" : "Ping you in Slack when an agent asks a question in the terminal?", hint: names, initial: first || had.size > 0 })
+        : had.size > 0;
+      if (yes) {
+        for (const [name, a] of hookAgents) {
+          const status = a.status({ script: hookScript });
+          // Installed and pointing here: nothing to do. Anything else is (re)installed.
+          if (status.installed && !status.note) {
+            if (asking("hooks")) ui.done(`${HOOK_LABELS[name] ?? name}: hooks in place`);
+            summary.push(`hooks: ${HOOK_LABELS[name] ?? name}`);
+            continue;
+          }
+          if (!asking("hooks") && !had.has(name)) continue; // kept means kept: no new agents unasked
+          try {
+            a.install({ script: hookScript });
+            ui.done(`${HOOK_LABELS[name] ?? name}: hooks ${status.installed ? "now point at this copy" : "installed"}`, name === "codex" && !status.installed ? "open /hooks in Codex once and trust the three roger-roger hooks" : name === "opencode" ? "restart OpenCode to load the plugin" : "");
+            summary.push(`hooks: ${HOOK_LABELS[name] ?? name}`);
+          } catch (e) {
+            ui.failed(`${HOOK_LABELS[name] ?? name}: could not install the hooks`, e.message);
+          }
+        }
+      } else if (had.size) {
+        for (const name of had) {
+          try {
+            hooks.agents[name].uninstall();
+            ui.done(`${HOOK_LABELS[name] ?? name}: hooks removed`);
+          } catch (e) {
+            ui.failed(`${HOOK_LABELS[name] ?? name}: could not remove the hooks`, e.message);
           }
         }
       }
     }
 
     // ---- tray
-    if (process.platform === "win32" || process.platform === "darwin") {
-      const status = await daemon("tray", { _: ["status"] }).catch(() => null);
-      if (status?.data?.installed) {
-        ui.done("Tray icon is installed", status.data.running ? "and running" : "it starts with the daemon");
+    if ((process.platform === "win32" || process.platform === "darwin") && (first || asking("tray"))) {
+      const status = trayStatus ?? (await daemon("tray", { _: ["status"] }).catch(() => null))?.data;
+      if (status?.installed) {
+        ui.done("Tray icon is installed", status.running ? "and running" : "it starts with the daemon");
       } else {
         const yes = await ui.confirm({ message: "Show every agent in the system tray?", hint: "downloads about 4 MB, nothing compiled", initial: true });
         if (yes) {
@@ -711,29 +872,38 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
       }
     }
 
-    // ---- try it
+    // ---- remember which version did this, so the next run can say what it is updating from
+    if (VERSION) {
+      const saved = loadConfig();
+      if (saved) saveConfig({ ...saved, installedVersion: VERSION });
+    }
+
+    // ---- try it: offered the first time, and when how you're reached has changed
     await ui.run("Starting the daemon", () => daemon("ping"), { done: (r) => ({ text: "Daemon running", detail: `pid ${r.data?.pid ?? "?"}, it stays up for every agent on this machine` }) }).catch(() => {});
-    const session = { identity: identity(env, process.cwd(), { session: "roger-roger install" }), about: { name: "roger-roger install", agent: "install" } };
-    const test = await ui.confirm({ message: "Send a test notification now?" });
-    if (test) {
-      await attempt(ui, "Sending the test", () =>
-        ui.run("Sending", () =>
-          daemon("notify", {
-            kind: "info",
-            message: "roger-roger is set up. This is what a notification looks like.",
-            say: "[positive] Roger roger. You are all set.",
-            project: "roger-roger",
-            session: "roger-roger install",
-          }, session),
-        { done: (r) => ({ text: "Test notification sent", detail: describeResults(r.data?.results) }) }),
-      { skipLabel: "Skip the test" });
+    const touchedDelivery = ["reach", "sound", "voice"].some(asking);
+    if (first || touchedDelivery) {
+      const session = { identity: identity(env, process.cwd(), { session: "roger-roger install" }), about: { name: "roger-roger install", agent: "install" } };
+      const test = await ui.confirm({ message: "Send a test notification now?", initial: first });
+      if (test) {
+        await attempt(ui, "Sending the test", () =>
+          ui.run("Sending", () =>
+            daemon("notify", {
+              kind: "info",
+              message: "roger-roger is set up. This is what a notification looks like.",
+              say: "[positive] Roger roger. You are all set.",
+              project: "roger-roger",
+              session: "roger-roger install",
+            }, session),
+          { done: (r) => ({ text: "Test notification sent", detail: describeResults(r.data?.results) }) }),
+        { skipLabel: "Skip the test" });
+      }
+      await daemon("end", {}, session).catch(() => {});
     }
-    await daemon("end", {}, session).catch(() => {});
 
     ui.outro([
-      c.bold("Done."),
+      c.bold(first ? "Done." : upgrading ? `Updated to ${VERSION}.` : "Done."),
       "",
-      ...summary.map((s) => `${c.green("•")} ${s}`),
+      ...[...new Set(summary)].map((s) => `${c.green("•")} ${s}`),
       ...(herdrDone ? [`${c.green("•")} Herdr plugin`] : []),
       "",
       `Settings: ${c.dim(configPath())}`,
@@ -772,11 +942,16 @@ export function removeSkillLink(link, fsx = fs) {
 
 /** Whether Herdr has the plugin, so uninstall can say so rather than guess. */
 export function herdrHasPlugin(herdr) {
+  return Boolean(herdrPlugin(herdr));
+}
+
+/** The registered plugin as Herdr lists it (with its `plugin_root`), or null. */
+export function herdrPlugin(herdr) {
   try {
     const r = spawnSync(herdr.command, ["plugin", "list", "--json"], { encoding: "utf8", windowsHide: true, timeout: 15_000 });
-    return (JSON.parse(r.stdout)?.result?.plugins ?? []).some((p) => p.plugin_id === "roger-roger");
+    return (JSON.parse(r.stdout)?.result?.plugins ?? []).find((p) => p.plugin_id === "roger-roger") ?? null;
   } catch {
-    return false;
+    return null;
   }
 }
 

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

@@ -68,10 +68,22 @@ export function isNickname(value) {
  * A free nickname from the pool, chosen at random so consecutive sessions don't look alike. Falls
  * back to numbering (`sage2`) only once every name in the pool is in use.
  */
-export function pickName(taken = [], pool = NAMES, random = Math.random) {
+/**
+ * A name for a new session. `taken` are names in use right now and are never given out; `avoid`
+ * are names a quiet session was using lately, given out only once nothing else is left, so a
+ * session that goes quiet for an hour comes back to its own name rather than someone else's.
+ */
+export function pickName(taken = [], pool = NAMES, random = Math.random, { avoid = [] } = {}) {
   const used = new Set(taken.map((n) => String(n).toLowerCase()));
   const names = (pool.length ? pool : NAMES).map((n) => String(n).toLowerCase()).filter(isNickname);
-  const free = names.filter((n) => !used.has(n));
+  // `avoid` runs from the most recently quiet to the longest quiet. Names are freed from the end
+  // of it one at a time, so the name lent out is the one whose owner has been gone the longest.
+  const held = avoid.map((n) => String(n).toLowerCase());
+  let free = [];
+  for (let keep = held.length; keep >= 0 && !free.length; keep--) {
+    const reserved = new Set(held.slice(0, keep));
+    free = names.filter((n) => !used.has(n) && !reserved.has(n));
+  }
   // Two of a kind side by side defeat the point, so prefer an emoji nobody is wearing.
   const swatches = new Set([...used].map((n) => colourOf(n).swatch));
   const distinct = free.filter((n) => !swatches.has(colourOf(n).swatch));

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

@@ -16,7 +16,8 @@ import { NAMES, colourOf, pickName } from "./names.mjs";
 const QUIET_MS = 30 * 60 * 1000;
 // Even with a live pid, a session that hasn't said anything all day is no longer a sensible target.
 const MAX_IDLE_MS = 12 * 3600 * 1000;
-const FORGET_MS = 7 * 24 * 3600 * 1000;
+// A conversation can be picked up again weeks later, and should come back under the name it had.
+const FORGET_MS = 30 * 24 * 3600 * 1000;
 const MAX_QUEUE = 50;
 
 export const STATES = ["working", "waiting", "paused", "done"];
@@ -87,15 +88,20 @@ export function register(identity, about = {}, pool = NAMES) {
       : identity.id;
     if (fingerprint) state.aliases[fingerprint] = id;
     const existing = state.sessions[id];
-    const taken = Object.values(state.sessions)
-      .filter((s) => s.id !== id && isLive(s))
+    const others = Object.values(state.sessions).filter((s) => s.id !== id && !s.endedAt);
+    const taken = others.filter((s) => isLive(s)).map((s) => s.nickname);
+    // Names quiet sessions are still remembered by, the most recently quiet first: a newcomer gets
+    // one only when nothing else is free, and then the one whose owner has been gone longest.
+    const avoid = others
+      .filter((s) => !isLive(s))
+      .sort((a, b) => Date.parse(b.lastSeen ?? 0) - Date.parse(a.lastSeen ?? 0))
       .map((s) => s.nickname);
     const session = {
       ...existing,
       id,
       // A session keeps its name, unless someone else was given it while this one was quiet — two
       // live agents answering to "jade" is exactly what the names are there to prevent.
-      nickname: existing?.nickname && !taken.includes(existing.nickname) ? existing.nickname : pickName(taken, pool),
+      nickname: existing?.nickname && !taken.includes(existing.nickname) ? existing.nickname : pickName(taken, pool, Math.random, { avoid }),
       pid: identity.pid || existing?.pid || 0,
       cwd: identity.cwd ?? existing?.cwd ?? "",
       project: identity.project || existing?.project || "",