skydive-cli 0.2.0 → 0.3.0

package/dist/js/bin.mjs

@@ -1,28 +1,26 @@
 #!/usr/bin/env node
-import { A as getShareMachineDefault, B as saveSession, C as DEFAULT_WEB_URL, D as getPromptHistoryPath, E as getLastSeenVersion, F as resolveConfig, H as setLastSeenVersion, I as resolveManagementAuth, L as resolveSession, M as getStoredApiKeyWorkspaceName, N as getUpdateCheckDisabled, P as resolveAppUrl, T as getConfigPath, _ as setActiveWorkspace, b as API_KEY_PREFIX, d as themes, g as listWorkspaces, h as getSessionIdentity, j as getStoredApiKeyId, m as getActiveWorkspaceId, p as ensureActiveOrganization, v as API_KEYS_URL, w as deleteConfig, x as DEFAULT_API_URL, y as API_KEY_FAMILY_PREFIX, z as saveConfig } from "./theme-CuQhvqzN.mjs";
-import { n as printError, r as printTable, t as output } from "./output-B4cW10Ph.mjs";
-import { n as createRestClient } from "./rest-CamHVOce.mjs";
-import { i as resolveAgent } from "./print-Bin4u16d.mjs";
-import { a as registerPortalDevice, c as machineIdentity, n as findThisDevice, o as revokePortalAccess, r as grantPortalAccess, t as fetchPortalDevices } from "./api-CDTKq_5Q.mjs";
-import { t as SandboxStream } from "./client-CpEvH2Pq.mjs";
+import { C as setActiveWorkspace, S as listWorkspaces, T as version, _ as themes, b as getActiveWorkspaceId, o as brandHelpArt, t as installCrashHandler, w as name, x as getSessionIdentity, y as ensureActiveOrganization } from "./install-CMYBFvR2.mjs";
+import { A as resolveAppUrl, C as getPromptHistoryPath, D as getStoredApiKeyId, E as getShareMachineDefault, F as saveConfig, I as saveSession, M as resolveManagementAuth, N as resolveSession, O as getStoredApiKeyWorkspaceName, R as setLastSeenVersion, S as getLastSeenVersion, _ as API_KEY_PREFIX, b as deleteConfig, g as API_KEY_FAMILY_PREFIX, h as API_KEYS_URL, i as resolveAgent, j as resolveConfig, k as getUpdateCheckDisabled, v as DEFAULT_API_URL, x as getConfigPath } from "./print-Cd-bVSEJ.mjs";
+import { n as printError, r as printTable, t as output } from "./output-DYzzdXYV.mjs";
+import { n as createRestClient, t as HttpError } from "./rest-BlN_uWmL.mjs";
+import { a as registerPortalDevice, i as grantPortalAccess, n as fetchPortalDevices, o as revokePortalAccess, r as findThisDevice, s as machineIdentity } from "./client-Dc7GZ3PG.mjs";
+import { c as PORTAL_DAEMON_FLAG, i as queryDaemonStatus, l as daemonPaths, n as ensureDaemonRunning, o as stopDaemon } from "./daemon-Co4CtpXZ.mjs";
+import { t as SandboxStream } from "./client-DfcJFEbh.mjs";
 import { hideBin } from "yargs/helpers";
 import yargs from "yargs";
-import { hostname } from "node:os";
+import os, { hostname } from "node:os";
 import path from "node:path";
 import { err, ok } from "neverthrow";
 import { z } from "zod";
 import open from "open";
+import fs from "node:fs";
 import { spawn, spawnSync } from "node:child_process";
 import { createHash } from "node:crypto";
-import fs from "node:fs";
 import zlib from "node:zlib";
+import fsp from "node:fs/promises";
 import semver from "semver";
+import { createInterface } from "node:readline";
 
