@aragon-agent/cli 0.6.24 → 0.6.26

package/dist/proc/terminal-plan.js

@@ -0,0 +1,360 @@
+/**
+ * What a new terminal window looks like from the outside (tui-branch-terminal-shortcut
+ * 3.7).
+ *
+ * ASCII ONLY - `src/proc/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * PURE, AND THAT IS THE POINT. Three platforms, at least ten terminal emulators,
+ * four exec-argument conventions and Windows' three layers of parsing (we -> `cmd`
+ * -> `PowerShell`) all collapse into "what should we spawn, with which argv". A
+ * command body that called `spawn('cmd', ['/c','start', ...])` inline would bury
+ * the only testable part of this feature - the command line itself - inside
+ * untestable IO. `proc/readiness.ts` and `proc/classify.ts` set the same precedent
+ * inside this directory.
+ *
+ * WHY SESSION CODE MAY DEPEND ON THIS MODULE: it imports nothing from
+ * `node:child_process`, reads no configuration and creates no process. The single
+ * place a process is created stays in `session/branch-launch.ts`, so `proc/` keeps
+ * meaning "processes" and `session/` keeps meaning "sessions".
+ *
+ * EVERY RUNG CARRIES ITS OWN WORKING DIRECTORY (D-16 / D-23 / I-9). This is the
+ * one thing a reviewer will assume is free and is not: `spawn({ cwd })` decides the
+ * cwd of the process WE start, and for `wt -w 0 nt` (a new tab in an already
+ * running Windows Terminal) or `osascript` (a new Terminal.app window) that
+ * process merely forwards the request - the window opens in the terminal's own
+ * default directory. So `wt` passes `-d`, and both script rungs start with
+ * `cd <cwd> &&`. `--resume` does not restore a cwd, so a window that opens in the
+ * wrong place can never be corrected from inside the branch.
+ */
+import { statSync } from 'node:fs';
+import { isAbsolute, join } from 'node:path';
+/**
+ * The POSIX ladder (D-6), most-specific first.
+ *
+ * `--` TERMINATES THE EMULATOR'S OWN OPTION PARSING for `gnome-terminal`, `kitty`
+ * and `wezterm` (which spells it `start --`). Without it their parsers eat the
+ * `-c` that belongs to the shell we are starting, and the window opens with the
+ * emulator's own error instead of our command - the same class of defect the
+ * `wt` rung has (D-23 / R-16).
+ */
+const POSIX_CANDIDATES = Object.freeze([
+    { name: 'terminal-env', probe: '$TERMINAL', execArgs: ['-e'] },
+    { name: 'x-terminal-emulator', probe: 'x-terminal-emulator', execArgs: ['-e'] },
+    { name: 'gnome-terminal', probe: 'gnome-terminal', execArgs: ['--'] },
+    { name: 'konsole', probe: 'konsole', execArgs: ['-e'] },
+    { name: 'xfce4-terminal', probe: 'xfce4-terminal', execArgs: ['-x'] },
+    { name: 'kitty', probe: 'kitty', execArgs: ['--'] },
+    { name: 'wezterm', probe: 'wezterm', execArgs: ['start', '--'] },
+    { name: 'alacritty', probe: 'alacritty', execArgs: ['-e'] },
+    { name: 'xterm', probe: 'xterm', execArgs: ['-e'] },
+]);
+/** The env var that overrides the shell the new window runs (D-7). */
+export const ARAGON_BRANCH_SHELL_ENV = 'ARAGON_BRANCH_SHELL';
+/** `PowerShell` and `cmd` both stop being reliable far below the 32767 OS limit. */
+const BARE_POWER_SHELL_WORD_RE = /^[A-Za-z0-9._\\/:+=@-]+$/;
+/**
+ * Build the ladder for this platform, most-preferred rung first.
+ *
+ * The return value is a LIST because the failures this feature can actually hit
+ * are synchronous argument rejections (ENOENT on `wt.exe`, no X display), and a
+ * list lets `branch-launch.ts` walk down it without knowing anything about
+ * terminals. Rung COUNT is bounded by the caller (`BRANCH_TERMINAL_LIMITS.maxRungs`),
+ * so there is exactly one place that number lives.
+ */
+export function planTerminalLaunch(input) {
+    const isExecutable = input.isExecutable ?? defaultIsExecutable(input.platform, input.pathDirs);
+    const platform = normalizePlatform(input.platform);
+    if (platform === 'win32') {
+        return {
+            ok: true,
+            plans: windowsPlans(input, isExecutable),
+            shell: input.shell,
+            manual: input.manual,
+        };
+    }
+    const script = posixWindowScript(input.cwd, input.shell, input.command);
+    const plans = platform === 'darwin'
+        ? darwinPlans(isExecutable, script)
+        : posixPlans(input, isExecutable, script);
+    if (plans.length === 0) {
+        // NOT AN ERROR STATE TO APOLOGISE FOR (K-2): an SSH session or a container has
+        // no terminal emulator, and the honest answer - one pasteable command - is the
+        // whole reason the manual line exists (I-4).
+        return { ok: false, reason: 'no-launcher', shell: input.shell, manual: input.manual };
+    }
+    return { ok: true, plans, shell: input.shell, manual: input.manual };
+}
+function normalizePlatform(platform) {
+    if (platform === 'win32')
+        return 'win32';
+    if (platform === 'darwin')
+        return 'darwin';
+    return 'posix';
+}
+/**
+ * Windows: `wt` when we are demonstrably inside Windows Terminal, then `cmd`.
+ *
+ * THE `WT_SESSION` TEST IS NOT A CAPABILITY TEST, IT IS THE ONLY HONEST ONE WE
+ * HAVE. Probing for `wt.exe` proves the binary exists, not that a Windows Terminal
+ * is listening; `WT_SESSION` is set for every process a pane starts, so its
+ * presence is the one signal that a new tab will land somewhere.
+ */
+function windowsPlans(input, isExecutable) {
+    const plans = [];
+    const encoded = encodePowerShellCommand(powerShellScript(input.command));
+    const inWindowsTerminal = (input.env.WT_SESSION ?? '').length > 0;
+    if (inWindowsTerminal && isExecutable('wt.exe')) {
+        plans.push({
+            file: 'wt.exe',
+            // `-d` IS THE CWD (D-16). `-w 0` reuses the current window, `nt` opens a new
+            // tab, and `--` stops `wt` parsing the single-dash switches that belong to
+            // PowerShell. This failure is UNOBSERVABLE: `wt.exe` forwards the request and
+            // exits, so a rejected argument still produces a successful `'spawn'` event
+            // and the ladder cannot fall back (K-1 / D-23).
+            args: ['-w', '0', 'nt', '-d', input.cwd, '--title', input.title, '--', input.shell.path,
+                '-NoExit', '-EncodedCommand', encoded],
+            windowsVerbatimArguments: false,
+            rung: 'wt',
+        });
+    }
+    plans.push({
+        file: 'cmd.exe',
+        // `start`'s FIRST argument is the window title, and it must be present: an
+        // empty string is what most snippets use, but naming the window is how a user
+        // tells three branches apart in the taskbar (AC-1). The cwd needs no argument
+        // at all - `cmd.exe` inherits the cwd we pass to `spawn` (I-9).
+        args: ['/d', '/s', '/c', cmdStartLine(input.title, input.shell.path, encoded)],
+        windowsVerbatimArguments: true,
+        rung: 'cmd',
+    });
+    return plans;
+}
+/** `start "<title>" <shell> -NoExit -EncodedCommand <base64>`, one verbatim `cmd` line. */
+function cmdStartLine(title, shellPath, encoded) {
+    return `start ${quoteWin32Arg(title)} ${quoteWin32Arg(shellPath)}` +
+        ` -NoExit -EncodedCommand ${encoded}`;
+}
+/** macOS: Terminal.app via AppleScript; the script owns the cwd and the held-open shell. */
+function darwinPlans(isExecutable, script) {
+    // `osascript` IS PROBED, unlike `cmd.exe`. It lives at `/usr/bin/osascript` on
+    // every macOS install, so a failed probe means a broken PATH or a system without
+    // the tool - and in that case "no terminal could be opened here" plus a pasteable
+    // command is the honest answer (T-29), not a spawn that is certain to fail.
+    if (!isExecutable('osascript'))
+        return [];
+    return [{
+            file: 'osascript',
+            args: [
+                '-e',
+                `tell application "Terminal" to do script "${escapeAppleScriptText(script)}"`,
+                '-e',
+                'tell application "Terminal" to activate',
+            ],
+            windowsVerbatimArguments: false,
+            rung: 'osascript',
+        }];
+}
+/** Every POSIX candidate that exists, in ladder order. */
+function posixPlans(input, isExecutable, script) {
+    const plans = [];
+    for (const candidate of POSIX_CANDIDATES) {
+        const file = resolveCandidate(candidate, input.env);
+        if (file === null || !isExecutable(file))
+            continue;
+        plans.push({
+            file,
+            // The `cd` lives INSIDE the script, not in the emulator's argv: `-e` / `--` /
+            // `-x` conventions all pass the rest of the argv to the shell unchanged, so a
+            // script that starts with `cd` is correct for every rung - including rungs
+            // that do not exist yet (D-16 / D-23).
+            args: [...candidate.execArgs, input.shell.path, '-c', script],
+            windowsVerbatimArguments: false,
+            rung: candidate.name,
+        });
+    }
+    return plans;
+}
+/**
+ * The `$TERMINAL` escape hatch, with the D-7 trade-off spelled out: a value with
+ * spaces (`"/usr/bin/code --reuse-window"`) is used as ONE executable path and
+ * never split, because splitting needs a shell parser and a shell parser is what
+ * re-introduces the quoting problem. Not found means "skip this rung".
+ */
+function resolveCandidate(candidate, env) {
+    if (candidate.probe !== '$TERMINAL')
+        return candidate.probe;
+    const value = env.TERMINAL;
+    if (value === undefined || value.length === 0)
+        return null;
+    return value;
+}
+/**
+ * The window script, used verbatim by both the AppleScript payload and `-c`.
+ *
+ * `cd` FIRST, THEN THE COMMAND, THEN `exec <shell> -i`. The trailing `exec` keeps
+ * the window alive after `aragon` exits: the TUI writes its final transcript on
+ * exit (`ui/exit-snapshot.ts`), and a window that closes at that instant swallows
+ * the last screenful the user was about to read. `-c`, not `-lc` (R-15): a LOGIN
+ * shell sources `~/.bash_profile` / `~/.zprofile`, which can be slow, noisy, or
+ * PATH-changing, and holding the window open is already `exec ... -i`'s job.
+ */
+function posixWindowScript(cwd, shell, command) {
+    return `cd ${posixQuote(cwd)} && ${posixScript(command)} ; exec ${posixQuote(shell.path)} -i`;
+}
+/** PowerShell: the whole command as one base64(UTF-16LE) blob (D-20). */
+export function powerShellScript(parts) {
+    return parts.map(powerShellQuote).join(' ');
+}
+/** Bare words stay bare; everything else becomes a single-quoted literal. */
+export function powerShellQuote(value) {
+    if (BARE_POWER_SHELL_WORD_RE.test(value))
+        return value;
+    return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+ * `-EncodedCommand` takes base64 of UTF-16LE, which needs no shell quoting at all.
+ *
+ * The alphabet is `A-Za-z0-9+/=` - no spaces, no quotes, no `cmd` metacharacters -
+ * so the blob survives all three of Windows' parsers as an ordinary word. This is
+ * the same trick `ui/win-vt-force.ts` uses, for the same reason: encode the fragile
+ * thing into a form nothing can argue with, at construction time. Our command line
+ * necessarily contains spaced paths (`C:\Program Files\nodejs\node.exe`), so the
+ * fragile thing is not hypothetical.
+ */
+export function encodePowerShellCommand(script) {
+    return Buffer.from(script, 'utf16le').toString('base64');
+}
+/** POSIX single-quote escaping: `'` becomes `'\''`. */
+export function posixQuote(value) {
+    return `'${value.replace(/'/g, "'\\''")}'`;
+}
+export function posixScript(parts) {
+    return parts.map(posixQuote).join(' ');
+}
+/** AppleScript string literals only need `\` and `"` escaped. */
+export function escapeAppleScriptText(value) {
+    return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+}
+/**
+ * Win32 argv quoting for the `cmd` rung's title and shell path: quote when it
+ * contains whitespace, otherwise leave it alone.
+ *
+ * THE INPUT DOMAIN EXCLUDES `"` BY CONSTRUCTION (R-17/T-48): Windows paths cannot
+ * contain it, and the title is `aragon <id>` where an id is `[A-Za-z0-9._-]`. If a
+ * future source can contain a quote, this must switch to `cmd`'s rule (`""`) and
+ * not to the POSIX `\"` written here - the two are not interchangeable.
+ */
+export function quoteWin32Arg(value) {
+    return /\s/.test(value) ? `"${value}"` : value;
+}
+/** PATH entries for `name` probing: both spellings on Windows, `:` on POSIX. */
+export function pathDirsOf(env, platform) {
+    if (normalizePlatform(platform) === 'win32') {
+        // `Path` and `PATH` genuinely coexist in a Windows env object (Node copies what
+        // it was given), and reading only one of them is how a probe silently finds
+        // nothing. Both are read, in that order, deduplicated.
+        const dirs = [];
+        for (const key of ['Path', 'PATH']) {
+            const value = env[key];
+            if (value === undefined || value.length === 0)
+                continue;
+            for (const dir of value.split(';')) {
+                if (dir.length > 0 && !dirs.includes(dir))
+                    dirs.push(dir);
+            }
+        }
+        return dirs;
+    }
+    const value = env.PATH ?? '';
+    return value.split(':').filter((dir) => dir.length > 0);
+}
+/**
+ * The default probe: is this a file we could execute?
+ *
+ * An absolute or separator-bearing value is stat'd directly (that is the
+ * `ARAGON_BRANCH_SHELL=/usr/local/bin/fish` case); a bare name is looked up in the
+ * PATH directories, trying `name` and - on Windows - `name + '.exe'`, because a
+ * user typing `pwsh` and a probe looking for `pwsh.exe` are the same request.
+ *
+ * EVERY EXCEPTION RETURNS FALSE: one failed stat means "this candidate is not
+ * here", not "the feature is broken", and a missing terminal must degrade to the
+ * manual command rather than throw out of a key handler.
+ */
+export function defaultIsExecutable(platform, pathDirs) {
+    const windows = normalizePlatform(platform) === 'win32';
+    const dirs = pathDirs ?? pathDirsOf(process.env, platform);
+    return (name) => {
+        if (name.length === 0)
+            return false;
+        const suffixes = windows && !/\.exe$/i.test(name) ? [name, `${name}.exe`] : [name];
+        if (isAbsolute(name) || /[\\/]/.test(name)) {
+            return suffixes.some((suffix) => isFile(suffix));
+        }
+        return dirs.some((dir) => suffixes.some((suffix) => isFile(join(dir, suffix))));
+    };
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Which shell the new window runs (D-7), first match wins.
+ *
+ * The requirement says "PowerShell / bash", and both platforms have two answers
+ * worth distinguishing: PowerShell 7 (`pwsh.exe`) when the user installed it,
+ * Windows PowerShell 5.1 otherwise; `$SHELL` when the user's login shell is not
+ * bash, then bash, then `/bin/sh` as the one path that exists everywhere.
+ * `ARAGON_BRANCH_SHELL` is the escape hatch - an ENV VALUE, not a config key
+ * (D-17): a "Ctrl+L opens no terminal" switch would create the one state this
+ * feature must never have.
+ */
+export function resolveShell(input) {
+    // `pathDirs` is FORWARDED, not dropped: a caller that supplies its own PATH
+    // (a test, or `branch-launch.ts` with the injected env) must not have the shell
+    // probe silently fall back to `process.env`'s PATH.
+    const isExecutable = input.isExecutable ?? defaultIsExecutable(input.platform, input.pathDirs);
+    const override = input.env[ARAGON_BRANCH_SHELL_ENV];
+    const platform = normalizePlatform(input.platform);
+    if (platform === 'win32') {
+        if (override !== undefined && override.length > 0 && isExecutable(override)) {
+            return { path: override, kind: 'powershell' };
+        }
+        if (isExecutable('pwsh.exe'))
+            return { path: 'pwsh.exe', kind: 'powershell' };
+        return { path: 'powershell.exe', kind: 'powershell' };
+    }
+    if (override !== undefined && override.length > 0) {
+        return { path: override, kind: 'posix' };
+    }
+    const loginShell = input.env.SHELL;
+    if (loginShell !== undefined && isAbsolute(loginShell)) {
+        return { path: loginShell, kind: 'posix' };
+    }
+    if (isExecutable('bash'))
+        return { path: 'bash', kind: 'posix' };
+    return { path: '/bin/sh', kind: 'posix' };
+}
+/**
+ * Fit a window title into `maxCells` columns (R-7 / T-47).
+ *
+ * THE TITLE IS THE ONLY THING THIS TOUCHES. An id can be 64 characters long, so
+ * `aragon <id>` exceeds the 60-cell budget by construction for the longest ids -
+ * and truncating the id anywhere else (the command line, `--resume`) would produce
+ * a branch that cannot find its own parent. Code points, not bytes: the title is
+ * ASCII today, and a future non-ASCII title must not be cut through a surrogate
+ * pair.
+ */
+export function truncateTitle(title, maxCells) {
+    const chars = Array.from(title);
+    // A budget that is not a usable number is a caller bug, not a reason to destroy
+    // the title: clamping to one character would be silently worse than not cutting.
+    if (!Number.isFinite(maxCells) || maxCells < 1)
+        return title;
+    if (chars.length <= maxCells)
+        return title;
+    return chars.slice(0, Math.floor(maxCells)).join('');
+}

package/dist/session/branch-invocation.d.ts

@@ -0,0 +1,83 @@
+/**
+ * What command the new terminal runs (tui-branch-terminal-shortcut 3.4).
+ *
+ * ASCII ONLY - `src/session/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THIS MODULE HAS NO IO ON PURPOSE. It answers two questions and nothing else:
+ * "which argv pieces make up the aragon command" and "how does that sentence read
+ * when printed to a human". Spawning lives in `session/branch-launch.ts`, and the
+ * terminal ladder lives in `proc/terminal-plan.ts`, so the one part of this
+ * feature that a unit test can pin exactly - the command line - is not buried
+ * inside an `spawn()` call. The repository already draws the boundary this way:
+ * `proc/readiness.ts` and `proc/classify.ts` are pure, `proc/supervisor.ts` is the
+ * part that touches processes.
+ *
+ * NAMED `branch-invocation`, NOT `branch-command` (R-22): `commands/branch-command.ts`
+ * is the command body, and two files with one basename make every import, stack
+ * trace and grep ambiguous. What this module exports is an *invocation*.
+ */
+/** Which of the three resolution rules produced the command (D-8). */
+export type AragonCommandKind = 'override' | 'script' | 'bin';
+export interface AragonCommandResolution {
+    /** argv pieces, ready to hand to a shell or a terminal emulator. */
+    parts: string[];
+    kind: AragonCommandKind;
+    /** Human-readable note for the log and the error copy. Never part of the command. */
+    origin: string;
+}
+export interface BranchInvocation {
+    /** `[...aragon.parts, '--resume', id]`. */
+    parts: string[];
+    /** One line, pasteable into cmd / PowerShell / sh (quoted where needed). */
+    command: string;
+}
+export declare const BRANCH_RESUME_FLAG = "--resume";
+/** The env var that overrides "what executable the new window runs" (D-7 sibling). */
+export declare const ARAGON_BRANCH_COMMAND_ENV = "ARAGON_BRANCH_COMMAND";
+/**
+ * Decide what to execute in the new window (D-8), first match wins.
+ *
+ * The precedence exists because `aragon` is NOT on PATH in three of this
+ * repository's own four ways of running: `npm run dev:cli`, `npx
+ * @aragon-agent/cli`, and `node packages/cli/dist/cli.js`. Rule 2 recovers all
+ * three from `process.execPath` + `process.argv[1]` without consulting PATH at
+ * all, which is the only way "press the key and something starts" holds on a
+ * machine where the global install is missing.
+ *
+ * The override is treated as ONE executable path and never split into arguments:
+ * splitting needs a shell parser, and a shell parser is what re-introduces the
+ * quoting problem this feature spends a whole module avoiding. The documented
+ * escape hatch is a `.cmd` / `.sh` wrapper.
+ */
+export declare function resolveAragonCommand(input: {
+    argv: readonly string[];
+    execPath: string;
+    env: Record<string, string | undefined>;
+}): AragonCommandResolution;
+/** `parts` + `--resume <id>`, plus the one-line form for toasts and manual fallback. */
+export declare function buildResumeInvocation(input: {
+    id: string;
+    aragon: AragonCommandResolution;
+}): BranchInvocation;
+/**
+ * Join argv pieces into one line a human can paste into any of the three shells.
+ *
+ * NOT A SHELL ESCAPER. This text goes to the toast, to the notice and to the
+ * README, never back through a parser: the three platforms agree on what double
+ * quotes mean around a path with spaces, and that is the whole requirement. The
+ * real command lines are built by `proc/terminal-plan.ts`, which quotes for the
+ * exact parser each rung lands in.
+ */
+export declare function joinCommandLine(parts: readonly string[]): string;
+/**
+ * The second gate on D-9: an id is about to be concatenated into a command line.
+ *
+ * The command body checks first (it owns the user-facing sentence). This check
+ * exists because a future caller can go straight to `buildResumeInvocation`, and
+ * the injection defence belongs at the boundary that builds the string rather
+ * than at the one call site that happens to exist today.
+ *
+ * Returns `null` when the id is usable, otherwise one sentence naming the actual
+ * value (`<= 64 characters`, first 24 of it) so the user can see what was wrong.
+ */
+export declare function validateBranchId(id: string): string | null;

package/dist/session/branch-invocation.js

@@ -0,0 +1,109 @@
+/**
+ * What command the new terminal runs (tui-branch-terminal-shortcut 3.4).
+ *
+ * ASCII ONLY - `src/session/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * THIS MODULE HAS NO IO ON PURPOSE. It answers two questions and nothing else:
+ * "which argv pieces make up the aragon command" and "how does that sentence read
+ * when printed to a human". Spawning lives in `session/branch-launch.ts`, and the
+ * terminal ladder lives in `proc/terminal-plan.ts`, so the one part of this
+ * feature that a unit test can pin exactly - the command line - is not buried
+ * inside an `spawn()` call. The repository already draws the boundary this way:
+ * `proc/readiness.ts` and `proc/classify.ts` are pure, `proc/supervisor.ts` is the
+ * part that touches processes.
+ *
+ * NAMED `branch-invocation`, NOT `branch-command` (R-22): `commands/branch-command.ts`
+ * is the command body, and two files with one basename make every import, stack
+ * trace and grep ambiguous. What this module exports is an *invocation*.
+ */
+import { isAbsolute } from 'node:path';
+import { isValidSessionId } from './store.js';
+export const BRANCH_RESUME_FLAG = '--resume';
+/** The env var that overrides "what executable the new window runs" (D-7 sibling). */
+export const ARAGON_BRANCH_COMMAND_ENV = 'ARAGON_BRANCH_COMMAND';
+/** Longest prefix of a rejected id that reaches the user's screen. */
+const REJECTED_ID_PREVIEW_CELLS = 24;
+/**
+ * A path that could be a script we are already running (`node <script.js>`).
+ *
+ * Anchored and case-insensitive: Windows writes `.JS` in the wild, and an
+ * unanchored variant would also match `cli.js.bak` - which is not something node
+ * could have been invoked with.
+ */
+const SCRIPT_PATH_RE = /\.(?:js|cjs|mjs)$/i;
+/**
+ * Decide what to execute in the new window (D-8), first match wins.
+ *
+ * The precedence exists because `aragon` is NOT on PATH in three of this
+ * repository's own four ways of running: `npm run dev:cli`, `npx
+ * @aragon-agent/cli`, and `node packages/cli/dist/cli.js`. Rule 2 recovers all
+ * three from `process.execPath` + `process.argv[1]` without consulting PATH at
+ * all, which is the only way "press the key and something starts" holds on a
+ * machine where the global install is missing.
+ *
+ * The override is treated as ONE executable path and never split into arguments:
+ * splitting needs a shell parser, and a shell parser is what re-introduces the
+ * quoting problem this feature spends a whole module avoiding. The documented
+ * escape hatch is a `.cmd` / `.sh` wrapper.
+ */
+export function resolveAragonCommand(input) {
+    const override = input.env[ARAGON_BRANCH_COMMAND_ENV];
+    if (override !== undefined && override.length > 0) {
+        return {
+            parts: [override],
+            kind: 'override',
+            origin: `${ARAGON_BRANCH_COMMAND_ENV}=${override}`,
+        };
+    }
+    const script = input.argv[1];
+    if (script !== undefined && isAbsolute(script) && SCRIPT_PATH_RE.test(script)) {
+        return {
+            parts: [input.execPath, script],
+            kind: 'script',
+            origin: 'process.execPath + process.argv[1]',
+        };
+    }
+    return { parts: ['aragon'], kind: 'bin', origin: 'aragon on PATH' };
+}
+/** `parts` + `--resume <id>`, plus the one-line form for toasts and manual fallback. */
+export function buildResumeInvocation(input) {
+    const parts = [...input.aragon.parts, BRANCH_RESUME_FLAG, input.id];
+    return { parts, command: joinCommandLine(parts) };
+}
+/**
+ * Join argv pieces into one line a human can paste into any of the three shells.
+ *
+ * NOT A SHELL ESCAPER. This text goes to the toast, to the notice and to the
+ * README, never back through a parser: the three platforms agree on what double
+ * quotes mean around a path with spaces, and that is the whole requirement. The
+ * real command lines are built by `proc/terminal-plan.ts`, which quotes for the
+ * exact parser each rung lands in.
+ */
+export function joinCommandLine(parts) {
+    return parts.map(quoteForDisplay).join(' ');
+}
+/** Empty and whitespace-or-quote-bearing pieces get double quotes; the rest stay bare. */
+function quoteForDisplay(part) {
+    if (part.length === 0)
+        return '""';
+    if (!/[\s"]/.test(part))
+        return part;
+    return `"${part.replace(/"/g, '\\"')}"`;
+}
+/**
+ * The second gate on D-9: an id is about to be concatenated into a command line.
+ *
+ * The command body checks first (it owns the user-facing sentence). This check
+ * exists because a future caller can go straight to `buildResumeInvocation`, and
+ * the injection defence belongs at the boundary that builds the string rather
+ * than at the one call site that happens to exist today.
+ *
+ * Returns `null` when the id is usable, otherwise one sentence naming the actual
+ * value (`<= 64 characters`, first 24 of it) so the user can see what was wrong.
+ */
+export function validateBranchId(id) {
+    if (isValidSessionId(id))
+        return null;
+    const preview = id.slice(0, REJECTED_ID_PREVIEW_CELLS);
+    return `Session id "${preview}" is not a legal file name, so it cannot be resumed.`;
+}

package/dist/session/branch-launch.d.ts

@@ -0,0 +1,70 @@
+/**
+ * The `/branch` port: flush, plan, spawn (tui-branch-terminal-shortcut 3.6).
+ *
+ * ASCII ONLY - `src/session/**` is inside `glyphs.test.ts::inScope`.
+ *
+ * ORDER IS CORRECTNESS (I-1). The child process's first act is to read the parent
+ * session file, and the parent's checkpoint is debounced and fingerprint-
+ * short-circuited (`checkpoint.ts`). Spawning before a successful FORCED write
+ * means the branch can read the previous turn - or, after `aragon sessions rm
+ * <id>`, no file at all - and the user sees "the branch opened but lost the last
+ * ten turns". That is a data defect, not a UX one, so `checkpoint({force:true})`
+ * returns `ok` before any terminal is created.
+ *
+ * THE CHILD IS NOT A SERVICE (D-5 / I-3): `detached: true`, `stdio: 'ignore'`,
+ * `unref()`, and deliberately no `ProcSupervisor` registration. Registering it
+ * would make the parent's exit kill a session running in another window.
+ *
+ * EVERY FAILURE CARRIES A PASTEABLE COMMAND (I-4). "Could not open a terminal" is
+ * a dead end; `aragon --resume a4k2m9` is 22 characters the user can always use.
+ */
+import { spawn } from 'node:child_process';
+import { type ScopedLogger } from '../logging/logger.js';
+import { type BranchCommandPort } from '../commands/branch-command.js';
+export interface BranchRequest {
+    id: string;
+    cwd: string;
+    /** Late `'error'` events after the window opened (I-10). */
+    onLateError?: (message: string) => void;
+}
+export type BranchOpenResult = {
+    ok: true;
+    command: string;
+    shell: string;
+    rung: string;
+} | {
+    ok: false;
+    reason: 'cooldown' | 'checkpoint-failed' | 'no-launcher' | 'spawn-failed';
+    /**
+     * A complete, user-facing sentence - never an internal reason code.
+     * `checkpoint-failed` in particular has two very different causes
+     * (`not-sendable` vs `no-identity`), and only the launcher knows which one it
+     * hit, so the sentence is composed HERE from `BRANCH_COPY`.
+     */
+    message: string;
+    /** Always present, so no failure is a dead end (I-4). */
+    command: string;
+    retryInMs?: number;
+};
+export interface BranchLauncherDeps {
+    /** Injected by `cli.tsx`: a thin wrapper over `checkpointWriter.writeNow`, with `force`. */
+    checkpoint(opts: {
+        force: true;
+    }): {
+        ok: boolean;
+        message?: string;
+    };
+    platform: NodeJS.Platform;
+    env: Record<string, string | undefined>;
+    argv: readonly string[];
+    execPath: string;
+    spawn?: typeof spawn;
+    isExecutable?: (name: string) => boolean;
+    now?: () => number;
+    logger?: ScopedLogger;
+}
+/**
+ * Build the port. The only mutable state is this closure's four values, none of
+ * which outlives the process (no persistence, 6 in the spec).
+ */
+export declare function createBranchLauncher(deps: BranchLauncherDeps): BranchCommandPort;