@codyswann/lisa 4.81.3 → 4.81.4

package/plugins/lisa/skills/lisa-setup-session-manager/SKILL.md

@@ -42,11 +42,14 @@ writes `$SM`, and pass `--project-root "$ROOT"` (the absolute project root) on e
 
 1. Preview: `node "$SM/session-manager.mjs" init-config --project-root "$ROOT"`. It detects
    `projects/*/.lisa.config.json` and proposes `name`, `interval`, `repos`, `capacity`, `stall` and a
-   per-project `notify.stateDir`. Show the block to the operator.
+   per-project `notify.stateDir`. Repo detection leaves out linked worktrees and keeps one checkout
+   per remote, so ticket worktrees and second clones under `projects/` are not proposed. Show the
+   block to the operator and ask whether any repo is missing or should not be routed.
 2. Write it: the same command with `--write`. It adds only non-secret fields and never overwrites an
    existing block (`reason: "exists"` means keep it).
-3. Ask the operator to replace each repo's starter `hints` with the technologies and areas that
-   identify it (e.g. `api`: `["NestJS","migrations"]`, `web`: `["Expo","screens"]`), and whether to
+3. Each repo's `hints` are a draft: its name plus one per well-known dependency (`NestJS`, `Expo`,
+   `AWS CDK`, ...). Ask the operator to correct them and add the areas that identify the repo
+   (e.g. `api`: `["NestJS","migrations"]`, `web`: `["Expo","screens"]`), and whether to
    set `sessionManager.trustedAuthorIds`. Without it, any author's Ready item reaches a
    bypass-permissions worker; say so plainly. The list holds stable tracker user ids as strings,
    never logins: the GitHub numeric user id (`gh api users/<login> --jq .id`), the Jira
@@ -61,8 +64,14 @@ The operator creates a bot with @BotFather, one per project. Then run
 - `stored: true`: done.
 - Exit 2 because a token already exists: keep it (re-running setup is safe). Only when the operator
   says the stored token is wrong or belongs to another project, re-run with `store-token --replace`.
