claude-yes 1.147.0 → 1.149.0

package/dist/SUPPORTED_CLIS-CFaRUz70.js

@@ -0,0 +1,8 @@
+import "./ts-9In7C_H_.js";
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-xwsWu7p6.js";
+import "./pidStore-fqXqTKkh.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DmEBbACr.js";
+
+export { SUPPORTED_CLIS };

package/dist/{SUPPORTED_CLIS-BFZPtEsl.js → SUPPORTED_CLIS-DmEBbACr.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-DKH7E-F6.js";
+import { t as CLIS_CONFIG } from "./ts-9In7C_H_.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-BFZPtEsl.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DmEBbACr.js.map

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env bun
 import { t as invokedCliName } from "./invokedCli-uqM2YYA7.js";
 import { n as logger } from "./logger-CDIsZ-Pp.js";
-import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-BGsjdYf6.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-xwsWu7p6.js";
 import { argv } from "process";
 import { execFileSync, spawn } from "child_process";
 import ms from "ms";
@@ -480,7 +480,7 @@ function buildRustArgs(argv, cliFromScript, supportedClis) {
 	const rawArg = process.argv[2];
 	const managerCommands = !invokedCliName(process.argv);
 	const isHelpFlag = rawArg === "-h" || rawArg === "--help";
-	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-CiRgqMjR.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-DCsphJXW.js");
 	if (isHelpFlag && process.argv.length === 3) {
 		cmdHelp(managerCommands);
 		process.exit(0);
@@ -513,7 +513,7 @@ if (config.useRust) {
 		}
 	}
 	if (rustBinary) {
-		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-BUNhV-WM.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-CFaRUz70.js");
 		const rustArgs = buildRustArgs(process.argv, config.cli, SUPPORTED_CLIS);
 		if (config.verbose) {
 			console.log(`[rust] Using binary: ${rustBinary}`);

package/dist/index.js

@@ -1,6 +1,6 @@
-import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-DKH7E-F6.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-9In7C_H_.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-BGsjdYf6.js";
+import "./versionChecker-xwsWu7p6.js";
 import "./pidStore-fqXqTKkh.js";
 import "./globalPidIndex-DlmmJlO8.js";
 

package/dist/{schedule-Dq0rsd5g.js → schedule-CdJjOPt7.js}

@@ -1,10 +1,10 @@
-import "./ts-DKH7E-F6.js";
+import "./ts-9In7C_H_.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-BGsjdYf6.js";
+import "./versionChecker-xwsWu7p6.js";
 import "./pidStore-fqXqTKkh.js";
 import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BFZPtEsl.js";
-import { n as resolveSpawnCwd } from "./workspaceConfig-B3ylOZAO.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DmEBbACr.js";
+import { i as resolveSpawnCwd } from "./workspaceConfig-B9VX8tVO.js";
 import { createHash } from "node:crypto";
 
 //#region ts/oxmgrService.ts
@@ -141,4 +141,4 @@ async function cmdSchedule(rest) {
 
 //#endregion
 export { cmdSchedule };
-//# sourceMappingURL=schedule-Dq0rsd5g.js.map
+//# sourceMappingURL=schedule-CdJjOPt7.js.map

package/dist/{serve-C5nlXrQt.js → serve-j3Jwmk5O.js}

@@ -1,15 +1,16 @@
-import "./ts-DKH7E-F6.js";
+import "./ts-9In7C_H_.js";
 import "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-BGsjdYf6.js";
+import { r as getInstalledPackage } from "./versionChecker-xwsWu7p6.js";
 import "./pidStore-fqXqTKkh.js";
 import { a as updateGlobalPidStatus } from "./globalPidIndex-DlmmJlO8.js";
 import { t as pgidForWrapper } from "./reaper-C-eWAxIj.js";
 import "./configShared-C1C04bbq.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BFZPtEsl.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DmEBbACr.js";
 import "./e2e-ClOI_aqV.js";
 import "./webrtcLink-BWhuA74k.js";
 import "./remotes-qK6uozO4.js";
-import { S as snapshotStatus, _ as renderRawLog, c as extractTaskCounts, g as readNotes, i as controlCodeFromName, m as listRecords, o as deriveLiveStatus, w as writeToIpc, y as resolveOne } from "./subcommands-DAv18AHb.js";
+import { i as resolveSpawnCwd, r as isProvisionAllowed, t as getProvisionRoot } from "./workspaceConfig-B9VX8tVO.js";
+import { S as snapshotStatus, _ as renderRawLog, c as extractTaskCounts, g as readNotes, i as controlCodeFromName, m as listRecords, o as deriveLiveStatus, w as writeToIpc, y as resolveOne } from "./subcommands-PCUd7vJf.js";
 import yargs from "yargs";
 import { mkdir, open, readFile, stat, writeFile } from "fs/promises";
 import { homedir, hostname, userInfo } from "os";
@@ -20,6 +21,22 @@ import { randomBytes, timingSafeEqual } from "crypto";
 
 //#region ts/serve.ts
 const DEFAULT_PORT = 7432;
+/**
+* Normalize a user-supplied GitHub-ish source into the standard
+* `<owner>/<repo>/tree/<branch>` path that codehost/provision's `parseSpec`
+* understands. Interim fallback used only when the linked codehost build
+* predates `parseSource` (the canonical normalizer in the standard):
+*   https://github.com/o/r/tree/b · github.com/o/r/tree/b · o/r/tree/b
+*   o/r@branch · o/r (→ default branch main)
+*/
+function normalizeGithubSource(s) {
+	let v = s.trim().replace(/^https?:\/\//, "").replace(/^github\.com\//, "");
+	v = v.replace(/[?#].*$/, "").replace(/\.git$/, "").replace(/^\/+|\/+$/g, "");
+	const at = v.match(/^([^/]+)\/([^/@]+)@(.+)$/);
+	if (at) return `${at[1]}/${at[2]}/tree/${at[3]}`;
+	if (/^[^/]+\/[^/]+$/.test(v)) return `${v}/tree/main`;
+	return v;
+}
 function agentYesHome() {
 	return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
 }
@@ -1031,9 +1048,47 @@ Options:
 			}
 			const cli = String(body.cli ?? "claude");
 			if (!SUPPORTED_CLIS.includes(cli)) return new Response(`unsupported cli: ${cli}`, { status: 400 });
-			const cwd = typeof body.cwd === "string" && body.cwd ? body.cwd : process.cwd();
 			const prompt = String(body.prompt ?? "");
-			process.stderr.write(`→ console spawned:  ay ${cli}${prompt ? ` -- "${prompt.slice(0, 60)}"` : ""}  (cwd: ${cwd})\n`);
+			let cwd;
+			let provisioned = null;
+			const from = typeof body.from === "string" ? body.from.trim() : "";
+			if (from) {
+				let prov;
+				try {
+					prov = await import("codehost/provision");
+				} catch (e) {
+					return new Response(`spawn-from needs the 'codehost' package (codehost/provision) — install it (npm i -g codehost) or 'bun link' it for local dev: ${e.message}`, { status: 501 });
+				}
+				let spec;
+				try {
+					spec = typeof prov.parseSource === "function" ? prov.parseSource(from) : prov.parseSpec(normalizeGithubSource(from));
+				} catch {
+					spec = null;
+				}
+				if (!spec) return new Response(`unrecognized spawn source: ${from}`, { status: 400 });
+				if (!isProvisionAllowed(spec.owner, spec.repo)) return new Response(`provisioning '${spec.owner}/${spec.repo}' is not allowed — add the owner to provisionAllowlist in ~/.agent-yes/config.json (or "*" to allow all)`, { status: 403 });
+				let result;
+				try {
+					const wsRoot = getProvisionRoot();
+					result = await prov.provision(spec, wsRoot ? { wsRoot } : void 0);
+				} catch (e) {
+					return new Response(`provision failed: ${e.message}`, { status: 502 });
+				}
+				if (!result?.ok) return new Response(result?.error ?? "provision failed", { status: 502 });
+				cwd = result.folder;
+				provisioned = {
+					action: result.action,
+					folder: result.folder
+				};
+			} else {
+				cwd = resolveSpawnCwd(body.cwd);
+				try {
+					await mkdir(cwd, { recursive: true });
+				} catch (e) {
+					return new Response(`cannot create cwd ${cwd}: ${e.message}`, { status: 500 });
+				}
+			}
+			process.stderr.write(`→ console spawned:  ay ${cli}${prompt ? ` -- "${prompt.slice(0, 60)}"` : ""}  (cwd: ${cwd}${provisioned ? `, ${provisioned.action} from ${from}` : ""})\n`);
 			const ayBin = Bun.which("ay") ?? process.argv[1];
 			const ayCmd = process.platform === "win32" && ayBin.toLowerCase().endsWith(".exe") ? [ayBin] : [process.execPath, ayBin];
 			try {
@@ -1053,7 +1108,8 @@ Options:
 					ok: true,
 					pid: child.pid,
 					cli,
-					cwd
+					cwd,
+					...provisioned ? { provisioned } : {}
 				});
 			} catch (e) {
 				return new Response(e.message, { status: 500 });
@@ -1179,4 +1235,4 @@ Options:
 
 //#endregion
 export { cmdServe };
-//# sourceMappingURL=serve-C5nlXrQt.js.map
+//# sourceMappingURL=serve-j3Jwmk5O.js.map

package/dist/{setup-CYnFh4ZX.js → setup-BsVxgyr7.js}

@@ -1,4 +1,4 @@
-import { r as setWorkspaceRoot, t as getWorkspaceRoot } from "./workspaceConfig-B3ylOZAO.js";
+import { a as setWorkspaceRoot, n as getWorkspaceRoot } from "./workspaceConfig-B9VX8tVO.js";
 import { existsSync } from "node:fs";
 import { stdin, stdout } from "node:process";
 import { createInterface } from "node:readline/promises";
@@ -32,7 +32,7 @@ async function cmdSetup(rest) {
 	if (!existsSync(abs)) process.stderr.write(`  note: that directory doesn't exist yet — create it, or agents spawned there will fail\n`);
 	if (noShare) return 0;
 	process.stdout.write(`\nsharing this machine to agent-yes.com…\n`);
-	const { cmdServe } = await import("./serve-C5nlXrQt.js");
+	const { cmdServe } = await import("./serve-j3Jwmk5O.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-CYnFh4ZX.js.map
+//# sourceMappingURL=setup-BsVxgyr7.js.map

package/dist/{subcommands-CiRgqMjR.js → subcommands-DCsphJXW.js}

@@ -4,6 +4,6 @@ import "./configShared-C1C04bbq.js";
 import "./e2e-ClOI_aqV.js";
 import "./webrtcLink-BWhuA74k.js";
 import "./remotes-qK6uozO4.js";
-import { C as stopTipForCli, S as snapshotStatus, _ as renderRawLog, a as cursorAbs, b as resolveReadWindow, c as extractTaskCounts, d as isExitRequest, f as isPidAlive, g as readNotes, h as matchKeyword, i as controlCodeFromName, l as finalizedLines, m as listRecords, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isSubcommand, r as cmdHelp, s as extractNeedsInput, t as GRACEFUL_EXIT_COMMANDS, u as isAgentStuck, v as renderRawLogLines, w as writeToIpc, x as runSubcommand, y as resolveOne } from "./subcommands-DAv18AHb.js";
+import { C as stopTipForCli, S as snapshotStatus, _ as renderRawLog, a as cursorAbs, b as resolveReadWindow, c as extractTaskCounts, d as isExitRequest, f as isPidAlive, g as readNotes, h as matchKeyword, i as controlCodeFromName, l as finalizedLines, m as listRecords, n as READ_PAGE_DEFAULT, o as deriveLiveStatus, p as isSubcommand, r as cmdHelp, s as extractNeedsInput, t as GRACEFUL_EXIT_COMMANDS, u as isAgentStuck, v as renderRawLogLines, w as writeToIpc, x as runSubcommand, y as resolveOne } from "./subcommands-PCUd7vJf.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{subcommands-DAv18AHb.js → subcommands-PCUd7vJf.js}

@@ -554,15 +554,15 @@ async function runSubcommand(argv) {
 			case "restart": return await cmdRestart(rest);
 			case "note": return await cmdNote(rest);
 			case "serve": {
-				const { cmdServe } = await import("./serve-C5nlXrQt.js");
+				const { cmdServe } = await import("./serve-j3Jwmk5O.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-CYnFh4ZX.js");
+				const { cmdSetup } = await import("./setup-BsVxgyr7.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-Dq0rsd5g.js");
+				const { cmdSchedule } = await import("./schedule-CdJjOPt7.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
@@ -2593,4 +2593,4 @@ async function cmdResultSet(rest) {
 
 //#endregion
 export { stopTipForCli as C, snapshotStatus as S, renderRawLog as _, cursorAbs as a, resolveReadWindow as b, extractTaskCounts as c, isExitRequest as d, isPidAlive as f, readNotes as g, matchKeyword as h, controlCodeFromName as i, finalizedLines as l, listRecords as m, READ_PAGE_DEFAULT as n, deriveLiveStatus as o, isSubcommand as p, cmdHelp as r, extractNeedsInput as s, GRACEFUL_EXIT_COMMANDS as t, isAgentStuck as u, renderRawLogLines as v, writeToIpc as w, runSubcommand as x, resolveOne as y };
-//# sourceMappingURL=subcommands-DAv18AHb.js.map
+//# sourceMappingURL=subcommands-PCUd7vJf.js.map

package/dist/{ts-DKH7E-F6.js → ts-9In7C_H_.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-BGsjdYf6.js";
+import { r as getInstalledPackage } from "./versionChecker-xwsWu7p6.js";
 import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
 import { i as shouldUseLock, r as releaseLock, t as acquireLock } from "./runningLock-V4qvXgAw.js";
 import { t as PidStore } from "./pidStore-fqXqTKkh.js";
@@ -1800,4 +1800,4 @@ function sleep(ms) {
 
 //#endregion
 export { removeControlCharacters as a, AgentContext as i, agentYes as n, config as r, CLIS_CONFIG as t };
-//# sourceMappingURL=ts-DKH7E-F6.js.map
+//# sourceMappingURL=ts-9In7C_H_.js.map

package/dist/{versionChecker-BGsjdYf6.js → versionChecker-xwsWu7p6.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "claude-yes";
-var version = "1.147.0";
+var version = "1.149.0";
 
 //#endregion
 //#region ts/versionChecker.ts
@@ -215,4 +215,4 @@ async function displayVersion() {
 
 //#endregion
 export { versionString as i, displayVersion as n, getInstalledPackage as r, checkAndAutoUpdate as t };
-//# sourceMappingURL=versionChecker-BGsjdYf6.js.map
+//# sourceMappingURL=versionChecker-xwsWu7p6.js.map

package/dist/workspaceConfig-B9VX8tVO.js

@@ -0,0 +1,91 @@
+import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
+import { mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import path from "path";
+
+//#region ts/workspaceConfig.ts
+function configPath() {
+	return path.join(agentYesHome(), "config.json");
+}
+function readConfig() {
+	try {
+		return JSON.parse(readFileSync(configPath(), "utf-8"));
+	} catch {
+		return {};
+	}
+}
+/** Expand a leading `~` (`~` or `~/x`) to an absolute home-based path. */
+function expandTilde(p) {
+	const s = p.trim();
+	if (s === "~") return homedir();
+	if (s.startsWith("~/") || s.startsWith("~\\")) return path.join(homedir(), s.slice(2));
+	return s;
+}
+/** The configured workspace root (absolute), or the home dir if unset. */
+function getWorkspaceRoot() {
+	const w = readConfig().workspace;
+	return w && w.trim() ? w : homedir();
+}
+/**
+* Root for `from`-provisioned worktrees, handed to codehost/provision so they
+* land in `<root>/<owner>/<repo>/tree/<branch>`. Resolution order: env
+* `CODEHOST_WS_ROOT` wins (ops override), then the configured `provisionRoot`,
+* else undefined — letting codehost/provision fall back to its own `~/ws`
+* default. Kept separate from `workspace` (the plain-cwd default), which may be a
+* specific project dir rather than a root.
+*/
+function getProvisionRoot() {
+	const env = process.env.CODEHOST_WS_ROOT?.trim();
+	if (env) return path.resolve(expandTilde(env));
+	const r = readConfig().provisionRoot;
+	return r && r.trim() ? path.resolve(expandTilde(r)) : void 0;
+}
+/**
+* Owner/repo allowlist for `from`-provisioning. Provisioning clones a repo and
+* runs its setup script (dependency installs + package lifecycle hooks = code
+* execution on the host), so an **empty allowlist means DENY ALL** — a secure
+* default the host opts out of by listing owners it trusts. Entries match
+* `<owner>` (any repo of that owner), `<owner>/<repo>` (exact), or `*` (allow
+* all — an explicit opt-in to the wide-open behavior). Env
+* `CODEHOST_PROVISION_ALLOWLIST` (comma-separated) overrides the config.
+*/
+function getProvisionAllowlist() {
+	const env = process.env.CODEHOST_PROVISION_ALLOWLIST?.trim();
+	return (env ? env.split(",") : readConfig().provisionAllowlist ?? []).map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+/** Whether `<owner>/<repo>` may be `from`-provisioned, per {@link getProvisionAllowlist}. */
+function isProvisionAllowed(owner, repo) {
+	const list = getProvisionAllowlist();
+	if (list.includes("*")) return true;
+	const o = owner.toLowerCase();
+	const full = `${owner}/${repo}`.toLowerCase();
+	return list.some((e) => e.replace(/\/\*$/, "") === o || e === full);
+}
+/** Persist the workspace root, tilde-expanded and resolved to an absolute path. */
+function setWorkspaceRoot(dir) {
+	const abs = path.resolve(expandTilde(dir));
+	const cfg = readConfig();
+	cfg.workspace = abs;
+	mkdirSync(agentYesHome(), { recursive: true });
+	writeFileSync(configPath(), JSON.stringify(cfg, null, 2));
+	return abs;
+}
+/**
+* Resolve a user-supplied spawn location to an absolute cwd:
+* - empty            → the workspace root
+* - a bare name      → `<workspace>/<name>` (so "myproject" lands under the root)
+* - `~`-prefixed     → home-based absolute
+* - anything with a path separator → resolved as-is
+*/
+function resolveSpawnCwd(input) {
+	const root = getWorkspaceRoot();
+	const v = (input ?? "").trim();
+	if (!v) return root;
+	if (v.startsWith("~")) return path.resolve(expandTilde(v));
+	if (v.includes("/") || v.includes("\\") || path.isAbsolute(v)) return path.resolve(v);
+	return path.join(root, v);
+}
+
+//#endregion
+export { setWorkspaceRoot as a, resolveSpawnCwd as i, getWorkspaceRoot as n, isProvisionAllowed as r, getProvisionRoot as t };
+//# sourceMappingURL=workspaceConfig-B9VX8tVO.js.map

package/lab/ui/index.html

@@ -550,7 +550,10 @@
         position: fixed;
         inset: 0;
         z-index: 30;
-        background: rgba(2, 6, 12, 0.6);
+        /* Light scrim only: the omnibox live-previews the highlighted agent in the
+           terminal behind it, so the backdrop must stay see-through. The omnibox's
+           own panel bg + shadow keep it legible against the brighter terminal. */
+        background: rgba(2, 6, 12, 0.32);
         display: flex;
         align-items: flex-start;
         justify-content: center;
@@ -1490,8 +1493,8 @@
         <div class="omni-results" id="omni-results"></div>
         <div class="omni-foot">
           <span
-            ><b>↑↓</b> move &nbsp; <b>⏎</b> open &nbsp; <b>⌘⏎</b> spawn here &nbsp;
-            <b>esc</b> close</span
+            ><b>↑↓</b> preview &nbsp; <b>⏎</b> open &nbsp; <b>⌘⏎</b> spawn here &nbsp;
+            <b>esc</b> cancel</span
           >
         </div>
       </div>
@@ -3326,7 +3329,12 @@
         document.title = docTitle(name, e && e.status); // pure formatter (tested)
       }
 
-      function select(keyOrPid) {
+      // opts.preview — a transient "peek" used by the Cmd+K omnibox to swap the
+      // background terminal to the highlighted candidate WITHOUT committing: it
+      // renders + live-tails the agent exactly like a real open, but skips the
+      // persistence (localStorage/URL hash) and skips stealing keyboard focus from
+      // the omnibox input. Esc later restores the original via a full select().
+      function select(keyOrPid, opts = {}) {
         const e =
           entries.find((x) => x._key === keyOrPid) ||
           entries.find((x) => String(x.pid) === String(keyOrPid));
@@ -3343,19 +3351,22 @@
         renderPeerSelections(); // drop any prior agent's peer-selection overlay now
         sendPresence(); // announce we're now watching this agent (host TTLs the prior one)
         paintHeaderBadge();
-        // Remember the selection so a refresh re-opens this agent (see boot/autoPid).
-        try {
-          localStorage.setItem("ay.sel", sel);
-        } catch {}
-        // Reflect it in the URL hash as #room:pid. The fragment is never sent in
-        // any request, so — unlike the old ?pid= query that landed in the server's
-        // access logs — the agent id stays client-side, while still surviving a
-        // refresh and being copy-pasteable as a deep link.
-        try {
-          const want = "#" + e._room + ":" + e.pid;
-          if (location.hash !== want)
-            history.replaceState(null, document.title, location.pathname + want);
-        } catch {}
+        // Persist the selection (refresh re-opens this agent) and reflect it in the
+        // URL hash as #room:pid — but ONLY for a real open. A preview is transient,
+        // so it must not clobber the remembered selection or the deep-link hash;
+        // those still point at the agent we'll restore to on Esc. The fragment is
+        // never sent in any request, so the agent id stays client-side while
+        // surviving a refresh and being copy-pasteable as a deep link.
+        if (!opts.preview) {
+          try {
+            localStorage.setItem("ay.sel", sel);
+          } catch {}
+          try {
+            const want = "#" + e._room + ":" + e.pid;
+            if (location.hash !== want)
+              history.replaceState(null, document.title, location.pathname + want);
+          } catch {}
+        }
         // pid + tx are how we talk to the agent's own host; sel (composite) is
         // only for UI identity/highlight, since pids can collide across rooms.
         const pid = e.pid;
@@ -3427,7 +3438,9 @@
         // On a phone, auto-focusing yanks up the soft keyboard the moment you open
         // an agent — even when you only meant to read the tail. Skip it there; a tap
         // on the terminal still focuses to type. Desktop keeps instant keyboard input.
-        if (window.innerWidth > 720) term.focus();
+        // During a preview the omnibox input owns the keyboard (so ↑↓ keep moving the
+        // selection), so never pull focus into the terminal.
+        if (!opts.preview && window.innerWidth > 720) term.focus();
         // An agent can rename itself by emitting an OSC 0/2 title sequence
         // (\x1b]2;my-name\x07); xterm parses it out of the raw PTY stream we already
         // feed it, so we just surface the latest title as the header name. Falls
@@ -3537,7 +3550,12 @@
           const close = tx.subscribe(
             "/api/tail/" + encodeURIComponent(pid) + "?raw=1",
             (raw) => {
-              if (term) {
+              // Guard on selKey: a late event from a just-closed subscription (the
+              // close is async, so one buffered message can still arrive) must NOT
+              // be written into the NEW terminal — otherwise the previous agent's
+              // raw bleeds into the one we just switched to. Preview makes switches
+              // frequent, so this race is no longer theoretical.
+              if (term && sel === selKey) {
                 term.write(raw);
                 perfNote("out", raw?.length ?? 0);
               }
@@ -3689,32 +3707,93 @@
       let omniIdx = 0;
       let omniTailTimer = null;
       let omniTailSeq = 0;
+      // Live-preview state. While the omnibox is open it swaps the BACKGROUND
+      // terminal to whatever candidate is highlighted, so you can read it through
+      // the (lightened) backdrop. omniReturnSel is the agent that was open when the
+      // omnibox launched — Esc/cancel restores it, commit (Enter/click) keeps the
+      // previewed one. omniWasDetail remembers the mobile list/detail pane so a
+      // cancel lands back where you were. omniPreviewKey dedupes redundant swaps;
+      // omniPreviewTimer debounces them (rebuilding xterm + the tail SSE on every
+      // arrow keypress would thrash the host).
+      let omniReturnSel = null;
+      let omniWasDetail = false;
+      let omniPreviewing = false;
+      let omniPreviewKey = null;
+      let omniPreviewTimer = null;
       const omniOpen = () => $("omni").style.display !== "none";
 
       function openOmni() {
+        omniReturnSel = sel;
+        omniWasDetail = document.querySelector(".app").classList.contains("show-detail");
+        omniPreviewing = false;
+        omniPreviewKey = sel; // start deduped against the already-open agent
         $("omni").style.display = "flex";
         const inp = $("omni-input");
         inp.value = "";
         inp.focus();
-        runOmni();
-      }
-      function closeOmni() {
+        runOmni(); // no preview yet — the bg stays on the original until you move/type
+      }
+      // restore=true (default — Esc / backdrop click / Cmd+K toggle) reverts the
+      // terminal to the agent that was open before the omnibox, via a full select()
+      // so the original is re-persisted, and undoes any mobile pane flip the preview
+      // caused. restore=false (commit) leaves the previewed agent in place for the
+      // caller (omniActivate) to finalize with its own select().
+      function closeOmni(restore = true) {
         if (omniTailTimer) clearTimeout(omniTailTimer);
+        if (omniPreviewTimer) clearTimeout(omniPreviewTimer);
+        omniPreviewTimer = null;
         omniTailSeq++; // cancel any in-flight tail search
         $("omni").style.display = "none";
+        if (restore && omniPreviewing) {
+          // Re-open + re-persist the original (only if we actually moved away from
+          // it — when previewing the original itself, sel already matches and the
+          // saved selection was never clobbered, so a rebuild would just flicker).
+          if (omniReturnSel && sel !== omniReturnSel) select(omniReturnSel);
+          // Either way restore the mobile list/detail state the preview flipped.
+          document.querySelector(".app").classList.toggle("show-detail", omniWasDetail);
+        }
+        omniPreviewing = false;
       }
 
-      // The agent the spawn action is anchored to. PINNED to the agent currently
-      // open in the console (its cwd/cli), so the spawn target stays put as you
-      // arrow through search results. Falls back to the top result when nothing is
-      // selected yet.
+      // The agent the spawn action is anchored to. PINNED to the agent that was open
+      // when the omnibox launched (omniReturnSel) — NOT the live `sel`, which now
+      // moves as you arrow-preview candidates — so the spawn cwd/cli stays put as you
+      // browse. Falls back to the top result when nothing was open.
       function omniAnchor() {
-        const cur = sel ? entries.find((x) => x._key === sel) : null;
+        const cur = omniReturnSel ? entries.find((x) => x._key === omniReturnSel) : null;
         if (cur) return cur;
         const first = omniRows.find((r) => r.kind === "agent");
         return first ? first.entry : null;
       }
 
+      // Which agent the highlighted candidate should preview in the background: an
+      // agent row → that agent; the spawn row / an empty list → the launch-time
+      // agent (so the backdrop shows the spawn target's cwd).
+      function omniPreviewTarget() {
+        const row = omniRows[omniIdx];
+        if (row && row.kind === "agent") return row.entry._key;
+        return omniReturnSel;
+      }
+      // Swap the background terminal to the highlighted candidate. Debounced so a
+      // held arrow key doesn't rebuild xterm + reconnect the tail on every repeat,
+      // and deduped by key so re-renders (filtering, tail-search inserts) don't
+      // re-peek the agent already shown. Called only on explicit user moves (arrow /
+      // type), never on open, so the bg stays on the original until you act.
+      function omniPreview() {
+        const key = omniPreviewTarget();
+        if (key === omniPreviewKey) return; // already targeting this agent
+        omniPreviewKey = key;
+        if (omniPreviewTimer) clearTimeout(omniPreviewTimer);
+        omniPreviewTimer = setTimeout(() => {
+          omniPreviewTimer = null;
+          if (!omniOpen()) return; // closed during the debounce window
+          if (!key || key === sel) return; // nothing to peek / already showing it
+          omniPreviewing = true;
+          select(key, { preview: true });
+          $("omni-input").focus(); // select() must not steal the keyboard
+        }, 120);
+      }
+
       function renderOmni() {
         const q = $("omni-input").value.trim();
         if (omniIdx >= omniRows.length) omniIdx = Math.max(0, omniRows.length - 1);
@@ -3803,8 +3882,12 @@
                 : esc(raw);
             const at = omniRows.findIndex((r) => r.kind === "spawn");
             const row = { kind: "agent", entry: e, snippet };
-            if (at >= 0) omniRows.splice(at, 0, row);
-            else omniRows.push(row);
+            if (at >= 0) {
+              omniRows.splice(at, 0, row);
+              // Keep the highlight (and thus the preview) anchored to the SAME row:
+              // an insert at/above omniIdx shifts our row down one, so follow it.
+              if (at <= omniIdx) omniIdx++;
+            } else omniRows.push(row);
           }),
         );
         if (seq === omniTailSeq) renderOmni();
@@ -3814,13 +3897,14 @@
         if (!omniRows.length) return;
         omniIdx = (omniIdx + d + omniRows.length) % omniRows.length;
         renderOmni();
+        omniPreview();
       }
       async function omniActivate(forceSpawn) {
         const q = $("omni-input").value.trim();
         const row = omniRows[omniIdx];
         if (forceSpawn || (row && row.kind === "spawn")) {
           const anchor = omniAnchor();
-          closeOmni();
+          closeOmni(false); // committing — keep the bg as-is, spawnAndSelect takes over
           await spawnAndSelect(
             { cli: anchor?.cli || "claude", cwd: anchor?.cwd || undefined, prompt: q || undefined },
             anchor?._room,
@@ -3828,12 +3912,17 @@
           return;
         }
         if (row && row.kind === "agent") {
-          closeOmni();
+          closeOmni(false); // committing the previewed agent — don't restore the original
           select(row.entry._key);
         }
       }
 
-      $("omni-input").addEventListener("input", runOmni);
+      // Typing re-filters AND re-previews the new top match (user-initiated, so a
+      // bg swap here is expected); the open's own runOmni() call is silent.
+      $("omni-input").addEventListener("input", () => {
+        runOmni();
+        omniPreview();
+      });
       $("omni-results").addEventListener("click", (ev) => {
         const r = ev.target.closest(".omni-row");
         if (!r) return;
@@ -4245,6 +4334,7 @@
         const before = new Set(entries.filter((e) => e._room === target.id).map((e) => e.pid));
         const res = await target.tx.post("/api/spawn", {
           cli: spec.cli || "claude",
+          from: spec.from || undefined,
           cwd: spec.cwd || undefined,
           prompt: spec.prompt || undefined,
         });
@@ -4296,7 +4386,8 @@
         $("newform").innerHTML = `<div class="lcard">
       <div class="ltitle">New agent · ${esc(where)}</div>
       <div class="nfield"><label>CLI</label><input id="nf-cli" value="claude" spellcheck="false" autocapitalize="off" /></div>
-      <div class="nfield"><label>Working dir</label><input id="nf-cwd" value="${esc(cwd)}" placeholder="(host default)" spellcheck="false" autocapitalize="off" /></div>
+      <div class="nfield"><label>Spawn from — optional</label><input id="nf-from" placeholder="github URL / owner/repo@branch — provisions a worktree" spellcheck="false" autocapitalize="off" /></div>
+      <div class="nfield"><label>Working dir</label><input id="nf-cwd" value="${esc(cwd)}" placeholder="(host default — ignored when Spawn from is set)" spellcheck="false" autocapitalize="off" /></div>
       <div class="nfield"><label>Prompt — optional</label><textarea id="nf-prompt" rows="3" placeholder="initial message to send the agent…"></textarea></div>
       <div class="lrow">
         <button class="lfleet" id="nf-go">▷ Launch</button>
@@ -4312,6 +4403,7 @@
         if (!go || go.disabled) return;
         const spec = {
           cli: ($("nf-cli").value || "claude").trim(),
+          from: $("nf-from")?.value.trim() || "",
           cwd: $("nf-cwd").value.trim(),
           prompt: $("nf-prompt").value,
         };
@@ -4320,7 +4412,7 @@
         // target fleet. A 2nd `claude -c` in the same repo fights over the same
         // session/files and usually exits on startup — which looks like "the new
         // agent never appears". Let the user pick a different dir or proceed.
-        if (spec.cwd) {
+        if (spec.cwd && !spec.from) {
           await loadList();
           const norm = (p) => (p || "").replace(/\/+$/, "");
           const busy = entries.some(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.147.0",
+  "version": "1.149.0",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "ai",

package/ts/serve.ts

@@ -21,9 +21,33 @@ import { updateGlobalPidStatus } from "./globalPidIndex.ts";
 import { pgidForWrapper } from "./reaper.ts";
 import { SUPPORTED_CLIS } from "./SUPPORTED_CLIS.ts";
 import { getInstalledPackage } from "./versionChecker.ts";
+import { getProvisionRoot, isProvisionAllowed, resolveSpawnCwd } from "./workspaceConfig.ts";
 
 const DEFAULT_PORT = 7432;
 
+/**
+ * Normalize a user-supplied GitHub-ish source into the standard
+ * `<owner>/<repo>/tree/<branch>` path that codehost/provision's `parseSpec`
+ * understands. Interim fallback used only when the linked codehost build
+ * predates `parseSource` (the canonical normalizer in the standard):
+ *   https://github.com/o/r/tree/b · github.com/o/r/tree/b · o/r/tree/b
+ *   o/r@branch · o/r (→ default branch main)
+ */
+function normalizeGithubSource(s: string): string {
+  let v = s
+    .trim()
+    .replace(/^https?:\/\//, "")
+    .replace(/^github\.com\//, "");
+  v = v
+    .replace(/[?#].*$/, "")
+    .replace(/\.git$/, "")
+    .replace(/^\/+|\/+$/g, "");
+  const at = v.match(/^([^/]+)\/([^/@]+)@(.+)$/);
+  if (at) return `${at[1]}/${at[2]}/tree/${at[3]}`;
+  if (/^[^/]+\/[^/]+$/.test(v)) return `${v}/tree/main`;
+  return v;
+}
+
 function agentYesHome(): string {
   return process.env.AGENT_YES_HOME ?? path.join(homedir(), ".agent-yes");
 }
@@ -1448,9 +1472,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
       return Response.json(live);
     }
 
-    // POST /api/spawn  body {cli, cwd, prompt} — launch a new agent
+    // POST /api/spawn  body {cli, cwd?, from?, prompt?} — launch a new agent.
+    // `from` (a GitHub URL / owner/repo@branch / owner/repo/tree/branch) is
+    // resolved to a ready worktree via codehost/provision (the shared workspace
+    // standard); otherwise `cwd` is resolved against the workspace root and
+    // created if missing (Layer-0 plain-dir provisioning — no more ENOENT 500).
     if (req.method === "POST" && p === "/api/spawn") {
-      let body: { cli?: string; cwd?: string; prompt?: string };
+      let body: { cli?: string; cwd?: string; from?: string; prompt?: string };
       try {
         body = (await req.json()) as typeof body;
       } catch {
@@ -1459,10 +1487,73 @@ export async function cmdServe(rest: string[]): Promise<number> {
       const cli = String(body.cli ?? "claude");
       if (!SUPPORTED_CLIS.includes(cli as never))
         return new Response(`unsupported cli: ${cli}`, { status: 400 });
-      const cwd = typeof body.cwd === "string" && body.cwd ? body.cwd : process.cwd();
       const prompt = String(body.prompt ?? "");
+
+      // Resolve the working directory. A `from` source is provisioned (clone /
+      // worktree) through codehost/provision; a plain `cwd` is resolved to the
+      // workspace root and mkdir-p'd so a missing dir no longer ENOENTs.
+      let cwd: string;
+      let provisioned: { action: string; folder: string } | null = null;
+      const from = typeof body.from === "string" ? body.from.trim() : "";
+      if (from) {
+        type Spec = { owner: string; repo: string; branch: string };
+        let prov: {
+          parseSource?: (s: string) => Spec | null;
+          parseSpec: (s: string) => Spec | null;
+          provision: (
+            spec: Spec,
+            opts?: { wsRoot?: string },
+          ) => Promise<{ ok: boolean; folder: string; action: string; error?: string }>;
+        };
+        try {
+          prov = (await import("codehost/provision")) as typeof prov;
+        } catch (e) {
+          return new Response(
+            `spawn-from needs the 'codehost' package (codehost/provision) — install it ` +
+              `(npm i -g codehost) or 'bun link' it for local dev: ${(e as Error).message}`,
+            { status: 501 },
+          );
+        }
+        // Malformed input (e.g. bad %-encoding) must surface as 400, not a 500.
+        let spec: Spec | null;
+        try {
+          spec =
+            typeof prov.parseSource === "function"
+              ? prov.parseSource(from)
+              : prov.parseSpec(normalizeGithubSource(from));
+        } catch {
+          spec = null;
+        }
+        if (!spec) return new Response(`unrecognized spawn source: ${from}`, { status: 400 });
+        // Provisioning clones the repo and runs its setup script (dependency
+        // installs + package lifecycle hooks = code execution on the host), so
+        // gate it behind an owner/repo allowlist — empty allowlist = deny all.
+        if (!isProvisionAllowed(spec.owner, spec.repo))
+          return new Response(
+            `provisioning '${spec.owner}/${spec.repo}' is not allowed — add the owner to ` +
+              `provisionAllowlist in ~/.agent-yes/config.json (or "*" to allow all)`,
+            { status: 403 },
+          );
+        let result: { ok: boolean; folder: string; action: string; error?: string };
+        try {
+          const wsRoot = getProvisionRoot();
+          result = await prov.provision(spec, wsRoot ? { wsRoot } : undefined);
+        } catch (e) {
+          return new Response(`provision failed: ${(e as Error).message}`, { status: 502 });
+        }
+        if (!result?.ok) return new Response(result?.error ?? "provision failed", { status: 502 });
+        cwd = result.folder;
+        provisioned = { action: result.action, folder: result.folder };
+      } else {
+        cwd = resolveSpawnCwd(body.cwd);
+        try {
+          await mkdir(cwd, { recursive: true });
+        } catch (e) {
+          return new Response(`cannot create cwd ${cwd}: ${(e as Error).message}`, { status: 500 });
+        }
+      }
       process.stderr.write(
-        `→ console spawned:  ay ${cli}${prompt ? ` -- "${prompt.slice(0, 60)}"` : ""}  (cwd: ${cwd})\n`,
+        `→ console spawned:  ay ${cli}${prompt ? ` -- "${prompt.slice(0, 60)}"` : ""}  (cwd: ${cwd}${provisioned ? `, ${provisioned.action} from ${from}` : ""})\n`,
       );
       // Resolve `ay` to an absolute command. The detached daemon (oxmgr/launchd/
       // pm2) usually has a PATH WITHOUT ~/.bun/bin, so a bare "ay" fails with
@@ -1483,7 +1574,13 @@ export async function cmdServe(rest: string[]): Promise<number> {
           stderr: "ignore",
         });
         child.unref();
-        return Response.json({ ok: true, pid: child.pid, cli, cwd });
+        return Response.json({
+          ok: true,
+          pid: child.pid,
+          cli,
+          cwd,
+          ...(provisioned ? { provisioned } : {}),
+        });
       } catch (e) {
         return new Response((e as Error).message, { status: 500 });
       }

package/ts/workspaceConfig.spec.ts

@@ -1,10 +1,13 @@
 import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { mkdtempSync, rmSync } from "fs";
+import { mkdtempSync, rmSync, writeFileSync } from "fs";
 import { homedir, tmpdir } from "os";
 import path from "path";
 import {
   expandTilde,
+  getProvisionAllowlist,
+  getProvisionRoot,
   getWorkspaceRoot,
+  isProvisionAllowed,
   resolveSpawnCwd,
   setWorkspaceRoot,
 } from "./workspaceConfig.ts";
@@ -20,6 +23,8 @@ describe("workspaceConfig", () => {
   afterEach(() => {
     if (original === undefined) delete process.env.AGENT_YES_HOME;
     else process.env.AGENT_YES_HOME = original;
+    delete process.env.CODEHOST_WS_ROOT;
+    delete process.env.CODEHOST_PROVISION_ALLOWLIST;
     rmSync(tmp, { recursive: true, force: true });
   });
 
@@ -71,4 +76,70 @@ describe("workspaceConfig", () => {
       expect(resolveSpawnCwd("a/b")).toBe(path.resolve("a/b"));
     });
   });
+
+  const writeConfig = (c: Record<string, unknown>) =>
+    writeFileSync(path.join(tmp, "config.json"), JSON.stringify(c));
+
+  describe("getProvisionRoot", () => {
+    it("is undefined when neither env nor config is set", () => {
+      expect(getProvisionRoot()).toBeUndefined();
+    });
+
+    it("returns the configured provisionRoot, resolved", () => {
+      writeConfig({ provisionRoot: "/code" });
+      expect(getProvisionRoot()).toBe(path.resolve("/code"));
+    });
+
+    it("env CODEHOST_WS_ROOT overrides the config and expands ~", () => {
+      writeConfig({ provisionRoot: "/code" });
+      process.env.CODEHOST_WS_ROOT = "~/ws";
+      expect(getProvisionRoot()).toBe(path.join(homedir(), "ws"));
+    });
+
+    it("ignores a blank configured value", () => {
+      writeConfig({ provisionRoot: "   " });
+      expect(getProvisionRoot()).toBeUndefined();
+    });
+  });
+
+  describe("getProvisionAllowlist", () => {
+    it("is empty when unset", () => {
+      expect(getProvisionAllowlist()).toEqual([]);
+    });
+
+    it("reads and normalizes the configured list (trim/lowercase/drop empties)", () => {
+      writeConfig({ provisionAllowlist: [" Snomiao ", "Acme/Repo", ""] });
+      expect(getProvisionAllowlist()).toEqual(["snomiao", "acme/repo"]);
+    });
+
+    it("env CODEHOST_PROVISION_ALLOWLIST (comma-separated) overrides config", () => {
+      writeConfig({ provisionAllowlist: ["snomiao"] });
+      process.env.CODEHOST_PROVISION_ALLOWLIST = "Foo, bar/baz ,";
+      expect(getProvisionAllowlist()).toEqual(["foo", "bar/baz"]);
+    });
+  });
+
+  describe("isProvisionAllowed", () => {
+    it("denies everything when the allowlist is empty (secure default)", () => {
+      expect(isProvisionAllowed("snomiao", "agent-yes")).toBe(false);
+    });
+
+    it("'*' allows any owner/repo", () => {
+      writeConfig({ provisionAllowlist: ["*"] });
+      expect(isProvisionAllowed("anyone", "anything")).toBe(true);
+    });
+
+    it("matches by owner case-insensitively and rejects others", () => {
+      writeConfig({ provisionAllowlist: ["snomiao"] });
+      expect(isProvisionAllowed("SNOMIAO", "x")).toBe(true);
+      expect(isProvisionAllowed("evil", "x")).toBe(false);
+    });
+
+    it("matches an exact owner/repo and an owner/* glob", () => {
+      writeConfig({ provisionAllowlist: ["acme/widget", "org/*"] });
+      expect(isProvisionAllowed("acme", "widget")).toBe(true);
+      expect(isProvisionAllowed("acme", "other")).toBe(false);
+      expect(isProvisionAllowed("org", "anything")).toBe(true);
+    });
+  });
 });

package/ts/workspaceConfig.ts

@@ -15,6 +15,10 @@ import { agentYesHome } from "./agentYesHome.ts";
 
 interface Config {
   workspace?: string;
+  /** Root for `from`-provisioned worktrees (`<root>/<owner>/<repo>/tree/<branch>`). */
+  provisionRoot?: string;
+  /** Owners/repos permitted for `from`-provisioning; empty = deny all. */
+  provisionAllowlist?: string[];
 }
 
 function configPath(): string {
@@ -43,6 +47,45 @@ export function getWorkspaceRoot(): string {
   return w && w.trim() ? w : homedir();
 }
 
+/**
+ * Root for `from`-provisioned worktrees, handed to codehost/provision so they
+ * land in `<root>/<owner>/<repo>/tree/<branch>`. Resolution order: env
+ * `CODEHOST_WS_ROOT` wins (ops override), then the configured `provisionRoot`,
+ * else undefined — letting codehost/provision fall back to its own `~/ws`
+ * default. Kept separate from `workspace` (the plain-cwd default), which may be a
+ * specific project dir rather than a root.
+ */
+export function getProvisionRoot(): string | undefined {
+  const env = process.env.CODEHOST_WS_ROOT?.trim();
+  if (env) return path.resolve(expandTilde(env));
+  const r = readConfig().provisionRoot;
+  return r && r.trim() ? path.resolve(expandTilde(r)) : undefined;
+}
+
+/**
+ * Owner/repo allowlist for `from`-provisioning. Provisioning clones a repo and
+ * runs its setup script (dependency installs + package lifecycle hooks = code
+ * execution on the host), so an **empty allowlist means DENY ALL** — a secure
+ * default the host opts out of by listing owners it trusts. Entries match
+ * `<owner>` (any repo of that owner), `<owner>/<repo>` (exact), or `*` (allow
+ * all — an explicit opt-in to the wide-open behavior). Env
+ * `CODEHOST_PROVISION_ALLOWLIST` (comma-separated) overrides the config.
+ */
+export function getProvisionAllowlist(): string[] {
+  const env = process.env.CODEHOST_PROVISION_ALLOWLIST?.trim();
+  const raw = env ? env.split(",") : (readConfig().provisionAllowlist ?? []);
+  return raw.map((s) => s.trim().toLowerCase()).filter(Boolean);
+}
+
+/** Whether `<owner>/<repo>` may be `from`-provisioned, per {@link getProvisionAllowlist}. */
+export function isProvisionAllowed(owner: string, repo: string): boolean {
+  const list = getProvisionAllowlist();
+  if (list.includes("*")) return true;
+  const o = owner.toLowerCase();
+  const full = `${owner}/${repo}`.toLowerCase();
+  return list.some((e) => e.replace(/\/\*$/, "") === o || e === full);
+}
+
 /** Persist the workspace root, tilde-expanded and resolved to an absolute path. */
 export function setWorkspaceRoot(dir: string): string {
   const abs = path.resolve(expandTilde(dir));

package/dist/SUPPORTED_CLIS-BUNhV-WM.js

@@ -1,8 +0,0 @@
-import "./ts-DKH7E-F6.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-BGsjdYf6.js";
-import "./pidStore-fqXqTKkh.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-BFZPtEsl.js";
-
-export { SUPPORTED_CLIS };

package/dist/workspaceConfig-B3ylOZAO.js

@@ -1,56 +0,0 @@
-import { t as agentYesHome } from "./agentYesHome-_eJa3DaX.js";
-import { mkdirSync, readFileSync, writeFileSync } from "fs";
-import { homedir } from "os";
-import path from "path";
-
-//#region ts/workspaceConfig.ts
-function configPath() {
-	return path.join(agentYesHome(), "config.json");
-}
-function readConfig() {
-	try {
-		return JSON.parse(readFileSync(configPath(), "utf-8"));
-	} catch {
-		return {};
-	}
-}
-/** Expand a leading `~` (`~` or `~/x`) to an absolute home-based path. */
-function expandTilde(p) {
-	const s = p.trim();
-	if (s === "~") return homedir();
-	if (s.startsWith("~/") || s.startsWith("~\\")) return path.join(homedir(), s.slice(2));
-	return s;
-}
-/** The configured workspace root (absolute), or the home dir if unset. */
-function getWorkspaceRoot() {
-	const w = readConfig().workspace;
-	return w && w.trim() ? w : homedir();
-}
-/** Persist the workspace root, tilde-expanded and resolved to an absolute path. */
-function setWorkspaceRoot(dir) {
-	const abs = path.resolve(expandTilde(dir));
-	const cfg = readConfig();
-	cfg.workspace = abs;
-	mkdirSync(agentYesHome(), { recursive: true });
-	writeFileSync(configPath(), JSON.stringify(cfg, null, 2));
-	return abs;
-}
-/**
-* Resolve a user-supplied spawn location to an absolute cwd:
-* - empty            → the workspace root
-* - a bare name      → `<workspace>/<name>` (so "myproject" lands under the root)
-* - `~`-prefixed     → home-based absolute
-* - anything with a path separator → resolved as-is
-*/
-function resolveSpawnCwd(input) {
-	const root = getWorkspaceRoot();
-	const v = (input ?? "").trim();
-	if (!v) return root;
-	if (v.startsWith("~")) return path.resolve(expandTilde(v));
-	if (v.includes("/") || v.includes("\\") || path.isAbsolute(v)) return path.resolve(v);
-	return path.join(root, v);
-}
-
-//#endregion
-export { resolveSpawnCwd as n, setWorkspaceRoot as r, getWorkspaceRoot as t };
-//# sourceMappingURL=workspaceConfig-B3ylOZAO.js.map