@agent-team-foundation/first-tree-hub 0.7.1 → 0.7.2

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { C as setConfigValue, S as serverConfigSchema, _ as loadAgents, b as resetConfigMeta, c as saveCredentials, f as agentConfigSchema, g as initConfig, h as getConfigValue, l as DEFAULT_CONFIG_DIR, n as ensureFreshAccessToken, o as resolveServerUrl, p as clientConfigSchema, r as ensureFreshAdminToken, s as saveAgentConfig, u as DEFAULT_DATA_DIR, v as readConfigFile, y as resetConfig } from "../bootstrap-CRDR6NwE.mjs";
-import { A as stopPostgres, C as checkServerReachable, F as SdkError, I as SessionRegistry, L as cleanWorkspaces, M as createOwner, P as FirstTreeHubSDK, S as checkServerHealth, T as printResults, _ as checkClientConfig, a as uninstallClientService, b as checkNodeVersion, c as promptAddAgent, d as loadOnboardState, f as onboardCheck, g as checkAgentConfigs, h as runMigrations, j as ClientRuntime, l as promptMissingFields, m as saveOnboardState, n as installClientService, o as startServer, p as onboardCreate, r as isServiceSupported, s as isInteractive, t as getClientServiceStatus, u as formatCheckReport, v as checkDatabase, w as checkWebSocket, x as checkServerConfig, y as checkDocker } from "../core-C05B8FzH.mjs";
+import { A as stopPostgres, C as checkServerReachable, F as SdkError, I as SessionRegistry, L as cleanWorkspaces, M as createOwner, P as FirstTreeHubSDK, S as checkServerHealth, T as printResults, _ as checkClientConfig, a as uninstallClientService, b as checkNodeVersion, c as promptAddAgent, d as loadOnboardState, f as onboardCheck, g as checkAgentConfigs, h as runMigrations, j as ClientRuntime, l as promptMissingFields, m as saveOnboardState, n as installClientService, o as startServer, p as onboardCreate, r as isServiceSupported, s as isInteractive, t as getClientServiceStatus, u as formatCheckReport, v as checkDatabase, w as checkWebSocket, x as checkServerConfig, y as checkDocker } from "../core-6-paFwyo.mjs";
 import { n as bindFeishuUser, t as bindFeishuBot } from "../feishu-CJ08ntOD.mjs";
 import { createRequire } from "node:module";
 import { Command } from "commander";

package/dist/{core-C05B8FzH.mjs → core-6-paFwyo.mjs}

@@ -1493,6 +1493,451 @@ echo "long message body" | first-tree-hub agent send <agentId>
 For content with quotes, \`$\`, backticks, or newlines, prefer stdin to avoid shell escaping issues.
 `;
 }