-- `reason: "no-tty"` (an agent's Bash has no terminal): print `command` from the output and ask the
-  operator to run it in their own terminal, where it prompts with echo off. Wait for them to confirm.
+- `reason: "no-tty"` (an agent's Bash has no terminal): offer the operator both routes, and say
+  plainly that Claude Code's `!` prefix has no terminal either, so it fails the same way:
+  - **Clipboard (simplest):** they copy the token from the BotFather chat and tell you; then run
+    `clipboardCommand` from the output (`store-token --from-clipboard`). It validates the token,
+    stores it, never prints it, and clears the clipboard. On `stored: false`, say what `message`
+    reports and ask them to copy it again.
+  - **Separate terminal app:** print `command` and ask them to run it in Terminal, iTerm or similar,
+    outside the agent, where it prompts with echo off. Wait for them to confirm.
 - `empty` / `invalid`: say what was wrong and ask again.
 
 Never ask for the token in chat, never echo, log or commit it, and never put it in
@@ -97,14 +106,24 @@ If `.lisa/automations/session-manager.runbook.md` does not exist, copy
 `$SM/../references/runbook-template.md` there. Never overwrite an existing runbook: it is the
 project's. It is checked in, like every automation runbook (`automation-runbook-contract`).
 
-## Step 7: Coexistence warning
-
-Tell the operator, before starting: if this project also runs the scheduled `intake-repair` loop, it
-can re-dispatch an item a local worker is still building (it treats a claimed item with no tracker
-activity for `intake.repair.staleAfterHours` as stalled). `intake-tickets` competes for the same
-Ready items. Recommend tearing down `intake-tickets` (`/lisa:tear-down-automations intake-tickets`)
-and either raising `intake.repair.staleAfterHours` above `stall.noOutputMinutes × stall.maxAttempts`
-or tearing down `intake-repair`.
+## Step 7: Check for competing intake loops
+
+The scheduled `intake-repair` loop can re-dispatch an item a local worker is still building (it treats
+a claimed item with no tracker activity for `intake.repair.staleAfterHours` as stalled), and
+`intake-tickets` competes for the same Ready items. Find out whether either is running before you
+start the manager; do not leave the operator to check.
+
+1. Run `node "$SM/session-manager.mjs" coexistence --project-root "$ROOT"`. For each loop it reports
+   the last run recorded in this project's run log and whether that is `recent`. `live` lists the
+   loops that ran recently.
+2. A run log is evidence, not proof: also list your runtime's scheduler for those loop names (Claude
+   Code: the `/schedule` listing of claude.ai routines; Codex: automations; a `lisa-<loop>.yml`
+   workflow with a `schedule:` trigger on GitHub Actions).
+3. Report what you found, per loop, in one line each. Only for a loop that is live (a recent run, or a
+   scheduler entry): recommend tearing down `intake-tickets` (`/lisa:tear-down-automations
+   intake-tickets`) and either raising `intake.repair.staleAfterHours` above
+   `stall.noOutputMinutes × stall.maxAttempts` or tearing down `intake-repair`. When neither is live,
+   say so and move on.
 
 ## Step 8: Accept workspace trust in each worker repo
 
@@ -113,12 +132,15 @@ folder?" prompt: until someone has accepted it in a directory, `claude --bg` ref
 and `spawn` exits 2 saying so. Do this once per routed repo (or once for the root on a single-repo
 project), on every machine that runs the manager:
 
-1. List the directories workers start in. Single-repo: the project root. Multi-repo: for each key in
-   `sessionManager.repos.entries`,
-   `node "$SM/session-manager.mjs" repo-dir --repo <key> --raw --project-root "$ROOT"`.
-2. Ask the operator, in their own terminal, to run `claude` once in that directory,
-   accept the trust prompt, then exit. An agent's Bash cannot answer that prompt, so never try to
-   accept it for them.
+1. Run `node "$SM/session-manager.mjs" trust-status --project-root "$ROOT"`. It lists every
+   directory workers start in (each routed repo, or the root on a single-repo project) with whether
+   Claude Code has already recorded trust for it. `needsTrust` lists the ones that are not
+   `trusted: true`. When it is empty, this step is done: say so.
+2. For each directory in `needsTrust`, ask the operator, in a separate terminal app (not the agent's
+   Bash or Claude Code's `!` prefix), to run `claude` once in that directory, accept the trust prompt,
+   then exit. An agent's Bash cannot answer that prompt, so never try to accept it for them. Then
+   re-run `trust-status` to confirm. (`trusted: "unknown"` means Claude Code's state file could not be
+   read; treat it as needing trust.)
 3. Re-run this step whenever a repo is added to `sessionManager.repos`.
 
 ## Step 9: Start and pair
@@ -152,5 +174,6 @@ confirm the "Session manager Telegram isolation?" check is green. Fix every warn
 `node "$SM/session-manager.mjs" status --project-root "$ROOT"` should show the manager running.
 
 Report: the config block written (or kept), where the token lives (the path, never the value), the
-plugin scope result, the runbook path, which repo dirs had workspace trust accepted, the manager's
-tmux session name, and the doctor result.
+plugin scope result, the runbook path, which repo dirs were already trusted and which the operator
+accepted trust in, what the competing-loop check found, the manager's tmux session name, and the
+doctor result.

package/plugins/lisa-agy/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "lisa",
-  "version": "4.81.3",
+  "version": "4.81.4",
   "description": "Universal governance — agents, skills, commands, hooks, and rules for all projects",
   "author": {
     "name": "Cody Swann"

package/plugins/lisa-agy/skills/lisa-session-manager/SKILL.md

@@ -23,9 +23,9 @@ channels (Telegram) and cross-session messaging (`SendMessage`, `crossSessionInb
 | Runtime | lisa-setup-session-manager | lisa-session-manager (manager) | `managedBy=` |
 |---|---|---|---|
 | Claude Code | supported | supported (reference). Needs `claude` ≥ 2.1.224, `tmux`, `bun` | supported |
-| Codex | config, token and runbook are supported. `start` launches a Claude Code manager, so it works when the `claude` CLI is installed | the skill ships, but `cycle` refuses to run here (no `/loop`, channels or `SendMessage`); tell the operator to run `start` | rejected with the gap message |
+| Codex | config, token (prompt or `--from-clipboard`), runbook, `trust-status` and `coexistence` are supported. `trust-status` reads Claude Code's trust record, which is the one that matters (workers are Claude Code); accepting trust needs the `claude` CLI. `coexistence` sees only run logs, so also list Codex automations. `start` launches a Claude Code manager, so it works when the `claude` CLI is installed | the skill ships, but `cycle` refuses to run here (no `/loop`, channels or `SendMessage`); tell the operator to run `start` | rejected with the gap message |
 | Cursor / Antigravity (agy) / Copilot / Devin | same as Codex | same as Codex | rejected |
-| OpenCode | config and token are supported; script resolution relies on the npm rung, so `queue` and `record-cycle` need the npm package | gap | rejected |
+| OpenCode | same setup subcommands as Codex, but script resolution relies on the npm rung: the CLI imports plugin-level scripts the skill-folder copy lacks, so every subcommand needs the npm package | gap | rejected |
 
 On any runtime other than Claude Code, `cycle` stops with: "The session manager runs on Claude Code
 only (background sessions, channels, cross-session messaging). Run `/lisa:session-manager start`

package/plugins/lisa-agy/skills/lisa-session-manager/scripts/cli-manager.mjs

@@ -1,6 +1,7 @@
 /**
- * Manager and setup subcommands of the session-manager CLI: start, stop,
- * status, repo-dir, validate, init-config and store-token.
+ * Manager subcommands of the session-manager CLI: start, stop, status,
+ * repo-dir and validate. The setup ones (init-config, store-token,
+ * trust-status, coexistence) live in cli-setup.mjs.
  *
  * `start` hosts the manager in tmux. It refuses (exit 2) unless the bot
  * token file exists with owner-only permissions in the project's own state
@@ -11,15 +12,11 @@
  * manager's tmux session: workers hold claimed work and keep running.
  * @module session-manager/cli-manager
  */
-import { existsSync, readFileSync, writeFileSync } from "node:fs";
-import path from "node:path";
-
 import {
   CliError,
   EXIT,
   GLOBAL_CONFIG_FILE,
   asSetupError,
-  asSetupErrorAsync,
   intFlag,
   listAgents,
   loadProject,
@@ -28,12 +25,8 @@ import {
   requireLisaRepo,
   run,
 } from "./cli-runtime.mjs";
-import { buildDefaultBlock, detectRepos, resolveRepoDir } from "./config.mjs";
-import {
-  defaultProjectSlug,
-  probeOwnSession,
-  sessionSurvives,
-} from "./isolation.mjs";
+import { resolveRepoDir } from "./config.mjs";
+import { probeOwnSession, sessionSurvives } from "./isolation.mjs";
 import {
   assertTokenPresent,
   buildForegroundCommand,
@@ -41,7 +34,6 @@ import {
   buildManagerLaunch,
   buildStopManager,
   resolveStateDir,
-  storeToken as storeTokenFile,
 } from "./launch.mjs";
 import { readLedger } from "./ledger.mjs";
 import { parseWorkerName, scrubWorkerEnv } from "./workers.mjs";
@@ -208,69 +200,6 @@ export function validate(ctx) {
   };
 }
 
-/**
- * `init-config [--slug <slug>] [--write]`: the default block for this
- * project, written to `.lisa.config.json` only with `--write` and only when
- * no block exists. Non-secret fields only; the token never goes here.
- * @param {object} ctx - CLI context
- * @returns {{ json: object }} `{written,block,...}`
- */
-export function initConfig(ctx) {
-  const { global } = loadProject(ctx.root);
-  if (global?.sessionManager) {
-    return {
-      json: { written: false, reason: "exists", block: global.sessionManager },
-    };
-  }
-  const slug =
-    ctx.values.slug ?? defaultProjectSlug(ctx.root, global?.github?.repo);
-  const block = asSetupError(() =>
-    buildDefaultBlock({
-      projectSlug: slug,
-      detectedRepos: detectRepos(ctx.root),
-    })
-  );
-  if (!ctx.values.write) return { json: { written: false, block } };
-
-  const file = path.join(ctx.root, GLOBAL_CONFIG_FILE);
-  if (!existsSync(file)) {
-    throw new CliError(
-      `${file} does not exist; set up Lisa in this project first.`,
-      EXIT.SETUP
-    );
-  }
-  const current = JSON.parse(readFileSync(file, "utf8"));
-  writeFileSync(
-    file,
-    `${JSON.stringify({ ...current, sessionManager: block }, null, 2)}\n`
-  );
-  return { json: { written: true, path: file, block } };
-}
-
-/**
- * `store-token [--replace]`: prompt for the bot token on the operator's
- * terminal and write `<stateDir>/.env`. An existing token is kept (exit 2)
- * unless `--replace` is given. With no TTY it prints the command the operator
- * must run themselves and exits 0 with `stored:false`.
- * @param {object} ctx - CLI context
- * @returns {Promise<{ json: object, exitCode: number }>} Outcome
- */
-export async function storeToken(ctx) {
-  const config = requireConfig(ctx);
-  const result = await asSetupErrorAsync(() =>
-    storeTokenFile({
-      stateDir: config.notify?.stateDir,
-      scriptsDir: ctx.scriptsDir,
-      projectRoot: ctx.root,
-      replace: ctx.values.replace === true,
-      env: ctx.env,
-      homedir: ctx.homedir,
-    })
-  );
-  const refused = result.stored === false && result.reason !== "no-tty";
-  return { json: result, exitCode: refused ? EXIT.SETUP : EXIT.OK };
-}
-
 /**
  * `status`: is the manager's tmux session up, and what does the ledger say
  * about each worker it dispatched.

package/plugins/lisa-agy/skills/lisa-session-manager/scripts/cli-setup.mjs

@@ -0,0 +1,165 @@
+/**
+ * Setup subcommands of the session-manager CLI: init-config, store-token,
+ * trust-status and coexistence. Each one answers a question
+ * `lisa-setup-session-manager` would otherwise put to the operator, so setup
+ * asks only what a script cannot find out.
+ * @module session-manager/cli-setup
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+import {
+  CliError,
+  EXIT,
+  GLOBAL_CONFIG_FILE,
+  asSetupError,
+  asSetupErrorAsync,
+  loadProject,
+  requireConfig,
+} from "./cli-runtime.mjs";
+import {
+  buildDefaultBlock,
+  detectRepos,
+  draftHints,
+  resolveRepoDir,
+} from "./config.mjs";
+import { defaultProjectSlug } from "./isolation.mjs";
+import {
+  storeToken as storeTokenFile,
+  storeTokenFromClipboard,
+} from "./launch.mjs";
+import {
+  coexistence as readCoexistence,
+  trustStatus as readTrust,
+} from "./setup-checks.mjs";
+
+/**
+ * `init-config [--slug <slug>] [--write]`: the default block for this
+ * project, written to `.lisa.config.json` only with `--write` and only when
+ * no block exists. Non-secret fields only; the token never goes here. Repos
+ * are the routable children `detectRepos` finds (linked worktrees and second
+ * clones of one remote left out), each with drafted hints.
+ * @param {object} ctx - CLI context
+ * @returns {{ json: object }} `{written,block,...}`
+ */
+export function initConfig(ctx) {
+  const { global } = loadProject(ctx.root);
+  if (global?.sessionManager) {
+    return {
+      json: { written: false, reason: "exists", block: global.sessionManager },
+    };
+  }
+  const slug =
+    ctx.values.slug ?? defaultProjectSlug(ctx.root, global?.github?.repo);
+  const detectedRepos = detectRepos(ctx.root);
+  const hints = Object.fromEntries(
+    detectedRepos.map(name => [
+      name,
+      draftHints(path.join(ctx.root, "projects", name), name),
+    ])
+  );
+  const block = asSetupError(() =>
+    buildDefaultBlock({ projectSlug: slug, detectedRepos, hints })
+  );
+  if (!ctx.values.write) return { json: { written: false, block } };
+
+  const file = path.join(ctx.root, GLOBAL_CONFIG_FILE);
+  if (!existsSync(file)) {
+    throw new CliError(
+      `${file} does not exist; set up Lisa in this project first.`,
+      EXIT.SETUP
+    );
+  }
+  const current = JSON.parse(readFileSync(file, "utf8"));
+  writeFileSync(
+    file,
+    `${JSON.stringify({ ...current, sessionManager: block }, null, 2)}\n`
+  );
+  return { json: { written: true, path: file, block } };
+}
+
+/**
+ * `store-token [--replace] [--from-clipboard]`: store the bot token in the
+ * project's state dir. By default it prompts on the operator's terminal (echo
+ * off); with no TTY it prints the two commands that work instead and exits 0
+ * with `stored:false`. `--from-clipboard` reads the system clipboard and needs
+ * no TTY. An existing token is kept (exit 2) unless `--replace` is given.
+ * @param {object} ctx - CLI context
+ * @returns {Promise<{ json: object, exitCode: number }>} Outcome
+ */
+export async function storeToken(ctx) {
+  const config = requireConfig(ctx);
+  const input = {
+    stateDir: config.notify?.stateDir,
+    scriptsDir: ctx.scriptsDir,
+    projectRoot: ctx.root,
+    replace: ctx.values.replace === true,
+    env: ctx.env,
+    homedir: ctx.homedir,
+  };
+  const result = ctx.values["from-clipboard"]
+    ? asSetupError(() => storeTokenFromClipboard(input))
+    : await asSetupErrorAsync(() => storeTokenFile(input));
+  const refused = result.stored === false && result.reason !== "no-tty";
+  return { json: result, exitCode: refused ? EXIT.SETUP : EXIT.OK };
+}
+
+/**
+ * Every directory a worker can start in: each routed repo, or the root on a
+ * single-repo project.
+ * @param {object} ctx - CLI context
+ * @param {object} config - Resolved block
+ * @returns {string[]} Absolute directories
+ */
+function workerDirs(ctx, config) {
+  const keys = Object.keys(config.repos?.entries ?? {});
+  if (keys.length === 0) return [ctx.root];
+  return keys.map(key =>
+    asSetupError(() => resolveRepoDir(config, key, ctx.root))
+  );
+}
+
+/**
+ * `trust-status`: whether Claude Code has recorded workspace trust for each
+ * worker directory. Exit 0 either way; setup asks the operator only about the
+ * rows that are not `trusted: true`.
+ * @param {object} ctx - CLI context
+ * @returns {{ json: object }} `{file,dirs:[{dir,trusted}],needsTrust}`
+ */
+export function trustStatus(ctx) {
+  const config = requireConfig(ctx);
+  const report = readTrust({
+    dirs: workerDirs(ctx, config),
+    env: ctx.env,
+    homedir: ctx.homedir,
+  });
+  return {
+    json: {
+      ...report,
+      needsTrust: report.dirs
+        .filter(row => row.trusted !== true)
+        .map(row => row.dir),
+    },
+  };
+}
+
+/**
+ * `coexistence`: what this project's run logs say about the scheduled intake
+ * loops that compete with the manager. Exit 0 either way.
+ * @param {object} ctx - CLI context
+ * @returns {{ json: object }} `{windowHours,loops:[...],live}`
+ */
+export function coexistence(ctx) {
+  const config = requireConfig(ctx);
+  const report = readCoexistence({
+    root: ctx.root,
+    now: ctx.now(),
+    stall: config.stall,
+  });
+  return {
+    json: {
+      ...report,
+      live: report.loops.filter(row => row.recent).map(row => row.loop),
+    },
+  };
+}

package/plugins/lisa-agy/skills/lisa-session-manager/scripts/cli-usage.mjs

@@ -61,12 +61,19 @@ Manager
   stop       tmux kill-session -t =<name> only, and only for a session started
              in this root (exit 2 otherwise); workers keep running.
              stdout {status:"stopped"|"not-running",name}.
-  store-token [--replace]
+  store-token [--replace] [--from-clipboard]
              Prompts for the bot token on the terminal (echo off) and writes
              <stateDir>/.env. Exit 2 when a token is already there, unless
-             --replace. With no TTY: exit 0, stdout {stored:false,
-             reason:"no-tty",command} where command is the line the operator
-             runs in their own terminal. Bad input: exit 2.
+             --replace. With no TTY (an agent's Bash, and Claude Code's !
+             prefix too): exit 0, stdout {stored:false,reason:"no-tty",
+             message,command,clipboardCommand}; command is the line the
+             operator runs in a separate terminal app.
+             --from-clipboard reads the token from the clipboard instead
+             (pbpaste; wl-paste, xclip or xsel on Linux), needs no TTY, and
+             clears the clipboard after a successful store. stdout
+             {stored:true,path,clipboardCleared}. The token is never printed.
+             Bad input, empty clipboard or no clipboard tool: exit 2,
+             {stored:false,reason,message}.
 
 Config and routing
   repo-dir [--repo <key>] [--raw]
@@ -75,10 +82,27 @@ Config and routing
   validate   stdout {valid,errors}; exit 2 when invalid or absent.
   init-config [--slug <slug>] [--write]
              stdout {written,block[,reason:"exists"][,path]}. Detects
-             projects/*/.lisa.config.json. Default slug: <github.repo or
-             folder name>-<first 6 hex of sha256(realpath(root))>; --slug is
-             used as given. --write adds the block to .lisa.config.json,
-             never overwriting an existing one.
+             projects/*/.lisa.config.json, skipping linked worktrees (.git is
+             a file) and keeping one child per origin remote (the one named
+             after the repo, else the first by name). Each repo's hints are a
+             draft: its name, then one per well-known package.json dependency
+             (e.g. @nestjs/* -> NestJS, expo -> Expo, aws-cdk-lib -> AWS CDK).
+             Default slug: <github.repo or folder name>-<first 6 hex of
+             sha256(realpath(root))>; --slug is used as given. --write adds
+             the block to .lisa.config.json, never overwriting an existing one.
+  trust-status
+             stdout {file,dirs:[{dir,trusted:true|false|"unknown"}],
+             needsTrust:[dir]}: whether Claude Code has recorded workspace
+             trust (hasTrustDialogAccepted in $CLAUDE_CONFIG_DIR/.claude.json,
+             else ~/.claude.json) for each worker dir. "unknown" when that
+             file cannot be read. Read-only; never accepts trust.
+  coexistence
+             stdout {windowHours,loops:[{loop,log,lastRun:{ts,outcome}|null,
+             recent}],live:[loop]} for intake-tickets and intake-repair, from
+             .lisa/automations/runs/<loop>.jsonl. recent = last run within
+             windowHours (2 x stall.noOutputMinutes x stall.maxAttempts, at
+             least 24h). Run logs only: the runtime's scheduler is the
+             authority on whether a loop is still scheduled.
 
 Per cycle
   queue --tracker github [--me <id>] [--label <name>] [--github-repo <o/r>]

package/plugins/lisa-agy/skills/lisa-session-manager/scripts/clipboard.mjs

@@ -0,0 +1,119 @@
+/**
+ * Read and clear the system clipboard, for `store-token --from-clipboard`.
+ *
+ * `store-token` prompts on a TTY with echo off, and an agent's Bash has no
+ * TTY. Neither does Claude Code's `!` prefix, which is the first thing an
+ * operator inside Claude Code tries, so the only working route used to be a
+ * separate terminal app (CodySwannGT/lisa#4465). The clipboard is the route an
+ * operator reaches for instead: they copy the token from BotFather and the
+ * agent stores it without ever seeing it.
+ *
+ * What is read is a secret. It is returned to the caller and never placed in
+ * an error message, a log line or a return value of anything else here.
+ * @module session-manager/clipboard
+ */
+import { spawnSync } from "node:child_process";
+
+/** Upper bound for one clipboard tool call. */
+const TOOL_TIMEOUT_MS = 5000;
+
+/**
+ * Clipboard tools per platform, tried in order: the first one that runs is
+ * used for both reading and clearing.
+ */
+const TOOLS = Object.freeze({
+  darwin: [{ name: "pbpaste", read: ["pbpaste"], clear: ["pbcopy"] }],
+  linux: [
+    {
+      name: "wl-paste",
+      read: ["wl-paste", "--no-newline"],
+      clear: ["wl-copy", "--clear"],
+    },
+    {
+      name: "xclip",
+      read: ["xclip", "-o", "-selection", "clipboard"],
+      clear: ["xclip", "-i", "-selection", "clipboard"],
+    },
+    {
+      name: "xsel",
+      read: ["xsel", "--clipboard", "--output"],
+      clear: ["xsel", "--clipboard", "--clear"],
+    },
+  ],
+});
+
+/**
+ * Run one tool with empty stdin.
+ *
+ * A clear (`capture: false`) discards the tool's output instead of piping it:
+ * `xclip -i` forks a background selection owner, and a child holding an
+ * inherited pipe makes `spawnSync` wait out the whole timeout. Any spawn
+ * error (a timeout included) is a failure, never a success.
+ * @param {string[]} argv - Command and arguments
+ * @param {{ capture?: boolean }} [options] - Whether to capture stdout
+ * @returns {{ status: number | null, stdout: string, missing: boolean }}
+ *   Outcome; `missing` when the binary is not on PATH
+ */
+function runTool([command, ...args], { capture = true } = {}) {
+  const result = spawnSync(command, args, {
+    input: "",
+    encoding: "utf8",
+    timeout: TOOL_TIMEOUT_MS,
+    stdio: ["pipe", capture ? "pipe" : "ignore", "ignore"],
+  });
+  return {
+    status: result.error ? null : result.status,
+    stdout: result.stdout ?? "",
+    missing: result.error?.code === "ENOENT",
+  };
+}
+
+/**
+ * Read the clipboard with the first available tool for `platform`.
+ * @param {{ platform?: string, run?: typeof runTool }} [seams] - Platform and
+ *   the tool runner
+ * @returns {{ ok: true, text: string, clear: () => boolean } |
+ *   { ok: false, reason: "unsupported" | "unavailable" | "failed",
+ *     message: string }} The text and a function that clears the clipboard
+ *   (true when it did), or why nothing was read
+ */
+export function readClipboard(seams = {}) {
+  const platform = seams.platform ?? process.platform;
+  const run = seams.run ?? runTool;
+  const tools = TOOLS[platform];
+  if (!tools) {
+    return {
+      ok: false,
+      reason: "unsupported",
+      message: `Reading the clipboard is not supported on ${platform}.`,
+    };
+  }
+  const failed = [];
+  for (const tool of tools) {
+    const result = run(tool.read);
+    if (result.missing) continue;
+    // An installed tool can still fail where another works (wl-paste on an
+    // X11 session), so a failure moves on to the next tool.
+    if (result.status !== 0) {
+      failed.push(`${tool.name} exited ${result.status}`);
+      continue;
+    }
+    return {
+      ok: true,
+      text: result.stdout,
+      clear: () => run(tool.clear, { capture: false }).status === 0,
+    };
+  }
+  if (failed.length > 0) {
+    return {
+      ok: false,
+      reason: "failed",
+      message: `${failed.join("; ")}; nothing was read.`,
+    };
+  }
+  return {
+    ok: false,
+    reason: "unavailable",
+    message: `No clipboard tool found (tried ${tools.map(t => t.name).join(", ")}).`,
+  };
+}