offworld 0.3.3 → 0.3.5

package/dist/{src-CrZvPV0A.mjs → src-DAHGD773.mjs}

@@ -6,7 +6,7 @@ import { z } from "zod";
 import * as p from "@clack/prompts";
 import { NotLoggedInError, Paths, RepoExistsError, TokenExpiredError, cleanShellConfig, clearAuthData, cloneRepo, detectInstallMethod, detectInstalledAgents, discoverRepos, executeUninstall, executeUpgrade, fetchLatestVersion, gcRepos, getAllAgentConfigs, getAuthPath, getAuthStatus, getClonedRepoPath, getCommitDistance, getCommitSha, getConfigPath, getCurrentVersion, getMapEntry, getMetaPath, getMetaRoot, getProvider, getReferencePath, getRepoRoot, getRepoStatus, getShellConfigFiles, getToken, installGlobalSkill, installReference, isRepoCloned, listProviders, listRepos, loadAuthData, loadConfig, matchDependenciesToReferencesWithRemoteCheck, parseDependencies, parseRepoInput, pruneRepos, readGlobalMap, removeRepo, resolveDependencyRepo, resolveReferenceKeywords, saveAuthData, saveConfig, searchMap, toReferenceFileName, toReferenceName, updateAgentFiles, updateAllRepos, updateRepo, validateProviderModel, writeGlobalMap, writeProjectMap } from "@offworld/sdk/internal";
 import { AuthenticationError, CommitExistsError, CommitNotFoundError, GitHubError, InvalidInputError, InvalidReferenceError, LowStarsError, PrivateRepoError, RateLimitError, RepoNotFoundError, checkRemote, checkRemoteByName, pullReference, pullReferenceByName, pushReference } from "@offworld/sdk/sync";
-import { generateReferenceWithAI } from "@offworld/sdk/ai";
+import { createOpenCodeContext, generateReferenceWithAI } from "@offworld/sdk/ai";
 import { ReferenceMetaSchema, WorkOSAuthErrorResponseSchema, WorkOSDeviceAuthResponseSchema, WorkOSTokenResponseSchema } from "@offworld/types";
 import { homedir } from "node:os";
 import { AgentSchema, ConfigSchema } from "@offworld/types/schemas";