-//#region package.json
-var name = "skydive-cli";
-var version = "0.2.0";
-
-//#endregion
 //#region src/types.ts
 const NON_INTERACTIVE_ENV_VARS = [
 	"CI",
@@ -715,6 +713,308 @@ const authCommand = {
 	handler: () => {}
 };
 
+//#endregion
+//#region src/commands/completion.ts
+/**
+* The argv sentinel yargs answers with completion candidates for a partially
+* typed command line. The scripts below are the only callers; `bin.ts` also
+* matches on it to keep notices off the user's prompt (see isCompletionProbe).
+*/
+const COMPLETION_PROBE_FLAG = "--get-yargs-completions";
+const SUPPORTED_SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+/**
+* True when this invocation is a shell asking for completion candidates
+* rather than a user running a command. Such a run must print candidates and
+* nothing else: stderr is still a TTY inside a completion function, so an
+* update notice would be drawn onto the prompt line, and the what's-new
+* notice is one-shot — a TAB press would consume it unread.
+*/
+function isCompletionProbe(argv) {
+	return argv.includes(COMPLETION_PROBE_FLAG);
+}
+/**
+* Blank the word the cursor is still on before yargs sees a probe.
+*
+* yargs' completion walk treats *every* token in the probe as a finished
+* command, the word under the cursor included: it scans the args for one that
+* names a command, descends into that command's builder, and answers from
+* there. So a fully typed command name answers with nothing —
+* `skydive conv<TAB>` descends into the `conv` alias of `conversations` and
+* emits an empty list, which leaves an alias that can never be expanded and a
+* `skydive agents<TAB>` that won't even add its trailing space. In bash it is
+* worse than a no-op: `complete -o default` reads the empty list as "no
+* candidates" and offers local *filenames* instead.
+*
+* The three scripts all send the partial word as the last token — that is
+* yargs' wire format, not something we chose — so drop it here and let the
+* shell filter the full candidate list by prefix. That is already what happens
+* for any partial that doesn't happen to name a command (`skydive conve<TAB>`
+* gets all 13 commands back today and bash/zsh/fish narrow them), so this only
+* removes the special case, it doesn't change the contract.
+*
+* Two tokens are left alone:
+* - one starting with `-`, because yargs uses exactly that to decide between
+*   offering options and offering subcommands, and
+* - the command name itself, so a probe never degrades to an empty script name.
+*/
+function normalizeProbeArgv(argv) {
+	const flag = argv.indexOf(COMPLETION_PROBE_FLAG);
+	if (flag === -1 || argv.length - flag < 3) return argv;
+	const last = argv[argv.length - 1] ?? "";
+	if (last === "" || last.startsWith("-")) return argv;
+	return [...argv.slice(0, -1), ""];
+}
+const blockStart = (name) => `###-begin-${name}-completions-###`;
+const blockEnd = (name) => `###-end-${name}-completions-###`;
+/**
+* Emit a completion script that asks the CLI itself for candidates on every
+* TAB, rather than baking today's command tree into the script. bash and zsh
+* are adapted from yargs' own templates
+* (node_modules/yargs/build/lib/completion-templates.js); fish is
+* hand-written, as yargs ships no fish template. Differences from yargs:
+*
+* - The shell is an explicit argument, not inferred from `$SHELL` at generate
+*   time, so `skydive completion zsh` is meaningful from any shell.
+* - The script calls `skydive` off PATH instead of the absolute path of the
+*   generating process, which would go stale on every version bump under a
+*   version manager.
+* - The probe's wire format is pinned. yargs picks it from `SHELL`/`ZSH_NAME`
+*   — plain lines normally, `value:description` when either says "zsh" — so
+*   a bash user whose login shell is zsh would otherwise get descriptions
+*   stuffed into COMPREPLY. bash asks for plain lines; zsh and fish ask for
+*   the descriptive format and render the descriptions.
+*/
+function renderCompletionScript(shell, commandName = "skydive") {
+	if (shell === "zsh") return zshScript(commandName);
+	if (shell === "fish") return fishScript(commandName);
+	return bashScript(commandName);
+}
+function bashScript(name) {
+	const fn = `_${name}_completions`;
+	return `${blockStart(name)}
+#
+# ${name} command completion script, generated by \`${name} completion bash\`.
+# Installed by \`${name} completion install bash\`; edits inside this block
+# are overwritten on the next install.
+#
+${fn}()
+{
+  local cur_word args candidates
+
+  cur_word="\${COMP_WORDS[COMP_CWORD]}"
+  args=("\${COMP_WORDS[@]}")
+
+  candidates=$(SHELL=bash ZSH_NAME= ${name} ${COMPLETION_PROBE_FLAG} "\${args[@]}" 2>/dev/null)
+
+  COMPREPLY=( $(compgen -W "\${candidates}" -- "\${cur_word}") )
+
+  return 0
+}
+complete -o bashdefault -o default -F ${fn} ${name}
+${blockEnd(name)}
+`;
+}
+function zshScript(name) {
+	const fn = `_${name}_completions`;
+	return `${blockStart(name)}
+#
+# ${name} command completion script, generated by \`${name} completion zsh\`.
+# Installed by \`${name} completion install zsh\`; edits inside this block
+# are overwritten on the next install.
+#
+${fn}()
+{
+  local reply
+  local si=$IFS
+  IFS=$'\\n' reply=($(COMP_CWORD="$((CURRENT-1))" COMP_LINE="$BUFFER" COMP_POINT="$CURSOR" SHELL=zsh ${name} ${COMPLETION_PROBE_FLAG} "\${words[@]}" 2>/dev/null))
+  IFS=$si
+  _describe 'values' reply
+}
+# compdef only exists once compinit has run. Sourcing this block from a .zshrc
+# that never calls compinit (or calls it later) would otherwise fail with
+# "command not found: compdef".
+#
+# -i is load-bearing: a bare compinit that finds an insecure directory on fpath
+# stops to ask "Ignore insecure directories and continue?", and where it cannot
+# open the terminal it prints "compinit: initialization aborted" and defines no
+# compdef at all -- so the line below fails and the user gets no completions.
+# An insecure fpath entry is ordinary, not exotic: Homebrew's
+# share/zsh/site-functions is writable by the installing user. -i skips those
+# directories and carries on, which beats prompting from someone's shell
+# startup.
+if ! type compdef >/dev/null 2>&1; then
+  autoload -Uz compinit && compinit -i
+fi
+compdef ${fn} ${name}
+${blockEnd(name)}
+`;
+}
+function fishScript(name) {
+	const fn = `__${name}_completions`;
+	return `${blockStart(name)}
+#
+# ${name} command completion script, generated by \`${name} completion fish\`.
+# Installed by \`${name} completion install fish\`; edits are overwritten on
+# the next install.
+#
+function ${fn}
+    set -l tokens (commandline --current-process --tokenize --cut-at-cursor)
+    set -l current (commandline --current-token --cut-at-cursor)
+
+    for line in (ZSH_NAME=zsh ${name} ${COMPLETION_PROBE_FLAG} $tokens "$current" 2>/dev/null)
+        set -l masked (string replace --all -- '\\:' \\x01 $line)
+        set -l parts (string split --max 1 -- ':' $masked)
+        set -l value (string replace --all -- \\x01 ':' $parts[1])
+
+        # Filter by the partial token ourselves. fish 3.3 and older (Ubuntu
+        # 22.04 LTS ships 3.3.1) skip their own matching for any candidate that
+        # carries a description, so \`${name} ag<TAB>\` there offers every
+        # command instead of the one that matches -- and a description is the
+        # whole reason this script asks for the descriptive wire format. Newer
+        # fish filters, so this is a no-op on it. Compared by length rather
+        # than \`string match\` so a token holding a glob character stays
+        # literal. Prefix matching is also what bash's \`compgen -W\` and zsh's
+        # \`_describe\` do, so the three shells now agree.
+        if test (string sub --length (string length -- "$current") -- "$value") != "$current"
+            continue
+        end
+
+        if set -q parts[2]
+            printf '%s\\t%s\\n' $value (string replace --all -- \\x01 ':' $parts[2])
+        else
+            printf '%s\\n' $value
+        end
+    end
+end
+
+# -f: only our candidates, no filename fallback. -k: keep the CLI's own order
+# instead of fish's alphabetical sort.
+complete -c ${name} -f -k -a '(${fn})'
+${blockEnd(name)}
+`;
+}
+const defaultInstallEnv = () => ({
+	home: os.homedir(),
+	platform: process.platform,
+	env: process.env,
+	exists: fs.existsSync
+});
+/**
+* The shell to install for when the user didn't name one. `$SHELL` is the
+* only signal available: a completion install runs as a child process, so the
+* invoking shell's own variables (`$ZSH_VERSION`, `$FISH_VERSION`) aren't
+* visible here.
+*/
+function detectShell(env = process.env) {
+	const shell = env["SHELL"];
+	if (!shell) return null;
+	const name = path.basename(shell);
+	return SUPPORTED_SHELLS.find((candidate) => name === candidate) ?? null;
+}
+function completionTarget(shell, deps = defaultInstallEnv()) {
+	const { home, platform, env, exists } = deps;
+	if (shell === "fish") {
+		const configHome = env["XDG_CONFIG_HOME"] || path.join(home, ".config");
+		return {
+			path: path.join(configHome, "fish", "completions", "skydive.fish"),
+			mode: "file"
+		};
+	}
+	if (shell === "zsh") {
+		const zdotdir = env["ZDOTDIR"] || home;
+		return {
+			path: path.join(zdotdir, ".zshrc"),
+			mode: "block"
+		};
+	}
+	const rc = path.join(home, ".bashrc");
+	const profile = path.join(home, ".bash_profile");
+	const preferred = platform === "darwin" ? profile : rc;
+	const alternate = platform === "darwin" ? rc : profile;
+	if (!exists(preferred) && exists(alternate)) return {
+		path: alternate,
+		mode: "block"
+	};
+	return {
+		path: preferred,
+		mode: "block"
+	};
+}
+/**
+* The startup file's contents with our block added or refreshed. Idempotent:
+* a second install rewrites the block in place rather than appending a
+* duplicate, which is also how an upgraded CLI ships a newer script.
+*/
+function spliceCompletionBlock(existing, script, commandName = "skydive") {
+	const start = existing.indexOf(blockStart(commandName));
+	const endMarker = blockEnd(commandName);
+	const end = existing.indexOf(endMarker);
+	if (start !== -1 && end > start) {
+		const before = existing.slice(0, start);
+		const after = existing.slice(end + endMarker.length).replace(/^\n/, "");
+		return `${before}${script.trimEnd()}\n${after}`;
+	}
+	return `${existing}${existing === "" || existing.endsWith("\n\n") ? "" : "\n"}\n${script}`;
+}
+function installCompletionScript(shell, deps = defaultInstallEnv()) {
+	const target = completionTarget(shell, deps);
+	const script = renderCompletionScript(shell);
+	const existing = deps.exists(target.path) ? fs.readFileSync(target.path, "utf8") : "";
+	const contents = target.mode === "file" ? script : spliceCompletionBlock(existing, script);
+	fs.mkdirSync(path.dirname(target.path), { recursive: true });
+	fs.writeFileSync(target.path, contents, "utf8");
+	return {
+		shell,
+		path: target.path,
+		updated: existing.includes(blockStart("skydive"))
+	};
+}
+/** What the user has to do before completions work in the shell they're in. */
+function activationHint(result) {
+	return result.shell === "fish" ? "Open a new fish shell to pick them up (fish autoloads completions)." : `Open a new shell, or run: source ${result.path}`;
+}
+const installCommand$1 = {
+	command: "install [shell]",
+	describe: "Install completions into your shell's startup file",
+	builder: (y) => y.positional("shell", {
+		type: "string",
+		describe: "Shell to install for (default: $SHELL)"
+	}).example("skydive completion install", "Install for the current shell").example("skydive completion install fish", "Install for a named shell"),
+	handler: async (argv) => {
+		const shell = argv.shell ? SUPPORTED_SHELLS.find((candidate) => candidate === argv.shell) : detectShell();
+		if (!shell) throw new Error(argv.shell ? `No completions for ${argv.shell}. Supported: ${SUPPORTED_SHELLS.join(", ")}.` : `Could not tell which shell to install for from $SHELL. Name one: ${SUPPORTED_SHELLS.join(", ")}.`);
+		let result;
+		try {
+			result = installCompletionScript(shell);
+		} catch (error) {
+			throw new Error(`Could not write ${shell} completions: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+		}
+		if (argv.json) {
+			output(argv, result);
+			return;
+		}
+		console.log(`${result.updated ? "Updated" : "Installed"} ${result.shell} completions in ${result.path}`);
+		if (!argv.quiet) console.log(activationHint(result));
+	}
+};
+const completionCommand = {
+	command: "completion [shell]",
+	describe: "Print the shell completion script for bash, zsh, or fish",
+	builder: (y) => y.positional("shell", {
+		type: "string",
+		choices: SUPPORTED_SHELLS,
+		describe: "Shell to generate completions for"
+	}).command(installCommand$1).example("skydive completion install", "Set up completions for your shell").example("eval \"$(skydive completion zsh)\"", "Enable completions for this shell only"),
+	handler: async (argv) => {
+		if (!argv.shell) throw new Error(`Specify a shell (${SUPPORTED_SHELLS.join(", ")}), or run \`skydive completion install\` to set up $SHELL.`);
+		process.stdout.write(renderCompletionScript(argv.shell));
+	}
+};
+
 //#endregion
 //#region src/commands/session.ts
 /**
@@ -1200,7 +1500,7 @@ const importCommand = {
 				process.exit(1);
 			}
 		}
-		const { runChat } = await import("./boot-CGaXUEer.mjs");
+		const { runChat } = await import("./boot-HAgDg_b4.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -1209,6 +1509,7 @@ const importCommand = {
 			notifications: true,
 			agentSelector: argv.agent ?? null,
 			conversationId: null,
+			newConversation: false,
 			seedPrompt: buildImportSeedPrompt(process.cwd())
 		});
 	}
@@ -1226,7 +1527,7 @@ async function runImportPrintMode({ argv, appUrl }) {
 		printError(`${session.error.message} For non-interactive use, run \`skydive auth login --web\` first, or set SKYDIVE_SESSION_TOKEN.`);
 		process.exit(1);
 	}
-	const { connectMachineShare } = await import("./print-share-D7OSxvE2.mjs");
+	const { connectMachineShare } = await import("./print-share-7qfpQtWK.mjs");
 	const machineShare = await connectMachineShare({
 		appUrl,
 		sessionToken: session.value.sessionToken,
@@ -1234,7 +1535,7 @@ async function runImportPrintMode({ argv, appUrl }) {
 	});
 	const extra = (argv.print ?? "").trim();
 	const prompt = buildImportSeedPrompt(process.cwd()) + (extra ? `\n\nAdditional instructions: ${extra}` : "");
-	const { runPrint } = await import("./print-BZH0b3KB.mjs");
+	const { runPrint } = await import("./print-CPCFci60.mjs");
 	try {
 		const result = await runPrint({
 			appUrl,
@@ -1449,6 +1750,97 @@ const secretsCommand = {
 	handler: () => {}
 };
 
+//#endregion
+//#region src/auth/agent-workspace.ts
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/**
+* Cap on concurrent per-workspace probes. An account can be in a lot of
+* workspaces; firing one request per workspace all at once is a burst the
+* API (and the user's uplink) doesn't need. Four keeps the common case
+* (a handful of workspaces) effectively parallel while bounding the worst.
+*/
+const PROBE_CONCURRENCY = 4;
+/**
+* `Promise.all` with at most `limit` tasks in flight — a dependency-free
+* stand-in for p-queue sized to this one call site. Results keep input
+* order.
+*/
+async function mapWithConcurrency(items, limit, fn) {
+	const results = [];
+	const queue = items.entries();
+	const workers = Array.from({ length: Math.min(limit, items.length) }, async () => {
+		for (const [index, item] of queue) results[index] = await fn(item);
+	});
+	await Promise.all(workers);
+	return results;
+}
+/**
+* Whether the agent is visible in one workspace, via the typed rest client
+* scoped with `x-workspace-id` (a per-request override — the session's
+* persisted active workspace is untouched, so probing is side-effect free).
+* A miss (404 unknown/hidden, 403 other org) or a network failure is simply
+* "not here" — if the API is truly unreachable the main request path fails
+* right after with its own (better) error.
+*/
+async function probeAgent({ appUrl, sessionToken, agentId, workspaceId }) {
+	const client = createRestClient({
+		appUrl,
+		sessionToken,
+		...workspaceId ? { workspaceId } : {}
+	});
+	try {
+		return { name: (await client.getAgent({ agentId })).name };
+	} catch (error) {
+		if (error instanceof HttpError) return null;
+		return null;
+	}
+}
+async function resolveAgentWorkspace({ appUrl, sessionToken, agentSelector }) {
+	if (!agentSelector || !uuidPattern.test(agentSelector)) return { kind: "active" };
+	if (await probeAgent({
+		appUrl,
+		sessionToken,
+		agentId: agentSelector,
+		workspaceId: null
+	})) return { kind: "active" };
+	const [workspaces, activeId] = await Promise.all([listWorkspaces({
+		appUrl,
+		sessionToken
+	}), getActiveWorkspaceId({
+		appUrl,
+		sessionToken
+	})]);
+	if (workspaces.isErr()) return {
+		kind: "list-failed",
+		message: workspaces.error.message
+	};
+	const found = (await mapWithConcurrency(workspaces.value.filter((w) => activeId.isErr() || w.id !== activeId.value), PROBE_CONCURRENCY, async (workspace) => ({
+		workspace,
+		hit: await probeAgent({
+			appUrl,
+			sessionToken,
+			agentId: agentSelector,
+			workspaceId: workspace.id
+		})
+	}))).find((p) => p.hit !== null);
+	if (!found?.hit) return { kind: "not-found" };
+	const switched = await setActiveWorkspace({
+		appUrl,
+		sessionToken,
+		organizationId: found.workspace.id
+	});
+	if (switched.isErr()) return {
+		kind: "switch-failed",
+		workspace: found.workspace,
+		message: switched.error.message
+	};
+	return {
+		kind: "switched",
+		workspace: found.workspace,
+		agentName: found.hit.name
+	};
+}
+
 //#endregion
 //#region src/commands/chat.ts
 const chatCommand = {
@@ -1465,6 +1857,10 @@ const chatCommand = {
 		alias: "resume",
 		type: "string",
 		describe: "Continue an existing conversation by id. With -p, the one-shot lands in that conversation; without -p, the TUI opens directly into it (the agent is resolved from the conversation, no --agent needed)."
+	}).option("new", {
+		type: "boolean",
+		default: false,
+		describe: "Start a fresh conversation instead of opening the conversation list. With --agent, opens a new conversation with that agent directly. Without --agent, opens a new conversation once you pick an agent (auto-picked if the account has only one). Ignored with --resume, which always continues the named conversation."
 	}).option("share-machine", {
 		type: "boolean",
 		describe: "Share this machine with the agent over the portal so it can run commands here (default-deny; in the TUI you approve per agent, with -p the flag grants the target agent for the run). Defaults to `shareMachineDefault` in the CLI config file; --no-share-machine disables for this invocation."
@@ -1475,7 +1871,7 @@ const chatCommand = {
 		type: "boolean",
 		default: true,
 		describe: "Show a desktop notification when a run finishes or needs your input while this terminal is unfocused (use --no-notify to disable)"
-	}).example("skydive chat -p \"summarize my open PRs\" --agent grace", "One-shot, non-interactive").example("echo \"what changed today?\" | skydive chat -p --agent grace", "Read the prompt from stdin").example("skydive chat --agent grace", "Open Grace's conversation list in the TUI (skips the agent picker)").example("skydive chat --resume 0197e0f3-…", "Reopen a previous conversation in the TUI (the id is printed when you quit a chat)"),
+	}).example("skydive chat -p \"summarize my open PRs\" --agent grace", "One-shot, non-interactive").example("echo \"what changed today?\" | skydive chat -p --agent grace", "Read the prompt from stdin").example("skydive chat --agent grace", "Open Grace's conversation list in the TUI (skips the agent picker)").example("skydive chat --agent grace --new", "Start a fresh conversation with Grace directly (skips the conversation list)").example("skydive chat --resume 0197e0f3-…", "Reopen a previous conversation in the TUI (the id is printed when you quit a chat)"),
 	handler: async (argv) => {
 		const appUrl = resolveAppUrl({ appUrl: argv["api-url"] });
 		if (argv.print !== void 0) {
@@ -1511,7 +1907,12 @@ const chatCommand = {
 			printError(`Unknown theme "${themeId}". Valid themes: ${themes.map((t) => t.id).join(", ")}`);
 			process.exit(1);
 		}
-		const { runChat } = await import("./boot-CGaXUEer.mjs");
+		await ensureAgentWorkspace({
+			appUrl,
+			sessionToken: session.value.sessionToken,
+			agentSelector: argv.agent ?? null
+		});
+		const { runChat } = await import("./boot-HAgDg_b4.mjs");
 		await runChat({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -1521,6 +1922,7 @@ const chatCommand = {
 			notifications: argv.notify,
 			agentSelector: argv.agent ?? null,
 			conversationId: argv.conversation ?? null,
+			newConversation: resolveNewConversation(argv),
 			seedPrompt: null
 		});
 	}
@@ -1533,13 +1935,55 @@ const chatCommand = {
 function resolveShareMachine(argv) {
 	return argv["share-machine"] ?? getShareMachineDefault();
 }
+/**
+* Whether this invocation should boot straight into a fresh conversation:
+* `--new` requests it, but `--resume <id>` always wins (it pins an existing
+* conversation, so "new" is meaningless alongside it).
+*/
+function resolveNewConversation(argv) {
+	return argv.new === true && !argv.conversation;
+}
+/**
+* Cross-workspace `--agent <uuid>` handling shared by the TUI and -p paths:
+* on a hit in another workspace, switch to it and say so on stderr (stdout
+* may carry the -p reply/JSON envelope); when the id matches no workspace on
+* the account, fail with the two realistic fixes instead of the misleading
+* "no agent matches" roster error.
+*/
+async function ensureAgentWorkspace({ appUrl, sessionToken, agentSelector }) {
+	const resolution = await resolveAgentWorkspace({
+		appUrl,
+		sessionToken,
+		agentSelector
+	});
+	if (resolution.kind === "active") return;
+	if (resolution.kind === "switched") {
+		console.error(`Switched workspace to ${resolution.workspace.name} (${resolution.workspace.slug}) — ${resolution.agentName} lives there.`);
+		return;
+	}
+	if (resolution.kind === "list-failed") {
+		printError(`No agent with id ${agentSelector} in the current workspace, and listing your other workspaces failed (${resolution.message}), so it couldn't be searched for elsewhere. Retry, or run \`skydive workspace switch <slug>\` if you know where it lives.`);
+		process.exit(1);
+	}
+	if (resolution.kind === "switch-failed") {
+		printError(`Agent found in workspace ${resolution.workspace.name}, but switching to it failed: ${resolution.message}. Run \`skydive workspace switch ${resolution.workspace.slug}\` and retry.`);
+		process.exit(1);
+	}
+	printError(`No agent with id ${agentSelector} in any workspace on this account. It may belong to a different account — run \`skydive auth login\` with the right one — or the agent may have been archived.`);
+	process.exit(1);
+}
 async function runPrintMode({ argv, appUrl }) {
 	const session = resolveSession({ appUrl });
 	if (session.isErr()) {
 		printError(`${session.error.message} For non-interactive use, run \`skydive auth login\` first, or set SKYDIVE_SESSION_TOKEN.`);
 		process.exit(1);
 	}
-	const { runPrint, readStdin } = await import("./print-BZH0b3KB.mjs");
+	const { runPrint, readStdin } = await import("./print-CPCFci60.mjs");
+	await ensureAgentWorkspace({
+		appUrl,
+		sessionToken: session.value.sessionToken,
+		agentSelector: argv.agent ?? null
+	});
 	let prompt = (argv.print ?? "").trim();
 	if (!prompt) {
 		if (process.stdin.isTTY) {
@@ -1554,7 +1998,7 @@ async function runPrintMode({ argv, appUrl }) {
 	}
 	let machineShare = null;
 	if (resolveShareMachine(argv)) {
-		const { connectMachineShare } = await import("./print-share-D7OSxvE2.mjs");
+		const { connectMachineShare } = await import("./print-share-7qfpQtWK.mjs");
 		machineShare = await connectMachineShare({
 			appUrl,
 			sessionToken: session.value.sessionToken,
@@ -1613,7 +2057,7 @@ const getCommand = {
 			printError(`${session.error.message} Run \`skydive auth login\` first, or set SKYDIVE_SESSION_TOKEN.`);
 			process.exit(1);
 		}
-		const { messageGet } = await import("./print-BZH0b3KB.mjs");
+		const { messageGet } = await import("./print-CPCFci60.mjs");
 		try {
 			const result = await messageGet({
 				appUrl,
@@ -1810,7 +2254,7 @@ const switchCommand = {
 				printError("The workspace picker needs the Bun runtime and it could not be set up automatically. Pass a workspace slug instead, or install Bun and retry.");
 				process.exit(1);
 			}
-			const { runWorkspacePicker } = await import("./boot-CGaXUEer.mjs");
+			const { runWorkspacePicker } = await import("./boot-HAgDg_b4.mjs");
 			await runWorkspacePicker(session);
 			return;
 		}
@@ -1888,7 +2332,7 @@ const openCommand = {
 		const agent = argv.agent ? resolveAgent((await fetchPortalDevices(session)).agents, argv.agent) : null;
 		const cwd = argv.cwd ? path.resolve(argv.cwd) : process.cwd();
 		const { machineName } = machineIdentity();
-		const { PortalClient } = await import("./client-D6NAkL9e.mjs");
+		const { PortalClient } = await import("./client-DuwxEDG4.mjs");
 		let lastLine = "";
 		let signalConnected;
 		const connected = new Promise((resolve) => {
@@ -1897,7 +2341,7 @@ const openCommand = {
 		const client = new PortalClient({
 			appUrl: session.appUrl,
 			sessionToken: session.sessionToken,
-			cwd,
+			resolveCwd: () => cwd,
 			onState: (state) => {
 				if (state.status === "connected") signalConnected();
 				const line = state.status === "error" ? `portal: connection error: ${state.error ?? "unknown"} — retrying` : `portal: ${state.status}`;
@@ -2012,10 +2456,111 @@ function buildDeviceTable(devices, agents, thisMachineName) {
 		])
 	};
 }
+/**
+* `skydive portal daemon <cmd>` — operator control of the per-host portal daemon
+* (the process that owns the single portal connection and routes exec per
+* conversation). Distinct from the agent-facing `platform portal`: this manages
+* the local daemon a human runs, so it lives on the skydive CLI only.
+*/
+const daemonStatusCommand = {
+	command: "status",
+	describe: "Show the portal daemon: running state, connection, and routing map",
+	handler: async (argv) => {
+		const status = await queryDaemonStatus(requireSession(argv).appUrl);
+		if (argv.json) {
+			output(argv, status ?? { running: false });
+			return;
+		}
+		if (!status) {
+			console.log("portal daemon: not running");
+			return;
+		}
+		const cwdCount = Object.keys(status.cwds).length;
+		console.log(`portal daemon: running (pid ${status.pid})`);
+		console.log(`  app:        ${status.appUrl}`);
+		console.log(`  connection: ${status.portal.status}${status.portal.error ? ` (${status.portal.error})` : ""}`);
+		if (status.portal.machineName) console.log(`  machine:    ${status.portal.friendlyName}`);
+		console.log(`  attached:   ${status.clientCount} CLI session(s)`);
+		console.log(`  granted:    ${status.portal.grantedAgentIds.length} agent(s)`);
+		console.log(`  routing:    ${cwdCount} conversation(s)`);
+	}
+};
+const daemonStopCommand = {
+	command: "stop",
+	describe: "Stop the portal daemon, cutting every attached session and live exec/tunnel",
+	handler: async (argv) => {
+		const result = await stopDaemon(requireSession(argv).appUrl);
+		if (argv.json) {
+			output(argv, { result });
+			return;
+		}
+		console.log(result === "not-running" ? "portal daemon: not running" : result === "failed" ? "portal daemon: could not be stopped" : `portal daemon: stopped${result === "killed" ? " (force-killed)" : ""}`);
+	}
+};
+const daemonStartCommand = {
+	command: "start",
+	describe: "Start the portal daemon if it is not already running",
+	handler: async (argv) => {
+		const session = requireSession(argv);
+		await ensureDaemonRunning(session.appUrl);
+		const status = await queryDaemonStatus(session.appUrl);
+		if (argv.json) {
+			output(argv, {
+				running: !!status,
+				pid: status?.pid ?? null
+			});
+			return;
+		}
+		console.log(status ? `portal daemon: running (pid ${status.pid})` : "portal daemon: failed to start");
+	}
+};
+const daemonRestartCommand = {
+	command: "restart",
+	describe: "Stop and restart the portal daemon (e.g. to pick up a new build)",
+	handler: async (argv) => {
+		const session = requireSession(argv);
+		await stopDaemon(session.appUrl);
+		await ensureDaemonRunning(session.appUrl);
+		const status = await queryDaemonStatus(session.appUrl);
+		if (argv.json) {
+			output(argv, {
+				running: !!status,
+				pid: status?.pid ?? null
+			});
+			return;
+		}
+		console.log(status ? `portal daemon: restarted (pid ${status.pid})` : "portal daemon: failed to restart");
+	}
+};
+const daemonLogsCommand = {
+	command: "logs",
+	describe: "Print the portal daemon's log",
+	builder: (y) => y.option("follow", {
+		alias: "f",
+		type: "boolean",
+		default: false,
+		describe: "Follow the log (like tail -f)"
+	}),
+	handler: async (argv) => {
+		const { logPath } = daemonPaths(requireSession(argv).appUrl);
+		const child = spawn("tail", argv.follow === true ? ["-f", logPath] : [
+			"-n",
+			"200",
+			logPath
+		], { stdio: "inherit" });
+		await new Promise((resolve) => child.on("close", () => resolve()));
+	}
+};
+const daemonCommand = {
+	command: "daemon",
+	describe: "Control the local portal daemon (status, stop, start, restart, logs)",
+	builder: (y) => y.command(daemonStatusCommand).command(daemonStopCommand).command(daemonStartCommand).command(daemonRestartCommand).command(daemonLogsCommand).demandCommand(1, "Specify a subcommand: status, stop, start, restart, logs"),
+	handler: () => {}
+};
 const portalCommand = {
 	command: "portal",
 	describe: "Open this machine's portal to agents and manage their access",
-	builder: (y) => y.command(openCommand).command(grantCommand).command(revokeCommand).command(statusCommand).demandCommand(1, "Specify a subcommand: open, grant, revoke, status"),
+	builder: (y) => y.command(openCommand).command(grantCommand).command(revokeCommand).command(statusCommand).command(daemonCommand).demandCommand(1, "Specify a subcommand: open, grant, revoke, status, daemon"),
 	handler: () => {}
 };
 
@@ -2060,8 +2605,8 @@ const sandboxCommand = {
 	}).example("skydive sandbox --agent grace", "Live terminal (Ctrl-] detaches)").example("skydive sandbox --agent grace -- tail -n 50 /tmp/harness.log", "One-shot command (use `--` so its flags reach the sandbox)").example("skydive sandbox --agent grace -- sh -c 'ls /tmp | wc -l'", "Shell features go through an explicit `sh -c`"),
 	handler: async (argv) => {
 		const session = requireSession(argv);
-		const { createRestClient } = await import("./rest-COkLEZOB.mjs");
-		const { resolveAgent } = await import("./print-BZH0b3KB.mjs");
+		const { createRestClient } = await import("./rest-CDTXCmUb.mjs");
+		const { resolveAgent } = await import("./print-CPCFci60.mjs");
 		const client = createRestClient({
 			appUrl: session.appUrl,
 			sessionToken: session.sessionToken
@@ -2130,7 +2675,7 @@ async function runPty({ session, agentId, agentName }) {
 		return 1;
 	}
 	console.error(`Connecting to ${agentName}'s sandbox… (Ctrl-] detaches)`);
-	const { runRawPtyPassthrough } = await import("./raw-pty-2_VA1kw_.mjs");
+	const { runRawPtyPassthrough } = await import("./raw-pty-ChUHav4d.mjs");
 	const result = await runRawPtyPassthrough({
 		stdin: process.stdin,
 		stdout: process.stdout,
@@ -2142,10 +2687,679 @@ async function runPty({ session, agentId, agentName }) {
 	return result.code;
 }
 
+//#endregion
+//#region src/update-check/manifest.ts
+/**
+* The release manifest the binary pipeline publishes
+* (`.github/workflows/release-skydive-cli-binaries.yml`) and the api serves
+* (`apps/anyone/api/src/routes/cli-releases.ts`). The update *check* only
+* needs `version` (see ./sources.ts), but the self-updater
+* (`../commands/update.ts`) needs the per-target byte pointer + integrity
+* digest too, so the full shape lives here and both consume it.
+*
+* Kept deliberately in sync with the api's `manifestSchema`: a field the api
+* validates but we drop here is fine, but a field we *require* that the api
+* doesn't emit would make every install fail — so required fields mirror the
+* api exactly (name, version, channel, per-target key/sha256/size).
+*/
+const releaseManifestSchema = z.object({
+	name: z.string().min(1),
+	version: z.string().min(1),
+	channel: z.string().min(1),
+	pubDate: z.string().optional(),
+	targets: z.record(z.object({
+		key: z.string().min(1),
+		sha256: z.string().regex(/^[0-9a-f]{64}$/),
+		size: z.number().int().positive()
+	}))
+});
+/**
+* The four release targets the pipeline builds. Named `<os>-<arch>` to match
+* the manifest's `targets` keys and the install script's `$OS-$ARCH`.
+*/
+const RELEASE_TARGETS = [
+	"darwin-arm64",
+	"darwin-x64",
+	"linux-arm64",
+	"linux-x64"
+];
+function isReleaseTarget(value) {
+	return RELEASE_TARGETS.some((target) => target === value);
+}
+/**
+* Map this host's `process.platform` / `process.arch` to a release target,
+* or null when we don't publish a binary for it. Mirrors the install
+* script's `uname -s` / `uname -m` normalization (arm64/aarch64 -> arm64,
+* x86_64/amd64 -> x64) so a CLI self-update resolves the same object a fresh
+* `curl | sh` install would.
+*/
+function hostReleaseTarget(platform, arch) {
+	const os = platform === "darwin" ? "darwin" : platform === "linux" ? "linux" : null;
+	if (!os) return null;
+	const cpu = arch === "arm64" || arch === "aarch64" ? "arm64" : arch === "x64" || arch === "x86_64" || arch === "amd64" ? "x64" : null;
+	if (!cpu) return null;
+	const target = `${os}-${cpu}`;
+	return isReleaseTarget(target) ? target : null;
+}
+function lookupTarget(manifest, platform, arch) {
+	const target = hostReleaseTarget(platform, arch);
+	if (!target) return {
+		ok: false,
+		reason: "unsupported-host",
+		target: null
+	};
+	const entry = manifest.targets[target];
+	if (!entry) return {
+		ok: false,
+		reason: "missing-from-manifest",
+		target
+	};
+	return {
+		ok: true,
+		target,
+		entry
+	};
+}
+
+//#endregion
+//#region src/update-check/versions.ts
+/** Canary builds carry a prerelease suffix (`X.Y.Z-beta.N`, synthesized in
+* CI); a plain semver is a stable release. An unparseable version defaults
+* to stable. */
+function resolveChannel(version) {
+	return (semver.prerelease(version, { loose: true })?.length ?? 0) > 0 ? "canary" : "stable";
+}
+/** npm dist-tag for a channel (see release-skydive-cli.yml). */
+function distTagForChannel(channel) {
+	return channel === "canary" ? "beta" : "latest";
+}
+/**
+* True when `candidate` is a strictly newer release than `current`, per
+* semver precedence (the `semver` package, including prerelease ordering).
+* Unparseable input is never newer, so garbage from the registry can't
+* produce a notice.
+*/
+function isNewerVersion(candidate, current) {
+	if (!semver.valid(candidate, { loose: true })) return false;
+	if (!semver.valid(current, { loose: true })) return false;
+	return semver.gt(candidate, current, { loose: true });
+}
+
+//#endregion
+//#region src/update-check/install.ts
+/**
+* The self-updater for compiled-binary installs. The update *check*
+* (./index.ts) is notify-only; this is what a user-invoked `skydive update`
+* (../commands/update.ts) runs to actually replace the binary.
+*
+* package-manager installs are never self-mutated here — that's the install
+* mode's own tool's job, and silently reaching into a global npm/yarn/pnpm
+* prefix is exactly the footgun the existing notice policy avoids. They still
+* go through the same {@link planUpdate} version comparison (an install that
+* skips it has no way to know it is already current); only the *action*
+* differs — the command prints, or offers to run, the upgrade command.
+*
+* The dangerous part is replacing a running executable in place, so the flow
+* is split: a pure {@link planUpdate} decides *whether* and *what* (testable
+* with no IO), and {@link downloadAndVerify} / {@link applyBinary} do the IO
+* with integrity checks and an atomic rename.
+*/
+/** Cap so a wrong URL or a hung CDN can't wedge `skydive update` forever. */
+const DOWNLOAD_TIMEOUT_MS = 6e4;
+/**
+* The single version comparison every install mode goes through: only a
+* strictly newer release is an update. `allowSameVersion` (`--force`) and
+* `allowDowngrade` (rollback) are the two explicit escape hatches.
+*/
+function wantsInstall(opts) {
+	const newer = isNewerVersion(opts.latestVersion, opts.currentVersion);
+	const same = opts.latestVersion === opts.currentVersion;
+	return newer || same && opts.allowSameVersion === true || !newer && !same && opts.allowDowngrade === true;
+}
+/**
+* Decide what `skydive update` should do, given the running version, the
+* install source, the channel's newest release, and this host. Pure — no
+* network, no filesystem — so every branch is unit-testable.
+*
+* `latestVersion` is the channel's current version for a **package-manager**
+* install (an npm dist-tag lookup). A binary install reads it off `manifest`
+* instead, because there the manifest is both the version pointer and the
+* byte source. Either way it must be a real fetched answer: a package-manager
+* install that skips the comparison is what made `skydive update` announce
+* "0.2.0 → 0.2.0" on every invocation.
+*
+* `allowSameVersion` forces a reinstall of the current version (the `--force`
+* escape hatch for a corrupt binary); `allowDowngrade` lets an explicit
+* pinned/older manifest install over a newer running binary (rollback).
+*/
+function planUpdate(opts) {
+	const { currentVersion, source, manifest, platform, arch } = opts;
+	if (source !== "binary") {
+		const { latestVersion } = opts;
+		if (!latestVersion || !wantsInstall({
+			...opts,
+			latestVersion
+		})) return {
+			kind: "up-to-date",
+			currentVersion
+		};
+		return {
+			kind: "unsupported-source",
+			source,
+			latestVersion
+		};
+	}
+	if (!manifest) return {
+		kind: "up-to-date",
+		currentVersion
+	};
+	if (!wantsInstall({
+		...opts,
+		latestVersion: manifest.version
+	})) return {
+		kind: "up-to-date",
+		currentVersion
+	};
+	const lookup = lookupTarget(manifest, platform, arch);
+	if (!lookup.ok) return lookup.reason === "unsupported-host" ? {
+		kind: "unsupported-host",
+		platform,
+		arch
+	} : {
+		kind: "missing-from-manifest",
+		target: lookup.target,
+		version: manifest.version
+	};
+	return {
+		kind: "update",
+		target: lookup.target,
+		version: manifest.version,
+		key: lookup.entry.key,
+		sha256: lookup.entry.sha256,
+		size: lookup.entry.size
+	};
+}
+var UpdateError = class extends Error {};
+/** Read a Node errno string (`EACCES`, `EROFS`, ...) off an unknown thrown
+* value without a type assertion — the property is validated before it's read. */
+function errnoCode(error) {
+	if (error && typeof error === "object" && "code" in error) {
+		const { code } = error;
+		if (typeof code === "string") return code;
+	}
+}
+/** Lowercase hex sha256 of a buffer, for comparing against the manifest. */
+function sha256Hex(bytes) {
+	return createHash("sha256").update(bytes).digest("hex");
+}
+/**
+* Download the release object and verify its digest before it ever touches
+* the install path. Returns the raw bytes; the caller writes them atomically.
+* Throws {@link UpdateError} (with an actionable message) on any HTTP,
+* timeout, or integrity failure — never a bare fetch error.
+*/
+async function downloadAndVerify(opts) {
+	const url = `${opts.downloadBaseUrl}/${opts.key}`;
+	const doFetch = opts.fetchImpl ?? fetch;
+	const signal = opts.signal ?? AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS);
+	let response;
+	try {
+		response = await doFetch(url, {
+			signal,
+			redirect: "follow"
+		});
+	} catch (error) {
+		throw new UpdateError(`download failed from ${url}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	if (!response.ok) throw new UpdateError(`download failed from ${url}: HTTP ${response.status}`);
+	const bytes = new Uint8Array(await response.arrayBuffer());
+	if (bytes.byteLength === 0) throw new UpdateError(`download from ${url} was empty`);
+	const actual = sha256Hex(bytes);
+	if (actual !== opts.expectedSha256) throw new UpdateError(`sha256 mismatch (expected ${opts.expectedSha256}, got ${actual}) — the download may be corrupt; re-run \`skydive update\``);
+	return bytes;
+}
+/**
+* Atomically replace the executable at `destPath` with `bytes`. The temp file
+* is written in the *same directory* as the target so the final `rename` is
+* atomic (rename across filesystems is not) — a crash mid-update leaves either
+* the old binary or the new one, never a truncated file.
+*
+* On a locked destination (Windows, or a read-only install dir) the rename
+* fails; we surface an actionable UpdateError instead of a raw errno. macOS
+* and Linux happily rename over a running executable (the old inode stays
+* live for the current process), which is what makes in-place self-update
+* safe here.
+*/
+async function applyBinary(destPath, bytes) {
+	const dir = path.dirname(destPath);
+	const tmp = path.join(dir, `.skydive-update-${process.pid}-${Date.now()}.tmp`);
+	try {
+		await fsp.writeFile(tmp, bytes, { mode: 493 });
+		await fsp.chmod(tmp, 493);
+		await fsp.rename(tmp, destPath);
+	} catch (error) {
+		await fsp.rm(tmp, { force: true }).catch(() => {});
+		const code = errnoCode(error);
+		if (code === "EACCES" || code === "EPERM" || code === "EROFS") throw new UpdateError(`cannot write ${destPath} (permission denied). Re-run with the right permissions, or reinstall with the install script.`);
+		throw new UpdateError(`failed to install the new binary at ${destPath}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+/**
+* Resolve the path of the currently running executable to overwrite. For a
+* `bun --compile` binary that's `process.execPath`; we resolve symlinks so a
+* `~/.local/bin/skydive` symlink into a versioned store updates the real
+* file, not the link. Returns null when the path can't be determined (e.g. a
+* non-binary context), which the command treats as "can't self-update".
+*/
+function resolveSelfPath(execPath = process.execPath) {
+	if (!execPath) return null;
+	try {
+		return fs.realpathSync(execPath);
+	} catch (_error) {
+		return execPath;
+	}
+}
+
+//#endregion
+//#region src/update-check/sources.ts
+function resolveInstallSource() {
+	return typeof SKYDIVE_CLI_INSTALL_SOURCE === "string" && SKYDIVE_CLI_INSTALL_SOURCE === "binary" ? "binary" : "package-manager";
+}
+const NPM_REGISTRY_URL = "https://registry.npmjs.org";
+const npmDistTagsSchema = z.record(z.string(), z.unknown());
+const binaryManifestSchema = z.object({ version: z.unknown().optional() });
+/** npm dist-tags for the published package (`skydive-cli`). */
+const npmReleaseSource = {
+	async fetchLatestVersion(channel, { signal }) {
+		const response = await fetch(`${NPM_REGISTRY_URL}/-/package/${name}/dist-tags`, {
+			signal,
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const tags = npmDistTagsSchema.safeParse(await response.json());
+		if (!tags.success) return null;
+		const version = tags.data[distTagForChannel(channel)];
+		return typeof version === "string" ? version : null;
+	},
+	async fetchManifest() {
+		return null;
+	}
+};
+/**
+* Release CDN (CloudFront over the releases bucket, infra: CliReleasesCdn).
+* Serves the channel pointers the release workflow uploads
+* (`channels/{stable,canary}.json`, cached max-age=60) alongside the
+* binaries. The daily poll goes here, not to the api, so a fleet of
+* installed binaries puts no load on — and takes no dependency on — the api.
+*/
+const RELEASE_CDN_URL = "https://dl.skydive.com";
+/** Channel manifest on the release CDN, for compiled binaries. The same
+* document the api's channel route serves (see
+* apps/anyone/api/src/routes/cli-releases.ts, which reads it from the
+* bucket this CDN fronts). */
+const binaryReleaseSource = {
+	async fetchLatestVersion(channel, { signal }) {
+		const response = await fetch(`${RELEASE_CDN_URL}/channels/${channel}.json`, {
+			signal,
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const manifest = binaryManifestSchema.safeParse(await response.json());
+		if (!manifest.success) return null;
+		return typeof manifest.data.version === "string" ? manifest.data.version : null;
+	},
+	async fetchManifest(channel, { signal }) {
+		const response = await fetch(`${RELEASE_CDN_URL}/channels/${channel}.json`, {
+			signal,
+			headers: { accept: "application/json" }
+		});
+		if (!response.ok) return null;
+		const manifest = releaseManifestSchema.safeParse(await response.json());
+		return manifest.success ? manifest.data : null;
+	}
+};
+function releaseSourceForInstall(source) {
+	return source === "binary" ? binaryReleaseSource : npmReleaseSource;
+}
+
+//#endregion
+//#region src/update-check/notice.ts
+/** The install-mode-specific action line. A package-manager install is never
+* self-mutated — we only tell the user what to run. A binary install has a
+* built-in self-updater (`skydive update`, ../commands/update.ts), so that's
+* the action; the curl re-install stays the documented fallback. */
+function renderUpdateCommand(channel, source) {
+	if (source === "binary") return channel === "canary" ? "skydive update --channel canary" : "skydive update";
+	return `npm install -g ${name}@${distTagForChannel(channel)}`;
+}
+function renderUpdateNotice(opts) {
+	return `\nUpdate available: ${opts.currentVersion} \u2192 ${opts.latestVersion}\nRun ${renderUpdateCommand(opts.channel, opts.source)}\n`;
+}
+/**
+* Whether this invocation may print the notice. Pure so it's testable; the
+* inputs are raw pre-yargs argv (parsing hasn't happened when this runs) and
+* stderr's TTY-ness. `--json`/`--quiet` go to stdout, and the notice goes to
+* stderr — but scripts commonly capture 2>&1, so machine-readable modes
+* suppress it entirely rather than risk corrupting piped output.
+*/
+function shouldNotify(opts) {
+	if (!opts.stderrIsTTY) return false;
+	if (opts.argv.includes("--json") || opts.argv.includes("--quiet")) return false;
+	return true;
+}
+
+//#endregion
+//#region src/update-check/package-manager.ts
+const KNOWN = [
+	"npm",
+	"yarn",
+	"pnpm",
+	"bun"
+];
+function isKnown(value) {
+	return KNOWN.some((m) => m === value);
+}
+/**
+* Parse the manager name out of an `npm_config_user_agent` string. npm, yarn,
+* pnpm and bun all set it to `"<manager>/<version> ..."` when they spawn a
+* script, which is the most reliable signal for how *this* process was
+* launched. Returns null when the var is absent or unrecognized.
+*/
+function parseUserAgent(userAgent) {
+	if (!userAgent) return null;
+	const name = userAgent.trim().split("/")[0]?.toLowerCase();
+	return name && isKnown(name) ? name : null;
+}
+/**
+* Best-effort detection of the manager that owns this install. Order of
+* signals, most to least reliable:
+*   1. `npm_config_user_agent` — set by the manager that spawned us.
+*   2. the executable path — a global bin under a `pnpm`/`yarn`/`bun` store
+*      names the manager even when we weren't spawned by it (e.g. the user
+*      typed `skydive` directly).
+* Falls back to `npm`, the documented default install path, so the command we
+* show is always runnable — the prompt still lets the user decline and copy a
+* different one.
+*/
+function detectPackageManager(opts) {
+	const fromUa = parseUserAgent(opts.env["npm_config_user_agent"]);
+	if (fromUa) return fromUa;
+	const exec = opts.execPath.toLowerCase();
+	if (exec.includes("pnpm")) return "pnpm";
+	if (exec.includes("yarn")) return "yarn";
+	if (exec.includes("bun")) return "bun";
+	return "npm";
+}
+/**
+* The global-install command (as argv) for a manager + channel. Each manager's
+* global-add spelling differs; the version target is the channel's dist-tag
+* (`latest`/`beta`), matching what the release workflow publishes.
+*/
+function installCommand(manager, channel) {
+	const spec = `${name}@${distTagForChannel(channel)}`;
+	switch (manager) {
+		case "npm": return [
+			"npm",
+			"install",
+			"-g",
+			spec
+		];
+		case "pnpm": return [
+			"pnpm",
+			"add",
+			"-g",
+			spec
+		];
+		case "bun": return [
+			"bun",
+			"add",
+			"-g",
+			spec
+		];
+		case "yarn": return [
+			"yarn",
+			"global",
+			"add",
+			spec
+		];
+	}
+}
+/** The command as a copy-pasteable string for prompts and notices. */
+function installCommandString(manager, channel) {
+	return installCommand(manager, channel).join(" ");
+}
+
+//#endregion
+//#region src/update-check/pm-update.ts
+/**
+* The interactive upgrade path for a package-manager install: instead of only
+* printing "run npm install -g …", offer to run it now, and on confirm run
+* that exact command and relaunch the CLI on the new version.
+*
+* We never silently mutate a package-manager install (the manager owns it),
+* but an explicit prompt the user answers with a keypress is honest consent —
+* and it runs the *same* command we detected + display, so what you approve is
+* what executes. Non-interactive contexts (no TTY, --json/--quiet, CI) skip
+* the prompt entirely and fall back to the printed notice.
+*/
+/** Whether it's safe to show an interactive prompt at all. */
+function canPromptInteractively(opts) {
+	if (opts.json || opts.quiet) return false;
+	if (!opts.stdinIsTTY || !opts.stdoutIsTTY) return false;
+	if (opts.env["CI"] || opts.env["SKYDIVE_NO_UPDATE_CHECK"]) return false;
+	return true;
+}
+/**
+* Interpret a raw prompt answer. Default (empty / Enter) is **yes** — the
+* prompt renders `[Y/n]`, so a bare Enter accepts. Anything starting with `n`
+* (case-insensitive) is no; any other non-empty input is treated as no too,
+* so a fat-fingered answer never runs an install the user didn't mean.
+*/
+function interpretYesNo(answer) {
+	const a = answer.trim().toLowerCase();
+	if (a === "") return true;
+	return a === "y" || a === "yes";
+}
+/** Ask a `[Y/n]` question on the TTY and resolve to the boolean answer. */
+async function promptYesNo(question) {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return interpretYesNo(await new Promise((resolve) => {
+			rl.question(question, resolve);
+		}));
+	} finally {
+		rl.close();
+	}
+}
+/**
+* Heading shared by the prompt and the printed instruction, so the two can't
+* disagree about what is happening. `--force` asks to reinstall the version
+* already running, and calling that an update is exactly the lie this path
+* used to tell on every invocation — so it gets its own wording.
+*/
+function renderPmUpdateHeading(opts) {
+	return opts.latestVersion === opts.currentVersion ? `Reinstalling ${opts.currentVersion}.` : `Update available: ${opts.currentVersion} \u2192 ${opts.latestVersion}`;
+}
+/**
+* Offer + run the package-manager upgrade. Returns a result the caller turns
+* into output and an exit/relaunch decision — kept separate from the actual
+* relaunch so it's testable without re-execing the test runner.
+*/
+async function offerPackageManagerUpdate(opts) {
+	const manager = detectPackageManager({
+		env: opts.env,
+		execPath: opts.execPath
+	});
+	const command = installCommand(manager, opts.channel);
+	const commandStr = installCommandString(manager, opts.channel);
+	if (!opts.interactive) return { status: "skipped-noninteractive" };
+	if (!await (opts.ask ?? promptYesNo)(`${renderPmUpdateHeading(opts)}\nRun \`${commandStr}\` now? [Y/n] `)) return { status: "declined" };
+	const { status } = (opts.run ?? ((cmd) => {
+		const [bin, ...args] = cmd;
+		return { status: spawnSync(bin ?? "", args, { stdio: "inherit" }).status };
+	}))(command);
+	if (status !== 0) return {
+		status: "failed",
+		code: status,
+		command: commandStr
+	};
+	return {
+		status: "installed",
+		command: commandStr
+	};
+}
+/**
+* Relaunch the CLI after a successful in-place upgrade so the user lands back
+* on their command running the new version. Uses the same interpreter + argv
+* the current process was launched with; detaches so the parent can exit
+* cleanly. Never throws — a failed relaunch just means the user re-runs
+* manually, which the caller's message covers.
+*/
+function relaunchCli(argv = process.argv) {
+	try {
+		const [, script, ...rest] = argv;
+		spawn(process.execPath, script ? [script, ...rest] : rest, { stdio: "inherit" }).on("exit", (code) => process.exit(code ?? 0));
+	} catch (_error) {
+		process.exit(0);
+	}
+}
+
+//#endregion
+//#region src/commands/update.ts
+/**
+* `skydive update` — the user-invoked self-updater the update *check*
+* (../update-check/index.ts) has always pointed at. Notify-only remains the
+* automatic behavior; this is the explicit "do it now" action.
+*
+* Binary installs self-update in place (download -> verify sha256 -> atomic
+* replace); package-manager installs are never self-mutated (the notice
+* policy) — we print the exact upgrade command instead. `--check` is a dry
+* run; `--force` reinstalls the current version (repair a corrupt binary).
+*/
+const FETCH_TIMEOUT_MS$1 = 15e3;
+function normalizeChannel(raw, currentVersion) {
+	if (raw === "stable" || raw === "canary") return raw;
+	return resolveChannel(currentVersion);
+}
+/** Human-readable line for a plan outcome. Pure so the handler stays thin. */
+function describePlan(plan, channel, isCheck) {
+	switch (plan.kind) {
+		case "up-to-date": return `Already on the latest ${channel} release (${plan.currentVersion}).`;
+		case "unsupported-source": return `${renderPmUpdateHeading({
+			currentVersion: version,
+			latestVersion: plan.latestVersion
+		})}\nThis is a ${plan.source} install, so update through your package manager:\n  ${renderUpdateCommand(channel, plan.source)}`;
+		case "unsupported-host": return `No Skydive binary is published for ${plan.platform}/${plan.arch}.`;
+		case "missing-from-manifest": return `The ${channel} ${plan.version} release has no binary for your platform (${plan.target}).`;
+		case "update": return isCheck ? `Update available: ${version} \u2192 ${plan.version} (${channel}, ${plan.target}).\nRun \`skydive update\` to install it.` : `Updating ${version} \u2192 ${plan.version} (${channel}, ${plan.target})...`;
+	}
+}
+const updateCommand = {
+	command: "update",
+	describe: "Update the Skydive CLI to the latest release",
+	builder: (y) => y.option("channel", {
+		type: "string",
+		choices: ["stable", "canary"],
+		describe: "Release channel to update to (default: this build's channel)"
+	}).option("check", {
+		type: "boolean",
+		default: false,
+		describe: "Only report whether an update is available; don't install"
+	}).option("force", {
+		type: "boolean",
+		default: false,
+		describe: "Reinstall the current version even if already up to date (repairs a corrupt binary)"
+	}).example("skydive update", "Install the latest release").example("skydive update --check", "See if an update is available").example("skydive update --channel canary", "Switch to the canary line"),
+	handler: async (argv) => {
+		const currentVersion = version;
+		const source = resolveInstallSource();
+		const channel = normalizeChannel(argv.channel, currentVersion);
+		const releaseSource = releaseSourceForInstall(source);
+		const signal = AbortSignal.timeout(FETCH_TIMEOUT_MS$1);
+		const manifest = source === "binary" ? await releaseSource.fetchManifest(channel, { signal }).catch(() => null) : null;
+		const latestVersion = source === "binary" ? manifest?.version ?? null : await releaseSource.fetchLatestVersion(channel, { signal }).catch(() => null);
+		if (latestVersion === null) {
+			if (argv.json) {
+				output(argv, {
+					status: "unavailable",
+					channel,
+					currentVersion
+				});
+				return;
+			}
+			throw new UpdateError(source === "binary" ? `couldn't reach the ${channel} release channel — check your connection and try again.` : `couldn't reach the npm registry to look up the ${channel} release — check your connection and try again.`);
+		}
+		const plan = planUpdate({
+			currentVersion,
+			source,
+			latestVersion,
+			manifest,
+			platform: process.platform,
+			arch: process.arch,
+			allowSameVersion: argv.force
+		});
+		if (argv.json) {
+			output(argv, {
+				plan,
+				channel,
+				currentVersion,
+				dryRun: argv.check
+			});
+			return;
+		}
+		if (plan.kind === "unsupported-source" && !argv.check) {
+			const interactive = canPromptInteractively({
+				stdinIsTTY: Boolean(process.stdin.isTTY),
+				stdoutIsTTY: Boolean(process.stdout.isTTY),
+				json: argv.json,
+				quiet: argv.quiet,
+				env: process.env
+			});
+			const result = await offerPackageManagerUpdate({
+				channel,
+				currentVersion,
+				latestVersion: plan.latestVersion,
+				env: process.env,
+				execPath: process.execPath,
+				interactive
+			});
+			switch (result.status) {
+				case "installed":
+					console.log(`Updated via \`${result.command}\`. Relaunching \`skydive\`...`);
+					relaunchCli();
+					return;
+				case "failed": throw new UpdateError(`\`${result.command}\` exited with code ${result.code ?? "unknown"}. Try running it yourself.`);
+				case "declined":
+					console.log(describePlan(plan, channel, false));
+					return;
+				case "skipped-noninteractive":
+					console.log(describePlan(plan, channel, false));
+					return;
+			}
+		}
+		if (plan.kind !== "update" || argv.check) {
+			console.log(describePlan(plan, channel, argv.check));
+			return;
+		}
+		const selfPath = resolveSelfPath();
+		if (!selfPath) throw new UpdateError("couldn't determine this binary's path to replace it — reinstall with the install script instead.");
+		console.log(describePlan(plan, channel, false));
+		await applyBinary(selfPath, await downloadAndVerify({
+			downloadBaseUrl: RELEASE_CDN_URL,
+			key: plan.key,
+			expectedSha256: plan.sha256
+		}));
+		console.log(`Updated to ${plan.version}. Run \`skydive --version\` to confirm.`);
+	}
+};
+
 //#endregion
 //#region src/cli.ts
 function createCli(argv) {
-	return yargs(argv).scriptName("skydive").usage("$0 <command> [options]").parserConfiguration({ "populate--": true }).example("skydive auth login", "Store your API key").example("skydive chat", "Open the interactive chat TUI (prod)").example("skydive chat --api-url http://localhost:4500", "Chat against a local dev API").example("skydive agents list", "List your agents").example("skydive keys create \"my-key\"", "Create an API key").example("skydive secrets set OPENAI_API_KEY --agent-id <id>", "Set a secret (value from stdin)").example("skydive workspace list", "List workspaces on your account").example("skydive workspace switch acme-team", "Switch the workspace all `skydive` commands act on").example("skydive portal open --agent grace", "Open the portal to this machine for an agent, headless (no TUI)").option("json", {
+	return yargs(argv).scriptName("skydive").usage("$0 <command> [options]").parserConfiguration({ "populate--": true }).example("skydive auth login", "Store your API key").example("skydive chat", "Open the interactive chat TUI (prod)").example("skydive chat --api-url http://localhost:4500", "Chat against a local dev API").example("skydive agents list", "List your agents").example("skydive completion install", "Set up TAB completion for your shell").example("skydive keys create \"my-key\"", "Create an API key").example("skydive secrets set OPENAI_API_KEY --agent-id <id>", "Set a secret (value from stdin)").example("skydive workspace list", "List workspaces on your account").example("skydive workspace switch acme-team", "Switch the workspace all `skydive` commands act on").example("skydive portal open --agent grace", "Open the portal to this machine for an agent, headless (no TUI)").option("json", {
 		type: "boolean",
 		default: false,
 		global: true,
@@ -2159,7 +3373,7 @@ function createCli(argv) {
 		type: "string",
 		global: true,
 		describe: "Override API base URL"
-	}).command(authCommand).command(chatCommand).command(messagesCommand).command(conversationsCommand).command(agentsCommand).command(importCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).command(portalCommand).command(sandboxCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(version).alias("v", "version").alias("h", "help").help().fail((msg, err) => {
+	}).command(authCommand).command(chatCommand).command(messagesCommand).command(conversationsCommand).command(agentsCommand).command(importCommand).command(keysCommand).command(secretsCommand).command(workspaceCommand).command(portalCommand).command(sandboxCommand).command(updateCommand).command(completionCommand).demandCommand(1, "Specify a command. Run --help for usage.").strict().wrap(null).version(version).alias("v", "version").alias("h", "help").help().fail((msg, err) => {
 		printError(err ? err instanceof Error ? err.message : String(err) : msg ?? "Unknown error");
 		process.exit(1);
 	});
@@ -2271,100 +3485,6 @@ function isCheckDue(lastCheckedAt, now = Date.now()) {
 	return now - then >= CHECK_INTERVAL_MS;
 }
 
-//#endregion
-//#region src/update-check/versions.ts
-/** Canary builds carry a prerelease suffix (`X.Y.Z-beta.N`, synthesized in
-* CI); a plain semver is a stable release. An unparseable version defaults
-* to stable. */
-function resolveChannel(version) {
-	return (semver.prerelease(version, { loose: true })?.length ?? 0) > 0 ? "canary" : "stable";
-}
-/** npm dist-tag for a channel (see release-skydive-cli.yml). */
-function distTagForChannel(channel) {
-	return channel === "canary" ? "beta" : "latest";
-}
-/**
-* True when `candidate` is a strictly newer release than `current`, per
-* semver precedence (the `semver` package, including prerelease ordering).
-* Unparseable input is never newer, so garbage from the registry can't
-* produce a notice.
-*/
-function isNewerVersion(candidate, current) {
-	if (!semver.valid(candidate, { loose: true })) return false;
-	if (!semver.valid(current, { loose: true })) return false;
-	return semver.gt(candidate, current, { loose: true });
-}
-
-//#endregion
-//#region src/update-check/notice.ts
-/** The install-mode-specific action line. A package-manager install is never
-* self-mutated — we only tell the user what to run. */
-function renderUpdateCommand(channel, source) {
-	if (source === "binary") return `curl -fsSL ${DEFAULT_WEB_URL}/api/v1/cli/install.sh | ${channel === "canary" ? "SKYDIVE_CHANNEL=canary " : ""}sh`;
-	return `npm install -g ${name}@${distTagForChannel(channel)}`;
-}
-function renderUpdateNotice(opts) {
-	return `\nUpdate available: ${opts.currentVersion} \u2192 ${opts.latestVersion}\nRun ${renderUpdateCommand(opts.channel, opts.source)}\n`;
-}
-/**
-* Whether this invocation may print the notice. Pure so it's testable; the
-* inputs are raw pre-yargs argv (parsing hasn't happened when this runs) and
-* stderr's TTY-ness. `--json`/`--quiet` go to stdout, and the notice goes to
-* stderr — but scripts commonly capture 2>&1, so machine-readable modes
-* suppress it entirely rather than risk corrupting piped output.
-*/
-function shouldNotify(opts) {
-	if (!opts.stderrIsTTY) return false;
-	if (opts.argv.includes("--json") || opts.argv.includes("--quiet")) return false;
-	return true;
-}
-
-//#endregion
-//#region src/update-check/sources.ts
-function resolveInstallSource() {
-	return typeof SKYDIVE_CLI_INSTALL_SOURCE === "string" && SKYDIVE_CLI_INSTALL_SOURCE === "binary" ? "binary" : "package-manager";
-}
-const NPM_REGISTRY_URL = "https://registry.npmjs.org";
-const npmDistTagsSchema = z.record(z.string(), z.unknown());
-const binaryManifestSchema = z.object({ version: z.unknown().optional() });
-/** npm dist-tags for the published package (`skydive-cli`). */
-const npmReleaseSource = { async fetchLatestVersion(channel, { signal }) {
-	const response = await fetch(`${NPM_REGISTRY_URL}/-/package/${name}/dist-tags`, {
-		signal,
-		headers: { accept: "application/json" }
-	});
-	if (!response.ok) return null;
-	const tags = npmDistTagsSchema.safeParse(await response.json());
-	if (!tags.success) return null;
-	const version = tags.data[distTagForChannel(channel)];
-	return typeof version === "string" ? version : null;
-} };
-/**
-* Release CDN (CloudFront over the releases bucket, infra: CliReleasesCdn).
-* Serves the channel pointers the release workflow uploads
-* (`channels/{stable,canary}.json`, cached max-age=60) alongside the
-* binaries. The daily poll goes here, not to the api, so a fleet of
-* installed binaries puts no load on — and takes no dependency on — the api.
-*/
-const RELEASE_CDN_URL = "https://dl.skydive.com";
-/** Channel manifest on the release CDN, for compiled binaries. The same
-* document the api's channel route serves (see
-* apps/anyone/api/src/routes/cli-releases.ts, which reads it from the
-* bucket this CDN fronts). */
-const binaryReleaseSource = { async fetchLatestVersion(channel, { signal }) {
-	const response = await fetch(`${RELEASE_CDN_URL}/channels/${channel}.json`, {
-		signal,
-		headers: { accept: "application/json" }
-	});
-	if (!response.ok) return null;
-	const manifest = binaryManifestSchema.safeParse(await response.json());
-	if (!manifest.success) return null;
-	return typeof manifest.data.version === "string" ? manifest.data.version : null;
-} };
-function releaseSourceForInstall(source) {
-	return source === "binary" ? binaryReleaseSource : npmReleaseSource;
-}
-
 //#endregion
 //#region src/update-check/index.ts
 /**
@@ -2466,7 +3586,7 @@ function setupUpdateCheck(argv) {
 
 //#endregion
 //#region src/changelog.generated.ts
-const CHANGELOG_MD = "# Changelog\n\nAll notable changes to the Skydive CLI are documented here.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),\nand this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n## [0.2.0] - 2026-07-29\n\n### Added\n\n**Sandbox & machine access**\n\n- Standalone `skydive sandbox` command for direct access to an agent's sandbox.\n- `/sandbox` in the chat TUI — live PTY session and one-shot command execution.\n- Headless machine sharing via `skydive portal`, with self-registering portal grants.\n- `shareMachineDefault` config key for always-on portal sharing.\n\n**Chat TUI**\n\n- File pane (`ctrl+g`) with Changes and Files tabs: a shared file tree plus source viewer and a workspace browser, mouse-resizable and responsive to terminal size.\n- Agent todo list rendered in the chat TUI, above the composer, mirroring the web chat's todo card.\n- Fuzzy finder in the conversation and agent pickers.\n- Slash-command autocomplete menu.\n- Paste or drag-and-drop any file into the composer; paste clipboard images with Cmd+V.\n- Run local shell commands with `!` in the composer.\n- Conversation recaps, streamed live title updates, and per-agent attribution on assistant turns.\n- Working timer rolls up into minutes and hours.\n- Conversation picker paginates past 50 conversations and shows only your own conversations.\n- Esc leaves a live run; typing `exit` quits the chat.\n- Cursor Dark theme.\n- Picker rows no longer overlap when a conversation title contains a newline, tab, or control character.\n\n**Headless & scripting**\n\n- Resume a conversation by id.\n- `conversations list` and `conversations show` for transcript reads.\n- `messages get`, with run recovery keyed on message id.\n- Connect cards surface in headless `-p` mode so a driving agent never gets stuck.\n\n**Authentication**\n\n- `skydive auth login` via the browser now auto-mints an API key, so one login yields both a chat session and a usable management credential. Management commands announce the key's pinned workspace when it drives them, so a workspace mismatch is visible at use time.\n- Workspace picker on the device authorization page.\n- Account and workspace identity shown in `auth status`.\n\n**Platform**\n\n- Standalone binary builds compiling the CLI into a per-target executable.\n- Interactive workspace switcher; management commands follow the active workspace.\n- Terminal host integrations and agent notifications.\n\n### Fixed\n\n- Transcript errors collapse to one line, click to expand (REST and portal errors keep their full body).\n- Dragged/pasted image file paths attach the file instead of inserting path text, including macOS paths with literal parentheses.\n- Bare URLs in chat markdown are hyperlinked so they survive text wrap.\n- Composer draft is preserved across TUI overlays.\n- Relative connect links resolve before opening the browser.\n- Numbered markdown headings render colored in the TUI.\n- Chat transcript pages by 75% of a screen; picker rows stay on one line.\n- Run starts push to the TUI over the conversation stream.\n- Security: remediated high-severity dependency findings and cleared tar/shell-quote CVEs.\n\n## [0.1.0] - 2026-07-21\n\nInitial public release: `skydive chat` TUI, agent and conversation management,\ndevice authorization, and headless `-p` mode.\n";
+const CHANGELOG_MD = "# Changelog\n\nAll notable changes to the Skydive CLI are documented here.\n\nThe format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),\nand this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).\n\n## [Unreleased]\n\n## [0.3.0] - 2026-08-04\n\n### Added\n\n**Chat TUI**\n\n- `/fork` slash command to fork a conversation at any point and continue in a new thread.\n- `/conversation` switches threads from inside a live session.\n- `/compact` triggers manual conversation compaction.\n- `/portal` and `/copy` slash commands.\n- Archive the current conversation from the chat TUI.\n- `--new` flag on `skydive chat` to start a fresh conversation.\n- Debounced server-side conversation search in the picker, with title matches ranked first.\n- File review pane orientation toggle, and review comments in the file pane.\n- Pinned plan card controls and a jump-to-latest hint.\n- Terminal title (OSC) follows the live conversation title on every screen; inside cmux the workspace is renamed too, and linked PRs are pushed to the cmux sidebar.\n- Every participating agent shows in the conversation list; connect cards each have their own identity, and ctrl+r asks which connect card to act on.\n- Colored Skydive splash art in `skydive --help` and the TUI pickers.\n- New-agent name prefilled from the server's suggestion.\n\n**CLI & platform**\n\n- `skydive update` self-updater, with an update notice when a new version is available.\n- Shell completions for bash, zsh, and fish via `completion install`.\n- Portal daemon: one connection per host with per-conversation working directories.\n- Agent-led coding-agent import (`skydive import`).\n- Per-workspace scoping on the REST client, and cross-org `--agent <uuid>` auto-switches workspace.\n- `skydive-beta` wrapper for the canary channel.\n\n### Fixed\n\n- `skydive update` no longer claims an update is available on every npm install.\n- Chat memory is bounded (payload clamps + windowed rows) with a memory watchdog and OOM diagnostic report; transcript rows are memoized so streaming stops re-rendering the whole chat.\n- Chat-send failures map to real error messages.\n- Notification and sidebar previews use the last text block of the reply and strip inline markdown.\n- Picker rows no longer overlap when a conversation title contains a newline, tab, or control character.\n- Sending to non-web channel conversations is blocked in the TUI.\n- GitHub bot connect opens on the web front door, not api.skydive.com.\n- TUI activity counter times from the run, not the screen.\n\n## [0.2.0] - 2026-07-29\n\n### Added\n\n**Sandbox & machine access**\n\n- Standalone `skydive sandbox` command for direct access to an agent's sandbox.\n- `/sandbox` in the chat TUI — live PTY session and one-shot command execution.\n- Headless machine sharing via `skydive portal`, with self-registering portal grants.\n- `shareMachineDefault` config key for always-on portal sharing.\n\n**Chat TUI**\n\n- File pane (`ctrl+g`) with Changes and Files tabs: a shared file tree plus source viewer and a workspace browser, mouse-resizable and responsive to terminal size.\n- Agent todo list rendered in the chat TUI, above the composer, mirroring the web chat's todo card.\n- Fuzzy finder in the conversation and agent pickers.\n- Slash-command autocomplete menu.\n- Paste or drag-and-drop any file into the composer; paste clipboard images with Cmd+V.\n- Run local shell commands with `!` in the composer.\n- Conversation recaps, streamed live title updates, and per-agent attribution on assistant turns.\n- Working timer rolls up into minutes and hours.\n- Conversation picker paginates past 50 conversations and shows only your own conversations.\n- Esc leaves a live run; typing `exit` quits the chat.\n- Cursor Dark theme.\n- Picker rows no longer overlap when a conversation title contains a newline, tab, or control character.\n\n**Headless & scripting**\n\n- Resume a conversation by id.\n- `conversations list` and `conversations show` for transcript reads.\n- `messages get`, with run recovery keyed on message id.\n- Connect cards surface in headless `-p` mode so a driving agent never gets stuck.\n\n**Authentication**\n\n- `skydive auth login` via the browser now auto-mints an API key, so one login yields both a chat session and a usable management credential. Management commands announce the key's pinned workspace when it drives them, so a workspace mismatch is visible at use time.\n- Workspace picker on the device authorization page.\n- Account and workspace identity shown in `auth status`.\n\n**Platform**\n\n- Standalone binary builds compiling the CLI into a per-target executable.\n- Interactive workspace switcher; management commands follow the active workspace.\n- Terminal host integrations and agent notifications.\n\n### Fixed\n\n- Transcript errors collapse to one line, click to expand (REST and portal errors keep their full body).\n- Dragged/pasted image file paths attach the file instead of inserting path text, including macOS paths with literal parentheses.\n- Bare URLs in chat markdown are hyperlinked so they survive text wrap.\n- Composer draft is preserved across TUI overlays.\n- Relative connect links resolve before opening the browser.\n- Numbered markdown headings render colored in the TUI.\n- Chat transcript pages by 75% of a screen; picker rows stay on one line.\n- Run starts push to the TUI over the conversation stream.\n- Security: remediated high-severity dependency findings and cleared tar/shell-quote CVEs.\n\n## [0.1.0] - 2026-07-21\n\nInitial public release: `skydive chat` TUI, agent and conversation management,\ndevice authorization, and headless `-p` mode.\n";
 
 //#endregion
 //#region src/whats-new.ts
@@ -2602,13 +3722,26 @@ function maybePrintWhatsNew({ stderrIsTTY = process.stderr.isTTY ?? false, nonIn
 
 //#endregion
 //#region src/bin.ts
+installCrashHandler();
 if (process.argv.includes(UPDATE_WORKER_FLAG)) {
 	await runUpdateCheckWorker();
 	process.exit(0);
 }
-maybePrintWhatsNew();
-setupUpdateCheck(hideBin(process.argv));
-createCli(resolveArgv(hideBin(process.argv))).parse();
+if (process.argv.includes(PORTAL_DAEMON_FLAG)) {
+	const { runPortalDaemon } = await import("./daemon-Ch_MSDmQ.mjs");
+	runPortalDaemon(process.argv);
+} else runCli();
+function runCli() {
+	const completionProbe = isCompletionProbe(process.argv);
+	if (!completionProbe) {
+		maybePrintWhatsNew();
+		setupUpdateCheck(hideBin(process.argv));
+	}
+	const resolved = resolveArgv(normalizeProbeArgv(hideBin(process.argv)));
+	const raw = hideBin(process.argv);
+	if (!completionProbe && (raw.includes("--help") || raw.includes("-h")) && !raw.some((a) => !a.startsWith("-")) && !raw.includes("--json") && !raw.includes("--quiet")) process.stdout.write(brandHelpArt());
+	createCli(resolved).parse();
+}
 
 //#endregion
 export {  };