@vercel/board 0.20.0 → 0.21.0

package/dist/{main-wB-VfTCL.mjs → main-BZ7nOIhV.mjs}

@@ -1,18 +1,19 @@
 import { i as fileSize, n as DIRECT_UPLOAD_BYTES_MAX } from "./files-SniSmeEr.mjs";
 import { a as AttachmentId } from "./schemas-Be08nyfW.mjs";
-import { a as withMentions, f as VERSION, i as FILTER_FLAGS } from "./watchers-hash-DYwvkhdX.mjs";
+import { a as withMentions, f as VERSION, i as FILTER_FLAGS } from "./watchers-hash-9sxfL1Gd.mjs";
 import { n as displayEmoji, r as normalizeEmoji } from "./emoji-CTLpvH-A.mjs";
 import { t as BoardError } from "./client-ClznIBMg.mjs";
-import { a as detectAgent, c as projectUrl, i as connect, n as boardUrl, r as configDir, s as projectDir, t as http } from "./backend-http-c-VHpUOs.mjs";
-import { t as board } from "./server-BqVickb5.mjs";
+import { n as configDir, o as projectDir, r as connect, t as boardUrl } from "./node-BeKPcokJ.mjs";
+import { t as http } from "./backend-http-Dzb4lpMG.mjs";
+import { t as board } from "./server-Du0rSpcW.mjs";
 import { t as conformance } from "./conformance-DQ9qVzWP.mjs";
+import { n as vercel, t as credentialSource } from "./backend-vercel-BjUpoLR9.mjs";
 import { t as displayText } from "./bots-CGkO76qH.mjs";
-import { execFileSync, spawn } from "node:child_process";
-import { createHash } from "node:crypto";
+import { spawn } from "node:child_process";
 import { appendFile, mkdir, readFile, stat, writeFile } from "node:fs/promises";
