@sofatutor/agent-bridge 0.13.1 → 0.15.0

package/dist/index.mjs

@@ -7,6 +7,7 @@ import yaml from "js-yaml";
 import { z } from "zod";
 import { execFileSync, execSync } from "node:child_process";
 import fsExtra from "fs-extra";
+import { Prompt, isCancel } from "@clack/core";
 //#region src/lib/config.ts
 const SAFE_NAME_RE = /^[A-Za-z0-9._-]+$/;
 const safeName = z.string().min(1).refine((v) => SAFE_NAME_RE.test(v) && v !== "." && v !== "..", { message: "Only [A-Za-z0-9._-] characters allowed, cannot be . or .." });
@@ -25,12 +26,53 @@ const sourceConfigSchema = z.object({
 	source: z.string().min(1).refine((v) => !v.startsWith("-"), { message: "Must not start with '-'" }),
 	branch: z.string().refine((v) => /^[A-Za-z0-9._/-]+$/.test(v) && !v.startsWith("-"), { message: "Must match [A-Za-z0-9._/-] and not start with '-'" }).optional()
 });
+/**
+* A path inside a domain that should be synced. One or two segments:
+*   `skills`            → the whole feature type
+*   `skills/deploy`     → a single feature (folder or file)
+*   `AGENTS.md`         → a flat file at the domain root
+*/
+const includePath = z.string().min(1).refine((v) => {
+	const segs = v.split("/");
+	return segs.length <= 2 && segs.every((seg) => SAFE_NAME_RE.test(seg) && seg !== "." && seg !== "..");
+}, { message: "Must be <feature-type>, <feature-type>/<feature> or <file> using [A-Za-z0-9._-]" });
+const domainObjectSchema = z.object({
+	name: safeName,
+	include: z.array(includePath).optional()
+});
+/** Domains are written as objects; a bare string (`- shared`) is accepted as shorthand. */
+const domainConfigSchema = z.union([safeName.transform((name) => ({ name })), domainObjectSchema]);
 const bridgeConfigSchema = z.object({
 	version: z.string().optional(),
-	domains: z.array(safeName).min(1, "'domains' must be a non-empty array"),
+	domains: z.array(safeName).optional(),
 	tools: z.array(toolConfigSchema).min(1, "'tools' must be a non-empty array"),
-	sources: z.array(sourceConfigSchema).min(1, "'sources' must be a non-empty array")
+	sources: z.array(sourceConfigSchema.extend({ domains: z.array(domainConfigSchema).optional() })).min(1, "'sources' must be a non-empty array")
 }).superRefine((data, ctx) => {
+	data.sources.forEach((s, i) => {
+		const domains = s.domains ?? data.domains;
+		if (!domains || domains.length === 0) ctx.addIssue({
+			code: z.ZodIssueCode.custom,
+			message: `Source '${s.name}' has no domains (set 'sources[].domains' or top-level 'domains')`,
+			path: [
+				"sources",
+				i,
+				"domains"
+			]
+		});
+		const seen = /* @__PURE__ */ new Set();
+		for (const d of s.domains ?? []) {
+			if (seen.has(d.name)) ctx.addIssue({
+				code: z.ZodIssueCode.custom,
+				message: `Duplicate domain '${d.name}' in source '${s.name}'`,
+				path: [
+					"sources",
+					i,
+					"domains"
+				]
+			});
+			seen.add(d.name);
+		}
+	});
 	const toolNames = /* @__PURE__ */ new Set();
 	const toolFolders = /* @__PURE__ */ new Set();
 	data.tools.forEach((t, i) => {
@@ -88,6 +130,24 @@ const bridgeConfigSchema = z.object({
 		});
 	});
 });
