offworld 0.3.4 → 0.3.6

package/README.md

@@ -97,7 +97,6 @@ ow list
 
 ```
 --reference, -r   Reference filename override
---shallow         Use shallow clone (--depth 1)
 --sparse          Sparse checkout (src/, lib/, packages/, docs/)
 --branch <name>   Branch to clone
 --force, -f       Force regeneration
@@ -128,7 +127,7 @@ ow list
 --all             Select all deps
 --deps            Comma-separated deps
 --skip            Deps to exclude
---generate, -g    Generate references for new deps
+--generate, -g    Force local generation for new deps
 --dry-run, -d     Preview only
 --yes, -y         Skip confirmations
 ```
@@ -150,12 +149,13 @@ ow list
 
 ## Config Keys
 
-| Key              | Type    | Description                                           |
-| ---------------- | ------- | ----------------------------------------------------- |
-| `repoRoot`       | string  | Where to clone repos (default: `~/ow`)                |
-| `defaultShallow` | boolean | Use shallow clone by default                          |
-| `defaultModel`   | string  | AI model (e.g., `anthropic/claude-sonnet-4-20250514`) |
-| `agents`         | list    | Comma-separated agent names                           |
+| Key                     | Type    | Description                                                           |
+| ----------------------- | ------- | --------------------------------------------------------------------- |
+| `repoRoot`              | string  | Where to clone repos (default: `~/ow`)                                |
+| `defaultModel`          | string  | AI 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 commit distance is unknown (default: `false`) |
+| `agents`                | list    | Comma-separated agent names                                           |
 
 ## Path Discovery
 

package/dist/cli.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { r as version, t as createOwCli } from "./src-BLm6ei_p.mjs";
+import { r as version, t as createOwCli } from "./src-BN5uTbLS.mjs";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";

package/dist/index.d.mts

@@ -4,12 +4,11 @@ import { z } from "zod";
 import * as trpc_cli_dist_json_js0 from "trpc-cli/dist/json.js";
 
 //#region src/index.d.ts
-declare const version = "0.3.4";
+declare const version = "0.3.6";
 declare const router: {
   pull: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, z.ZodObject<{
     repo: z.ZodString;
     reference: z.ZodOptional<z.ZodString>;
-    shallow: z.ZodDefault<z.ZodBoolean>;
     sparse: z.ZodDefault<z.ZodBoolean>;
     branch: z.ZodOptional<z.ZodString>;
     force: z.ZodDefault<z.ZodBoolean>;
@@ -71,6 +70,7 @@ declare const router: {
       generate: z.ZodDefault<z.ZodBoolean>;
       dryRun: z.ZodDefault<z.ZodBoolean>;
       yes: z.ZodDefault<z.ZodBoolean>;
+      concurrency: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
   };
   map: {
@@ -96,7 +96,6 @@ declare const router: {
       all: z.ZodDefault<z.ZodBoolean>;
       pattern: z.ZodOptional<z.ZodString>;
       dryRun: z.ZodDefault<z.ZodBoolean>;
-      unshallow: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>, _orpc_server0.Schema<void, void>, _orpc_server0.MergedErrorMap<Record<never, never>, _orpc_server0.MergedErrorMap<Record<never, never>, Record<never, never>>>, Record<never, never>>;
     prune: _orpc_server0.Procedure<_orpc_server0.MergedInitialContext<Record<never, never>, _orpc_server0.MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>>, Record<never, never>, z.ZodObject<{
       dryRun: z.ZodDefault<z.ZodBoolean>;

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;cA+Ba,OAAA;AAAA,cAEA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAugBG,WAAA,CAAA;0BAAW,SAAA,CAAA,gBAAA;;+BA5OX,oBAAA,KAAA,sBAAA,CAAA,WAAA;AAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;cA+Ba,OAAA;AAAA,cAEA,MAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwgBG,WAAA,CAAA;0BAAW,SAAA,CAAA,gBAAA;;+BAnPuC,oBAAA,KAAA,sBAAA,CAAA,WAAA;AAAA"}

package/dist/index.mjs

@@ -1,3 +1,3 @@
-import { n as router, r as version, t as createOwCli } from "./src-BLm6ei_p.mjs";
+import { n as router, r as version, t as createOwCli } from "./src-BN5uTbLS.mjs";
 
 export { createOwCli, router, version };

package/dist/{src-BLm6ei_p.mjs → src-BN5uTbLS.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...");
+		if (!verbose) s.start("Generating reference with OpenCode...");
 		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,14 +390,11 @@ 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;
-		s.start("Generating reference with AI...");
+		s.start("Generating reference with OpenCode...");
 		const qualifiedName = source.qualifiedName;
 		const referenceRepoName = source.type === "remote" ? source.fullName : source.name;
 		const result = await generateReferenceWithAI(repoPath, referenceRepoName, {
@@ -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 });
@@ -1852,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.");
@@ -1995,28 +2033,23 @@ 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({
@@ -2024,16 +2057,121 @@ async function projectInitHandler(options = {}) {
 					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
+				};
+			}
+		}), concurrency);
+	}
+	if (generateGroup.length > 0) {
+		p.log.step(`Generating ${pc.yellow(generateGroup.length)} references with OpenCode...`);
+		let openCodeContext;
+		try {
+			if (generateGroup.length > 1) {
+				p.log.info(pc.dim("Starting OpenCode server for batch generation..."));
+				openCodeContext = await createOpenCodeContext({ onDebug: () => {} });
 			}
-		} catch (error) {
-			const errMsg = error instanceof Error ? error.message : "Unknown error";
-			spinner.stop(`${prefix} ${pc.red("✗")} ${pc.dim(errMsg)}`);
-			failedCount++;
+			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();
 		}
 	}
 	if (successfulMatches.length > 0) {
@@ -2334,12 +2472,11 @@ async function mapSearchHandler(options) {
 
 //#endregion
 //#region src/index.ts
-const version = "0.3.4";
+const version = "0.3.6";
 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" }),
@@ -2352,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,
@@ -2433,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
@@ -2444,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 () => {
@@ -2476,9 +2613,10 @@ Valid keys: repoRoot, defaultShallow, defaultModel, agents` }).handler(async ({
 		all: z.boolean().default(false).describe("Select all detected dependencies"),
 		deps: z.string().optional().describe("Comma-separated deps to include (skip selection)"),
 		skip: z.string().optional().describe("Comma-separated deps to exclude"),
-		generate: z.boolean().default(false).describe("Generate references for deps without existing ones").meta({ alias: "g" }),
+		generate: z.boolean().default(false).describe("Force local generation for deps without existing refs").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
@@ -2489,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({
@@ -2540,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({
@@ -2634,4 +2771,4 @@ function createOwCli() {
 
 //#endregion
 export { router as n, version as r, createOwCli as t };
-//# sourceMappingURL=src-BLm6ei_p.mjs.map
+//# sourceMappingURL=src-BN5uTbLS.mjs.map