roger-roger 0.1.4 → 0.1.13

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. 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, 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;
   }
 }