@os-eco/overstory-cli 0.6.1

package/src/commands/sling.ts

@@ -0,0 +1,661 @@
+/**
+ * CLI command: overstory sling <task-id>
+ *
+ * CRITICAL PATH. Orchestrates a full agent spawn:
+ * 1. Load config + manifest
+ * 2. Validate (depth limit, hierarchy)
+ * 3. Load manifest + validate capability
+ * 4. Resolve or create run_id (current-run.txt)
+ * 5. Check name uniqueness + concurrency limit
+ * 6. Validate bead exists
+ * 7. Create worktree
+ * 8. Generate + write overlay CLAUDE.md
+ * 9. Deploy hooks config
+ * 10. Claim beads issue
+ * 11. Create agent identity
+ * 12. Create tmux session running claude
+ * 13. Record session in SessionStore + increment run agent count
+ * 14. Return AgentSession
+ */
+
+import { mkdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import { deployHooks } from "../agents/hooks-deployer.ts";
+import { createIdentity, loadIdentity } from "../agents/identity.ts";
+import { createManifestLoader, resolveModel } from "../agents/manifest.ts";
+import { writeOverlay } from "../agents/overlay.ts";
+import { loadConfig } from "../config.ts";
+import { AgentError, HierarchyError, ValidationError } from "../errors.ts";
+import { inferDomain } from "../insights/analyzer.ts";
+import { createMulchClient } from "../mulch/client.ts";
+import { openSessionStore } from "../sessions/compat.ts";
+import { createRunStore } from "../sessions/store.ts";
+import type { TrackerIssue } from "../tracker/factory.ts";
+import { createTrackerClient, resolveBackend, trackerCliName } from "../tracker/factory.ts";
+import type { AgentSession, OverlayConfig } from "../types.ts";
+import { createWorktree } from "../worktree/manager.ts";
+import { createSession, sendKeys, waitForTuiReady } from "../worktree/tmux.ts";
+
+/**
+ * Calculate how many milliseconds to sleep before spawning a new agent,
+ * based on the configured stagger delay and when the most recent active
+ * session was started.
+ *
+ * Returns 0 if no sleep is needed (no active sessions, delay is 0, or
+ * enough time has already elapsed).
+ *
+ * @param staggerDelayMs - The configured minimum delay between spawns
+ * @param activeSessions - Currently active (non-zombie) sessions
+ * @param now - Current timestamp in ms (defaults to Date.now(), injectable for testing)
+ */
+export function calculateStaggerDelay(
+	staggerDelayMs: number,
+	activeSessions: ReadonlyArray<{ startedAt: string }>,
+	now: number = Date.now(),
+): number {
+	if (staggerDelayMs <= 0 || activeSessions.length === 0) {
+		return 0;
+	}
+
+	const mostRecent = activeSessions.reduce((latest, s) => {
+		return new Date(s.startedAt).getTime() > new Date(latest.startedAt).getTime() ? s : latest;
+	});
+	const elapsed = now - new Date(mostRecent.startedAt).getTime();
+	const remaining = staggerDelayMs - elapsed;
+	return remaining > 0 ? remaining : 0;
+}
+
+/**
+ * Check if the current process is running as root (UID 0).
+ * Returns true if running as root, false otherwise.
+ * Returns false on platforms that don't support getuid (e.g., Windows).
+ *
+ * The getuid parameter is injectable for testability without mocking process.getuid.
+ */
+export function isRunningAsRoot(getuid: (() => number) | undefined = process.getuid): boolean {
+	return getuid?.() === 0;
+}
+
+/**
+ * Infer mulch domains from a list of file paths.
+ * Returns unique domains sorted alphabetically, falling back to
+ * configured defaults if no domains could be inferred.
+ */
+export function inferDomainsFromFiles(
+	files: readonly string[],
+	configDomains: readonly string[],
+): string[] {
+	const inferred = new Set<string>();
+	for (const file of files) {
+		const domain = inferDomain(file);
+		if (domain !== null) {
+			inferred.add(domain);
+		}
+	}
+	if (inferred.size === 0) {
+		return [...configDomains];
+	}
+	return [...inferred].sort();
+}
+
+/**
+ * Parse a named flag value from an args array.
+ */
+function getFlag(args: string[], flag: string): string | undefined {
+	const idx = args.indexOf(flag);
+	if (idx === -1 || idx + 1 >= args.length) {
+		return undefined;
+	}
+	return args[idx + 1];
+}
+
+/**
+ * Options for building the structured startup beacon.
+ */
+export interface BeaconOptions {
+	agentName: string;
+	capability: string;
+	taskId: string;
+	parentAgent: string | null;
+	depth: number;
+}
+
+/**
+ * Build a structured startup beacon for an agent.
+ *
+ * The beacon is the first user message sent to a Claude Code agent via
+ * tmux send-keys. It provides identity context and a numbered startup
+ * protocol so the agent knows exactly what to do on boot.
+ *
+ * Format:
+ *   [OVERSTORY] <agent-name> (<capability>) <ISO timestamp> task:<bead-id>
+ *   Depth: <n> | Parent: <parent-name|none>
+ *   Startup protocol:
+ *   1. Read your assignment in .claude/CLAUDE.md
+ *   2. Load expertise: mulch prime
+ *   3. Check mail: overstory mail check --agent <name>
+ *   4. Begin working on task <bead-id>
+ */
+export function buildBeacon(opts: BeaconOptions): string {
+	const timestamp = new Date().toISOString();
+	const parent = opts.parentAgent ?? "none";
+	const parts = [
+		`[OVERSTORY] ${opts.agentName} (${opts.capability}) ${timestamp} task:${opts.taskId}`,
+		`Depth: ${opts.depth} | Parent: ${parent}`,
+		`Startup: read .claude/CLAUDE.md, run mulch prime, check mail (overstory mail check --agent ${opts.agentName}), then begin task ${opts.taskId}`,
+	];
+	return parts.join(" — ");
+}
+
+/**
+ * Check if a parent agent has spawned any scouts.
+ * Returns true if the parent has at least one scout child in the session history.
+ */
+export function parentHasScouts(
+	sessions: ReadonlyArray<{ parentAgent: string | null; capability: string }>,
+	parentAgent: string,
+): boolean {
+	return sessions.some((s) => s.parentAgent === parentAgent && s.capability === "scout");
+}
+
+/**
+ * Check if any active agent is already working on the given bead ID.
+ * Returns the agent name if locked, or null if the bead is free.
+ *
+ * @param activeSessions - Currently active (non-zombie) sessions
+ * @param beadId - The bead task ID to check for concurrent work
+ */
+export function checkBeadLock(
+	activeSessions: ReadonlyArray<{ agentName: string; beadId: string }>,
+	beadId: string,
+): string | null {
+	const existing = activeSessions.find((s) => s.beadId === beadId);
+	return existing?.agentName ?? null;
+}
+
+/**
+ * Check if spawning another agent would exceed the per-run session limit.
+ * Returns true if the limit is reached. A limit of 0 means unlimited.
+ *
+ * @param maxSessionsPerRun - Config limit (0 = unlimited)
+ * @param currentRunAgentCount - Number of agents already spawned in this run
+ */
+export function checkRunSessionLimit(
+	maxSessionsPerRun: number,
+	currentRunAgentCount: number,
+): boolean {
+	if (maxSessionsPerRun <= 0) return false;
+	return currentRunAgentCount >= maxSessionsPerRun;
+}
+
+/**
+ * Validate hierarchy constraints: the coordinator (no parent) may only spawn leads.
+ *
+ * When parentAgent is null, the caller is the coordinator or a human.
+ * Only "lead" capability is allowed in that case. All other capabilities
+ * (builder, scout, reviewer, merger) must be spawned by a lead or supervisor
+ * that passes --parent.
+ *
+ * @param parentAgent - The --parent flag value (null = coordinator/human)
+ * @param capability - The requested agent capability
+ * @param name - The agent name (for error context)
+ * @param depth - The requested hierarchy depth
+ * @param forceHierarchy - If true, bypass the check (for debugging)
+ * @throws HierarchyError if the constraint is violated
+ */
+export function validateHierarchy(
+	parentAgent: string | null,
+	capability: string,
+	name: string,
+	_depth: number,
+	forceHierarchy: boolean,
+): void {
+	if (forceHierarchy) {
+		return;
+	}
+
+	if (parentAgent === null && capability !== "lead") {
+		throw new HierarchyError(
+			`Coordinator cannot spawn "${capability}" directly. Only "lead" is allowed without --parent. Use a lead as intermediary, or pass --force-hierarchy to bypass.`,
+			{ agentName: name, requestedCapability: capability },
+		);
+	}
+}
+
+/**
+ * Entry point for `overstory sling <task-id> [flags]`.
+ *
+ * Flags:
+ *   --capability <type>    builder | scout | reviewer | lead | merger
+ *   --name <name>          Unique agent name
+ *   --spec <path>          Path to task spec file
+ *   --files <f1,f2,...>    Exclusive file scope
+ *   --parent <agent-name>  Parent agent (for hierarchy tracking)
+ *   --depth <n>            Current hierarchy depth (default 0)
+ *   --force-hierarchy      Bypass hierarchy validation (debugging only)
+ */
+const SLING_HELP = `overstory sling — Spawn a worker agent
+
+Usage: overstory sling <task-id> [flags]
+
+Arguments:
+  <task-id>                  Beads task ID to assign
+
+Options:
+  --capability <type>        Agent type: builder | scout | reviewer | lead | merger (default: builder)
+  --name <name>              Unique agent name (required)
+  --spec <path>              Path to task spec file
+  --files <f1,f2,...>        Exclusive file scope (comma-separated)
+  --parent <agent-name>      Parent agent for hierarchy tracking
+  --depth <n>                Current hierarchy depth (default: 0)
+  --skip-scout                 Skip scout phase for lead agents (jump to build)
+  --skip-task-check              Skip task existence validation (for worktree-created issues)
+  --force-hierarchy            Bypass hierarchy validation (debugging only)
+  --json                     Output result as JSON
+  --help, -h                 Show this help`;
+
+export async function slingCommand(args: string[]): Promise<void> {
+	if (args.includes("--help") || args.includes("-h")) {
+		process.stdout.write(`${SLING_HELP}\n`);
+		return;
+	}
+
+	const taskId = args.find((a) => !a.startsWith("--"));
+	if (!taskId) {
+		throw new ValidationError("Task ID is required: overstory sling <task-id>", {
+			field: "taskId",
+		});
+	}
+
+	const capability = getFlag(args, "--capability") ?? "builder";
+	const name = getFlag(args, "--name");
+	const specPath = getFlag(args, "--spec") ?? null;
+	const filesRaw = getFlag(args, "--files");
+	const parentAgent = getFlag(args, "--parent") ?? null;
+	const depthStr = getFlag(args, "--depth");
+	const depth = depthStr !== undefined ? Number.parseInt(depthStr, 10) : 0;
+	const forceHierarchy = args.includes("--force-hierarchy");
+	const skipScout = args.includes("--skip-scout");
+	const skipTaskCheck = args.includes("--skip-task-check");
+
+	if (!name || name.trim().length === 0) {
+		throw new ValidationError("--name is required for sling", { field: "name" });
+	}
+
+	if (Number.isNaN(depth) || depth < 0) {
+		throw new ValidationError("--depth must be a non-negative integer", {
+			field: "depth",
+			value: depthStr,
+		});
+	}
+
+	if (isRunningAsRoot()) {
+		throw new AgentError(
+			"Cannot spawn agents as root (UID 0). The claude CLI rejects --dangerously-skip-permissions when run as root, causing the tmux session to die immediately. Run overstory as a non-root user.",
+			{ agentName: name },
+		);
+	}
+
+	// Warn if --skip-scout is used for a non-lead capability (harmless but confusing)
+	if (skipScout && capability !== "lead") {
+		process.stderr.write(
+			`⚠️  Warning: --skip-scout is only meaningful for leads. Ignoring for "${capability}" agent "${name}".\n`,
+		);
+	}
+
+	if (skipTaskCheck && !parentAgent) {
+		process.stderr.write(
+			`Warning: --skip-task-check without --parent is unusual. This flag is designed for leads spawning builders with worktree-created issues.\n`,
+		);
+	}
+
+	// Validate that spec file exists if provided, and resolve to absolute path
+	// so agents in worktrees can access it (worktrees don't have .overstory/)
+	let absoluteSpecPath: string | null = null;
+	if (specPath !== null) {
+		absoluteSpecPath = resolve(specPath);
+		const specFile = Bun.file(absoluteSpecPath);
+		const specExists = await specFile.exists();
+		if (!specExists) {
+			throw new ValidationError(`Spec file not found: ${specPath}`, {
+				field: "spec",
+				value: specPath,
+			});
+		}
+	}
+
+	const fileScope = filesRaw
+		? filesRaw
+				.split(",")
+				.map((f) => f.trim())
+				.filter((f) => f.length > 0)
+		: [];
+
+	// 1. Load config
+	const cwd = process.cwd();
+	const config = await loadConfig(cwd);
+	const resolvedBackend = await resolveBackend(config.taskTracker.backend, config.project.root);
+
+	// 2. Validate depth limit
+	// Hierarchy: orchestrator(0) -> lead(1) -> specialist(2)
+	// With maxDepth=2, depth=2 is the deepest allowed leaf, so reject only depth > maxDepth
+	if (depth > config.agents.maxDepth) {
+		throw new AgentError(
+			`Depth limit exceeded: depth ${depth} > maxDepth ${config.agents.maxDepth}`,
+			{ agentName: name },
+		);
+	}
+
+	// 2b. Validate hierarchy: coordinator (no --parent) can only spawn leads
+	validateHierarchy(parentAgent, capability, name, depth, forceHierarchy);
+
+	// 3. Load manifest and validate capability
+	const manifestLoader = createManifestLoader(
+		join(config.project.root, config.agents.manifestPath),
+		join(config.project.root, config.agents.baseDir),
+	);
+	const manifest = await manifestLoader.load();
+
+	const agentDef = manifest.agents[capability];
+	if (!agentDef) {
+		throw new AgentError(
+			`Unknown capability "${capability}". Available: ${Object.keys(manifest.agents).join(", ")}`,
+			{ agentName: name, capability },
+		);
+	}
+
+	// 4. Resolve or create run_id for this spawn
+	const overstoryDir = join(config.project.root, ".overstory");
+	const currentRunPath = join(overstoryDir, "current-run.txt");
+	let runId: string;
+
+	const currentRunFile = Bun.file(currentRunPath);
+	if (await currentRunFile.exists()) {
+		runId = (await currentRunFile.text()).trim();
+	} else {
+		runId = `run-${new Date().toISOString().replace(/[:.]/g, "-")}`;
+		const runStore = createRunStore(join(overstoryDir, "sessions.db"));
+		try {
+			runStore.createRun({
+				id: runId,
+				startedAt: new Date().toISOString(),
+				coordinatorSessionId: null,
+				status: "active",
+			});
+		} finally {
+			runStore.close();
+		}
+		await Bun.write(currentRunPath, runId);
+	}
+
+	// 4b. Check per-run session limit
+	if (config.agents.maxSessionsPerRun > 0) {
+		const runCheckStore = createRunStore(join(overstoryDir, "sessions.db"));
+		try {
+			const run = runCheckStore.getRun(runId);
+			if (run && checkRunSessionLimit(config.agents.maxSessionsPerRun, run.agentCount)) {
+				throw new AgentError(
+					`Run session limit reached: ${run.agentCount}/${config.agents.maxSessionsPerRun} agents spawned in run "${runId}". ` +
+						`Increase agents.maxSessionsPerRun in config.yaml or start a new run.`,
+					{ agentName: name },
+				);
+			}
+		} finally {
+			runCheckStore.close();
+		}
+	}
+
+	// 5. Check name uniqueness and concurrency limit against active sessions
+	const { store } = openSessionStore(overstoryDir);
+	try {
+		const activeSessions = store.getActive();
+		if (activeSessions.length >= config.agents.maxConcurrent) {
+			throw new AgentError(
+				`Max concurrent agent limit reached: ${activeSessions.length}/${config.agents.maxConcurrent} active agents`,
+				{ agentName: name },
+			);
+		}
+
+		const existing = store.getByName(name);
+		if (existing && existing.state !== "zombie" && existing.state !== "completed") {
+			throw new AgentError(`Agent name "${name}" is already in use (state: ${existing.state})`, {
+				agentName: name,
+			});
+		}
+
+		// 5d. Bead-level locking: prevent concurrent agents on the same bead ID.
+		// Exception: the parent agent may delegate its own task to a child.
+		const lockHolder = checkBeadLock(activeSessions, taskId);
+		if (lockHolder !== null && lockHolder !== parentAgent) {
+			throw new AgentError(
+				`Bead "${taskId}" is already being worked by agent "${lockHolder}". ` +
+					`Concurrent work on the same bead causes duplicate issues and wasted tokens.`,
+				{ agentName: name },
+			);
+		}
+
+		// 5b. Enforce stagger delay between agent spawns
+		const staggerMs = calculateStaggerDelay(config.agents.staggerDelayMs, activeSessions);
+		if (staggerMs > 0) {
+			await Bun.sleep(staggerMs);
+		}
+
+		// 5c. Structural enforcement: warn when a lead spawns a builder without prior scouts.
+		// This is a non-blocking warning — it does not prevent the spawn, but surfaces
+		// the scout-skip pattern so agents and operators can see it happening.
+		if (capability === "builder" && parentAgent && !parentHasScouts(store.getAll(), parentAgent)) {
+			process.stderr.write(
+				`⚠️  Warning: "${parentAgent}" is spawning builder "${name}" without having spawned any scouts.\n`,
+			);
+			process.stderr.write(
+				"   Leads should spawn scouts in Phase 1 before building. See agents/lead.md.\n",
+			);
+		}
+
+		// 6. Validate task exists and is in a workable state (if tracker enabled)
+		const tracker = createTrackerClient(resolvedBackend, config.project.root);
+		if (config.taskTracker.enabled && !skipTaskCheck) {
+			let issue: TrackerIssue;
+			try {
+				issue = await tracker.show(taskId);
+			} catch (err) {
+				throw new AgentError(`Task "${taskId}" not found or inaccessible`, {
+					agentName: name,
+					cause: err instanceof Error ? err : undefined,
+				});
+			}
+
+			const workableStatuses = ["open", "in_progress"];
+			if (!workableStatuses.includes(issue.status)) {
+				throw new ValidationError(
+					`Task "${taskId}" is not workable (status: ${issue.status}). Only open or in_progress issues can be assigned.`,
+					{ field: "taskId", value: taskId },
+				);
+			}
+		}
+
+		// 7. Create worktree
+		const worktreeBaseDir = join(config.project.root, config.worktrees.baseDir);
+		await mkdir(worktreeBaseDir, { recursive: true });
+
+		const { path: worktreePath, branch: branchName } = await createWorktree({
+			repoRoot: config.project.root,
+			baseDir: worktreeBaseDir,
+			agentName: name,
+			baseBranch: config.project.canonicalBranch,
+			beadId: taskId,
+		});
+
+		// 8. Generate + write overlay CLAUDE.md
+		const agentDefPath = join(config.project.root, config.agents.baseDir, agentDef.file);
+		const baseDefinition = await Bun.file(agentDefPath).text();
+
+		// 8a. Fetch file-scoped mulch expertise if mulch is enabled and files are provided
+		let mulchExpertise: string | undefined;
+		if (config.mulch.enabled && fileScope.length > 0) {
+			try {
+				const mulch = createMulchClient(config.project.root);
+				mulchExpertise = await mulch.prime(undefined, undefined, { files: fileScope });
+			} catch {
+				// Non-fatal: mulch expertise is supplementary context
+				mulchExpertise = undefined;
+			}
+		}
+
+		const overlayConfig: OverlayConfig = {
+			agentName: name,
+			beadId: taskId,
+			specPath: absoluteSpecPath,
+			branchName,
+			worktreePath,
+			fileScope,
+			mulchDomains: config.mulch.enabled
+				? inferDomainsFromFiles(fileScope, config.mulch.domains)
+				: [],
+			parentAgent: parentAgent,
+			depth,
+			canSpawn: agentDef.canSpawn,
+			capability,
+			baseDefinition,
+			mulchExpertise,
+			skipScout: skipScout && capability === "lead",
+			qualityGates: config.project.qualityGates,
+			trackerCli: trackerCliName(resolvedBackend),
+			trackerName: resolvedBackend,
+		};
+
+		try {
+			await writeOverlay(worktreePath, overlayConfig, config.project.root);
+		} catch (err) {
+			// Clean up the orphaned worktree created in step 7 (overstory-p4st)
+			try {
+				const cleanupProc = Bun.spawn(["git", "worktree", "remove", "--force", worktreePath], {
+					cwd: config.project.root,
+					stdout: "pipe",
+					stderr: "pipe",
+				});
+				await cleanupProc.exited;
+			} catch {
+				// Best-effort cleanup; the original error is more important
+			}
+			throw err;
+		}
+
+		// 9. Deploy hooks config (capability-specific guards)
+		await deployHooks(worktreePath, name, capability);
+
+		// 10. Claim tracker issue
+		if (config.taskTracker.enabled && !skipTaskCheck) {
+			try {
+				await tracker.claim(taskId);
+			} catch {
+				// Non-fatal: issue may already be claimed
+			}
+		}
+
+		// 11. Create agent identity (if new)
+		const identityBaseDir = join(config.project.root, ".overstory", "agents");
+		const existingIdentity = await loadIdentity(identityBaseDir, name);
+		if (!existingIdentity) {
+			await createIdentity(identityBaseDir, {
+				name,
+				capability,
+				created: new Date().toISOString(),
+				sessionsCompleted: 0,
+				expertiseDomains: config.mulch.enabled ? config.mulch.domains : [],
+				recentTasks: [],
+			});
+		}
+
+		// 12. Create tmux session running claude in interactive mode
+		const tmuxSessionName = `overstory-${config.project.name}-${name}`;
+		const { model, env } = resolveModel(config, manifest, capability, agentDef.model);
+		const claudeCmd = `claude --model ${model} --dangerously-skip-permissions`;
+		const pid = await createSession(tmuxSessionName, worktreePath, claudeCmd, {
+			...env,
+			OVERSTORY_AGENT_NAME: name,
+			OVERSTORY_WORKTREE_PATH: worktreePath,
+		});
+
+		// 13. Record session BEFORE sending the beacon so that hook-triggered
+		// updateLastActivity() can find the entry and transition booting->working.
+		// Without this, a race exists: hooks fire before the session is persisted,
+		// leaving the agent stuck in "booting" (overstory-036f).
+		const session: AgentSession = {
+			id: `session-${Date.now()}-${name}`,
+			agentName: name,
+			capability,
+			worktreePath,
+			branchName,
+			beadId: taskId,
+			tmuxSession: tmuxSessionName,
+			state: "booting",
+			pid,
+			parentAgent: parentAgent,
+			depth,
+			runId,
+			startedAt: new Date().toISOString(),
+			lastActivity: new Date().toISOString(),
+			escalationLevel: 0,
+			stalledSince: null,
+		};
+
+		store.upsert(session);
+
+		// Increment agent count for the run
+		const runStore = createRunStore(join(overstoryDir, "sessions.db"));
+		try {
+			runStore.incrementAgentCount(runId);
+		} finally {
+			runStore.close();
+		}
+
+		// 13b. Wait for Claude Code TUI to render before sending input.
+		// Polling capture-pane is more reliable than a fixed sleep because
+		// TUI init time varies by machine load and model state.
+		await waitForTuiReady(tmuxSessionName);
+		// Buffer for the input handler to attach after initial render
+		await Bun.sleep(1_000);
+
+		const beacon = buildBeacon({
+			agentName: name,
+			capability,
+			taskId,
+			parentAgent,
+			depth,
+		});
+		await sendKeys(tmuxSessionName, beacon);
+
+		// 13c. Follow-up Enters with increasing delays to ensure submission.
+		// Claude Code's TUI may consume early Enters during late initialization
+		// (overstory-yhv6). An Enter on an empty input line is harmless.
+		for (const delay of [1_000, 2_000]) {
+			await Bun.sleep(delay);
+			await sendKeys(tmuxSessionName, "");
+		}
+
+		// 14. Output result
+		const output = {
+			agentName: name,
+			capability,
+			taskId,
+			branch: branchName,
+			worktree: worktreePath,
+			tmuxSession: tmuxSessionName,
+			pid,
+		};
+
+		if (args.includes("--json")) {
+			process.stdout.write(`${JSON.stringify(output)}\n`);
+		} else {
+			process.stdout.write(`🚀 Agent "${name}" launched!\n`);
+			process.stdout.write(`   Task:     ${taskId}\n`);
+			process.stdout.write(`   Branch:   ${branchName}\n`);
+			process.stdout.write(`   Worktree: ${worktreePath}\n`);
+			process.stdout.write(`   Tmux:     ${tmuxSessionName}\n`);
+			process.stdout.write(`   PID:      ${pid}\n`);
+		}
+	} finally {
+		store.close();
+	}
+}