+/**
+* Domains to scan for a source: its own `domains`, falling back to the legacy
+* top-level `domains` list (everything included).
+*/
+function sourceDomains(config, source) {
+	if (source.domains) return source.domains;
+	return (config.domains ?? []).map((name) => ({ name }));
+}
+/**
+* Whether `relPath` (relative to the domain root, e.g. `skills`,
+* `skills/deploy`, `AGENTS.md`) is selected by the domain's `include` list.
+* No `include` means everything is selected.
+*/
+function isIncluded(domain, relPath) {
+	const inc = domain.include;
+	if (!inc) return true;
+	return inc.some((entry) => entry === relPath || relPath.startsWith(entry + "/") || entry.startsWith(relPath + "/"));
+}
 const BRIDGE_DIR = ".agent-bridge";
 const CONFIG_FILENAME = "config.yml";
 /**
@@ -169,7 +229,8 @@ async function saveConfig(repoRoot, config) {
 	await mkdir(bridgeDir(repoRoot), { recursive: true });
 	const content = yaml.dump(config, {
 		lineWidth: -1,
-		noRefs: true
+		noRefs: true,
+		skipInvalid: true
 	});
 	await writeFile(configPath(repoRoot), content, "utf-8");
 }
@@ -216,15 +277,15 @@ const AGENT_BRIDGE_HOOKS = ["post-checkout", "post-merge"];
 const HOOK_MARKER = "# agent-bridge-hook";
 /**
 * Generate the hook script content.
-* Runs update and sync in the background, logging to `.agent-bridge/hook.log`
+* Runs sync in the background, logging to `.agent-bridge/hook.log`
 * (trimmed to the last ~200 lines) so failures are diagnosable.
 */
 function generateHookScript() {
 	return `#!/bin/sh
 ${HOOK_MARKER}
 # This hook was installed by Agent Bridge.
-# It runs 'agent-bridge update && agent-bridge sync' in the background
-# to keep your AI agent configurations up to date.
+# It runs 'agent-bridge sync' in the background to keep your AI agent
+# configurations up to date.
 
 REPO_ROOT="$(git rev-parse --show-toplevel 2>/dev/null)"
 LOG_DIR="\${REPO_ROOT:-.}/.agent-bridge"
@@ -239,9 +300,9 @@ mkdir -p "\$LOG_DIR" 2>/dev/null
   {
     echo "--- $(date '+%Y-%m-%dT%H:%M:%S%z') agent-bridge hook ---"
     if command -v agent-bridge >/dev/null 2>&1; then
-      agent-bridge update && agent-bridge sync
+      agent-bridge sync
     elif command -v npx >/dev/null 2>&1; then
-      npx @sofatutor/agent-bridge update && npx @sofatutor/agent-bridge sync
+      npx @sofatutor/agent-bridge sync
     else
       echo "agent-bridge not found (install globally or ensure npx is available)"
     fi
@@ -333,6 +394,23 @@ async function installGitHooks(repoRoot, force = false) {
 	return result;
 }
 /**
+* Rewrite hooks that Agent Bridge installed earlier with the current script.
+* Hooks we did not install (no marker) and missing hooks are left alone.
+*/
+async function refreshGitHooks(repoRoot) {
+	const refreshed = [];
+	if (!isInGitRepo(repoRoot)) return refreshed;
+	const hooksDir = getGitHooksDir(repoRoot);
+	for (const hookName of AGENT_BRIDGE_HOOKS) {
+		const hookPath = join(hooksDir, hookName);
+		if (!await hasAgentBridgeHook(hookPath)) continue;
+		await writeFile(hookPath, generateHookScript(), "utf-8");
+		await chmod(hookPath, 493);
+		refreshed.push(hookName);
+	}
+	return refreshed;
+}
+/**
 * Remove Agent Bridge git hooks from the repository.
 * Only removes hooks that have the Agent Bridge marker.
 */
@@ -641,304 +719,428 @@ async function removeStaleSourceDirs(repoRoot, config) {
 	return removed;
 }
 //#endregion
-//#region src/lib/version.ts
-const VERSION = "0.13.1";
-//#endregion
-//#region src/commands/init.ts
-const WELL_KNOWN_TOOLS = [
-	{
-		value: {
-			name: "vscode",
-			folder: ".github"
-		},
-		label: "VS Code (.github/)"
-	},
-	{
-		value: {
-			name: "cursor",
-			folder: ".cursor"
-		},
-		label: "Cursor (.cursor/)"
-	},
-	{
-		value: {
-			name: "claude",
-			folder: ".claude"
-		},
-		label: "Claude (.claude/)"
-	},
-	{
-		value: {
-			name: "pi",
-			folder: ".pi"
-		},
-		label: "Pi (.pi/)"
+//#region src/lib/manifest.ts
+const TOOL_PREFIX_SEPARATOR = "--";
+function parseToolPrefix(name) {
+	const idx = name.indexOf(TOOL_PREFIX_SEPARATOR);
+	if (idx > 0) return {
+		toolPrefix: name.substring(0, idx),
+		baseName: name.substring(idx + 2)
+	};
+	return { baseName: name };
+}
+function featureMatchesTool(feature, toolName) {
+	if (!feature.toolPrefix) return true;
+	return feature.toolPrefix === toolName;
+}
+function featureName(feature) {
+	if (feature.toolPrefix) return parseToolPrefix(feature.name).baseName;
+	return feature.name;
+}
+/**
+* Discover all feature types across all sources and domains.
+*/
+async function discoverFeatureTypes(repoRoot, config) {
+	const types = /* @__PURE__ */ new Set();
+	for (const source of config.sources) {
+		const srcPath = resolveSourcePath(repoRoot, source);
+		for (const domain of sourceDomains(config, source)) {
+			const domainDir = join(srcPath, domain.name);
+			if (!await dirExists(domainDir)) continue;
+			const entries = await readdir(domainDir, { withFileTypes: true });
+			for (const entry of entries) if (entry.isDirectory() && isIncluded(domain, entry.name)) types.add(entry.name);
+		}
 	}
-];
-const WELL_KNOWN_TOOL_MAP = Object.fromEntries(WELL_KNOWN_TOOLS.map((t) => [t.value.name, t.value]));
-const CUSTOM_TOOL_SENTINEL = {
-	name: "__custom__",
-	folder: "__custom__"
-};
-const DEFAULT_DOMAINS = [
-	"backend",
-	"frontend",
-	"shared"
-];
+	return [...types].sort();
+}
 /**
-* Derive a short source name from a URL or local path.
+* Scan all features across sources × domains × feature types.
 *
-* Examples:
-*   https://github.com/org/repo.git  → repo
-*   git@github.com:org/repo.git      → repo
-*   file:///tmp/bare.git             → bare
-*   /path/to/my-folder               → my-folder
+* Structure: `<source-path>/<domain>/<feature-type>/<feature>/` (folder-based)
+*         or `<source-path>/<domain>/<feature-type>/<feature.ext>` (file-based)
 */
-function deriveSourceName(source) {
-	let segment = source;
-	const sshMatch = segment.match(/^[\w.-]+@[\w.-]+:(.+)$/);
-	if (sshMatch) segment = sshMatch[1];
-	try {
-		segment = new URL(segment).pathname;
-	} catch {}
-	return (segment.replace(/\/+$/, "").split("/").pop() ?? segment).replace(/\.git$/, "") || "source";
+async function scanFeatures(repoRoot, config, featureTypes) {
+	const features = [];
+	for (const source of config.sources) {
+		const srcPath = resolveSourcePath(repoRoot, source);
+		for (const domain of sourceDomains(config, source)) for (const ft of featureTypes) {
+			if (!isIncluded(domain, ft)) continue;
+			const { toolPrefix: typeToolPrefix, baseName: baseType } = parseToolPrefix(ft);
+			const ftDir = join(srcPath, domain.name, ft);
+			if (!await dirExists(ftDir)) continue;
+			const entries = await readdir(ftDir, { withFileTypes: true });
+			for (const entry of entries) {
+				const isFile = entry.isFile();
+				const isDir = entry.isDirectory();
+				if (!isFile && !isDir) continue;
+				if (!isIncluded(domain, `${ft}/${entry.name}`)) continue;
+				const { toolPrefix: itemToolPrefix } = parseToolPrefix(entry.name);
+				const toolPrefix = itemToolPrefix ?? typeToolPrefix;
+				features.push({
+					name: entry.name,
+					type: ft,
+					displayType: baseType,
+					source: source.name,
+					domain: domain.name,
+					absolutePath: join(ftDir, entry.name),
+					toolPrefix,
+					isFile
+				});
+			}
+		}
+	}
+	return features;
+}
+/** Top-level directories of a source that can act as domains. */
+async function listDomains(srcPath) {
+	if (!await dirExists(srcPath)) return [];
+	return (await readdir(srcPath, { withFileTypes: true })).filter((e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules").map((e) => e.name).sort();
 }
 /**
-* Parse a comma-separated `--tools` argument into ToolConfig[].
-* Accepts well-known names (cursor, vscode, claude) or `name:folder` pairs.
+* List what `sync` would consider inside a domain, so the user can pick a
+* subset. `toolNames` filters `<tool>--file` entries to configured tools.
 */
-function parseToolsArg(input) {
-	return input.split(",").map((t) => {
-		const trimmed = t.trim();
-		if (!trimmed) throw new Error("Empty tool name in --tools");
-		if (WELL_KNOWN_TOOL_MAP[trimmed]) return WELL_KNOWN_TOOL_MAP[trimmed];
-		const colonIdx = trimmed.indexOf(":");
-		if (colonIdx > 0) return {
-			name: trimmed.slice(0, colonIdx),
-			folder: trimmed.slice(colonIdx + 1)
-		};
-		throw new Error(`Unknown tool "${trimmed}". Use a known name (${Object.keys(WELL_KNOWN_TOOL_MAP).join(", ")}) or name:folder format.`);
+async function listDomainContents(srcPath, domain, toolNames) {
+	const domainDir = join(srcPath, domain);
+	const tools = new Set(toolNames);
+	const result = {
+		featureTypes: [],
+		files: []
+	};
+	if (!await dirExists(domainDir)) return result;
+	const entries = await readdir(domainDir, { withFileTypes: true });
+	for (const entry of entries) {
+		if (entry.name.startsWith(".")) continue;
+		if (entry.isDirectory()) {
+			const features = (await readdir(join(domainDir, entry.name), { withFileTypes: true })).filter((f) => (f.isFile() || f.isDirectory()) && !f.name.startsWith(".")).map((f) => f.name).sort();
+			result.featureTypes.push({
+				name: entry.name,
+				features
+			});
+		} else if (entry.isFile()) {
+			const { toolPrefix } = parseToolPrefix(entry.name);
+			if (ROOT_FILES.includes(entry.name) || toolPrefix && tools.has(toolPrefix)) result.files.push(entry.name);
+		}
+	}
+	result.featureTypes.sort((a, b) => a.name.localeCompare(b.name));
+	result.files.sort();
+	return result;
+}
+function detectDuplicates(features) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const f of features) {
+		const linkName = featureName(f);
+		const key = `${f.displayType}/${linkName}`;
+		const group = byKey.get(key) ?? [];
+		group.push(f);
+		byKey.set(key, group);
+	}
+	const conflicts = [];
+	for (const [, group] of byKey) if (group.length > 1) conflicts.push({
+		name: featureName(group[0]),
+		type: group[0].type,
+		paths: group.map((f) => f.absolutePath)
 	});
+	return conflicts;
 }
 /**
-* Parse a single `--source` argument into a SourceConfig.
-* Supports `#branch` suffix for remote sources.
+* Well-known root files that live at the domain root and should be synced to the
+* workspace root. When a source contains `<domain>/AGENTS.md` (etc.), Agent Bridge
+* copies it to the project root.
 */
-function parseSourceArg(input, repoRoot) {
-	let source = input.trim();
-	let branch;
-	const hashIdx = source.lastIndexOf("#");
-	if (hashIdx > 0) {
-		branch = source.slice(hashIdx + 1);
-		source = source.slice(0, hashIdx);
+const ROOT_FILES = [
+	"AGENTS.md",
+	"CLAUDE.md",
+	"SYSTEM.md"
+];
+/**
+* Scan all sources × domains for well-known root files.
+* Returns one entry per found file.
+*/
+async function scanRootFiles(repoRoot, config) {
+	const found = [];
+	for (const source of config.sources) {
+		const srcPath = resolveSourcePath(repoRoot, source);
+		for (const domain of sourceDomains(config, source)) for (const fileName of ROOT_FILES) {
+			if (!isIncluded(domain, fileName)) continue;
+			const filePath = join(srcPath, domain.name, fileName);
+			if (await fileExists(filePath)) found.push({
+				fileName,
+				source: source.name,
+				domain: domain.name,
+				absolutePath: filePath
+			});
+		}
 	}
-	if (!source) throw new Error("Empty source in --source");
-	const entry = {
-		name: deriveSourceName(source),
-		source
-	};
-	if (!isRemoteSource(entry.source)) entry.source = resolve(repoRoot, entry.source);
-	if (branch) entry.branch = branch;
-	return entry;
+	return found;
 }
-async function initCommand(cwd, opts) {
-	const repoRoot = cwd ?? findRepoRoot();
-	if (await isOptedOut(repoRoot)) if (opts?.force) await removeOptOutMarker(repoRoot);
-	else {
-		p.log.warn(`${OPT_OUT_MARKER} present — Agent Bridge is opted out. Skipping init. Delete the file or run with --force to re-enable.`);
-		return;
-	}
-	const hasToolsArg = !!opts?.tools;
-	const hasSourceArg = !!(opts?.source && opts.source.length > 0);
-	if (hasToolsArg !== hasSourceArg) {
-		p.log.error("Both --tools and --source are required for non-interactive init.");
-		process.exit(1);
-	}
-	if (hasToolsArg && hasSourceArg) {
-		const domains = opts.domains ? opts.domains.split(",").map((d) => d.trim()).filter(Boolean) : [...DEFAULT_DOMAINS];
-		const tools = parseToolsArg(opts.tools);
-		const sources = opts.source.map((s) => parseSourceArg(s, repoRoot));
-		const seen = /* @__PURE__ */ new Set();
-		for (const s of sources) {
-			if (seen.has(s.name)) throw new Error(`Duplicate source name "${s.name}" derived from --source arguments`);
-			seen.add(s.name);
-		}
-		const config = {
-			version: VERSION,
-			domains,
-			tools,
-			sources
-		};
-		await saveConfig(repoRoot, config);
-		await ensureBridgeGitignore(repoRoot);
-		p.log.success("Saved .agent-bridge/config.yml");
-		const spinner = p.spinner();
-		spinner.start("Fetching remote sources…");
-		const fetchErrors = (await syncAllSources(repoRoot, config)).filter((r) => r.error);
-		if (fetchErrors.length > 0) {
-			spinner.stop("Some sources failed");
-			for (const err of fetchErrors) p.log.error(`${err.name}: ${err.error}`);
-		} else spinner.stop("All sources ready");
-		if (opts.hooks && isInGitRepo(repoRoot)) {
-			const hookResult = await installGitHooks(repoRoot, opts.force === true);
-			if (hookResult.installed.length > 0) p.log.success(`Installed git hooks: ${hookResult.installed.join(", ")}`);
-			if (hookResult.skipped.length > 0) p.log.warn(`Skipped hooks: ${hookResult.skipped.join(", ")}`);
-			if (hookResult.errors.length > 0) for (const e of hookResult.errors) p.log.error(`Hook ${e.hook}: ${e.error}`);
-		}
-		p.outro("Done! Run `agent-bridge sync` to sync features.");
-		return;
+/**
+* Detect duplicate root files (same filename provided by multiple sources/domains).
+*/
+function detectRootFileDuplicates(rootFiles) {
+	const byName = /* @__PURE__ */ new Map();
+	for (const rf of rootFiles) {
+		const group = byName.get(rf.fileName) ?? [];
+		group.push(rf);
+		byName.set(rf.fileName, group);
 	}
-	p.intro("Welcome to Agent Bridge — Project Setup");
-	if (await configExists(repoRoot)) {
-		const existing = await loadConfig(repoRoot);
-		p.log.info(`Config already exists with ${existing.sources?.length ?? 0} source(s). Re-running will overwrite.`);
-	}
-	const domainsInput = await p.text({
-		message: "Domains (comma-separated)",
-		placeholder: DEFAULT_DOMAINS.join(", "),
-		defaultValue: DEFAULT_DOMAINS.join(", "),
-		validate: (v) => {
-			if (!v.trim()) return "At least one domain is required";
-		}
-	});
-	if (p.isCancel(domainsInput)) {
-		p.cancel("Setup cancelled.");
-		process.exit(1);
-	}
-	const domains = domainsInput.split(",").map((d) => d.trim()).filter(Boolean);
-	const selectedTools = await p.multiselect({
-		message: "Which tools (IDEs) should receive Agent Bridge files?",
-		options: [...WELL_KNOWN_TOOLS, {
-			value: CUSTOM_TOOL_SENTINEL,
-			label: "Other (add custom tool)"
-		}],
-		required: true
+	const duplicates = [];
+	for (const [fileName, group] of byName) if (group.length > 1) duplicates.push({
+		fileName,
+		paths: group.map((rf) => rf.absolutePath)
 	});
-	if (p.isCancel(selectedTools)) {
-		p.cancel("Setup cancelled.");
-		process.exit(1);
-	}
-	const tools = selectedTools.filter((t) => t.name !== "__custom__");
-	if (selectedTools.some((t) => t.name === "__custom__")) {
-		let addingCustom = true;
-		while (addingCustom) {
-			const name = await p.text({
-				message: "Custom tool name (used for <tool>-- prefix matching)",
-				placeholder: "windsurf",
-				defaultValue: "",
-				validate: (v) => {
-					if (!v.trim()) return "Tool name cannot be empty";
-					if (tools.some((t) => t.name === v.trim())) return "Tool name already used";
-				}
-			});
-			if (p.isCancel(name)) break;
-			const folder = await p.text({
-				message: `Target folder for "${name}"`,
-				placeholder: `.${name}`,
-				defaultValue: "",
-				validate: (v) => {
-					if (!v.trim()) return "Folder cannot be empty";
-					if (tools.some((t) => t.folder === v.trim())) return "Folder already used by another tool";
-				}
-			});
-			if (p.isCancel(folder)) break;
-			tools.push({
-				name: name.trim(),
-				folder: folder.trim()
-			});
-			const addMore = await p.confirm({
-				message: "Add another custom tool?",
-				initialValue: false
-			});
-			if (p.isCancel(addMore) || !addMore) addingCustom = false;
-		}
-		if (tools.length === 0) {
-			p.cancel("At least one tool is required.");
-			process.exit(1);
+	return duplicates;
+}
+/**
+* Scan all sources × domains for tool-prefixed flat files at the domain level.
+* A file named `cursor--settings.json` targets the tool "cursor" with
+* destination filename "settings.json".
+*/
+async function scanToolRootEntries(repoRoot, config) {
+	const entries = [];
+	const toolNames = new Set(config.tools.map((t) => t.name));
+	for (const source of config.sources) {
+		const srcPath = resolveSourcePath(repoRoot, source);
+		for (const domain of sourceDomains(config, source)) {
+			const domainDir = join(srcPath, domain.name);
+			if (!await dirExists(domainDir)) continue;
+			const domainEntries = await readdir(domainDir, { withFileTypes: true });
+			for (const entry of domainEntries) {
+				if (!entry.isFile() || !isIncluded(domain, entry.name)) continue;
+				const { toolPrefix, baseName } = parseToolPrefix(entry.name);
+				if (!toolPrefix || !toolNames.has(toolPrefix)) continue;
+				entries.push({
+					toolName: toolPrefix,
+					name: baseName,
+					source: source.name,
+					domain: domain.name,
+					absolutePath: join(domainDir, entry.name)
+				});
+			}
 		}
 	}
-	const sources = [];
-	const addSource = async () => {
-		const source = await p.text({
-			message: "Source URL or local path",
-			placeholder: "https://github.com/org/repo.git",
-			defaultValue: "",
-			validate: (v) => {
-				if (!v.trim()) return "Source URL/path cannot be empty";
-				const derived = deriveSourceName(v.trim());
-				if (sources.some((s) => s.name === derived)) return `Source name "${derived}" (derived from URL) already used`;
+	return entries;
+}
+/**
+* Detect duplicate tool root entries (same tool + name from multiple sources/domains).
+*/
+function detectToolRootDuplicates(entries) {
+	const byKey = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const key = `${entry.toolName}/${entry.name}`;
+		const group = byKey.get(key) ?? [];
+		group.push(entry);
+		byKey.set(key, group);
+	}
+	const duplicates = [];
+	for (const [, group] of byKey) if (group.length > 1) duplicates.push({
+		toolName: group[0].toolName,
+		name: group[0].name,
+		paths: group.map((e) => e.absolutePath)
+	});
+	return duplicates;
+}
+//#endregion
+//#region src/lib/tree.ts
+var TreeModel = class {
+	selected = /* @__PURE__ */ new Set();
+	expanded = /* @__PURE__ */ new Set();
+	cursor = 0;
+	constructor(roots, opts = {}) {
+		this.roots = roots;
+		const depth = opts.expandDepth ?? 1;
+		const expand = (nodes, d) => {
+			if (d >= depth) return;
+			for (const n of nodes) if (n.children?.length) {
+				this.expanded.add(n);
+				expand(n.children, d + 1);
 			}
-		});
-		if (p.isCancel(source)) return false;
-		const entry = {
-			name: deriveSourceName(source.trim()),
-			source: source.trim()
 		};
-		if (!isRemoteSource(entry.source)) entry.source = resolve(repoRoot, entry.source);
-		if (isRemoteSource(entry.source)) {
-			const branch = await p.text({
-				message: "Branch (leave empty for remote default)",
-				placeholder: "main",
-				defaultValue: ""
-			});
-			if (p.isCancel(branch)) return false;
-			if (branch.trim()) entry.branch = branch.trim();
-		}
-		sources.push(entry);
-		return true;
-	};
-	p.log.info("Add at least one source.");
-	let addingSource = true;
-	while (addingSource) {
-		if (!await addSource()) {
-			if (sources.length === 0) {
-				p.cancel("At least one source is required.");
-				process.exit(1);
+		expand(roots, 0);
+		for (const v of opts.initialSelected ?? []) this.selected.add(v);
+	}
+	/** Visible rows in display order, honoring collapsed nodes. */
+	rows() {
+		const out = [];
+		const walk = (nodes, depth, parent) => {
+			for (const node of nodes) {
+				out.push({
+					node,
+					depth,
+					parent
+				});
+				if (node.children?.length && this.expanded.has(node)) walk(node.children, depth + 1, node);
 			}
-			break;
+		};
+		walk(this.roots, 0);
+		return out;
+	}
+	current() {
+		return this.rows()[this.cursor];
+	}
+	isExpanded(node) {
+		return this.expanded.has(node);
+	}
+	leaves(node) {
+		if (!node.children?.length) return node.value !== void 0 ? [node.value] : [];
+		return node.children.flatMap((c) => this.leaves(c));
+	}
+	state(node) {
+		const leaves = this.leaves(node);
+		if (leaves.length === 0) return "none";
+		const n = leaves.filter((l) => this.selected.has(l)).length;
+		return n === 0 ? "none" : n === leaves.length ? "all" : "some";
+	}
+	/** Space: leaf toggles; parent selects all descendants unless already all. */
+	toggle() {
+		const row = this.current();
+		if (!row) return;
+		const leaves = this.leaves(row.node);
+		if (this.state(row.node) === "all") for (const l of leaves) this.selected.delete(l);
+		else for (const l of leaves) this.selected.add(l);
+	}
+	move(delta) {
+		const n = this.rows().length;
+		if (n === 0) return;
+		this.cursor = (this.cursor + delta + n) % n;
+	}
+	/** Right: expand. On a leaf or an open node, nothing happens. */
+	expand() {
+		const row = this.current();
+		if (row?.node.children?.length) this.expanded.add(row.node);
+	}
+	/** Left: collapse an open node; on a closed node or leaf, jump to its parent. */
+	collapse() {
+		const row = this.current();
+		if (!row) return;
+		if (row.node.children?.length && this.expanded.has(row.node)) {
+			this.expanded.delete(row.node);
+			return;
+		}
+		if (row.parent) {
+			const idx = this.rows().findIndex((r) => r.node === row.parent);
+			if (idx >= 0) this.cursor = idx;
 		}
-		const addMore = await p.confirm({
-			message: "Add another source?",
-			initialValue: false
-		});
-		if (p.isCancel(addMore) || !addMore) addingSource = false;
 	}
-	const config = {
-		version: VERSION,
-		domains,
-		tools,
-		sources
-	};
-	await saveConfig(repoRoot, config);
-	await ensureBridgeGitignore(repoRoot);
-	p.log.success("Saved .agent-bridge/config.yml");
-	const s = p.spinner();
-	s.start("Fetching remote sources…");
-	const errors = (await syncAllSources(repoRoot, config)).filter((r) => r.error);
-	if (errors.length > 0) {
-		s.stop("Some sources failed");
-		for (const err of errors) p.log.error(`${err.name}: ${err.error}`);
-	} else s.stop("All sources ready");
-	if (isInGitRepo(repoRoot)) {
-		const installHooks = await p.confirm({
-			message: "Install git hooks to auto-sync on checkout/merge?",
-			initialValue: false
-		});
-		if (!p.isCancel(installHooks) && installHooks) {
-			const hookResult = await installGitHooks(repoRoot, opts?.force === true);
-			if (hookResult.installed.length > 0) p.log.success(`Installed git hooks: ${hookResult.installed.join(", ")}`);
-			if (hookResult.skipped.length > 0) {
-				p.log.warn(`Skipped hooks (existing non-Agent-Bridge hooks): ${hookResult.skipped.join(", ")}`);
-				p.log.info("Re-run `agent-bridge init --force` to overwrite, or integrate manually.");
+	toggleExpand() {
+		const row = this.current();
+		if (!row?.node.children?.length) return;
+		if (this.expanded.has(row.node)) this.expanded.delete(row.node);
+		else this.expanded.add(row.node);
+	}
+};
+//#endregion
+//#region src/lib/tree-prompt.ts
+const tty = process.stdout.isTTY && !process.env.NO_COLOR;
+const paint = (code, s) => tty ? `\x1b[${code}m${s}\x1b[39m` : s;
+const dim = (s) => tty ? `\x1b[2m${s}\x1b[22m` : s;
+const cyan = (s) => paint(36, s);
+const green = (s) => paint(32, s);
+const yellow = (s) => paint(33, s);
+const red = (s) => paint(31, s);
+const gray = (s) => paint(90, s);
+const S_BAR = "│";
+const S_BAR_END = "└";
+const CHECK = {
+	none: "◻",
+	some: yellow("◧"),
+	all: green("◼")
+};
+function symbol(state) {
+	if (state === "cancel") return red("■");
+	if (state === "error") return yellow("▲");
+	if (state === "submit") return green("◇");
+	return cyan("◆");
+}
+/**
+* A checkbox tree. Space toggles the node under the cursor (a parent toggles
+* everything beneath it), ←/→ collapse/expand, Enter confirms.
+* Resolves to the selected leaf values, or the clack cancel symbol.
+*/
+async function treeSelect(opts) {
+	const model = new TreeModel(opts.tree, {
+		expandDepth: opts.expandDepth,
+		initialSelected: opts.initialValues
+	});
+	const maxItems = Math.max(5, opts.maxItems ?? (process.stdout.rows || 24) - 6);
+	const prompt = new Prompt({
+		validate: () => {
+			if (opts.required !== false && model.selected.size === 0) return "Select at least one item.";
+		},
+		render() {
+			const title = `${gray(S_BAR)}\n${symbol(this.state)}  ${opts.message}\n`;
+			if (this.state === "submit") {
+				const n = model.selected.size;
+				return `${title}${gray(S_BAR)}  ${dim(`${n} item${n === 1 ? "" : "s"} selected`)}`;
+			}
+			if (this.state === "cancel") return `${title}${gray(S_BAR)}  ${dim("cancelled")}\n${gray(S_BAR)}`;
+			const rows = model.rows();
+			let start = 0;
+			if (rows.length > maxItems) start = Math.min(Math.max(0, model.cursor - Math.floor(maxItems / 2)), rows.length - maxItems);
+			const end = Math.min(rows.length, start + maxItems);
+			const lines = [];
+			if (start > 0) lines.push(`${cyan(S_BAR)}  ${dim("…")}`);
+			for (let i = start; i < end; i++) {
+				const { node, depth } = rows[i];
+				const active = i === model.cursor;
+				const arrow = !!node.children?.length ? model.isExpanded(node) ? "▾" : "▸" : " ";
+				const box = CHECK[model.state(node)];
+				const indent = "  ".repeat(depth);
+				let label = active ? node.label : dim(node.label);
+				if (node.hint) label += ` ${dim(node.hint)}`;
+				lines.push(`${cyan(S_BAR)}  ${indent}${dim(arrow)} ${box} ${label}`);
 			}
-			if (hookResult.errors.length > 0) for (const err of hookResult.errors) p.log.error(`Hook ${err.hook}: ${err.error}`);
+			if (end < rows.length) lines.push(`${cyan(S_BAR)}  ${dim("…")}`);
+			const footer = this.state === "error" ? `${yellow(S_BAR_END)}  ${yellow(this.error)}` : `${cyan(S_BAR_END)}  ${dim("space toggle · ←/→ collapse/expand · enter confirm")}`;
+			return `${title}${lines.join("\n")}\n${footer}\n`;
 		}
-	}
-	p.outro("Done! Run `agent-bridge sync` to sync features.");
+	}, false);
+	prompt.on("cursor", (key) => {
+		switch (key) {
+			case "up":
+				model.move(-1);
+				break;
+			case "down":
+				model.move(1);
+				break;
+			case "left":
+				model.collapse();
+				break;
+			case "right":
+				model.expand();
+				break;
+			case "space":
+				model.toggle();
+				break;
+		}
+		prompt.value = [...model.selected];
+	});
+	prompt.value = [...model.selected];
+	const result = await prompt.prompt();
+	if (isCancel(result)) return result;
+	return [...model.selected];
 }
 //#endregion
+//#region src/lib/version.ts
+const VERSION = "0.15.0";
+//#endregion
 //#region src/lib/migrations/index.ts
-const migrations = [];
+const migrations = [{
+	version: "0.14.0",
+	description: "move top-level domains into each source; git hooks run `sync` only",
+	migrate: async (repoRoot, config) => {
+		const { domains, ...rest } = config;
+		const sources = config.sources.map((s) => s.domains ? s : {
+			...s,
+			domains: (domains ?? []).map((name) => ({ name }))
+		});
+		await refreshGitHooks(repoRoot);
+		return {
+			...rest,
+			sources
+		};
+	}
+}];
 /** Parse "1.2.3" or "1.2.3-beta.1" into [major, minor, patch]. */
 function parseSemver(version) {
 	const parts = version.replace(/^v/, "").split("-")[0].split(".").map(Number);
@@ -994,190 +1196,6 @@ async function runMigrations(repoRoot) {
 	};
 }
 //#endregion
-//#region src/lib/manifest.ts
-const TOOL_PREFIX_SEPARATOR = "--";
-function parseToolPrefix(name) {
-	const idx = name.indexOf(TOOL_PREFIX_SEPARATOR);
-	if (idx > 0) return {
-		toolPrefix: name.substring(0, idx),
-		baseName: name.substring(idx + 2)
-	};
-	return { baseName: name };
-}
-function featureMatchesTool(feature, toolName) {
-	if (!feature.toolPrefix) return true;
-	return feature.toolPrefix === toolName;
-}
-function featureName(feature) {
-	if (feature.toolPrefix) return parseToolPrefix(feature.name).baseName;
-	return feature.name;
-}
-/**
-* Discover all feature types across all sources and domains.
-*/
-async function discoverFeatureTypes(repoRoot, config) {
-	const types = /* @__PURE__ */ new Set();
-	for (const source of config.sources) {
-		const srcPath = resolveSourcePath(repoRoot, source);
-		for (const domain of config.domains) {
-			const domainDir = join(srcPath, domain);
-			if (!await dirExists(domainDir)) continue;
-			const entries = await readdir(domainDir, { withFileTypes: true });
-			for (const entry of entries) if (entry.isDirectory()) types.add(entry.name);
-		}
-	}
-	return [...types].sort();
-}
-/**
-* Scan all features across sources × domains × feature types.
-*
-* Structure: `<source-path>/<domain>/<feature-type>/<feature>/` (folder-based)
-*         or `<source-path>/<domain>/<feature-type>/<feature.ext>` (file-based)
-*/
-async function scanFeatures(repoRoot, config, featureTypes) {
-	const features = [];
-	for (const source of config.sources) {
-		const srcPath = resolveSourcePath(repoRoot, source);
-		for (const domain of config.domains) for (const ft of featureTypes) {
-			const { toolPrefix: typeToolPrefix, baseName: baseType } = parseToolPrefix(ft);
-			const ftDir = join(srcPath, domain, ft);
-			if (!await dirExists(ftDir)) continue;
-			const entries = await readdir(ftDir, { withFileTypes: true });
-			for (const entry of entries) {
-				const isFile = entry.isFile();
-				const isDir = entry.isDirectory();
-				if (!isFile && !isDir) continue;
-				const { toolPrefix: itemToolPrefix } = parseToolPrefix(entry.name);
-				const toolPrefix = itemToolPrefix ?? typeToolPrefix;
-				features.push({
-					name: entry.name,
-					type: ft,
-					displayType: baseType,
-					source: source.name,
-					domain,
-					absolutePath: join(ftDir, entry.name),
-					toolPrefix,
-					isFile
-				});
-			}
-		}
-	}
-	return features;
-}
-function detectDuplicates(features) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const f of features) {
-		const linkName = featureName(f);
-		const key = `${f.displayType}/${linkName}`;
-		const group = byKey.get(key) ?? [];
-		group.push(f);
-		byKey.set(key, group);
-	}
-	const conflicts = [];
-	for (const [, group] of byKey) if (group.length > 1) conflicts.push({
-		name: featureName(group[0]),
-		type: group[0].type,
-		paths: group.map((f) => f.absolutePath)
-	});
-	return conflicts;
-}
-/**
-* Well-known root files that live at the domain root and should be synced to the
-* workspace root. When a source contains `<domain>/AGENTS.md` (etc.), Agent Bridge
-* copies it to the project root.
-*/
-const ROOT_FILES = [
-	"AGENTS.md",
-	"CLAUDE.md",
-	"SYSTEM.md"
-];
-/**
-* Scan all sources × domains for well-known root files.
-* Returns one entry per found file.
-*/
-async function scanRootFiles(repoRoot, config) {
-	const found = [];
-	for (const source of config.sources) {
-		const srcPath = resolveSourcePath(repoRoot, source);
-		for (const domain of config.domains) for (const fileName of ROOT_FILES) {
-			const filePath = join(srcPath, domain, fileName);
-			if (await fileExists(filePath)) found.push({
-				fileName,
-				source: source.name,
-				domain,
-				absolutePath: filePath
-			});
-		}
-	}
-	return found;
-}
-/**
-* Detect duplicate root files (same filename provided by multiple sources/domains).
-*/
-function detectRootFileDuplicates(rootFiles) {
-	const byName = /* @__PURE__ */ new Map();
-	for (const rf of rootFiles) {
-		const group = byName.get(rf.fileName) ?? [];
-		group.push(rf);
-		byName.set(rf.fileName, group);
-	}
-	const duplicates = [];
-	for (const [fileName, group] of byName) if (group.length > 1) duplicates.push({
-		fileName,
-		paths: group.map((rf) => rf.absolutePath)
-	});
-	return duplicates;
-}
-/**
-* Scan all sources × domains for tool-prefixed flat files at the domain level.
-* A file named `cursor--settings.json` targets the tool "cursor" with
-* destination filename "settings.json".
-*/
-async function scanToolRootEntries(repoRoot, config) {
-	const entries = [];
-	const toolNames = new Set(config.tools.map((t) => t.name));
-	for (const source of config.sources) {
-		const srcPath = resolveSourcePath(repoRoot, source);
-		for (const domain of config.domains) {
-			const domainDir = join(srcPath, domain);
-			if (!await dirExists(domainDir)) continue;
-			const domainEntries = await readdir(domainDir, { withFileTypes: true });
-			for (const entry of domainEntries) {
-				if (!entry.isFile()) continue;
-				const { toolPrefix, baseName } = parseToolPrefix(entry.name);
-				if (!toolPrefix || !toolNames.has(toolPrefix)) continue;
-				entries.push({
-					toolName: toolPrefix,
-					name: baseName,
-					source: source.name,
-					domain,
-					absolutePath: join(domainDir, entry.name)
-				});
-			}
-		}
-	}
-	return entries;
-}
-/**
-* Detect duplicate tool root entries (same tool + name from multiple sources/domains).
-*/
-function detectToolRootDuplicates(entries) {
-	const byKey = /* @__PURE__ */ new Map();
-	for (const entry of entries) {
-		const key = `${entry.toolName}/${entry.name}`;
-		const group = byKey.get(key) ?? [];
-		group.push(entry);
-		byKey.set(key, group);
-	}
-	const duplicates = [];
-	for (const [, group] of byKey) if (group.length > 1) duplicates.push({
-		toolName: group[0].toolName,
-		name: group[0].name,
-		paths: group.map((e) => e.absolutePath)
-	});
-	return duplicates;
-}
-//#endregion
 //#region src/lib/sync.ts
 /**
 * Compute the destination path for a feature inside a tool's folder.
@@ -1458,11 +1476,11 @@ async function syncCommand(cwd, _opts) {
 	}
 	const s = p.spinner();
 	s.start("Loading configuration…");
-	const config = await loadConfig(repoRoot);
 	const migrationResult = await runMigrations(repoRoot);
 	if (migrationResult) p.log.info(`Config upgraded ${migrationResult.fromVersion} → ${migrationResult.toVersion}` + (migrationResult.applied.length > 0 ? ` (${migrationResult.applied.length} migration(s))` : ""));
+	const config = await loadConfig(repoRoot);
 	s.stop("Configuration valid");
-	s.start("Syncing sources…");
+	s.start("Fetching sources…");
 	const sourceResults = await syncAllSources(repoRoot, config);
 	const sourceErrors = sourceResults.filter((r) => r.error);
 	if (sourceErrors.length > 0) {
@@ -1473,7 +1491,7 @@ async function syncCommand(cwd, _opts) {
 	const staleRemoved = await removeStaleSourceDirs(repoRoot, config);
 	if (staleRemoved.length > 0) for (const name of staleRemoved) p.log.info(`Removed stale source: ${name}`);
 	for (const r of sourceResults) if (r.action !== "local") p.log.info(`${r.name}: ${r.action}`);
-	s.stop("Sources synced");
+	s.stop("Sources up to date");
 	s.start("Discovering features…");
 	const features = await scanFeatures(repoRoot, config, await discoverFeatureTypes(repoRoot, config));
 	const rootFiles = await scanRootFiles(repoRoot, config);
@@ -1546,22 +1564,388 @@ async function syncCommand(cwd, _opts) {
 	p.outro("Sync complete.");
 }
 //#endregion
-//#region src/commands/update.ts
-async function updateCommand(cwd, _opts) {
-	const repoRoot = cwd ?? findRepoRoot();
-	p.intro("Agent Bridge — Update Sources");
-	const config = await loadConfig(repoRoot);
-	const migrationResult = await runMigrations(repoRoot);
-	if (migrationResult) p.log.info(`Config upgraded ${migrationResult.fromVersion} → ${migrationResult.toVersion}` + (migrationResult.applied.length > 0 ? ` (${migrationResult.applied.length} migration(s))` : ""));
+//#region src/commands/init.ts
+const WELL_KNOWN_TOOLS = [
+	{
+		value: {
+			name: "vscode",
+			folder: ".github"
+		},
+		label: "VS Code (.github/)"
+	},
+	{
+		value: {
+			name: "cursor",
+			folder: ".cursor"
+		},
+		label: "Cursor (.cursor/)"
+	},
+	{
+		value: {
+			name: "claude",
+			folder: ".claude"
+		},
+		label: "Claude (.claude/)"
+	},
+	{
+		value: {
+			name: "pi",
+			folder: ".pi"
+		},
+		label: "Pi (.pi/)"
+	}
+];
+const WELL_KNOWN_TOOL_MAP = Object.fromEntries(WELL_KNOWN_TOOLS.map((t) => [t.value.name, t.value]));
+const CUSTOM_TOOL_SENTINEL = {
+	name: "__custom__",
+	folder: "__custom__"
+};
+/**
+* Derive a short source name from a URL or local path.
+*
+* Examples:
+*   https://github.com/org/repo.git  → repo
+*   git@github.com:org/repo.git      → repo
+*   file:///tmp/bare.git             → bare
+*   /path/to/my-folder               → my-folder
+*/
+function deriveSourceName(source) {
+	let segment = source;
+	const sshMatch = segment.match(/^[\w.-]+@[\w.-]+:(.+)$/);
+	if (sshMatch) segment = sshMatch[1];
+	try {
+		segment = new URL(segment).pathname;
+	} catch {}
+	return (segment.replace(/\/+$/, "").split("/").pop() ?? segment).replace(/\.git$/, "") || "source";
+}
+/**
+* Parse a comma-separated `--tools` argument into ToolConfig[].
+* Accepts well-known names (cursor, vscode, claude) or `name:folder` pairs.
+*/
+function parseToolsArg(input) {
+	return input.split(",").map((t) => {
+		const trimmed = t.trim();
+		if (!trimmed) throw new Error("Empty tool name in --tools");
+		if (WELL_KNOWN_TOOL_MAP[trimmed]) return WELL_KNOWN_TOOL_MAP[trimmed];
+		const colonIdx = trimmed.indexOf(":");
+		if (colonIdx > 0) return {
+			name: trimmed.slice(0, colonIdx),
+			folder: trimmed.slice(colonIdx + 1)
+		};
+		throw new Error(`Unknown tool "${trimmed}". Use a known name (${Object.keys(WELL_KNOWN_TOOL_MAP).join(", ")}) or name:folder format.`);
+	});
+}
+/**
+* Parse a single `--source` argument into a SourceConfig.
+* Supports `#branch` suffix for remote sources.
+*/
+function parseSourceArg(input, repoRoot) {
+	let source = input.trim();
+	let branch;
+	const hashIdx = source.lastIndexOf("#");
+	if (hashIdx > 0) {
+		branch = source.slice(hashIdx + 1);
+		source = source.slice(0, hashIdx);
+	}
+	if (!source) throw new Error("Empty source in --source");
+	const entry = {
+		name: deriveSourceName(source),
+		source
+	};
+	if (!isRemoteSource(entry.source)) entry.source = resolve(repoRoot, entry.source);
+	if (branch) entry.branch = branch;
+	return entry;
+}
+/**
+* Turn a per-domain selection into the `include` list stored in config.
+* Returns `undefined` when everything is selected (= sync the whole domain).
+* A fully selected feature type collapses to its name (`skills`).
+*/
+function buildInclude(contents, selected) {
+	const include = [];
+	let everything = true;
+	for (const ft of contents.featureTypes) {
+		const picked = ft.features.filter((f) => selected.has(`${ft.name}/${f}`));
+		if (picked.length === ft.features.length) include.push(ft.name);
+		else {
+			everything = false;
+			include.push(...picked.map((f) => `${ft.name}/${f}`));
+		}
+	}
+	for (const file of contents.files) if (selected.has(file)) include.push(file);
+	else everything = false;
+	return everything ? void 0 : include;
+}
+function cancelled(value) {
+	if (p.isCancel(value)) {
+		p.cancel("Setup cancelled.");
+		process.exit(1);
+	}
+	return false;
+}
+/** Clone remote sources / verify local ones. Exits on failure. */
+async function fetchSources(repoRoot, sources) {
+	await ensureBridgeGitignore(repoRoot);
 	const s = p.spinner();
-	s.start("Updating all remote sources…");
-	const results = await syncAllSources(repoRoot, config);
-	s.stop("Update complete");
-	for (const r of results) if (r.error) p.log.error(`${r.name}: ${r.error}`);
-	else p.log.info(`${r.name}: ${r.action}`);
-	const errors = results.filter((r) => r.error);
-	if (errors.length > 0) p.outro(`Done with ${errors.length} error(s).`);
-	else p.outro("All sources up to date.");
+	s.start("Fetching sources…");
+	const errors = (await Promise.all(sources.map((src) => syncSource(repoRoot, src)))).filter((r) => r.error);
+	if (errors.length > 0) {
+		s.stop("Some sources failed");
+		for (const err of errors) p.log.error(`${err.name}: ${err.error}`);
+		p.cancel("Fix the source URL/path and run `agent-bridge init` again.");
+		process.exit(1);
+	}
+	s.stop(`${sources.length} source(s) ready`);
+}
+async function maybeInstallHooks(repoRoot, force) {
+	const hookResult = await installGitHooks(repoRoot, force);
+	if (hookResult.installed.length > 0) p.log.success(`Installed git hooks: ${hookResult.installed.join(", ")}`);
+	if (hookResult.skipped.length > 0) {
+		p.log.warn(`Skipped hooks (existing non-Agent-Bridge hooks): ${hookResult.skipped.join(", ")}`);
+		p.log.info("Re-run `agent-bridge init --force` to overwrite, or integrate manually.");
+	}
+	for (const e of hookResult.errors) p.log.error(`Hook ${e.hook}: ${e.error}`);
+}
+async function promptTools() {
+	const selected = await p.multiselect({
+		message: "Which tools should receive synced files?",
+		options: [...WELL_KNOWN_TOOLS, {
+			value: CUSTOM_TOOL_SENTINEL,
+			label: "Other (add custom tool)"
+		}],
+		required: true
+	});
+	cancelled(selected);
+	const tools = selected.filter((t) => t.name !== CUSTOM_TOOL_SENTINEL.name);
+	if (!selected.some((t) => t.name === CUSTOM_TOOL_SENTINEL.name)) return tools;
+	for (;;) {
+		const name = await p.text({
+			message: "Custom tool name (used for <tool>-- prefix matching)",
+			placeholder: "windsurf",
+			validate: (v) => {
+				if (!v.trim()) return "Tool name cannot be empty";
+				if (tools.some((t) => t.name === v.trim())) return "Tool name already used";
+			}
+		});
+		if (p.isCancel(name)) break;
+		const folder = await p.text({
+			message: `Target folder for "${name}"`,
+			placeholder: `.${name}`,
+			validate: (v) => {
+				if (!v.trim()) return "Folder cannot be empty";
+				if (tools.some((t) => t.folder === v.trim())) return "Folder already used by another tool";
+			}
+		});
+		if (p.isCancel(folder)) break;
+		tools.push({
+			name: name.trim(),
+			folder: folder.trim()
+		});
+		const more = await p.confirm({
+			message: "Add another custom tool?",
+			initialValue: false
+		});
+		if (p.isCancel(more) || !more) break;
+	}
+	if (tools.length === 0) {
+		p.cancel("At least one tool is required.");
+		process.exit(1);
+	}
+	return tools;
+}
+async function promptSources(repoRoot) {
+	const sources = [];
+	p.log.info("Add at least one source — a Git URL or a local folder that follows the domain layout.");
+	for (;;) {
+		const input = await p.text({
+			message: sources.length === 0 ? "Source URL or local path" : "Another source URL or local path",
+			placeholder: "https://github.com/org/ai-hub.git",
+			validate: (v) => {
+				if (!v.trim()) return "Source URL/path cannot be empty";
+				const derived = deriveSourceName(v.trim());
+				if (sources.some((s) => s.name === derived)) return `Source name "${derived}" (derived from URL) already used`;
+			}
+		});
+		if (p.isCancel(input)) {
+			if (sources.length === 0) cancelled(input);
+			break;
+		}
+		const entry = parseSourceArg(input, repoRoot);
+		if (isRemoteSource(entry.source) && !entry.branch) {
+			const branch = await p.text({
+				message: "Branch (leave empty for the remote default)",
+				placeholder: "main",
+				defaultValue: ""
+			});
+			cancelled(branch);
+			if (branch.trim()) entry.branch = branch.trim();
+		}
+		sources.push(entry);
+		const more = await p.confirm({
+			message: "Add another source?",
+			initialValue: false
+		});
+		if (p.isCancel(more) || !more) break;
+	}
+	return sources;
+}
+/**
+* One checkbox tree: source → domain → feature type → feature (plus a
+* `files` group per domain). Ticking a node ticks everything beneath it.
+* Returns, per source, the picked domains with their `include` lists
+* (`undefined` include = whole domain).
+*/
+async function promptSelection(repoRoot, sources, toolNames) {
+	const SEP = "\0";
+	const contentsByKey = /* @__PURE__ */ new Map();
+	const tree = [];
+	for (const source of sources) {
+		const srcPath = resolveSourcePath(repoRoot, source);
+		const domains = await listDomains(srcPath);
+		if (domains.length === 0) {
+			p.log.warn(`${source.name}: no domain folders found — nothing to select.`);
+			continue;
+		}
+		const domainNodes = [];
+		for (const domain of domains) {
+			const contents = await listDomainContents(srcPath, domain, toolNames);
+			contentsByKey.set(`${source.name}${SEP}${domain}`, contents);
+			const prefix = `${source.name}${SEP}${domain}${SEP}`;
+			const children = contents.featureTypes.filter((ft) => ft.features.length > 0).map((ft) => ({
+				label: ft.name,
+				hint: `(${ft.features.length})`,
+				children: ft.features.map((f) => ({
+					label: f,
+					value: `${prefix}${ft.name}/${f}`
+				}))
+			}));
+			if (contents.files.length > 0) children.push({
+				label: "files",
+				children: contents.files.map((f) => ({
+					label: f,
+					value: `${prefix}${f}`
+				}))
+			});
+			const hint = contents.featureTypes.filter((ft) => ft.features.length > 0).map((ft) => `${ft.features.length} ${ft.name}`).join(", ");
+			domainNodes.push(children.length > 0 ? {
+				label: domain,
+				hint: hint ? `(${hint})` : void 0,
+				children
+			} : {
+				label: domain,
+				hint: "(empty)",
+				value: prefix
+			});
+		}
+		tree.push({
+			label: source.name,
+			children: domainNodes
+		});
+	}
+	if (tree.length === 0) {
+		p.cancel("No domains found in any source. Check the source layout: <source>/<domain>/<feature-type>/…");
+		process.exit(1);
+	}
+	const picked = await treeSelect({
+		message: "What do you want to sync? Tick a domain to take all of it, or open it and pick pieces.",
+		tree,
+		expandDepth: 1,
+		required: true
+	});
+	cancelled(picked);
+	const byDomain = /* @__PURE__ */ new Map();
+	for (const value of picked) {
+		const [sourceName, domain, rel] = value.split(SEP);
+		const key = `${sourceName}${SEP}${domain}`;
+		const set = byDomain.get(key) ?? /* @__PURE__ */ new Set();
+		if (rel) set.add(rel);
+		byDomain.set(key, set);
+	}
+	const result = /* @__PURE__ */ new Map();
+	for (const [key, rels] of byDomain) {
+		const [sourceName, domain] = key.split(SEP);
+		const contents = contentsByKey.get(key);
+		const include = rels.size === 0 ? void 0 : buildInclude(contents, rels);
+		const list = result.get(sourceName) ?? [];
+		list.push(include ? {
+			name: domain,
+			include
+		} : { name: domain });
+		result.set(sourceName, list);
+	}
+	return result;
+}
+async function initCommand(cwd, opts) {
+	const repoRoot = cwd ?? findRepoRoot();
+	if (await isOptedOut(repoRoot)) if (opts?.force) await removeOptOutMarker(repoRoot);
+	else {
+		p.log.warn(`${OPT_OUT_MARKER} present — Agent Bridge is opted out. Skipping init. Delete the file or run with --force to re-enable.`);
+		return;
+	}
+	const hasToolsArg = !!opts?.tools;
+	const hasSourceArg = !!(opts?.source && opts.source.length > 0);
+	if (hasToolsArg !== hasSourceArg) {
+		p.log.error("Both --tools and --source are required for non-interactive init.");
+		process.exit(1);
+	}
+	if (hasToolsArg && hasSourceArg) {
+		const tools = parseToolsArg(opts.tools);
+		const sources = opts.source.map((s) => parseSourceArg(s, repoRoot));
+		const seen = /* @__PURE__ */ new Set();
+		for (const s of sources) {
+			if (seen.has(s.name)) throw new Error(`Duplicate source name "${s.name}" derived from --source arguments`);
+			seen.add(s.name);
+		}
+		await fetchSources(repoRoot, sources);
+		const domainsArg = opts.domains ? opts.domains.split(",").map((d) => d.trim()).filter(Boolean) : void 0;
+		for (const source of sources) {
+			source.domains = (domainsArg ?? await listDomains(resolveSourcePath(repoRoot, source))).map((name) => ({ name }));
+			if (source.domains.length === 0) p.log.warn(`${source.name}: no domains found — add some or pass --domains.`);
+		}
+		await saveConfig(repoRoot, {
+			version: VERSION,
+			tools,
+			sources
+		});
+		p.log.success("Saved .agent-bridge/config.yml");
+		if (opts.hooks && isInGitRepo(repoRoot)) await maybeInstallHooks(repoRoot, opts.force === true);
+		p.outro("Done! Run `agent-bridge sync` to sync features.");
+		return;
+	}
+	p.intro("Agent Bridge — Project Setup");
+	if (await configExists(repoRoot)) {
+		const existing = await loadConfig(repoRoot);
+		p.log.info(`Config already exists with ${existing.sources.length} source(s). Finishing this setup will overwrite it.`);
+	}
+	const tools = await promptTools();
+	const sources = await promptSources(repoRoot);
+	await fetchSources(repoRoot, sources);
+	const picked = await promptSelection(repoRoot, sources, tools.map((t) => t.name));
+	for (const source of sources) source.domains = picked.get(source.name) ?? [];
+	const activeSources = sources.filter((s) => (s.domains?.length ?? 0) > 0);
+	for (const s of sources) if (!activeSources.includes(s)) p.log.warn(`${s.name}: no domains selected — source dropped from config.`);
+	await saveConfig(repoRoot, {
+		version: VERSION,
+		tools,
+		sources: activeSources
+	});
+	p.log.success("Saved .agent-bridge/config.yml — commit this file.");
+	if (isInGitRepo(repoRoot)) {
+		const installHooks = await p.confirm({
+			message: "Install git hooks to auto-sync after checkout/merge?",
+			initialValue: false
+		});
+		if (!p.isCancel(installHooks) && installHooks) await maybeInstallHooks(repoRoot, opts?.force === true);
+	}
+	const syncNow = await p.confirm({
+		message: "Run `agent-bridge sync` now?",
+		initialValue: true
+	});
+	if (!p.isCancel(syncNow) && syncNow) {
+		await syncCommand(repoRoot);
+		return;
+	}
+	p.outro("Done! Run `agent-bridge sync` whenever you want to pull the latest features.");
 }
 //#endregion
 //#region src/commands/opt-out.ts
@@ -1637,9 +2021,12 @@ function collect(value, previous) {
 	return previous;
 }
 const program = new Command().name("agent-bridge").description("Manage AI tool configurations from multiple sources").version(VERSION, "-v, --version");
-program.command("init").description("Initialize Agent Bridge (creates .agent-bridge/config.yml)").option("--cwd <path>", "Override the working directory").option("--force", "Overwrite existing non-Agent-Bridge git hooks").option("--domains <list>", "Comma-separated domain list (default: backend,frontend,shared)").option("--tools <list>", "Comma-separated tool names (cursor,vscode,claude) or name:folder pairs").option("-s, --source <url>", "Source URL or path (repeatable, append #branch for branch)", collect, []).option("--hooks", "Auto-install git hooks without prompting").action(await withCwdValidation(initCommand));
-program.command("sync").description("Fetch sources, discover features, and sync files").option("--cwd <path>", "Override the working directory").action(await withCwdValidation(syncCommand));
-program.command("update").description("Fetch latest changes for all remote sources").option("--cwd <path>", "Override the working directory").action(await withCwdValidation(updateCommand));
+program.command("init").description("Set up Agent Bridge: pick tools, sources and domains (creates .agent-bridge/config.yml)").option("--cwd <path>", "Override the working directory").option("--force", "Overwrite existing non-Agent-Bridge git hooks").option("--domains <list>", "Comma-separated domain list (default: every domain found in each source)").option("--tools <list>", "Comma-separated tool names (cursor,vscode,claude) or name:folder pairs").option("-s, --source <url>", "Source URL or path (repeatable, append #branch for branch)", collect, []).option("--hooks", "Auto-install git hooks without prompting").action(await withCwdValidation(initCommand));
+program.command("sync").description("Fetch the latest sources and sync features into your tool folders").option("--cwd <path>", "Override the working directory").action(await withCwdValidation(syncCommand));
+program.command("update", { hidden: true }).option("--cwd <path>", "Override the working directory").action(await withCwdValidation(async (cwd) => {
+	console.error("`agent-bridge update` is deprecated — running `agent-bridge sync` instead (it fetches sources too).");
+	await syncCommand(cwd);
+}));
 program.command("opt-out").description("Remove Agent Bridge hooks, synced files, and .agent-bridge state").option("--cwd <path>", "Override the working directory").action(await withCwdValidation(optOutCommand));
 program.parse();
 //#endregion