roger-roger 0.1.14 → 0.2.0

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

@@ -11,10 +11,11 @@ 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, readSlackCredentials, rogerRogerHome, saveConfig, voiceSample } from "./lib.mjs";
+import { SKILL_DIR, VERSION, VOICES, applySetup, olderThan, 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 { unregisterWindows } from "./desktop.mjs";
+import { createApp, loginFinish, loginStart, setupStatus, currentApp, deleteApp } from "./slackapp.mjs";
 import { cliInstallDir, findCli, installCli } from "./slackcli.mjs";
 import { call, connect, request } from "./client.mjs";
 import { identity } from "./agent.mjs";
@@ -200,13 +201,7 @@ export function globalCopy(env = process.env) {
   }
 }
 
-/** a < b for dotted versions; anything unparseable counts as older. */
-export function olderThan(a, b) {
-  const parse = (v) => String(v ?? "").split(".").map((n) => parseInt(n, 10) || 0);
-  const [x, y] = [parse(a), parse(b)];
-  for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) < (y[i] ?? 0);
-  return false;
-}
+export { olderThan };
 
 /**
  * Which copy of the skill everything should point at, and whether to offer a global install:
@@ -763,6 +758,9 @@ export async function runInstall(args, { script, hooks, input = process.stdin, o
           { 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 },
+          ...(["win32", "darwin"].includes(process.platform)
+            ? [{ value: "desktop", label: "Desktop notification", hint: process.platform === "win32" ? "a Windows notification, with Go to pane for agents in Herdr" : "a macOS notification; brew install terminal-notifier for Go to pane", checked: config ? config.methods.includes("desktop") : true }]
+            : []),
         ],
       });
       if (methods.includes("slack")) {
@@ -1036,13 +1034,17 @@ export async function uninstallFindings({ home = os.homedir(), env = process.env
     home: [rogerRogerHome(env), path.join(home, ".attention")].filter((d) => fs.existsSync(d)),
     global: global?.present ? global : null,
     slackCli: await slackCliFootprint(home),
+    // Only while its record is here: once the home is gone there is nothing left to find it by.
+    slackApp: fs.existsSync(rogerRogerHome(env)) ? currentApp() : null,
   };
 }
 
 /** Everything but the Slack CLI, with no questions. Returns what was done. */
