jobarbiter 0.3.1 → 0.3.2

package/src/lib/observe.ts

@@ -1,14 +1,14 @@
 /**
  * JobArbiter Observer — Hook installer for coding agent CLIs
  *
- * Detects installed coding agents, installs observation hooks that
- * extract proficiency signals from session transcripts.
+ * Installs observation hooks that extract proficiency signals from
+ * session transcripts. Uses detect-tools.ts for agent detection.
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync, chmodSync, unlinkSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join } from "node:path";
 import { homedir } from "node:os";
-import { execSync } from "node:child_process";
+import { getObservableTools, type DetectedTool } from "./detect-tools.js";
 
 // ── Types ──────────────────────────────────────────────────────────────
 
@@ -25,107 +25,39 @@ interface HookConfig {
 	[key: string]: unknown;
 }
 
-// ── Agent Detection ────────────────────────────────────────────────────
-
-const AGENT_DEFINITIONS = [
-	{
-		id: "claude-code",
-		name: "Claude Code",
-		configDir: join(homedir(), ".claude"),
-		hookFormat: "claude" as const,
-		detectBin: "claude",
-	},
-	{
-		id: "cursor",
-		name: "Cursor",
-		configDir: join(homedir(), ".cursor"),
-		hookFormat: "cursor" as const,
-		detectBin: null, // Cursor is an app, not a CLI
-		detectDir: join(homedir(), ".cursor"),
-	},
-	{
-		id: "opencode",
-		name: "OpenCode",
-		configDir: join(homedir(), ".config", "opencode"),
-		hookFormat: "opencode" as const,
-		detectBin: "opencode",
-	},
-	{
-		id: "codex",
-		name: "Codex CLI",
-		configDir: join(homedir(), ".codex"),
-		hookFormat: "codex" as const,
-		detectBin: "codex",
-	},
-	{
-		id: "gemini",
-		name: "Gemini CLI",
-		configDir: join(homedir(), ".gemini"),
-		hookFormat: "gemini" as const,
-		detectBin: "gemini",
-	},
-];
-
-function binExists(name: string): boolean {
-	try {
-		execSync(`which ${name}`, { stdio: "ignore" });
-		return true;
-	} catch {
-		return false;
-	}
-}
+// ── Agent Config Directories ───────────────────────────────────────────
 
-export function detectAgents(): DetectedAgent[] {
-	return AGENT_DEFINITIONS.map((def) => {
-		const installed =
-			(def.detectBin && binExists(def.detectBin)) ||
-			existsSync(def.configDir);
-
-		return {
-			id: def.id,
-			name: def.name,
-			configDir: def.configDir,
-			hookFormat: def.hookFormat,
-			installed: !!installed,
-			hookInstalled: installed ? isHookInstalled(def.id, def.configDir, def.hookFormat) : false,
-		};
-	});
-}
+const AGENT_CONFIG_DIRS: Record<string, string> = {
+	"claude-code": join(homedir(), ".claude"),
+	"cursor": join(homedir(), ".cursor"),
+	"opencode": join(homedir(), ".config", "opencode"),
+	"codex": join(homedir(), ".codex"),
+	"gemini": join(homedir(), ".gemini"),
+};
 
-// ── Hook Detection ─────────────────────────────────────────────────────
+const AGENT_HOOK_FORMATS: Record<string, "claude" | "cursor" | "opencode" | "codex" | "gemini"> = {
+	"claude-code": "claude",
+	"cursor": "cursor",
+	"opencode": "opencode",
+	"codex": "codex",
+	"gemini": "gemini",
+};
 
-function isHookInstalled(agentId: string, configDir: string, format: string): boolean {
-	try {
-		switch (format) {
-			case "claude":
-			case "cursor": {
-				const hookFile = join(configDir, "hooks.json");
-				if (!existsSync(hookFile)) return false;
-				const content = readFileSync(hookFile, "utf-8");
-				return content.includes("jobarbiter");
-			}
-			case "opencode": {
-				const pluginDir = join(configDir, "plugins");
-				return existsSync(join(pluginDir, "jobarbiter-observer.ts"));
-			}
-			case "codex": {
-				const configFile = join(configDir, "config.toml");
-				if (!existsSync(configFile)) return false;
-				const content = readFileSync(configFile, "utf-8");
-				return content.includes("jobarbiter");
-			}
-			case "gemini": {
-				const settingsFile = join(configDir, "settings.json");
-				if (!existsSync(settingsFile)) return false;
-				const content = readFileSync(settingsFile, "utf-8");
-				return content.includes("jobarbiter");
-			}
-			default:
-				return false;
-		}
-	} catch {
-		return false;
-	}
+/**
+ * Detect agents that support observation.
+ * Uses the shared detect-tools module for detection.
+ */
+export function detectAgents(): DetectedAgent[] {
+	const observableTools = getObservableTools();
+	
+	return observableTools.map((tool) => ({
+		id: tool.id,
+		name: tool.name,
+		configDir: AGENT_CONFIG_DIRS[tool.id] || tool.configDir || "",
+		hookFormat: AGENT_HOOK_FORMATS[tool.id] || "claude",
+		installed: tool.installed,
+		hookInstalled: tool.observerActive,
+	}));
 }
 
 // ── Observer Data Directory ────────────────────────────────────────────
