skydive-cli 0.5.0-beta.8 → 0.5.0

package/dist/js/{profiler-DawY0V0Z.mjs → install-CtAVvERm.mjs}

@@ -1,16 +1,12 @@
 #!/usr/bin/env node
-import { S as getConfigPath } from "./print-BpuyEfWX.mjs";
+import { c as version$1 } from "./rest-B9__Zsuk.mjs";
+import { w as getConfigPath } from "./print-D_UEjdSw.mjs";
 import os from "node:os";
 import path from "node:path";
 import { err, ok } from "neverthrow";
 import { z } from "zod";
 import fs from "node:fs";
 
-//#region package.json
-var name = "skydive-cli";
-var version$1 = "0.5.0-beta.8";
-
-//#endregion
 //#region src/auth/organization.ts
 const workspaceSchema = z.object({
 	id: z.string(),
@@ -32,6 +28,32 @@ async function listWorkspaces({ appUrl, sessionToken }) {
 	}
 }
 /**
+* Match a workspace selector against a roster the way `workspace switch` does:
+* exact id first, then case-insensitive slug, then case-insensitive name.
+* Returns null when nothing matches. Pure — the caller owns fetching and error
+* messaging.
+*/
+function matchWorkspace(workspaces, selector) {
+	const needle = selector.trim().toLowerCase();
+	return workspaces.find((w) => w.id === selector) ?? workspaces.find((w) => w.slug.toLowerCase() === needle) ?? workspaces.find((w) => w.name.toLowerCase() === needle) ?? null;
+}
+/**
+* Resolve a workspace selector (slug, name, or id) to its id by listing the
+* account's workspaces and matching. Used by any command that takes a
+* `--workspace` flag to scope requests without persisting an active-workspace
+* switch.
+*/
+async function resolveWorkspaceId({ appUrl, sessionToken, selector }) {
+	const workspaces = await listWorkspaces({
+		appUrl,
+		sessionToken
+	});
+	if (workspaces.isErr()) return err(workspaces.error);
+	const match = matchWorkspace(workspaces.value, selector);
+	if (!match) return err({ message: `No workspace matches "${selector}". Run \`skydive workspace list\` to see available workspaces.` });
+	return ok(match);
+}
+/**
 * Resolve who the current chat session belongs to: the signed-in user's
 * email/name and the active workspace. Used by `auth status` so a user running
 * multiple accounts can answer "am I logged into the right one?" without
@@ -125,6 +147,218 @@ async function ensureActiveOrganization({ appUrl, sessionToken }) {
 	});
 }
 
+//#endregion
+//#region src/shell/shell-env.ts
+/**
+* Shared, dependency-light shell primitives used by anything that edits the
+* user's shell startup files — `completion install` and `agents alias`. Kept
+* free of yargs and the CLI's output layer so the TUI can import it without
+* dragging command machinery into its bundle or creating a TUI -> commands
+* import cycle.
+*/
+const SUPPORTED_SHELLS = [
+	"bash",
+	"zsh",
+	"fish"
+];
+const defaultInstallEnv = () => ({
+	home: os.homedir(),
+	platform: process.platform,
+	env: process.env,
+	exists: fs.existsSync
+});
+/**
+* The shell to act on when the user didn't name one. `$SHELL` is the only
+* signal available: an 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;
+}
+
+//#endregion
+//#region src/commands/agent-alias.ts
+/**
+* Shell aliases that point a friendly command name at a specific agent's chat.
+*
+* When someone creates an agent named "Ripple", they almost always want to
+* reach it again by typing `ripple`, not `skydive chat --agent <uuid>`. This
+* module writes a managed alias block into the user's shell startup file so
+* `ripple` opens that agent. It reuses the same shell detection and startup-file
+* machinery as `completion install` (imported from ./completion), so the two
+* features agree on which file to touch and how to detect the shell.
+*
+* The alias always targets the agent **id**, never its name: names are not
+* unique and can be renamed, so an id keeps `ripple` pointed at the same agent
+* even if a second "Ripple" is created later or this one is renamed.
+*/
+/**
+* Turn a display name into a shell-safe alias token: lowercase, non-alnum runs
+* collapsed to a single hyphen, leading/trailing hyphens trimmed. "Ripple" ->
+* "ripple", "My Agent" -> "my-agent", "Ripple 2.0" -> "ripple-2-0".
+*
+* A leading digit is prefixed with `a-` because bash rejects an alias name that
+* starts with a digit (`alias 2fast=...` is a syntax error). An empty result
+* (a name that was all punctuation) falls back to "agent" so callers always get
+* a usable token to offer or dedupe from.
+*/
+function slugifyAliasName(name) {
+	const slug = name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+	if (!slug) return "agent";
+	return /^[0-9]/.test(slug) ? `a-${slug}` : slug;
+}
+/**
+* The alias token to actually install, given a preferred token and the set of
+* names already taken (existing aliases, and — the caller's choice — commands
+* on PATH). Prefers the clean token; on a collision appends the lowest integer
+* that frees it: `ripple` -> `ripple2` -> `ripple3`. Matching is
+* case-insensitive because shells treat `Ripple` and `ripple` as distinct
+* aliases but a user typing one means the other.
+*/
+function dedupeAliasName(preferred, taken) {
+	const takenLower = new Set(Array.from(taken, (t) => t.trim().toLowerCase()).filter(Boolean));
+	if (!takenLower.has(preferred.toLowerCase())) return preferred;
+	for (let n = 2;; n += 1) {
+		const candidate = `${preferred}${n}`;
+		if (!takenLower.has(candidate.toLowerCase())) return candidate;
+	}
+}
+/** The startup file an alias block belongs in, per shell. */
+function aliasTarget(shell, deps = defaultInstallEnv()) {
+	const { home, platform, env, exists } = deps;
+	const join = path.posix.join;
+	if (shell === "fish") return join(env["XDG_CONFIG_HOME"] || join(home, ".config"), "fish", "config.fish");
+	if (shell === "zsh") return join(env["ZDOTDIR"] || home, ".zshrc");
+	const rc = join(home, ".bashrc");
+	const profile = join(home, ".bash_profile");
+	const preferred = platform === "darwin" ? profile : rc;
+	const alternate = platform === "darwin" ? rc : profile;
+	if (!exists(preferred) && exists(alternate)) return alternate;
+	return preferred;
+}
+const BLOCK_START = "###-begin-skydive-agent-aliases-###";
+const BLOCK_END = "###-end-skydive-agent-aliases-###";
+const aliasLine = (entry) => {
+	const ws = entry.workspaceId ? ` --workspace ${entry.workspaceId}` : "";
+	return `alias ${entry.alias}='skydive chat --agent ${entry.agentId}${ws} --new' # skydive-agent:${entry.agentId}`;
+};
+/**
+* Parse the alias entries already inside the managed block. Used to merge a new
+* alias with existing ones and to answer "is this token taken?". Tolerant of
+* hand-edits: only well-formed lines carrying our trailing marker are read
+* back; anything else in the block is preserved verbatim on rewrite.
+*/
+function parseAliasBlock(existing) {
+	const start = existing.indexOf(BLOCK_START);
+	const end = existing.indexOf(BLOCK_END);
+	if (start === -1 || end <= start) return [];
+	const body = existing.slice(start + 35, end);
+	const entries = [];
+	for (const line of body.split("\n")) {
+		const match = line.match(/^alias\s+([^=]+)=.*# skydive-agent:([0-9a-f-]+)\s*$/i);
+		if (match?.[1] && match[2]) {
+			const wsMatch = line.match(/--workspace\s+(\S+)/);
+			entries.push({
+				alias: match[1].trim(),
+				agentId: match[2],
+				workspaceId: wsMatch?.[1]
+			});
+		}
+	}
+	return entries;
+}
+/**
+* Merge `entry` into the managed alias block of `existing`, returning the new
+* file contents. Idempotent: re-installing the same alias for the same agent is
+* a no-op edit; a new agent id adds a line; an existing agent id has its alias
+* token refreshed. The block is created if absent.
+*/
+function spliceAliasBlock(existing, entry) {
+	const current = parseAliasBlock(existing).filter((e) => e.agentId !== entry.agentId);
+	current.push(entry);
+	current.sort((a, b) => a.alias.localeCompare(b.alias));
+	const block = [
+		BLOCK_START,
+		"# skydive agent aliases, managed by `skydive agents alias`. Edits between",
+		"# these markers are overwritten when an alias is added or refreshed.",
+		...current.map(aliasLine),
+		BLOCK_END
+	].join("\n");
+	const start = existing.indexOf(BLOCK_START);
+	const endMarker = BLOCK_END;
+	const end = existing.indexOf(endMarker);
+	if (start !== -1 && end > start) return `${existing.slice(0, start)}${block}\n${existing.slice(end + 33).replace(/^\n/, "")}`;
+	return `${existing}${existing === "" || existing.endsWith("\n\n") ? "" : "\n"}\n${block}\n`;
+}
+/**
+* Write (or refresh) an agent alias in the user's shell startup file. Returns
+* the resolved shell, file, and the alias token actually used. Does not dedupe
+* on its own — pass a token already reconciled with `takenAliasNames` so the
+* caller controls the suggestion UX.
+*/
+function installAgentAlias(input, deps = defaultInstallEnv()) {
+	const target = aliasTarget(input.shell, deps);
+	const existing = deps.exists(target) ? fs.readFileSync(target, "utf8") : "";
+	const contents = spliceAliasBlock(existing, {
+		alias: input.alias,
+		agentId: input.agentId,
+		workspaceId: input.workspaceId
+	});
+	fs.mkdirSync(path.dirname(target), { recursive: true });
+	fs.writeFileSync(target, contents, "utf8");
+	return {
+		shell: input.shell,
+		path: target,
+		alias: input.alias,
+		agentId: input.agentId,
+		updated: existing.includes(BLOCK_START)
+	};
+}
+/**
+* Alias tokens already defined in our managed block of the given shell's
+* startup file. The dedupe source: a fresh install shouldn't collide with an
+* alias we wrote for another agent. (We don't try to read the user's own
+* hand-written aliases or PATH — a shell child process can't see the parent's
+* live alias table, and probing PATH is noisy; the dedupe covers our own
+* blocks, which is where real collisions come from in practice.)
+*/
+function takenAliasNames(shell, deps = defaultInstallEnv()) {
+	const target = aliasTarget(shell, deps);
+	if (!deps.exists(target)) return [];
+	return parseAliasBlock(fs.readFileSync(target, "utf8")).map((e) => e.alias);
+}
+/** What the user must do before the alias works in the shell they're in. */
+function aliasActivationHint(result) {
+	return result.shell === "fish" ? "Open a new fish shell to use it." : `Open a new shell, or run: source ${result.path}`;
+}
+
+//#endregion
+//#region src/chat/import-seed.ts
+/** Map `process.platform` to the OS family used by the seed prompts. Every
+* non-`win32` platform Node runs on (darwin, linux, the BSDs) is POSIX. */
+function machineOsFromPlatform(platform) {
+	return platform === "win32" ? "windows" : "posix";
+}
+/** One clause describing the machine's shell/paths so the agent's discovery
+* sweep uses the right conventions instead of guessing. */
+function osHint(os) {
+	return os === "windows" ? "This machine is Windows, so use PowerShell and Windows paths (%USERPROFILE%, backslashes)." : "This machine is POSIX (macOS/Linux), so use a POSIX shell and paths (~, forward slashes).";
+}
+/**
+* The first message of an explicit `skydive import` conversation, sent as the
+* user. Frames the migration and points the agent at its import-config skill.
+*/
+function buildImportSeedPrompt(projectDir, os) {
+	return [
+		"I'm migrating from another coding agent. Import my setup from this machine.",
+		"",
+		`Use your import-config skill. I ran this from \`${projectDir}\`, so start there and in my home directory. ${osHint(os)} Don't assume one tool — do the discovery sweep so you catch whatever I actually use (Claude Code, Cursor, Codex, Gemini CLI, Copilot, Windsurf, Cline, OpenCode, Aider, and any nested AGENTS.md). Show me the plan first: everything you found, what you'll bring over, where it lands in you, and anything you're leaving out (credentials especially). Then wait for my OK before committing anything.`
+	].join("\n");
+}
+
 //#endregion
 //#region src/chat/tui/theme.ts
 const tokyonight = {
@@ -132,6 +366,7 @@ const tokyonight = {
 	label: "Tokyo Night",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#c0caf5",
 		muted: "#7a7a7a",
 		dim: "#565f89",
@@ -160,6 +395,7 @@ const tokyonightDay = {
 	label: "Tokyo Night Day",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#3760bf",
 		muted: "#848cb5",
 		dim: "#9da3c2",
@@ -188,6 +424,7 @@ const catppuccinMocha = {
 	label: "Catppuccin Mocha",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#cdd6f4",
 		muted: "#7f849c",
 		dim: "#6c7086",
@@ -216,6 +453,7 @@ const catppuccinLatte = {
 	label: "Catppuccin Latte",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#4c4f69",
 		muted: "#8c8fa1",
 		dim: "#9ca0b0",
@@ -244,6 +482,7 @@ const gruvboxDark = {
 	label: "Gruvbox Dark",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#ebdbb2",
 		muted: "#928374",
 		dim: "#7c6f64",
@@ -272,6 +511,7 @@ const gruvboxLight = {
 	label: "Gruvbox Light",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#3c3836",
 		muted: "#928374",
 		dim: "#a89984",
@@ -300,6 +540,7 @@ const solarizedDark = {
 	label: "Solarized Dark",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#93a1a1",
 		muted: "#586e75",
 		dim: "#586e75",
@@ -328,6 +569,7 @@ const solarizedLight = {
 	label: "Solarized Light",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#657b83",
 		muted: "#839496",
 		dim: "#93a1a1",
@@ -356,6 +598,7 @@ const nord = {
 	label: "Nord",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#d8dee9",
 		muted: "#616e88",
 		dim: "#4c566a",
@@ -384,6 +627,7 @@ const dracula = {
 	label: "Dracula",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#f8f8f2",
 		muted: "#6272a4",
 		dim: "#6272a4",
@@ -412,6 +656,7 @@ const oneDark = {
 	label: "One Dark",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#abb2bf",
 		muted: "#5c6370",
 		dim: "#5c6370",
@@ -440,6 +685,7 @@ const oneLight = {
 	label: "One Light",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#383a42",
 		muted: "#a0a1a7",
 		dim: "#a0a1a7",
@@ -468,6 +714,7 @@ const rosePine = {
 	label: "Rosé Pine",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#e0def4",
 		muted: "#908caa",
 		dim: "#6e6a86",
@@ -496,6 +743,7 @@ const rosePineDawn = {
 	label: "Rosé Pine Dawn",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#575279",
 		muted: "#797593",
 		dim: "#9893a5",
@@ -524,6 +772,7 @@ const everforestDark = {
 	label: "Everforest Dark",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#d3c6aa",
 		muted: "#859289",
 		dim: "#7a8478",
@@ -552,6 +801,7 @@ const everforestLight = {
 	label: "Everforest Light",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#5c6a72",
 		muted: "#939f91",
 		dim: "#a6b0a0",
@@ -580,6 +830,7 @@ const githubDark = {
 	label: "GitHub Dark",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#c9d1d9",
 		muted: "#8b949e",
 		dim: "#6e7681",
@@ -608,6 +859,7 @@ const githubLight = {
 	label: "GitHub Light",
 	mode: "light",
 	palette: {
+		cursor: "#737373",
 		fg: "#24292f",
 		muted: "#57606a",
 		dim: "#8c959f",
@@ -636,6 +888,7 @@ const kanagawa = {
 	label: "Kanagawa",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		fg: "#dcd7ba",
 		muted: "#727169",
 		dim: "#54546d",
@@ -664,6 +917,7 @@ const cursorDark = {
 	label: "Cursor Dark",
 	mode: "dark",
 	palette: {
+		cursor: "#ffffff",
 		background: "#181818",
 		fg: "#d4d4d4",
 		muted: "#898989",
@@ -725,6 +979,7 @@ const monoTheme = {
 	label: "No color",
 	mode: "dark",
 	palette: {
+		cursor: void 0,
 		fg: void 0,
 		muted: void 0,
 		dim: void 0,
@@ -807,6 +1062,277 @@ function applyTheme(def) {
 	version++;
 }
 
+//#endregion
+//#region src/profiling/profiler.ts
+/**
+* Session diagnostics. Every invocation records enough context to reconstruct
+* what happened after the fact. SKYDIVE_PROFILE can select a custom directory
+* or disable recording with `0`.
+*
+* Default sessions live under the CLI's system state directory. Explicit
+* profiles keep the original cwd/custom-path behavior and add a CPU profile.
+* Each directory is designed to be handed to an agent (or a human) and read
+* without special tooling:
+*
+*   network.ndjson   every fetch: method, url, status, timing, content type
+*   state.ndjson     TUI state transitions (screen changes, store updates)
+*   commits.ndjson   React commits: which subtree rendered, when, how long
+*   render.ndjson    OpenTUI renderer samples: fps, frame times, cells drawn
+*   render.json      final renderer stats dump (full frame-time series)
+*   cpu-<pid>.cpuprofile  V8 CPU profile (Node-run commands only)
+*   meta-<pid>.json  argv, versions, runtime, exit code, wall time
+*
+* Every ndjson event carries a wall-clock `t` (epoch ms) and `pid`, so
+* records from the Node parent and the Bun-re-exec'd chat TUI land in the
+* same files and stay correlatable on one clock. The profile directory is
+* created by the first process and shared with children through
+* SKYDIVE_PROFILE_DIR (the chat re-exec inherits the environment).
+*
+*/
+const ENV_FLAG = "SKYDIVE_PROFILE";
+const ENV_DIR = "SKYDIVE_PROFILE_DIR";
+const DEFAULT_SESSION_LIMIT = 20;
+let activeDir = null;
+let startedAtMs = 0;
+/**
+* Buffered event lines per stream, flushed asynchronously. Events are
+* appended to an in-memory buffer and written with fs.promises off the
+* hot path, so recording never blocks the TUI's event loop — high-rate
+* streams (React commits, renderer samples) stay cheap. Whatever is
+* still buffered when the process exits is drained synchronously in the
+* exit handler, where async I/O would never flush.
+*/
+const pendingLines = /* @__PURE__ */ new Map();
+let flushScheduled = false;
+let flushing = Promise.resolve();
+function drainBuffersSync() {
+	if (activeDir === null) return;
+	for (const [stream, lines] of pendingLines) {
+		if (lines.length === 0) continue;
+		pendingLines.set(stream, []);
+		try {
+			fs.appendFileSync(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
+		} catch (_error) {}
+	}
+}
+function scheduleFlush() {
+	if (flushScheduled || activeDir === null) return;
+	flushScheduled = true;
+	setTimeout(() => {
+		flushScheduled = false;
+		flushing = flushing.then(async () => {
+			if (activeDir === null) return;
+			for (const [stream, lines] of pendingLines) {
+				if (lines.length === 0) continue;
+				pendingLines.set(stream, []);
+				try {
+					await fs.promises.appendFile(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
+				} catch (_error) {}
+			}
+		});
+	}, 100).unref?.();
+}
+function profilingEnabled() {
+	return process.env[ENV_FLAG] !== "0";
+}
+function explicitProfilingEnabled() {
+	const value = process.env[ENV_FLAG];
+	return value !== void 0 && value !== "" && value !== "0";
+}
+function profileDir() {
+	return activeDir;
+}
+function automaticLogsDir(platform, env, home) {
+	const appName = env["SKYDIVE_CONFIG_NAME"] ?? "skydive";
+	if (platform === "darwin") return path.join(home, "Library", "Logs", appName);
+	if (platform === "linux") {
+		const stateHome = env["XDG_STATE_HOME"] || path.join(home, ".local", "state");
+		return path.join(stateHome, appName);
+	}
+	return path.join(path.dirname(getConfigPath()), "logs");
+}
+function getAutomaticLogsDir() {
+	return automaticLogsDir(process.platform, process.env, os.homedir());
+}
+function sanitizeToken(token) {
+	return token.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
+}
+function commandName(argv) {
+	return argv.find((arg) => !arg.startsWith("-")) ?? "chat";
+}
+function sessionName(argv) {
+	const command = commandName(argv);
+	return `${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19)}-${sanitizeToken(command)}-${process.pid}`;
+}
+/**
+* Automatic logs retain command shape, not values. Positional arguments and
+* flag values can contain prompts, secrets, paths, and other private data.
+*/
+function safeAutomaticArgv(argv) {
+	return [commandName(argv), ...argv.filter((arg) => arg.startsWith("-")).map((arg) => arg.split("=", 1)[0] ?? arg)];
+}
+/** Keeps automatic diagnostics bounded without touching explicit profiles. */
+function pruneAutomaticSessions(root, activeSession) {
+	try {
+		const sessions = fs.readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory() && entry.name !== activeSession).map((entry) => entry.name).sort().reverse();
+		for (const stale of sessions.slice(DEFAULT_SESSION_LIMIT - 1)) fs.rmSync(path.join(root, stale), {
+			recursive: true,
+			force: true
+		});
+	} catch (_error) {}
+}
+/**
+* Appends one event to a stream file. Buffered and written asynchronously
+* so recording never blocks the event loop; the exit handler drains any
+* remainder synchronously so abrupt exits still keep their events.
+*/
+function record(stream, event) {
+	if (activeDir === null) return;
+	const line = JSON.stringify({
+		t: Date.now(),
+		pid: process.pid,
+		...event
+	});
+	const lines = pendingLines.get(stream);
+	if (lines === void 0) pendingLines.set(stream, [line]);
+	else lines.push(line);
+	scheduleFlush();
+}
+/** Writes a JSON artifact (non-append) into the profile directory. */
+function writeArtifact(name, data) {
+	if (activeDir === null) return;
+	try {
+		fs.writeFileSync(path.join(activeDir, name), JSON.stringify(data, null, 2));
+	} catch (_error) {}
+}
+function safeAutomaticUrl(value) {
+	try {
+		const url = new URL(value);
+		for (const key of url.searchParams.keys()) url.searchParams.set(key, "<redacted>");
+		url.hash = "";
+		return url.href;
+	} catch (_error) {
+		return "<invalid-url>";
+	}
+}
+/**
+* Patches globalThis.fetch to record request timing. A wrapper (not
+* undici's diagnostics_channel) because chat re-execs under Bun, where
+* fetch is Bun-native and undici events never fire; the wrapper behaves
+* identically in both runtimes.
+*/
+function installFetchRecorder(explicit) {
+	const original = globalThis.fetch;
+	const wrapped = async (...args) => {
+		const [input, init] = args;
+		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+		const method = init?.method ?? (input instanceof Request ? input.method : "GET");
+		const started = Date.now();
+		try {
+			const res = await original(...args);
+			const contentType = res.headers.get("content-type") ?? "";
+			record("network", {
+				method,
+				url: explicit ? url : safeAutomaticUrl(url),
+				status: res.status,
+				durationMs: Date.now() - started,
+				contentType,
+				streamed: contentType.includes("text/event-stream")
+			});
+			return res;
+		} catch (err) {
+			record("network", {
+				method,
+				url: explicit ? url : safeAutomaticUrl(url),
+				status: 0,
+				durationMs: Date.now() - started,
+				error: err instanceof Error ? err.message : String(err)
+			});
+			throw err;
+		}
+	};
+	globalThis.fetch = Object.assign(wrapped, original);
+}
+function isBunRuntime() {
+	return typeof process !== "undefined" && "bun" in process.versions;
+}
+/**
+* Starts the V8 CPU profiler via node:inspector. Node-run commands only —
+* Bun does not implement the inspector Profiler domain, so the chat TUI
+* skips this artifact.
+*/
+function startCpuProfile() {
+	if (isBunRuntime()) return;
+	(async () => {
+		try {
+			const { Session } = await import("node:inspector/promises");
+			const session = new Session();
+			session.connect();
+			await session.post("Profiler.enable");
+			await session.post("Profiler.start");
+			process.once("beforeExit", () => {
+				(async () => {
+					try {
+						const { profile } = await session.post("Profiler.stop");
+						writeArtifact(`cpu-${process.pid}.cpuprofile`, profile);
+						session.disconnect();
+					} catch (_error) {}
+				})();
+			});
+		} catch (_error) {}
+	})();
+}
+/**
+* Starts diagnostics unless SKYDIVE_PROFILE=0. Creates a system-state session
+* directory (or joins the one a parent process created), patches fetch, and
+* registers the exit-time metadata dump. Explicit profiles also capture CPU.
+*/
+function maybeStartProfiling(argv, cliVersion) {
+	if (!profilingEnabled() || activeDir !== null) return;
+	const inherited = process.env[ENV_DIR];
+	const explicit = explicitProfilingEnabled();
+	let automaticRoot = null;
+	let automaticSession = null;
+	if (inherited !== void 0 && inherited !== "") activeDir = inherited;
+	else if (explicit) {
+		const flagValue = process.env[ENV_FLAG] ?? "1";
+		activeDir = flagValue === "1" || flagValue.toLowerCase() === "true" ? path.resolve(process.cwd(), `skydive-profile-${sessionName(argv)}`) : path.resolve(process.cwd(), flagValue);
+		process.env[ENV_DIR] = activeDir;
+	} else {
+		automaticRoot = getAutomaticLogsDir();
+		automaticSession = sessionName(argv);
+		activeDir = path.join(automaticRoot, automaticSession);
+		process.env[ENV_DIR] = activeDir;
+	}
+	try {
+		fs.mkdirSync(activeDir, {
+			recursive: true,
+			mode: 448
+		});
+		if (automaticRoot !== null && automaticSession !== null) pruneAutomaticSessions(automaticRoot, automaticSession);
+	} catch (_error) {
+		activeDir = null;
+		return;
+	}
+	startedAtMs = Date.now();
+	installFetchRecorder(explicit);
+	if (explicit) startCpuProfile();
+	process.on("exit", (code) => {
+		drainBuffersSync();
+		writeArtifact(`meta-${process.pid}.json`, {
+			argv: explicit ? argv : safeAutomaticArgv(argv),
+			cliVersion,
+			runtime: isBunRuntime() ? `bun ${process.versions["bun"]}` : `node ${process.version}`,
+			platform: process.platform,
+			pid: process.pid,
+			exitCode: code,
+			startedAt: new Date(startedAtMs).toISOString(),
+			wallTimeMs: Date.now() - startedAtMs
+		});
+		if (explicit && process.env[ENV_DIR] === activeDir && inherited === void 0) process.stderr.write(`\nprofile written to ${activeDir}\n`);
+	});
+}
+
 //#endregion
 //#region src/brand.ts
 const MARK_CELLS = [
@@ -907,6 +1433,17 @@ const WORDMARK = [
 	"███████║██║  ██╗   ██║   ██████╔╝██║ ╚████╔╝ ███████╗",
 	"╚══════╝╚═╝  ╚═╝   ╚═╝   ╚═════╝ ╚═╝  ╚═══╝  ╚══════╝"
 ];
+/** Columns between the pinwheel and the wordmark. */
+const SPLASH_GAP = 3;
+/** Columns the full mark + wordmark occupies (no chrome). */
+const SPLASH_WIDTH = MARK_WIDTH + SPLASH_GAP + WORDMARK.reduce((max, line) => Math.max(max, line.length), 0);
+/** Extra columns around the splash: `skydive --help` indents by 2, the TUI
+*  app pads 1 on each side. Same number, so one threshold covers both. */
+const SPLASH_CHROME = 2;
+/** Whether the full splash fits on one line of `columns` without wrapping. */
+function splashFitsWidth(columns) {
+	return columns >= SPLASH_WIDTH + SPLASH_CHROME;
+}
 const RESET = "\x1B[0m";
 function hexToRgb(hex) {
 	const n = Number.parseInt(hex.slice(1), 16);
@@ -933,7 +1470,7 @@ function markLinesAnsi() {
 function brandHelpArt(stream = process.stdout) {
 	if (!stream.isTTY) return "";
 	const truecolor = (typeof stream.getColorDepth === "function" ? stream.getColorDepth() : 1) >= 24;
-	if ((stream.columns ?? 80) < 66) return truecolor ? `\n  ${sgr("✦", BRAND_ACCENT)} Skydive\n` : "\n  ✦ Skydive\n";
+	if (!splashFitsWidth(stream.columns ?? 80)) return truecolor ? `\n  ${sgr("✦", BRAND_ACCENT)} Skydive\n` : "\n  ✦ Skydive\n";
 	if (!truecolor) return `\n${WORDMARK.map((l) => `  ${l}`).join("\n")}\n`;
 	const mark = markLinesAnsi();
 	const word = [...WORDMARK];
@@ -1057,211 +1594,4 @@ function printFatalNotice(file, memory) {
 }
 
 //#endregion
-//#region src/profiling/profiler.ts
-/**
-* Opt-in session profiling. When SKYDIVE_PROFILE is set, an invocation
-* records everything needed to reconstruct what happened performance-wise —
-* designed so the whole directory can be handed to an agent (or a human)
-* and read without special tooling:
-*
-*   network.ndjson   every fetch: method, url, status, timing, content type
-*   state.ndjson     TUI state transitions (screen changes, store updates)
-*   commits.ndjson   React commits: which subtree rendered, when, how long
-*   render.ndjson    OpenTUI renderer samples: fps, frame times, cells drawn
-*   render.json      final renderer stats dump (full frame-time series)
-*   cpu-<pid>.cpuprofile  V8 CPU profile (Node-run commands only)
-*   meta-<pid>.json  argv, versions, runtime, exit code, wall time
-*
-* Every ndjson event carries a wall-clock `t` (epoch ms) and `pid`, so
-* records from the Node parent and the Bun-re-exec'd chat TUI land in the
-* same files and stay correlatable on one clock. The profile directory is
-* created by the first process and shared with children through
-* SKYDIVE_PROFILE_DIR (the chat re-exec inherits the environment).
-*
-* Inert unless SKYDIVE_PROFILE is set: no patched fetch, no subscriptions,
-* no inspector session.
-*/
-const ENV_FLAG = "SKYDIVE_PROFILE";
-const ENV_DIR = "SKYDIVE_PROFILE_DIR";
-let activeDir = null;
-let startedAtMs = 0;
-/**
-* Buffered event lines per stream, flushed asynchronously. Events are
-* appended to an in-memory buffer and written with fs.promises off the
-* hot path, so recording never blocks the TUI's event loop — high-rate
-* streams (React commits, renderer samples) stay cheap. Whatever is
-* still buffered when the process exits is drained synchronously in the
-* exit handler, where async I/O would never flush.
-*/
-const pendingLines = /* @__PURE__ */ new Map();
-let flushScheduled = false;
-let flushing = Promise.resolve();
-function drainBuffersSync() {
-	if (activeDir === null) return;
-	for (const [stream, lines] of pendingLines) {
-		if (lines.length === 0) continue;
-		pendingLines.set(stream, []);
-		try {
-			fs.appendFileSync(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
-		} catch (_error) {}
-	}
-}
-function scheduleFlush() {
-	if (flushScheduled || activeDir === null) return;
-	flushScheduled = true;
-	setTimeout(() => {
-		flushScheduled = false;
-		flushing = flushing.then(async () => {
-			if (activeDir === null) return;
-			for (const [stream, lines] of pendingLines) {
-				if (lines.length === 0) continue;
-				pendingLines.set(stream, []);
-				try {
-					await fs.promises.appendFile(path.join(activeDir, `${stream}.ndjson`), lines.join("\n") + "\n");
-				} catch (_error) {}
-			}
-		});
-	}, 100).unref?.();
-}
-function profilingEnabled() {
-	const v = process.env[ENV_FLAG];
-	return v !== void 0 && v !== "" && v !== "0";
-}
-function sanitizeToken(token) {
-	return token.replace(/[^a-zA-Z0-9_-]/g, "_").slice(0, 40);
-}
-/**
-* Appends one event to a stream file. Buffered and written asynchronously
-* so recording never blocks the event loop; the exit handler drains any
-* remainder synchronously so abrupt exits still keep their events.
-*/
-function record(stream, event) {
-	if (activeDir === null) return;
-	const line = JSON.stringify({
-		t: Date.now(),
-		pid: process.pid,
-		...event
-	});
-	const lines = pendingLines.get(stream);
-	if (lines === void 0) pendingLines.set(stream, [line]);
-	else lines.push(line);
-	scheduleFlush();
-}
-/** Writes a JSON artifact (non-append) into the profile directory. */
-function writeArtifact(name, data) {
-	if (activeDir === null) return;
-	try {
-		fs.writeFileSync(path.join(activeDir, name), JSON.stringify(data, null, 2));
-	} catch (_error) {}
-}
-/**
-* Patches globalThis.fetch to record request timing. A wrapper (not
-* undici's diagnostics_channel) because chat re-execs under Bun, where
-* fetch is Bun-native and undici events never fire; the wrapper behaves
-* identically in both runtimes.
-*/
-function installFetchRecorder() {
-	const original = globalThis.fetch;
-	const wrapped = async (...args) => {
-		const [input, init] = args;
-		const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-		const method = init?.method ?? (input instanceof Request ? input.method : "GET");
-		const started = Date.now();
-		try {
-			const res = await original(...args);
-			const contentType = res.headers.get("content-type") ?? "";
-			record("network", {
-				method,
-				url,
-				status: res.status,
-				durationMs: Date.now() - started,
-				contentType,
-				streamed: contentType.includes("text/event-stream")
-			});
-			return res;
-		} catch (err) {
-			record("network", {
-				method,
-				url,
-				status: 0,
-				durationMs: Date.now() - started,
-				error: err instanceof Error ? err.message : String(err)
-			});
-			throw err;
-		}
-	};
-	globalThis.fetch = Object.assign(wrapped, original);
-}
-function isBunRuntime() {
-	return typeof process !== "undefined" && "bun" in process.versions;
-}
-/**
-* Starts the V8 CPU profiler via node:inspector. Node-run commands only —
-* Bun does not implement the inspector Profiler domain, so the chat TUI
-* skips this artifact.
-*/
-function startCpuProfile() {
-	if (isBunRuntime()) return;
-	(async () => {
-		try {
-			const { Session } = await import("node:inspector/promises");
-			const session = new Session();
-			session.connect();
-			await session.post("Profiler.enable");
-			await session.post("Profiler.start");
-			process.once("beforeExit", () => {
-				(async () => {
-					try {
-						const { profile } = await session.post("Profiler.stop");
-						writeArtifact(`cpu-${process.pid}.cpuprofile`, profile);
-						session.disconnect();
-					} catch (_error) {}
-				})();
-			});
-		} catch (_error) {}
-	})();
-}
-/**
-* Activates profiling for this process if SKYDIVE_PROFILE is set. Creates
-* the profile directory (or joins the one a parent process created),
-* patches fetch, starts the CPU profiler, and registers the exit-time
-* meta dump. Call once, as early as possible.
-*/
-function maybeStartProfiling(argv, cliVersion) {
-	if (!profilingEnabled() || activeDir !== null) return;
-	const inherited = process.env[ENV_DIR];
-	if (inherited !== void 0 && inherited !== "") activeDir = inherited;
-	else {
-		const flagValue = process.env[ENV_FLAG] ?? "1";
-		const command = argv.find((a) => !a.startsWith("-")) ?? "chat";
-		const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").replace("T", "_").slice(0, 19);
-		activeDir = flagValue === "1" || flagValue.toLowerCase() === "true" ? path.resolve(process.cwd(), `skydive-profile-${sanitizeToken(command)}-${stamp}`) : path.resolve(process.cwd(), flagValue);
-		process.env[ENV_DIR] = activeDir;
-	}
-	try {
-		fs.mkdirSync(activeDir, { recursive: true });
-	} catch (_error) {
-		activeDir = null;
-		return;
-	}
-	startedAtMs = Date.now();
-	installFetchRecorder();
-	startCpuProfile();
-	process.on("exit", (code) => {
-		drainBuffersSync();
-		writeArtifact(`meta-${process.pid}.json`, {
-			argv,
-			cliVersion,
-			runtime: isBunRuntime() ? `bun ${process.versions["bun"]}` : `node ${process.version}`,
-			platform: process.platform,
-			pid: process.pid,
-			exitCode: code,
-			startedAt: new Date(startedAtMs).toISOString(),
-			wallTimeMs: Date.now() - startedAtMs
-		});
-		if (process.env[ENV_DIR] === activeDir && inherited === void 0) process.stderr.write(`\nprofile written to ${activeDir}\n`);
-	});
-}
-
-//#endregion
-export { ensureActiveOrganization as C, setActiveWorkspace as D, listWorkspaces as E, name as O, themesForMode as S, getSessionIdentity as T, themeForMode as _, installCrashHandler as a, themeVersion as b, MARK_CELLS as c, DEFAULT_THEME_ID as d, applyTheme as f, theme as g, noColorRequested as h, writeArtifact as i, version$1 as k, WORDMARK as l, monoTheme as m, profilingEnabled as n, buildCrashReport as o, findTheme as p, record as r, writeCrashReport as s, maybeStartProfiling as t, brandHelpArt as u, themeMode as v, getActiveWorkspaceId as w, themes as x, themeModeFromColorFgBg as y };
+export { installAgentAlias as A, resolveWorkspaceId as B, themeVersion as C, machineOsFromPlatform as D, buildImportSeedPrompt as E, detectShell as F, ensureActiveOrganization as I, getActiveWorkspaceId as L, takenAliasNames as M, SUPPORTED_SHELLS as N, aliasActivationHint as O, defaultInstallEnv as P, getSessionIdentity as R, themeModeFromColorFgBg as S, themesForMode as T, setActiveWorkspace as V, monoTheme as _, WORDMARK as a, themeForMode as b, getAutomaticLogsDir as c, profilingEnabled as d, record as f, findTheme as g, applyTheme as h, MARK_CELLS as i, slugifyAliasName as j, dedupeAliasName as k, maybeStartProfiling as l, DEFAULT_THEME_ID as m, buildCrashReport as n, brandHelpArt as o, writeArtifact as p, writeCrashReport as r, splashFitsWidth as s, installCrashHandler as t, profileDir as u, noColorRequested as v, themes as w, themeMode as x, theme as y, listWorkspaces as z };