@offworld/sdk 0.2.2 → 0.3.0

package/dist/index.mjs

@@ -1,3910 +1,5 @@
-import { chmodSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
-import { basename, dirname, join, resolve } from "node:path";
-import { ConfigSchema, GitHubRepoMetadataSchema, GlobalMapSchema, ModelsDevDataSchema, NpmPackageResponseSchema, ProjectMapSchema, WorkOSTokenResponseSchema } from "@offworld/types";
-import { xdgConfig, xdgData, xdgState } from "xdg-basedir";
-import { homedir } from "node:os";
-import { createHash } from "node:crypto";
-import { GlobalMapSchema as GlobalMapSchema$1, ProjectMapSchema as ProjectMapSchema$1 } from "@offworld/types/schemas";
-import { execFileSync, execSync, spawn } from "node:child_process";
-import { z } from "zod";
-import { ConvexHttpClient } from "convex/browser";
-import { api } from "@offworld/backend-api/api";
+import { A as getToken, B as NotGitRepoError, C as getAllAgentConfigs, D as clearAuthData, E as TokenExpiredError, F as saveAuthData, G as DEFAULT_IGNORE_PATTERNS, H as RepoSourceError, I as getMapEntry, K as VERSION, L as getProjectMapPath, M as isLoggedIn, N as loadAuthData, O as getAuthPath, P as refreshAccessToken, R as resolveRepoKey, S as getAgentConfig, T as NotLoggedInError, U as getReferenceFileNameForSource, V as PathNotFoundError, W as parseRepoInput, _ as parseDependencies, a as discoverRepos, b as agents, c as pruneRepos, d as matchDependenciesToReferences, f as matchDependenciesToReferencesWithRemoteCheck, g as detectManifestType, h as resolveFromNpm, i as validateProviderModel, j as getTokenOrNull, k as getAuthStatus, l as updateAllRepos, m as resolveDependencyRepo, n as listProviders, o as gcRepos, p as FALLBACK_MAPPINGS, r as listProvidersWithModels, s as getRepoStatus, t as getProvider, u as isReferenceInstalled, v as installGlobalSkill, w as AuthError, x as detectInstalledAgents, y as installReference, z as searchMap } from "./public-DbZeh2Mr.mjs";
+import { a as getRepoPath, c as saveConfig, d as toReferenceName, f as Paths, i as getReferencePath, l as toMetaDirName, n as getMetaPath, o as getRepoRoot, p as expandTilde, r as getMetaRoot, s as loadConfig, t as getConfigPath, u as toReferenceFileName } from "./config-DW8J4gl5.mjs";
+import { _ as upsertGlobalMapEntry, a as cloneRepo, c as getCommitSha, d as listRepos, f as removeRepo, g as removeGlobalMapEntry, h as readGlobalMap, i as RepoNotFoundError, l as isRepoCloned, m as updateRepo, n as GitError, o as getClonedRepoPath, p as unshallowRepo, r as RepoExistsError, s as getCommitDistance, t as CloneError, u as isShallowClone, v as writeGlobalMap, y as writeProjectMap } from "./clone-DyLvmbJZ.mjs";
 
-//#region src/constants.ts
-/**
-* SDK Constants
-*/
-/** SDK version - must match package.json */
-const VERSION = "0.2.2";
-/**
-* Default patterns to ignore when scanning repositories.
-* Includes directories, binary files, IDE configs, and build outputs.
-*/
-const DEFAULT_IGNORE_PATTERNS = [
-	".git",
-	".git/**",
-	".svn",
-	".hg",
-	"node_modules",
-	"node_modules/**",
-	"vendor",
-	"vendor/**",
-	".pnpm",
-	".yarn",
-	"dist",
-	"dist/**",
-	"build",
-	"build/**",
-	"out",
-	"out/**",
-	".next",
-	".nuxt",
-	".output",
-	"target",
-	"__pycache__",
-	"*.pyc",
-	".vscode",
-	".vscode/**",
-	".idea",
-	".idea/**",
-	"*.swp",
-	"*.swo",
-	".DS_Store",
-	"*.jpg",
-	"*.jpeg",
-	"*.png",
-	"*.gif",
-	"*.ico",
-	"*.webp",
-	"*.svg",
-	"*.bmp",
-	"*.tiff",
-	"*.mp4",
-	"*.webm",
-	"*.mov",
-	"*.avi",
-	"*.mkv",
-	"*.mp3",
-	"*.wav",
-	"*.flac",
-	"*.ogg",
-	"*.pdf",
-	"*.zip",
-	"*.tar",
-	"*.gz",
-	"*.rar",
-	"*.7z",
-	"*.exe",
-	"*.dll",
-	"*.so",
-	"*.dylib",
-	"*.bin",
-	"*.wasm",
-	"*.woff",
-	"*.woff2",
-	"*.ttf",
-	"*.eot",
-	"*.otf",
-	"package-lock.json",
-	"yarn.lock",
-	"pnpm-lock.yaml",
-	"bun.lockb",
-	"Cargo.lock",
-	"Gemfile.lock",
-	"poetry.lock",
-	"composer.lock",
-	"go.sum",
-	"coverage",
-	"coverage/**",
-	".nyc_output",
-	".coverage",
-	"htmlcov",
-	"*.log",
-	"logs",
-	"tmp",
-	"temp",
-	".tmp",
-	".temp",
-	".cache",
-	".env",
-	".env.*",
-	"*.pem",
-	"*.key"
-];
-
-//#endregion
-//#region src/paths.ts
-/**
-* XDG-based directory paths for offworld CLI
-* Uses xdg-basedir package for cross-platform compatibility (Linux/macOS)
-*/
-const APP_NAME = "offworld";
-/**
-* Main namespace for all XDG-compliant paths
-*/
-const Paths = {
-	get config() {
-		return join(xdgConfig ?? join(homedir(), ".config"), APP_NAME);
-	},
-	get data() {
-		return join(xdgData ?? join(homedir(), ".local", "share"), APP_NAME);
-	},
-	get state() {
-		return join(xdgState ?? join(homedir(), ".local", "state"), APP_NAME);
-	},
-	get configFile() {
-		return join(this.config, "offworld.json");
-	},
-	get authFile() {
-		return join(this.data, "auth.json");
-	},
-	get metaDir() {
-		return join(this.data, "meta");
-	},
-	get defaultRepoRoot() {
-		return join(homedir(), "ow");
-	},
-	get offworldSkillDir() {
-		return join(this.data, "skill", "offworld");
-	},
-	get offworldReferencesDir() {
-		return join(this.offworldSkillDir, "references");
-	},
-	get offworldAssetsDir() {
-		return join(this.offworldSkillDir, "assets");
-	},
-	get offworldGlobalMapPath() {
-		return join(this.offworldAssetsDir, "map.json");
-	}
-};
-/**
-* Expands ~ to user's home directory (for backward compatibility)
-*/
-function expandTilde(path) {
-	if (path.startsWith("~/")) return join(homedir(), path.slice(2));
-	return path;
-}
-
-//#endregion
-//#region src/config.ts
-/**
-* Config utilities for path management and configuration loading
-*/
-/**
-* Returns the repository root directory.
-* Uses configured repoRoot or defaults to ~/ow
-*/
-function getMetaRoot() {
-	return Paths.data;
-}
-function getRepoRoot(config) {
-	return expandTilde(config?.repoRoot ?? Paths.defaultRepoRoot);
-}
-/**
-* Returns the path for a specific repository.
-* Format: {repoRoot}/{provider}/{owner}/{repo}
-*
-* @param fullName - The repo identifier in "owner/repo" format
-* @param provider - Git provider (defaults to "github")
-* @param config - Optional config for custom repoRoot
-*/
-function getRepoPath(fullName, provider = "github", config) {
-	const root = getRepoRoot(config);
-	const [owner, repo] = fullName.split("/");
-	if (!owner || !repo) throw new Error(`Invalid fullName format: ${fullName}. Expected "owner/repo"`);
-	return join(root, provider, owner, repo);
-}
-/**
-* Convert owner/repo format to meta directory name.
-* Collapses owner==repo (e.g., better-auth/better-auth -> better-auth)
-*/
-function toMetaDirName(repoName) {
-	if (repoName.includes("/")) {
-		const parts = repoName.split("/");
-		const owner = parts[0];
-		const repo = parts[1];
-		if (!owner || !repo) return repoName;
-		if (owner === repo) return repo;
-		return `${owner}-${repo}`;
-	}
-	return repoName;
-}
-/**
-* Convert owner/repo format to reference filename.
-* Collapses redundant owner/repo pairs by checking if repo name is contained in owner:
-* - honojs/hono -> hono.md (hono is in honojs)
-* - get-convex/convex-backend -> convex-backend.md (convex is in get-convex)
-* - tanstack/query -> tanstack-query.md (query is not in tanstack)
-*/
-function toReferenceFileName(repoName) {
-	if (repoName.includes("/")) {
-		const parts = repoName.split("/");
-		const owner = parts[0];
-		const repo = parts[1];
-		if (!owner || !repo) return `${repoName.toLowerCase()}.md`;
-		const ownerLower = owner.toLowerCase();
-		const repoLower = repo.toLowerCase();
-		if (repoLower.split("-").find((part) => part.length >= 3 && ownerLower.includes(part)) || ownerLower === repoLower) return `${repoLower}.md`;
-		return `${ownerLower}-${repoLower}.md`;
-	}
-	return `${repoName.toLowerCase()}.md`;
-}
-function toReferenceName(repoName) {
-	return toReferenceFileName(repoName).replace(/\.md$/, "");
-}
-function getReferencePath(fullName) {
-	return join(Paths.offworldReferencesDir, toReferenceFileName(fullName));
-}
-function getMetaPath(fullName) {
-	return join(Paths.data, "meta", toMetaDirName(fullName));
-}
-/**
-* Returns the path to the configuration file
-* Uses XDG Base Directory specification
-*/
-function getConfigPath() {
-	return Paths.configFile;
-}
-/**
-* Loads configuration from ~/.config/offworld/offworld.json
-* Returns defaults if file doesn't exist
-*/
-function loadConfig() {
-	const configPath = getConfigPath();
-	if (!existsSync(configPath)) return ConfigSchema.parse({});
-	try {
-		const content = readFileSync(configPath, "utf-8");
-		const data = JSON.parse(content);
-		return ConfigSchema.parse(data);
-	} catch {
-		return ConfigSchema.parse({});
-	}
-}
-/**
-* Saves configuration to ~/.config/offworld/offworld.json
-* Creates directory if it doesn't exist
-* Merges with existing config
-*/
-function saveConfig(updates) {
-	const configPath = getConfigPath();
-	const configDir = dirname(configPath);
-	if (!existsSync(configDir)) mkdirSync(configDir, { recursive: true });
-	const merged = {
-		...loadConfig(),
-		...updates
-	};
-	const validated = ConfigSchema.parse(merged);
-	writeFileSync(configPath, JSON.stringify(validated, null, 2), "utf-8");
-	return validated;
-}
-
-//#endregion
-//#region src/repo-source.ts
-/**
-* Repository source parsing utilities
-*/
-var RepoSourceError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "RepoSourceError";
-	}
-};
-var PathNotFoundError = class extends RepoSourceError {
-	constructor(path) {
-		super(`Path does not exist: ${path}`);
-		this.name = "PathNotFoundError";
-	}
-};
-var NotGitRepoError = class extends RepoSourceError {
-	constructor(path) {
-		super(`Directory is not a git repository: ${path}`);
-		this.name = "NotGitRepoError";
-	}
-};
-const PROVIDER_HOSTS = {
-	"github.com": "github",
-	"gitlab.com": "gitlab",
-	"bitbucket.org": "bitbucket"
-};
-const HTTPS_URL_REGEX = /^https?:\/\/(github\.com|gitlab\.com|bitbucket\.org)\/([^/]+)\/([^/]+?)(?:\.git)?$/;
-const SSH_URL_REGEX = /^git@(github\.com|gitlab\.com|bitbucket\.org):([^/]+)\/([^/]+?)(?:\.git)?$/;
-const SHORT_FORMAT_REGEX = /^([^/:@]+)\/([^/:@]+)$/;
-/**
-* Generates a short hash of a path for local repo identification
-*/
-function hashPath(path) {
-	return createHash("sha256").update(path).digest("hex").slice(0, 12);
-}
-/**
-* Builds a clone URL for a remote repository
-*/
-function buildCloneUrl(provider, owner, repo) {
-	return `https://${{
-		github: "github.com",
-		gitlab: "gitlab.com",
-		bitbucket: "bitbucket.org"
-	}[provider]}/${owner}/${repo}.git`;
-}
-/**
-* Parses a remote repository from HTTPS URL format
-*/
-function parseHttpsUrl(input) {
-	const match = input.match(HTTPS_URL_REGEX);
-	if (!match) return null;
-	const [, host, owner, repo] = match;
-	if (!host || !owner || !repo) return null;
-	const provider = PROVIDER_HOSTS[host];
-	if (!provider) return null;
-	const ownerLower = owner.toLowerCase();
-	const repoLower = repo.toLowerCase();
-	return {
-		type: "remote",
-		provider,
-		owner: ownerLower,
-		repo: repoLower,
-		fullName: `${ownerLower}/${repoLower}`,
-		qualifiedName: `${host}:${ownerLower}/${repoLower}`,
-		cloneUrl: buildCloneUrl(provider, ownerLower, repoLower)
-	};
-}
-/**
-* Parses a remote repository from SSH URL format
-*/
-function parseSshUrl(input) {
-	const match = input.match(SSH_URL_REGEX);
-	if (!match) return null;
-	const [, host, owner, repo] = match;
-	if (!host || !owner || !repo) return null;
-	const provider = PROVIDER_HOSTS[host];
-	if (!provider) return null;
-	const ownerLower = owner.toLowerCase();
-	const repoLower = repo.toLowerCase();
-	return {
-		type: "remote",
-		provider,
-		owner: ownerLower,
-		repo: repoLower,
-		fullName: `${ownerLower}/${repoLower}`,
-		qualifiedName: `${host}:${ownerLower}/${repoLower}`,
-		cloneUrl: buildCloneUrl(provider, ownerLower, repoLower)
-	};
-}
-/**
-* Parses a remote repository from short format (owner/repo)
-* Defaults to GitHub as provider
-*/
-function parseShortFormat(input) {
-	const match = input.match(SHORT_FORMAT_REGEX);
-	if (!match) return null;
-	const [, owner, repo] = match;
-	if (!owner || !repo) return null;
-	const provider = "github";
-	const host = "github.com";
-	const ownerLower = owner.toLowerCase();
-	const repoLower = repo.toLowerCase();
-	return {
-		type: "remote",
-		provider,
-		owner: ownerLower,
-		repo: repoLower,
-		fullName: `${ownerLower}/${repoLower}`,
-		qualifiedName: `${host}:${ownerLower}/${repoLower}`,
-		cloneUrl: buildCloneUrl(provider, ownerLower, repoLower)
-	};
-}
-/**
-* Parses a local repository path
-* Validates that the path exists and contains a .git directory
-*/
-function parseLocalPath(input) {
-	const absolutePath = resolve(expandTilde(input));
-	if (!existsSync(absolutePath)) throw new PathNotFoundError(absolutePath);
-	if (!statSync(absolutePath).isDirectory()) throw new RepoSourceError(`Path is not a directory: ${absolutePath}`);
-	if (!existsSync(resolve(absolutePath, ".git"))) throw new NotGitRepoError(absolutePath);
-	return {
-		type: "local",
-		path: absolutePath,
-		name: basename(absolutePath),
-		qualifiedName: `local:${hashPath(absolutePath)}`
-	};
-}
-/**
-* Determines if input looks like a local path
-*/
-function isLocalPath(input) {
-	return input.startsWith(".") || input.startsWith("/") || input.startsWith("~");
-}
-/**
-* Parses a repository input and returns a structured RepoSource
-*
-* Supported formats:
-* - owner/repo (short format, defaults to GitHub)
-* - https://github.com/owner/repo
-* - https://gitlab.com/owner/repo
-* - https://bitbucket.org/owner/repo
-* - git@github.com:owner/repo.git (SSH format)
-* - . (current directory as local repo)
-* - /absolute/path (local repo)
-*
-* @throws PathNotFoundError if local path doesn't exist
-* @throws NotGitRepoError if local path is not a git repository
-* @throws RepoSourceError for other parsing failures
-*/
-function parseRepoInput(input) {
-	const trimmed = input.trim();
-	const httpsResult = parseHttpsUrl(trimmed);
-	if (httpsResult) return httpsResult;
-	const sshResult = parseSshUrl(trimmed);
-	if (sshResult) return sshResult;
-	if (isLocalPath(trimmed)) return parseLocalPath(trimmed);
-	const shortResult = parseShortFormat(trimmed);
-	if (shortResult) return shortResult;
-	throw new RepoSourceError(`Unable to parse repository input: ${input}. Expected formats: owner/repo, https://github.com/owner/repo, git@github.com:owner/repo.git, or a local path`);
-}
-function getReferenceFileNameForSource(source) {
-	if (source.type === "remote") return toReferenceFileName(source.fullName);
-	return toReferenceFileName(source.name);
-}
-
-//#endregion
-//#region src/index-manager.ts
-/**
-* Map manager for global and project maps
-*
-* Manages:
-* - Global map: ~/.local/share/offworld/skill/offworld/assets/map.json
-* - Project map: ./.offworld/map.json
-*/
-/**
-* Reads the global map from ~/.local/share/offworld/skill/offworld/assets/map.json
-* Returns empty map if file doesn't exist or is invalid
-*/
-function readGlobalMap() {
-	const mapPath = Paths.offworldGlobalMapPath;
-	if (!existsSync(mapPath)) return { repos: {} };
-	try {
-		const content = readFileSync(mapPath, "utf-8");
-		const data = JSON.parse(content);
-		return GlobalMapSchema.parse(data);
-	} catch {
-		return { repos: {} };
-	}
-}
-/**
-* Writes the global map to ~/.local/share/offworld/skill/offworld/assets/map.json
-* Creates directory if it doesn't exist
-*/
-function writeGlobalMap(map) {
-	const mapPath = Paths.offworldGlobalMapPath;
-	const mapDir = dirname(mapPath);
-	if (!existsSync(mapDir)) mkdirSync(mapDir, { recursive: true });
-	const validated = GlobalMapSchema.parse(map);
-	writeFileSync(mapPath, JSON.stringify(validated, null, 2), "utf-8");
-}
-/**
-* Adds or updates a repo entry in the global map
-*
-* @param qualifiedName - The qualified repo name (owner/repo)
-* @param entry - The map entry to add/update
-*/
-function upsertGlobalMapEntry(qualifiedName, entry) {
-	const map = readGlobalMap();
-	map.repos[qualifiedName] = entry;
-	writeGlobalMap(map);
-}
-/**
-* Removes a repo entry from the global map
-*
-* @param qualifiedName - The qualified repo name (owner/repo)
-* @returns true if repo was removed, false if not found
-*/
-function removeGlobalMapEntry(qualifiedName) {
-	const map = readGlobalMap();
-	if (!(qualifiedName in map.repos)) return false;
-	delete map.repos[qualifiedName];
-	writeGlobalMap(map);
-	return true;
-}
-/**
-* Writes a project map to ./.offworld/map.json
-*
-* @param projectRoot - Absolute path to project root
-* @param entries - Map of qualified repo names to project map entries
-*/
-function writeProjectMap(projectRoot, entries) {
-	const mapPath = join(projectRoot, ".offworld", "map.json");
-	const mapDir = dirname(mapPath);
-	if (!existsSync(mapDir)) mkdirSync(mapDir, { recursive: true });
-	const projectMap = {
-		version: 1,
-		scope: "project",
-		globalMapPath: Paths.offworldGlobalMapPath,
-		repos: entries
-	};
-	const validated = ProjectMapSchema.parse(projectMap);
-	writeFileSync(mapPath, JSON.stringify(validated, null, 2), "utf-8");
-}
-
-//#endregion
-//#region src/map.ts
-/**
-* Map query helpers for fast routing without reading full map.json
-*/
-function readGlobalMapSafe() {
-	const mapPath = Paths.offworldGlobalMapPath;
-	if (!existsSync(mapPath)) return null;
-	try {
-		const content = readFileSync(mapPath, "utf-8");
-		return GlobalMapSchema$1.parse(JSON.parse(content));
-	} catch {
-		return null;
-	}
-}
-function readProjectMapSafe(cwd) {
-	const mapPath = resolve(cwd, ".offworld/map.json");
-	if (!existsSync(mapPath)) return null;
-	try {
-		const content = readFileSync(mapPath, "utf-8");
-		return ProjectMapSchema$1.parse(JSON.parse(content));
-	} catch {
-		return null;
-	}
-}
-/**
-* Normalize input to match against repo keys.
-* Accepts: github.com:owner/repo, owner/repo, repo
-*/
-function normalizeInput(input) {
-	const trimmed = input.trim().toLowerCase();
-	if (trimmed.includes(":")) {
-		const parts = trimmed.split(":", 2);
-		const provider = parts[0];
-		const fullName = parts[1] ?? "";
-		return {
-			provider,
-			fullName,
-			repoName: fullName.split("/").pop() ?? fullName
-		};
-	}
-	if (trimmed.includes("/")) return {
-		fullName: trimmed,
-		repoName: trimmed.split("/").pop() ?? trimmed
-	};
-	return {
-		fullName: trimmed,
-		repoName: trimmed
-	};
-}
-/**
-* Tokenize a string for search matching.
-* Lowercase, strip @, split on /_- and whitespace.
-*/
-function tokenize(str) {
-	return str.toLowerCase().replace(/@/g, "").split(/[/_\-\s]+/).filter(Boolean);
-}
-/**
-* Resolve an input string to a qualified repo key in a map.
-*
-* @param input - Accepts github.com:owner/repo, owner/repo, or repo name
-* @param map - A global or project map
-* @returns The matching qualified name or null
-*/
-function resolveRepoKey(input, map) {
-	const { provider, fullName, repoName } = normalizeInput(input);
-	const keys = Object.keys(map.repos);
-	if (provider) {
-		const qualifiedKey = `${provider}:${fullName}`;
-		if (keys.includes(qualifiedKey)) return qualifiedKey;
-	}
-	for (const key of keys) if ((key.includes(":") ? key.split(":")[1] : key)?.toLowerCase() === fullName) return key;
-	for (const key of keys) if (key.split("/").pop()?.toLowerCase() === repoName) return key;
-	return null;
-}
-/**
-* Get a map entry for a repo, preferring project map if available.
-*
-* @param input - Repo identifier (github.com:owner/repo, owner/repo, or repo)
-* @param options - Options for lookup
-* @returns Entry with scope and qualified name, or null if not found
-*/
-function getMapEntry(input, options = {}) {
-	const { preferProject = true, cwd = process.cwd() } = options;
-	const projectMap = preferProject ? readProjectMapSafe(cwd) : null;
-	const globalMap = readGlobalMapSafe();
-	if (projectMap) {
-		const key = resolveRepoKey(input, projectMap);
-		if (key && projectMap.repos[key]) return {
-			scope: "project",
-			qualifiedName: key,
-			entry: projectMap.repos[key]
-		};
-	}
-	if (globalMap) {
-		const key = resolveRepoKey(input, globalMap);
-		if (key && globalMap.repos[key]) return {
-			scope: "global",
-			qualifiedName: key,
-			entry: globalMap.repos[key]
-		};
-	}
-	return null;
-}
-/**
-* Search the map for repos matching a term.
-*
-* Scoring:
-* - Exact fullName match: 100
-* - Keyword hit: 50 per keyword
-* - Partial contains in fullName: 25
-* - Partial contains in keywords: 10
-*
-* @param term - Search term
-* @param options - Search options
-* @returns Sorted list of matches
-*/
-function searchMap(term, options = {}) {
-	const { limit = 10 } = options;
-	const globalMap = readGlobalMapSafe();
-	if (!globalMap) return [];
-	const termTokens = tokenize(term);
-	const termLower = term.toLowerCase();
-	const results = [];
-	for (const qualifiedName of Object.keys(globalMap.repos)) {
-		const entry = globalMap.repos[qualifiedName];
-		if (!entry) continue;
-		const fullName = qualifiedName.includes(":") ? qualifiedName.split(":")[1] ?? qualifiedName : qualifiedName;
-		const fullNameLower = fullName.toLowerCase();
-		const keywords = entry.keywords ?? [];
-		const keywordsLower = keywords.map((k) => k.toLowerCase());
-		let score = 0;
-		if (fullNameLower === termLower) score += 100;
-		for (const token of termTokens) if (keywordsLower.includes(token)) score += 50;
-		if (fullNameLower.includes(termLower) && score < 100) score += 25;
-		for (const kw of keywordsLower) if (kw.includes(termLower)) score += 10;
-		const fullNameTokens = tokenize(fullName);
-		for (const token of termTokens) if (fullNameTokens.includes(token)) score += 30;
-		if (score > 0) results.push({
-			qualifiedName,
-			fullName,
-			localPath: entry.localPath,
-			primary: entry.primary,
-			keywords,
-			score
-		});
-	}
-	results.sort((a, b) => {
-		if (b.score !== a.score) return b.score - a.score;
-		return a.fullName.localeCompare(b.fullName);
-	});
-	return results.slice(0, limit);
-}
-/**
-* Get the project map path if it exists in cwd.
-*/
-function getProjectMapPath(cwd = process.cwd()) {
-	const mapPath = resolve(cwd, ".offworld/map.json");
-	return existsSync(mapPath) ? mapPath : null;
-}
-
-//#endregion
-//#region src/clone.ts
-/**
-* Git clone and repository management utilities
-*/
-var CloneError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "CloneError";
-	}
-};
-var RepoExistsError = class extends CloneError {
-	constructor(path) {
-		super(`Repository already exists at: ${path}`);
-		this.name = "RepoExistsError";
-	}
-};
-var RepoNotFoundError = class extends CloneError {
-	constructor(qualifiedName) {
-		super(`Repository not found in index: ${qualifiedName}`);
-		this.name = "RepoNotFoundError";
-	}
-};
-var GitError = class extends CloneError {
-	constructor(message, command, exitCode) {
-		super(`Git command failed: ${message}`);
-		this.command = command;
-		this.exitCode = exitCode;
-		this.name = "GitError";
-	}
-};
-function execGit(args, cwd) {
-	try {
-		return execFileSync("git", args, {
-			cwd,
-			encoding: "utf-8",
-			stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			]
-		}).trim();
-	} catch (error) {
-		const err = error;
-		throw new GitError((err.stderr ? typeof err.stderr === "string" ? err.stderr : err.stderr.toString() : err.message || "Unknown error").trim(), `git ${args.join(" ")}`, err.status ?? null);
-	}
-}
-function execGitAsync(args, cwd) {
-	return new Promise((resolve, reject) => {
-		const proc = spawn("git", args, {
-			cwd,
-			stdio: [
-				"ignore",
-				"pipe",
-				"pipe"
-			],
-			env: {
-				...process.env,
-				GIT_TERMINAL_PROMPT: "0"
-			}
-		});
-		let stdout = "";
-		let stderr = "";
-		proc.stdout.on("data", (data) => {
-			stdout += data.toString();
-		});
-		proc.stderr.on("data", (data) => {
-			stderr += data.toString();
-		});
-		proc.on("close", (code) => {
-			if (code === 0) resolve(stdout.trim());
-			else reject(new GitError(stderr.trim() || "Unknown error", `git ${args.join(" ")}`, code));
-		});
-		proc.on("error", (err) => {
-			reject(new GitError(err.message, `git ${args.join(" ")}`, null));
-		});
-	});
-}
-function getCommitSha(repoPath) {
-	return execGit(["rev-parse", "HEAD"], repoPath);
-}
-function getCommitDistance(repoPath, olderSha, newerSha = "HEAD") {
-	try {
-		try {
-			execGit([
-				"cat-file",
-				"-e",
-				olderSha
-			], repoPath);
-		} catch {
-			return null;
-		}
-		const count = execGit([
-			"rev-list",
-			"--count",
-			`${olderSha}..${newerSha}`
-		], repoPath);
-		return Number.parseInt(count, 10);
-	} catch {
-		return null;
-	}
-}
-const SPARSE_CHECKOUT_DIRS = [
-	"src",
-	"lib",
-	"packages",
-	"docs",
-	"README.md",
-	"package.json"
-];
-/**
-* Clone a remote repository to the local repo root.
-*
-* @param source - Remote repo source from parseRepoInput()
-* @param options - Clone options (shallow, branch, config)
-* @returns The local path where the repo was cloned
-* @throws RepoExistsError if repo already exists (unless force is true)
-* @throws GitError if clone fails
-*/
-async function cloneRepo(source, options = {}) {
-	const config = options.config ?? loadConfig();
-	const repoPath = getRepoPath(source.fullName, source.provider, config);
-	if (existsSync(repoPath)) if (options.force) rmSync(repoPath, {
-		recursive: true,
-		force: true
-	});
-	else throw new RepoExistsError(repoPath);
-	try {
-		if (options.sparse) await cloneSparse(source.cloneUrl, repoPath, options);
-		else await cloneStandard(source.cloneUrl, repoPath, options);
-	} catch (err) {
-		cleanupEmptyParentDirs(repoPath);
-		throw err;
-	}
-	const referenceFileName = toReferenceFileName(source.fullName);
-	const hasReference = existsSync(join(Paths.offworldReferencesDir, referenceFileName));
-	upsertGlobalMapEntry(source.qualifiedName, {
-		localPath: repoPath,
-		references: hasReference ? [referenceFileName] : [],
-		primary: hasReference ? referenceFileName : "",
-		keywords: [],
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
-	return repoPath;
-}
-function cleanupEmptyParentDirs(repoPath) {
-	const ownerDir = dirname(repoPath);
-	if (existsSync(ownerDir) && readdirSync(ownerDir).length === 0) rmSync(ownerDir, {
-		recursive: true,
-		force: true
-	});
-}
-async function cloneStandard(cloneUrl, repoPath, options) {
-	const args = ["clone"];
-	if (options.shallow) args.push("--depth", "1");
-	if (options.branch) args.push("--branch", options.branch);
-	args.push(cloneUrl, repoPath);
-	await execGitAsync(args);
-}
-async function cloneSparse(cloneUrl, repoPath, options) {
-	const args = [
-		"clone",
-		"--filter=blob:none",
-		"--no-checkout",
-		"--sparse"
-	];
-	if (options.shallow) args.push("--depth", "1");
-	if (options.branch) args.push("--branch", options.branch);
-	args.push(cloneUrl, repoPath);
-	await execGitAsync(args);
-	await execGitAsync([
-		"sparse-checkout",
-		"set",
-		...SPARSE_CHECKOUT_DIRS
-	], repoPath);
-	await execGitAsync(["checkout"], repoPath);
-}
-function isShallowClone(repoPath) {
-	try {
-		return execGit(["rev-parse", "--is-shallow-repository"], repoPath) === "true";
-	} catch {
-		return false;
-	}
-}
-async function unshallowRepo(repoPath) {
-	if (!isShallowClone(repoPath)) return false;
-	await execGitAsync(["fetch", "--unshallow"], repoPath);
-	return true;
-}
-/**
-* Update a cloned repository by running git fetch and pull.
-*
-* @param qualifiedName - The qualified name of the repo (e.g., "github.com:owner/repo")
-* @param options - Update options
-* @returns Update result with commit SHAs
-* @throws RepoNotFoundError if repo not in index
-* @throws GitError if fetch/pull fails
-*/
-async function updateRepo(qualifiedName, options = {}) {
-	const entry = readGlobalMap().repos[qualifiedName];
-	if (!entry) throw new RepoNotFoundError(qualifiedName);
-	const repoPath = entry.localPath;
-	if (!existsSync(repoPath)) throw new RepoNotFoundError(qualifiedName);
-	const previousSha = getCommitSha(repoPath);
-	let unshallowed = false;
-	if (options.unshallow) unshallowed = await unshallowRepo(repoPath);
-	await execGitAsync(["fetch"], repoPath);
-	await execGitAsync(["pull", "--ff-only"], repoPath);
-	const currentSha = getCommitSha(repoPath);
-	upsertGlobalMapEntry(qualifiedName, {
-		...entry,
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
-	return {
-		updated: previousSha !== currentSha,
-		previousSha,
-		currentSha,
-		unshallowed
-	};
-}
-async function removeRepo(qualifiedName, options = {}) {
-	const entry = readGlobalMap().repos[qualifiedName];
-	if (!entry) return false;
-	const { referenceOnly = false, repoOnly = false } = options;
-	const removeRepoFiles = !referenceOnly;
-	const removeReferenceFiles = !repoOnly;
-	if (removeRepoFiles && existsSync(entry.localPath)) {
-		rmSync(entry.localPath, {
-			recursive: true,
-			force: true
-		});
-		cleanupEmptyParentDirs(entry.localPath);
-	}
-	if (removeReferenceFiles) {
-		for (const referenceFileName of entry.references) {
-			const referencePath = join(Paths.offworldReferencesDir, referenceFileName);
-			if (existsSync(referencePath)) rmSync(referencePath, { force: true });
-		}
-		if (entry.primary) {
-			const metaDirName = entry.primary.replace(/\.md$/, "");
-			const metaPath = join(Paths.metaDir, metaDirName);
-			if (existsSync(metaPath)) rmSync(metaPath, {
-				recursive: true,
-				force: true
-			});
-		}
-	}
-	if (removeRepoFiles) removeGlobalMapEntry(qualifiedName);
-	else if (removeReferenceFiles) upsertGlobalMapEntry(qualifiedName, {
-		...entry,
-		references: [],
-		primary: ""
-	});
-	return true;
-}
-function listRepos() {
-	const map = readGlobalMap();
-	return Object.keys(map.repos);
-}
-function isRepoCloned(qualifiedName) {
-	const entry = readGlobalMap().repos[qualifiedName];
-	if (!entry) return false;
-	return existsSync(entry.localPath);
-}
-/**
-* Get the local path for a cloned repository.
-*
-* @param qualifiedName - The qualified name of the repo
-* @returns The local path or undefined if not cloned
-*/
-function getClonedRepoPath(qualifiedName) {
-	const entry = readGlobalMap().repos[qualifiedName];
-	if (!entry) return void 0;
-	if (!existsSync(entry.localPath)) return void 0;
-	return entry.localPath;
-}
-
-//#endregion
-//#region src/ai/errors.ts
-/**
-* Base class for OpenCode reference errors
-*/
-var OpenCodeReferenceError = class extends Error {
-	_tag = "OpenCodeReferenceError";
-	constructor(message, details) {
-		super(message);
-		this.details = details;
-		this.name = "OpenCodeReferenceError";
-	}
-};
-/**
-* Error when the @opencode-ai/sdk package is not installed or invalid
-*/
-var OpenCodeSDKError = class extends OpenCodeReferenceError {
-	_tag = "OpenCodeSDKError";
-	constructor(message) {
-		super(message ?? "Failed to import @opencode-ai/sdk. Install it with: bun add @opencode-ai/sdk");
-		this.name = "OpenCodeSDKError";
-	}
-};
-/**
-* Error when the requested provider is not found
-*/
-var InvalidProviderError = class extends OpenCodeReferenceError {
-	_tag = "InvalidProviderError";
-	hint;
-	constructor(providerID, availableProviders) {
-		const hint = availableProviders.length > 0 ? `Available providers: ${availableProviders.join(", ")}` : "No providers available. Check your OpenCode configuration.";
-		super(`Provider "${providerID}" not found. ${hint}`);
-		this.providerID = providerID;
-		this.availableProviders = availableProviders;
-		this.name = "InvalidProviderError";
-		this.hint = hint;
-	}
-};
-/**
-* Error when the provider exists but is not connected/authenticated
-*/
-var ProviderNotConnectedError = class extends OpenCodeReferenceError {
-	_tag = "ProviderNotConnectedError";
-	hint;
-	constructor(providerID, connectedProviders) {
-		const hint = connectedProviders.length > 0 ? `Connected providers: ${connectedProviders.join(", ")}. Run 'opencode auth ${providerID}' to connect.` : `No providers connected. Run 'opencode auth ${providerID}' to authenticate.`;
-		super(`Provider "${providerID}" is not connected. ${hint}`);
-		this.providerID = providerID;
-		this.connectedProviders = connectedProviders;
-		this.name = "ProviderNotConnectedError";
-		this.hint = hint;
-	}
-};
-/**
-* Error when the requested model is not found for a provider
-*/
-var InvalidModelError = class extends OpenCodeReferenceError {
-	_tag = "InvalidModelError";
-	hint;
-	constructor(modelID, providerID, availableModels) {
-		const hint = availableModels.length > 0 ? `Available models for ${providerID}: ${availableModels.slice(0, 10).join(", ")}${availableModels.length > 10 ? ` (and ${availableModels.length - 10} more)` : ""}` : `No models available for provider "${providerID}".`;
-		super(`Model "${modelID}" not found for provider "${providerID}". ${hint}`);
-		this.modelID = modelID;
-		this.providerID = providerID;
-		this.availableModels = availableModels;
-		this.name = "InvalidModelError";
-		this.hint = hint;
-	}
-};
-/**
-* Error when the OpenCode server fails to start
-*/
-var ServerStartError = class extends OpenCodeReferenceError {
-	_tag = "ServerStartError";
-	hint;
-	constructor(message, port, details) {
-		const hint = port ? `Failed to start server on port ${port}. Ensure no other process is using this port.` : "Failed to start OpenCode server. Check your OpenCode installation and configuration.";
-		super(`${message}. ${hint}`, details);
-		this.port = port;
-		this.name = "ServerStartError";
-		this.hint = hint;
-	}
-};
-/**
-* Error when a session operation fails
-*/
-var SessionError = class extends OpenCodeReferenceError {
-	_tag = "SessionError";
-	hint;
-	constructor(message, sessionId, sessionState, details) {
-		const hint = `Session operation failed${sessionId ? ` (session: ${sessionId})` : ""}.${sessionState ? ` State: ${sessionState}.` : ""} Try creating a new session.`;
-		super(`${message}. ${hint}`, details);
-		this.sessionId = sessionId;
-		this.sessionState = sessionState;
-		this.name = "SessionError";
-		this.hint = hint;
-	}
-};
-/**
-* Error when a request times out
-*/
-var TimeoutError = class extends OpenCodeReferenceError {
-	_tag = "TimeoutError";
-	hint;
-	constructor(timeoutMs, operation = "operation") {
-		const hint = `The ${operation} did not complete within ${timeoutMs}ms. Consider increasing the timeout or checking if the model is responding.`;
-		super(`Timeout: ${operation} did not complete within ${timeoutMs}ms. ${hint}`);
-		this.timeoutMs = timeoutMs;
-		this.operation = operation;
-		this.name = "TimeoutError";
-		this.hint = hint;
-	}
-};
-
-//#endregion
-//#region src/ai/stream/types.ts
-/**
-* Zod schemas for OpenCode stream events
-* Replaces inline `as` casts with runtime-validated types
-*/
-const PartBaseSchema = z.object({
-	id: z.string().optional(),
-	sessionID: z.string().optional(),
-	messageID: z.string().optional()
-});
-const TextPartSchema = PartBaseSchema.extend({
-	type: z.literal("text"),
-	text: z.string().optional()
-});
-const ToolStatePendingSchema = z.object({ status: z.literal("pending") });
-const ToolStateRunningSchema = z.object({
-	status: z.literal("running"),
-	title: z.string().optional(),
-	input: z.unknown().optional(),
-	metadata: z.record(z.string(), z.unknown()).optional(),
-	time: z.object({ start: z.number() }).optional()
-});
-const ToolStateCompletedSchema = z.object({
-	status: z.literal("completed"),
-	title: z.string().optional(),
-	input: z.record(z.string(), z.unknown()).optional(),
-	output: z.string().optional(),
-	metadata: z.record(z.string(), z.unknown()).optional(),
-	time: z.object({
-		start: z.number(),
-		end: z.number()
-	}).optional()
-});
-const ToolStateErrorSchema = z.object({
-	status: z.literal("error"),
-	error: z.string().optional(),
-	input: z.record(z.string(), z.unknown()).optional(),
-	time: z.object({
-		start: z.number(),
-		end: z.number()
-	}).optional()
-});
-const ToolStateSchema = z.discriminatedUnion("status", [
-	ToolStatePendingSchema,
-	ToolStateRunningSchema,
-	ToolStateCompletedSchema,
-	ToolStateErrorSchema
-]);
-const ToolPartSchema = PartBaseSchema.extend({
-	type: z.literal("tool"),
-	callID: z.string().optional(),
-	tool: z.string().optional(),
-	state: ToolStateSchema.optional()
-});
-const StepStartPartSchema = PartBaseSchema.extend({ type: z.literal("step-start") });
-const StepFinishPartSchema = PartBaseSchema.extend({
-	type: z.literal("step-finish"),
-	reason: z.string().optional()
-});
-const ToolUsePartSchema = PartBaseSchema.extend({
-	type: z.literal("tool-use"),
-	toolUseId: z.string().optional(),
-	name: z.string().optional()
-});
-const ToolResultPartSchema = PartBaseSchema.extend({
-	type: z.literal("tool-result"),
-	toolUseId: z.string().optional()
-});
-const MessagePartSchema = z.discriminatedUnion("type", [
-	TextPartSchema,
-	ToolPartSchema,
-	StepStartPartSchema,
-	StepFinishPartSchema,
-	ToolUsePartSchema,
-	ToolResultPartSchema
-]);
-/**
-* Session error payload
-*/
-const SessionErrorSchema = z.object({
-	name: z.string().optional(),
-	message: z.string().optional(),
-	code: z.string().optional()
-});
-const MessagePartUpdatedPropsSchema = z.object({ part: MessagePartSchema });
-/**
-* Properties for session.idle event
-*/
-const SessionIdlePropsSchema = z.object({ sessionID: z.string() });
-/**
-* Properties for session.error event
-*/
-const SessionErrorPropsSchema = z.object({
-	sessionID: z.string(),
-	error: SessionErrorSchema.optional()
-});
-/**
-* Properties for session.updated event
-*/
-const SessionUpdatedPropsSchema = z.object({
-	sessionID: z.string(),
-	status: z.string().optional()
-});
-/**
-* message.part.updated event
-*/
-const MessagePartUpdatedEventSchema = z.object({
-	type: z.literal("message.part.updated"),
-	properties: MessagePartUpdatedPropsSchema
-});
-/**
-* session.idle event
-*/
-const SessionIdleEventSchema = z.object({
-	type: z.literal("session.idle"),
-	properties: SessionIdlePropsSchema
-});
-/**
-* session.error event
-*/
-const SessionErrorEventSchema = z.object({
-	type: z.literal("session.error"),
-	properties: SessionErrorPropsSchema
-});
-/**
-* session.updated event
-*/
-const SessionUpdatedEventSchema = z.object({
-	type: z.literal("session.updated"),
-	properties: SessionUpdatedPropsSchema
-});
-/**
-* Generic event for unknown types (passthrough)
-*/
-const GenericEventSchema = z.object({
-	type: z.string(),
-	properties: z.record(z.string(), z.unknown())
-});
-
-//#endregion
-//#region src/ai/stream/accumulator.ts
-/**
-* Accumulates text from streaming message parts.
-* Tracks multiple parts by ID and provides delta text between updates.
-*/
-var TextAccumulator = class {
-	parts = /* @__PURE__ */ new Map();
-	_firstTextReceived = false;
-	/**
-	* Whether any text has been received
-	*/
-	get hasReceivedText() {
-		return this._firstTextReceived;
-	}
-	/**
-	* Accumulate text from a message part and return the delta (new text only).
-	* Returns null if the part should be skipped (non-text, no ID, no text).
-	*/
-	accumulatePart(part) {
-		if (part.type !== "text" || !part.text || !part.id) return null;
-		const partId = part.id;
-		const prevText = this.parts.get(partId) ?? "";
-		this.parts.set(partId, part.text);
-		if (!this._firstTextReceived) this._firstTextReceived = true;
-		if (part.text.length > prevText.length) return part.text.slice(prevText.length);
-		return null;
-	}
-	/**
-	* Get the full accumulated text from all parts
-	*/
-	getFullText() {
-		return Array.from(this.parts.values()).join("");
-	}
-	/**
-	* Get the number of distinct parts accumulated
-	*/
-	getPartCount() {
-		return this.parts.size;
-	}
-	/**
-	* Get info about each part for debugging
-	*/
-	getPartInfo() {
-		return Array.from(this.parts.entries()).map(([id, text]) => ({
-			id,
-			length: text.length
-		}));
-	}
-	/**
-	* Clear accumulated text
-	*/
-	clear() {
-		this.parts.clear();
-		this._firstTextReceived = false;
-	}
-};
-
-//#endregion
-//#region src/ai/stream/transformer.ts
-/**
-* Stream event transformer and parser
-* Safely parses and validates stream events using Zod schemas
-*/
-/**
-* Parse a raw stream event into a typed result.
-* Uses safe parsing - returns type: "unknown" for unrecognized or invalid events.
-*/
-function parseStreamEvent(event) {
-	switch (event.type) {
-		case "message.part.updated": {
-			const propsResult = MessagePartUpdatedPropsSchema.safeParse(event.properties);
-			if (!propsResult.success) return {
-				type: "unknown",
-				rawType: event.type
-			};
-			const props = propsResult.data;
-			return {
-				type: "message.part.updated",
-				props,
-				textPart: props.part.type === "text" ? props.part : null,
-				toolPart: props.part.type === "tool" ? props.part : null
-			};
-		}
-		case "session.idle": {
-			const propsResult = SessionIdlePropsSchema.safeParse(event.properties);
-			if (!propsResult.success) return {
-				type: "unknown",
-				rawType: event.type
-			};
-			return {
-				type: "session.idle",
-				props: propsResult.data
-			};
-		}
-		case "session.error": {
-			const propsResult = SessionErrorPropsSchema.safeParse(event.properties);
-			if (!propsResult.success) return {
-				type: "unknown",
-				rawType: event.type
-			};
-			const props = propsResult.data;
-			let error = null;
-			if (props.error) {
-				const errorResult = SessionErrorSchema.safeParse(props.error);
-				if (errorResult.success) error = errorResult.data;
-			}
-			return {
-				type: "session.error",
-				props,
-				error
-			};
-		}
-		default: return {
-			type: "unknown",
-			rawType: event.type
-		};
-	}
-}
-function isEventForSession(event, sessionId) {
-	const props = event.properties;
-	if ("sessionID" in props && typeof props.sessionID === "string") return props.sessionID === sessionId;
-	if ("part" in props && typeof props.part === "object" && props.part !== null && "sessionID" in props.part && typeof props.part.sessionID === "string") return props.part.sessionID === sessionId;
-	return true;
-}
-
-//#endregion
-//#region src/ai/opencode.ts
-const DEFAULT_AI_PROVIDER = "opencode";
-const DEFAULT_AI_MODEL = "claude-opus-4-5";
-let cachedCreateOpencode = null;
-let cachedCreateOpencodeClient = null;
-async function getOpenCodeSDK() {
-	if (cachedCreateOpencode && cachedCreateOpencodeClient) return {
-		createOpencode: cachedCreateOpencode,
-		createOpencodeClient: cachedCreateOpencodeClient
-	};
-	try {
-		const sdk = await import("@opencode-ai/sdk");
-		if (typeof sdk.createOpencode !== "function" || typeof sdk.createOpencodeClient !== "function") throw new OpenCodeSDKError("SDK missing required exports");
-		cachedCreateOpencode = sdk.createOpencode;
-		cachedCreateOpencodeClient = sdk.createOpencodeClient;
-		return {
-			createOpencode: cachedCreateOpencode,
-			createOpencodeClient: cachedCreateOpencodeClient
-		};
-	} catch (error) {
-		if (error instanceof OpenCodeSDKError) throw error;
-		throw new OpenCodeSDKError();
-	}
-}
-function formatToolMessage(tool, state) {
-	if (state.title) return state.title;
-	if (!tool) return null;
-	const input = state.input && typeof state.input === "object" && !Array.isArray(state.input) ? state.input : void 0;
-	if (!input) return `Running ${tool}...`;
-	switch (tool) {
-		case "read": {
-			const path = input.filePath ?? input.path;
-			if (typeof path === "string") return `Reading ${path.split("/").pop()}...`;
-			return "Reading file...";
-		}
-		case "glob": {
-			const pattern = input.pattern;
-			if (typeof pattern === "string") return `Globbing ${pattern}...`;
-			return "Searching files...";
-		}
-		case "grep": {
-			const pattern = input.pattern;
-			if (typeof pattern === "string") return `Searching for "${pattern.length > 30 ? `${pattern.slice(0, 30)}...` : pattern}"...`;
-			return "Searching content...";
-		}
-		case "list": {
-			const path = input.path;
-			if (typeof path === "string") return `Listing ${path}...`;
-			return "Listing directory...";
-		}
-		default: return `Running ${tool}...`;
-	}
-}
-async function streamPrompt(options) {
-	const { prompt, cwd, systemPrompt, provider: optProvider, model: optModel, timeoutMs, onDebug, onStream } = options;
-	const debug = onDebug ?? (() => {});
-	const stream = onStream ?? (() => {});
-	const startTime = Date.now();
-	debug("Loading OpenCode SDK...");
-	const { createOpencode, createOpencodeClient } = await getOpenCodeSDK();
-	const maxAttempts = 10;
-	let server = null;
-	let client = null;
-	let port = 0;
-	const config = {
-		plugin: [],
-		mcp: {},
-		instructions: [],
-		agent: {
-			build: { disable: true },
-			general: { disable: true },
-			plan: { disable: true },
-			explore: { disable: true },
-			analyze: {
-				prompt: [
-					"You are an expert at analyzing open source codebases and producing documentation.",
-					"",
-					"Your job is to read the codebase and produce structured output based on the user's request.",
-					"Use glob to discover files, grep to search for patterns, and read to examine file contents.",
-					"",
-					"Guidelines:",
-					"- Explore the codebase thoroughly before producing output",
-					"- Focus on understanding architecture, key abstractions, and usage patterns",
-					"- When asked for JSON output, respond with ONLY valid JSON - no markdown, no code blocks",
-					"- When asked for prose, write clear and concise documentation",
-					"- Always base your analysis on actual code you've read, never speculate"
-				].join("\n"),
-				mode: "primary",
-				description: "Analyze open source codebases and produce summaries and reference files",
-				tools: {
-					read: true,
-					grep: true,
-					glob: true,
-					list: true,
-					write: false,
-					bash: false,
-					delete: false,
-					edit: false,
-					patch: false,
-					path: false,
-					todowrite: false,
-					todoread: false,
-					websearch: false,
-					webfetch: false,
-					codesearch: false,
-					skill: false,
-					task: false,
-					mcp: false,
-					question: false,
-					plan_enter: false,
-					plan_exit: false
-				},
-				permission: {
-					edit: "deny",
-					bash: "deny",
-					webfetch: "deny",
-					external_directory: "deny"
-				}
-			}
-		}
-	};
-	debug("Starting embedded OpenCode server...");
-	for (let attempt = 0; attempt < maxAttempts; attempt++) {
-		port = Math.floor(Math.random() * 3e3) + 3e3;
-		try {
-			server = (await createOpencode({
-				port,
-				cwd,
-				config
-			})).server;
-			client = createOpencodeClient({
-				baseUrl: `http://localhost:${port}`,
-				directory: cwd
-			});
-			debug(`Server started on port ${port}`);
-			break;
-		} catch (err) {
-			if (err instanceof Error && err.message?.includes("port")) continue;
-			throw new ServerStartError("Failed to start OpenCode server", port, err);
-		}
-	}
-	if (!server || !client) throw new ServerStartError("Failed to start OpenCode server after all attempts");
-	const providerID = optProvider ?? DEFAULT_AI_PROVIDER;
-	const modelID = optModel ?? DEFAULT_AI_MODEL;
-	try {
-		debug("Creating session...");
-		const sessionResult = await client.session.create();
-		if (sessionResult.error) throw new SessionError("Failed to create session", void 0, void 0, sessionResult.error);
-		const sessionId = sessionResult.data.id;
-		debug(`Session created: ${sessionId}`);
-		debug("Validating provider and model...");
-		const providerResult = await client.provider.list();
-		if (providerResult.error) throw new OpenCodeReferenceError("Failed to fetch provider list", providerResult.error);
-		const { all: allProviders, connected: connectedProviders } = providerResult.data;
-		const allProviderIds = allProviders.map((p) => p.id);
-		const provider = allProviders.find((p) => p.id === providerID);
-		if (!provider) throw new InvalidProviderError(providerID, allProviderIds);
-		if (!connectedProviders.includes(providerID)) throw new ProviderNotConnectedError(providerID, connectedProviders);
-		const availableModelIds = Object.keys(provider.models);
-		if (!provider.models[modelID]) throw new InvalidModelError(modelID, providerID, availableModelIds);
-		debug(`Provider "${providerID}" and model "${modelID}" validated`);
-		debug("Subscribing to events...");
-		const { stream: eventStream } = await client.event.subscribe();
-		const fullPrompt = systemPrompt ? `${systemPrompt}\n\nAnalyzing codebase at: ${cwd}\n\n${prompt}` : `Analyzing codebase at: ${cwd}\n\n${prompt}`;
-		debug("Sending prompt...");
-		const promptPromise = client.session.prompt({
-			path: { id: sessionId },
-			body: {
-				agent: "analyze",
-				parts: [{
-					type: "text",
-					text: fullPrompt
-				}],
-				model: {
-					providerID,
-					modelID
-				}
-			}
-		});
-		const textAccumulator = new TextAccumulator();
-		debug("Waiting for response...");
-		let timeoutId = null;
-		const processEvents = async () => {
-			for await (const event of eventStream) {
-				if (!isEventForSession(event, sessionId)) continue;
-				const parsed = parseStreamEvent(event);
-				switch (parsed.type) {
-					case "message.part.updated":
-						if (parsed.toolPart?.state) {
-							const { state, tool } = parsed.toolPart;
-							if (state.status === "running") {
-								const message = formatToolMessage(tool, state);
-								if (message) debug(message);
-							}
-						}
-						if (parsed.textPart) {
-							const delta = textAccumulator.accumulatePart(parsed.textPart);
-							if (!textAccumulator.hasReceivedText) debug("Writing reference...");
-							if (delta) stream(delta);
-						}
-						break;
-					case "session.idle":
-						if (parsed.props.sessionID === sessionId) {
-							debug("Response complete");
-							return textAccumulator.getFullText();
-						}
-						break;
-					case "session.error":
-						if (parsed.props.sessionID === sessionId) {
-							const errorName = parsed.error?.name ?? "Unknown session error";
-							debug(`Session error: ${JSON.stringify(parsed.props.error)}`);
-							throw new SessionError(errorName, sessionId, "error", parsed.props.error);
-						}
-						break;
-					case "unknown": break;
-				}
-			}
-			return textAccumulator.getFullText();
-		};
-		let responseText;
-		if (timeoutMs && timeoutMs > 0) {
-			const timeoutPromise = new Promise((_, reject) => {
-				timeoutId = setTimeout(() => {
-					reject(new TimeoutError(timeoutMs, "session response"));
-				}, timeoutMs);
-			});
-			responseText = await Promise.race([processEvents(), timeoutPromise]);
-			if (timeoutId) clearTimeout(timeoutId);
-		} else responseText = await processEvents();
-		await promptPromise;
-		if (!responseText) throw new OpenCodeReferenceError("No response received from OpenCode");
-		debug(`Response received (${responseText.length} chars)`);
-		const durationMs = Date.now() - startTime;
-		debug(`Complete in ${durationMs}ms`);
-		return {
-			text: responseText,
-			sessionId,
-			durationMs
-		};
-	} finally {
-		debug("Closing server...");
-		server.close();
-	}
-}
-
-//#endregion
-//#region src/sync.ts
-/**
-* Sync utilities for CLI-Convex communication
-* Uses ConvexHttpClient for direct type-safe API calls
-*/
-const PRODUCTION_CONVEX_URL = "https://trustworthy-coyote-128.convex.cloud";
-function getConvexUrl() {
-	return process.env.CONVEX_URL ?? PRODUCTION_CONVEX_URL;
-}
-const GITHUB_API_BASE = "https://api.github.com";
-var SyncError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "SyncError";
-	}
-};
-var NetworkError = class extends SyncError {
-	constructor(message, statusCode) {
-		super(message);
-		this.statusCode = statusCode;
-		this.name = "NetworkError";
-	}
-};
-var AuthenticationError = class extends SyncError {
-	constructor(message = "Authentication required. Please run 'ow auth login' first.") {
-		super(message);
-		this.name = "AuthenticationError";
-	}
-};
-var RateLimitError = class extends SyncError {
-	constructor(message = "Rate limit exceeded. You can push up to 3 times per repo per day.") {
-		super(message);
-		this.name = "RateLimitError";
-	}
-};
-var ConflictError = class extends SyncError {
-	constructor(message = "A newer reference already exists on the server.", remoteCommitSha) {
-		super(message);
-		this.remoteCommitSha = remoteCommitSha;
-		this.name = "ConflictError";
-	}
-};
-var CommitExistsError = class extends SyncError {
-	constructor(message = "A reference already exists for this commit SHA.") {
-		super(message);
-		this.name = "CommitExistsError";
-	}
-};
-var InvalidInputError = class extends SyncError {
-	constructor(message) {
-		super(message);
-		this.name = "InvalidInputError";
-	}
-};
-var InvalidReferenceError = class extends SyncError {
-	constructor(message) {
-		super(message);
-		this.name = "InvalidReferenceError";
-	}
-};
-var RepoNotFoundError$1 = class extends SyncError {
-	constructor(message = "Repository not found on GitHub.") {
-		super(message);
-		this.name = "RepoNotFoundError";
-	}
-};
-var LowStarsError = class extends SyncError {
-	constructor(message = "Repository has less than 5 stars.") {
-		super(message);
-		this.name = "LowStarsError";
-	}
-};
-var PrivateRepoError = class extends SyncError {
-	constructor(message = "Private repositories are not supported.") {
-		super(message);
-		this.name = "PrivateRepoError";
-	}
-};
-var CommitNotFoundError = class extends SyncError {
-	constructor(message = "Commit not found in repository.") {
-		super(message);
-		this.name = "CommitNotFoundError";
-	}
-};
-var GitHubError = class extends SyncError {
-	constructor(message = "GitHub API error.") {
-		super(message);
-		this.name = "GitHubError";
-	}
-};
-var PushNotAllowedError = class extends SyncError {
-	constructor(message, reason) {
-		super(message);
-		this.reason = reason;
-		this.name = "PushNotAllowedError";
-	}
-};
-function createClient(token) {
-	const client = new ConvexHttpClient(getConvexUrl());
-	if (token) client.setAuth(token);
-	return client;
-}
-/**
-* Fetches reference from the remote server
-* @param fullName - Repository full name (owner/repo)
-* @returns Reference data or null if not found
-*/
-async function pullReference(fullName) {
-	const client = createClient();
-	try {
-		let result = await client.query(api.references.pull, {
-			fullName,
-			referenceName: toReferenceName(fullName)
-		});
-		if (!result) result = await client.query(api.references.pull, { fullName });
-		if (!result) return null;
-		client.mutation(api.references.recordPull, {
-			fullName,
-			referenceName: result.referenceName
-		}).catch(() => {});
-		return {
-			fullName: result.fullName,
-			referenceName: result.referenceName,
-			referenceDescription: result.referenceDescription,
-			referenceContent: result.referenceContent,
-			commitSha: result.commitSha,
-			generatedAt: result.generatedAt
-		};
-	} catch (error) {
-		throw new NetworkError(`Failed to pull reference: ${error instanceof Error ? error.message : error}`);
-	}
-}
-/**
-* Fetches a specific reference by name from the remote server
-* @param fullName - Repository full name (owner/repo)
-* @param referenceName - Specific reference name to pull
-* @returns Reference data or null if not found
-*/
-async function pullReferenceByName(fullName, referenceName) {
-	const client = createClient();
-	try {
-		const result = await client.query(api.references.pull, {
-			fullName,
-			referenceName
-		});
-		if (!result) return null;
-		client.mutation(api.references.recordPull, {
-			fullName,
-			referenceName
-		}).catch(() => {});
-		return {
-			fullName: result.fullName,
-			referenceName: result.referenceName,
-			referenceDescription: result.referenceDescription,
-			referenceContent: result.referenceContent,
-			commitSha: result.commitSha,
-			generatedAt: result.generatedAt
-		};
-	} catch (error) {
-		throw new NetworkError(`Failed to pull reference: ${error instanceof Error ? error.message : error}`);
-	}
-}
-/**
-* Pushes reference to the remote server
-* All validation happens server-side
-* @param reference - Reference data to push
-* @param token - Authentication token
-* @returns Push result
-*/
-async function pushReference(reference, token) {
-	const client = createClient(token);
-	try {
-		const result = await client.action(api.references.push, {
-			fullName: reference.fullName,
-			referenceName: reference.referenceName,
-			referenceDescription: reference.referenceDescription,
-			referenceContent: reference.referenceContent,
-			commitSha: reference.commitSha,
-			generatedAt: reference.generatedAt
-		});
-		if (!result.success) switch (result.error) {
-			case "auth_required": throw new AuthenticationError();
-			case "rate_limit": throw new RateLimitError("Rate limit exceeded. You can push up to 20 times per day.");
-			case "commit_already_exists": throw new CommitExistsError(result.message);
-			case "invalid_input": throw new InvalidInputError(result.message ?? "Invalid input");
-			case "invalid_reference": throw new InvalidReferenceError(result.message ?? "Invalid reference content");
-			case "repo_not_found": throw new RepoNotFoundError$1(result.message);
-			case "low_stars": throw new LowStarsError(result.message);
-			case "private_repo": throw new PrivateRepoError(result.message);
-			case "commit_not_found": throw new CommitNotFoundError(result.message);
-			case "github_error": throw new GitHubError(result.message);
-			default: throw new SyncError(result.message ?? "Unknown error");
-		}
-		return { success: true };
-	} catch (error) {
-		if (error instanceof SyncError) throw error;
-		throw new NetworkError(`Failed to push reference: ${error instanceof Error ? error.message : error}`);
-	}
-}
-/**
-* Checks if reference exists on remote server (lightweight check)
-* @param fullName - Repository full name (owner/repo)
-* @returns Check result
-*/
-async function checkRemote(fullName) {
-	const client = createClient();
-	try {
-		let result = await client.query(api.references.check, {
-			fullName,
-			referenceName: toReferenceName(fullName)
-		});
-		if (!result.exists) result = await client.query(api.references.check, { fullName });
-		if (!result.exists) return { exists: false };
-		return {
-			exists: true,
-			commitSha: result.commitSha,
-			generatedAt: result.generatedAt
-		};
-	} catch (error) {
-		throw new NetworkError(`Failed to check remote: ${error instanceof Error ? error.message : error}`);
-	}
-}
-/**
-* Checks if a specific reference exists on the remote server
-* @param fullName - Repository full name (owner/repo)
-* @param referenceName - Specific reference name to check
-* @returns Check result
-*/
-async function checkRemoteByName(fullName, referenceName) {
-	const client = createClient();
-	try {
-		const result = await client.query(api.references.check, {
-			fullName,
-			referenceName
-		});
-		if (!result.exists) return { exists: false };
-		return {
-			exists: true,
-			commitSha: result.commitSha,
-			generatedAt: result.generatedAt
-		};
-	} catch (error) {
-		throw new NetworkError(`Failed to check remote: ${error instanceof Error ? error.message : error}`);
-	}
-}
-/**
-* Compares local vs remote commit SHA to check staleness
-* @param fullName - Repository full name (owner/repo)
-* @param localCommitSha - Local commit SHA
-* @returns Staleness result
-*/
-async function checkStaleness(fullName, localCommitSha) {
-	const remote = await checkRemote(fullName);
-	if (!remote.exists || !remote.commitSha) return {
-		isStale: false,
-		localCommitSha,
-		remoteCommitSha: void 0
-	};
-	return {
-		isStale: localCommitSha !== remote.commitSha,
-		localCommitSha,
-		remoteCommitSha: remote.commitSha
-	};
-}
-/**
-* Fetches GitHub repository metadata
-* @param owner - Repository owner
-* @param repo - Repository name
-* @returns Repository metadata or null on error
-*/
-async function fetchGitHubMetadata(owner, repo) {
-	try {
-		const response = await fetch(`${GITHUB_API_BASE}/repos/${owner}/${repo}`, { headers: {
-			Accept: "application/vnd.github.v3+json",
-			"User-Agent": "offworld-cli"
-		} });
-		if (!response.ok) return null;
-		const json = await response.json();
-		const result = GitHubRepoMetadataSchema.safeParse(json);
-		if (!result.success) return null;
-		const data = result.data;
-		return {
-			stars: data.stargazers_count ?? 0,
-			description: data.description ?? void 0,
-			language: data.language ?? void 0,
-			defaultBranch: data.default_branch ?? "main"
-		};
-	} catch {
-		return null;
-	}
-}
-/**
-* Fetches GitHub repository stars
-* @param owner - Repository owner
-* @param repo - Repository name
-* @returns Number of stars, or 0 on error
-*/
-async function fetchRepoStars(owner, repo) {
-	return (await fetchGitHubMetadata(owner, repo))?.stars ?? 0;
-}
-/**
-* Checks if a repository can be pushed to offworld.sh (client-side quick checks)
-* Note: Star count and other validations happen server-side
-*
-* @param source - Repository source
-* @returns Can push result
-*/
-function canPushToWeb(source) {
-	if (source.type === "local") return {
-		allowed: false,
-		reason: "Local repositories cannot be pushed to offworld.sh. Only remote repositories with a public URL are supported."
-	};
-	if (source.provider !== "github") return {
-		allowed: false,
-		reason: `${source.provider} repositories are not yet supported. GitHub support only for now - GitLab and Bitbucket coming soon!`
-	};
-	return { allowed: true };
-}
-/**
-* Validates that a source can be pushed and throws appropriate error if not
-* Note: This only does quick client-side checks. Full validation happens server-side.
-* @param source - Repository source
-* @throws PushNotAllowedError if push is not allowed
-*/
-function validatePushAllowed(source) {
-	const result = canPushToWeb(source);
-	if (!result.allowed) {
-		const reason = source.type === "local" ? "local" : "not-github";
-		throw new PushNotAllowedError(result.reason, reason);
-	}
-}
-
-//#endregion
-//#region src/auth.ts
-/**
-* Authentication utilities for offworld CLI
-*/
-const AuthDataSchema = z.object({
-	token: z.string(),
-	expiresAt: z.string().optional(),
-	workosId: z.string().optional(),
-	refreshToken: z.string().optional(),
-	email: z.string().optional()
-});
-var AuthError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "AuthError";
-	}
-};
-var NotLoggedInError = class extends AuthError {
-	constructor(message = "Not logged in. Please run 'ow auth login' first.") {
-		super(message);
-		this.name = "NotLoggedInError";
-	}
-};
-var TokenExpiredError = class extends AuthError {
-	constructor(message = "Session expired. Please run 'ow auth login' again.") {
-		super(message);
-		this.name = "TokenExpiredError";
-	}
-};
-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;
-	}
-}
-function getAuthPath() {
-	return Paths.authFile;
-}
-function saveAuthData(data) {
-	const authPath = getAuthPath();
-	const authDir = dirname(authPath);
-	if (!existsSync(authDir)) mkdirSync(authDir, { recursive: true });
-	writeFileSync(authPath, JSON.stringify(data, null, 2), "utf-8");
-	chmodSync(authPath, 384);
-}
-/**
-* Loads authentication data from ~/.local/share/offworld/auth.json
-* Returns null if file doesn't exist or is invalid
-*/
-function loadAuthData() {
-	const authPath = getAuthPath();
-	if (!existsSync(authPath)) return null;
-	try {
-		const content = readFileSync(authPath, "utf-8");
-		const json = JSON.parse(content);
-		const parsed = AuthDataSchema.safeParse(json);
-		if (!parsed.success) return null;
-		return parsed.data;
-	} catch {
-		return null;
-	}
-}
-/**
-* Clears stored authentication data
-* @returns true if auth file was deleted, false if it didn't exist
-*/
-function clearAuthData() {
-	const authPath = getAuthPath();
-	if (!existsSync(authPath)) return false;
-	try {
-		unlinkSync(authPath);
-		return true;
-	} catch {
-		return false;
-	}
-}
-async function getToken() {
-	const data = loadAuthData();
-	if (!data) throw new NotLoggedInError();
-	let expiresAtStr = data.expiresAt;
-	if (!expiresAtStr) {
-		expiresAtStr = extractJwtExpiration(data.token);
-		if (expiresAtStr) {
-			data.expiresAt = expiresAtStr;
-			saveAuthData(data);
-		}
-	}
-	if (expiresAtStr) {
-		const expiresAt = new Date(expiresAtStr);
-		const now = /* @__PURE__ */ new Date();
-		const oneMinute = 60 * 1e3;
-		if (expiresAt <= now) {
-			if (data.refreshToken) try {
-				return (await refreshAccessToken()).token;
-			} catch {
-				throw new TokenExpiredError();
-			}
-			throw new TokenExpiredError();
-		}
-		if (expiresAt.getTime() - now.getTime() < oneMinute) {
-			if (data.refreshToken) try {
-				return (await refreshAccessToken()).token;
-			} catch {
-				return data.token;
-			}
-		}
-	}
-	return data.token;
-}
-/**
-* Gets the current authentication token, or null if not logged in
-* Does not throw errors
-*/
-async function getTokenOrNull() {
-	try {
-		return await getToken();
-	} catch {
-		return null;
-	}
-}
-async function isLoggedIn() {
-	return await getTokenOrNull() !== null;
-}
-async function getAuthStatus() {
-	const data = loadAuthData();
-	if (!data) return { isLoggedIn: false };
-	let expiresAtStr = data.expiresAt;
-	if (!expiresAtStr) {
-		expiresAtStr = extractJwtExpiration(data.token);
-		if (expiresAtStr) {
-			data.expiresAt = expiresAtStr;
-			saveAuthData(data);
-		}
-	}
-	if (expiresAtStr) {
-		const expiresAt = new Date(expiresAtStr);
-		const now = /* @__PURE__ */ new Date();
-		const oneMinute = 60 * 1e3;
-		if (expiresAt <= now) {
-			if (data.refreshToken) try {
-				const refreshed = await refreshAccessToken();
-				return {
-					isLoggedIn: true,
-					email: refreshed.email,
-					workosId: refreshed.workosId,
-					expiresAt: refreshed.expiresAt
-				};
-			} catch {
-				return { isLoggedIn: false };
-			}
-			return { isLoggedIn: false };
-		}
-		if (expiresAt.getTime() - now.getTime() < oneMinute) {
-			if (data.refreshToken) try {
-				const refreshed = await refreshAccessToken();
-				return {
-					isLoggedIn: true,
-					email: refreshed.email,
-					workosId: refreshed.workosId,
-					expiresAt: refreshed.expiresAt
-				};
-			} catch {
-				return {
-					isLoggedIn: true,
-					email: data.email,
-					workosId: data.workosId,
-					expiresAt: expiresAtStr
-				};
-			}
-		}
-	}
-	return {
-		isLoggedIn: true,
-		email: data.email,
-		workosId: data.workosId,
-		expiresAt: expiresAtStr
-	};
-}
-const WORKOS_API = "https://api.workos.com";
-const PRODUCTION_WORKOS_CLIENT_ID = "client_01KFAD76TNGN02AP96982HG35E";
-function getWorkosClientId() {
-	return process.env.WORKOS_CLIENT_ID ?? PRODUCTION_WORKOS_CLIENT_ID;
-}
-async function refreshAccessToken() {
-	const data = loadAuthData();
-	if (!data?.refreshToken) throw new AuthError("No refresh token available. Please log in again.");
-	try {
-		const response = await fetch(`${WORKOS_API}/user_management/authenticate`, {
-			method: "POST",
-			headers: { "Content-Type": "application/x-www-form-urlencoded" },
-			body: new URLSearchParams({
-				grant_type: "refresh_token",
-				refresh_token: data.refreshToken,
-				client_id: getWorkosClientId()
-			})
-		});
-		if (!response.ok) throw new AuthError(`Token refresh failed: ${await response.text()}`);
-		const json = await response.json();
-		const tokenData = WorkOSTokenResponseSchema.parse(json);
-		const newAuthData = {
-			token: tokenData.access_token,
-			email: tokenData.user.email,
-			workosId: tokenData.user.id,
-			refreshToken: tokenData.refresh_token,
-			expiresAt: tokenData.expires_at ? (/* @__PURE__ */ new Date(tokenData.expires_at * 1e3)).toISOString() : extractJwtExpiration(tokenData.access_token)
-		};
-		saveAuthData(newAuthData);
-		return newAuthData;
-	} catch (error) {
-		if (error instanceof AuthError) throw error;
-		throw new AuthError(`Failed to refresh token: ${error instanceof Error ? error.message : "Unknown error"}`);
-	}
-}
-
-//#endregion
-//#region src/agents.ts
-/**
-* Agent Registry & Auto-Detection
-*
-* Centralized registry of supported AI coding agents with their
-* skill directory locations and detection functions.
-*/
-const agents = {
-	opencode: {
-		name: "opencode",
-		displayName: "OpenCode",
-		skillsDir: ".opencode/skills",
-		globalSkillsDir: "~/.config/opencode/skills",
-		detectInstalled: () => existsSync(expandTilde("~/.config/opencode"))
-	},
-	"claude-code": {
-		name: "claude-code",
-		displayName: "Claude Code",
-		skillsDir: ".claude/skills",
-		globalSkillsDir: "~/.claude/skills",
-		detectInstalled: () => existsSync(expandTilde("~/.claude"))
-	},
-	codex: {
-		name: "codex",
-		displayName: "Codex (OpenAI)",
-		skillsDir: ".codex/skills",
-		globalSkillsDir: "~/.codex/skills",
-		detectInstalled: () => existsSync(expandTilde("~/.codex"))
-	},
-	amp: {
-		name: "amp",
-		displayName: "Amp",
-		skillsDir: ".agents/skills",
-		globalSkillsDir: "~/.config/agents/skills",
-		detectInstalled: () => existsSync(expandTilde("~/.config/amp"))
-	},
-	antigravity: {
-		name: "antigravity",
-		displayName: "Antigravity",
-		skillsDir: ".agent/skills",
-		globalSkillsDir: "~/.gemini/antigravity/skills",
-		detectInstalled: () => existsSync(expandTilde("~/.gemini/antigravity"))
-	},
-	cursor: {
-		name: "cursor",
-		displayName: "Cursor",
-		skillsDir: ".cursor/skills",
-		globalSkillsDir: "~/.cursor/skills",
-		detectInstalled: () => existsSync(expandTilde("~/.cursor"))
-	}
-};
-/**
-* Detect which agents are installed on the system.
-* Checks for the existence of each agent's config directory.
-*
-* @returns Array of installed agent identifiers
-*/
-function detectInstalledAgents() {
-	const installed = [];
-	for (const config of Object.values(agents)) if (config.detectInstalled()) installed.push(config.name);
-	return installed;
-}
-/**
-* Get the configuration for a specific agent.
-*
-* @param type - Agent identifier
-* @returns AgentConfig for the specified agent
-*/
-function getAgentConfig(type) {
-	return agents[type];
-}
-/**
-* Get all agent configurations as an array.
-*
-* @returns Array of all agent configurations
-*/
-function getAllAgentConfigs() {
-	return Object.values(agents);
-}
-
-//#endregion
-//#region src/generate.ts
-/**
-* This module provides a streamlined approach to generating reference files
-* by delegating all codebase exploration to the AI agent via OpenCode.
-*/
-const PackageJsonKeywordsSchema = z.object({
-	name: z.string().optional(),
-	keywords: z.array(z.string()).optional()
-});
-function normalizeKeyword(value) {
-	const trimmed = value.trim();
-	if (!trimmed) return [];
-	const normalized = trimmed.toLowerCase();
-	const tokens = /* @__PURE__ */ new Set();
-	const addToken = (token) => {
-		const cleaned = token.trim().toLowerCase();
-		if (cleaned.length < 2) return;
-		tokens.add(cleaned);
-	};
-	addToken(normalized);
-	addToken(normalized.replaceAll("/", "-"));
-	addToken(normalized.replaceAll("/", ""));
-	for (const token of normalized.split(/[\s/_-]+/)) addToken(token);
-	if (normalized.startsWith("@")) addToken(normalized.slice(1));
-	return Array.from(tokens);
-}
-function deriveKeywords(fullName, localPath, referenceContent) {
-	const keywords = /* @__PURE__ */ new Set();
-	const addKeywords = (value) => {
-		for (const token of normalizeKeyword(value)) keywords.add(token);
-	};
-	addKeywords(fullName);
-	const headingMatch = referenceContent.match(/^#\s+(.+)$/m);
-	if (headingMatch?.[1]) addKeywords(headingMatch[1]);
-	const packageJsonPath = join(localPath, "package.json");
-	if (existsSync(packageJsonPath)) try {
-		const content = readFileSync(packageJsonPath, "utf-8");
-		const json = JSON.parse(content);
-		const parsed = PackageJsonKeywordsSchema.safeParse(json);
-		if (parsed.success) {
-			if (parsed.data.name) addKeywords(parsed.data.name);
-			if (parsed.data.keywords) for (const keyword of parsed.data.keywords) addKeywords(keyword);
-		}
-	} catch {}
-	return Array.from(keywords);
-}
-function createReferenceGenerationPrompt(referenceName) {
-	return `You are an expert at analyzing open source libraries and producing reference documentation for AI coding agents.
-
-## PRIMARY GOAL
-
-Generate a reference markdown file that helps developers USE this library effectively. This is NOT a contribution guide - it's a usage reference for developers consuming this library in their own projects.
-
-## CRITICAL RULES
-
-1. **USER PERSPECTIVE ONLY**: Write for developers who will npm/pip/cargo install this library and use it in THEIR code.
-   - DO NOT include: how to contribute, internal test commands, repo-specific policies
-   - DO NOT include: "never mock in tests" or similar internal dev guidelines
-   - DO NOT include: commands like "npx hereby", "just ready", "bun test" that run the library's own tests
-   - DO include: how to install, import, configure, and use the public API
-
-2. **NO FRONTMATTER**: Output pure markdown with NO YAML frontmatter. Start directly with the library name heading.
-
-3. **QUICK REFERENCES**: Include a "Quick References" section with paths to key entry points in the repo:
-   - Paths must be relative from repo root (e.g., \`src/index.ts\`, \`docs/api.md\`)
-   - Include: main entry point, type definitions, README, key docs
-   - DO NOT include absolute paths or user-specific paths
-   - Keep to 3-5 most important files that help users understand the library
-
-4. **PUBLIC API FOCUS**: Document what users import and call, not internal implementation details.
-   - Entry points: what to import from the package
-   - Configuration: how to set up/initialize
-   - Core methods/functions: the main API surface
-   - Types: key TypeScript interfaces users need
-
-5. **MONOREPO AWARENESS**: Many libraries are monorepos with multiple packages:
-   - Check for \`packages/\`, \`apps/\`, \`crates/\`, or \`libs/\` directories
-   - Check root package.json for \`workspaces\` field
-   - If monorepo: document the package structure and key packages users would install
-   - Use full paths from repo root (e.g., \`packages/core/src/index.ts\`)
-   - Identify which packages are publishable vs internal
-
-## EXPLORATION STEPS
-
-Use Read, Grep, Glob tools to explore:
-1. Root package.json / Cargo.toml - check for workspaces/monorepo config
-2. Check for \`packages/\`, \`apps/\`, \`crates/\` directories
-3. README.md - official usage documentation
-4. For monorepos: explore each publishable package's entry point
-5. docs/ or website/ - find documentation
-6. examples/ - real usage patterns
-7. TypeScript definitions (.d.ts) - public API surface
-
-## OUTPUT FORMAT
-
-IMPORTANT: Reference name is "${referenceName}" (for internal tracking only - do NOT include in output).
-
-\`\`\`markdown
-# {Library Name}
-
-{2-3 sentence overview of what this library does and its key value proposition}
-
-## Quick References
-
-| File | Purpose |
-|------|---------|
-| \`packages/{pkg}/src/index.ts\` | Main entry point (monorepo example) |
-| \`src/index.ts\` | Main entry point (single-package example) |
-| \`README.md\` | Documentation |
-
-(For monorepos, include paths to key publishable packages)
-
-## Packages (for monorepos only)
-
-| Package | npm name | Description |
-|---------|----------|-------------|
-| \`packages/core\` | \`@scope/core\` | Core functionality |
-| \`packages/react\` | \`@scope/react\` | React bindings |
-
-(OMIT this section for single-package repos)
-
-## When to Use
-
-- {Practical scenario where a developer would reach for this library}
-- {Another real-world use case}
-- {Problem this library solves}
-
-## Installation
-
-\`\`\`bash
-# Single package
-npm install {package-name}
-
-# Monorepo (show key packages)
-npm install @scope/core @scope/react
-\`\`\`
-
-## Best Practices
-
-1. {Actionable best practice for USERS of this library}
-2. {Common mistake to avoid when using this library}
-3. {Performance or correctness tip}
-
-## Common Patterns
-
-**{Pattern Name}:**
-\`\`\`{language}
-{Minimal working code example}
-\`\`\`
-
-**{Another Pattern}:**
-\`\`\`{language}
-{Another code example}
-\`\`\`
-
-## API Quick Reference
-
-| Export | Type | Description |
-|--------|------|-------------|
-| \`{main export}\` | {type} | {what it does} |
-| \`{another export}\` | {type} | {what it does} |
-
-{Add more sections as appropriate for the library: Configuration, Types, CLI Commands (if user-facing), etc.}
-\`\`\`
-
-## QUALITY CHECKLIST
-
-Before outputting, verify:
-- [ ] NO YAML frontmatter - start directly with # heading
-- [ ] Every code example is something a USER would write, not a contributor
-- [ ] No internal test commands or contribution workflows
-- [ ] Quick References paths are relative from repo root (no absolute/user paths)
-- [ ] Best practices are for using the library, not developing it
-- [ ] If monorepo: Packages section lists publishable packages with npm names
-- [ ] If monorepo: paths include package directory (e.g., \`packages/core/src/index.ts\`)
-
-Now explore the codebase and generate the reference content.
-
-## OUTPUT INSTRUCTIONS
-
-After exploring, output your complete reference wrapped in XML tags like this:
-
-\`\`\`
-<reference_output>
-(your complete markdown reference here)
-</reference_output>
-\`\`\`
-
-REQUIREMENTS:
-- Start with a level-1 heading with the actual library name (e.g., "# TanStack Query")
-- Include sections: Quick References (table), When to Use (bullets), Installation, Best Practices, Common Patterns (with code), API Quick Reference (table)
-- Minimum 2000 characters of actual content - short or placeholder content will be rejected
-- Fill in real information from your exploration - do not use placeholder text like "{Library Name}"
-- No YAML frontmatter - start directly with the markdown heading
-- Output ONLY the reference inside the tags, no other text
-
-Begin exploring now.`;
-}
-/**
-* Extract the actual reference markdown content from AI response.
-* The response may include echoed prompt/system context before the actual reference.
-* Handles multiple edge cases:
-* - Model echoes the prompt template (skip template content)
-* - Model forgets to close the tag (extract to end of response)
-* - Multiple tag pairs (find the one with real content)
-*/
-function extractReferenceContent(rawResponse, onDebug) {
-	const openTag = "<reference_output>";
-	const closeTag = "</reference_output>";
-	onDebug?.(`[extract] Raw response length: ${rawResponse.length} chars`);
-	const openIndices = [];
-	const closeIndices = [];
-	let pos = 0;
-	while ((pos = rawResponse.indexOf(openTag, pos)) !== -1) {
-		openIndices.push(pos);
-		pos += 18;
-	}
-	pos = 0;
-	while ((pos = rawResponse.indexOf(closeTag, pos)) !== -1) {
-		closeIndices.push(pos);
-		pos += 19;
-	}
-	onDebug?.(`[extract] Found ${openIndices.length} open tag(s), ${closeIndices.length} close tag(s)`);
-	const cleanContent = (raw) => {
-		let content = raw.trim();
-		if (content.startsWith("```")) {
-			content = content.replace(/^```(?:markdown)?\s*\n?/, "");
-			content = content.replace(/\n?```\s*$/, "");
-		}
-		return content.trim();
-	};
-	const isTemplateContent = (content) => {
-		return content.includes("{Library Name}") || content.includes("(your complete markdown reference here)");
-	};
-	for (let i = openIndices.length - 1; i >= 0; i--) {
-		const openIdx = openIndices[i];
-		if (openIdx === void 0) continue;
-		const closeIdx = closeIndices.find((c) => c > openIdx);
-		if (closeIdx !== void 0) {
-			const content = cleanContent(rawResponse.slice(openIdx + 18, closeIdx));
-			onDebug?.(`[extract] Pair ${i}: open=${openIdx}, close=${closeIdx}, len=${content.length}`);
-			onDebug?.(`[extract] Preview: "${content.slice(0, 200)}${content.length > 200 ? "..." : ""}"`);
-			if (isTemplateContent(content)) {
-				onDebug?.(`[extract] Skipping pair ${i} - template placeholder content`);
-				continue;
-			}
-			if (content.length >= 500) {
-				onDebug?.(`[extract] Using pair ${i} - valid content`);
-				validateReferenceContent(content);
-				return content;
-			}
-			onDebug?.(`[extract] Pair ${i} too short (${content.length} chars)`);
-		}
-	}
-	const lastOpenIdx = openIndices[openIndices.length - 1];
-	if (lastOpenIdx !== void 0) {
-		if (!closeIndices.some((c) => c > lastOpenIdx)) {
-			onDebug?.(`[extract] Last open tag at ${lastOpenIdx} is unclosed - extracting to end`);
-			const content = cleanContent(rawResponse.slice(lastOpenIdx + 18));
-			onDebug?.(`[extract] Unclosed content: ${content.length} chars`);
-			onDebug?.(`[extract] Preview: "${content.slice(0, 200)}${content.length > 200 ? "..." : ""}"`);
-			if (!isTemplateContent(content) && content.length >= 500) {
-				onDebug?.(`[extract] Using unclosed content - valid`);
-				validateReferenceContent(content);
-				return content;
-			}
-		}
-	}
-	onDebug?.(`[extract] No valid content found`);
-	onDebug?.(`[extract] Response tail: "${rawResponse.slice(-300)}"`);
-	throw new Error("Failed to extract reference content: no valid <reference_output> tags found. The AI may have failed to follow the output format or produced placeholder content.");
-}
-/**
-* Validate extracted reference content has minimum required structure.
-* Throws if content is invalid.
-*/
-function validateReferenceContent(content) {
-	const foundPlaceholders = [
-		"{Library Name}",
-		"{Full overview paragraph}",
-		"{Table with 3-5 key files}",
-		"{3+ bullet points}",
-		"{Install commands}",
-		"{3+ numbered items}",
-		"{2+ code examples",
-		"{Table of key exports}",
-		"{Additional sections"
-	].filter((p) => content.includes(p));
-	if (foundPlaceholders.length > 0) throw new Error(`Invalid reference content: contains template placeholders (${foundPlaceholders.slice(0, 3).join(", ")}). The AI echoed the format instead of generating actual content.`);
-	if (content.length < 500) throw new Error(`Invalid reference content: too short (${content.length} chars, minimum 500). The AI may have produced placeholder or incomplete content.`);
-	if (!content.startsWith("#")) throw new Error("Invalid reference content: must start with markdown heading. Content must begin with '# Library Name' (no YAML frontmatter).");
-}
-/**
-* Generate a reference markdown file for a repository using AI.
-*
-* Opens an OpenCode session and instructs the AI agent to explore the codebase
-* using Read, Grep, and Glob tools, then produce a comprehensive reference.
-*
-* @param repoPath - Path to the repository to analyze
-* @param repoName - Qualified name of the repo (e.g., "tanstack/query" or "my-local-repo")
-* @param options - Generation options (provider, model, callbacks)
-* @returns The generated reference content and commit SHA
-*/
-async function generateReferenceWithAI(repoPath, repoName, options = {}) {
-	const { provider, model, onDebug, onStream } = options;
-	const [configProvider, configModel] = loadConfig().defaultModel?.split("/") ?? [];
-	const aiProvider = provider ?? configProvider;
-	const aiModel = model ?? configModel;
-	onDebug?.(`Starting AI reference generation for ${repoName}`);
-	onDebug?.(`Repo path: ${repoPath}`);
-	onDebug?.(`Provider: ${aiProvider ?? "default"}, Model: ${aiModel ?? "default"}`);
-	const commitSha = getCommitSha(repoPath);
-	onDebug?.(`Commit SHA: ${commitSha}`);
-	const referenceName = toReferenceName(repoName);
-	onDebug?.(`Reference name: ${referenceName}`);
-	const result = await streamPrompt({
-		prompt: createReferenceGenerationPrompt(referenceName),
-		cwd: repoPath,
-		provider: aiProvider,
-		model: aiModel,
-		onDebug,
-		onStream
-	});
-	onDebug?.(`Generation complete (${result.durationMs}ms, ${result.text.length} chars)`);
-	const referenceContent = extractReferenceContent(result.text, onDebug);
-	onDebug?.(`Extracted reference content (${referenceContent.length} chars)`);
-	return {
-		referenceContent,
-		commitSha
-	};
-}
-/**
-* Ensure a symlink exists, removing any existing file/directory at the path
-*/
-function ensureSymlink(target, linkPath) {
-	try {
-		const stat = lstatSync(linkPath);
-		if (stat.isSymbolicLink()) unlinkSync(linkPath);
-		else if (stat.isDirectory()) rmSync(linkPath, { recursive: true });
-		else unlinkSync(linkPath);
-	} catch {}
-	mkdirSync(join(linkPath, ".."), { recursive: true });
-	symlinkSync(target, linkPath, "dir");
-}
-/**
-* Static template for the global SKILL.md file.
-* This is the single routing skill that all agents see.
-*/
-const GLOBAL_SKILL_TEMPLATE = `---
-name: offworld
-description: Routes queries to Offworld reference files. Find and read per-repo references for dependency knowledge.
-allowed-tools: Bash(ow:*) Read
----
-
-# Offworld Reference Router
-
-Use \`ow\` to locate and read Offworld reference files for dependencies.
-
-## What This Does
-
-- Finds references for libraries and repos
-- Returns paths for reference files and local clones
-- Helps you read the right context fast
-
-## When to Use
-
-- You need docs or patterns for a dependency
-- You want the verified reference instead of web search
-- You are about to work inside a repo clone
-
-## Prerequisites
-
-Check that the CLI is available:
-
-\`\`\`bash
-ow --version
-\`\`\`
-
-If \`ow\` is not available, install it:
-
-\`\`\`bash
-curl -fsSL https://offworld.sh/install | bash
-\`\`\`
-
-## Setup
-
-Initialize Offworld once per machine:
-
-\`\`\`bash
-ow init
-\`\`\`
-
-For a specific project, build a project map:
-
-\`\`\`bash
-ow project init
-\`\`\`
-
-## Usage
-
-**Find a reference:**
-\`\`\`bash
-ow map search <term>     # search by name or keyword
-ow map show <repo>       # get info for specific repo
-\`\`\`
-
-**Get paths for tools:**
-\`\`\`bash
-ow map show <repo> --ref   # reference file path (use with Read)
-ow map show <repo> --path  # clone directory path
-\`\`\`
-
-**Example workflow:**
-\`\`\`bash
-# 1. Find the repo
-ow map search zod
-
-# 2. Get reference path
-ow map show colinhacks/zod --ref
-# Output: /Users/.../.local/share/offworld/skill/offworld/references/colinhacks-zod.md
-
-# 3. Read the reference with the path from step 2
-\`\`\`
-
-## If Reference Not Found
-
-\`\`\`bash
-ow pull <owner/repo>    # clone + generate reference
-ow project init         # scan project deps, install references
-\`\`\`
-
-## Notes
-
-- Project map (\`.offworld/map.json\`) takes precedence over global map when present
-- Reference files are markdown with API docs, patterns, best practices
-- Clone paths useful for exploring source code after reading reference
-
-## Additional Resources
-
-- Docs: https://offworld.sh/cli
-`;
-/**
-* Ensures the global SKILL.md exists and symlinks the offworld/ directory to all agent skill directories.
-*
-* Creates:
-* - ~/.local/share/offworld/skill/offworld/SKILL.md (static routing template)
-* - ~/.local/share/offworld/skill/offworld/assets/ (for map.json)
-* - ~/.local/share/offworld/skill/offworld/references/ (for reference files)
-* - Symlinks entire offworld/ directory to each agent's skill directory
-*/
-function installGlobalSkill() {
-	const config = loadConfig();
-	mkdirSync(Paths.offworldSkillDir, { recursive: true });
-	mkdirSync(Paths.offworldAssetsDir, { recursive: true });
-	mkdirSync(Paths.offworldReferencesDir, { recursive: true });
-	const skillPath = join(Paths.offworldSkillDir, "SKILL.md");
-	if (!existsSync(skillPath)) writeFileSync(skillPath, GLOBAL_SKILL_TEMPLATE, "utf-8");
-	const configuredAgents = config.agents ?? [];
-	for (const agentName of configuredAgents) {
-		const agentConfig = agents[agentName];
-		if (agentConfig) {
-			const agentSkillDir = expandTilde(join(agentConfig.globalSkillsDir, "offworld"));
-			ensureSymlink(Paths.offworldSkillDir, agentSkillDir);
-		}
-	}
-}
-/**
-* Install a reference file for a specific repository.
-*
-* Creates:
-* - ~/.local/share/offworld/skill/offworld/references/{owner-repo}.md
-* - ~/.local/share/offworld/meta/{owner-repo}/meta.json
-* - Updates global map with reference info
-*
-* @param qualifiedName - Qualified key for map storage (e.g., "github.com:owner/repo" or "local:name")
-* @param fullName - Full repo name for file naming (e.g., "owner/repo")
-* @param localPath - Absolute path to the cloned repository
-* @param referenceContent - The generated reference markdown content
-* @param meta - Metadata about the generation (referenceUpdatedAt, commitSha, version)
-* @param keywords - Optional array of keywords for search/routing
-*/
-function installReference(qualifiedName, fullName, localPath, referenceContent, meta, keywords) {
-	installGlobalSkill();
-	const referenceFileName = toReferenceFileName(fullName);
-	const metaDirName = toMetaDirName(fullName);
-	const referencePath = join(Paths.offworldReferencesDir, referenceFileName);
-	mkdirSync(Paths.offworldReferencesDir, { recursive: true });
-	writeFileSync(referencePath, referenceContent, "utf-8");
-	const metaDir = join(Paths.metaDir, metaDirName);
-	mkdirSync(metaDir, { recursive: true });
-	const metaJson = JSON.stringify(meta, null, 2);
-	writeFileSync(join(metaDir, "meta.json"), metaJson, "utf-8");
-	const map = readGlobalMap();
-	const existingEntry = map.repos[qualifiedName];
-	const legacyProviderMap = {
-		"github.com": "github",
-		"gitlab.com": "gitlab",
-		"bitbucket.org": "bitbucket"
-	};
-	const [host] = qualifiedName.split(":");
-	const legacyProvider = host ? legacyProviderMap[host] : void 0;
-	const legacyQualifiedName = legacyProvider ? `${legacyProvider}:${fullName}` : void 0;
-	const legacyEntry = legacyQualifiedName ? map.repos[legacyQualifiedName] : void 0;
-	const references = [...existingEntry?.references ?? [], ...legacyEntry?.references ?? []];
-	if (!references.includes(referenceFileName)) references.push(referenceFileName);
-	const derivedKeywords = keywords ?? deriveKeywords(fullName, localPath, referenceContent);
-	const keywordsSet = new Set([
-		...existingEntry?.keywords ?? [],
-		...legacyEntry?.keywords ?? [],
-		...derivedKeywords
-	]);
-	map.repos[qualifiedName] = {
-		localPath,
-		references,
-		primary: referenceFileName,
-		keywords: Array.from(keywordsSet),
-		updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-	};
-	if (legacyQualifiedName && legacyQualifiedName in map.repos) delete map.repos[legacyQualifiedName];
-	writeGlobalMap(map);
-}
-
-//#endregion
-//#region src/manifest.ts
-/**
-* Dependency manifest parsing for multiple package ecosystems
-*/
-const DEFAULT_IGNORED_DIRS = new Set([
-	".git",
-	".offworld",
-	".turbo",
-	"build",
-	"dist",
-	"node_modules",
-	"out"
-]);
-/**
-* Detects the manifest type in a directory
-*/
-function detectManifestType(dir) {
-	if (existsSync(join(dir, "package.json"))) return "npm";
-	if (existsSync(join(dir, "pyproject.toml"))) return "python";
-	if (existsSync(join(dir, "Cargo.toml"))) return "rust";
-	if (existsSync(join(dir, "go.mod"))) return "go";
-	if (existsSync(join(dir, "requirements.txt"))) return "python";
-	return "unknown";
-}
-/**
-* Parses dependencies from manifest files
-*/
-function parseDependencies(dir) {
-	switch (detectManifestType(dir)) {
-		case "npm": return parseNpmDependencies(dir);
-		case "python": return existsSync(join(dir, "pyproject.toml")) ? parsePyprojectToml(join(dir, "pyproject.toml")) : parseRequirementsTxt(join(dir, "requirements.txt"));
-		case "rust": return parseCargoToml(join(dir, "Cargo.toml"));
-		case "go": return parseGoMod(join(dir, "go.mod"));
-		default: return [];
-	}
-}
-function parseNpmDependencies(dir) {
-	return mergeDependencies(parsePackageJson(join(dir, "package.json")), parseWorkspaceDependencies(dir)).sort((a, b) => a.name.localeCompare(b.name));
-}
-function parseWorkspaceDependencies(dir) {
-	const workspacePatterns = getWorkspacePatterns(dir);
-	if (workspacePatterns.length === 0) return [];
-	const packageJsonPaths = resolveWorkspacePackageJsonPaths(dir, workspacePatterns);
-	const deps = [];
-	for (const path of packageJsonPaths) deps.push(...parsePackageJson(path));
-	return mergeDependencies([], deps);
-}
-function getWorkspacePatterns(dir) {
-	const patterns = /* @__PURE__ */ new Set();
-	const packageJsonPath = join(dir, "package.json");
-	if (existsSync(packageJsonPath)) {
-		const workspaces = readJson(packageJsonPath)?.workspaces;
-		if (Array.isArray(workspaces)) {
-			for (const pattern of workspaces) if (typeof pattern === "string") patterns.add(pattern);
-		} else if (workspaces && typeof workspaces === "object") {
-			const packagesField = workspaces.packages;
-			if (Array.isArray(packagesField)) {
-				for (const pattern of packagesField) if (typeof pattern === "string") patterns.add(pattern);
-			}
-		}
-	}
-	const pnpmWorkspacePath = existsSync(join(dir, "pnpm-workspace.yaml")) ? join(dir, "pnpm-workspace.yaml") : existsSync(join(dir, "pnpm-workspace.yml")) ? join(dir, "pnpm-workspace.yml") : null;
-	if (pnpmWorkspacePath) for (const pattern of parsePnpmWorkspacePackages(pnpmWorkspacePath)) patterns.add(pattern);
-	return Array.from(patterns);
-}
-function resolveWorkspacePackageJsonPaths(dir, patterns) {
-	const includePatterns = patterns.filter((pattern) => !pattern.startsWith("!"));
-	const excludePatterns = patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1));
-	if (includePatterns.length === 0) return [];
-	const includeRegexes = includePatterns.map(patternToRegex);
-	const excludeRegexes = excludePatterns.map(patternToRegex);
-	const matches = [];
-	const directories = walkDirectories(dir);
-	for (const relativePath of directories) {
-		if (!includeRegexes.some((regex) => regex.test(relativePath))) continue;
-		if (excludeRegexes.some((regex) => regex.test(relativePath))) continue;
-		const packageJsonPath = join(dir, relativePath, "package.json");
-		if (existsSync(packageJsonPath)) matches.push(packageJsonPath);
-	}
-	return Array.from(new Set(matches));
-}
-function walkDirectories(root) {
-	const results = [];
-	const stack = [""];
-	while (stack.length > 0) {
-		const relativePath = stack.pop();
-		const currentPath = relativePath ? join(root, relativePath) : root;
-		let entries;
-		try {
-			entries = readdirSync(currentPath, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const entry of entries) {
-			if (!entry.isDirectory()) continue;
-			if (DEFAULT_IGNORED_DIRS.has(entry.name)) continue;
-			const nextRelative = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-			results.push(nextRelative);
-			stack.push(nextRelative);
-		}
-	}
-	return results;
-}
-function patternToRegex(pattern) {
-	let normalized = pattern.trim().replace(/\\/g, "/");
-	if (normalized.startsWith("./")) normalized = normalized.slice(2);
-	if (normalized.endsWith("/")) normalized = normalized.slice(0, -1);
-	const withGlob = normalized.replace(/[.+^${}()|[\]\\*]/g, "\\$&").replace(/\\\*\\\*/g, ".*").replace(/\\\*/g, "[^/]+");
-	return new RegExp(`^${withGlob}$`);
-}
-function parsePnpmWorkspacePackages(path) {
-	try {
-		const lines = readFileSync(path, "utf-8").split("\n");
-		const patterns = [];
-		let inPackages = false;
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (!trimmed || trimmed.startsWith("#")) continue;
-			if (/^packages\s*:/.test(trimmed)) {
-				inPackages = true;
-				continue;
-			}
-			if (!inPackages) continue;
-			const entryMatch = trimmed.match(/^-\s*(.+)$/);
-			if (entryMatch?.[1]) {
-				const value = entryMatch[1].trim().replace(/^['"]|['"]$/g, "");
-				if (value) patterns.push(value);
-				continue;
-			}
-			if (!line.startsWith(" ") && !line.startsWith("	")) break;
-		}
-		return patterns;
-	} catch {
-		return [];
-	}
-}
-function readJson(path) {
-	try {
-		const content = readFileSync(path, "utf-8");
-		return JSON.parse(content);
-	} catch {
-		return null;
-	}
-}
-function mergeDependencies(base, incoming) {
-	const map = /* @__PURE__ */ new Map();
-	for (const dep of [...base, ...incoming]) {
-		const existing = map.get(dep.name);
-		if (!existing) {
-			map.set(dep.name, { ...dep });
-			continue;
-		}
-		const dev = existing.dev && dep.dev;
-		const version = existing.version ?? dep.version;
-		map.set(dep.name, {
-			name: dep.name,
-			version,
-			dev
-		});
-	}
-	return Array.from(map.values());
-}
-/**
-* Parse package.json dependencies
-*/
-function parsePackageJson(path) {
-	try {
-		const content = readFileSync(path, "utf-8");
-		const pkg = JSON.parse(content);
-		const deps = [];
-		if (pkg.dependencies && typeof pkg.dependencies === "object") for (const [name, version] of Object.entries(pkg.dependencies)) deps.push({
-			name,
-			version,
-			dev: false
-		});
-		if (pkg.devDependencies && typeof pkg.devDependencies === "object") for (const [name, version] of Object.entries(pkg.devDependencies)) deps.push({
-			name,
-			version,
-			dev: true
-		});
-		if (pkg.peerDependencies && typeof pkg.peerDependencies === "object") for (const [name, version] of Object.entries(pkg.peerDependencies)) deps.push({
-			name,
-			version,
-			dev: false
-		});
-		if (pkg.optionalDependencies && typeof pkg.optionalDependencies === "object") for (const [name, version] of Object.entries(pkg.optionalDependencies)) deps.push({
-			name,
-			version,
-			dev: false
-		});
-		return deps;
-	} catch {
-		return [];
-	}
-}
-/**
-* Parse pyproject.toml dependencies
-*/
-function parsePyprojectToml(path) {
-	try {
-		const content = readFileSync(path, "utf-8");
-		const deps = [];
-		const depsSection = content.match(/\[project\.dependencies\]([\s\S]*?)(?=\[|$)/);
-		if (!depsSection?.[1]) return [];
-		const lines = depsSection[1].split("\n");
-		for (const line of lines) {
-			const match = line.match(/["']([a-zA-Z0-9_-]+)(?:[>=<~!]+([^"']+))?["']/);
-			if (match?.[1]) deps.push({
-				name: match[1],
-				version: match[2]?.trim(),
-				dev: false
-			});
-		}
-		return deps;
-	} catch {
-		return [];
-	}
-}
-/**
-* Parse Cargo.toml dependencies
-*/
-function parseCargoToml(path) {
-	try {
-		const content = readFileSync(path, "utf-8");
-		const deps = [];
-		const depsSection = content.match(/\[dependencies\]([\s\S]*?)(?=\[|$)/);
-		if (!depsSection?.[1]) return [];
-		const lines = depsSection[1].split("\n");
-		for (const line of lines) {
-			const simpleMatch = line.match(/^([a-zA-Z0-9_-]+)\s*=\s*"([^"]+)"/);
-			const tableMatch = line.match(/^([a-zA-Z0-9_-]+)\s*=\s*{.*version\s*=\s*"([^"]+)"/);
-			if (simpleMatch?.[1] && simpleMatch[2]) deps.push({
-				name: simpleMatch[1],
-				version: simpleMatch[2],
-				dev: false
-			});
-			else if (tableMatch?.[1] && tableMatch[2]) deps.push({
-				name: tableMatch[1],
-				version: tableMatch[2],
-				dev: false
-			});
-		}
-		return deps;
-	} catch {
-		return [];
-	}
-}
-/**
-* Parse go.mod dependencies
-*/
-function parseGoMod(path) {
-	try {
-		const content = readFileSync(path, "utf-8");
-		const deps = [];
-		const requireSection = content.match(/require\s*\(([\s\S]*?)\)/);
-		if (!requireSection?.[1]) {
-			const singleRequire = content.match(/require\s+([^\s]+)\s+([^\s]+)/);
-			if (singleRequire?.[1] && singleRequire[2]) deps.push({
-				name: singleRequire[1],
-				version: singleRequire[2],
-				dev: false
-			});
-			return deps;
-		}
-		const lines = requireSection[1].split("\n");
-		for (const line of lines) {
-			const match = line.match(/^\s*([^\s]+)\s+([^\s]+)/);
-			if (match?.[1] && match[2]) deps.push({
-				name: match[1],
-				version: match[2],
-				dev: false
-			});
-		}
-		return deps;
-	} catch {
-		return [];
-	}
-}
-/**
-* Parse requirements.txt dependencies
-*/
-function parseRequirementsTxt(path) {
-	try {
-		const content = readFileSync(path, "utf-8");
-		const deps = [];
-		const lines = content.split("\n");
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (!trimmed || trimmed.startsWith("#")) continue;
-			const match = trimmed.match(/^([a-zA-Z0-9_-]+)(?:[>=<~!]+(.+))?/);
-			if (match?.[1]) deps.push({
-				name: match[1],
-				version: match[2]?.trim(),
-				dev: false
-			});
-		}
-		return deps;
-	} catch {
-		return [];
-	}
-}
-
-//#endregion
-//#region src/dep-mappings.ts
-/**
-* Dependency name to GitHub repo resolution:
-* 1. Query npm registry for repository.url
-* 2. Fall back to FALLBACK_MAPPINGS for packages missing repository field
-* 3. Return unknown (caller handles)
-*/
-/**
-* Fallback mappings for packages where npm registry doesn't have repository.url.
-* Only add packages here that genuinely don't have the field set.
-*/
-const FALLBACK_MAPPINGS = {
-	"@convex-dev/react-query": "get-convex/convex-react-query",
-	"@opencode-ai/sdk": "anomalyco/opencode-sdk-js"
-};
-/**
-* Parse GitHub repo from various git URL formats.
-* Handles:
-* - git+https://github.com/owner/repo.git
-* - https://github.com/owner/repo
-* - git://github.com/owner/repo.git
-* - github:owner/repo
-*/
-function parseGitHubUrl(url) {
-	for (const pattern of [/github\.com[/:]([\w-]+)\/([\w.-]+?)(?:\.git)?$/, /^github:([\w-]+)\/([\w.-]+)$/]) {
-		const match = url.match(pattern);
-		if (match) return `${match[1]}/${match[2]}`;
-	}
-	return null;
-}
-/**
-* Fallback to npm registry to extract repository.url.
-* Returns null if package not found, no repo field, or not a GitHub repo.
-*/
-async function resolveFromNpm(packageName) {
-	try {
-		const res = await fetch(`https://registry.npmjs.org/${packageName}`);
-		if (!res.ok) return null;
-		const json = await res.json();
-		const result = NpmPackageResponseSchema.safeParse(json);
-		if (!result.success) return null;
-		const repoUrl = result.data.repository?.url;
-		if (!repoUrl) return null;
-		return parseGitHubUrl(repoUrl);
-	} catch {
-		return null;
-	}
-}
-/**
-* Resolution order:
-* 1. Query npm registry for repository.url
-* 2. Check FALLBACK_MAPPINGS for packages missing repository field
-* 3. Return unknown
-*/
-async function resolveDependencyRepo(dep) {
-	const npmRepo = await resolveFromNpm(dep);
-	if (npmRepo) return {
-		dep,
-		repo: npmRepo,
-		source: "npm"
-	};
-	if (dep in FALLBACK_MAPPINGS) return {
-		dep,
-		repo: FALLBACK_MAPPINGS[dep] ?? null,
-		source: "fallback"
-	};
-	return {
-		dep,
-		repo: null,
-		source: "unknown"
-	};
-}
-
-//#endregion
-//#region src/reference-matcher.ts
-/**
-* Reference matching utilities for dependency resolution
-*
-* Maps dependencies to their reference status (installed, remote, generate, unknown)
-*/
-/**
-* Check if a reference is installed locally.
-* A reference is considered installed if {owner-repo}.md exists in offworld/references/.
-*
-* @param repo - Repo name in owner/repo format
-* @returns true if reference is installed locally
-*/
-function isReferenceInstalled(repo) {
-	const referenceFileName = toReferenceFileName(repo);
-	return existsSync(join(Paths.offworldReferencesDir, referenceFileName));
-}
-/**
-* Match dependencies to their reference availability status.
-*
-* Status logic:
-* - installed: {owner-repo}.md exists in offworld/references/
-* - remote: Reference exists on offworld.sh (quick pull)
-* - generate: Has valid GitHub repo but needs AI generation (slow, uses tokens)
-* - unknown: No GitHub repo found
-*
-* @param resolvedDeps - Array of resolved dependencies with repo info
-* @returns Array of reference matches with status
-*/
-function matchDependenciesToReferences(resolvedDeps) {
-	return resolvedDeps.map((dep) => {
-		if (!dep.repo) return {
-			dep: dep.dep,
-			repo: null,
-			status: "unknown",
-			source: dep.source
-		};
-		if (isReferenceInstalled(dep.repo)) return {
-			dep: dep.dep,
-			repo: dep.repo,
-			status: "installed",
-			source: dep.source
-		};
-		return {
-			dep: dep.dep,
-			repo: dep.repo,
-			status: "generate",
-			source: dep.source
-		};
-	});
-}
-/**
-* Match dependencies to their reference availability status with remote check.
-* This is async because it checks the remote server for each dependency.
-*
-* Status logic:
-* - installed: {owner-repo}.md exists in offworld/references/
-* - remote: Reference exists on offworld.sh (quick pull)
-* - generate: Has valid GitHub repo but needs AI generation (slow, uses tokens)
-* - unknown: No GitHub repo found
-*
-* @param resolvedDeps - Array of resolved dependencies with repo info
-* @returns Promise of array of reference matches with status
-*/
-async function matchDependenciesToReferencesWithRemoteCheck(resolvedDeps) {
-	return await Promise.all(resolvedDeps.map(async (dep) => {
-		if (!dep.repo) return {
-			dep: dep.dep,
-			repo: null,
-			status: "unknown",
-			source: dep.source
-		};
-		if (isReferenceInstalled(dep.repo)) return {
-			dep: dep.dep,
-			repo: dep.repo,
-			status: "installed",
-			source: dep.source
-		};
-		try {
-			if ((await checkRemote(dep.repo)).exists) return {
-				dep: dep.dep,
-				repo: dep.repo,
-				status: "remote",
-				source: dep.source
-			};
-		} catch {}
-		return {
-			dep: dep.dep,
-			repo: dep.repo,
-			status: "generate",
-			source: dep.source
-		};
-	}));
-}
-
-//#endregion
-//#region src/agents-md.ts
-/**
-* AGENTS.md manipulation utilities
-*
-* Manages updating project AGENTS.md and agent-specific files with reference information.
-*/
-/**
-* Generate markdown table for project references section.
-*
-* @param references - Array of installed references
-* @returns Markdown string with table
-*/
-function generateReferencesTable(references) {
-	const lines = [
-		"## Project References",
-		"",
-		"References installed for this project's dependencies:",
-		"",
-		"| Dependency | Reference | Path |",
-		"| --- | --- | --- |"
-	];
-	for (const reference of references) lines.push(`| ${reference.dependency} | ${reference.reference} | ${reference.path} |`);
-	lines.push("");
-	lines.push("To update references: `ow pull <dependency>`");
-	lines.push("To regenerate all: `ow project init --all --generate`");
-	lines.push("");
-	return lines.join("\n");
-}
-/**
-* Update or append Project References section in a markdown file.
-* If the section exists, replaces its content. Otherwise, appends to end.
-*
-* @param filePath - Path to markdown file
-* @param references - Array of installed references
-*/
-function appendReferencesSection(filePath, references) {
-	const content = existsSync(filePath) ? readFileSync(filePath, "utf-8") : "";
-	const referencesMarkdown = generateReferencesTable(references);
-	const sectionRegex = /^## Project References\n(?:.*\n)*?(?=^## |$)/m;
-	const match = content.match(sectionRegex);
-	let updatedContent;
-	if (match) updatedContent = content.replace(sectionRegex, referencesMarkdown);
-	else updatedContent = content.trim() + "\n\n" + referencesMarkdown;
-	writeFileSync(filePath, updatedContent, "utf-8");
-}
-/**
-* Update AGENTS.md and agent-specific files with project references.
-* Creates files if they don't exist.
-*
-* @param projectRoot - Project root directory
-* @param references - Array of installed references to document
-*/
-function updateAgentFiles(projectRoot, references) {
-	const agentsMdPath = join(projectRoot, "AGENTS.md");
-	const claudeMdPath = join(projectRoot, "CLAUDE.md");
-	appendReferencesSection(agentsMdPath, references);
-	if (existsSync(claudeMdPath)) appendReferencesSection(claudeMdPath, references);
-}
-
-//#endregion
-//#region src/repo-manager.ts
-function getDirSize(dirPath) {
-	if (!existsSync(dirPath)) return 0;
-	let size = 0;
-	try {
-		const entries = readdirSync(dirPath, { withFileTypes: true });
-		for (const entry of entries) {
-			const fullPath = join(dirPath, entry.name);
-			if (entry.isDirectory()) size += getDirSize(fullPath);
-			else if (entry.isFile()) try {
-				size += statSync(fullPath).size;
-			} catch {}
-		}
-	} catch {}
-	return size;
-}
-function getLastAccessTime(dirPath) {
-	if (!existsSync(dirPath)) return null;
-	let latestTime = null;
-	try {
-		latestTime = statSync(dirPath).mtime;
-		const fetchHead = join(dirPath, ".git", "FETCH_HEAD");
-		if (existsSync(fetchHead)) {
-			const fetchStat = statSync(fetchHead);
-			if (!latestTime || fetchStat.mtime > latestTime) latestTime = fetchStat.mtime;
-		}
-	} catch {}
-	return latestTime;
-}
-function matchesPattern(name, pattern) {
-	if (!pattern || pattern === "*") return true;
-	return new RegExp("^" + pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i").test(name);
-}
-const yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
-async function getRepoStatus(options = {}) {
-	const { onProgress } = options;
-	const map = readGlobalMap();
-	const qualifiedNames = Object.keys(map.repos);
-	const total = qualifiedNames.length;
-	let withReference = 0;
-	let missing = 0;
-	let diskBytes = 0;
-	for (let i = 0; i < qualifiedNames.length; i++) {
-		const qualifiedName = qualifiedNames[i];
-		const entry = map.repos[qualifiedName];
-		onProgress?.(i + 1, total, qualifiedName);
-		await yieldToEventLoop();
-		if (!existsSync(entry.localPath)) {
-			missing++;
-			continue;
-		}
-		if (entry.references.length > 0) withReference++;
-		diskBytes += getDirSize(entry.localPath);
-	}
-	return {
-		total,
-		withReference,
-		missing,
-		diskBytes
-	};
-}
-async function updateAllRepos(options = {}) {
-	const { pattern, dryRun = false, unshallow = false, onProgress } = options;
-	const map = readGlobalMap();
-	const qualifiedNames = Object.keys(map.repos);
-	const updated = [];
-	const skipped = [];
-	const unshallowed = [];
-	const errors = [];
-	for (const qualifiedName of qualifiedNames) {
-		const entry = map.repos[qualifiedName];
-		if (pattern && !matchesPattern(qualifiedName, pattern)) continue;
-		if (!existsSync(entry.localPath)) {
-			skipped.push(qualifiedName);
-			onProgress?.(qualifiedName, "skipped", "missing on disk");
-			continue;
-		}
-		if (dryRun) {
-			updated.push(qualifiedName);
-			onProgress?.(qualifiedName, "updated", "would update");
-			continue;
-		}
-		onProgress?.(qualifiedName, "updating");
-		try {
-			const result = await updateRepo(qualifiedName, { unshallow });
-			if (result.unshallowed) {
-				unshallowed.push(qualifiedName);
-				onProgress?.(qualifiedName, "unshallowed", "converted to full clone");
-			}
-			if (result.updated) {
-				updated.push(qualifiedName);
-				onProgress?.(qualifiedName, "updated", `${result.previousSha.slice(0, 7)} → ${result.currentSha.slice(0, 7)}`);
-			} else if (!result.unshallowed) {
-				skipped.push(qualifiedName);
-				onProgress?.(qualifiedName, "skipped", "already up to date");
-			}
-		} catch (err) {
-			const message = err instanceof GitError ? err.message : String(err);
-			errors.push({
-				repo: qualifiedName,
-				error: message
-			});
-			onProgress?.(qualifiedName, "error", message);
-		}
-	}
-	return {
-		updated,
-		skipped,
-		unshallowed,
-		errors
-	};
-}
-async function pruneRepos(options = {}) {
-	const { dryRun = false, onProgress } = options;
-	const map = readGlobalMap();
-	const qualifiedNames = Object.keys(map.repos);
-	const removedFromIndex = [];
-	const orphanedDirs = [];
-	for (const qualifiedName of qualifiedNames) {
-		const entry = map.repos[qualifiedName];
-		await yieldToEventLoop();
-		if (!existsSync(entry.localPath)) {
-			onProgress?.(qualifiedName, "missing on disk");
-			removedFromIndex.push(qualifiedName);
-			if (!dryRun) removeGlobalMapEntry(qualifiedName);
-		}
-	}
-	const repoRoot = getRepoRoot(loadConfig());
-	if (existsSync(repoRoot)) {
-		const indexedPaths = new Set(Object.values(map.repos).map((r) => r.localPath));
-		try {
-			const providers = readdirSync(repoRoot, { withFileTypes: true });
-			for (const provider of providers) {
-				if (!provider.isDirectory()) continue;
-				const providerPath = join(repoRoot, provider.name);
-				const owners = readdirSync(providerPath, { withFileTypes: true });
-				for (const owner of owners) {
-					if (!owner.isDirectory()) continue;
-					const ownerPath = join(providerPath, owner.name);
-					const repoNames = readdirSync(ownerPath, { withFileTypes: true });
-					for (const repoName of repoNames) {
-						await yieldToEventLoop();
-						if (!repoName.isDirectory()) continue;
-						const repoPath = join(ownerPath, repoName.name);
-						if (!existsSync(join(repoPath, ".git"))) continue;
-						if (!indexedPaths.has(repoPath)) {
-							const fullName = `${owner.name}/${repoName.name}`;
-							onProgress?.(fullName, "not in map");
-							orphanedDirs.push(repoPath);
-						}
-					}
-				}
-			}
-		} catch {}
-	}
-	return {
-		removedFromIndex,
-		orphanedDirs
-	};
-}
-async function gcRepos(options = {}) {
-	const { olderThanDays, withoutReference = false, dryRun = false, onProgress } = options;
-	const map = readGlobalMap();
-	const qualifiedNames = Object.keys(map.repos);
-	const removed = [];
-	let freedBytes = 0;
-	const now = /* @__PURE__ */ new Date();
-	const cutoffDate = olderThanDays ? /* @__PURE__ */ new Date(now.getTime() - olderThanDays * 24 * 60 * 60 * 1e3) : null;
-	for (const qualifiedName of qualifiedNames) {
-		const entry = map.repos[qualifiedName];
-		await yieldToEventLoop();
-		if (!existsSync(entry.localPath)) continue;
-		let shouldRemove = false;
-		let reason = "";
-		if (cutoffDate) {
-			const lastAccess = getLastAccessTime(entry.localPath);
-			if (lastAccess && lastAccess < cutoffDate) {
-				shouldRemove = true;
-				reason = `not accessed in ${olderThanDays}+ days`;
-			}
-		}
-		if (withoutReference && entry.references.length === 0) {
-			shouldRemove = true;
-			reason = reason ? `${reason}, no reference` : "no reference";
-		}
-		if (!shouldRemove) continue;
-		const sizeBytes = getDirSize(entry.localPath);
-		onProgress?.(qualifiedName, reason, sizeBytes);
-		if (!dryRun) {
-			rmSync(entry.localPath, {
-				recursive: true,
-				force: true
-			});
-			for (const refFile of entry.references) {
-				const refPath = join(Paths.offworldReferencesDir, refFile);
-				if (existsSync(refPath)) rmSync(refPath, { force: true });
-			}
-			if (entry.primary) {
-				const metaDirName = entry.primary.replace(/\.md$/, "");
-				const metaPath = join(Paths.metaDir, metaDirName);
-				if (existsSync(metaPath)) rmSync(metaPath, {
-					recursive: true,
-					force: true
-				});
-			}
-			removeGlobalMapEntry(qualifiedName);
-		}
-		removed.push({
-			repo: qualifiedName,
-			reason,
-			sizeBytes
-		});
-		freedBytes += sizeBytes;
-	}
-	return {
-		removed,
-		freedBytes
-	};
-}
-async function discoverRepos(options = {}) {
-	const { dryRun = false, onProgress } = options;
-	const config = loadConfig();
-	const repoRoot = options.repoRoot ?? getRepoRoot(config);
-	const discovered = [];
-	let alreadyIndexed = 0;
-	if (!existsSync(repoRoot)) return {
-		discovered,
-		alreadyIndexed
-	};
-	const map = readGlobalMap();
-	const indexedPaths = new Set(Object.values(map.repos).map((r) => r.localPath));
-	try {
-		const providers = readdirSync(repoRoot, { withFileTypes: true });
-		for (const provider of providers) {
-			if (!provider.isDirectory()) continue;
-			const providerPath = join(repoRoot, provider.name);
-			const providerHost = {
-				github: "github.com",
-				gitlab: "gitlab.com",
-				bitbucket: "bitbucket.org"
-			}[provider.name] ?? provider.name;
-			const owners = readdirSync(providerPath, { withFileTypes: true });
-			for (const owner of owners) {
-				if (!owner.isDirectory()) continue;
-				const ownerPath = join(providerPath, owner.name);
-				const repoNames = readdirSync(ownerPath, { withFileTypes: true });
-				for (const repoName of repoNames) {
-					await yieldToEventLoop();
-					if (!repoName.isDirectory()) continue;
-					const repoPath = join(ownerPath, repoName.name);
-					if (!existsSync(join(repoPath, ".git"))) continue;
-					if (indexedPaths.has(repoPath)) {
-						alreadyIndexed++;
-						continue;
-					}
-					const fullName = `${owner.name}/${repoName.name}`;
-					const qualifiedName = `${providerHost}:${fullName}`;
-					onProgress?.(fullName, providerHost);
-					if (!dryRun) upsertGlobalMapEntry(qualifiedName, {
-						localPath: repoPath,
-						references: [],
-						primary: "",
-						keywords: [],
-						updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-					});
-					discovered.push({
-						fullName,
-						qualifiedName,
-						localPath: repoPath
-					});
-				}
-			}
-		}
-	} catch {}
-	return {
-		discovered,
-		alreadyIndexed
-	};
-}
-
-//#endregion
-//#region src/models.ts
-const MODELS_DEV_URL = "https://models.dev/api.json";
-let cachedData = null;
-let cacheTime = 0;
-const CACHE_TTL_MS = 300 * 1e3;
-/**
-* Fetch raw data from models.dev with caching
-*/
-async function fetchModelsDevData() {
-	const now = Date.now();
-	if (cachedData && now - cacheTime < CACHE_TTL_MS) return cachedData;
-	const res = await fetch(MODELS_DEV_URL, { signal: AbortSignal.timeout(1e4) });
-	if (!res.ok) throw new Error(`Failed to fetch models.dev: ${res.status} ${res.statusText}`);
-	const json = await res.json();
-	const parsed = ModelsDevDataSchema.safeParse(json);
-	if (!parsed.success) throw new Error(`Invalid models.dev response: ${parsed.error.message}`);
-	cachedData = parsed.data;
-	cacheTime = now;
-	return cachedData;
-}
-/**
-* List all available providers from models.dev
-*/
-async function listProviders() {
-	const data = await fetchModelsDevData();
-	return Object.values(data).map((p) => ({
-		id: p.id,
-		name: p.name,
-		env: p.env ?? []
-	})).sort((a, b) => a.name.localeCompare(b.name));
-}
-/**
-* Get a specific provider with all its models
-*/
-async function getProvider(providerId) {
-	const provider = (await fetchModelsDevData())[providerId];
-	if (!provider) return null;
-	return {
-		id: provider.id,
-		name: provider.name,
-		env: provider.env ?? [],
-		models: Object.values(provider.models).filter((m) => m.status !== "deprecated").map((m) => ({
-			id: m.id,
-			name: m.name,
-			reasoning: m.reasoning ?? false,
-			experimental: m.experimental,
-			status: m.status
-		})).sort((a, b) => a.name.localeCompare(b.name))
-	};
-}
-/**
-* Get all providers with their models
-*/
-async function listProvidersWithModels() {
-	const data = await fetchModelsDevData();
-	return Object.values(data).map((p) => ({
-		id: p.id,
-		name: p.name,
-		env: p.env ?? [],
-		models: Object.values(p.models).filter((m) => m.status !== "deprecated").map((m) => ({
-			id: m.id,
-			name: m.name,
-			reasoning: m.reasoning ?? false,
-			experimental: m.experimental,
-			status: m.status
-		})).sort((a, b) => a.name.localeCompare(b.name))
-	})).sort((a, b) => a.name.localeCompare(b.name));
-}
-/**
-* Validate that a provider/model combination exists
-*/
-async function validateProviderModel(providerId, modelId) {
-	const provider = await getProvider(providerId);
-	if (!provider) {
-		const providers = await listProviders();
-		return {
-			valid: false,
-			error: `Provider "${providerId}" not found. Available: ${providers.slice(0, 10).map((p) => p.id).join(", ")}${providers.length > 10 ? "..." : ""}`
-		};
-	}
-	if (!provider.models.find((m) => m.id === modelId)) return {
-		valid: false,
-		error: `Model "${modelId}" not found for provider "${providerId}". Available: ${provider.models.slice(0, 10).map((m) => m.id).join(", ")}${provider.models.length > 10 ? "..." : ""}`
-	};
-	return { valid: true };
-}
-
-//#endregion
-//#region src/installation.ts
-/**
-* Installation utilities for upgrade/uninstall commands
-*/
-const GITHUB_REPO = "oscabriel/offworld";
-const NPM_PACKAGE = "offworld";
-/**
-* Detect how offworld was installed
-*/
-function detectInstallMethod() {
-	const execPath = process.execPath;
-	if (execPath.includes(".local/bin")) return "curl";
-	const checks = [
-		{
-			name: "npm",
-			test: () => {
-				try {
-					return execSync("npm list -g --depth=0 2>/dev/null", { encoding: "utf-8" }).includes(NPM_PACKAGE);
-				} catch {
-					return false;
-				}
-			}
-		},
-		{
-			name: "pnpm",
-			test: () => {
-				try {
-					return execSync("pnpm list -g --depth=0 2>/dev/null", { encoding: "utf-8" }).includes(NPM_PACKAGE);
-				} catch {
-					return false;
-				}
-			}
-		},
-		{
-			name: "bun",
-			test: () => {
-				try {
-					return execSync("bun pm ls -g 2>/dev/null", { encoding: "utf-8" }).includes(NPM_PACKAGE);
-				} catch {
-					return false;
-				}
-			}
-		},
-		{
-			name: "brew",
-			test: () => {
-				try {
-					execSync("brew list --formula offworld 2>/dev/null", { encoding: "utf-8" });
-					return true;
-				} catch {
-					return false;
-				}
-			}
-		}
-	];
-	if (execPath.includes("npm")) {
-		if (checks.find((c) => c.name === "npm")?.test()) return "npm";
-	}
-	if (execPath.includes("pnpm")) {
-		if (checks.find((c) => c.name === "pnpm")?.test()) return "pnpm";
-	}
-	if (execPath.includes("bun")) {
-		if (checks.find((c) => c.name === "bun")?.test()) return "bun";
-	}
-	if (execPath.includes("Cellar") || execPath.includes("homebrew")) {
-		if (checks.find((c) => c.name === "brew")?.test()) return "brew";
-	}
-	for (const check of checks) if (check.test()) return check.name;
-	return "unknown";
-}
-/**
-* Get current installed version
-*/
-function getCurrentVersion() {
-	return VERSION;
-}
-/**
-* Fetch latest version from appropriate source
-*/
-async function fetchLatestVersion(method) {
-	const installMethod = method ?? detectInstallMethod();
-	try {
-		if (installMethod === "npm" || installMethod === "pnpm" || installMethod === "bun") {
-			const response = await fetch(`https://registry.npmjs.org/${NPM_PACKAGE}/latest`);
-			if (!response.ok) return null;
-			const json = await response.json();
-			const result = NpmPackageResponseSchema.safeParse(json);
-			if (!result.success) return null;
-			return result.data.version ?? null;
-		}
-		const response = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, { headers: {
-			Accept: "application/vnd.github.v3+json",
-			"User-Agent": "offworld-cli"
-		} });
-		if (!response.ok) return null;
-		const json = await response.json();
-		return (typeof json === "object" && json !== null && "tag_name" in json ? String(json.tag_name) : null)?.replace(/^v/, "") ?? null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Execute upgrade for given method
-*/
-function executeUpgrade(method, version) {
-	return new Promise((resolve, reject) => {
-		let cmd;
-		let args;
-		switch (method) {
-			case "curl":
-				cmd = "bash";
-				args = ["-c", `curl -fsSL https://offworld.sh/install | VERSION=${version} bash`];
-				break;
-			case "npm":
-				cmd = "npm";
-				args = [
-					"install",
-					"-g",
-					`${NPM_PACKAGE}@${version}`
-				];
-				break;
-			case "pnpm":
-				cmd = "pnpm";
-				args = [
-					"install",
-					"-g",
-					`${NPM_PACKAGE}@${version}`
-				];
-				break;
-			case "bun":
-				cmd = "bun";
-				args = [
-					"install",
-					"-g",
-					`${NPM_PACKAGE}@${version}`
-				];
-				break;
-			case "brew":
-				cmd = "brew";
-				args = ["upgrade", "offworld"];
-				break;
-			default:
-				reject(/* @__PURE__ */ new Error(`Cannot upgrade: unknown installation method`));
-				return;
-		}
-		const proc = spawn(cmd, args, { stdio: "inherit" });
-		proc.on("close", (code) => {
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`Upgrade failed with exit code ${code}`));
-		});
-		proc.on("error", reject);
-	});
-}
-/**
-* Execute uninstall for given method
-*/
-function executeUninstall(method) {
-	return new Promise((resolve, reject) => {
-		let cmd;
-		let args;
-		switch (method) {
-			case "curl":
-				try {
-					const binPath = join(homedir(), ".local", "bin", "ow");
-					if (existsSync(binPath)) execSync(`rm -f "${binPath}"`, { stdio: "inherit" });
-					resolve();
-				} catch (err) {
-					reject(err);
-				}
-				return;
-			case "npm":
-				cmd = "npm";
-				args = [
-					"uninstall",
-					"-g",
-					NPM_PACKAGE
-				];
-				break;
-			case "pnpm":
-				cmd = "pnpm";
-				args = [
-					"uninstall",
-					"-g",
-					NPM_PACKAGE
-				];
-				break;
-			case "bun":
-				cmd = "bun";
-				args = [
-					"remove",
-					"-g",
-					NPM_PACKAGE
-				];
-				break;
-			case "brew":
-				cmd = "brew";
-				args = ["uninstall", "offworld"];
-				break;
-			default:
-				reject(/* @__PURE__ */ new Error(`Cannot uninstall: unknown installation method`));
-				return;
-		}
-		const proc = spawn(cmd, args, { stdio: "inherit" });
-		proc.on("close", (code) => {
-			if (code === 0) resolve();
-			else reject(/* @__PURE__ */ new Error(`Uninstall failed with exit code ${code}`));
-		});
-		proc.on("error", reject);
-	});
-}
-/**
-* Get shell config files to clean
-*/
-function getShellConfigFiles() {
-	const home = homedir();
-	const configs = [];
-	for (const file of [
-		".bashrc",
-		".bash_profile",
-		".profile",
-		".zshrc",
-		".zshenv",
-		".config/fish/config.fish"
-	]) {
-		const path = join(home, file);
-		if (existsSync(path)) configs.push(path);
-	}
-	return configs;
-}
-/**
-* Clean PATH entries from shell config
-*/
-function cleanShellConfig(filePath) {
-	try {
-		const lines = readFileSync(filePath, "utf-8").split("\n");
-		const filtered = [];
-		let modified = false;
-		for (const line of lines) {
-			const trimmed = line.trim();
-			if (trimmed.includes(".local/bin") && (trimmed.startsWith("export PATH=") || trimmed.startsWith("fish_add_path"))) {
-				if (trimmed.includes("# offworld") || trimmed === "export PATH=\"$HOME/.local/bin:$PATH\"") {
-					modified = true;
-					continue;
-				}
-			}
-			filtered.push(line);
-		}
-		if (modified) writeFileSync(filePath, filtered.join("\n"), "utf-8");
-		return modified;
-	} catch {
-		return false;
-	}
-}
-
-//#endregion
-export { AuthError, AuthenticationError, CloneError, CommitExistsError, CommitNotFoundError, ConflictError, DEFAULT_IGNORE_PATTERNS, FALLBACK_MAPPINGS, GitError, GitHubError, InvalidInputError, InvalidReferenceError, LowStarsError, NetworkError, NotGitRepoError, NotLoggedInError, OpenCodeSDKError, PathNotFoundError, Paths, PrivateRepoError, PushNotAllowedError, RateLimitError, RepoExistsError, RepoNotFoundError, RepoSourceError, SyncError, RepoNotFoundError$1 as SyncRepoNotFoundError, TokenExpiredError, VERSION, agents, appendReferencesSection, canPushToWeb, checkRemote, checkRemoteByName, checkStaleness, cleanShellConfig, clearAuthData, cloneRepo, detectInstallMethod, detectInstalledAgents, detectManifestType, discoverRepos, executeUninstall, executeUpgrade, expandTilde, fetchGitHubMetadata, fetchLatestVersion, fetchRepoStars, gcRepos, generateReferenceWithAI, getAgentConfig, getAllAgentConfigs, getAuthPath, getAuthStatus, getClonedRepoPath, getCommitDistance, getCommitSha, getConfigPath, getCurrentVersion, getMapEntry, getMetaPath, getMetaRoot, getProjectMapPath, getProvider, getReferenceFileNameForSource, getReferencePath, getRepoPath, getRepoRoot, getRepoStatus, getShellConfigFiles, getToken, getTokenOrNull, installGlobalSkill, installReference, isLoggedIn, isReferenceInstalled, isRepoCloned, isShallowClone, listProviders, listProvidersWithModels, listRepos, loadAuthData, loadConfig, matchDependenciesToReferences, matchDependenciesToReferencesWithRemoteCheck, parseDependencies, parseRepoInput, pruneRepos, pullReference, pullReferenceByName, pushReference, readGlobalMap, refreshAccessToken, removeGlobalMapEntry, removeRepo, resolveDependencyRepo, resolveFromNpm, resolveRepoKey, saveAuthData, saveConfig, searchMap, streamPrompt, toMetaDirName, toReferenceFileName, toReferenceName, unshallowRepo, updateAgentFiles, updateAllRepos, updateRepo, upsertGlobalMapEntry, validateProviderModel, validatePushAllowed, writeGlobalMap, writeProjectMap };
-//# sourceMappingURL=index.mjs.map
+export { AuthError, CloneError, DEFAULT_IGNORE_PATTERNS, FALLBACK_MAPPINGS, GitError, NotGitRepoError, NotLoggedInError, PathNotFoundError, Paths, RepoExistsError, RepoNotFoundError, RepoSourceError, TokenExpiredError, VERSION, agents, clearAuthData, cloneRepo, detectInstalledAgents, detectManifestType, discoverRepos, expandTilde, gcRepos, getAgentConfig, getAllAgentConfigs, getAuthPath, getAuthStatus, getClonedRepoPath, getCommitDistance, getCommitSha, getConfigPath, getMapEntry, getMetaPath, getMetaRoot, getProjectMapPath, getProvider, getReferenceFileNameForSource, getReferencePath, getRepoPath, getRepoRoot, getRepoStatus, getToken, getTokenOrNull, installGlobalSkill, installReference, isLoggedIn, isReferenceInstalled, isRepoCloned, isShallowClone, listProviders, listProvidersWithModels, listRepos, loadAuthData, loadConfig, matchDependenciesToReferences, matchDependenciesToReferencesWithRemoteCheck, parseDependencies, parseRepoInput, pruneRepos, readGlobalMap, refreshAccessToken, removeGlobalMapEntry, removeRepo, resolveDependencyRepo, resolveFromNpm, resolveRepoKey, saveAuthData, saveConfig, searchMap, toMetaDirName, toReferenceFileName, toReferenceName, unshallowRepo, updateAllRepos, updateRepo, upsertGlobalMapEntry, validateProviderModel, writeGlobalMap, writeProjectMap };