@@ -146,7 +146,7 @@ function parseModelFlag$1(model) {
 	return { model };
 }
 async function pullHandler(options) {
-	const { repo, shallow = false, sparse = false, branch, force = false, verbose = false, quiet = false, skipConfirm = false, onProgress } = options;
+	const { repo, sparse = false, branch, force = false, verbose = false, allowGenerate = true, skipUpdate = false, quiet = false, skipConfirm = false, onProgress } = options;
 	const referenceName = options.reference?.trim() || void 0;
 	const { provider, model } = parseModelFlag$1(options.model);
 	const config = loadConfig();
@@ -158,7 +158,7 @@ async function pullHandler(options) {
 	} : createSpinner({ silent: quiet });
 	const log = quiet ? () => {} : (msg) => p.log.info(msg);
 	const logSuccess = quiet ? () => {} : (msg) => p.log.success(msg);
-	if (verbose && !quiet) p.log.info(`[verbose] Options: repo=${repo}, reference=${referenceName ?? "default"}, shallow=${shallow}, branch=${branch || "default"}, force=${force}`);
+	if (verbose && !quiet) p.log.info(`[verbose] Options: repo=${repo}, reference=${referenceName ?? "default"}, branch=${branch || "default"}, force=${force}`);
 	try {
 		s.start("Parsing repository input...");
 		const source = parseRepoInput(repo);
@@ -167,17 +167,20 @@ async function pullHandler(options) {
 		let repoPath;
 		if (source.type === "remote") {
 			const qualifiedName = source.qualifiedName;
-			if (isRepoCloned(qualifiedName)) {
+			if (isRepoCloned(qualifiedName)) if (skipUpdate) {
+				repoPath = getClonedRepoPath(qualifiedName);
+				s.stop("Using existing clone");
+			} else {
 				s.start("Updating repository...");
 				const result = await updateRepo(qualifiedName);
 				repoPath = getClonedRepoPath(qualifiedName);
 				if (result.updated) s.stop(`Updated (${result.previousSha.slice(0, 7)} → ${result.currentSha.slice(0, 7)})`);
 				else s.stop("Already up to date");
-			} else {
+			}
+			else {
 				s.start(`Cloning ${source.fullName}...`);
 				try {
 					repoPath = await cloneRepo(source, {
-						shallow,
 						sparse,
 						branch,
 						config,
@@ -218,19 +221,23 @@ async function pullHandler(options) {
 					const remoteSha = remoteCheck.commitSha;
 					const remoteShaNorm = remoteSha.slice(0, 7);
 					const currentShaNorm = currentSha.slice(0, 7);
-					const MAX_COMMIT_DISTANCE = 20;
+					const maxCommitDistance = config.maxCommitDistance ?? 20;
+					const acceptUnknownDistance = config.acceptUnknownDistance ?? false;
 					const commitDistance = getCommitDistance(repoPath, remoteSha, currentSha);
-					if (isReferenceOverride || remoteShaNorm === currentShaNorm || commitDistance !== null && commitDistance <= MAX_COMMIT_DISTANCE) {
-						if (!isReferenceOverride) if (commitDistance === 0 || remoteShaNorm === currentShaNorm) {
+					const isExactMatch = remoteShaNorm === currentShaNorm || commitDistance === 0;
+					const isWithinDistance = commitDistance !== null && commitDistance <= maxCommitDistance;
+					const hasUnknownDistance = commitDistance === null;
+					if (isReferenceOverride || isExactMatch || isWithinDistance || acceptUnknownDistance && hasUnknownDistance) {
+						if (!isReferenceOverride) if (isExactMatch) {
 							verboseLog(`Remote SHA matches (${remoteShaNorm})`, verbose);
 							s.stop("Remote reference found (exact match)");
-						} else if (commitDistance !== null) {
-							verboseLog(`Remote reference is ${commitDistance} commits behind (within ${MAX_COMMIT_DISTANCE} threshold)`, verbose);
+						} else if (isWithinDistance) {
+							verboseLog(`Remote reference is ${commitDistance} commits behind (within ${maxCommitDistance} threshold)`, verbose);
 							s.stop(`Remote reference found (${commitDistance} commits behind)`);
-						} else {
-							verboseLog("Remote reference found (commit distance unknown)", verbose);
+						} else if (hasUnknownDistance) {
+							verboseLog(acceptUnknownDistance ? "Remote reference found (distance unknown, accepted)" : "Remote reference found (commit distance unknown)", verbose);
 							s.stop("Remote reference found");
-						}
+						} else s.stop("Remote reference found");
 						else s.stop("Remote reference found");
 						log(`Preview: ${referenceName ? `https://offworld.sh/${source.fullName}/${encodeURIComponent(referenceName)}` : `https://offworld.sh/${source.fullName}`}`);
 						let useRemote = true;
@@ -266,7 +273,7 @@ async function pullHandler(options) {
 						}
 					} else {
 						const distanceInfo = commitDistance !== null ? ` (${commitDistance} commits behind)` : "";
-						verboseLog(`Remote reference too outdated${distanceInfo}, threshold is ${MAX_COMMIT_DISTANCE}`, verbose);
+						verboseLog(`Remote reference too outdated${distanceInfo}, threshold is ${maxCommitDistance}`, verbose);
 						s.stop(`Remote reference outdated${distanceInfo}`);
 					}
 				} else s.stop("No remote reference found");
@@ -277,17 +284,30 @@ async function pullHandler(options) {
 			}
 		}
 		if (isReferenceOverride) throw new Error(`Reference not found on offworld.sh: ${referenceName}`);
+		if (!allowGenerate && source.type === "remote") {
+			const message = "Remote reference unavailable, outdated, or declined; local generation is disabled.";
+			s.stop(message);
+			return {
+				success: false,
+				repoPath,
+				referenceSource: "local",
+				referenceInstalled: false,
+				message
+			};
+		}
 		verboseLog(`Starting AI reference generation for: ${repoPath}`, verbose);
 		if (!verbose) s.start("Generating reference with AI...");
 		try {
+			const onDebug = verbose ? (message) => {
+				p.log.info(`[${timestamp()}] [debug] ${message}`);
+			} : (msg) => {
+				if (!msg.startsWith("[")) s.message(msg);
+			};
 			const { referenceContent, commitSha: referenceCommitSha } = await generateReferenceWithAI(repoPath, qualifiedName, {
 				provider,
 				model,
-				onDebug: verbose ? (message) => {
-					p.log.info(`[${timestamp()}] [debug] ${message}`);
-				} : (msg) => {
-					if (!msg.startsWith("[")) s.message(msg);
-				}
+				openCodeContext: options.openCodeContext,
+				onDebug
 			});
 			const meta = {
 				referenceUpdatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -370,10 +390,7 @@ async function generateHandler(options) {
 				p.log.info(`Using existing clone at ${repoPath}`);
 			} else {
 				s.start(`Cloning ${source.fullName}...`);
-				repoPath = await cloneRepo(source, {
-					shallow: config.defaultShallow,
-					config
-				});
+				repoPath = await cloneRepo(source, { config });
 				s.stop("Repository cloned");
 			}
 		} else repoPath = source.path;
@@ -466,13 +483,12 @@ async function repoListHandler(options) {
 	return { repos: items };
 }
 async function repoUpdateHandler(options) {
-	const { all = false, pattern, dryRun = false, unshallow = false } = options;
+	const { all = false, pattern, dryRun = false } = options;
 	if (!all && !pattern) {
 		p.log.error("Specify --all or a pattern to update.");
 		return {
 			updated: [],
 			skipped: [],
-			unshallowed: [],
 			errors: []
 		};
 	}
@@ -483,19 +499,17 @@ async function repoUpdateHandler(options) {
 		return {
 			updated: [],
 			skipped: [],
-			unshallowed: [],
 			errors: []
 		};
 	}
 	let processed = 0;
 	const outcomes = [];
 	const spinner = p.spinner();
-	const action = unshallow ? "Unshallowing" : "Updating";
+	const action = "Updating";
 	spinner.start(dryRun ? `Checking ${total} repos...` : `${action} ${total} repos...`);
 	const result = await updateAllRepos({
 		pattern,
 		dryRun,
-		unshallow,
 		onProgress: (repo, status, message) => {
 			if (status === "updating") {
 				processed++;
@@ -509,12 +523,10 @@ async function repoUpdateHandler(options) {
 	});
 	spinner.stop(dryRun ? "Dry run complete" : `${action} complete`);
 	for (const { repo, status, message } of outcomes) if (status === "updated") p.log.success(`${repo}${message ? ` (${message})` : ""}`);
-	else if (status === "unshallowed") p.log.success(`${repo}: ${message}`);
 	else if (status === "error") p.log.error(`${repo}: ${message}`);
 	else if (status === "skipped" && message !== "up to date" && message !== "already up to date") p.log.warn(`${repo}: ${message}`);
 	const parts = [];
 	if (result.updated.length > 0) parts.push(`${result.updated.length} ${dryRun ? "would update" : "updated"}`);
-	if (result.unshallowed.length > 0) parts.push(`${result.unshallowed.length} unshallowed`);
 	if (result.skipped.length > 0) parts.push(`${result.skipped.length} skipped`);
 	if (result.errors.length > 0) parts.push(`${result.errors.length} failed`);
 	if (parts.length > 0) p.log.info(`Summary: ${parts.join(", ")}`);
@@ -1155,8 +1167,9 @@ async function handleReferenceOnlyRemoval(repoName, yes, dryRun) {
 */
 const VALID_KEYS = [
 	"repoRoot",
-	"defaultShallow",
 	"defaultModel",
+	"maxCommitDistance",
+	"acceptUnknownDistance",
 	"agents"
 ];
 function isValidKey(key) {
@@ -1201,16 +1214,7 @@ async function configSetHandler(options) {
 		};
 	}
 	let parsedValue;
-	if (key === "defaultShallow") if (value === "true" || value === "1") parsedValue = true;
-	else if (value === "false" || value === "0") parsedValue = false;
-	else {
-		p.log.error(`Invalid boolean value: ${value}. Use 'true' or 'false'.`);
-		return {
-			success: false,
-			message: `Invalid boolean value: ${value}`
-		};
-	}
-	else if (key === "agents") {
+	if (key === "agents") {
 		const agentValues = value.split(",").map((a) => a.trim()).filter(Boolean);
 		const agentsResult = z.array(AgentSchema).safeParse(agentValues);
 		if (!agentsResult.success) {
@@ -1223,6 +1227,26 @@ async function configSetHandler(options) {
 			};
 		}
 		parsedValue = agentsResult.data;
+	} else if (key === "maxCommitDistance") {
+		const parsed = Number.parseInt(value, 10);
+		if (Number.isNaN(parsed) || parsed < 0) {
+			p.log.error("maxCommitDistance must be a non-negative integer.");
+			return {
+				success: false,
+				message: "Invalid maxCommitDistance value"
+			};
+		}
+		parsedValue = parsed;
+	} else if (key === "acceptUnknownDistance") {
+		const normalized = value.trim().toLowerCase();
+		if (normalized !== "true" && normalized !== "false") {
+			p.log.error("acceptUnknownDistance must be 'true' or 'false'.");
+			return {
+				success: false,
+				message: "Invalid acceptUnknownDistance value"
+			};
+		}
+		parsedValue = normalized === "true";
 	} else parsedValue = value;
 	try {
 		saveConfig({ [key]: parsedValue });
@@ -1806,6 +1830,27 @@ async function initHandler(options = {}) {
 
 //#endregion
 //#region src/handlers/project.ts
+function isInternalDependencyVersion(version) {
+	if (!version) return false;
+	const trimmed = version.trim();
+	if (!trimmed) return false;
+	const isPathReference = trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("/") || trimmed.startsWith("~/") || trimmed.startsWith("~\\");
+	return trimmed.startsWith("workspace:") || trimmed.startsWith("file:") || trimmed.startsWith("link:") || trimmed.startsWith("portal:") || isPathReference;
+}
+function dedupeMatchesByRepo(matches) {
+	const seenRepos = /* @__PURE__ */ new Set();
+	const deduped = [];
+	for (const match of matches) {
+		if (!match.repo) {
+			deduped.push(match);
+			continue;
+		}
+		if (seenRepos.has(match.repo)) continue;
+		seenRepos.add(match.repo);
+		deduped.push(match);
+	}
+	return deduped;
+}
 function detectProjectRoot() {
 	let currentDir = process.cwd();
 	while (currentDir !== homedir()) {
@@ -1831,6 +1876,20 @@ function showBanner() {
 	for (const line of LOGO_LINES) console.log(`${OLIVE}${line}${RESET}`);
 	console.log();
 }
+async function runWithConcurrency(tasks, concurrency) {
+	if (concurrency < 1) throw new Error("Concurrency must be at least 1.");
+	const results = [];
+	let index = 0;
+	async function worker() {
+		while (index < tasks.length) {
+			const i = index++;
+			results[i] = await tasks[i]();
+		}
+	}
+	const workers = Array.from({ length: Math.min(concurrency, tasks.length) }, () => worker());
+	await Promise.all(workers);
+	return results;
+}
 async function projectInitHandler(options = {}) {
 	showBanner();
 	p.intro("Scan your deps to install reference files and create a clone map for your agents.");
@@ -1865,11 +1924,7 @@ async function projectInitHandler(options = {}) {
 	p.log.info(`Found ${pc.cyan(dependencies.length)} dependencies`);
 	if (dependencies.length > 10) p.log.warn("Generating many references at once uses a lot of tokens. Consider selecting just a few.");
 	p.log.step("Resolving GitHub repositories...");
-	const isInternalDep = (version) => {
-		if (!version) return false;
-		return version.startsWith("workspace:") || version.startsWith("catalog:") || version.startsWith("file:") || version.startsWith("link:");
-	};
-	const resolvedPromises = dependencies.filter((dep) => !isInternalDep(dep.version)).map((dep) => resolveDependencyRepo(dep.name));
+	const resolvedPromises = dependencies.filter((dep) => !isInternalDependencyVersion(dep.version)).map((dep) => resolveDependencyRepo(dep.name, dep.version));
 	const resolved = await Promise.all(resolvedPromises);
 	const skipList = options.skip ? options.skip.split(",").map((d) => d.trim()) : [];
 	const depsList = options.deps ? options.deps.split(",").map((d) => d.trim()) : [];
@@ -1944,6 +1999,12 @@ async function projectInitHandler(options = {}) {
 		}
 		selected = Array.isArray(selectedResult) ? selectedResult : [];
 	}
+	const dedupedSelected = dedupeMatchesByRepo(selected);
+	if (dedupedSelected.length !== selected.length) {
+		const dedupeCount = selected.length - dedupedSelected.length;
+		p.log.info(`Deduped ${dedupeCount} duplicate dependencies that map to the same repository.`);
+	}
+	selected = dedupedSelected;
 	if (selected.length === 0) {
 		p.log.warn("No dependencies selected.");
 		p.outro("");
@@ -1972,55 +2033,164 @@ async function projectInitHandler(options = {}) {
 			message: "Dry run complete"
 		};
 	}
+	const requestedConcurrency = options.concurrency ?? 4;
+	const concurrency = Number.isFinite(requestedConcurrency) && requestedConcurrency > 0 ? Math.max(1, Math.trunc(requestedConcurrency)) : 4;
+	const installedGroup = selected.filter((m) => m.status === "installed");
+	const remoteGroup = selected.filter((m) => m.status === "remote");
+	const generateGroup = selected.filter((m) => m.status === "generate");
+	const total = selected.length;
 	const installed = [];
+	const successfulMatches = [];
 	let failedCount = 0;
-	const total = selected.length;
-	for (let i = 0; i < selected.length; i++) {
-		const match = selected[i];
-		if (!match.repo) continue;
-		const repo = match.repo;
-		const prefix = `${`[${i + 1}/${total}]`} ${match.dep}`;
-		const spinner = p.spinner();
-		spinner.start(`${prefix}: Starting...`);
-		try {
-			const pullResult = await pullHandler({
-				repo,
-				shallow: true,
-				force: options.generate,
-				verbose: false,
-				quiet: true,
-				skipConfirm: true,
-				onProgress: (msg) => spinner.message(`${prefix}: ${msg}`)
-			});
-			if (pullResult.success && pullResult.referenceInstalled) {
+	let counter = 0;
+	if (installedGroup.length > 0) {
+		p.log.step(`Adding ${pc.blue(installedGroup.length)} already-installed references...`);
+		await runWithConcurrency(installedGroup.map((match) => async () => {
+			const i = ++counter;
+			const repo = match.repo;
+			const prefix = `${`[${i}/${total}]`} ${match.dep}`;
+			try {
 				const referencePath = getReferencePath(repo);
+				successfulMatches.push(match);
 				installed.push({
 					dependency: match.dep,
 					reference: toReferenceFileName(repo),
 					path: referencePath
 				});
-				const source = pullResult.referenceSource === "remote" ? "downloaded" : "generated";
-				spinner.stop(`${prefix} ${pc.green("✓")} ${pc.dim(`(${source})`)}`);
-			} else {
+				p.log.info(`${prefix} ${pc.green("✓")} ${pc.dim("(already installed)")}`);
+				return {
+					match,
+					success: true,
+					source: "installed"
+				};
+			} catch (error) {
+				const errMsg = error instanceof Error ? error.message : "Unknown error";
+				p.log.info(`${prefix} ${pc.red("✗")} ${pc.dim(errMsg)}`);
+				failedCount++;
+				return {
+					match,
+					success: false
+				};
+			}
+		}), concurrency);
+	}
+	if (remoteGroup.length > 0) {
+		p.log.step(`Downloading ${pc.green(remoteGroup.length)} remote references...`);
+		await runWithConcurrency(remoteGroup.map((match) => async () => {
+			const i = ++counter;
+			const repo = match.repo;
+			const prefix = `${`[${i}/${total}]`} ${match.dep}`;
+			const spinner = p.spinner();
+			spinner.start(`${prefix}: Downloading...`);
+			try {
+				const pullResult = await pullHandler({
+					repo,
+					force: false,
+					verbose: false,
+					allowGenerate: false,
+					quiet: true,
+					skipConfirm: true,
+					skipUpdate: true,
+					onProgress: (msg) => spinner.message(`${prefix}: ${msg}`)
+				});
+				if (pullResult.success && pullResult.referenceInstalled) {
+					const referencePath = getReferencePath(repo);
+					successfulMatches.push(match);
+					installed.push({
+						dependency: match.dep,
+						reference: toReferenceFileName(repo),
+						path: referencePath
+					});
+					const source = pullResult.referenceSource === "remote" ? "downloaded" : pullResult.referenceSource;
+					spinner.stop(`${prefix} ${pc.green("✓")} ${pc.dim(`(${source})`)}`);
+					return {
+						match,
+						success: true,
+						source: "remote"
+					};
+				}
 				spinner.stop(`${prefix} ${pc.red("✗")} ${pc.red("failed")}`);
 				failedCount++;
+				return {
+					match,
+					success: false
+				};
+			} catch (error) {
+				const errMsg = error instanceof Error ? error.message : "Unknown error";
+				spinner.stop(`${prefix} ${pc.red("✗")} ${pc.dim(errMsg)}`);
+				failedCount++;
+				return {
+					match,
+					success: false
+				};
 			}
-		} catch (error) {
-			const errMsg = error instanceof Error ? error.message : "Unknown error";
-			spinner.stop(`${prefix} ${pc.red("✗")} ${pc.dim(errMsg)}`);
-			failedCount++;
-		}
+		}), concurrency);
 	}
-	const map = readGlobalMap();
-	writeProjectMap(projectRoot, Object.fromEntries(selected.filter((m) => m.repo).map((m) => {
-		const qualifiedName = `github.com:${m.repo}`;
-		const entry = map.repos[qualifiedName];
-		return [qualifiedName, {
-			localPath: entry?.localPath ?? "",
-			reference: toReferenceFileName(m.repo),
-			keywords: entry?.keywords ?? []
-		}];
-	})));
+	if (generateGroup.length > 0 && options.generate) {
+		p.log.step(`Generating ${pc.yellow(generateGroup.length)} references with AI...`);
+		let openCodeContext;
+		try {
+			if (generateGroup.length > 1) {
+				p.log.info(pc.dim("Starting shared AI server for batch generation..."));
+				openCodeContext = await createOpenCodeContext({ onDebug: () => {} });
+			}
+			for (const match of generateGroup) {
+				const i = ++counter;
+				const repo = match.repo;
+				const prefix = `${`[${i}/${total}]`} ${match.dep}`;
+				const spinner = p.spinner();
+				spinner.start(`${prefix}: Starting...`);
+				try {
+					const pullResult = await pullHandler({
+						repo,
+						force: options.generate,
+						verbose: false,
+						quiet: true,
+						skipConfirm: true,
+						openCodeContext,
+						onProgress: (msg) => spinner.message(`${prefix}: ${msg}`)
+					});
+					if (pullResult.success && pullResult.referenceInstalled) {
+						const referencePath = getReferencePath(repo);
+						successfulMatches.push(match);
+						installed.push({
+							dependency: match.dep,
+							reference: toReferenceFileName(repo),
+							path: referencePath
+						});
+						const source = pullResult.referenceSource === "remote" ? "downloaded" : "generated";
+						spinner.stop(`${prefix} ${pc.green("✓")} ${pc.dim(`(${source})`)}`);
+					} else {
+						spinner.stop(`${prefix} ${pc.red("✗")} ${pc.red("failed")}`);
+						failedCount++;
+					}
+				} catch (error) {
+					const errMsg = error instanceof Error ? error.message : "Unknown error";
+					spinner.stop(`${prefix} ${pc.red("✗")} ${pc.dim(errMsg)}`);
+					failedCount++;
+				}
+			}
+		} finally {
+			openCodeContext?.close();
+		}
+	} else if (generateGroup.length > 0 && !options.generate) p.log.info(`Skipping ${pc.yellow(generateGroup.length)} deps that need generation (use --generate to include them).`);
+	if (successfulMatches.length > 0) {
+		const map = readGlobalMap();
+		const successfulRepos = /* @__PURE__ */ new Map();
+		for (const match of successfulMatches) {
+			if (!match.repo || successfulRepos.has(match.repo)) continue;
+			successfulRepos.set(match.repo, match);
+		}
+		writeProjectMap(projectRoot, Object.fromEntries(Array.from(successfulRepos.values()).map((match) => {
+			const qualifiedName = `github.com:${match.repo}`;
+			const entry = map.repos[qualifiedName];
+			return [qualifiedName, {
+				localPath: entry?.localPath ?? "",
+				reference: toReferenceFileName(match.repo),
+				keywords: entry?.keywords ?? []
+			}];
+		})));
+	} else p.log.warn("No references were installed. Project map was not updated.");
 	if (installed.length > 0) try {
 		updateAgentFiles(projectRoot, installed);
 	} catch (error) {
@@ -2302,12 +2472,11 @@ async function mapSearchHandler(options) {
 
 //#endregion
 //#region src/index.ts
-const version = "0.3.3";
+const version = "0.3.5";
 const router = os.router({
 	pull: os.input(z.object({
 		repo: z.string().describe("repo").meta({ positional: true }),
 		reference: z.string().optional().describe("Reference name to pull (defaults to owner-repo)").meta({ alias: "r" }),
-		shallow: z.boolean().default(false).describe("Use shallow clone (--depth 1)").meta({ negativeAlias: "full-history" }),
 		sparse: z.boolean().default(false).describe("Use sparse checkout (only src/, lib/, packages/, docs/)"),
 		branch: z.string().optional().describe("Branch to clone"),
 		force: z.boolean().default(false).describe("Force re-generation").meta({ alias: "f" }),
@@ -2320,7 +2489,6 @@ const router = os.router({
 		await pullHandler({
 			repo: input.repo,
 			reference: input.reference,
-			shallow: input.shallow,
 			sparse: input.sparse,
 			branch: input.branch,
 			force: input.force,
@@ -2401,10 +2569,11 @@ const router = os.router({
 		})).meta({ description: `Set a config value
 
 Valid keys:
-  repoRoot        (string)  Where to clone repos (e.g., ~/ow)
-  defaultShallow  (boolean) Use shallow clone by default (true/false)
-  defaultModel    (string)  AI provider/model (e.g., anthropic/claude-sonnet-4-20250514)
-  agents          (list)    Comma-separated agents (e.g., claude-code,opencode)` }).handler(async ({ input }) => {
+  repoRoot             (string)  Where to clone repos (e.g., ~/ow)
+  defaultModel         (string)  AI provider/model (e.g., anthropic/claude-sonnet-4-20250514)
+  maxCommitDistance     (number)  Max commit distance to accept remote references (default: 20)
+  acceptUnknownDistance (boolean) Accept remote refs when distance is unknown (default: false)
+  agents               (list)    Comma-separated agents (e.g., claude-code,opencode)` }).handler(async ({ input }) => {
 			await configSetHandler({
 				key: input.key,
 				value: input.value
@@ -2412,7 +2581,7 @@ Valid keys:
 		}),
 		get: os.input(z.object({ key: z.string().describe("key").meta({ positional: true }) })).meta({ description: `Get a config value
 
-Valid keys: repoRoot, defaultShallow, defaultModel, agents` }).handler(async ({ input }) => {
+Valid keys: repoRoot, defaultModel, maxCommitDistance, acceptUnknownDistance, agents` }).handler(async ({ input }) => {
 			await configGetHandler({ key: input.key });
 		}),
 		reset: os.input(z.object({})).meta({ description: "Reset config to defaults" }).handler(async () => {
@@ -2446,7 +2615,8 @@ Valid keys: repoRoot, defaultShallow, defaultModel, agents` }).handler(async ({
 		skip: z.string().optional().describe("Comma-separated deps to exclude"),
 		generate: z.boolean().default(false).describe("Generate references for deps without existing ones").meta({ alias: "g" }),
 		dryRun: z.boolean().default(false).describe("Show what would be done without doing it").meta({ alias: "d" }),
-		yes: z.boolean().default(false).describe("Skip confirmations").meta({ alias: "y" })
+		yes: z.boolean().default(false).describe("Skip confirmations").meta({ alias: "y" }),
+		concurrency: z.number().int().min(1).default(4).describe("Max parallel installs for remote/installed refs (min: 1)").meta({ alias: "c" })
 	})).meta({
 		description: "Scan manifest, install references, update AGENTS.md",
 		default: true
@@ -2457,7 +2627,8 @@ Valid keys: repoRoot, defaultShallow, defaultModel, agents` }).handler(async ({
 			skip: input.skip,
 			generate: input.generate,
 			dryRun: input.dryRun,
-			yes: input.yes
+			yes: input.yes,
+			concurrency: input.concurrency
 		});
 	}) }),
 	map: os.router({
@@ -2508,14 +2679,12 @@ Valid keys: repoRoot, defaultShallow, defaultModel, agents` }).handler(async ({
 		update: os.input(z.object({
 			all: z.boolean().default(false).describe("Update all repos"),
 			pattern: z.string().optional().describe("Filter by pattern"),
-			dryRun: z.boolean().default(false).describe("Show what would be updated").meta({ alias: "d" }),
-			unshallow: z.boolean().default(false).describe("Convert shallow clones to full clones")
+			dryRun: z.boolean().default(false).describe("Show what would be updated").meta({ alias: "d" })
 		})).meta({ description: "Update repos (git fetch + pull)" }).handler(async ({ input }) => {
 			await repoUpdateHandler({
 				all: input.all,
 				pattern: input.pattern,
-				dryRun: input.dryRun,
-				unshallow: input.unshallow
+				dryRun: input.dryRun
 			});
 		}),
 		prune: os.input(z.object({
@@ -2602,4 +2771,4 @@ function createOwCli() {
 
 //#endregion
 export { router as n, version as r, createOwCli as t };
-//# sourceMappingURL=src-CrZvPV0A.mjs.map
+//# sourceMappingURL=src-DAHGD773.mjs.map