roger-roger 0.1.0

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

@@ -0,0 +1,560 @@
+// `roger-roger install`: everything between "npm install" and the first notification, asked in the
+// terminal rather than through an agent. It links the skill into every agent's skills folder, tells
+// Herdr about it, connects Slack, lets the user hear the sounds and voices before choosing, installs
+// the terminal-question hooks and the tray, and ends with a test notification.
+//
+// Each step is safe to repeat: run it again to change anything, and a step that is already done
+// says so and moves on. Without a terminal (or with --yes) only the parts that need no answer run:
+// the links, and the Herdr plugin.
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { SKILL_DIR, VOICES, applySetup, configPath, listSounds, loadConfig, saveConfig, voiceSample } from "./lib.mjs";
+import { PROVIDERS, SPEECH_SETUP, catalog, keyFor } from "./tts.mjs";
+import { saveKey } from "./speechkey.mjs";
+import { createApp, loginFinish, loginStart, setupStatus } from "./slackapp.mjs";
+import { installCli } from "./slackcli.mjs";
+import { call } from "./client.mjs";
+import { identity } from "./agent.mjs";
+import { Cancelled, createUI } from "./tui.mjs";
+
+export const VERSION = (() => {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(SKILL_DIR, "..", "..", "package.json"), "utf8")).version ?? "";
+  } catch {
+    return "";
+  }
+})();
+
+// ---------------------------------------------------------------- where skills live
+
+/** The agents that read skills from a folder in the home directory, and where. */
+export const SKILL_HOMES = [
+  { id: "claude", label: "Claude Code", dir: [".claude"] },
+  { id: "codex", label: "Codex", dir: [".codex"] },
+  { id: "opencode", label: "OpenCode", dir: [".config", "opencode"] },
+  { id: "cursor", label: "Cursor", dir: [".cursor"] },
+  { id: "gemini", label: "Gemini CLI", dir: [".gemini"] },
+  { id: "copilot", label: "GitHub Copilot CLI", dir: [".copilot"] },
+  { id: "agents", label: "Shared skills folder", dir: [".agents"], always: true, hint: "~/.agents/skills, where `npx skills add` puts skills" },
+];
+
+/** Where each agent would find the skill, and which agents are on this machine. */
+export function skillLinks(home = os.homedir(), fsx = fs) {
+  return SKILL_HOMES.map((a) => {
+    const root = path.join(home, ...a.dir);
+    return {
+      ...a,
+      root,
+      link: path.join(root, "skills", "roger-roger"),
+      present: a.always || fsx.existsSync(root),
+    };
+  });
+}
+
+/** One shape for a path, so two spellings of one place compare equal (macOS's /var is /private/var). */
+const norm = (p, fsx = fs) => {
+  let r = path.resolve(p).replace(/[\\/]+$/, "");
+  try {
+    r = fsx.realpathSync(r);
+  } catch {}
+  return process.platform === "win32" ? r.toLowerCase() : r;
+};
+
+/**
+ * What to do so that `link` leads to `target`: nothing, create it, point an old link elsewhere at
+ * it, replace a real folder (a copy from `npx skills add`), or leave a file alone.
+ */
+export function planLink(link, target, fsx = fs) {
+  let st;
+  try {
+    st = fsx.lstatSync(link);
+  } catch {
+    return { action: "create" };
+  }
+  if (st.isSymbolicLink()) {
+    let to = "";
+    try {
+      to = fsx.readlinkSync(link);
+    } catch {}
+    const resolved = path.resolve(path.dirname(link), to);
+    return norm(resolved, fsx) === norm(target, fsx) ? { action: "none", note: "already linked" } : { action: "relink", current: resolved };
+  }
+  if (st.isDirectory()) {
+    return norm(link, fsx) === norm(target, fsx) ? { action: "none", note: "this is the copy itself" } : { action: "replace", current: link };
+  }
+  return { action: "conflict", current: link };
+}
+
+/** Carry out a plan. A `replace` moves the folder aside rather than deleting it. */
+export function applyLink(link, target, plan, fsx = fs, now = new Date()) {
+  if (plan.action === "none" || plan.action === "conflict") return plan;
+  if (plan.action === "relink") fsx.unlinkSync(link);
+  if (plan.action === "replace") {
+    const stamp = now.toISOString().slice(0, 16).replace(/[-:T]/g, "");
+    const aside = `${link}.replaced-${stamp}`;
+    fsx.renameSync(link, aside);
+    plan = { ...plan, movedTo: aside };
+  }
+  fsx.mkdirSync(path.dirname(link), { recursive: true });
+  fsx.symlinkSync(target, link, process.platform === "win32" ? "junction" : "dir");
+  return { ...plan, done: true };
+}
+
+// ---------------------------------------------------------------- herdr
+
+/** The `herdr` binary, from the pane's environment or PATH: `{ command, version }`, or null. */
+export function findHerdr(env = process.env) {
+  const candidates = [env.HERDR_BIN_PATH, "herdr"].filter(Boolean);
+  for (const command of candidates) {
+    try {
+      const r = spawnSync(command, ["--version"], { encoding: "utf8", windowsHide: true, timeout: 10_000, env });
+      const m = /herdr\s+v?(\d+\.\d+\.\d+)/.exec(`${r.stdout}${r.stderr}`);
+      if (r.status === 0) return { command, version: m?.[1] ?? "" };
+    } catch {}
+  }
+  return null;
+}
+
+/** Register the skill folder as a Herdr plugin (its manifest is `herdr-plugin.toml` in there). */
+export function herdrLink(herdr, dir = SKILL_DIR) {
+  const r = spawnSync(herdr.command, ["plugin", "link", dir, "--enabled"], { encoding: "utf8", windowsHide: true, timeout: 20_000 });
+  if (r.status === 0) return { ok: true, output: r.stdout.trim() };
+  const text = `${r.stderr}${r.stdout}`.trim();
+  let message = text;
+  try {
+    message = JSON.parse(text)?.error?.message ?? text;
+  } catch {}
+  if (/already/i.test(message)) return { ok: true, note: message };
+  return { ok: false, error: message || `herdr plugin link exited with ${r.status ?? r.error?.message}` };
+}
+
+// ---------------------------------------------------------------- the quiet part
+
+/**
+ * The steps that need no answers: link the skill for every agent present, and into Herdr if it is
+ * here. `replaceDirs` says whether a folder that is a copy of the skill may be moved aside.
+ */
+export function quietInstall({ home = os.homedir(), env = process.env, target = SKILL_DIR, agents = null, replaceDirs = false } = {}) {
+  const links = skillLinks(home)
+    .filter((a) => a.present && (!agents || agents.includes(a.id)))
+    .map((a) => {
+      const plan = planLink(a.link, target);
+      if (plan.action === "replace" && !replaceDirs) return { agent: a.id, label: a.label, link: a.link, ...plan, skipped: "a folder is there already; run `roger-roger install` in a terminal to replace it" };
+      try {
+        return { agent: a.id, label: a.label, link: a.link, ...applyLink(a.link, target, plan) };
+      } catch (e) {
+        return { agent: a.id, label: a.label, link: a.link, ...plan, error: e.message };
+      }
+    });
+  const herdr = findHerdr(env);
+  return {
+    target,
+    links,
+    herdr: herdr ? { ...herdr, ...herdrLink(herdr, target) } : null,
+  };
+}
+
+// ---------------------------------------------------------------- the conversation
+
+const SOUND_HINTS = {
+  chime: "two rising bell notes",
+  ding: "a single bell",
+  marimba: "soft and low",
+  bubble: "two quick pops",
+  alert: "three insistent beeps",
+};
+
+const PROVIDER_HINTS = {
+  gemini: "Google · 30 expressive voices, reads tone tags",
+  openai: "gpt-4o-mini-tts and friends",
+  elevenlabs: "your own voice library",
+};
+
+/** Ask the daemon for something, the way the CLI would. */
+const daemon = (cmd, args = {}, session = null) => call(cmd, args, { session });
+
+/** One retry loop for a step that talks to the network. */
+async function attempt(ui, label, fn, { skipLabel = `Skip ${label} for now` } = {}) {
+  for (;;) {
+    try {
+      return await fn();
+    } catch (e) {
+      if (e instanceof Cancelled) throw e;
+      ui.failed(`${label} didn't work`, e.message);
+      const next = await ui.select({
+        message: "What now?",
+        choices: [
+          { value: "retry", label: "Try again" },
+          { value: "skip", label: skipLabel, hint: "run `roger-roger install` again later" },
+        ],
+      });
+      if (next === "skip") return null;
+    }
+  }
+}
+
+/** Slack: install the CLI, log in, create the app. Returns the user's member ID, or null if skipped. */
+async function connectSlack(ui) {
+  for (;;) {
+    const status = await attempt(ui, "Checking Slack", () => ui.run("Checking the Slack connection", () => setupStatus(), { done: () => "Checked Slack" }));
+    if (!status) return null;
+    if (status.next === "done") {
+      const account = status.logins.find((l) => l.teamId === status.app?.teamId) ?? status.logins[0];
+      ui.done("Slack is connected", account ? `${account.team}, through the roger-roger app` : "");
+      return { userId: account?.userId ?? "", team: account?.team ?? "" };
+    }
+    if (status.next === "install-cli") {
+      const yes = await ui.confirm({ message: "Install the Slack CLI?", hint: "Slack's official tool, installed for your user only" });
+      if (!yes) return null;
+      const cli = await attempt(ui, "Installing the Slack CLI", () => ui.run("Downloading the Slack CLI", () => installCli(), { done: (c) => `Installed the Slack CLI ${c.version}` }));
+      if (!cli) return null;
+      continue;
+    }
+    if (status.next === "login") {
+      const ticket = await attempt(ui, "Logging in", () => ui.run("Asking Slack for a login ticket", () => loginStart(), { done: () => "Got a login ticket" }));
+      if (!ticket) return null;
+      ui.note("Log the Slack CLI in", [
+        "1. Paste this into any message box in Slack, in the workspace you want:",
+        "",
+        `   ${ticket.command}`,
+        "",
+        "2. Approve the dialog. Slack then shows you a challenge code.",
+        "3. Type or paste that code below.",
+      ]);
+      const code = await ui.text({ message: "Challenge code", placeholder: "the code Slack showed you", validate: (v) => (v ? "" : "paste the code, or press Esc to stop") });
+      const done = await attempt(ui, "Logging in", () => ui.run("Finishing the login", () => loginFinish({ challenge: code, ticket: ticket.ticket }), { done: (a) => `Logged in to ${a.map((x) => x.team).join(", ")}` }));
+      if (!done) return null;
+      continue;
+    }
+    if (status.next === "create") {
+      let teamId;
+      if (status.logins.length > 1) {
+        teamId = await ui.select({ message: "Which workspace?", choices: status.logins.map((l) => ({ value: l.teamId, label: l.team, hint: l.teamId })) });
+      }
+      const app = await attempt(ui, "Creating the Slack app", () => ui.run("Creating the roger-roger app in your workspace", () => createApp({ teamId }), { done: (a) => ({ text: `Created the roger-roger app in ${a.team}`, detail: "its tokens are in ~/.roger-roger/slack.json" }) }));
+      if (!app) return null;
+      return { userId: app.userId, team: app.team };
+    }
+    throw new Error(`unexpected Slack setup state "${status.next}"`);
+  }
+}
+
+/** Where Slack messages go: the user's DMs, the target they had, or a channel. */
+async function slackTarget(ui, { config, userId }) {
+  const current = config?.slack?.target ?? "";
+  const choices = [];
+  if (userId) choices.push({ value: "dm", label: "Direct messages", hint: `from the roger-roger bot, to you (${userId})` });
+  if (current && current !== userId) choices.push({ value: "keep", label: `Keep ${current}`, hint: "what it is set to now" });
+  choices.push({ value: "channel", label: "A channel", hint: "invite the bot to it first" });
+  const pick = choices.length === 1 ? choices[0].value : await ui.select({ message: "Where should messages go?", choices, initial: current && current !== userId ? "keep" : "dm" });
+  if (pick === "dm") return { target: userId, mention: "" };
+  if (pick === "keep") return { target: current, mention: config?.slack?.mention ?? "" };
+  const target = await ui.text({ message: "Which channel?", placeholder: "C0123ABCD or #channel-name", validate: (v) => (/^(C[A-Z0-9]+|#[\w-]+)$/i.test(v) ? "" : "a channel ID (C…) or a #name") });
+  const mention = await ui.text({
+    message: "Mention you in channel posts?",
+    placeholder: "your member ID (U0123ABCD), or leave empty",
+    initial: userId,
+    validate: (v) => (!v || /^U[A-Z0-9]+$/i.test(v) ? "" : "a member ID starts with U"),
+  });
+  return { target, mention };
+}
+
+/** The voice: provider, key, voice, and how much to say. */
+async function chooseSpeech(ui, { config, persist }) {
+  const provider = await ui.select({
+    message: "Who should make the voice?",
+    initial: config?.speechProvider ?? "gemini",
+    choices: Object.values(PROVIDERS).map((p) => ({ value: p.id, label: p.label, hint: PROVIDER_HINTS[p.id] ?? "" })),
+  });
+  const p = PROVIDERS[provider];
+  // Saved now so the previews below speak with this provider, not the one configured before.
+  await persist({ "speech-provider": provider });
+  let key = keyFor({ speechProvider: provider, speechKeyVar: config?.speechProvider === provider ? config?.speechKeyVar ?? "" : "" });
+  if (key.value) {
+    ui.done(`${p.label} key found`, `in ${key.name}`);
+  } else {
+    const pasted = await ui.text({
+      message: `${p.label} API key`,
+      mask: true,
+      placeholder: "paste it, or leave empty to use the computer's own voice for now",
+    });
+    if (pasted) {
+      const file = saveKey(p.keyVars[0], pasted);
+      key = { name: p.keyVars[0], value: pasted };
+      ui.done("Key saved", `${file}; setting ${p.keyVars[0]} in your environment works too`);
+    } else {
+      ui.done("No key", "the computer's own voice will speak until a key is set");
+    }
+  }
+  const hasKey = Boolean(key.value);
+
+  const all = catalog(provider).voices;
+  const choice = (v) => ({
+    value: v.id,
+    label: v.name ?? v.id,
+    hint: v.description ?? VOICES[v.id] ?? "",
+    preview: hasKey ? () => daemon("say", { _: [voiceSample(v.name ?? v.id)], voice: v.id, test: true }) : undefined,
+    previewing: `${v.name ?? v.id} is introducing itself…`,
+  });
+  const shortlist = (p.previewVoices ?? []).map((id) => all.find((v) => v.id === id)).filter(Boolean);
+  const current = config?.speechProvider === provider ? config?.voice : p.defaultVoice;
+  let voice = null;
+  if (shortlist.length && shortlist.length < all.length) {
+    voice = await ui.select({
+      message: "Which voice?",
+      initial: current,
+      choices: [...shortlist.map(choice), { value: null, label: "More voices…", hint: `all ${all.length}` }],
+      previewHint: hasKey ? "space to hear it" : "no key yet, so no previews",
+    });
+  }
+  if (voice === null) {
+    voice = await ui.select({ message: "Which voice?", initial: current, choices: all.map(choice), previewHint: hasKey ? "space to hear it" : "no key yet, so no previews" });
+  }
+  const speech = await ui.select({
+    message: "How much should be said out loud?",
+    initial: config?.speech ?? "auto",
+    choices: [
+      { value: "auto", label: "Let the agent decide", hint: "a short line out loud, the detail in Slack" },
+      { value: "brief", label: "One short sentence", hint: "always" },
+      { value: "same", label: "The whole message", hint: "exactly what Slack gets" },
+    ],
+  });
+  return { provider, voice, speech, hasKey };
+}
+
+/** 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 });
+  const c = ui.style;
+  const major = Number(process.versions.node.split(".")[0]);
+
+  if (args.yes || !ui.interactive) {
+    const result = quietInstall({ home, env });
+    output.write(JSON.stringify({ ok: true, ...result, ...(ui.interactive ? {} : { note: "no terminal, so nothing was asked: only the links were made" }) }, null, 2) + "\n");
+    return 0;
+  }
+
+  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
+    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",
+    ]);
+
+    // ---- 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 })),
+    });
+    for (const a of agents.filter((x) => wanted.includes(x.id))) {
+      const plan = planLink(a.link, SKILL_DIR);
+      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) {
+          ui.done(`${a.label}: kept its copy`, a.link);
+          continue;
+        }
+      }
+      if (plan.action === "conflict") {
+        ui.failed(`${a.label}: something else is at ${a.link}`, "move it away and run install again");
+        continue;
+      }
+      try {
+        const done = applyLink(a.link, SKILL_DIR, plan);
+        ui.done(`${a.label}: ${plan.action === "none" ? plan.note : "linked"}`, `${a.link}${done.movedTo ? ` (the copy is at ${done.movedTo})` : ""}`);
+        summary.push(a.label);
+      } catch (e) {
+        ui.failed(`${a.label}: could not link`, e.message);
+      }
+    }
+
+    // ---- 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" });
+      if (yes) {
+        const r = herdrLink(herdr, SKILL_DIR);
+        if (r.ok) {
+          ui.done("Registered with Herdr", r.note ?? "herdr plugin list shows it");
+          herdrDone = true;
+        } else ui.failed("Herdr would not link the plugin", r.error);
+      }
+    }
+
+    // ---- what and how
+    const setupArgs = {};
+    const persist = async (more = {}) => {
+      Object.assign(setupArgs, more);
+      const merged = applySetup(loadConfig(), setupArgs, listSounds(), SPEECH_SETUP);
+      saveConfig(merged);
+      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");
+      }
+    }
+    await persist({ methods: methods.join(",") });
+
+    if (methods.includes("sound")) {
+      const sounds = listSounds();
+      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}…` })),
+      });
+      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"})`);
+    }
+
+    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}`);
+
+    // ---- 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 });
+        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 });
+              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);
+            }
+          }
+        }
+      }
+    }
+
+    // ---- 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");
+      } 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) {
+          const ok = await attempt(ui, "Installing the tray", () => ui.run("Installing the tray", () => daemon("tray", { _: ["install"] }), { done: () => "Tray installed" }), { skipLabel: "Skip the tray" });
+          if (ok) {
+            await daemon("tray", { _: ["start"] }).catch(() => {});
+            summary.push("tray");
+          }
+        }
+      }
+    }
+
+    // ---- try it
+    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" });
+    }
+    await daemon("end", {}, session).catch(() => {});
+
+    ui.outro([
+      c.bold("Done."),
+      "",
+      ...summary.map((s) => `${c.green("•")} ${s}`),
+      ...(herdrDone ? [`${c.green("•")} Herdr plugin`] : []),
+      "",
+      `Settings: ${c.dim(configPath())}`,
+      `Change anything: ${c.cyan("roger-roger install")} again, or just tell your agent.`,
+    ]);
+    return 0;
+  } catch (e) {
+    if (e instanceof Cancelled) {
+      output.write(os.EOL + `${ui.rail.end}  Stopped. Anything already done stays done; run ${c.cyan("roger-roger install")} to carry on.` + os.EOL + os.EOL);
+      return 130;
+    }
+    ui.failed("Setup stopped", e.message);
+    return 1;
+  }
+}
+
+/** One line on what a test notification managed. */
+function describeResults(results = {}) {
+  const parts = [];
+  for (const [method, r] of Object.entries(results)) {
+    if (method === "queued") continue;
+    parts.push(r?.ok ? method : `${method} failed${r?.error ? ` (${r.error})` : ""}`);
+  }
+  return parts.join(" · ") || "nothing was sent";
+}