claude-yes 1.148.0 → 1.149.1

package/dist/SUPPORTED_CLIS-DhVolHXQ.js

@@ -0,0 +1,8 @@
+import "./ts-C21nFgXQ.js";
+import "./logger-CDIsZ-Pp.js";
+import "./versionChecker-C-JJk14E.js";
+import "./pidStore-fqXqTKkh.js";
+import "./globalPidIndex-DlmmJlO8.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DyQjQODe.js";
+
+export { SUPPORTED_CLIS };

package/dist/{SUPPORTED_CLIS-CmsPbgMe.js → SUPPORTED_CLIS-DyQjQODe.js}

@@ -1,8 +1,8 @@
-import { t as CLIS_CONFIG } from "./ts-CaCRPaos.js";
+import { t as CLIS_CONFIG } from "./ts-C21nFgXQ.js";
 
 //#region ts/SUPPORTED_CLIS.ts
 const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG);
 
 //#endregion
 export { SUPPORTED_CLIS as t };
-//# sourceMappingURL=SUPPORTED_CLIS-CmsPbgMe.js.map
+//# sourceMappingURL=SUPPORTED_CLIS-DyQjQODe.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-DfO37H1R.js";
+import { i as versionString, n as displayVersion, r as getInstalledPackage, t as checkAndAutoUpdate } from "./versionChecker-C-JJk14E.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-BQ2tu-y9.js");
+	const { isSubcommand, runSubcommand, cmdHelp } = await import("./subcommands-Bv7xJq9E.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-DpHVL8Mi.js");
+		const { SUPPORTED_CLIS } = await import("./SUPPORTED_CLIS-DhVolHXQ.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-CaCRPaos.js";
+import { a as removeControlCharacters, i as AgentContext, n as agentYes, r as config, t as CLIS_CONFIG } from "./ts-C21nFgXQ.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-DfO37H1R.js";
+import "./versionChecker-C-JJk14E.js";
 import "./pidStore-fqXqTKkh.js";
 import "./globalPidIndex-DlmmJlO8.js";
 

package/dist/{schedule-DkTLO7No.js → schedule-BJk96cOy.js}

@@ -1,10 +1,10 @@
-import "./ts-CaCRPaos.js";
+import "./ts-C21nFgXQ.js";
 import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-DfO37H1R.js";
+import "./versionChecker-C-JJk14E.js";
 import "./pidStore-fqXqTKkh.js";
 import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CmsPbgMe.js";
-import { n as resolveSpawnCwd } from "./workspaceConfig-B3ylOZAO.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DyQjQODe.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-DkTLO7No.js.map
+//# sourceMappingURL=schedule-BJk96cOy.js.map

package/dist/{serve-DQK6u2KS.js → serve-CaIDZfhy.js}

@@ -1,15 +1,16 @@
-import "./ts-CaCRPaos.js";
+import "./ts-C21nFgXQ.js";
 import "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-DfO37H1R.js";
+import { r as getInstalledPackage } from "./versionChecker-C-JJk14E.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-CmsPbgMe.js";
+import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-DyQjQODe.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-Df_SjmLN.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-OyK7Y447.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-DQK6u2KS.js.map
+//# sourceMappingURL=serve-CaIDZfhy.js.map

package/dist/{setup-6R_yJsKX.js → setup-B15dHEd1.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-DQK6u2KS.js");
+	const { cmdServe } = await import("./serve-CaIDZfhy.js");
 	return cmdServe([
 		"install",
 		"--share",
@@ -42,4 +42,4 @@ async function cmdSetup(rest) {
 
 //#endregion
 export { cmdSetup };
-//# sourceMappingURL=setup-6R_yJsKX.js.map
+//# sourceMappingURL=setup-B15dHEd1.js.map

package/dist/{subcommands-BQ2tu-y9.js → subcommands-Bv7xJq9E.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-Df_SjmLN.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-OyK7Y447.js";
 
 export { cmdHelp, isSubcommand, runSubcommand };

package/dist/{subcommands-Df_SjmLN.js → subcommands-OyK7Y447.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-DQK6u2KS.js");
+				const { cmdServe } = await import("./serve-CaIDZfhy.js");
 				return cmdServe(rest);
 			}
 			case "setup": {
-				const { cmdSetup } = await import("./setup-6R_yJsKX.js");
+				const { cmdSetup } = await import("./setup-B15dHEd1.js");
 				return cmdSetup(rest);
 			}
 			case "schedule": {
-				const { cmdSchedule } = await import("./schedule-DkTLO7No.js");
+				const { cmdSchedule } = await import("./schedule-BJk96cOy.js");
 				return cmdSchedule(rest);
 			}
 			case "remote": {
@@ -2381,7 +2381,7 @@ async function cmdStatus(rest) {
 		cwdScope: typeof argv.cwd === "string" ? path.resolve(argv.cwd) : null
 	};
 	const keyword = argv._[0] !== void 0 ? String(argv._[0]) : void 0;
-	if (!keyword) throw new Error("usage: ay status <keyword> [--watch | --wait | --wait-idle] [--timeout=Ns]");
+	if (!keyword) throw new Error("usage: ay status <keyword> [--watch | --wait | --wait-idle] [--timeout=Ns] [--cwd=DIR] [--latest]");
 	{
 		const remote = await resolveRemoteSpec(keyword);
 		if (remote) return runRemoteStatus(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-Df_SjmLN.js.map
+//# sourceMappingURL=subcommands-OyK7Y447.js.map

package/dist/{ts-CaCRPaos.js → ts-C21nFgXQ.js}

@@ -1,5 +1,5 @@
 import { n as logger, t as addTransport } from "./logger-CDIsZ-Pp.js";
-import { r as getInstalledPackage } from "./versionChecker-DfO37H1R.js";
+import { r as getInstalledPackage } from "./versionChecker-C-JJk14E.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-CaCRPaos.js.map
+//# sourceMappingURL=ts-C21nFgXQ.js.map

package/dist/{versionChecker-DfO37H1R.js → versionChecker-C-JJk14E.js}

@@ -7,7 +7,7 @@ import { fileURLToPath } from "url";
 
 //#region package.json
 var name = "claude-yes";
-var version = "1.148.0";
+var version = "1.149.1";
 
 //#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-DfO37H1R.js.map
+//# sourceMappingURL=versionChecker-C-JJk14E.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

@@ -4334,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,
         });
@@ -4385,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>
@@ -4401,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,
         };
@@ -4409,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.148.0",
+  "version": "1.149.1",
   "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/subcommands.ts

@@ -2911,7 +2911,9 @@ async function cmdStatus(rest: string[]): Promise<number> {
   const keyword = argv._[0] !== undefined ? String(argv._[0]) : undefined;
 
   if (!keyword)
-    throw new Error("usage: ay status <keyword> [--watch | --wait | --wait-idle] [--timeout=Ns]");
+    throw new Error(
+      "usage: ay status <keyword> [--watch | --wait | --wait-idle] [--timeout=Ns] [--cwd=DIR] [--latest]",
+    );
 
   {
     const remote = await resolveRemoteSpec(keyword);

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-DpHVL8Mi.js

@@ -1,8 +0,0 @@
-import "./ts-CaCRPaos.js";
-import "./logger-CDIsZ-Pp.js";
-import "./versionChecker-DfO37H1R.js";
-import "./pidStore-fqXqTKkh.js";
-import "./globalPidIndex-DlmmJlO8.js";
-import { t as SUPPORTED_CLIS } from "./SUPPORTED_CLIS-CmsPbgMe.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