-export async function quietUninstall({ home = os.homedir(), env = process.env, hooks = null, script = "", slackCli = false } = {}) {
+export async function quietUninstall({ home = os.homedir(), env = process.env, hooks = null, script = "", slackCli = false, slackApp = false } = {}) {
   const found = await uninstallFindings({ home, env, hooks, script });
-  const done = { daemonStopped: await stopDaemon(env), hooks: [], links: [], instructions: [], herdr: null, home: [], slackCli: false, global: null };
+  const done = { daemonStopped: await stopDaemon(env), hooks: [], links: [], instructions: [], herdr: null, home: [], slackApp: null, slackCli: false, global: null };
+  // Before the home goes, because the app's ID goes with it.
+  if (slackApp && found.slackApp) done.slackApp = await deleteApp().catch((e) => ({ ok: false, error: e.message }));
   for (const f of found.instructions) {
     try {
       removeInstructions(f.path);
@@ -1072,6 +1074,8 @@ export async function quietUninstall({ home = os.homedir(), env = process.env, h
     fs.rmSync(dir, { recursive: true, force: true });
     done.home.push(dir);
   }
+  // The app id and link handler desktop notifications registered with Windows go with the settings.
+  if (found.home.length) done.desktop = unregisterWindows();
   if (slackCli && found.slackCli.present) {
     removeSlackCli({ home });
     done.slackCli = true;
@@ -1093,7 +1097,7 @@ export async function runUninstall(args, { script, hooks, input = process.stdin,
   const c = ui.style;
 
   if (args.yes || !ui.interactive) {
-    const done = await quietUninstall({ home, env, hooks, script, slackCli: Boolean(args["slack-cli"]) });
+    const done = await quietUninstall({ home, env, hooks, script, slackCli: Boolean(args["slack-cli"]), slackApp: Boolean(args["slack-app"]) });
     output.write(JSON.stringify({ ok: true, ...done }, null, 2) + "\n");
     return 0;
   }
@@ -1108,6 +1112,9 @@ export async function runUninstall(args, { script, hooks, input = process.stdin,
     if (found.hookAgents.length) choices.push({ value: "hooks", label: "Terminal-question hooks", hint: found.hookAgents.map((n) => labels[n] ?? n).join(", "), checked: true });
     if (found.herdr) choices.push({ value: "herdr", label: "The Herdr plugin", hint: "herdr plugin unlink", checked: true });
     if (found.home.length) choices.push({ value: "home", label: "Settings, Slack tokens, state", hint: found.home.join(", "), checked: true });
+    // Left in the workspace without its settings, the app can't be found again, and the next install
+    // makes a second one beside it. So it goes with the settings unless the user says otherwise.
+    if (found.slackApp) choices.push({ value: "slack-app", label: "The roger-roger Slack app", hint: `${found.slackApp.teamDomain ?? found.slackApp.teamId} (${found.slackApp.appId}), deleted from the workspace; kept, it becomes a duplicate when you install again`, checked: true });
     if (found.global) choices.push({ value: "global", label: "The roger-roger command", hint: `npm uninstall -g (${found.global.dir})`, checked: true });
     if (found.slackCli.present) choices.push({ value: "slack-cli", label: "The Slack CLI", hint: `${found.slackCli.dir} and its login in ~/.slack; Slack's tool, so off by default`, checked: false });
     if (!choices.length) {
@@ -1127,6 +1134,15 @@ export async function runUninstall(args, { script, hooks, input = process.stdin,
 
     const removed = [];
     if (await stopDaemon(env)) ui.done("Stopped the daemon and the tray");
+    if (what.includes("slack-app")) {
+      // A failure is shown on the task's own line, with where to delete it by hand.
+      const r = await ui.run("Deleting the Slack app", async () => {
+        const d = await deleteApp();
+        if (!d.ok) throw new Error(d.error);
+        return d;
+      }, { done: (d) => (d.deleted ? `Deleted the Slack app ${d.appId}` : d.note) }).catch(() => null);
+      if (r?.deleted) removed.push("Slack app");
+    }
     if (what.includes("hooks")) {
       for (const name of found.hookAgents) {
         try {
@@ -1173,6 +1189,7 @@ export async function runUninstall(args, { script, hooks, input = process.stdin,
         ui.done("Removed", dir);
         removed.push(dir);
       }
+      if (unregisterWindows().removed) ui.done("Removed the desktop notification registration", "HKCU\\Software\\Classes\\roger-roger");
     }
     if (what.includes("slack-cli")) {
       removeSlackCli({ home });

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

@@ -13,19 +13,35 @@ import { detectAgent } from "./agent.mjs";
 export const SKILL_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 export const SOUNDS_DIR = path.join(SKILL_DIR, "sounds");
 
-/** The package's version, when the skill sits inside the package; empty for a bare skills.sh copy. */
+/**
+ * The package's version. A bare skills.sh copy has no package.json around it, but it does carry the
+ * Herdr manifest, which is bumped with every release; only a copy with neither is unversioned.
+ */
 export const VERSION = (() => {
   try {
     return JSON.parse(fs.readFileSync(path.join(SKILL_DIR, "..", "..", "package.json"), "utf8")).version ?? "";
   } catch {
-    return "";
+    try {
+      return /^version = "([^"]*)"/m.exec(fs.readFileSync(path.join(SKILL_DIR, "herdr-plugin.toml"), "utf8"))?.[1] ?? "";
+    } catch {
+      return "";
+    }
   }
 })();
 
-export const METHODS = ["slack", "sound", "speech"];
+/** a < b for dotted versions; anything unparseable counts as older. */
+export function olderThan(a, b) {
+  const parse = (v) => String(v ?? "").split(".").map((n) => parseInt(n, 10) || 0);
+  const [x, y] = [parse(a), parse(b)];
+  for (let i = 0; i < 3; i++) if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) < (y[i] ?? 0);
+  return false;
+}
+
+export const METHODS = ["slack", "sound", "speech", "desktop"];
 export const KINDS = ["done", "blocked", "input", "milestone", "error", "info"];
 export const SPEECH_MODES = ["auto", "same", "brief"];
 export const WHEN_MODES = ["auto", "done-and-blocked", "blocked-only", "on-request"];
+export const PRESENCE_MODES = ["on", "off"];
 
 export const DEFAULT_MODEL = "gemini-3.1-flash-tts-preview";
 
@@ -163,6 +179,12 @@ export const DEFAULTS = {
   speechVolume: 100,
   // The tray icon: "auto" starts it with the daemon whenever it is installed, "off" leaves it to `tray start`.
   tray: "auto",
+  // Whether the user is at the computer decides how a notification reaches them. "on": at the desk
+  // (touched the keyboard or mouse in the last `awayAfter` seconds, screen unlocked) only the
+  // `presentMethods` of the configured ones are used; away or locked, all of them. "off": always all.
+  presence: "on",
+  presentMethods: ["sound", "speech", "desktop"],
+  awayAfter: 180,
   notes: "",
 };
 
@@ -485,6 +507,21 @@ export function applySetup(base, args, sounds = listSounds(), speech = GEMINI_ON
     const v = String(args.tray).toLowerCase();
     c.tray = v === "on" || v === "true" || v === "auto" ? "auto" : v === "off" || v === "false" ? "off" : oneOf(v, ["auto", "off"], "tray");
   }
+  if (args.presence !== undefined) {
+    const v = String(args.presence).toLowerCase();
+    c.presence = v === "true" || v === "on" ? "on" : v === "false" || v === "off" ? "off" : oneOf(v, PRESENCE_MODES, "presence");
+  }
+  if (args["present-methods"] !== undefined) {
+    const value = String(args["present-methods"]).trim().toLowerCase();
+    const methods = value === "none" ? [] : splitList(value);
+    for (const m of methods) oneOf(m, METHODS, "present-methods");
+    c.presentMethods = [...new Set(methods)];
+  }
+  if (args["away-after"] !== undefined) {
+    const seconds = parseDuration(String(args["away-after"]));
+    if (!Number.isFinite(seconds) || seconds < 10 || seconds > 4 * 3600) throw new Error("--away-after must be a duration from 10s to 4h, e.g. 3m");
+    c.awayAfter = seconds;
+  }
   if (args.remind !== undefined) c.remind = parseRemind(args.remind).map((s) => formatDuration(s));
   if (args["on-expire"] !== undefined) c.onExpire = oneOf(args["on-expire"], ON_EXPIRE, "on-expire");
   if (args["quiet-hours"] !== undefined) {
@@ -1067,6 +1104,29 @@ export function parseProgressActionId(value) {
   return m ? { key: m[1], action: m[2] } : null;
 }
 
+export const GOTO_PREFIX = "roger-roger_goto";
+
+/**
+ * A "Go to pane" button for a message from an agent in a Herdr pane: pressed on the desktop Slack,
+ * it brings that agent's tab to the front. Put before the session label, which stays last.
+ */
+export function withGotoButton(blocks, sessionId) {
+  if (!sessionId) return blocks;
+  const button = {
+    type: "actions",
+    block_id: `${GOTO_PREFIX}_block`,
+    elements: [{ type: "button", action_id: `${GOTO_PREFIX}:${sessionId}`, text: { type: "plain_text", text: ":desktop_computer: Go to pane", emoji: true } }],
+  };
+  const last = blocks.length - 1;
+  return last >= 0 && blocks[last].type === "context" ? [...blocks.slice(0, last), button, blocks[last]] : [...blocks, button];
+}
+
+/** `roger-roger_goto:<session id>` → the session id, or null. */
+export function parseGotoActionId(value) {
+  const m = new RegExp(`^${GOTO_PREFIX}:(.+)$`).exec(String(value));
+  return m ? m[1] : null;
+}
+
 /** 45s, 12m, 1h 12m, 2d 3h. */
 export function formatElapsed(ms) {
   const s = Math.max(0, Math.round(ms / 1000));

package/skills/roger-roger/scripts/open-url.js

@@ -0,0 +1,11 @@
+// Windows only: what a roger-roger:// link runs, by way of wscript.exe. A notification's buttons are
+// links, and Windows starts a link's handler as a fresh process; node.exe started that way opens a
+// console window for a moment. wscript has no console, so this hands the link to node hidden.
+//
+// Arguments: node.exe, roger-roger.mjs, the link.
+var shell = new ActiveXObject("WScript.Shell");
+var args = WScript.Arguments;
+if (args.length >= 3) {
+  var quote = function (s) { return '"' + String(s).replace(/"/g, "") + '"'; };
+  shell.Run(quote(args(0)) + " " + quote(args(1)) + " open-url " + quote(args(2)), 0, false);
+}

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

@@ -0,0 +1,157 @@
+// Is the user at the computer? How long since they last touched the keyboard or mouse, and whether
+// the screen is locked. A notification while they are sitting in front of the terminal doesn't need
+// to go to their phone as well; one while they are away does.
+//
+// Every platform answers differently, and some not at all. Anything that can't be read is "unknown",
+// and unknown changes nothing: the configured methods are used as they always were.
+//
+// - Windows: GetLastInputInfo, and LogonUI running for a locked screen. PowerShell takes a second or
+//   two to start, so one helper is kept, like the audio player, and asked a line at a time.
+// - macOS: HIDIdleTime from `ioreg`. The lock isn't readable without a helper binary; idle covers it.
+// - Linux: `loginctl` for the lock (and idle hint), `xprintidle` for idle time under X when installed.
+
+import { execFile, spawn } from "node:child_process";
+
+const PS_PRESENCE = `
+$ErrorActionPreference = 'Stop'
+Add-Type @'
+using System;
+using System.Runtime.InteropServices;
+public static class RogerRogerIdle {
+  [StructLayout(LayoutKind.Sequential)] struct LastInput { public uint cbSize; public uint dwTime; }
+  [DllImport("user32.dll")] static extern bool GetLastInputInfo(ref LastInput info);
+  public static long Ms() {
+    var info = new LastInput(); info.cbSize = (uint)Marshal.SizeOf(info);
+    if (!GetLastInputInfo(ref info)) return -1;
+    return (long)(uint)(Environment.TickCount - (int)info.dwTime);
+  }
+}
+'@
+[Console]::Out.WriteLine('READY')
+while ($null -ne ($line = [Console]::In.ReadLine())) {
+  try {
+    $locked = [bool](Get-Process -Name LogonUI -ErrorAction SilentlyContinue)
+    [Console]::Out.WriteLine("$([RogerRogerIdle]::Ms()) $([int]$locked)")
+  } catch {
+    [Console]::Out.WriteLine('-1 0')
+  }
+}
+`;
+
+const ANSWER_TIMEOUT_MS = 5_000;
+let helper = null;
+
+function windowsHelper() {
+  if (helper) return helper;
+  const child = spawn("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", PS_PRESENCE], {
+    stdio: ["pipe", "pipe", "ignore"],
+    windowsHide: true,
+  });
+  const waiters = [];
+  let buffer = "";
+  const self = {
+    ask() {
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => resolve(null), ANSWER_TIMEOUT_MS);
+        waiters.push((line) => (clearTimeout(timer), resolve(line)));
+        try {
+          child.stdin.write("?\n");
+        } catch {
+          resolve(null);
+        }
+      });
+    },
+    close() {
+      if (helper === self) helper = null;
+      try {
+        child.stdin.end();
+      } catch {}
+    },
+  };
+  const fail = () => {
+    if (helper === self) helper = null;
+    while (waiters.length) waiters.shift()(null);
+  };
+  child.stdout.setEncoding("utf8");
+  child.stdout.on("data", (chunk) => {
+    buffer += chunk;
+    let nl;
+    while ((nl = buffer.indexOf("\n")) !== -1) {
+      const line = buffer.slice(0, nl).trim();
+      buffer = buffer.slice(nl + 1);
+      if (line && line !== "READY") waiters.shift()?.(line);
+    }
+  });
+  child.stdin.on("error", fail);
+  child.on("error", fail);
+  child.on("exit", fail);
+  // It must not keep a finished CLI process alive; the daemon has other reasons to stay up.
+  child.unref();
+  child.stdout.unref?.();
+  child.stdin.unref?.();
+  helper = self;
+  return self;
+}
+
+const run = (cmd, args) => new Promise((resolve) => {
+  execFile(cmd, args, { encoding: "utf8", timeout: 3_000, windowsHide: true }, (error, stdout) => resolve(error ? null : stdout));
+});
+
+/** `{ idleMs, locked }`, either of them null when this machine won't say. */
+export async function readInput(platform = process.platform) {
+  if (platform === "win32") {
+    const line = await windowsHelper().ask();
+    const [ms, locked] = String(line ?? "").split(" ").map(Number);
+    return { idleMs: Number.isFinite(ms) && ms >= 0 ? ms : null, locked: line ? locked === 1 : null };
+  }
+  if (platform === "darwin") {
+    const out = await run("ioreg", ["-c", "IOHIDSystem", "-d", "4"]);
+    const ns = /"HIDIdleTime"\s*=\s*(\d+)/.exec(out ?? "")?.[1];
+    return { idleMs: ns ? Number(BigInt(ns) / 1_000_000n) : null, locked: null };
+  }
+  const session = process.env.XDG_SESSION_ID;
+  const hints = session ? await run("loginctl", ["show-session", session, "-p", "LockedHint", "-p", "IdleSinceHintMonotonic", "-p", "IdleHint"]) : null;
+  const locked = hints ? /LockedHint=yes/.test(hints) : null;
+  const x = process.env.DISPLAY ? await run("xprintidle", []) : null;
+  const idleMs = x && /^\d+/.test(x.trim()) ? Number(x.trim()) : null;
+  return { idleMs, locked };
+}
+
+/** Lets a finished process exit. */
+export function closePresence() {
+  helper?.close();
+}
+
+export const STATES = ["present", "away", "locked", "unknown"];
+
+/**
+ * `present`, `away` (idle for at least `awayAfterMs`), `locked`, or `unknown`, with the idle time
+ * that decided it. `read` is for tests.
+ */
+export async function presence({ awayAfterMs, read = readInput, env = process.env } = {}) {
+  // Forced, for tests and for trying the settings out without walking away from the desk.
+  const forced = String(env.ROGER_ROGER_PRESENCE ?? "").toLowerCase();
+  if (STATES.includes(forced)) return { state: forced, idleSeconds: null, forced: true };
+  let input;
+  try {
+    input = await read();
+  } catch {
+    input = { idleMs: null, locked: null };
+  }
+  const idleSeconds = input.idleMs === null ? null : Math.round(input.idleMs / 1000);
+  if (input.locked) return { state: "locked", idleSeconds };
+  if (input.idleMs === null) return { state: "unknown", idleSeconds };
+  return { state: input.idleMs >= awayAfterMs ? "away" : "present", idleSeconds };
+}
+
+/**
+ * The methods to use, given where the user is. At the desk they get `presentMethods` of what was
+ * configured: the terminal is in front of them, so a phone that buzzes too is one ping too many.
+ * Anything else — away, locked, or a machine that won't say — gets everything configured.
+ * `keep` are methods this call needs whatever happens (a reply in a Slack thread belongs in Slack).
+ */
+export function methodsForPresence(methods, where, { presentMethods, keep = [] }) {
+  if (where !== "present") return { methods, skipped: [] };
+  const allowed = new Set([...presentMethods, ...keep]);
+  return { methods: methods.filter((m) => allowed.has(m)), skipped: methods.filter((m) => !allowed.has(m)) };
+}

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

@@ -20,6 +20,7 @@ import { call, connect, request } from "./client.mjs";
 import { identity } from "./protocol.mjs";
 import { FROM_HOOKS, HANDLERS, owedTo } from "./handlers.mjs";
 import { closeAudio } from "./audio.mjs";
+import { closePresence } from "./presence.mjs";
 import { createApp, hooksConfig, loginFinish, loginStart, runHook, setupStatus } from "./slackapp.mjs";
 import { findCli, installCli } from "./slackcli.mjs";
 import { daemonRunning } from "./daemon.mjs";
@@ -32,6 +33,9 @@ import { codexHome, codexHookRequest, codexStatus, installCodex, uninstallCodex
 import { installOpencode, opencodeConfigDir, opencodeHookRequest, opencodeStatus, uninstallOpencode } from "./hooks-opencode.mjs";
 import { runInstall, runUninstall } from "./install.mjs";
 import { helpText } from "./help.mjs";
+import { formatDoctor, runDoctor } from "./doctor.mjs";
+import { parseOpenUrl, showDesktop, notificationText } from "./desktop.mjs";
+import { coloursOn, makeStyle } from "./tui.mjs";
 
 function out(obj, code = 0) {
   process.stdout.write(JSON.stringify(obj, null, 2) + "\n");
@@ -193,7 +197,7 @@ async function status() {
       slackTokenSource: readSlackCredentials() ? "slack-setup" : slackToken() ? "environment" : null,
       slackAppToken: Boolean(slackAppToken()),
       ...(rawAppToken && !slackAppToken()
-        ? { slackAppTokenWarning: "the Slack app token is not an app-level xapp- token, so `ask` is unavailable (see SKILL.md, Requirements)" }
+        ? { slackAppTokenWarning: "the Slack app token is not an app-level xapp- token, so `ask` is unavailable (see reference.md, Requirements)" }
         : {}),
       // Who speaks, where its key is read from, and whether anything is there. Never the key itself.
       speechProvider: providerOf(config).id,
@@ -277,6 +281,71 @@ async function daemonCommand(args) {
   throw new Error(`unknown daemon command "${step}" (status, start, stop)`);
 }
 
+/**
+ * `doctor`: what could stop a notification arriving, and what to do about each. A person at a
+ * terminal gets lines; anything else (an agent) the JSON, like every other command.
+ */
+async function doctor(args) {
+  let daemon = null;
+  try {
+    daemon = (await askDaemon("status")).data;
+  } catch {}
+  const report = await runDoctor({ daemon, agents: AGENTS, script: SCRIPT, offline: Boolean(args.offline) });
+  if (process.stdout.isTTY && !args.json) {
+    process.stdout.write(formatDoctor(report, makeStyle(coloursOn())));
+    process.exitCode = report.ok ? 0 : 1;
+    return;
+  }
+  return out(report, report.ok ? 0 : 1);
+}
+
+/**
+ * `open-url roger-roger://goto/sage`: what a notification's button runs. It comes from a click, not
+ * from an agent, so it asks the daemon as nobody: running it must not register a session of its own.
+ * Any web page can open a roger-roger:// link too, which is why only "go to that pane" is accepted.
+ */
+async function openUrl(args) {
+  // Started by a click, with nowhere to print: the log is the only way to see what happened.
+  const note = (line) => {
+    try {
+      fs.mkdirSync(rogerRogerHome(), { recursive: true });
+      fs.appendFileSync(path.join(rogerRogerHome(), "open-url.log"), `${new Date().toISOString()} ${args._[0] ?? "(none)"}: ${line}\n`);
+    } catch {}
+  };
+  const link = parseOpenUrl(args._[0]);
+  if (!link) {
+    note("refused");
+    return out({ ok: false, error: `not a link roger-roger opens: ${args._[0] ?? "(none)"}` }, 2);
+  }
+  const nobody = { identity: null, about: {} };
+  try {
+    let result;
+    try {
+      result = await call("goto", { _: [link.who] }, { session: nobody });
+    } catch (e) {
+      // A daemon from an older copy doesn't know `goto` (exit 2). Focusing a tab needs nothing it
+      // holds, so it is done here instead.
+      if (e.code !== 2) throw e;
+      result = await runLocally("goto", { _: [link.who] }, nobody);
+    }
+    const { data, code } = result;
+    note(data?.ok === false ? `failed: ${data.error}` : `focused ${link.who}`);
+    return out(data, code);
+  } catch (e) {
+    note(`failed: ${e.message}`);
+    return out({ ok: false, error: e.message }, typeof e.code === "number" ? e.code : 1);
+  }
+}
+
+/** `desktop test`: one notification now, to see that this machine shows them. */
+async function desktopCommand(args) {
+  const step = args._[0] ?? "test";
+  if (step !== "test") throw new Error(`unknown desktop command "${step}" (test)`);
+  const text = notificationText({ kind: "info", message: "Desktop notifications work. Agents' messages will look like this.", nickname: null, project: "roger-roger" });
+  const r = await showDesktop({ ...text, goto: typeof args.goto === "string" ? args.goto : null });
+  return out(r, r.ok ? 0 : 1);
+}
+
 // ---------------------------------------------------------------- agent hooks
 
 const SCRIPT = fileURLToPath(import.meta.url);
@@ -445,6 +514,9 @@ async function main() {
       process.exitCode = await runUninstall(args, { script: SCRIPT, hooks: { agents: AGENTS } });
       return;
     case "status": return status();
+    case "doctor": return doctor(args);
+    case "open-url": return openUrl(args);
+    case "desktop": return desktopCommand(args);
     case "setup": return setup(args);
     case "slack-setup": return slackSetup(args);
     case "slack-hook":
@@ -457,6 +529,7 @@ async function main() {
     // `sessions rename sage plum` is the only sub-command; anything else lists them.
     case "sessions": return args._[0] === "rename" ? run("rename", { ...args, _: args._.slice(1) }) : run("sessions", args);
     case "end": return run("end", args);
+    case "goto": return run("goto", args);
     case "inbox":
     case "messages": return run("messages", args);
 
@@ -488,6 +561,7 @@ main()
   .catch((e) => out({ ok: false, error: e.message }, typeof e.code === "number" ? e.code : 1))
   .finally(() => {
     closeAudio();
+    closePresence();
     // Normally the process exits on its own. If idle sockets hold it open, exit anyway after a
     // moment (an immediate process.exit can trip a libuv assertion on Windows).
     setTimeout(() => process.exit(), 3000).unref();

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

@@ -129,9 +129,20 @@ export function get(id) {
   return load().sessions[id] ?? null;
 }
 
-export function byNickname(nickname) {
+/**
+ * The session going by that name now. Names are lent out again once their owner has gone, so old
+ * records can share it: the running one wins, then whichever was seen last. Taking the first one
+ * found sent "go to flint" to a pane closed a week before.
+ */
+export function byNickname(nickname, now = Date.now()) {
   const want = String(nickname ?? "").toLowerCase();
-  return Object.values(load().sessions).find((s) => s.nickname === want) ?? null;
+  const named = Object.values(load().sessions).filter((s) => s.nickname === want);
+  const rank = (s) => [isLive(s, now) ? 1 : 0, Date.parse(s.lastSeen ?? 0) || 0];
+  named.sort((a, b) => {
+    const [x, y] = [rank(a), rank(b)];
+    return y[0] - x[0] || y[1] - x[1];
+  });
+  return named[0] ?? null;
 }
 
 /** Every live session, oldest first, with its colour resolved. */

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

@@ -43,10 +43,23 @@ export function hooksConfig() {
   return { hooks: { "get-hooks": hookCommand("get-hooks"), deploy: hookCommand("deploy") } };
 }
 
-/** Write (or refresh) the project. The app IDs the CLI keeps in .slack/apps.json are left alone. */
+const appsFile = () => path.join(projectDir(), ".slack", "apps.json");
+
+/**
+ * Write (or refresh) the project. The app IDs the CLI keeps in .slack/apps.json are left alone, and
+ * put back from slack.json when they went missing: without them `slack deploy` doesn't update the
+ * app the user already has, it makes another one, and the workspace fills up with roger-roger apps.
+ */
 function writeProject() {
   const dir = projectDir();
   fs.mkdirSync(path.join(dir, ".slack"), { recursive: true });
+  const known = readSlackCredentials()?.app;
+  if (!fs.existsSync(appsFile()) && known?.appId && known?.teamId) {
+    fs.writeFileSync(appsFile(), JSON.stringify({
+      apps: { [known.teamId]: { app_id: known.appId, team_id: known.teamId, ...(known.teamDomain ? { team_domain: known.teamDomain } : {}) } },
+      ...(known.teamDomain ? { default: known.teamDomain } : {}),
+    }, null, 2) + "\n");
+  }
   fs.writeFileSync(path.join(dir, ".slack", "hooks.json"), JSON.stringify(hooksConfig(), null, 2) + "\n");
   // The CLI reads manifest.json from the project root; the skill ships the source of truth.
   fs.copyFileSync(MANIFEST_PATH, path.join(dir, "manifest.json"));
@@ -60,7 +73,7 @@ export function linkedApp() {
   try {
     const apps = JSON.parse(fs.readFileSync(path.join(projectDir(), ".slack", "apps.json"), "utf8"));
     const app = Object.values(apps.apps ?? {})[0];
-    return app ? { appId: app.app_id, teamId: app.team_id } : null;
+    return app ? { appId: app.app_id, teamId: app.team_id, ...(app.team_domain ? { teamDomain: app.team_domain } : {}) } : null;
   } catch {
     return null;
   }
@@ -82,10 +95,12 @@ export function runHook(name, env = process.env) {
     process.stderr.write("roger-roger: the Slack CLI did not provide a bot token\n");
     return 1;
   }
+  const app = linkedApp() ?? readSlackCredentials()?.app;
   saveCredentials({
     source: "slack-cli",
     botToken,
     appToken: appToken.startsWith("xapp-") ? appToken : "",
+    ...(app ? { app } : {}),
     savedAt: new Date().toISOString(),
   });
   process.stdout.write(`roger-roger: saved Slack credentials to ${slackCredentialsPath()}\n`);
@@ -195,7 +210,10 @@ export async function createApp({ teamId } = {}) {
   const r = await slack(cli, ["deploy", "--team", account.teamId], { cwd });
   if (r.code !== 0) throw new Error(`slack deploy failed: ${r.out}`);
 
+  // The CLI writes the app's ID once the app exists, which is after the hook saved the tokens.
+  const created = linkedApp();
   const stored = readSlackCredentials();
+  if (stored && created && stored.app?.appId !== created.appId) saveCredentials({ ...stored, app: created });
   const botOk = await tokenWorks("auth.test", stored?.botToken);
   const appOk = await tokenWorks("apps.connections.open", stored?.appToken);
   if (!botOk || !appOk) {
@@ -203,3 +221,25 @@ export async function createApp({ teamId } = {}) {
   }
   return { ...linkedApp(), team: account.team, userId: account.userId };
 }
+
+/** The app this machine uses: from the CLI's project, or from slack.json when that went missing. */
+export function currentApp() {
+  return linkedApp() ?? readSlackCredentials()?.app ?? null;
+}
+
+export const appUrl = (appId) => `https://api.slack.com/apps/${appId}`;
+
+/**
+ * Delete the roger-roger app from its workspace, for uninstall. Without its settings an app left in
+ * the workspace can't be found again, and the next install makes a second one beside it.
+ */
+export async function deleteApp() {
+  const app = currentApp();
+  if (!app?.appId) return { ok: true, deleted: false, note: "no app is recorded on this machine" };
+  const cli = await findCli();
+  if (!cli) return { ok: false, deleted: false, appId: app.appId, error: `the Slack CLI isn't installed; delete it at ${appUrl(app.appId)}` };
+  writeProject();
+  const r = await slack(cli, ["app", "delete", "--app", app.appId, "--team", app.teamId, "--force"], { cwd: projectDir(), input: "y\n", timeout: 60_000 });
+  if (r.code !== 0) return { ok: false, deleted: false, appId: app.appId, error: `${r.out || "slack app delete failed"} (or delete it at ${appUrl(app.appId)})` };
+  return { ok: true, deleted: true, appId: app.appId, teamId: app.teamId };
+}

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

@@ -36,6 +36,8 @@ function agentLine(session, pending, now) {
     quietForMs: Math.max(0, now - Date.parse(session.lastSeen ?? 0)),
     queued: session.queue?.length ?? 0,
     owes: decisions.undeliveredFor(session.id).length,
+    // In a Herdr pane, so the panel can offer to bring its tab to the front.
+    inHerdr: Boolean(session.herdr?.tab),
     ...(waiting ? { waitingOn: { id: waiting.id, question: waiting.question, expiresAt: waiting.expiresAt } } : {}),
   };
 }

package/skills/roger-roger/slack/manifest.json

@@ -6,7 +6,7 @@
   },
   "features": {
     "app_home": {
-      "home_tab_enabled": false,
+      "home_tab_enabled": true,
       "messages_tab_enabled": true,
       "messages_tab_read_only_enabled": false
     },
@@ -22,7 +22,7 @@
   },
   "settings": {
     "event_subscriptions": {
-      "bot_events": ["message.im"]
+      "bot_events": ["message.im", "app_home_opened"]
     },
     "interactivity": {
       "is_enabled": true

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

@@ -467,6 +467,10 @@ async function main() {
       }
       if (ask.do === "snooze") return run("snooze", ask.value || "1h");
       if (ask.do === "hush") return run("hush");
+      if (ask.do === "goto" && ask.value) {
+        hidePanel();
+        return run("goto", String(ask.value));
+      }
       if (ask.do === "hide") return hidePanel();
       if (ask.do === "keep-open") {
         keepOpen = Boolean(ask.value);