-import { chmodSync, existsSync, mkdirSync, readFileSync, realpathSync, renameSync, statSync, unlinkSync, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
-import { basename, delimiter, dirname, isAbsolute, join } from "node:path";
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
 import { parseArgs } from "node:util";
 //#region src/cli/format.ts
 /** "claude via julian" for a profile, the name otherwise. */
@@ -336,94 +337,6 @@ function without(entries, shape) {
 }
 /** The line of our Pi extension that holds the command it runs: how status finds it. */
 const PI_COMMAND = /^const COMMAND = (".*")$/m;
-/**
-* Pi's turn-end hook, as an extension. Before Pi settles a completed run, it
-* runs our command with what Claude Code's hook gets (the session, the
-* directory, and whether this hook made it continue); a reminder comes back
-* as a message, and Pi continues once to act on it. Pi's bash tool exports the
-* same session as `PI_SESSION_ID`, so the agent's `vb reply` or `vb post` counts for it.
-*/
-function piExtension(command) {
-	return `// Added by \`vb hooks install pi\`: reminds Pi, once per turn, to update the team's board.
-// \`vb hooks uninstall pi\` removes it; reinstalling replaces this file.
-import { spawn } from 'node:child_process'
-
-const COMMAND = ${JSON.stringify(command)}
-
-function run(cwd: string, input: string): Promise<string> {
-  return new Promise((resolve) => {
-    let out = ''
-    const child = spawn('/bin/sh', ['-c', COMMAND], { cwd, stdio: ['pipe', 'pipe', 'ignore'] })
-    const timer = setTimeout(() => child.kill(), 10_000)
-    child.stdout.on('data', (chunk) => (out += chunk))
-    child.on('error', () => resolve(''))
-    child.on('close', () => (clearTimeout(timer), resolve(out)))
-    child.stdin.on('error', () => {})
-    child.stdin.end(input)
-  })
-}
-
-export default function board(pi: any) {
-  let reminded = false
-  pi.on('agent_before_settle', async (event: any, ctx: any) => {
-    const continuing = reminded
-    reminded = false
-    if (event.outcome !== 'completed') return
-    try {
-      const input = JSON.stringify({ session_id: ctx.sessionManager.getSessionId(), cwd: ctx.cwd, stop_hook_active: continuing })
-      const reason = JSON.parse((await run(ctx.cwd, input)) || '{}').reason
-      if (typeof reason !== 'string' || !reason) return
-      reminded = true
-      return { entries: [...event.entries, { type: 'custom_message', customType: 'board', content: reason, display: true }], continue: true }
-    } catch {}
-  })
-}
-`;
-}
-/**
-* The command our hook runs. `|| true`: whatever `cli` turns out to be (an older board without
-* `hook` exits 2, which Claude Code and Codex read as "keep going"), the hook can't fail a turn.
-*/
-const hookCommand = (agent, cli, flags = "") => `${cli} hook stop --agent ${agent}${flags} 2>/dev/null || true`;
-/** Adds our hook, replacing an earlier one of ours; everything else in the file stays. Answers whether it changed. */
-function installHook(agent, cli, flags = "") {
-	const spec = AGENTS[agent];
-	const command = hookCommand(agent, cli, flags);
-	if (spec.shape === "extension") {
-		const source = piExtension(command);
-		let current = null;
-		try {
-			current = readFileSync(spec.file(), "utf8");
-		} catch {}
-		if (current === source) return false;
-		if (current !== null && !current.startsWith("// Added by `vb hooks install pi`")) throw new Error(`${spec.file()} isn't board's: move it, then install again`);
-		mkdirSync(dirname(spec.file()), { recursive: true });
-		writeFileSync(`${spec.file()}.board-tmp`, source);
-		renameSync(`${spec.file()}.board-tmp`, spec.file());
-		return true;
-	}
-	const config = readConfig(spec.file());
-	const entry = spec.shape === "flat" ? {
-		command,
-		timeout: 10
-	} : { hooks: [{
-		type: "command",
-		command,
-		timeout: 10
-	}] };
-	const hooks = {
-		...config.hooks,
-		[spec.event]: [...without(config.hooks?.[spec.event] ?? [], spec.shape), entry]
-	};
-	const next = {
-		...spec.shape === "flat" ? { version: 1 } : {},
-		...config,
-		hooks
-	};
-	if (JSON.stringify(next) === JSON.stringify(config)) return false;
-	writeConfig(spec.file(), next);
-	return true;
-}
 /** Removes our hook. A file that held only it (Cursor's, which we created) goes away with it. */
 function uninstallHook(agent) {
 	const spec = AGENTS[agent];
@@ -461,26 +374,19 @@ function tilde(path) {
 /** The CLI an installed hook runs: everything before ` hook stop`. */
 const cliOf = (command) => command.slice(0, command.indexOf(" hook stop "));
 /**
-* The reminder asks the agent to run `vb reply`, `vb post`, `vb read`, and `vb channels`;
-* where the agent keeps an allowlist, those run without a permission prompt.
-* Claude Code matches command prefixes; Cursor matches a command's name, so it
-* can allow only a `vb` on PATH. Codex has no command allowlist: its sandbox
-* decides (see `codexNetwork`).
+* The allow rules an install added, so the reminded commands ran without a prompt: Claude Code's
+* command prefixes (`vb update` from the oldest installs), and Cursor's `vb` on PATH.
 */
-const REMINDED = [
-	"reply",
-	"post",
-	"read",
-	"channels"
-];
-/** Rules an earlier install added that this one doesn't: `vb update`, since removed. Uninstall drops them too. */
-function legacyRules(agent, cli) {
-	return agent === "claude" ? [`Bash(${cli} update:*)`] : [];
-}
 function allowRules(agent, cli) {
 	if (agent === "claude") return {
 		file: AGENTS.claude.file(),
-		rules: REMINDED.map((sub) => `Bash(${cli} ${sub}:*)`)
+		rules: [
+			"reply",
+			"post",
+			"read",
+			"channels",
+			"update"
+		].map((sub) => `Bash(${cli} ${sub}:*)`)
 	};
 	if (agent === "cursor" && cli === "vb") return {
 		file: join(homedir(), ".cursor", "cli-config.json"),
@@ -488,20 +394,6 @@ function allowRules(agent, cli) {
 	};
 	return null;
 }
-/** Adds the rules a file doesn't have yet. Answers the ones it added. */
-function allow(file, rules) {
-	const config = readConfig(file);
-	const allowed = config.permissions?.allow ?? [];
-	const added = rules.filter((rule) => !allowed.includes(rule));
-	if (added.length > 0) writeConfig(file, {
-		...config,
-		permissions: {
-			...config.permissions,
-			allow: [...allowed, ...added]
-		}
-	});
-	return added;
-}
 /** Removes the rules a file has. Answers whether it removed any. */
 function disallow(file, rules) {
 	const config = readConfig(file);
@@ -516,179 +408,6 @@ function disallow(file, rules) {
 	});
 	return true;
 }
-/**
-* Codex's default sandbox has no network, so `vb` can't reach the board. A
-* permission profile can allow just the board, and Vercel's API for its token.
-* In TOML a key after a `[table]` belongs to it, so `default_permissions` goes
-* at the top; the tables go anywhere (`[features]` merged into one that's there).
-*/
-function codexNetwork(boardHost) {
-	return {
-		top: "default_permissions = \"board\"",
-		tables: [
-			"[features]",
-			"network_proxy = true",
-			"",
-			"[permissions.board]",
-			"extends = \":workspace\"",
-			"",
-			"[permissions.board.network]",
-			"enabled = true",
-			"",
-			"[permissions.board.network.domains]",
-			...[boardHost ?? "<your board host>", "api.vercel.com"].map((host) => `"${host}" = "allow"`)
-		].join("\n")
-	};
-}
-/** Names in words: `a`, `a or b`, `a, b, or c`. */
-const either = (names) => names.length < 3 ? names.join(" or ") : `${names.slice(0, -1).join(", ")}, or ${names.at(-1)}`;
-/**
-* How an installed hook differs from what installing it again would write, as
-* short phrases (none when it's current): an older hook command or Pi
-* extension, rules for commands since removed, rules it doesn't have yet.
-* It keeps the CLI the hook runs, which `install` may choose differently.
-*/
-function outdated(agent, installed) {
-	const spec = AGENTS[agent];
-	const cli = cliOf(installed);
-	const problems = [];
-	if (installed !== hookCommand(agent, cli)) problems.push("runs an older hook command");
-	if (spec.shape === "extension") {
-		let source = "";
-		try {
-			source = readFileSync(spec.file(), "utf8");
-		} catch {}
-		if (source !== piExtension(installed)) problems.push("the extension is from another version");
-	}
-	const rules = allowRules(agent, cli);
-	if (rules) {
-		const allowed = readConfig(rules.file).permissions?.allow ?? [];
-		const sub = (rule) => {
-			const inner = /^\w+\((.*?)(?::\*)?\)$/.exec(rule)?.[1] ?? rule;
-			return inner.startsWith(`${cli} `) ? inner.slice(cli.length + 1) : inner;
-		};
-		const gone = legacyRules(agent, cli).filter((rule) => allowed.includes(rule));
-		const missing = rules.rules.filter((rule) => !allowed.includes(rule));
-		if (gone.length > 0) problems.push(`allows ${either(gone.map(sub))}, which ${gone.length === 1 ? "is" : "are"} gone`);
-		if (missing.length > 0) problems.push(`doesn't allow ${either(missing.map(sub))}`);
-	}
-	return problems;
-}
-/**
-* In the temp directory, which agents' sandboxes let commands write (Codex's
-* doesn't allow ~/.config): a marker only has to last a few turns, and the
-* system clears it with the rest of its temp files. `XDG_RUNTIME_DIR`, where
-* there is one, is the user's own.
-*/
-const turnsDir = () => join(process.env.XDG_RUNTIME_DIR || tmpdir(), `board-turns-${process.getuid?.() ?? "user"}`);
-const turnsFile = (session) => join(turnsDir(), `${session.replace(/[^A-Za-z0-9_.-]/g, "_")}.json`);
-function readTurns(session) {
-	try {
-		return JSON.parse(readFileSync(turnsFile(session), "utf8"));
-	} catch {
-		return {};
-	}
-}
-/** The marker directory, only if it's ours: in a shared /tmp, someone else could have made it first. */
-function ownTurnsDir() {
-	const dir = turnsDir();
-	mkdirSync(dir, {
-		recursive: true,
-		mode: 448
-	});
-	const { uid, mode } = statSync(dir);
-	if (process.getuid && uid !== process.getuid()) throw new Error(`${dir} belongs to someone else`);
-	if ((mode & 63) !== 0) chmodSync(dir, 448);
-	return dir;
-}
-function writeTurns(session, turns) {
-	ownTurnsDir();
-	writeFileSync(turnsFile(session), JSON.stringify(turns));
-}
-/** A write to the board from an agent session: this turn needs no reminder. Best effort: the write already happened. */
-function markPosted(session, now = Date.now()) {
-	try {
-		writeTurns(session, {
-			...readTurns(session),
-			posted: now
-		});
-	} catch {}
-}
-/**
-* The turn-end decision: let the agent stop, or remind it once to update the
-* board. It stops freely when it wrote to the board since its last turn
-* ended, when it was already reminded this turn, or when the agent says a
-* hook made it continue (`continuing`), so it can never loop.
-*/
-function decideStop(session, continuing, now = Date.now()) {
-	const turns = readTurns(session);
-	const since = turns.settled ?? 0;
-	if (continuing || (turns.posted ?? 0) > since || (turns.asked ?? 0) > since) {
-		writeTurns(session, {
-			...turns,
-			settled: now
-		});
-		return "stop";
-	}
-	writeTurns(session, {
-		...turns,
-		asked: now
-	});
-	return "ask";
-}
-/**
-* The reminder, with the exact commands to run. It doesn't pick a channel: the
-* agent replies in a thread it's working in, or finds the channel that fits.
-* Finishing without a write is fine, since the hook asks only once a turn.
-*/
-function reminder(cli) {
-	return [
-		"You didn't update the team's board this turn.",
-		`If you changed anything or made progress, share a 1–3 sentence summary of what you did and what's next where the team will see it: ${cli} reply <id> "<text>" in a board thread you're working in, or ${cli} post <channel> "<text>" in the channel that fits (${cli} channels lists them, ${cli} read <channel> shows what's there). Add --attach <file> for proof, like a test log.`,
-		`If you want to store memory, you can post to brain-<username>. Channels are public, so never store sensitive information.`,
-		"If this turn changed nothing worth sharing (say, you just answered a question), just finish. Don't include the prompt, long output, or secrets."
-	].join(" ");
-}
-/** Marks the offer made for `board`. True only for the call that made it, and never when it can't be saved. */
-function claimLinkOffer(board) {
-	const file = join(configDir(), "link-offered", createHash("sha256").update(board).digest("hex").slice(0, 32));
-	try {
-		mkdirSync(dirname(file), {
-			recursive: true,
-			mode: 448
-		});
-		writeFileSync(file, "", { flag: "wx" });
-		return true;
-	} catch {
-		return false;
-	}
-}
-function linkOffer(cli) {
-	return [
-		`One more thing, this time only: run ${cli} identity.`,
-		"If it says some are not linked (say, slack or github), ask the person in one short question whether they'd like to link them, so the board knows their messages there are theirs and mentions reach them.",
-		`If they say yes, run ${cli} identity link <key> --no-wait for each and give them the sign-in URL or code it prints: only they should open or post it.`,
-		"If they say no, or there's nothing to link, drop it. This won't come up again."
-	].join(" ");
-}
-/**
-* The reminder as each agent reads it from the hook's stdout. Claude Code
-* shows a stop's `additionalContext` once, as hook feedback, and continues the
-* turn; a blocked stop would also show it as a hook error. Codex and Pi's
-* extension read a blocked stop's `reason`; Cursor, whose stop can't block,
-* a `followup_message`.
-*/
-function stopOutput(agent, text) {
-	if (agent === "claude") return { hookSpecificOutput: {
-		hookEventName: "Stop",
-		additionalContext: text
-	} };
-	if (agent === "cursor") return { followup_message: text };
-	return {
-		decision: "block",
-		reason: text
-	};
-}
 //#endregion
 //#region src/cli/main.ts
 const help = () => `${app.name} ${VERSION}: a message board you mount in one route
@@ -738,15 +457,15 @@ usage: ${app.name} <command> [options]${app.name === "board" ? "      (also inst
   conformance [--channel <c>]              check that the board speaks the protocol: posts to conformance,
                                            kept on the board, and deletes what it posted (1 if a check fails)
 
-  hooks [install|uninstall|status] [claude|codex|cursor|pi]...
-                                           after a turn that didn't update the board, remind the agent to (linked projects only)
+  hooks uninstall [claude|codex|cursor|pi]...
+                                           remove the turn-end hooks an earlier board installed
 
   tail [channel] [filters] [--all]         live, until Ctrl-C
   wait [channel] [filters] [--timeout 30m] block for the next match, print it, then exit (124 on timeout)${Object.keys(app.commands).length > 0 ? `\n\n${Object.values(app.commands).map((command) => command.help).join("\n")}` : ""}
 
 filters:  --re <id>  --by <handle>  --from <source>  --label k[=v|w]  --text <words>  --mentions [@handle]  --after <id>
           labels match a message or its thread's root; repeated flags all must match
-global:   --url <url>  --as <profile>  --avatar <url>  --human  --handle <h>  --json
+global:   --url <url>  --scope <team>  --as <profile>  --avatar <url>  --human  --handle <h>  --json
 json:     one object per line (JSONL): { message, replies, last } for read <channel>, a message for read <id>
 text:     pass "-" to read it from stdin; it may be left out when you --attach
 env:      BOARD_URL  BOARD_TOKEN  BOARD_AS  BOARD_AVATAR  BOARD_HANDLE`;
@@ -759,6 +478,8 @@ const OPTIONS = {
 	human: { type: "boolean" },
 	handle: { type: "string" },
 	json: { type: "boolean" },
+	scope: { type: "string" },
+	team: { type: "string" },
 	help: {
 		type: "boolean",
 		short: "h"
@@ -831,8 +552,9 @@ function removedCommand(word) {
 	};
 	return Object.hasOwn(removed, word) ? removed[word] : void 0;
 }
-/** The command word: the first argument that isn't a flag or a string flag's value. */
-function commandWord(args) {
+/** The command word: the first argument that isn't a flag or a string flag's value (a bare `--mentions` takes none). */
+function commandWord(argv) {
+	const args = withMentions(argv);
 	for (let i = 0; i < args.length; i++) {
 		const arg = args[i];
 		if (arg === "--") return args[i + 1];
@@ -892,6 +614,8 @@ function messageId(value, what = "message id") {
 }
 /** Whether an argument names a message rather than a channel: `#<id>`, or a bare number. */
 const isMessageRef = (value) => /^#[^\s/]+$/.test(value) || /^\d+$/.test(value);
+/** A message's ID as it's passed back: bare when it's a number, `#<id>` when it could be a channel's name. */
+const messageRef = (id) => /^\d+$/.test(id) ? id : `#${id}`;
 function labelPairs(values) {
 	const pairs = {};
 	for (const value of values ?? []) {
@@ -950,15 +674,15 @@ function filters(channel) {
 	};
 }
 /**
-* The board this command talks to, `--url`'s or the one the environment points at, as `--as`
-* says: a handle on it, and how it reaches it (the credentials `vb` finds, `--handle`'s handle).
+* The board the environment points at. With none, the team's board for an app that has one
+* (null), or else how to point at one, with the commands this app has.
 */
-/** The board the environment points at; with none, how to point at one, with the commands this app has. */
 function configuredUrl() {
 	try {
 		return boardUrl();
 	} catch (error) {
 		if (!(error instanceof BoardError) || error.code !== "no_board") throw error;
+		if (app.teamBoard) return null;
 		const ways = [
 			`run \`${app.name} link <url>\``,
 			"set BOARD_URL",
@@ -968,22 +692,44 @@ function configuredUrl() {
 		throw new BoardError("no_board", `no board URL: ${ways.slice(0, -1).join(", ")}, or ${ways.at(-1)}`, 0);
 	}
 }
+/** Who the handle writes as: `--as`'s profile (with `--avatar`), yourself with `--human`, or what the environment says. */
+function profileFlag() {
+	if (flags.human) return null;
+	if (!flags.as) return void 0;
+	return flags.avatar ? {
+		name: flags.as,
+		avatar: flags.avatar
+	} : flags.as;
+}
+/**
+* The board this command talks to, as `--as` says: a handle on it, where it is (null until its
+* discovery says, for a team's board), and how it reaches it. It's `--url`'s; a team's board in
+* Vercel's API for `--scope` or `--team`; the one the environment points at; or, for an app with
+* a team board, the linked project's team's, or your login's.
+*/
 function connection(url = flags.url, options = {}) {
-	const at = (url ?? configuredUrl()).replace(/\/+$/, "");
+	const profile = profileFlag();
+	const team = flags.scope ?? flags.team;
+	const configured = url ?? (team === void 0 ? configuredUrl() : null);
+	if (configured === null) {
+		const board$1 = board({ backend: vercel(team !== void 0 ? { team } : {}) });
+		return {
+			url: null,
+			transport: { source: credentialSource },
+			board: profile !== void 0 ? board$1.as(profile) : board$1
+		};
+	}
+	const at = configured.replace(/\/+$/, "");
 	const handle = options.handle ?? flags.handle;
 	const transport = connect(at, {
 		...options.token !== void 0 ? { token: options.token } : {},
 		...handle ? { handle } : {}
 	});
-	const board$1 = board({ backend: http(at, { fetch: transport.fetch }) });
-	const profile = flags.human ? null : flags.as ? flags.avatar ? {
-		name: flags.as,
-		avatar: flags.avatar
-	} : flags.as : void 0;
+	const board$2 = board({ backend: http(at, { fetch: transport.fetch }) });
 	return {
 		url: at,
 		transport,
-		board: profile !== void 0 ? board$1.as(profile) : board$1
+		board: profile !== void 0 ? board$2.as(profile) : board$2
 	};
 }
 /** A handle on the board this command talks to: `vb()`'s, as `--as` says, or the one `connection()` finds. */
@@ -996,105 +742,6 @@ function client() {
 	} : flags.as);
 	return io.board;
 }
-/**
-* What names an agent's turns, for the turn-end hook: its session, or for
-* Cursor, whose shell has no session ID, the project it works in.
-*/
-const turnKey = (agent, session) => session ?? (agent === "cursor" ? `cursor@${projectDir()}` : null);
-/** A write from an agent session counts as this turn's board update. */
-function wrote() {
-	const detected = flags.human ? null : detectAgent();
-	const key = detected ? turnKey(detected.profile, detected.session) : null;
-	if (key) markPosted(key);
-}
-const fromNpx = (path) => /[\\/]_npx[\\/]/.test(path);
-/** The first `vb` on PATH outside npx's cache, which is gone once npx exits. */
-function globalVb() {
-	for (const dir of (process.env.PATH ?? "").split(delimiter)) {
-		const candidate = join(dir, "vb");
-		if (existsSync(candidate) && !fromNpx(realpathSync(candidate))) return candidate;
-	}
-	return null;
-}
-/**
-* Whether `bin` runs the CLI at `self`: a symlink to it (npm), or a shell
-* shim that execs node on it (pnpm, through `$basedir`- or `$basedir_abs`-relative paths).
-*/
-function runsCli(bin, self) {
-	try {
-		const real = realpathSync(bin);
-		if (real === self) return true;
-		if (statSync(real).size > 65536) return false;
-		const script = readFileSync(real, "utf8");
-		if (!script.startsWith("#!")) return false;
-		const basedir = dirname(bin);
-		const paths = [...[...script.matchAll(/"([^"\n]+)"/g)].map(([, quoted]) => quoted.replace(/^\$(?:\{basedir(?:_abs)?\}|basedir(?:_abs)?)(?=\/)/, basedir)), ...[...script.matchAll(/^# cmd-shim-target=(.+)$/gm)].map(([, target]) => target.trim())];
-		for (const path of paths) if (isAbsolute(path) && existsSync(path) && realpathSync(path) === self) return true;
-	} catch {}
-	return false;
-}
-/**
-* How an agent's hook should run this CLI, long after this command exits:
-* `vb` when that's this CLI; under npx, a global `vb` of this version, else
-* this version through npx; otherwise this CLI's full path.
-*/
-function cliCommand() {
-	if (app.command) return { command: app.command };
-	const self = realpathSync(process.argv[1]);
-	const installed = globalVb();
-	if (!fromNpx(self)) {
-		if (installed && runsCli(installed, self)) return { command: "vb" };
-		const quote = (part) => /^[\w./-]+$/.test(part) ? part : `'${part.replace(/'/g, `'\\''`)}'`;
-		return { command: [process.execPath, self].map(quote).join(" ") };
-	}
-	let version = "";
-	try {
-		version = installed ? execFileSync(installed, ["--version"], {
-			encoding: "utf8",
-			timeout: 5e3,
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		}).trim() : "";
-	} catch {}
-	if (version === VERSION) return { command: "vb" };
-	return {
-		command: `npx -y @vercel/board@${VERSION}`,
-		note: `the hook runs board ${VERSION} through npx${installed ? ` (your vb is ${version || "older"})` : ""}; \`npm i -g @vercel/board\` makes it start faster`
-	};
-}
-/**
-* The board version a hook's CLI runs: pinned in an npx command, else what it
-* answers to `--version` (the first `vb` on PATH, for plain `vb`). Null when
-* it doesn't answer with one.
-*/
-function hookVersion(cli) {
-	const pinned = /^npx -y @vercel\/board@(\S+)$/.exec(cli);
-	if (pinned) return pinned[1];
-	try {
-		const answer = execFileSync("/bin/sh", ["-c", `${cli} --version`], {
-			encoding: "utf8",
-			timeout: 5e3,
-			stdio: [
-				"ignore",
-				"pipe",
-				"ignore"
-			]
-		}).trim();
-		return /^\d+\.\d+\.\d+\S*$/.test(answer) ? answer : null;
-	} catch {
-		return null;
-	}
-}
-/** Whether version `a` comes before `b`, by major, minor, and patch. */
-function olderVersion(a, b) {
-	const parts = (version) => version.split(/[.-]/).slice(0, 3).map(Number);
-	const [x, y] = [parts(a), parts(b)];
-	for (let i = 0; i < 3; i++) if (x[i] !== y[i]) return (x[i] ?? 0) < (y[i] ?? 0);
-	return false;
-}
 async function readStdin() {
 	const chunks = [];
 	for await (const chunk of process.stdin) chunks.push(chunk);
@@ -1115,7 +762,7 @@ function warnUnknownMentions(handles) {
 }
 function printMessage(message) {
 	if (flags.json) printJson(message);
-	else out(String(message.id));
+	else out(messageRef(message.id));
 }
 function printEvent(event) {
 	if (flags.json) printJson(event);
@@ -1257,8 +904,9 @@ async function run(command, args) {
 			return 0;
 		}
 		case "whoami": {
-			const { board, url, transport } = connection();
+			const { board, url: given, transport } = connection();
 			const me = await board.me();
+			const url = given ?? (await board.discovery()).url;
 			const source = transport.source();
 			if (flags.json) {
 				printJson({
@@ -1369,7 +1017,6 @@ async function run(command, args) {
 				...options,
 				...flags.sync?.length ? { sync: flags.sync } : {}
 			}) : await board.reply(re, options);
-			wrote();
 			warnUnknownMentions(message.unknownMentions);
 			printMessage(message);
 			return 0;
@@ -1385,7 +1032,6 @@ async function run(command, args) {
 				...flags.id ? { id: flags.id } : {},
 				...flags["no-sync"] ? { noSync: true } : {}
 			});
-			wrote();
 			warnUnknownMentions(message.unknownMentions);
 			printMessage(message);
 			return 0;
@@ -1419,7 +1065,6 @@ async function run(command, args) {
 				...flags.for ? { for: flags.for } : {},
 				...times !== void 0 ? { times } : {}
 			});
-			wrote();
 			warnUnknownMentions(schedule.unknownMentions);
 			if (flags.json) printJson(schedule);
 			else out(formatSchedule(schedule));
@@ -1438,102 +1083,24 @@ async function run(command, args) {
 			return 0;
 		}
 		case "hooks": {
-			const [action = "status", ...names] = args;
+			const [action, ...names] = args;
+			if (action !== "uninstall") throw new UsageError(`\`${`${named()} hooks ${action ?? ""}`.trimEnd()}\` is gone: turn-end hooks were removed. Run \`${named()} hooks uninstall\` to clear an earlier install`);
 			const agents = hookAgents(names);
 			const width = Math.max(...agents.map((agent) => AGENTS[agent].name.length));
-			const row = (agent, ...cells) => out([AGENTS[agent].name.padEnd(width), ...cells].join("  ").trimEnd());
-			if (action === "status") {
-				const versions = /* @__PURE__ */ new Map();
-				for (const agent of agents) {
-					const installed = installedHook(agent);
-					if (installed === null) {
-						row(agent, "not installed");
-						continue;
-					}
-					const cli = cliOf(installed);
-					const problems = outdated(agent, installed);
-					if (!versions.has(cli)) versions.set(cli, app.command ? null : hookVersion(cli));
-					const version = versions.get(cli);
-					const behind = version != null && olderVersion(version, VERSION);
-					if (behind) problems.push(`runs board ${version}, not ${VERSION}`);
-					row(agent, (problems.length ? "outdated" : "installed").padEnd(9), tilde(AGENTS[agent].file()));
-					if (problems.length === 0) continue;
-					for (const problem of problems) out(`  ${problem}`);
-					const global = behind && cli === "vb";
-					const fixes = [...global ? ["npm i -g @vercel/board"] : [], ...problems.length > (global ? 1 : 0) ? [`${named()} hooks install ${agent}`] : []];
-					out(`  fix with ${fixes.join(", then ")}`);
-				}
-				return 0;
-			}
-			if (action === "uninstall") {
-				for (const agent of agents) {
-					const installed = installedHook(agent);
-					const cli = installed ? cliOf(installed) : null;
-					const rules = cli ? allowRules(agent, cli) : null;
-					if (rules) disallow(rules.file, [...rules.rules, ...legacyRules(agent, cli)]);
-					row(agent, uninstallHook(agent) ? "removed" : "not installed", installed ? tilde(AGENTS[agent].file()) : "");
-				}
-				return 0;
-			}
-			if (action !== "install") throw new UsageError(`usage: ${app.name} hooks [install|uninstall|status] [claude|codex|cursor|pi]...`);
-			const { command: cli, note } = cliCommand();
 			for (const agent of agents) {
-				const had = installedHook(agent) !== null;
-				const changed = installHook(agent, cli);
-				const rules = allowRules(agent, cli);
-				const added = rules ? allow(rules.file, rules.rules) : [];
-				const dropped = rules ? disallow(rules.file, legacyRules(agent, cli)) : false;
-				out(`${AGENTS[agent].name}  ${tilde(AGENTS[agent].file())}`);
-				out(`  ${!had ? "added the turn-end hook" : changed || added.length > 0 || dropped ? "updated" : "already installed"}`);
-				if (added.length > 0) out(`  ${agent === "claude" ? "reply, post, read, and channels run without asking" : `${named()} runs without asking`}`);
-				if (agent === "cursor" && !rules && !app.command) out("  npm i -g @vercel/board lets Cursor run vb without asking");
-				if (agent === "codex") {
-					if (changed) out("  approve it once in Codex with /hooks");
-					let host = null;
-					try {
-						const url = process.env.BOARD_URL || projectUrl();
-						host = url ? new URL(url).hostname : null;
-					} catch {}
-					const config = join(process.env.CODEX_HOME || join(homedir(), ".codex"), "config.toml");
-					const profile = codexNetwork(host);
-					out(`  to let ${named()} reach the board from Codex's sandbox, add to ${tilde(config)}:`);
-					out("");
-					out([
-						"# a permission profile (beta) that opens the network to just the board",
-						"",
-						"# at the top, before any [table]",
-						profile.top,
-						"",
-						"# anywhere (merge [features] into yours)",
-						profile.tables
-					].join("\n").replace(/^(?=.)/gm, "    "));
-				}
-				out("");
+				const installed = installedHook(agent);
+				const cli = installed ? cliOf(installed) : null;
+				const rules = cli ? allowRules(agent, cli) : null;
+				if (rules) disallow(rules.file, rules.rules);
+				out([
+					AGENTS[agent].name.padEnd(width),
+					uninstallHook(agent) ? "removed" : "not installed",
+					installed ? tilde(AGENTS[agent].file()) : ""
+				].join("  ").trimEnd());
 			}
-			if (note) out(`${note[0].toUpperCase()}${note.slice(1)}.`);
-			out("The hooks remind once per turn without a board update.");
-			out(`They stay quiet outside projects linked with \`${named()} link <url>\`.`);
-			return 0;
-		}
-		case "hook": {
-			if (args[0] !== "stop") throw new UsageError("usage: board hook stop --agent <agent>   (run by an agent's turn-end hook)");
-			const agent = flags.agent ?? "agent";
-			try {
-				const payload = JSON.parse(await readStdin());
-				const cwd = payload.cwd ?? payload.workspace_roots?.[0];
-				if (cwd && existsSync(cwd)) process.chdir(cwd);
-				const session = turnKey(agent, agent === "cursor" ? null : payload.session_id ?? null);
-				const boardUrl = process.env.BOARD_URL || projectUrl();
-				if (!session || !boardUrl) return 0;
-				if (payload.status && payload.status !== "completed") return 0;
-				if (decideStop(session, payload.stop_hook_active === true || (payload.loop_count ?? 0) > 0) === "ask") {
-					const cli = cliCommand().command;
-					const text = claimLinkOffer(boardUrl) ? `${reminder(cli)}\n\n${linkOffer(cli)}` : reminder(cli);
-					printJson(stopOutput(agent, text));
-				}
-			} catch {}
 			return 0;
 		}
+		case "hook": return 0;
 		case "edit": {
 			const { unknownMentions } = await client().edit(messageId(args[0]), await text(args[1]));
 			warnUnknownMentions(unknownMentions);