+const DEFAULT_CLONE_TIMEOUT_MS = 300 * 1e3;
+const FETCH_REFSPEC = "+refs/heads/*:refs/remotes/origin/*";
+const SESSION_BRANCH_PREFIX = "hub-session";
+function hashUrl(url) {
+	return createHash("sha256").update(url).digest("hex").slice(0, 32);
+}
+function shortHash(input) {
+	return createHash("sha256").update(input).digest("hex").slice(0, 8);
+}
+function deriveSessionBranchName(sessionKey, url) {
+	return `${SESSION_BRANCH_PREFIX}-${shortHash(sessionKey)}-${shortHash(url)}`;
+}
+/**
+* A value is SHA-like when it's a 7–40 character hex string. Used to decide
+* whether `ref` should be resolved via the remote namespace (branch name) or
+* used as-is (commit hash).
+*/
+function looksLikeCommitSha(ref) {
+	return /^[0-9a-f]{7,40}$/i.test(ref);
+}
+function createGitMirrorManager(opts) {
+	const mirrorsRoot = join(opts.dataDir, "git-mirrors");
+	const cloneTimeoutMs = opts.cloneTimeoutMs ?? Number(process.env.FIRST_TREE_HUB_GIT_CLONE_TIMEOUT_MS ?? DEFAULT_CLONE_TIMEOUT_MS);
+	const log = opts.log ?? (() => {});
+	const urlLocks = /* @__PURE__ */ new Map();
+	function withUrlLock(url, op) {
+		const key = hashUrl(url);
+		const next = (urlLocks.get(key) ?? Promise.resolve()).then(op, op);
+		urlLocks.set(key, next);
+		next.then(() => {
+			if (urlLocks.get(key) === next) urlLocks.delete(key);
+		}, () => {
+			if (urlLocks.get(key) === next) urlLocks.delete(key);
+		});
+		return next;
+	}
+	function mirrorDir(url) {
+		return join(mirrorsRoot, hashUrl(url));
+	}
+	async function git(args, cwd, timeoutMs, env) {
+		const start = Date.now();
+		return await new Promise((resolveExec, rejectExec) => {
+			const proc = spawn("git", args, {
+				cwd: cwd ?? void 0,
+				env: env ?? process.env,
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			let stdout = "";
+			let stderr = "";
+			proc.stdout.on("data", (d) => {
+				stdout += String(d);
+			});
+			proc.stderr.on("data", (d) => {
+				stderr += String(d);
+			});
+			const timer = setTimeout(() => {
+				proc.kill("SIGKILL");
+				rejectExec(new GitMirrorTimeoutError(`git ${args.join(" ")} timed out after ${timeoutMs}ms`));
+			}, timeoutMs);
+			proc.on("error", (err) => {
+				clearTimeout(timer);
+				rejectExec(err);
+			});
+			proc.on("close", (code) => {
+				clearTimeout(timer);
+				const elapsedMs = Date.now() - start;
+				if (code === 0) resolveExec({
+					stdout,
+					stderr,
+					elapsedMs
+				});
+				else rejectExec(new GitMirrorError(`git ${args.join(" ")} exited with code ${code}: ${stderr.slice(0, 1024)}`));
+			});
+		});
+	}
+	async function gitOk(args, cwd, timeoutMs) {
+		try {
+			await git(args, cwd, timeoutMs);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Bring the mirror's config to the invariant expected by this module:
+	* fetch refspec = `+refs/heads/*:refs/remotes/origin/*`, `remote.origin.mirror`
+	* absent, `refs/remotes/origin/HEAD` resolvable.
+	*
+	* Called from `ensureMirror` on every invocation — both the fresh-clone path
+	* (ensures our own bootstrap wrote the right values) and the pre-existing
+	* mirror path (repairs drift from the legacy `--mirror` config).
+	*/
+	async function assertMirrorConfig(mirrorPath, url) {
+		let migrated = false;
+		let currentFetch = "";
+		try {
+			const { stdout } = await git([
+				"config",
+				"--get-all",
+				"remote.origin.fetch"
+			], mirrorPath, 1e4);
+			currentFetch = stdout.trim();
+		} catch {
+			currentFetch = "";
+		}
+		if (currentFetch !== FETCH_REFSPEC) {
+			await git([
+				"config",
+				"--replace-all",
+				"remote.origin.fetch",
+				FETCH_REFSPEC
+			], mirrorPath, 1e4);
+			migrated = true;
+		}
+		if (await gitOk([
+			"config",
+			"--get",
+			"remote.origin.mirror"
+		], mirrorPath, 1e4)) {
+			await git([
+				"config",
+				"--unset-all",
+				"remote.origin.mirror"
+			], mirrorPath, 1e4);
+			migrated = true;
+		}
+		try {
+			const { stdout } = await git([
+				"config",
+				"--get",
+				"remote.origin.url"
+			], mirrorPath, 1e4);
+			if (stdout.trim() !== url) {
+				await git([
+					"config",
+					"--replace-all",
+					"remote.origin.url",
+					url
+				], mirrorPath, 1e4);
+				migrated = true;
+			}
+		} catch {
+			await git([
+				"remote",
+				"add",
+				"origin",
+				url
+			], mirrorPath, 1e4);
+			migrated = true;
+		}
+		if (migrated) {
+			await git([
+				"fetch",
+				"--prune",
+				"origin"
+			], mirrorPath, cloneTimeoutMs);
+			await gitOk([
+				"remote",
+				"set-head",
+				"origin",
+				"--auto"
+			], mirrorPath, 3e4);
+			log("mirrorConfigMigrated", { gitUrl: url });
+		}
+		return { migrated };
+	}
+	/**
+	* Bootstrap a fresh mirror at `mirrorPath`. Uses `git init --bare` +
+	* manual remote setup rather than `git clone --mirror` / `git clone --bare`,
+	* so we never transiently have the mirror configured to force-write
+	* `refs/heads/*` on fetch.
+	*/
+	async function bootstrapMirror(mirrorPath, url) {
+		mkdirSync(dirname(mirrorPath), { recursive: true });
+		await git([
+			"init",
+			"--bare",
+			mirrorPath
+		], null, cloneTimeoutMs);
+		await git([
+			"remote",
+			"add",
+			"origin",
+			url
+		], mirrorPath, 1e4);
+		await git([
+			"config",
+			"--replace-all",
+			"remote.origin.fetch",
+			FETCH_REFSPEC
+		], mirrorPath, 1e4);
+		await git([
+			"fetch",
+			"--prune",
+			"origin"
+		], mirrorPath, cloneTimeoutMs);
+		await gitOk([
+			"remote",
+			"set-head",
+			"origin",
+			"--auto"
+		], mirrorPath, 3e4);
+	}
+	async function branchExists(mirrorPath, branchName) {
+		return await gitOk([
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			`refs/heads/${branchName}`
+		], mirrorPath, 1e4);
+	}
+	/**
+	* Resolve the commit-ish to base a new session branch on.
+	*
+	* - explicit SHA → use as-is
+	* - explicit branch name → prefer `refs/remotes/origin/<ref>`, fall back to
+	*   a literal SHA resolution in case the caller handed us a short commit
+	* - `ref` absent → `refs/remotes/origin/HEAD`
+	*/
+	async function resolveBase(mirrorPath, ref) {
+		if (!ref) {
+			if (await gitOk([
+				"rev-parse",
+				"--verify",
+				"--quiet",
+				"refs/remotes/origin/HEAD"
+			], mirrorPath, 1e4)) return "refs/remotes/origin/HEAD";
+			throw new GitMirrorError("Cannot resolve default branch: refs/remotes/origin/HEAD is missing. Re-run with an explicit `ref`.");
+		}
+		if (looksLikeCommitSha(ref)) {
+			if (await gitOk([
+				"cat-file",
+				"-e",
+				ref
+			], mirrorPath, 1e4)) return ref;
+		}
+		const remoteRef = `refs/remotes/origin/${ref}`;
+		if (await gitOk([
+			"rev-parse",
+			"--verify",
+			"--quiet",
+			remoteRef
+		], mirrorPath, 1e4)) return remoteRef;
+		return ref;
+	}
+	return {
+		get mirrorsRoot() {
+			return mirrorsRoot;
+		},
+		ensureMirror(url) {
+			return withUrlLock(url, async () => {
+				mkdirSync(mirrorsRoot, { recursive: true });
+				const path = mirrorDir(url);
+				if (existsSync(join(path, "HEAD"))) {
+					const { migrated } = await assertMirrorConfig(path, url);
+					if (migrated) {}
+					return {
+						mirrorPath: path,
+						elapsedMs: 0,
+						cloned: false
+					};
+				}
+				const start = Date.now();
+				try {
+					await bootstrapMirror(path, url);
+					const elapsedMs = Date.now() - start;
+					log("ensureMirror", {
+						gitUrl: url,
+						elapsedMs,
+						cloned: true
+					});
+					return {
+						mirrorPath: path,
+						elapsedMs,
+						cloned: true
+					};
+				} catch (err) {
+					if (err instanceof GitMirrorTimeoutError) log("mirrorCloneTimeout", {
+						gitUrl: url,
+						timeoutMs: cloneTimeoutMs,
+						elapsedMs: cloneTimeoutMs
+					});
+					if (existsSync(path)) rmSync(path, {
+						recursive: true,
+						force: true
+					});
+					throw err;
+				}
+			});
+		},
+		fetchMirror(url) {
+			return withUrlLock(url, async () => {
+				const path = mirrorDir(url);
+				if (!existsSync(join(path, "HEAD"))) throw new GitMirrorError(`Cannot fetch — no mirror exists for "${url}"`);
+				try {
+					const { elapsedMs } = await git([
+						"fetch",
+						"--prune",
+						"origin"
+					], path, cloneTimeoutMs);
+					return { elapsedMs };
+				} catch (err) {
+					log("mirrorFetchFailed", {
+						gitUrl: url,
+						errorCode: err instanceof GitMirrorError ? "git-failed" : "unknown",
+						stderr: err instanceof Error ? err.message.slice(0, 1024) : String(err).slice(0, 1024)
+					});
+					throw err;
+				}
+			});
+		},
+		createWorktree({ url, ref, targetPath, sessionKey }) {
+			return withUrlLock(url, async () => {
+				const mirror = mirrorDir(url);
+				if (!existsSync(join(mirror, "HEAD"))) throw new GitMirrorError(`Cannot create worktree — no mirror exists for "${url}"`);
+				const absTarget = resolve(targetPath);
+				const branchName = deriveSessionBranchName(sessionKey, url);
+				if (existsSync(absTarget) && !isHubManagedWorktree(absTarget)) {
+					log("worktreeCreateConflict", {
+						gitUrl: url,
+						targetPath: absTarget,
+						occupantKind: classifyOccupant(absTarget)
+					});
+					throw new GitMirrorWorktreeConflictError(`Worktree target "${absTarget}" is already occupied by ${classifyOccupant(absTarget)} — aborting (D13)`);
+				}
+				const pathExists = existsSync(absTarget);
+				const hasBranch = await branchExists(mirror, branchName);
+				mkdirSync(dirname(absTarget), { recursive: true });
+				if (pathExists && hasBranch) {} else if (pathExists && !hasBranch) throw new GitMirrorError(`Worktree directory "${absTarget}" exists as a Hub worktree but the expected session branch "${branchName}" is missing in the mirror — manual cleanup required`);
+				else if (!pathExists && hasBranch) await git([
+					"worktree",
+					"add",
+					absTarget,
+					branchName
+				], mirror, cloneTimeoutMs);
+				else await git([
+					"worktree",
+					"add",
+					"-b",
+					branchName,
+					absTarget,
+					await resolveBase(mirror, ref)
+				], mirror, cloneTimeoutMs);
+				return {
+					worktreePath: absTarget,
+					headCommit: (await git(["rev-parse", "HEAD"], absTarget, 3e4)).stdout.trim(),
+					branchName
+				};
+			});
+		},
+		removeWorktree({ url, path, branchName }) {
+			return withUrlLock(url, async () => {
+				const absTarget = resolve(path);
+				const mirror = mirrorDir(url);
+				if (!isBareRepo(mirror)) {
+					if (existsSync(absTarget)) rmSync(absTarget, {
+						recursive: true,
+						force: true
+					});
+					return;
+				}
+				if (existsSync(absTarget)) await gitOk([
+					"worktree",
+					"remove",
+					"--force",
+					absTarget
+				], mirror, 3e4);
+				else await gitOk(["worktree", "prune"], mirror, 3e4);
+				if (existsSync(absTarget)) rmSync(absTarget, {
+					recursive: true,
+					force: true
+				});
+				if (await branchExists(mirror, branchName)) await gitOk([
+					"branch",
+					"-D",
+					branchName
+				], mirror, 1e4);
+			});
+		},
+		async gcMirrors(stillReferencedUrls) {
+			if (!existsSync(mirrorsRoot)) return { removed: [] };
+			const wantedHashes = new Set([...stillReferencedUrls].map(hashUrl));
+			const removed = [];
+			for (const entry of readdirSync(mirrorsRoot)) {
+				if (wantedHashes.has(entry)) continue;
+				const path = join(mirrorsRoot, entry);
+				if (!isBareRepo(path)) continue;
+				rmSync(path, {
+					recursive: true,
+					force: true
+				});
+				removed.push(entry);
+			}
+			return { removed };
+		}
+	};
+}
+function isBareRepo(p) {
+	return existsSync(join(p, "HEAD")) && existsSync(join(p, "objects"));
+}
+function isHubManagedWorktree(p) {
+	const gitMarker = join(p, ".git");
+	if (!existsSync(gitMarker)) return false;
+	try {
+		return statSync(gitMarker).isFile();
+	} catch {
+		return false;
+	}
+}
+function classifyOccupant(p) {
+	try {
+		const stat = statSync(p);
+		if (stat.isSymbolicLink()) return "symlink";
+		if (stat.isDirectory()) {
+			if (existsSync(join(p, ".git"))) return "git-repo";
+			return "directory";
+		}
+		if (stat.isFile()) return "file";
+		return "other";
+	} catch {
+		return "unknown";
+	}
+}
+var GitMirrorError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "GitMirrorError";
+	}
+};
+var GitMirrorTimeoutError = class extends GitMirrorError {
+	constructor(message) {
+		super(message);
+		this.name = "GitMirrorTimeoutError";
+	}
+};
+var GitMirrorWorktreeConflictError = class extends GitMirrorError {
+	constructor(message) {
+		super(message);
+		this.name = "GitMirrorWorktreeConflictError";
+	}
+};
 /**
 * InputController — push-based async iterable bridge.
 *
@@ -1741,7 +2186,7 @@ const createClaudeCodeHandler = (config) => {
 	let appliedConfigVersion = 0;
 	let appliedModel = "";
 	let appliedPayload = null;
-	/** Worktree paths materialised for this session — removed on shutdown. */
+	/** Worktrees materialised for this session — each entry removed on shutdown. */
 	const ownedWorktrees = [];
 	function toSDKUserMessage(message, sessionId) {
 		const rawContent = typeof message.content === "string" ? message.content : JSON.stringify(message.content);
@@ -1965,28 +2410,37 @@ const createClaudeCodeHandler = (config) => {
 			await gitMirrorManager.fetchMirror(repo.url);
 			if (existsSync(targetPath) && isHubWorktreeMarker(targetPath)) {
 				sessionCtx.log(`Git: reusing existing worktree at ${localPath}`);
-				ownedWorktrees.push(targetPath);
+				ownedWorktrees.push({
+					url: repo.url,
+					path: targetPath,
+					branchName: deriveSessionBranchName(sessionCtx.chatId, repo.url)
+				});
 				continue;
 			}
-			const { headCommit } = await gitMirrorManager.createWorktree({
+			const { headCommit, branchName } = await gitMirrorManager.createWorktree({
 				url: repo.url,
 				ref: repo.ref,
-				targetPath
+				targetPath,
+				sessionKey: sessionCtx.chatId
 			});
-			ownedWorktrees.push(targetPath);
-			sessionCtx.log(`Git: worktree at ${localPath} @ ${headCommit.slice(0, 7)}`);
+			ownedWorktrees.push({
+				url: repo.url,
+				path: targetPath,
+				branchName
+			});
+			sessionCtx.log(`Git: worktree at ${localPath} @ ${headCommit.slice(0, 7)} on ${branchName}`);
 		}
 	}
 	/** Tear down all worktrees this session owns; best-effort. */
 	async function cleanupGitWorktrees(sessionCtx) {
 		if (!gitMirrorManager) return;
 		while (ownedWorktrees.length > 0) {
-			const path = ownedWorktrees.pop();
-			if (!path) continue;
+			const entry = ownedWorktrees.pop();
+			if (!entry) continue;
 			try {
-				await gitMirrorManager.removeWorktree(path);
+				await gitMirrorManager.removeWorktree(entry);
 			} catch (err) {
-				sessionCtx.log(`Git: removeWorktree(${path}) failed — ${err instanceof Error ? err.message : String(err)}`);
+				sessionCtx.log(`Git: removeWorktree(${entry.path}) failed — ${err instanceof Error ? err.message : String(err)}`);
 			}
 		}
 	}
@@ -2200,226 +2654,6 @@ function createAgentConfigCache(opts) {
 		}
 	};
 }
-const DEFAULT_CLONE_TIMEOUT_MS = 300 * 1e3;
-function hashUrl(url) {
-	return createHash("sha256").update(url).digest("hex").slice(0, 32);
-}
-function createGitMirrorManager(opts) {
-	const mirrorsRoot = join(opts.dataDir, "git-mirrors");
-	const cloneTimeoutMs = opts.cloneTimeoutMs ?? Number(process.env.FIRST_TREE_HUB_GIT_CLONE_TIMEOUT_MS ?? DEFAULT_CLONE_TIMEOUT_MS);
-	const log = opts.log ?? (() => {});
-	function mirrorDir(url) {
-		return join(mirrorsRoot, hashUrl(url));
-	}
-	async function git(args, cwd, timeoutMs, env) {
-		const start = Date.now();
-		return await new Promise((resolveExec, rejectExec) => {
-			const proc = spawn("git", args, {
-				cwd: cwd ?? void 0,
-				env: env ?? process.env,
-				stdio: [
-					"ignore",
-					"pipe",
-					"pipe"
-				]
-			});
-			let stdout = "";
-			let stderr = "";
-			proc.stdout.on("data", (d) => {
-				stdout += String(d);
-			});
-			proc.stderr.on("data", (d) => {
-				stderr += String(d);
-			});
-			const timer = setTimeout(() => {
-				proc.kill("SIGKILL");
-				rejectExec(new GitMirrorTimeoutError(`git ${args.join(" ")} timed out after ${timeoutMs}ms`));
-			}, timeoutMs);
-			proc.on("error", (err) => {
-				clearTimeout(timer);
-				rejectExec(err);
-			});
-			proc.on("close", (code) => {
-				clearTimeout(timer);
-				const elapsedMs = Date.now() - start;
-				if (code === 0) resolveExec({
-					stdout,
-					stderr,
-					elapsedMs
-				});
-				else rejectExec(new GitMirrorError(`git ${args.join(" ")} exited with code ${code}: ${stderr.slice(0, 1024)}`));
-			});
-		});
-	}
-	return {
-		get mirrorsRoot() {
-			return mirrorsRoot;
-		},
-		async ensureMirror(url) {
-			mkdirSync(mirrorsRoot, { recursive: true });
-			const path = mirrorDir(url);
-			if (existsSync(join(path, "HEAD"))) return {
-				mirrorPath: path,
-				elapsedMs: 0,
-				cloned: false
-			};
-			try {
-				const { elapsedMs } = await git([
-					"clone",
-					"--mirror",
-					url,
-					path
-				], null, cloneTimeoutMs);
-				log("ensureMirror", {
-					gitUrl: url,
-					elapsedMs,
-					cloned: true
-				});
-				return {
-					mirrorPath: path,
-					elapsedMs,
-					cloned: true
-				};
-			} catch (err) {
-				if (err instanceof GitMirrorTimeoutError) log("mirrorCloneTimeout", {
-					gitUrl: url,
-					timeoutMs: cloneTimeoutMs,
-					elapsedMs: cloneTimeoutMs
-				});
-				if (existsSync(path)) rmSync(path, {
-					recursive: true,
-					force: true
-				});
-				throw err;
-			}
-		},
-		async fetchMirror(url) {
-			const path = mirrorDir(url);
-			if (!existsSync(join(path, "HEAD"))) throw new GitMirrorError(`Cannot fetch — no mirror exists for "${url}"`);
-			try {
-				const { elapsedMs } = await git(["fetch", "--prune"], path, cloneTimeoutMs);
-				return { elapsedMs };
-			} catch (err) {
-				log("mirrorFetchFailed", {
-					gitUrl: url,
-					errorCode: err instanceof GitMirrorError ? "git-failed" : "unknown",
-					stderr: err instanceof Error ? err.message.slice(0, 1024) : String(err).slice(0, 1024)
-				});
-				throw err;
-			}
-		},
-		async createWorktree({ url, ref, targetPath }) {
-			const mirror = mirrorDir(url);
-			if (!existsSync(join(mirror, "HEAD"))) throw new GitMirrorError(`Cannot create worktree — no mirror exists for "${url}"`);
-			const absTarget = resolve(targetPath);
-			if (existsSync(absTarget) && !isHubManagedWorktree(absTarget)) {
-				log("worktreeCreateConflict", {
-					gitUrl: url,
-					targetPath: absTarget,
-					occupantKind: classifyOccupant(absTarget)
-				});
-				throw new GitMirrorWorktreeConflictError(`Worktree target "${absTarget}" is already occupied by ${classifyOccupant(absTarget)} — aborting (D13)`);
-			}
-			mkdirSync(dirname(absTarget), { recursive: true });
-			const args = [
-				"worktree",
-				"add",
-				"--detach",
-				absTarget
-			];
-			if (ref) args.push(ref);
-			await git(args, mirror, cloneTimeoutMs);
-			return {
-				worktreePath: absTarget,
-				headCommit: (await git(["rev-parse", "HEAD"], absTarget, 3e4)).stdout.trim()
-			};
-		},
-		async removeWorktree(path) {
-			const absTarget = resolve(path);
-			if (!existsSync(absTarget)) return;
-			if (!existsSync(mirrorsRoot)) return;
-			let removed = false;
-			for (const entry of readdirSync(mirrorsRoot)) {
-				const mirror = join(mirrorsRoot, entry);
-				if (!isBareRepo(mirror)) continue;
-				try {
-					await git([
-						"worktree",
-						"remove",
-						"--force",
-						absTarget
-					], mirror, 3e4);
-					removed = true;
-					break;
-				} catch {}
-			}
-			if (!removed && existsSync(absTarget)) rmSync(absTarget, {
-				recursive: true,
-				force: true
-			});
-		},
-		async gcMirrors(stillReferencedUrls) {
-			if (!existsSync(mirrorsRoot)) return { removed: [] };
-			const wantedHashes = new Set([...stillReferencedUrls].map(hashUrl));
-			const removed = [];
-			for (const entry of readdirSync(mirrorsRoot)) {
-				if (wantedHashes.has(entry)) continue;
-				const path = join(mirrorsRoot, entry);
-				if (!isBareRepo(path)) continue;
-				rmSync(path, {
-					recursive: true,
-					force: true
-				});
-				removed.push(entry);
-			}
-			return { removed };
-		}
-	};
-}
-function isBareRepo(p) {
-	return existsSync(join(p, "HEAD")) && existsSync(join(p, "objects"));
-}
-function isHubManagedWorktree(p) {
-	const gitMarker = join(p, ".git");
-	if (!existsSync(gitMarker)) return false;
-	try {
-		return statSync(gitMarker).isFile();
-	} catch {
-		return false;
-	}
-}
-function classifyOccupant(p) {
-	try {
-		const stat = statSync(p);
-		if (stat.isSymbolicLink()) return "symlink";
-		if (stat.isDirectory()) {
-			if (existsSync(join(p, ".git"))) return "git-repo";
-			return "directory";
-		}
-		if (stat.isFile()) return "file";
-		return "other";
-	} catch {
-		return "unknown";
-	}
-}
-var GitMirrorError = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "GitMirrorError";
-	}
-};
-var GitMirrorTimeoutError = class extends GitMirrorError {
-	constructor(message) {
-		super(message);
-		this.name = "GitMirrorTimeoutError";
-	}
-};
-var GitMirrorWorktreeConflictError = class extends GitMirrorError {
-	constructor(message) {
-		super(message);
-		this.name = "GitMirrorWorktreeConflictError";
-	}
-};
 /**
 * Deduplicator — bounded set of recently seen IDs.
 *

package/dist/index.mjs

@@ -1,4 +1,4 @@
 import { a as resolveAccessToken, n as ensureFreshAccessToken, o as resolveServerUrl, r as ensureFreshAdminToken } from "./bootstrap-CRDR6NwE.mjs";
-import { A as stopPostgres, C as checkServerReachable, D as status, E as blank, F as SdkError, M as createOwner, N as hasUser, O as ensurePostgres, P as FirstTreeHubSDK, S as checkServerHealth, T as printResults, _ as checkClientConfig, a as uninstallClientService, b as checkNodeVersion, c as promptAddAgent, f as onboardCheck, g as checkAgentConfigs, h as runMigrations, i as resolveCliInvocation, j as ClientRuntime, k as isDockerAvailable, l as promptMissingFields, n as installClientService, o as startServer, p as onboardCreate, r as isServiceSupported, s as isInteractive, t as getClientServiceStatus, u as formatCheckReport, v as checkDatabase, w as checkWebSocket, x as checkServerConfig, y as checkDocker } from "./core-C05B8FzH.mjs";
+import { A as stopPostgres, C as checkServerReachable, D as status, E as blank, F as SdkError, M as createOwner, N as hasUser, O as ensurePostgres, P as FirstTreeHubSDK, S as checkServerHealth, T as printResults, _ as checkClientConfig, a as uninstallClientService, b as checkNodeVersion, c as promptAddAgent, f as onboardCheck, g as checkAgentConfigs, h as runMigrations, i as resolveCliInvocation, j as ClientRuntime, k as isDockerAvailable, l as promptMissingFields, n as installClientService, o as startServer, p as onboardCreate, r as isServiceSupported, s as isInteractive, t as getClientServiceStatus, u as formatCheckReport, v as checkDatabase, w as checkWebSocket, x as checkServerConfig, y as checkDocker } from "./core-6-paFwyo.mjs";
 import { n as bindFeishuUser, t as bindFeishuBot } from "./feishu-CJ08ntOD.mjs";
 export { ClientRuntime, FirstTreeHubSDK, SdkError, bindFeishuBot, bindFeishuUser, blank, checkAgentConfigs, checkClientConfig, checkDatabase, checkDocker, checkNodeVersion, checkServerConfig, checkServerHealth, checkServerReachable, checkWebSocket, createOwner, ensureFreshAccessToken, ensureFreshAdminToken, ensurePostgres, formatCheckReport, getClientServiceStatus, hasUser, installClientService, isDockerAvailable, isInteractive, isServiceSupported, onboardCheck, onboardCreate, printResults, promptAddAgent, promptMissingFields, resolveAccessToken, resolveCliInvocation, resolveServerUrl, runMigrations, startServer, status, stopPostgres, uninstallClientService };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-team-foundation/first-tree-hub",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "type": "module",
   "description": "First Tree Hub — unified CLI for server, client, and agent management",
   "exports": {