offworld 0.1.0

package/dist/src-CZHUGu1Q.mjs

@@ -0,0 +1,2447 @@
+import { existsSync, readFileSync, rmSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { os } from "@orpc/server";
+import { createCli } from "trpc-cli";
+import { z } from "zod";
+import * as p from "@clack/prompts";
+import { AuthenticationError, CommitExistsError, CommitNotFoundError, GitHubError, InvalidInputError, InvalidReferenceError, LowStarsError, NotLoggedInError, Paths, PrivateRepoError, RateLimitError, RepoExistsError, SyncRepoNotFoundError, TokenExpiredError, checkRemote, checkRemoteByName, cleanShellConfig, clearAuthData, cloneRepo, detectInstallMethod, detectInstalledAgents, discoverRepos, executeUninstall, executeUpgrade, fetchLatestVersion, gcRepos, generateReferenceWithAI, getAllAgentConfigs, getAuthPath, getAuthStatus, getClonedRepoPath, getCommitDistance, getCommitSha, getConfigPath, getCurrentVersion, getMapEntry, getMetaPath, getMetaRoot, getProvider, getReferencePath, getRepoRoot, getRepoStatus, getShellConfigFiles, getToken, installGlobalSkill, installReference, isRepoCloned, listProviders, listRepos, loadAuthData, loadConfig, matchDependenciesToReferences, parseDependencies, parseRepoInput, pruneRepos, pullReference, pullReferenceByName, pushReference, readGlobalMap, removeRepo, resolveDependencyRepo, saveAuthData, saveConfig, searchMap, toReferenceFileName, toReferenceName, updateAgentFiles, updateAllRepos, updateRepo, validateProviderModel, writeProjectMap } from "@offworld/sdk";
+import { AgentSchema, ConfigSchema } from "@offworld/types/schemas";
+import open from "open";
+import { homedir } from "node:os";
+
+//#region src/utils/spinner.ts
+var NoOpSpinner = class {
+	start(_message) {}
+	stop(_message) {}
+	message(_message) {}
+};
+/**
+* Creates a spinner that works in both TTY and non-TTY environments.
+* In TTY: returns a real @clack/prompts spinner with animation
+* In non-TTY: returns a no-op spinner that outputs nothing
+*
+* This prevents garbage output when running in non-interactive environments
+* (CI, piped output, agent sessions).
+*/
+function createSpinner() {
+	if (process.stdout.isTTY) return p.spinner();
+	return new NoOpSpinner();
+}
+/**
+* Check if running in a TTY environment
+*/
+const isTTY = process.stdout.isTTY ?? false;
+
+//#endregion
+//#region src/handlers/pull.ts
+function timestamp() {
+	return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
+}
+function verboseLog(message, verbose) {
+	if (verbose) p.log.info(`[${timestamp()}] ${message}`);
+}
+function getLocalMetaDir(source) {
+	return getMetaPath(source.type === "remote" ? source.fullName : source.name);
+}
+function loadLocalMeta(source) {
+	const metaPath = join(getLocalMetaDir(source), "meta.json");
+	if (!existsSync(metaPath)) return null;
+	try {
+		return JSON.parse(readFileSync(metaPath, "utf-8"));
+	} catch {
+		return null;
+	}
+}
+function hasValidCache(source, currentSha) {
+	return loadLocalMeta(source)?.commitSha?.slice(0, 7) === currentSha.slice(0, 7);
+}
+/**
+* Save remote reference to local filesystem.
+* Remote reference comes with pre-generated reference content.
+*/
+function saveRemoteReference(qualifiedName, referenceRepoName, localPath, referenceContent, commitSha, referenceUpdatedAt) {
+	installReference(qualifiedName, referenceRepoName, localPath, referenceContent, {
+		referenceUpdatedAt,
+		commitSha,
+		version: "0.1.0"
+	});
+}
+function parseModelFlag$1(model) {
+	if (!model) return {};
+	const parts = model.split("/");
+	if (parts.length === 2) return {
+		provider: parts[0],
+		model: parts[1]
+	};
+	return { model };
+}
+async function pullHandler(options) {
+	const { repo, shallow = false, sparse = false, branch, force = false, verbose = false } = options;
+	const referenceName = options.reference?.trim() || void 0;
+	const { provider, model } = parseModelFlag$1(options.model);
+	const config = loadConfig();
+	const isReferenceOverride = Boolean(referenceName);
+	const s = createSpinner();
+	if (verbose) p.log.info(`[verbose] Options: repo=${repo}, reference=${referenceName ?? "default"}, shallow=${shallow}, branch=${branch || "default"}, force=${force}`);
+	try {
+		s.start("Parsing repository input...");
+		const source = parseRepoInput(repo);
+		s.stop("Repository parsed");
+		verboseLog(`Parsed source: type=${source.type}, qualifiedName=${source.qualifiedName}`, verbose);
+		let repoPath;
+		if (source.type === "remote") {
+			const qualifiedName = source.qualifiedName;
+			if (isRepoCloned(qualifiedName)) {
+				s.start("Updating repository...");
+				const result = await updateRepo(qualifiedName);
+				repoPath = getClonedRepoPath(qualifiedName);
+				if (result.updated) s.stop(`Updated (${result.previousSha.slice(0, 7)} → ${result.currentSha.slice(0, 7)})`);
+				else s.stop("Already up to date");
+			} else {
+				s.start(`Cloning ${source.fullName}...`);
+				try {
+					repoPath = await cloneRepo(source, {
+						shallow,
+						sparse,
+						branch,
+						config,
+						force
+					});
+					s.stop("Repository cloned");
+					verboseLog(`Cloned to: ${repoPath}`, verbose);
+				} catch (err) {
+					if (err instanceof RepoExistsError && !force) {
+						s.stop("Repository exists");
+						throw err;
+					}
+					throw err;
+				}
+			}
+		} else repoPath = source.path;
+		const currentSha = getCommitSha(repoPath);
+		const qualifiedName = source.type === "remote" ? source.fullName : source.name;
+		if (isReferenceOverride && source.type !== "remote") throw new Error("--reference can only be used with remote repositories");
+		if (isReferenceOverride && !referenceName) throw new Error("--reference requires a reference name");
+		const requiredReferenceName = referenceName ?? "";
+		if (!force && !isReferenceOverride && hasValidCache(source, currentSha)) {
+			verboseLog("Using cached reference", verbose);
+			s.stop("Using cached reference");
+			return {
+				success: true,
+				repoPath,
+				referenceSource: "cached",
+				referenceInstalled: true
+			};
+		}
+		if (source.type === "remote" && (!force || isReferenceOverride)) {
+			verboseLog(`Checking offworld.sh for reference: ${source.fullName}`, verbose);
+			s.start("Checking offworld.sh for reference...");
+			try {
+				const remoteCheck = isReferenceOverride ? await checkRemoteByName(source.fullName, requiredReferenceName) : await checkRemote(source.fullName);
+				if (remoteCheck.exists && remoteCheck.commitSha) {
+					const remoteSha = remoteCheck.commitSha;
+					const remoteShaNorm = remoteSha.slice(0, 7);
+					const currentShaNorm = currentSha.slice(0, 7);
+					const MAX_COMMIT_DISTANCE = 20;
+					const commitDistance = getCommitDistance(repoPath, remoteSha, currentSha);
+					if (isReferenceOverride || remoteShaNorm === currentShaNorm || commitDistance !== null && commitDistance <= MAX_COMMIT_DISTANCE) {
+						if (!isReferenceOverride) if (commitDistance === 0 || remoteShaNorm === currentShaNorm) {
+							verboseLog(`Remote SHA matches (${remoteShaNorm})`, verbose);
+							s.stop("Remote reference found (exact match)");
+						} else if (commitDistance !== null) {
+							verboseLog(`Remote reference is ${commitDistance} commits behind (within ${MAX_COMMIT_DISTANCE} threshold)`, verbose);
+							s.stop(`Remote reference found (${commitDistance} commits behind)`);
+						} else {
+							verboseLog("Remote reference found (commit distance unknown)", verbose);
+							s.stop("Remote reference found");
+						}
+						else s.stop("Remote reference found");
+						const previewUrl = referenceName ? `https://offworld.sh/${source.fullName}/${encodeURIComponent(referenceName)}` : `https://offworld.sh/${source.fullName}`;
+						p.log.info(`Preview: ${previewUrl}`);
+						const useRemote = await p.confirm({
+							message: "Download this reference from offworld.sh?",
+							initialValue: true
+						});
+						if (p.isCancel(useRemote)) throw new Error("Operation cancelled");
+						if (!useRemote) {
+							if (isReferenceOverride) throw new Error("Remote reference download declined");
+							p.log.info("Skipping remote reference, generating locally...");
+						} else {
+							s.start("Downloading remote reference...");
+							const remoteReference = isReferenceOverride ? await pullReferenceByName(source.fullName, requiredReferenceName) : await pullReference(source.fullName);
+							if (remoteReference) {
+								s.stop("Downloaded remote reference");
+								saveRemoteReference(source.qualifiedName, source.fullName, repoPath, remoteReference.referenceContent, remoteReference.commitSha, remoteReference.generatedAt ?? (/* @__PURE__ */ new Date()).toISOString());
+								p.log.success(referenceName ? `Reference installed (${referenceName}) for: ${qualifiedName}` : `Reference installed for: ${qualifiedName}`);
+								return {
+									success: true,
+									repoPath,
+									referenceSource: "remote",
+									referenceInstalled: true
+								};
+							}
+							if (isReferenceOverride) throw new Error("Remote reference download failed");
+							s.stop("Remote download failed, generating locally...");
+						}
+					} else {
+						const distanceInfo = commitDistance !== null ? ` (${commitDistance} commits behind)` : "";
+						verboseLog(`Remote reference too outdated${distanceInfo}, threshold is ${MAX_COMMIT_DISTANCE}`, verbose);
+						s.stop(`Remote reference outdated${distanceInfo}`);
+					}
+				} else s.stop("No remote reference found");
+			} catch (err) {
+				verboseLog(`Remote check failed: ${err instanceof Error ? err.message : "Unknown"}`, verbose);
+				if (isReferenceOverride) throw err instanceof Error ? err : /* @__PURE__ */ new Error("Remote check failed");
+				s.stop("Remote check failed, continuing locally");
+			}
+		}
+		if (isReferenceOverride) throw new Error(`Reference not found on offworld.sh: ${referenceName}`);
+		verboseLog(`Starting AI reference generation for: ${repoPath}`, verbose);
+		if (!verbose) s.start("Generating reference with AI...");
+		try {
+			const { referenceContent, commitSha: referenceCommitSha } = await generateReferenceWithAI(repoPath, qualifiedName, {
+				provider,
+				model,
+				onDebug: verbose ? (message) => {
+					p.log.info(`[${timestamp()}] [debug] ${message}`);
+				} : (msg) => s.message(msg)
+			});
+			const meta = {
+				referenceUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				commitSha: referenceCommitSha,
+				version: "0.1.0"
+			};
+			const referenceRepoName = source.type === "remote" ? source.fullName : source.name;
+			installReference(source.qualifiedName, referenceRepoName, repoPath, referenceContent, meta);
+			if (!verbose) s.stop("Reference generated");
+			else p.log.success("Reference generated");
+			p.log.success(`Reference installed for: ${qualifiedName}`);
+			if (source.type === "remote") {
+				if (loadAuthData()?.token) p.log.info(`Run 'ow push ${source.fullName}' to share this reference to https://offworld.sh.`);
+			}
+			return {
+				success: true,
+				repoPath,
+				referenceSource: "local",
+				referenceInstalled: true
+			};
+		} catch (err) {
+			if (!verbose) s.stop("Reference generation failed");
+			const errMessage = err instanceof Error ? err.message : "Unknown error";
+			p.log.error(`Failed to generate reference: ${errMessage}`);
+			throw new Error(`Reference generation failed: ${errMessage}`);
+		}
+	} catch (error) {
+		s.stop("Failed");
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			repoPath: "",
+			referenceSource: "local",
+			referenceInstalled: false,
+			message
+		};
+	}
+}
+
+//#endregion
+//#region src/handlers/generate.ts
+function parseModelFlag(model) {
+	if (!model) return {};
+	const parts = model.split("/");
+	if (parts.length === 2) return {
+		provider: parts[0],
+		model: parts[1]
+	};
+	return { model };
+}
+async function generateHandler(options) {
+	const { repo, force = false } = options;
+	const { provider, model } = parseModelFlag(options.model);
+	const config = loadConfig();
+	const s = createSpinner();
+	try {
+		s.start("Parsing repository input...");
+		const source = parseRepoInput(repo);
+		s.stop("Repository parsed");
+		let repoPath;
+		if (source.type === "remote" && !force) {
+			s.start("Checking for existing remote reference...");
+			if ((await checkRemote(source.fullName)).exists) {
+				s.stop("Remote reference exists");
+				return {
+					success: false,
+					message: "Remote reference exists. Use --force to override."
+				};
+			}
+			s.stop("No remote reference found");
+		}
+		if (source.type === "remote") {
+			const qualifiedName = source.qualifiedName;
+			if (isRepoCloned(qualifiedName)) {
+				repoPath = getClonedRepoPath(qualifiedName);
+				p.log.info(`Using existing clone at ${repoPath}`);
+			} else {
+				s.start(`Cloning ${source.fullName}...`);
+				repoPath = await cloneRepo(source, {
+					shallow: config.defaultShallow,
+					config
+				});
+				s.stop("Repository cloned");
+			}
+		} else repoPath = source.path;
+		s.start("Generating reference with AI...");
+		const qualifiedName = source.qualifiedName;
+		const referenceRepoName = source.type === "remote" ? source.fullName : source.name;
+		const result = await generateReferenceWithAI(repoPath, referenceRepoName, {
+			provider,
+			model,
+			onDebug: (msg) => s.message(msg)
+		});
+		s.stop("Reference generated");
+		const { referenceContent, commitSha } = result;
+		const meta = {
+			referenceUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			commitSha,
+			version: "0.1.0"
+		};
+		const referencePath = getReferencePath(referenceRepoName);
+		installReference(qualifiedName, referenceRepoName, repoPath, referenceContent, meta);
+		p.log.success(`Reference saved to: ${referencePath}`);
+		p.log.info(`Reference installed for: ${qualifiedName}`);
+		return {
+			success: true,
+			referencePath
+		};
+	} catch (error) {
+		s.stop("Failed");
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			message
+		};
+	}
+}
+
+//#endregion
+//#region src/handlers/shared.ts
+/**
+* Format a repo entry for display
+*/
+function formatRepoForDisplay(item, showPaths) {
+	const parts = [item.fullName];
+	if (item.hasReference) parts.push("[reference]");
+	else parts.push("[no-reference]");
+	if (showPaths) parts.push(`(${item.localPath})`);
+	if (!item.exists) parts.push("[missing]");
+	return parts.join(" ");
+}
+
+//#endregion
+//#region src/handlers/repo.ts
+function formatBytes(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+	if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+	return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+function parseDays(olderThan) {
+	const match = olderThan.match(/^(\d+)d$/);
+	if (match?.[1]) return parseInt(match[1], 10);
+	return null;
+}
+function matchesPattern(name, pattern) {
+	if (!pattern || pattern === "*") return true;
+	return new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i").test(name);
+}
+async function repoListHandler(options) {
+	const { json = false, paths = false, pattern } = options;
+	const qualifiedNames = listRepos();
+	const map = readGlobalMap();
+	if (qualifiedNames.length === 0) {
+		if (!json) {
+			p.log.info("No repositories cloned yet.");
+			p.log.info("Use 'ow pull <repo>' to clone and generate a reference.");
+		}
+		return { repos: [] };
+	}
+	const items = [];
+	for (const qName of qualifiedNames) {
+		const entry = map.repos[qName];
+		if (!entry) continue;
+		if (pattern && !matchesPattern(qName, pattern)) continue;
+		const exists = existsSync(entry.localPath);
+		const hasReference = !!entry.primary;
+		items.push({
+			fullName: qName,
+			qualifiedName: qName,
+			localPath: entry.localPath,
+			hasReference,
+			referenceUpdatedAt: entry.updatedAt,
+			exists
+		});
+	}
+	if (json) console.log(JSON.stringify(items, null, 2));
+	else if (items.length === 0) {
+		if (pattern) p.log.info(`No repositories matching "${pattern}".`);
+	} else {
+		p.log.info(`Found ${items.length} repositories:\n`);
+		for (const item of items) console.log(formatRepoForDisplay(item, paths));
+	}
+	return { repos: items };
+}
+async function repoUpdateHandler(options) {
+	const { all = false, pattern, dryRun = false, unshallow = false } = options;
+	if (!all && !pattern) {
+		p.log.error("Specify --all or a pattern to update.");
+		return {
+			updated: [],
+			skipped: [],
+			unshallowed: [],
+			errors: []
+		};
+	}
+	const qualifiedNames = listRepos();
+	const total = (pattern ? qualifiedNames.filter((q) => matchesPattern(q, pattern)) : qualifiedNames).length;
+	if (total === 0) {
+		p.log.info(pattern ? `No repos matching "${pattern}"` : "No repos to update");
+		return {
+			updated: [],
+			skipped: [],
+			unshallowed: [],
+			errors: []
+		};
+	}
+	let processed = 0;
+	const outcomes = [];
+	const spinner = p.spinner();
+	const action = unshallow ? "Unshallowing" : "Updating";
+	spinner.start(dryRun ? `Checking ${total} repos...` : `${action} ${total} repos...`);
+	const result = await updateAllRepos({
+		pattern,
+		dryRun,
+		unshallow,
+		onProgress: (repo, status, message) => {
+			if (status === "updating") {
+				processed++;
+				spinner.message(`[${processed}/${total}] ${repo}`);
+			} else outcomes.push({
+				repo,
+				status,
+				message
+			});
+		}
+	});
+	spinner.stop(dryRun ? "Dry run complete" : `${action} complete`);
+	for (const { repo, status, message } of outcomes) if (status === "updated") p.log.success(`${repo}${message ? ` (${message})` : ""}`);
+	else if (status === "unshallowed") p.log.success(`${repo}: ${message}`);
+	else if (status === "error") p.log.error(`${repo}: ${message}`);
+	else if (status === "skipped" && message !== "up to date" && message !== "already up to date") p.log.warn(`${repo}: ${message}`);
+	const parts = [];
+	if (result.updated.length > 0) parts.push(`${result.updated.length} ${dryRun ? "would update" : "updated"}`);
+	if (result.unshallowed.length > 0) parts.push(`${result.unshallowed.length} unshallowed`);
+	if (result.skipped.length > 0) parts.push(`${result.skipped.length} skipped`);
+	if (result.errors.length > 0) parts.push(`${result.errors.length} failed`);
+	if (parts.length > 0) p.log.info(`Summary: ${parts.join(", ")}`);
+	return result;
+}
+async function repoPruneHandler(options) {
+	const { dryRun = false, yes = false, removeOrphans = false } = options;
+	const result = await pruneRepos({ dryRun: true });
+	const removedOrphans = [];
+	if (result.removedFromIndex.length === 0 && result.orphanedDirs.length === 0) {
+		p.log.info("Nothing to prune. Index and filesystem are in sync.");
+		return {
+			removedFromIndex: [],
+			orphanedDirs: [],
+			removedOrphans: []
+		};
+	}
+	if (result.removedFromIndex.length > 0) {
+		p.log.info(`Found ${result.removedFromIndex.length} repos in index but missing on disk:`);
+		for (const repo of result.removedFromIndex) console.log(`  - ${repo}`);
+	}
+	if (result.orphanedDirs.length > 0) {
+		p.log.info(`Found ${result.orphanedDirs.length} directories not in index:`);
+		for (const dir of result.orphanedDirs) console.log(`  - ${dir}`);
+	}
+	if (dryRun) {
+		p.log.info("Dry run - no changes made.");
+		return {
+			...result,
+			removedOrphans: []
+		};
+	}
+	let shouldProceed = yes;
+	if (!yes) {
+		const confirm = await p.confirm({ message: "Remove stale index entries?" });
+		if (p.isCancel(confirm)) {
+			p.log.info("Cancelled.");
+			return {
+				removedFromIndex: [],
+				orphanedDirs: result.orphanedDirs,
+				removedOrphans: []
+			};
+		}
+		shouldProceed = confirm;
+	}
+	if (shouldProceed) {
+		await pruneRepos({ dryRun: false });
+		p.log.success(`Removed ${result.removedFromIndex.length} stale index entries.`);
+	}
+	if (removeOrphans && result.orphanedDirs.length > 0) {
+		let shouldRemoveOrphans = yes;
+		if (!yes) {
+			const confirm = await p.confirm({ message: "Also remove orphaned directories?" });
+			if (!p.isCancel(confirm) && confirm) shouldRemoveOrphans = true;
+		}
+		if (shouldRemoveOrphans) {
+			for (const dir of result.orphanedDirs) {
+				rmSync(dir, {
+					recursive: true,
+					force: true
+				});
+				removedOrphans.push(dir);
+			}
+			p.log.success(`Removed ${removedOrphans.length} orphaned directories.`);
+		}
+	}
+	return {
+		...result,
+		removedOrphans
+	};
+}
+async function repoStatusHandler(options) {
+	const { json = false } = options;
+	const spinner = p.spinner();
+	spinner.start("Calculating repo status...");
+	const status = await getRepoStatus({ onProgress: (current, total, repo) => {
+		spinner.message(`[${current}/${total}] ${repo}`);
+	} });
+	spinner.stop("Status complete");
+	const output = {
+		total: status.total,
+		withReference: status.withReference,
+		missing: status.missing,
+		diskMB: Math.round(status.diskBytes / (1024 * 1024))
+	};
+	if (json) console.log(JSON.stringify(output, null, 2));
+	else {
+		p.log.info(`Managed repos: ${status.total}`);
+		p.log.info(`  With reference: ${status.withReference}`);
+		p.log.info(`  Missing: ${status.missing}`);
+		p.log.info(`  Disk usage: ${formatBytes(status.diskBytes)}`);
+	}
+	return output;
+}
+async function repoGcHandler(options) {
+	const { olderThan, withoutReference = false, dryRun = false, yes = false } = options;
+	if (!olderThan && !withoutReference) {
+		p.log.error("Specify at least one filter: --older-than or --without-reference");
+		return {
+			removed: [],
+			freedMB: 0
+		};
+	}
+	let olderThanDays;
+	if (olderThan) {
+		const days = parseDays(olderThan);
+		if (days === null) {
+			p.log.error("Invalid --older-than format. Use e.g. '30d' for 30 days.");
+			return {
+				removed: [],
+				freedMB: 0
+			};
+		}
+		olderThanDays = days;
+	}
+	const previewResult = await gcRepos({
+		olderThanDays,
+		withoutReference,
+		dryRun: true
+	});
+	if (previewResult.removed.length === 0) {
+		p.log.info("No repos match the criteria.");
+		return {
+			removed: [],
+			freedMB: 0
+		};
+	}
+	p.log.info(`Found ${previewResult.removed.length} repos to remove (${formatBytes(previewResult.freedBytes)}):`);
+	for (const { repo, reason, sizeBytes } of previewResult.removed) console.log(`  - ${repo} (${formatBytes(sizeBytes)}) - ${reason}`);
+	if (dryRun) {
+		p.log.info("Dry run - no changes made.");
+		return {
+			removed: previewResult.removed.map((r) => ({
+				repo: r.repo,
+				reason: r.reason,
+				sizeMB: Math.round(r.sizeBytes / (1024 * 1024))
+			})),
+			freedMB: Math.round(previewResult.freedBytes / (1024 * 1024))
+		};
+	}
+	let shouldProceed = yes;
+	if (!yes) {
+		const confirm = await p.confirm({ message: "Proceed with removal?" });
+		if (p.isCancel(confirm) || !confirm) {
+			p.log.info("Cancelled.");
+			return {
+				removed: [],
+				freedMB: 0
+			};
+		}
+		shouldProceed = true;
+	}
+	if (shouldProceed) {
+		const result = await gcRepos({
+			olderThanDays,
+			withoutReference,
+			dryRun: false
+		});
+		p.log.success(`Removed ${result.removed.length} repos, freed ${formatBytes(result.freedBytes)}`);
+		return {
+			removed: result.removed.map((r) => ({
+				repo: r.repo,
+				reason: r.reason,
+				sizeMB: Math.round(r.sizeBytes / (1024 * 1024))
+			})),
+			freedMB: Math.round(result.freedBytes / (1024 * 1024))
+		};
+	}
+	return {
+		removed: [],
+		freedMB: 0
+	};
+}
+async function repoDiscoverHandler(options) {
+	const { dryRun = false, yes = false } = options;
+	const repoRoot = getRepoRoot(loadConfig());
+	if (!existsSync(repoRoot)) {
+		p.log.error(`Repo root does not exist: ${repoRoot}`);
+		return {
+			discovered: 0,
+			alreadyIndexed: 0
+		};
+	}
+	const previewResult = await discoverRepos({
+		repoRoot,
+		dryRun: true
+	});
+	if (previewResult.discovered.length === 0) {
+		if (previewResult.alreadyIndexed > 0) p.log.info(`All ${previewResult.alreadyIndexed} repos already indexed.`);
+		else p.log.info("No repos found to discover.");
+		return {
+			discovered: 0,
+			alreadyIndexed: previewResult.alreadyIndexed
+		};
+	}
+	p.log.info(`Found ${previewResult.discovered.length} unindexed repos:`);
+	for (const repo of previewResult.discovered.slice(0, 20)) console.log(`  + ${repo.fullName}`);
+	if (previewResult.discovered.length > 20) console.log(`  ... and ${previewResult.discovered.length - 20} more`);
+	if (dryRun) {
+		p.log.info("Dry run - no changes made.");
+		return {
+			discovered: previewResult.discovered.length,
+			alreadyIndexed: previewResult.alreadyIndexed
+		};
+	}
+	let shouldProceed = yes;
+	if (!yes) {
+		const confirm = await p.confirm({ message: "Add these repos to the index?" });
+		if (p.isCancel(confirm) || !confirm) {
+			p.log.info("Cancelled.");
+			return {
+				discovered: 0,
+				alreadyIndexed: previewResult.alreadyIndexed
+			};
+		}
+		shouldProceed = true;
+	}
+	if (shouldProceed) {
+		const result = await discoverRepos({ repoRoot });
+		p.log.success(`Added ${result.discovered.length} repos to clone map (marked as not referenced)`);
+		return {
+			discovered: result.discovered.length,
+			alreadyIndexed: result.alreadyIndexed
+		};
+	}
+	return {
+		discovered: 0,
+		alreadyIndexed: previewResult.alreadyIndexed
+	};
+}
+
+//#endregion
+//#region src/handlers/push.ts
+/**
+* Push command handler
+*/
+const DESCRIPTION_MAX = 200;
+function extractDescription(referenceContent, fallback) {
+	const lines = referenceContent.split(/\r?\n/);
+	let sawTitle = false;
+	let description = "";
+	for (let i = 0; i < lines.length; i++) {
+		const line = lines[i]?.trim() ?? "";
+		if (!line) continue;
+		if (line.startsWith("# ")) {
+			sawTitle = true;
+			continue;
+		}
+		if (!sawTitle || line.startsWith("#")) continue;
+		description = line;
+		for (let j = i + 1; j < lines.length; j++) {
+			const next = lines[j]?.trim() ?? "";
+			if (!next || next.startsWith("#")) break;
+			description += ` ${next}`;
+		}
+		break;
+	}
+	description = description.replace(/\s+/g, " ").trim();
+	if (!description) description = fallback;
+	if (description.length > DESCRIPTION_MAX) description = description.slice(0, DESCRIPTION_MAX).trim();
+	if (!description) description = fallback.slice(0, DESCRIPTION_MAX);
+	return description;
+}
+/**
+* Load local reference data from disk.
+* Format: reference file + meta.json
+*/
+function loadLocalReference(metaDir, referencePath, fullName) {
+	const metaPath = join(metaDir, "meta.json");
+	if (!existsSync(referencePath) || !existsSync(metaPath)) return null;
+	try {
+		const referenceContent = readFileSync(referencePath, "utf-8");
+		const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+		return {
+			fullName: "",
+			referenceName: toReferenceName(fullName),
+			referenceDescription: extractDescription(referenceContent, `Reference for ${fullName}`),
+			referenceContent,
+			commitSha: meta.commitSha,
+			generatedAt: meta.referenceUpdatedAt
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Main push handler
+* Uploads local reference to offworld.sh
+*/
+async function pushHandler(options) {
+	const { repo } = options;
+	const s = createSpinner();
+	try {
+		let token;
+		try {
+			token = await getToken();
+		} catch (err) {
+			if (err instanceof NotLoggedInError || err instanceof TokenExpiredError) {
+				p.log.error(err.message);
+				return {
+					success: false,
+					message: err.message
+				};
+			}
+			throw err;
+		}
+		s.start("Parsing repository...");
+		const source = parseRepoInput(repo);
+		s.stop("Repository parsed");
+		if (source.type === "local") {
+			p.log.error("Local repositories cannot be pushed to offworld.sh.");
+			p.log.info("Only remote GitHub repositories can be pushed.");
+			return {
+				success: false,
+				message: "Local repositories not supported"
+			};
+		}
+		if (source.provider !== "github") {
+			p.log.error(`${source.provider} repositories are not yet supported.`);
+			p.log.info("GitHub support only for now - GitLab and Bitbucket coming soon!");
+			return {
+				success: false,
+				message: "Only GitHub repositories supported"
+			};
+		}
+		if (!isRepoCloned(source.qualifiedName)) {
+			p.log.error(`Repository ${source.fullName} is not cloned locally.`);
+			p.log.info(`Run 'ow pull ${source.fullName}' first to clone and analyze.`);
+			return {
+				success: false,
+				message: "Repository not cloned locally"
+			};
+		}
+		s.start("Loading local reference...");
+		const metaDir = getMetaPath(source.fullName);
+		const referencePath = getReferencePath(source.fullName);
+		if (!existsSync(metaDir) || !existsSync(referencePath)) {
+			s.stop("No reference found");
+			p.log.error(`No reference found for ${source.fullName}.`);
+			p.log.info(`Run 'ow generate ${source.fullName}' to generate reference.`);
+			return {
+				success: false,
+				message: "No local reference found"
+			};
+		}
+		const localReference = loadLocalReference(metaDir, referencePath, source.fullName);
+		if (!localReference) {
+			s.stop("Invalid reference");
+			p.log.error("Local reference is incomplete or corrupted.");
+			p.log.info(`Run 'ow generate ${source.fullName} --force' to regenerate.`);
+			return {
+				success: false,
+				message: "Local reference incomplete"
+			};
+		}
+		localReference.fullName = source.fullName;
+		const repoPath = getClonedRepoPath(source.qualifiedName);
+		if (repoPath) {
+			const currentSha = getCommitSha(repoPath);
+			if (currentSha !== localReference.commitSha) {
+				s.stop("Reference outdated");
+				p.log.warn("Local reference was generated for a different commit.");
+				p.log.info(`Reference: ${localReference.commitSha.slice(0, 7)}`);
+				p.log.info(`Current:  ${currentSha.slice(0, 7)}`);
+				p.log.info(`Run 'ow generate ${source.fullName} --force' to regenerate.`);
+				return {
+					success: false,
+					message: "Reference outdated - run generate to update"
+				};
+			}
+		}
+		s.stop("Reference loaded");
+		s.start("Uploading to offworld.sh...");
+		try {
+			const result = await pushReference(localReference, token);
+			if (result.success) {
+				s.stop("Reference uploaded!");
+				p.log.success(`Successfully pushed reference for ${source.fullName}`);
+				p.log.info(`View at: https://offworld.sh/${source.owner}/${source.repo}`);
+				return {
+					success: true,
+					message: "Reference pushed successfully"
+				};
+			}
+			s.stop("Upload failed");
+			p.log.error(result.message || "Unknown error during upload");
+			return {
+				success: false,
+				message: result.message || "Upload failed"
+			};
+		} catch (err) {
+			s.stop("Upload failed");
+			if (err instanceof AuthenticationError) {
+				p.log.error("Authentication failed.");
+				p.log.info("Please run 'ow auth login' again.");
+				return {
+					success: false,
+					message: "Authentication failed"
+				};
+			}
+			if (err instanceof RateLimitError) {
+				p.log.error("Rate limit exceeded.");
+				p.log.info("You can push up to 20 references per day.");
+				p.log.info("Please try again tomorrow.");
+				return {
+					success: false,
+					message: "Rate limit exceeded"
+				};
+			}
+			if (err instanceof CommitExistsError) {
+				p.log.error("A reference already exists for this commit.");
+				p.log.info(`Commit: ${localReference.commitSha.slice(0, 7)}`);
+				p.log.info("References are immutable per commit. Update the repo and regenerate to push a new version.");
+				return {
+					success: false,
+					message: "Reference already exists for this commit"
+				};
+			}
+			if (err instanceof InvalidInputError) {
+				p.log.error("Invalid input data.");
+				p.log.info(err.message);
+				return {
+					success: false,
+					message: err.message
+				};
+			}
+			if (err instanceof InvalidReferenceError) {
+				p.log.error("Invalid reference content.");
+				p.log.info(err.message);
+				p.log.info(`Run 'ow generate ${source.fullName} --force' to regenerate.`);
+				return {
+					success: false,
+					message: err.message
+				};
+			}
+			if (err instanceof SyncRepoNotFoundError) {
+				p.log.error("Repository not found on GitHub.");
+				p.log.info("Ensure the repository exists and is public.");
+				return {
+					success: false,
+					message: "Repository not found"
+				};
+			}
+			if (err instanceof LowStarsError) {
+				p.log.error("Repository does not meet star requirements.");
+				p.log.info("Repositories need at least 5 stars to be pushed to offworld.sh.");
+				p.log.info("This helps ensure quality skills for the community.");
+				return {
+					success: false,
+					message: "Repository needs 5+ stars"
+				};
+			}
+			if (err instanceof PrivateRepoError) {
+				p.log.error("Private repositories are not supported.");
+				p.log.info("Only public GitHub repositories can be pushed to offworld.sh.");
+				return {
+					success: false,
+					message: "Private repos not supported"
+				};
+			}
+			if (err instanceof CommitNotFoundError) {
+				p.log.error("Commit not found in repository.");
+				p.log.info("The analyzed commit may have been rebased or removed.");
+				p.log.info(`Run 'ow generate ${source.fullName} --force' to regenerate with current commit.`);
+				return {
+					success: false,
+					message: "Commit not found"
+				};
+			}
+			if (err instanceof GitHubError) {
+				p.log.error("GitHub API error.");
+				p.log.info(err.message);
+				p.log.info("Please try again later.");
+				return {
+					success: false,
+					message: "GitHub API error"
+				};
+			}
+			throw err;
+		}
+	} catch (error) {
+		s.stop("Failed");
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			message
+		};
+	}
+}
+
+//#endregion
+//#region src/handlers/remove.ts
+/**
+* Remove command handler
+*/
+function getAffectedPathsFromMap(qualifiedName) {
+	const entry = readGlobalMap().repos[qualifiedName];
+	if (!entry) return null;
+	const repoPath = entry.localPath;
+	const referenceFileName = entry.primary || "";
+	const referencePath = referenceFileName ? join(Paths.offworldReferencesDir, referenceFileName) : void 0;
+	return {
+		repoPath: existsSync(repoPath) ? repoPath : void 0,
+		referencePath: referencePath && existsSync(referencePath) ? referencePath : void 0,
+		symlinkPaths: []
+	};
+}
+async function rmHandler(options) {
+	const { repo, yes = false, referenceOnly = false, repoOnly = false, dryRun = false } = options;
+	try {
+		const source = parseRepoInput(repo);
+		const qualifiedName = source.qualifiedName;
+		const repoName = source.type === "remote" ? source.fullName : source.name;
+		if (referenceOnly && repoOnly) {
+			p.log.error("Cannot use --reference-only and --repo-only together");
+			return {
+				success: false,
+				message: "Invalid options"
+			};
+		}
+		const entry = readGlobalMap().repos[qualifiedName];
+		if (!entry && !referenceOnly) {
+			p.log.warn(`Repository not found in map: ${repo}`);
+			return {
+				success: false,
+				message: "Repository not found"
+			};
+		}
+		if (referenceOnly && !entry) return handleReferenceOnlyRemoval(repoName, yes, dryRun);
+		const affected = getAffectedPathsFromMap(qualifiedName);
+		if (dryRun || !yes) {
+			p.log.info("The following will be removed:");
+			if (!referenceOnly && affected.repoPath) console.log(`  Repository: ${affected.repoPath}`);
+			if (!repoOnly && affected.referencePath) console.log(`  Reference: ${affected.referencePath}`);
+			console.log("");
+		}
+		if (dryRun) {
+			p.log.info("Dry run - no files were deleted.");
+			return {
+				success: true,
+				removed: affected
+			};
+		}
+		if (!yes) {
+			const what = referenceOnly ? "reference files" : repoOnly ? "repository" : qualifiedName;
+			const confirm = await p.confirm({ message: `Are you sure you want to remove ${what}?` });
+			if (p.isCancel(confirm) || !confirm) {
+				p.log.info("Aborted.");
+				return {
+					success: false,
+					message: "Aborted by user"
+				};
+			}
+		}
+		const s = createSpinner();
+		const action = referenceOnly ? "Removing reference files..." : repoOnly ? "Removing repository..." : "Removing...";
+		s.start(action);
+		if (await removeRepo(qualifiedName, {
+			referenceOnly,
+			repoOnly
+		})) {
+			const doneMsg = referenceOnly ? "Reference files removed" : repoOnly ? "Repository removed" : "Removed";
+			s.stop(doneMsg);
+			p.log.success(`Removed: ${qualifiedName}`);
+			return {
+				success: true,
+				removed: affected
+			};
+		} else {
+			s.stop("Failed to remove");
+			return {
+				success: false,
+				message: "Failed to remove repository"
+			};
+		}
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			message
+		};
+	}
+}
+async function handleReferenceOnlyRemoval(repoName, yes, dryRun) {
+	const referenceFileName = toReferenceFileName(repoName);
+	const referencePath = join(Paths.offworldReferencesDir, referenceFileName);
+	const metaPath = getMetaPath(repoName);
+	if (!existsSync(referencePath) && !existsSync(metaPath)) {
+		p.log.warn(`No reference files found for: ${repoName}`);
+		return {
+			success: false,
+			message: "No reference files found"
+		};
+	}
+	if (dryRun || !yes) {
+		p.log.info("The following will be removed:");
+		if (existsSync(referencePath)) console.log(`  Reference: ${referencePath}`);
+		if (existsSync(metaPath)) console.log(`  Meta: ${metaPath}`);
+		console.log("");
+	}
+	if (dryRun) {
+		p.log.info("Dry run - no files were deleted.");
+		return {
+			success: true,
+			removed: { referencePath }
+		};
+	}
+	if (!yes) {
+		const confirm = await p.confirm({ message: `Are you sure you want to remove reference files for ${repoName}?` });
+		if (p.isCancel(confirm) || !confirm) {
+			p.log.info("Aborted.");
+			return {
+				success: false,
+				message: "Aborted by user"
+			};
+		}
+	}
+	const s = createSpinner();
+	s.start("Removing reference files...");
+	if (existsSync(referencePath)) rmSync(referencePath, { force: true });
+	if (existsSync(metaPath)) rmSync(metaPath, {
+		recursive: true,
+		force: true
+	});
+	s.stop("Reference files removed");
+	p.log.success(`Removed reference files for: ${repoName}`);
+	return {
+		success: true,
+		removed: { referencePath }
+	};
+}
+
+//#endregion
+//#region src/handlers/config.ts
+/**
+* Config command handlers
+*/
+const VALID_KEYS = [
+	"repoRoot",
+	"defaultShallow",
+	"defaultModel",
+	"agents"
+];
+function isValidKey(key) {
+	return VALID_KEYS.includes(key);
+}
+async function configShowHandler(options) {
+	const config = loadConfig();
+	const projectMapPath = resolve(process.cwd(), ".offworld/map.json");
+	const hasProjectMap = existsSync(projectMapPath);
+	const paths = {
+		skillDir: join(Paths.data, "skill", "offworld"),
+		referencesDir: join(Paths.data, "skill", "offworld", "references"),
+		globalMap: join(Paths.data, "skill", "offworld", "assets", "map.json")
+	};
+	if (hasProjectMap) paths.projectMap = projectMapPath;
+	if (options.json) {
+		const output = {
+			...config,
+			paths
+		};
+		console.log(JSON.stringify(output, null, 2));
+	} else {
+		p.log.info("Current configuration:\n");
+		for (const [key, value] of Object.entries(config)) console.log(`  ${key}: ${JSON.stringify(value)}`);
+		console.log("");
+		p.log.info(`Config file: ${getConfigPath()}`);
+		if (hasProjectMap) p.log.info(`Project map: ${projectMapPath}`);
+	}
+	return {
+		config,
+		paths
+	};
+}
+async function configSetHandler(options) {
+	const { key, value } = options;
+	if (!isValidKey(key)) {
+		p.log.error(`Invalid config key: ${key}`);
+		p.log.info(`Valid keys: ${VALID_KEYS.join(", ")}`);
+		return {
+			success: false,
+			message: `Invalid key: ${key}`
+		};
+	}
+	let parsedValue;
+	if (key === "defaultShallow") if (value === "true" || value === "1") parsedValue = true;
+	else if (value === "false" || value === "0") parsedValue = false;
+	else {
+		p.log.error(`Invalid boolean value: ${value}. Use 'true' or 'false'.`);
+		return {
+			success: false,
+			message: `Invalid boolean value: ${value}`
+		};
+	}
+	else if (key === "agents") {
+		const agentValues = value.split(",").map((a) => a.trim()).filter(Boolean);
+		const validAgents = AgentSchema.options;
+		const invalidAgents = agentValues.filter((a) => !validAgents.includes(a));
+		if (invalidAgents.length > 0) {
+			p.log.error(`Invalid agent(s): ${invalidAgents.join(", ")}`);
+			p.log.info(`Valid agents: ${validAgents.join(", ")}`);
+			return {
+				success: false,
+				message: `Invalid agents: ${invalidAgents.join(", ")}`
+			};
+		}
+		parsedValue = agentValues;
+	} else parsedValue = value;
+	try {
+		saveConfig({ [key]: parsedValue });
+		p.log.success(`Set ${key} = ${JSON.stringify(parsedValue)}`);
+		return {
+			success: true,
+			key,
+			value: parsedValue
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			message
+		};
+	}
+}
+async function configGetHandler(options) {
+	const { key } = options;
+	const config = loadConfig();
+	if (!isValidKey(key)) {
+		p.log.error(`Invalid config key: ${key}`);
+		p.log.info(`Valid keys: ${VALID_KEYS.join(", ")}`);
+		return {
+			key,
+			value: null
+		};
+	}
+	const value = config[key];
+	console.log(JSON.stringify(value));
+	return {
+		key,
+		value
+	};
+}
+async function configResetHandler() {
+	try {
+		const defaults = ConfigSchema.parse({});
+		saveConfig(defaults);
+		p.log.success("Configuration reset to defaults:");
+		for (const [key, value] of Object.entries(defaults)) console.log(`  ${key}: ${JSON.stringify(value)}`);
+		return { success: true };
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return { success: false };
+	}
+}
+async function configPathHandler() {
+	const path = getConfigPath();
+	console.log(path);
+	return { path };
+}
+async function configAgentsHandler() {
+	const config = loadConfig();
+	const detectedAgents = detectInstalledAgents();
+	const allAgentConfigs = getAllAgentConfigs();
+	if (detectedAgents.length > 0) {
+		const detectedNames = detectedAgents.map((a) => allAgentConfigs.find((c) => c.name === a)?.displayName ?? a).join(", ");
+		p.log.info(`Detected agents: ${detectedNames}`);
+	}
+	const agentOptions = allAgentConfigs.map((cfg) => ({
+		value: cfg.name,
+		label: cfg.displayName,
+		hint: cfg.globalSkillsDir
+	}));
+	const initialAgents = config.agents && config.agents.length > 0 ? config.agents : detectedAgents;
+	const agentsResult = await p.multiselect({
+		message: "Select agents to install skills to",
+		options: agentOptions,
+		initialValues: initialAgents,
+		required: false
+	});
+	if (p.isCancel(agentsResult)) {
+		p.log.warn("Cancelled");
+		return { success: false };
+	}
+	const agents = agentsResult;
+	try {
+		saveConfig({ agents });
+		p.log.success(`Agents set to: ${agents.join(", ") || "(none)"}`);
+		return {
+			success: true,
+			agents
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return { success: false };
+	}
+}
+
+//#endregion
+//#region src/handlers/auth.ts
+/**
+* Auth command handlers
+* Uses WorkOS Device Authorization Grant for CLI authentication
+*/
+const WORKOS_API = "https://api.workos.com";
+function getWorkosClientId() {
+	return process.env.WORKOS_CLIENT_ID || "";
+}
+function extractJwtExpiration(token) {
+	try {
+		const parts = token.split(".");
+		if (parts.length !== 3) return void 0;
+		const payload = parts[1];
+		if (!payload) return void 0;
+		const decoded = JSON.parse(Buffer.from(payload, "base64").toString("utf-8"));
+		if (typeof decoded.exp !== "number") return void 0;
+		return (/* @__PURE__ */ new Date(decoded.exp * 1e3)).toISOString();
+	} catch {
+		return;
+	}
+}
+async function requestDeviceCode() {
+	const response = await fetch(`${WORKOS_API}/user_management/authorize/device`, {
+		method: "POST",
+		headers: { "Content-Type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({ client_id: getWorkosClientId() })
+	});
+	if (!response.ok) {
+		const error = await response.text();
+		throw new Error(`Failed to request device code: ${error}`);
+	}
+	return response.json();
+}
+async function pollForTokens(deviceCode, interval, onStatus) {
+	let pollInterval = interval;
+	while (true) {
+		const response = await fetch(`${WORKOS_API}/user_management/authenticate`, {
+			method: "POST",
+			headers: { "Content-Type": "application/x-www-form-urlencoded" },
+			body: new URLSearchParams({
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+				device_code: deviceCode,
+				client_id: getWorkosClientId()
+			})
+		});
+		if (response.ok) return response.json();
+		const data = await response.json();
+		switch (data.error) {
+			case "authorization_pending":
+				onStatus?.("Waiting for approval...");
+				await sleep(pollInterval * 1e3);
+				break;
+			case "slow_down":
+				pollInterval += 5;
+				onStatus?.("Slowing down polling...");
+				await sleep(pollInterval * 1e3);
+				break;
+			case "access_denied": throw new Error("Authorization denied by user");
+			case "expired_token": throw new Error("Device code expired. Please try again.");
+			default: throw new Error(`Authentication failed: ${data.error}`);
+		}
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function authLoginHandler() {
+	if (!getWorkosClientId()) {
+		p.log.error("WORKOS_CLIENT_ID not configured.");
+		p.log.info("For local development, create apps/cli/.env with:");
+		p.log.info("  WORKOS_CLIENT_ID=your_client_id");
+		p.log.info("  CONVEX_URL=your_convex_url");
+		return {
+			success: false,
+			message: "WORKOS_CLIENT_ID not configured"
+		};
+	}
+	const s = createSpinner();
+	const currentStatus = await getAuthStatus();
+	if (currentStatus.isLoggedIn) {
+		p.log.info(`Already logged in as ${currentStatus.email || "unknown user"}`);
+		const shouldRelogin = await p.confirm({ message: "Do you want to log in again?" });
+		if (!shouldRelogin || p.isCancel(shouldRelogin)) return {
+			success: true,
+			email: currentStatus.email
+		};
+	}
+	s.start("Requesting device code...");
+	let deviceData;
+	try {
+		deviceData = await requestDeviceCode();
+	} catch (error) {
+		s.stop("Failed to get device code");
+		return {
+			success: false,
+			message: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+	s.stop();
+	p.log.info(`\nOpen this URL in your browser:\n`);
+	p.log.info(`  ${deviceData.verification_uri_complete}\n`);
+	p.log.info(`Or go to ${deviceData.verification_uri} and enter code: ${deviceData.user_code}\n`);
+	try {
+		await open(deviceData.verification_uri_complete);
+	} catch {}
+	s.start("Waiting for approval...");
+	try {
+		const tokenData = await pollForTokens(deviceData.device_code, deviceData.interval, (status) => {
+			s.message(status);
+		});
+		s.stop("Login successful!");
+		const expiresAt = tokenData.expires_at ? (/* @__PURE__ */ new Date(tokenData.expires_at * 1e3)).toISOString() : extractJwtExpiration(tokenData.access_token);
+		saveAuthData({
+			token: tokenData.access_token,
+			email: tokenData.user.email,
+			workosId: tokenData.user.id,
+			refreshToken: tokenData.refresh_token,
+			expiresAt
+		});
+		p.log.success(`Logged in as ${tokenData.user.email}`);
+		return {
+			success: true,
+			email: tokenData.user.email
+		};
+	} catch (error) {
+		s.stop("Login failed");
+		return {
+			success: false,
+			message: error instanceof Error ? error.message : "Unknown error"
+		};
+	}
+}
+/**
+* Handles 'ow auth logout' command
+* Clears stored session token
+*/
+async function authLogoutHandler() {
+	if (!(await getAuthStatus()).isLoggedIn) {
+		p.log.info("Not currently logged in");
+		return {
+			success: true,
+			message: "Not logged in"
+		};
+	}
+	if (clearAuthData()) {
+		p.log.success("Logged out successfully");
+		return {
+			success: true,
+			message: "Logged out successfully"
+		};
+	}
+	p.log.warn("Could not clear auth data");
+	return {
+		success: false,
+		message: "Could not clear auth data"
+	};
+}
+/**
+* Handles 'ow auth status' command
+* Shows current authentication status
+*/
+async function authStatusHandler() {
+	const status = await getAuthStatus();
+	if (status.isLoggedIn) {
+		p.log.info(`Logged in as: ${status.email || "unknown"}`);
+		if (status.expiresAt) {
+			const expiresDate = new Date(status.expiresAt);
+			p.log.info(`Session expires: ${expiresDate.toLocaleString()}`);
+		}
+		p.log.info(`Auth file: ${getAuthPath()}`);
+	} else {
+		p.log.info("Not logged in");
+		p.log.info("Run 'ow auth login' to authenticate");
+	}
+	return {
+		loggedIn: status.isLoggedIn,
+		email: status.email,
+		workosId: status.workosId,
+		expiresAt: status.expiresAt
+	};
+}
+
+//#endregion
+//#region src/handlers/init.ts
+const DEFAULT_PROVIDER = "anthropic";
+const MAX_SELECT_ITEMS = 15;
+function expandTilde(path) {
+	if (path.startsWith("~/")) return resolve(homedir(), path.slice(2));
+	return resolve(path);
+}
+function collapseTilde(path) {
+	const home = homedir();
+	if (path.startsWith(home)) return "~" + path.slice(home.length);
+	return path;
+}
+function validatePath(value) {
+	if (!value.trim()) return "Path cannot be empty";
+}
+function detectProjectRoot$1() {
+	let currentDir = process.cwd();
+	while (currentDir !== homedir()) {
+		if (existsSync(join(currentDir, "package.json"))) return currentDir;
+		const parent = dirname(currentDir);
+		if (parent === currentDir) break;
+		currentDir = parent;
+	}
+	return null;
+}
+async function initHandler(options = {}) {
+	const configPath = getConfigPath();
+	const existingConfig = loadConfig();
+	const configExists = existsSync(configPath);
+	const projectRoot = detectProjectRoot$1();
+	p.intro("ow init");
+	if (!options.skipAuth) {
+		if (!(await getAuthStatus()).isLoggedIn) {
+			p.log.info("You are not logged in");
+			const shouldLogin = await p.confirm({
+				message: "Do you want to log in now?",
+				initialValue: true
+			});
+			if (!p.isCancel(shouldLogin) && shouldLogin) await authLoginHandler();
+		}
+	}
+	if (configExists) {
+		if (!options.force) {
+			if (projectRoot) {
+				p.log.warn(`Global config already exists at ${configPath}`);
+				p.log.info("");
+				p.log.info("Did you mean to run project setup? Use:");
+				p.log.info("  ow project init");
+				p.log.info("");
+				p.log.info("To reconfigure global settings, use:");
+				p.log.info("  ow init --force");
+				p.outro("");
+				return {
+					success: false,
+					configPath
+				};
+			}
+			p.log.warn("Already configured. Use --force to reconfigure.");
+			p.outro("");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		p.log.info("Reconfiguring global settings...");
+	}
+	let repoRoot;
+	if (options.repoRoot) repoRoot = collapseTilde(expandTilde(options.repoRoot));
+	else {
+		const repoRootResult = await p.text({
+			message: "Where should repositories be cloned?",
+			placeholder: "~/ow",
+			initialValue: existingConfig.repoRoot,
+			validate: validatePath
+		});
+		if (p.isCancel(repoRootResult)) {
+			p.outro("Setup cancelled");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		repoRoot = collapseTilde(expandTilde(repoRootResult));
+	}
+	let provider;
+	let model;
+	if (options.model) {
+		const parts = options.model.split("/");
+		if (parts.length !== 2) {
+			p.log.error(`Invalid model format. Expected 'provider/model', got '${options.model}'`);
+			p.outro("Setup failed");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		provider = parts[0];
+		model = parts[1];
+		const validation = await validateProviderModel(provider, model);
+		if (!validation.valid) {
+			p.log.error(validation.error);
+			p.outro("Setup failed");
+			return {
+				success: false,
+				configPath
+			};
+		}
+	} else {
+		const spin = p.spinner();
+		spin.start("Fetching available providers...");
+		let providers;
+		try {
+			providers = await listProviders();
+		} catch (err) {
+			spin.stop("Failed to fetch providers");
+			p.log.error(err instanceof Error ? err.message : "Network error");
+			p.outro("Setup failed");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		spin.stop("Loaded providers from models.dev");
+		const priorityProviders = [
+			"opencode",
+			"anthropic",
+			"openai",
+			"google"
+		];
+		const providerOptions = [...providers.filter((p) => priorityProviders.includes(p.id)), ...providers.filter((p) => !priorityProviders.includes(p.id)).sort((a, b) => a.name.localeCompare(b.name))].map((prov) => ({
+			value: prov.id,
+			label: prov.name
+		}));
+		const currentProvider = existingConfig.defaultModel?.split("/")[0];
+		const providerResult = await p.select({
+			message: "Select your AI provider",
+			options: providerOptions,
+			initialValue: currentProvider ?? DEFAULT_PROVIDER,
+			maxItems: MAX_SELECT_ITEMS
+		});
+		if (p.isCancel(providerResult)) {
+			p.outro("Setup cancelled");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		provider = providerResult;
+		spin.start("Fetching models...");
+		const providerData = await getProvider(provider);
+		spin.stop(`Loaded ${providerData?.models.length ?? 0} models`);
+		if (!providerData || providerData.models.length === 0) {
+			p.log.error(`No models found for provider "${provider}"`);
+			p.outro("Setup failed");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		const modelOptions = providerData.models.map((m) => ({
+			value: m.id,
+			label: m.name,
+			hint: m.reasoning ? "reasoning" : m.status === "beta" ? "beta" : void 0
+		}));
+		const currentModel = existingConfig.defaultModel?.split("/")[1];
+		const modelResult = await p.select({
+			message: "Select your default model",
+			options: modelOptions,
+			initialValue: currentModel,
+			maxItems: MAX_SELECT_ITEMS
+		});
+		if (p.isCancel(modelResult)) {
+			p.outro("Setup cancelled");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		model = modelResult;
+	}
+	const detectedAgents = detectInstalledAgents();
+	const allAgentConfigs = getAllAgentConfigs();
+	if (detectedAgents.length > 0) {
+		const detectedNames = detectedAgents.map((a) => allAgentConfigs.find((c) => c.name === a)?.displayName ?? a).join(", ");
+		p.log.info(`Detected agents: ${detectedNames}`);
+	}
+	const agentOptions = allAgentConfigs.map((config) => ({
+		value: config.name,
+		label: config.displayName,
+		hint: config.globalSkillsDir
+	}));
+	let agents;
+	if (options.agents) {
+		const agentNames = options.agents.split(",").map((a) => a.trim());
+		const validAgents = allAgentConfigs.filter((c) => agentNames.includes(c.name)).map((c) => c.name);
+		if (validAgents.length === 0) {
+			p.log.error("No valid agent names provided");
+			p.outro("Setup failed");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		agents = validAgents;
+	} else {
+		const initialAgents = existingConfig.agents && existingConfig.agents.length > 0 ? existingConfig.agents : detectedAgents;
+		const agentsResult = await p.multiselect({
+			message: "Select agents to install skills to",
+			options: agentOptions,
+			initialValues: initialAgents,
+			required: false
+		});
+		if (p.isCancel(agentsResult)) {
+			p.outro("Setup cancelled");
+			return {
+				success: false,
+				configPath
+			};
+		}
+		agents = agentsResult;
+	}
+	const defaultModel = `${provider}/${model}`;
+	const newConfig = {
+		repoRoot,
+		defaultModel,
+		agents
+	};
+	try {
+		saveConfig(newConfig);
+		installGlobalSkill();
+		p.log.success("Configuration saved!");
+		p.log.info(`  Config file: ${configPath}`);
+		p.log.info(`  Repo root: ${repoRoot}`);
+		p.log.info(`  Meta root: ${getMetaRoot()}`);
+		p.log.info(`  State root: ${Paths.state}`);
+		p.log.info(`  Model: ${defaultModel}`);
+		p.log.info(`  Agents: ${agents.join(", ")}`);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(`Failed to save configuration: ${message}`);
+		p.outro("Setup failed");
+		return {
+			success: false,
+			configPath
+		};
+	}
+	const expandedRepoRoot = expandTilde(repoRoot);
+	if (existsSync(expandedRepoRoot)) {
+		const previewResult = await discoverRepos({
+			repoRoot: expandedRepoRoot,
+			dryRun: true
+		});
+		if (previewResult.discovered.length > 0) {
+			p.log.info("");
+			p.log.info(`Found ${previewResult.discovered.length} existing repos in ${repoRoot}`);
+			let shouldDiscover = options.yes;
+			if (!options.yes) {
+				const confirmDiscover = await p.confirm({
+					message: "Add them to your clone map? (they will be marked as not referenced)",
+					initialValue: true
+				});
+				if (!p.isCancel(confirmDiscover)) shouldDiscover = confirmDiscover;
+			}
+			if (shouldDiscover) {
+				const result = await discoverRepos({ repoRoot: expandedRepoRoot });
+				p.log.success(`Added ${result.discovered.length} repos to clone map`);
+			}
+		}
+	}
+	p.outro("Setup complete. Run 'ow pull <repo>' to get started.");
+	return {
+		success: true,
+		configPath
+	};
+}
+
+//#endregion
+//#region src/handlers/project.ts
+function detectProjectRoot() {
+	let currentDir = process.cwd();
+	while (currentDir !== homedir()) {
+		if (existsSync(join(currentDir, ".git"))) return currentDir;
+		const parent = dirname(currentDir);
+		if (parent === currentDir) break;
+		currentDir = parent;
+	}
+	return null;
+}
+async function projectInitHandler(options = {}) {
+	p.intro("ow project init");
+	if (!existsSync(getConfigPath())) {
+		p.log.error("No global config found. Run 'ow init' first to set up global configuration.");
+		p.outro("");
+		return {
+			success: false,
+			message: "No global config found"
+		};
+	}
+	if (!loadConfig().defaultModel) {
+		p.log.error("Global config is missing AI settings. Run 'ow init --force' to reconfigure.");
+		p.outro("");
+		return {
+			success: false,
+			message: "Invalid global config"
+		};
+	}
+	const projectRoot = detectProjectRoot() || process.cwd();
+	p.log.info(`Project root: ${projectRoot}`);
+	p.log.step("Scanning dependencies...");
+	const dependencies = parseDependencies(projectRoot);
+	if (dependencies.length === 0) {
+		p.log.warn("No dependencies found in manifest files.");
+		p.outro("");
+		return {
+			success: true,
+			message: "No dependencies found"
+		};
+	}
+	p.log.info(`Found ${dependencies.length} dependencies`);
+	p.log.step("Resolving GitHub repositories...");
+	const resolvedPromises = dependencies.map((dep) => resolveDependencyRepo(dep.name));
+	const resolved = await Promise.all(resolvedPromises);
+	const skipList = options.skip ? options.skip.split(",").map((d) => d.trim()) : [];
+	const depsList = options.deps ? options.deps.split(",").map((d) => d.trim()) : [];
+	let filtered = resolved.filter((r) => {
+		if (r.source === "unknown") return false;
+		if (skipList.includes(r.dep)) return false;
+		if (depsList.length > 0) return depsList.includes(r.dep);
+		return true;
+	});
+	if (filtered.length === 0) {
+		p.log.warn("No resolvable dependencies after filtering.");
+		p.outro("");
+		return {
+			success: true,
+			message: "No resolvable dependencies"
+		};
+	}
+	const matches = matchDependenciesToReferences(filtered);
+	let selected;
+	if (options.all || options.deps) selected = matches;
+	else {
+		const checklistOptions = matches.map((m) => {
+			return {
+				value: m,
+				label: `${m.dep} (${m.repo}) - ${m.status}`,
+				hint: m.status
+			};
+		});
+		const selectedResult = await p.multiselect({
+			message: "Select dependencies to install references for:",
+			options: checklistOptions,
+			required: false
+		});
+		if (p.isCancel(selectedResult)) {
+			p.cancel("Operation cancelled");
+			return {
+				success: false,
+				message: "Cancelled by user"
+			};
+		}
+		selected = selectedResult;
+	}
+	if (selected.length === 0) {
+		p.log.warn("No dependencies selected.");
+		p.outro("");
+		return {
+			success: true,
+			message: "No dependencies selected"
+		};
+	}
+	if (!options.yes && !options.dryRun) {
+		const confirm = await p.confirm({ message: `Install references for ${selected.length} dependencies?` });
+		if (p.isCancel(confirm) || !confirm) {
+			p.cancel("Operation cancelled");
+			return {
+				success: false,
+				message: "Cancelled by user"
+			};
+		}
+	}
+	if (options.dryRun) {
+		p.log.info("");
+		p.log.info("Dry run - would install references for:");
+		for (const match of selected) p.log.info(`  - ${match.dep} (${match.repo})`);
+		p.outro("Dry run complete");
+		return {
+			success: true,
+			message: "Dry run complete"
+		};
+	}
+	p.log.step(`Installing ${selected.length} references...`);
+	const installed = [];
+	let failedCount = 0;
+	for (const match of selected) try {
+		if (!match.repo) continue;
+		p.log.info(`Installing reference for ${match.dep}...`);
+		const pullResult = await pullHandler({
+			repo: match.repo,
+			shallow: true,
+			force: options.generate,
+			verbose: false
+		});
+		if (pullResult.success && pullResult.referenceInstalled) {
+			const referencePath = getReferencePath(match.repo);
+			installed.push({
+				dependency: match.dep,
+				reference: toReferenceFileName(match.repo),
+				path: referencePath
+			});
+		} else {
+			p.log.warn(`Failed to install reference for ${match.dep}`);
+			failedCount++;
+		}
+	} catch (error) {
+		const errMsg = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(`Error installing ${match.dep}: ${errMsg}`);
+		failedCount++;
+	}
+	const map = readGlobalMap();
+	writeProjectMap(projectRoot, Object.fromEntries(selected.filter((m) => m.repo).map((m) => {
+		const qualifiedName = `github.com:${m.repo}`;
+		const entry = map.repos[qualifiedName];
+		return [qualifiedName, {
+			localPath: entry?.localPath ?? "",
+			reference: toReferenceFileName(m.repo),
+			keywords: entry?.keywords ?? []
+		}];
+	})));
+	if (installed.length > 0) {
+		p.log.step("Updating AGENTS.md...");
+		try {
+			updateAgentFiles(projectRoot, installed);
+			p.log.success("AGENTS.md updated");
+		} catch (error) {
+			const errMsg = error instanceof Error ? error.message : "Unknown error";
+			p.log.error(`Failed to update AGENTS.md: ${errMsg}`);
+		}
+	}
+	p.log.info("");
+	p.log.success(`Installed ${installed.length} references`);
+	if (failedCount > 0) p.log.warn(`Failed to install ${failedCount} references`);
+	p.outro("Project init complete");
+	return {
+		success: true,
+		referencesInstalled: installed.length
+	};
+}
+
+//#endregion
+//#region src/handlers/upgrade.ts
+/**
+* Upgrade command handler
+*/
+async function upgradeHandler(options) {
+	const { target, method: methodOverride } = options;
+	try {
+		const s = createSpinner();
+		s.start("Detecting installation method...");
+		const method = methodOverride ?? detectInstallMethod();
+		s.stop(`Installation method: ${method}`);
+		if (method === "unknown") {
+			const confirm = await p.confirm({
+				message: "Could not detect installation method. Attempt curl-based upgrade?",
+				initialValue: false
+			});
+			if (p.isCancel(confirm) || !confirm) {
+				p.log.info("Aborted.");
+				return {
+					success: false,
+					message: "Unknown installation method"
+				};
+			}
+		}
+		const effectiveMethod = method === "unknown" ? "curl" : method;
+		const currentVersion = getCurrentVersion();
+		p.log.info(`Current version: ${currentVersion}`);
+		let targetVersion = target;
+		if (!targetVersion) {
+			s.start("Fetching latest version...");
+			const latest = await fetchLatestVersion(effectiveMethod);
+			s.stop(latest ? `Latest version: ${latest}` : "Could not fetch latest version");
+			if (!latest) {
+				p.log.error("Failed to fetch latest version");
+				return {
+					success: false,
+					message: "Failed to fetch latest version"
+				};
+			}
+			targetVersion = latest;
+		}
+		targetVersion = targetVersion.replace(/^v/, "");
+		if (currentVersion === targetVersion) {
+			p.log.success(`Already on version ${targetVersion}`);
+			return {
+				success: true,
+				from: currentVersion,
+				to: targetVersion
+			};
+		}
+		p.log.info(`Upgrading from ${currentVersion} to ${targetVersion}...`);
+		await executeUpgrade(effectiveMethod, targetVersion);
+		p.log.success(`Successfully upgraded to ${targetVersion}`);
+		p.log.info("Restart your terminal or run 'ow --version' to verify.");
+		return {
+			success: true,
+			from: currentVersion,
+			to: targetVersion
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			message
+		};
+	}
+}
+
+//#endregion
+//#region src/handlers/uninstall.ts
+/**
+* Uninstall command handler
+*/
+async function uninstallHandler(options) {
+	const { keepConfig = false, keepData = false, dryRun = false, force = false } = options;
+	try {
+		const method = detectInstallMethod();
+		p.log.info(`Installation method: ${method}`);
+		const toRemove = [
+			{
+				path: Paths.data,
+				label: "Data",
+				keep: keepData
+			},
+			{
+				path: Paths.config,
+				label: "Config",
+				keep: keepConfig
+			},
+			{
+				path: Paths.state,
+				label: "State",
+				keep: false
+			}
+		].filter((d) => !d.keep && existsSync(d.path));
+		if (dryRun || !force) {
+			p.log.info("The following will be removed:");
+			console.log("");
+			if (method === "curl") console.log("  Binary: ~/.local/bin/ow");
+			else console.log(`  Package: offworld (via ${method})`);
+			for (const dir of toRemove) console.log(`  ${dir.label}: ${dir.path}`);
+			if (keepConfig) console.log(`  [kept] Config: ${Paths.config}`);
+			if (keepData) console.log(`  [kept] Data: ${Paths.data}`);
+			console.log("");
+		}
+		if (dryRun) {
+			p.log.info("Dry run - nothing was removed.");
+			return {
+				success: true,
+				removed: {
+					binary: method === "curl",
+					config: !keepConfig && existsSync(Paths.config),
+					data: !keepData && existsSync(Paths.data),
+					state: existsSync(Paths.state)
+				}
+			};
+		}
+		if (!force) {
+			const confirm = await p.confirm({
+				message: "Are you sure you want to uninstall offworld?",
+				initialValue: false
+			});
+			if (p.isCancel(confirm) || !confirm) {
+				p.log.info("Aborted.");
+				return {
+					success: false,
+					message: "Aborted by user"
+				};
+			}
+		}
+		const s = createSpinner();
+		const removed = {};
+		s.start("Removing offworld...");
+		try {
+			await executeUninstall(method);
+			removed.binary = true;
+			s.stop("Removed offworld binary/package");
+		} catch (err) {
+			s.stop("Failed to remove binary/package");
+			p.log.warn(err instanceof Error ? err.message : "Unknown error");
+		}
+		for (const dir of toRemove) {
+			s.start(`Removing ${dir.label.toLowerCase()}...`);
+			try {
+				rmSync(dir.path, {
+					recursive: true,
+					force: true
+				});
+				s.stop(`Removed ${dir.label.toLowerCase()}`);
+				if (dir.label === "Config") removed.config = true;
+				if (dir.label === "Data") removed.data = true;
+				if (dir.label === "State") removed.state = true;
+			} catch (err) {
+				s.stop(`Failed to remove ${dir.label.toLowerCase()}`);
+				p.log.warn(err instanceof Error ? err.message : "Unknown error");
+			}
+		}
+		if (method === "curl") {
+			const shellConfigs = getShellConfigFiles();
+			const cleaned = [];
+			for (const config of shellConfigs) if (cleanShellConfig(config)) cleaned.push(config);
+			if (cleaned.length > 0) {
+				p.log.info(`Cleaned PATH from: ${cleaned.join(", ")}`);
+				removed.shellConfigs = cleaned;
+			}
+		}
+		p.log.success("Uninstall complete!");
+		if (method === "curl") p.log.info("You may need to restart your terminal.");
+		return {
+			success: true,
+			removed
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : "Unknown error";
+		p.log.error(message);
+		return {
+			success: false,
+			message
+		};
+	}
+}
+
+//#endregion
+//#region src/handlers/map.ts
+/**
+* Map command handlers for fast repo routing
+*/
+async function mapShowHandler(options) {
+	const { repo, json, path, ref } = options;
+	const result = getMapEntry(repo);
+	if (!result) {
+		if (json) console.log(JSON.stringify({ found: false }));
+		else if (!path && !ref) p.log.error(`Repo not found: ${repo}`);
+		return { found: false };
+	}
+	const { scope, qualifiedName, entry } = result;
+	const primary = "primary" in entry ? entry.primary : entry.reference;
+	const keywords = entry.keywords ?? [];
+	const refPath = `${Paths.offworldReferencesDir}/${primary}`;
+	if (path) {
+		console.log(entry.localPath);
+		return {
+			found: true,
+			scope,
+			qualifiedName,
+			localPath: entry.localPath,
+			primary,
+			keywords
+		};
+	}
+	if (ref) {
+		console.log(refPath);
+		return {
+			found: true,
+			scope,
+			qualifiedName,
+			localPath: entry.localPath,
+			primary,
+			keywords
+		};
+	}
+	if (json) console.log(JSON.stringify({
+		found: true,
+		scope,
+		qualifiedName,
+		localPath: entry.localPath,
+		primary,
+		referencePath: refPath,
+		keywords
+	}, null, 2));
+	else {
+		console.log(`Repo:      ${qualifiedName}`);
+		console.log(`Scope:     ${scope}`);
+		console.log(`Path:      ${entry.localPath}`);
+		console.log(`Reference: ${refPath}`);
+		if (keywords.length > 0) console.log(`Keywords:  ${keywords.join(", ")}`);
+	}
+	return {
+		found: true,
+		scope,
+		qualifiedName,
+		localPath: entry.localPath,
+		primary,
+		keywords
+	};
+}
+async function mapSearchHandler(options) {
+	const { term, limit = 10, json } = options;
+	const results = searchMap(term, { limit });
+	if (json) console.log(JSON.stringify(results, null, 2));
+	else if (results.length === 0) p.log.warn(`No matches found for: ${term}`);
+	else for (const r of results) {
+		const refPath = `${Paths.offworldReferencesDir}/${r.primary}`;
+		console.log(`${r.fullName}`);
+		console.log(`  path: ${r.localPath}`);
+		console.log(`  ref:  ${refPath}`);
+		if (r.keywords.length > 0) console.log(`  keywords: ${r.keywords.join(", ")}`);
+		console.log("");
+	}
+	return { results };
+}
+
+//#endregion
+//#region src/index.ts
+const version = "0.1.0";
+const router = os.router({
+	pull: os.input(z.object({
+		repo: z.string().describe("repo").meta({ positional: true }),
+		reference: z.string().optional().describe("Reference name to pull (defaults to owner-repo)").meta({ alias: "r" }),
+		shallow: z.boolean().default(false).describe("Use shallow clone (--depth 1)").meta({ negativeAlias: "full-history" }),
+		sparse: z.boolean().default(false).describe("Use sparse checkout (only src/, lib/, packages/, docs/)"),
+		branch: z.string().optional().describe("Branch to clone"),
+		force: z.boolean().default(false).describe("Force re-generation").meta({ alias: "f" }),
+		verbose: z.boolean().default(false).describe("Show detailed output"),
+		model: z.string().optional().describe("Model override (provider/model)").meta({ alias: "m" })
+	})).meta({
+		description: "Clone a repository and fetch or generate its reference",
+		negateBooleans: true
+	}).handler(async ({ input }) => {
+		await pullHandler({
+			repo: input.repo,
+			reference: input.reference,
+			shallow: input.shallow,
+			sparse: input.sparse,
+			branch: input.branch,
+			force: input.force,
+			verbose: input.verbose,
+			model: input.model
+		});
+	}),
+	list: os.input(z.object({
+		json: z.boolean().default(false).describe("Output as JSON"),
+		paths: z.boolean().default(false).describe("Show full paths"),
+		pattern: z.string().optional().describe("Filter by pattern (e.g. 'react-*')")
+	})).meta({
+		description: "List managed repositories (alias for 'ow repo list')",
+		aliases: { command: ["ls"] }
+	}).handler(async ({ input }) => {
+		await repoListHandler({
+			json: input.json,
+			paths: input.paths,
+			pattern: input.pattern
+		});
+	}),
+	generate: os.input(z.object({
+		repo: z.string().describe("repo").meta({ positional: true }),
+		force: z.boolean().default(false).describe("Force even if remote exists").meta({ alias: "f" }),
+		model: z.string().optional().describe("Model override (provider/model)").meta({ alias: "m" })
+	})).meta({
+		description: "Generate reference locally (ignores remote)",
+		aliases: { command: ["gen"] }
+	}).handler(async ({ input }) => {
+		await generateHandler({
+			repo: input.repo,
+			force: input.force,
+			model: input.model
+		});
+	}),
+	push: os.input(z.object({ repo: z.string().describe("repo").meta({ positional: true }) })).meta({ description: "Push local reference to offworld.sh" }).handler(async ({ input }) => {
+		await pushHandler({ repo: input.repo });
+	}),
+	remove: os.input(z.object({
+		repo: z.string().describe("repo").meta({ positional: true }),
+		yes: z.boolean().default(false).describe("Skip confirmation").meta({ alias: "y" }),
+		referenceOnly: z.boolean().default(false).describe("Only remove reference files (keep repo)"),
+		repoOnly: z.boolean().default(false).describe("Only remove cloned repo (keep reference)"),
+		dryRun: z.boolean().default(false).describe("Show what would be done").meta({ alias: "d" })
+	})).meta({
+		description: "Remove a cloned repository and its reference",
+		aliases: { command: ["rm"] }
+	}).handler(async ({ input }) => {
+		await rmHandler({
+			repo: input.repo,
+			yes: input.yes,
+			referenceOnly: input.referenceOnly,
+			repoOnly: input.repoOnly,
+			dryRun: input.dryRun
+		});
+	}),
+	auth: os.router({
+		login: os.input(z.object({})).meta({ description: "Login to offworld.sh" }).handler(async () => {
+			await authLoginHandler();
+		}),
+		logout: os.input(z.object({})).meta({ description: "Logout from offworld.sh" }).handler(async () => {
+			await authLogoutHandler();
+		}),
+		status: os.input(z.object({})).meta({ description: "Show authentication status" }).handler(async () => {
+			await authStatusHandler();
+		})
+	}),
+	config: os.router({
+		show: os.input(z.object({ json: z.boolean().default(false).describe("Output as JSON") })).meta({
+			description: "Show all config settings",
+			default: true
+		}).handler(async ({ input }) => {
+			await configShowHandler({ json: input.json });
+		}),
+		set: os.input(z.object({
+			key: z.string().describe("key").meta({ positional: true }),
+			value: z.string().describe("value").meta({ positional: true })
+		})).meta({ description: `Set a config value
+
+Valid keys:
+  repoRoot        (string)  Where to clone repos (e.g., ~/ow)
+  defaultShallow  (boolean) Use shallow clone by default (true/false)
+  defaultModel    (string)  AI provider/model (e.g., anthropic/claude-sonnet-4-20250514)
+  agents          (list)    Comma-separated agents (e.g., claude-code,opencode)` }).handler(async ({ input }) => {
+			await configSetHandler({
+				key: input.key,
+				value: input.value
+			});
+		}),
+		get: os.input(z.object({ key: z.string().describe("key").meta({ positional: true }) })).meta({ description: `Get a config value
+
+Valid keys: repoRoot, defaultShallow, defaultModel, agents` }).handler(async ({ input }) => {
+			await configGetHandler({ key: input.key });
+		}),
+		reset: os.input(z.object({})).meta({ description: "Reset config to defaults" }).handler(async () => {
+			await configResetHandler();
+		}),
+		path: os.input(z.object({})).meta({ description: "Show config file location" }).handler(async () => {
+			await configPathHandler();
+		}),
+		agents: os.input(z.object({})).meta({ description: "Interactively select agents for reference installation" }).handler(async () => {
+			await configAgentsHandler();
+		})
+	}),
+	init: os.input(z.object({
+		yes: z.boolean().default(false).describe("Skip confirmation prompts").meta({ alias: "y" }),
+		force: z.boolean().default(false).describe("Reconfigure even if config exists").meta({ alias: "f" }),
+		model: z.string().optional().describe("AI provider/model (e.g., anthropic/claude-sonnet-4-20250514)").meta({ alias: "m" }),
+		repoRoot: z.string().optional().describe("Where to clone repos"),
+		agents: z.string().optional().describe("Comma-separated agents").meta({ alias: "a" })
+	})).meta({ description: "Initialize configuration with interactive setup" }).handler(async ({ input }) => {
+		await initHandler({
+			yes: input.yes,
+			force: input.force,
+			model: input.model,
+			repoRoot: input.repoRoot,
+			agents: input.agents
+		});
+	}),
+	project: os.router({ init: os.input(z.object({
+		all: z.boolean().default(false).describe("Select all detected dependencies"),
+		deps: z.string().optional().describe("Comma-separated deps to include (skip selection)"),
+		skip: z.string().optional().describe("Comma-separated deps to exclude"),
+		generate: z.boolean().default(false).describe("Generate references for deps without existing ones").meta({ alias: "g" }),
+		dryRun: z.boolean().default(false).describe("Show what would be done without doing it").meta({ alias: "d" }),
+		yes: z.boolean().default(false).describe("Skip confirmations").meta({ alias: "y" })
+	})).meta({
+		description: "Scan manifest, install references, update AGENTS.md",
+		default: true
+	}).handler(async ({ input }) => {
+		await projectInitHandler({
+			all: input.all,
+			deps: input.deps,
+			skip: input.skip,
+			generate: input.generate,
+			dryRun: input.dryRun,
+			yes: input.yes
+		});
+	}) }),
+	map: os.router({
+		show: os.input(z.object({
+			repo: z.string().describe("repo").meta({ positional: true }),
+			json: z.boolean().default(false).describe("Output as JSON"),
+			path: z.boolean().default(false).describe("Print only local path"),
+			ref: z.boolean().default(false).describe("Print only reference file path")
+		})).meta({
+			description: "Show map entry for a repo",
+			default: true
+		}).handler(async ({ input }) => {
+			await mapShowHandler({
+				repo: input.repo,
+				json: input.json,
+				path: input.path,
+				ref: input.ref
+			});
+		}),
+		search: os.input(z.object({
+			term: z.string().describe("term").meta({ positional: true }),
+			limit: z.number().default(10).describe("Max results").meta({ alias: "n" }),
+			json: z.boolean().default(false).describe("Output as JSON")
+		})).meta({ description: "Search map for repos matching a term" }).handler(async ({ input }) => {
+			await mapSearchHandler({
+				term: input.term,
+				limit: input.limit,
+				json: input.json
+			});
+		})
+	}),
+	repo: os.router({
+		list: os.input(z.object({
+			json: z.boolean().default(false).describe("Output as JSON"),
+			paths: z.boolean().default(false).describe("Show full paths"),
+			pattern: z.string().optional().describe("Filter by pattern (e.g. 'react-*')")
+		})).meta({
+			description: "List managed repositories",
+			default: true,
+			aliases: { command: ["ls"] }
+		}).handler(async ({ input }) => {
+			await repoListHandler({
+				json: input.json,
+				paths: input.paths,
+				pattern: input.pattern
+			});
+		}),
+		update: os.input(z.object({
+			all: z.boolean().default(false).describe("Update all repos"),
+			pattern: z.string().optional().describe("Filter by pattern"),
+			dryRun: z.boolean().default(false).describe("Show what would be updated").meta({ alias: "d" }),
+			unshallow: z.boolean().default(false).describe("Convert shallow clones to full clones")
+		})).meta({ description: "Update repos (git fetch + pull)" }).handler(async ({ input }) => {
+			await repoUpdateHandler({
+				all: input.all,
+				pattern: input.pattern,
+				dryRun: input.dryRun,
+				unshallow: input.unshallow
+			});
+		}),
+		prune: os.input(z.object({
+			dryRun: z.boolean().default(false).describe("Show what would be pruned").meta({ alias: "d" }),
+			yes: z.boolean().default(false).describe("Skip confirmation").meta({ alias: "y" }),
+			removeOrphans: z.boolean().default(false).describe("Also remove orphaned directories")
+		})).meta({ description: "Remove stale index entries and find orphaned directories" }).handler(async ({ input }) => {
+			await repoPruneHandler({
+				dryRun: input.dryRun,
+				yes: input.yes,
+				removeOrphans: input.removeOrphans
+			});
+		}),
+		status: os.input(z.object({ json: z.boolean().default(false).describe("Output as JSON") })).meta({ description: "Show summary of managed repos" }).handler(async ({ input }) => {
+			await repoStatusHandler({ json: input.json });
+		}),
+		gc: os.input(z.object({
+			olderThan: z.string().optional().describe("Remove repos not accessed in N days (e.g. '30d')"),
+			withoutReference: z.boolean().default(false).describe("Remove repos without references"),
+			dryRun: z.boolean().default(false).describe("Show what would be removed").meta({ alias: "d" }),
+			yes: z.boolean().default(false).describe("Skip confirmation").meta({ alias: "y" })
+		})).meta({ description: "Garbage collect old/unused repos" }).handler(async ({ input }) => {
+			await repoGcHandler({
+				olderThan: input.olderThan,
+				withoutReference: input.withoutReference,
+				dryRun: input.dryRun,
+				yes: input.yes
+			});
+		}),
+		discover: os.input(z.object({
+			dryRun: z.boolean().default(false).describe("Show what would be added").meta({ alias: "d" }),
+			yes: z.boolean().default(false).describe("Skip confirmation").meta({ alias: "y" })
+		})).meta({ description: "Discover and index existing repos in repoRoot" }).handler(async ({ input }) => {
+			await repoDiscoverHandler({
+				dryRun: input.dryRun,
+				yes: input.yes
+			});
+		})
+	}),
+	upgrade: os.input(z.object({ target: z.string().optional().describe("Version to upgrade to") })).meta({ description: "Upgrade offworld to latest or specific version" }).handler(async ({ input }) => {
+		await upgradeHandler({ target: input.target });
+	}),
+	uninstall: os.input(z.object({
+		keepConfig: z.boolean().default(false).describe("Keep configuration files"),
+		keepData: z.boolean().default(false).describe("Keep data files (references, repos)"),
+		dryRun: z.boolean().default(false).describe("Show what would be removed").meta({ alias: "d" }),
+		force: z.boolean().default(false).describe("Skip confirmation").meta({ alias: "f" })
+	})).meta({ description: "Uninstall offworld and remove related files" }).handler(async ({ input }) => {
+		await uninstallHandler({
+			keepConfig: input.keepConfig,
+			keepData: input.keepData,
+			dryRun: input.dryRun,
+			force: input.force
+		});
+	})
+});
+const stripSecondaryDescription = (help) => help.split("\n").filter((line) => !line.startsWith("Available subcommands:")).join("\n");
+const stripDefaultCommandHelp = (help) => {
+	const firstUsageIndex = help.indexOf("Usage:");
+	if (firstUsageIndex === -1) return help.trimEnd();
+	const secondUsageIndex = help.indexOf("Usage:", firstUsageIndex + 1);
+	if (secondUsageIndex === -1) return help.trimEnd();
+	return help.slice(0, secondUsageIndex).trimEnd();
+};
+const normalizeRootHelp = (help) => stripDefaultCommandHelp(stripSecondaryDescription(help));
+function createOwCli() {
+	const cli = createCli({
+		router,
+		description: "Offworld CLI - Repository reference generation for AI coding agents"
+	});
+	const buildProgram = (runParams) => {
+		const program = cli.buildProgram(runParams);
+		const originalHelpInformation = program.helpInformation.bind(program);
+		program.helpInformation = () => normalizeRootHelp(originalHelpInformation());
+		return program;
+	};
+	const run = (runParams, program) => cli.run(runParams, program ?? buildProgram(runParams));
+	return {
+		...cli,
+		buildProgram,
+		run
+	};
+}
+
+//#endregion
+export { router as n, version as r, createOwCli as t };
+//# sourceMappingURL=src-CZHUGu1Q.mjs.map