@@ -576,6 +508,53 @@ function installGeminiHook(configDir: string, scriptPath: string): void {
 
 // ── Public API ─────────────────────────────────────────────────────────
 
+// ── Agent Name Mapping ─────────────────────────────────────────────────
+
+const AGENT_NAMES: Record<string, string> = {
+	"claude-code": "Claude Code",
+	"cursor": "Cursor",
+	"opencode": "OpenCode",
+	"codex": "Codex CLI",
+	"gemini": "Gemini CLI",
+};
+
+/**
+ * Check if observer hook is installed for an agent.
+ */
+function isHookInstalled(agentId: string, configDir: string, format: string): boolean {
+	try {
+		switch (format) {
+			case "claude":
+			case "cursor": {
+				const hookFile = join(configDir, "hooks.json");
+				if (!existsSync(hookFile)) return false;
+				const content = readFileSync(hookFile, "utf-8");
+				return content.includes("jobarbiter");
+			}
+			case "opencode": {
+				const pluginDir = join(configDir, "plugins");
+				return existsSync(join(pluginDir, "jobarbiter-observer.js"));
+			}
+			case "codex": {
+				const configFile = join(configDir, "config.toml");
+				if (!existsSync(configFile)) return false;
+				const content = readFileSync(configFile, "utf-8");
+				return content.includes("jobarbiter");
+			}
+			case "gemini": {
+				const settingsFile = join(configDir, "settings.json");
+				if (!existsSync(settingsFile)) return false;
+				const content = readFileSync(settingsFile, "utf-8");
+				return content.includes("jobarbiter");
+			}
+			default:
+				return false;
+		}
+	} catch {
+		return false;
+	}
+}
+
 /**
  * Install observer hooks for the specified agents.
  * Returns a summary of what was installed.
@@ -591,40 +570,43 @@ export function installObservers(
 	};
 
 	for (const agentId of agentIds) {
-		const def = AGENT_DEFINITIONS.find((d) => d.id === agentId);
-		if (!def) {
+		const configDir = AGENT_CONFIG_DIRS[agentId];
+		const hookFormat = AGENT_HOOK_FORMATS[agentId];
+		const agentName = AGENT_NAMES[agentId] || agentId;
+
+		if (!configDir || !hookFormat) {
 			result.errors.push({ agent: agentId, error: "Unknown agent" });
 			continue;
 		}
 
 		// Check if already installed
-		if (isHookInstalled(def.id, def.configDir, def.hookFormat)) {
-			result.skipped.push(def.name);
+		if (isHookInstalled(agentId, configDir, hookFormat)) {
+			result.skipped.push(agentName);
 			continue;
 		}
 
 		try {
-			switch (def.hookFormat) {
+			switch (hookFormat) {
 				case "claude":
-					installClaudeCodeHook(def.configDir, scriptPath);
+					installClaudeCodeHook(configDir, scriptPath);
 					break;
 				case "cursor":
-					installCursorHook(def.configDir, scriptPath);
+					installCursorHook(configDir, scriptPath);
 					break;
 				case "opencode":
-					installOpenCodeHook(def.configDir, scriptPath);
+					installOpenCodeHook(configDir, scriptPath);
 					break;
 				case "codex":
-					installCodexHook(def.configDir, scriptPath);
+					installCodexHook(configDir, scriptPath);
 					break;
 				case "gemini":
-					installGeminiHook(def.configDir, scriptPath);
+					installGeminiHook(configDir, scriptPath);
 					break;
 			}
-			result.installed.push(def.name);
+			result.installed.push(agentName);
 		} catch (err) {
 			result.errors.push({
-				agent: def.name,
+				agent: agentName,
 				error: err instanceof Error ? err.message : String(err),
 			});
 		}
@@ -640,17 +622,20 @@ export function removeObservers(agentIds: string[]): { removed: string[]; notFou
 	const result = { removed: [] as string[], notFound: [] as string[] };
 
 	for (const agentId of agentIds) {
-		const def = AGENT_DEFINITIONS.find((d) => d.id === agentId);
-		if (!def) {
+		const configDir = AGENT_CONFIG_DIRS[agentId];
+		const hookFormat = AGENT_HOOK_FORMATS[agentId];
+		const agentName = AGENT_NAMES[agentId] || agentId;
+
+		if (!configDir || !hookFormat) {
 			result.notFound.push(agentId);
 			continue;
 		}
 
 		try {
-			switch (def.hookFormat) {
+			switch (hookFormat) {
 				case "claude":
 				case "cursor": {
-					const hookFile = join(def.configDir, "hooks.json");
+					const hookFile = join(configDir, "hooks.json");
 					if (existsSync(hookFile)) {
 						const config = JSON.parse(readFileSync(hookFile, "utf-8"));
 						for (const [key, hooks] of Object.entries(config.hooks || {})) {
@@ -661,24 +646,24 @@ export function removeObservers(agentIds: string[]): { removed: string[]; notFou
 							}
 						}
 						writeFileSync(hookFile, JSON.stringify(config, null, 2) + "\n");
-						result.removed.push(def.name);
+						result.removed.push(agentName);
 					} else {
-						result.notFound.push(def.name);
+						result.notFound.push(agentName);
 					}
 					break;
 				}
 				case "opencode": {
-					const pluginFile = join(def.configDir, "plugins", "jobarbiter-observer.js");
+					const pluginFile = join(configDir, "plugins", "jobarbiter-observer.js");
 					if (existsSync(pluginFile)) {
-							unlinkSync(pluginFile);
-						result.removed.push(def.name);
+						unlinkSync(pluginFile);
+						result.removed.push(agentName);
 					} else {
-						result.notFound.push(def.name);
+						result.notFound.push(agentName);
 					}
 					break;
 				}
 				case "codex": {
-					const configFile = join(def.configDir, "config.toml");
+					const configFile = join(configDir, "config.toml");
 					if (existsSync(configFile)) {
 						let content = readFileSync(configFile, "utf-8");
 						content = content
@@ -686,14 +671,14 @@ export function removeObservers(agentIds: string[]): { removed: string[]; notFou
 							.filter((line) => !line.includes("jobarbiter"))
 							.join("\n");
 						writeFileSync(configFile, content);
-						result.removed.push(def.name);
+						result.removed.push(agentName);
 					} else {
-						result.notFound.push(def.name);
+						result.notFound.push(agentName);
 					}
 					break;
 				}
 				case "gemini": {
-					const settingsFile = join(def.configDir, "settings.json");
+					const settingsFile = join(configDir, "settings.json");
 					if (existsSync(settingsFile)) {
 						const settings = JSON.parse(readFileSync(settingsFile, "utf-8"));
 						for (const [key, hookGroups] of Object.entries(settings.hooks || {})) {
@@ -704,15 +689,15 @@ export function removeObservers(agentIds: string[]): { removed: string[]; notFou
 							}
 						}
 						writeFileSync(settingsFile, JSON.stringify(settings, null, 2) + "\n");
-						result.removed.push(def.name);
+						result.removed.push(agentName);
 					} else {
-						result.notFound.push(def.name);
+						result.notFound.push(agentName);
 					}
 					break;
 				}
 			}
 		} catch {
-			result.notFound.push(def.name);
+			result.notFound.push(agentName);
 		}
 	}
 

package/src/lib/onboard.ts

@@ -11,7 +11,15 @@
 import * as readline from "node:readline";
 import { loadConfig, saveConfig, getConfigPath, type Config } from "./config.js";
 import { apiUnauthenticated, api, ApiError } from "./api.js";
-import { detectAgents, installObservers, type DetectedAgent } from "./observe.js";
+import { installObservers } from "./observe.js";
+import {
+	detectAllTools,
+	getInstalledTools,
+	getToolsNeedingObserver,
+	formatToolDisplay,
+	type DetectedTool,
+	type ToolCategory,
+} from "./detect-tools.js";
 
 // ── ANSI Colors ────────────────────────────────────────────────────────
 
@@ -216,7 +224,9 @@ async function handleEmailVerification(
 	baseUrl: string,
 	userType: "worker" | "employer"
 ): Promise<{ email: string; apiKey: string; userId: string }> {
-	const totalSteps = userType === "worker" ? 5 : 6;
+	// Workers: 1) Account, 2) Tool Detection, 3) Domains, 4) GitHub, 5) LinkedIn, 6) Done
+	// Employers: 1) Account, 2) (skip verification), 3) Company, 4) Domain, 5) What You Need, 6) Done
+	const totalSteps = 6;
 	
 	console.log(`\n${sym.email} ${c.bold(`Step 1/${totalSteps} — Create Your Account`)}\n`);
 
@@ -303,16 +313,13 @@ async function runWorkerFlow(prompt: Prompt, state: OnboardState): Promise<void>
 		userType: "worker",
 	};
 
-	// Step 2: Profile Setup (tools + domains)
-	console.log(`${sym.tools} ${c.bold("Step 2/6 — Your AI Stack")}\n`);
-	
-	console.log(`What AI tools do you use? ${c.dim("(comma-separated)")}`);
-	console.log(c.dim("Examples: Claude Code, Cursor, OpenClaw, ChatGPT, Copilot, Midjourney\n"));
-	const toolsInput = await prompt.question(`${sym.arrow} `);
-	const tools = toolsInput.split(",").map(s => s.trim()).filter(Boolean);
-	state.tools = tools;
+	// Step 2: Auto-detect AI Tools
+	const detectedToolsResult = await runToolDetectionStep(prompt, config);
+	state.tools = detectedToolsResult.tools;
 
-	console.log(`\nWhat domains do you work in? ${c.dim("(comma-separated)")}`);
+	// Step 3: Domains
+	console.log(`${sym.target} ${c.bold("Step 3/6 — Your Domains")}\n`);
+	console.log(`What domains do you work in? ${c.dim("(comma-separated)")}`);
 	console.log(c.dim("Examples: full-stack dev, data engineering, trading, content creation\n"));
 	const domainsInput = await prompt.question(`${sym.arrow} `);
 	const domains = domainsInput.split(",").map(s => s.trim()).filter(Boolean);
@@ -325,7 +332,7 @@ async function runWorkerFlow(prompt: Prompt, state: OnboardState): Promise<void>
 		await api(config, "POST", "/v1/profile", {
 			domains,
 			tools: {
-				primary: tools,
+				primary: state.tools,
 			},
 		});
 		console.log(`${sym.check} Profile saved\n`);
@@ -333,9 +340,6 @@ async function runWorkerFlow(prompt: Prompt, state: OnboardState): Promise<void>
 		console.log(`${sym.warning} ${c.warning("Could not save profile details — you can update later with 'jobarbiter profile create'")}\n`);
 	}
 
-	// Step 3: Install Coding Agent Observers
-	await runObserverStep(prompt, state, 3, 6);
-
 	// Step 4: Connect GitHub (optional)
 	console.log(`${sym.link} ${c.bold("Step 4/6 — Connect GitHub")} ${c.dim("(optional)")}\n`);
 	console.log(`Connecting your GitHub lets us analyze your AI-assisted work patterns.`);
@@ -384,101 +388,133 @@ async function runWorkerFlow(prompt: Prompt, state: OnboardState): Promise<void>
 	showWorkerCompletion(state);
 }
 
-// ── Observer Installation Step ─────────────────────────────────────────
+// ── Tool Detection Step ────────────────────────────────────────────────
 
-async function runObserverStep(
+async function runToolDetectionStep(
 	prompt: Prompt,
-	state: OnboardState,
-	stepNum: number,
-	totalSteps: number,
-): Promise<void> {
-	console.log(`🔍 ${c.bold(`Step ${stepNum}/${totalSteps} — Coding Agent Observers`)}\n`);
-	console.log(c.dim("Scanning for coding agents...\n"));
-
-	const agents = detectAgents();
-	const detected = agents.filter((a) => a.installed);
-	const notDetected = agents.filter((a) => !a.installed);
-
-	// Show results
-	if (detected.length === 0) {
-		console.log(`  ${c.dim("No coding agents detected on this system.")}\n`);
-		console.log(c.dim("  You can install observers later with 'jobarbiter observe install'.\n"));
-		return;
+	config: Config,
+): Promise<{ tools: string[] }> {
+	console.log(`🔍 ${c.bold("Step 2/6 — Detecting AI Tools")}\n`);
+	console.log(c.dim("  Scanning your machine...\n"));
+
+	const allTools = detectAllTools();
+	const installed = allTools.filter((t) => t.installed);
+	const notInstalled = allTools.filter((t) => !t.installed && t.category === "coding-agent");
+
+	// Group by category
+	const codingAgents = installed.filter((t) => t.category === "coding-agent");
+	const chatTools = installed.filter((t) => t.category === "chat");
+	const orchestration = installed.filter((t) => t.category === "orchestration");
+	const apiProviders = installed.filter((t) => t.category === "api-provider");
+
+	// Display found tools
+	if (installed.length === 0) {
+		console.log(`  ${c.dim("No AI tools detected on this system.")}\n`);
+		console.log(c.dim("  You can add tools later with 'jobarbiter observe install'.\n"));
+		return { tools: [] };
 	}
 
-	console.log(`  Found on your system:`);
-	for (const agent of detected) {
-		if (agent.hookInstalled) {
-			console.log(`    ${sym.check} ${agent.name}  ${c.dim("(observer already installed)")}`);
+	console.log(`  ${c.bold("Found:")}`);
+
+	// Show coding agents with observer status
+	for (const tool of codingAgents) {
+		const display = formatToolDisplay(tool);
+		if (tool.observerAvailable) {
+			if (tool.observerActive) {
+				console.log(`    ${sym.check} ${display} ${c.dim("(observer active)")}`);
+			} else {
+				console.log(`    ${sym.check} ${display} ${c.success("(observer available)")}`);
+			}
 		} else {
-			console.log(`    ${c.success("✓")} ${agent.name}`);
+			console.log(`    ${sym.check} ${display} ${c.dim("(detected)")}`);
 		}
 	}
-	for (const agent of notDetected) {
-		console.log(`    ${c.dim("⬚")} ${agent.name}  ${c.dim("(not found)")}`);
+
+	// Show other tools
+	for (const tool of chatTools) {
+		console.log(`    ${sym.check} ${formatToolDisplay(tool)} ${c.dim("(detected)")}`);
+	}
+	for (const tool of orchestration) {
+		console.log(`    ${sym.check} ${formatToolDisplay(tool)} ${c.dim("(detected)")}`);
+	}
+	for (const tool of apiProviders) {
+		console.log(`    ${sym.check} ${tool.name} ${c.dim("configured")}`);
 	}
 
-	// Filter to agents that need installation
-	const needsInstall = detected.filter((a) => !a.hookInstalled);
-	
-	if (needsInstall.length === 0) {
-		console.log(`\n  ${c.dim("All detected agents already have observers installed.")}\n`);
-		return;
+	// Show not-detected coding agents
+	if (notInstalled.length > 0) {
+		console.log(`\n  ${c.dim("Not detected (install to track):")}`);
+		for (const tool of notInstalled.slice(0, 5)) {
+			console.log(`    ${c.dim("⬚")} ${tool.name}`);
+		}
+		if (notInstalled.length > 5) {
+			console.log(`    ${c.dim(`... and ${notInstalled.length - 5} more`)}`);
+		}
 	}
 
-	console.log(`\n  JobArbiter observes your coding sessions to build your`);
-	console.log(`  proficiency profile. ${c.bold("No code or prompts leave your machine")} —`);
-	console.log(`  only aggregate scores (tool usage, session counts, token volume).\n`);
-	console.log(c.dim(`  Data stored locally: ~/.config/jobarbiter/observer/observations.json`));
-	console.log(c.dim(`  Review anytime: jobarbiter observe status\n`));
+	// Collect tool names for profile
+	const toolNames = installed.map((t) => t.name);
 
-	const installAll = await prompt.confirm(
-		`  Install observers for all ${needsInstall.length} detected agent${needsInstall.length > 1 ? "s" : ""}?`,
-	);
+	// Observer installation for coding agents
+	const needsObserver = codingAgents.filter((t) => t.observerAvailable && !t.observerActive);
 
-	let toInstall: string[];
+	if (needsObserver.length > 0) {
+		console.log(`\n  ${c.bold("Observers")}`);
+		console.log(`  JobArbiter observes your coding sessions to build your`);
+		console.log(`  proficiency profile. ${c.bold("No code or prompts leave your machine")} —`);
+		console.log(`  only aggregate scores (tool usage, session counts, token volume).\n`);
+		console.log(c.dim(`  Data stored locally: ~/.config/jobarbiter/observer/observations.json`));
+		console.log(c.dim(`  Review anytime: jobarbiter observe status\n`));
 
-	if (installAll) {
-		toInstall = needsInstall.map((a) => a.id);
-	} else {
-		// Let user select individually
-		console.log(`\n  Select which agents to observe:\n`);
-		const selections: Record<string, boolean> = {};
-		
-		for (const agent of needsInstall) {
-			selections[agent.id] = await prompt.confirm(`    ${agent.name}?`, true);
-		}
+		const observerNames = needsObserver.map((t) => t.name).join(", ");
+		const installAll = await prompt.confirm(
+			`  Install observers for detected tools? (${observerNames})`,
+		);
 
-		toInstall = Object.entries(selections)
-			.filter(([, v]) => v)
-			.map(([k]) => k);
+		if (installAll) {
+			const toInstall = needsObserver.map((t) => t.id);
+			console.log(c.dim("\n  Installing observers..."));
+			const result = installObservers(toInstall);
 
-		if (toInstall.length === 0) {
-			console.log(`\n  ${c.dim("No observers installed. You can add them later with 'jobarbiter observe install'.")}\n`);
-			return;
-		}
-	}
-
-	// Install
-	console.log(c.dim("\n  Installing observers..."));
-	const result = installObservers(toInstall);
+			for (const name of result.installed) {
+				console.log(`    ${sym.check} ${name}`);
+			}
+			for (const name of result.skipped) {
+				console.log(`    ${c.dim("—")} ${name} ${c.dim("(already installed)")}`);
+			}
+			for (const { agent, error: errMsg } of result.errors) {
+				console.log(`    ${sym.cross} ${agent}: ${c.error(errMsg)}`);
+			}
 
-	for (const name of result.installed) {
-		console.log(`    ${sym.check} ${name}`);
-	}
-	for (const name of result.skipped) {
-		console.log(`    ${c.dim("—")} ${name} ${c.dim("(already installed)")}`);
-	}
-	for (const { agent, error: errMsg } of result.errors) {
-		console.log(`    ${sym.cross} ${agent}: ${c.error(errMsg)}`);
+			if (result.installed.length > 0) {
+				console.log(`\n  ${sym.check} ${c.success(`${result.installed.length} observer${result.installed.length > 1 ? "s" : ""} installed!`)}`);
+				console.log(c.dim(`  Your proficiency profile will start building automatically.\n`));
+			}
+		} else {
+			console.log(c.dim("\n  Skipped — you can install observers later with 'jobarbiter observe install'.\n"));
+		}
+	} else if (codingAgents.length > 0) {
+		const hasActiveObservers = codingAgents.some((t) => t.observerActive);
+		if (hasActiveObservers) {
+			console.log(`\n  ${c.dim("All detected agents already have observers installed.")}\n`);
+		} else {
+			console.log();
+		}
 	}
 
-	if (result.installed.length > 0) {
-		console.log(`\n  ${sym.check} ${c.success(`${result.installed.length} observer${result.installed.length > 1 ? "s" : ""} installed!`)}`);
-		console.log(c.dim(`  Your proficiency profile will start building automatically.\n`));
+	// "Did we miss anything?" prompt
+	console.log(`  ${c.dim("Did we miss anything?")}`);
+	const additionalTools = await prompt.question(`  Other AI tools you use ${c.dim("(comma-separated, or press Enter)")}: `);
+	
+	if (additionalTools.trim()) {
+		const additional = additionalTools.split(",").map((s) => s.trim()).filter(Boolean);
+		toolNames.push(...additional);
+		console.log(`  ${sym.check} Added: ${additional.join(", ")}\n`);
 	} else {
 		console.log();
 	}
+
+	return { tools: toolNames };
 }
 
 function showWorkerCompletion(state: OnboardState): void {