@overdeck/desktop 0.47.0 → 0.48.0

package/server/{workspace-manager-BPgTrG66.js → workspace-manager-Bem7ZBs9.js}

@@ -1,20 +1,25 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Br as CACHE_RULES_DIR, Fr as init_errors, Gn as init_projects, Qr as SYNC_SOURCES, Tr as FsError, Zr as SKILLS_DIR, f as loadConfigSync, jr as ProcessSpawnError, li as init_paths, t as init_config_yaml, zr as CACHE_AGENTS_DIR } from "./config-yaml-CxdwhAIA.js";
-import { a as PAN_DIRNAME, c as PAN_SESSIONS_FILENAME, i as PAN_CONTINUE_FILENAME, n as PAN_CONTEXT_FILENAME, s as PAN_FEEDBACK_DIRNAME } from "./types-Cm5ASJbq.js";
-import { t as init_pan_dir } from "./pan-dir-DMzF5wne.js";
-import { n as init_workspace_config, r as replacePlaceholdersSync, t as getDefaultWorkspaceConfigSync } from "./workspace-config-BdZM4PvZ.js";
-import { n as init_tunnel, r as removeTunnelIngress, t as addTunnelIngress } from "./tunnel-DUbUPElU.js";
-import { i as init_hume, n as createHumeConfig, r as deleteHumeConfig } from "./hume-DXNiu6nQ.js";
-import { a as renderDevcontainerSync, i as processTemplatesSync, n as createWorkspacePlaceholdersSync, o as sanitizeComposeFileSync, r as init_devcontainer_renderer, t as DEVCONTAINER_DIRNAME } from "./devcontainer-renderer-BUOIlfgD.js";
-import { n as init_docker, r as stopWorkspaceDockerPromise, t as getContainersReferencingWorkspacePathPromise } from "./docker-BJzlkqYB.js";
+import { Ar as FsError, Gr as CACHE_AGENTS_DIR, Kr as CACHE_RULES_DIR, Lr as ProcessSpawnError, Vr as init_errors, cn as init_projects, f as loadConfigSync, fn as listProjectsSync, hi as init_paths, ii as SYNC_SOURCES, ri as SKILLS_DIR, t as init_config_yaml } from "./config-yaml-BSCqwmX0.js";
+import { d as getOverdeckDatabaseSync, f as init_infra } from "./infra-CTrmVqc_.js";
+import { a as getWorkspaceForIssue, i as getWorkspaceById, n as getProjectByKey, o as init_resolver, r as getProjectByPath, s as listPinnedDocs, t as getMainWorkspace } from "./resolver-BvHd6RE4.js";
+import { i as init_paths$1, m as resolveWorkspaceMemoryRoot, r as ensureParentDir } from "./paths-BUuhi6jM.js";
+import { a as PAN_DIRNAME, c as PAN_SESSIONS_FILENAME, i as PAN_CONTINUE_FILENAME, n as PAN_CONTEXT_FILENAME, s as PAN_FEEDBACK_DIRNAME } from "./types-DzlUKiuf.js";
+import { t as init_pan_dir } from "./pan-dir-DhgKfO86.js";
+import { n as init_workspace_config, r as replacePlaceholdersSync, t as getDefaultWorkspaceConfigSync } from "./workspace-config-aUc2nIz6.js";
+import { n as init_tunnel, r as removeTunnelIngress, t as addTunnelIngress } from "./tunnel-CPf5M-Pc.js";
+import { i as init_hume, n as createHumeConfig, r as deleteHumeConfig } from "./hume-DrZEGpqc.js";
+import { r as unmirrorPin, t as init_state_mirror } from "./state-mirror-Cv_XgvT5.js";
+import { a as renderDevcontainerSync, i as processTemplatesSync, n as createWorkspacePlaceholdersSync, o as sanitizeComposeFileSync, r as init_devcontainer_renderer, t as DEVCONTAINER_DIRNAME } from "./devcontainer-renderer-B-o68Z5B.js";
+import { n as init_docker, r as stopWorkspaceDockerPromise, t as getContainersReferencingWorkspacePathPromise } from "./docker-meuLKLzV.js";
 import { join } from "node:path";
 import { Effect } from "effect";
 import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
 import { basename as basename$1, dirname as dirname$1, extname as extname$1, join as join$1, relative as relative$1, resolve as resolve$1 } from "path";
 import { homedir, platform } from "os";
 import { existsSync as existsSync$1, mkdirSync as mkdirSync$1, readdirSync as readdirSync$1, readlinkSync, renameSync as renameSync$1, statSync as statSync$1, symlinkSync as symlinkSync$1 } from "node:fs";
-import { createHash } from "crypto";
-import "fs/promises";
+import { createHash, randomUUID } from "crypto";
+import { readFile, rename, writeFile } from "fs/promises";
+import { randomUUID as randomUUID$1 } from "node:crypto";
 import { exec, execFile } from "child_process";
 import { promisify } from "util";
 //#region ../../lib/workspace-manager/migration.ts
@@ -589,6 +594,26 @@ function relocateVenvScripts(sourceVenv, destVenv) {
 		} catch {}
 	}
 }
+/**
+* Keep a generated hooks directory that lives inside the worktree out of
+* `git status`. With husky, `core.hooksPath` is `.husky/_` — a tracked-repo
+* path husky self-ignores by writing a `*` .gitignore into it on install.
+* `installPreRebaseHook` creates that directory itself in a fresh worktree,
+* long before `prepare: husky` ever runs, so without this the generated guard
+* lands as `?? .husky/_/pre-rebase` and every new workspace is born dirty —
+* which 409s the planning→work auto-handoff (PAN-3266).
+*
+* Directories under `.git/` need nothing: git never reports them.
+*/
+function ensureGeneratedHooksDirIsIgnored(targetPath, hooksDir) {
+	const relativeDir = relative$1(targetPath, hooksDir).replace(/\\/g, "/");
+	if (!relativeDir || relativeDir.startsWith("..") || relativeDir === ".git" || relativeDir.startsWith(".git/")) return;
+	const ignorePath = join$1(hooksDir, ".gitignore");
+	if (existsSync(ignorePath)) return;
+	try {
+		writeFileSync(ignorePath, "*\n", "utf-8");
+	} catch {}
+}
 /** Install the agent-only rebase guard in Git's configured hooks directory. */
 async function installPreRebaseHook(targetPath) {
 	const { stdout } = await execAsync$2("git rev-parse --git-path hooks", {
@@ -598,6 +623,7 @@ async function installPreRebaseHook(targetPath) {
 	const hooksDir = resolve$1(targetPath, stdout.trim());
 	const hookPath = join$1(hooksDir, "pre-rebase");
 	mkdirSync(hooksDir, { recursive: true });
+	ensureGeneratedHooksDirIsIgnored(targetPath, hooksDir);
 	const originalHookPath = `${hookPath}${PRE_REBASE_ORIGINAL_SUFFIX}`;
 	const existingHook = existsSync(hookPath) ? readFileSync(hookPath, "utf-8") : "";
 	if (!existingHook.includes(PRE_REBASE_HOOK_MARKER)) {
@@ -844,6 +870,172 @@ var init_worktree_ops = __esmMin((() => {
 	]);
 }));
 //#endregion
+//#region ../../lib/memory/identity-record.ts
+/**
+* Workspace identity mirror (PAN-1990, memory-paths-rekey).
+*
+* Memory storage is keyed by workspaceId (resolveWorkspaceMemoryRoot), which
+* is an opaque UUID with no human-readable trace back to the workspace it
+* belonged to if the overdeck.db row is ever lost. metadata.json at the
+* workspace's memory root is that trace: a best-effort recovery hint, not
+* canonical state. The workspaces table row remains the source of truth.
+*/
+function resolveWorkspaceIdentityPath(projectId, workspaceId) {
+	return join$1(resolveWorkspaceMemoryRoot(projectId, workspaceId), "metadata.json");
+}
+/** Write (or merge over) the identity fields at the workspace's memory-home metadata.json. */
+async function writeWorkspaceIdentity(row) {
+	const path = resolveWorkspaceIdentityPath(row.projectId, row.id);
+	await ensureParentDir(path);
+	const merged = {
+		...await readWorkspaceIdentity(path),
+		id: row.id,
+		projectId: row.projectId,
+		kind: row.kind,
+		name: row.name,
+		path: row.path,
+		branchName: row.branchName,
+		parentBranch: row.parentBranch,
+		issueId: row.issueId,
+		createdAt: row.createdAt
+	};
+	const tempPath = join$1(dirname$1(path), `.${randomUUID()}.tmp`);
+	await writeFile(tempPath, `${JSON.stringify(merged, null, 2)}\n`, "utf8");
+	await rename(tempPath, path);
+	return path;
+}
+/** Parse a workspace's metadata.json for rebuild. Returns null if missing or unreadable. */
+async function readWorkspaceIdentity(path) {
+	try {
+		const raw = await readFile(path, "utf8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+var init_identity_record = __esmMin((() => {
+	init_paths$1();
+}));
+//#endregion
+//#region ../../lib/workspaces/writer.ts
+/**
+* Workspaces/projects write door (PAN-1990).
+*
+* The ONLY module that INSERT/UPDATE/DELETEs the projects/workspaces/
+* project_targets/pinned_docs tables. See docs/PIPELINE-MEMBERSHIP.md's
+* two-doors tenet — every write to these tables goes through this writer.
+*
+* Identity-record mirroring into a workspace's memory-home metadata.json is a
+* best-effort recovery hint, not canonical state (the workspaces table row
+* remains the source of truth) — createWorkspace/archiveWorkspace are async
+* only to await that mirror write; the SQLite row write itself stays sync.
+*/
+/** Upsert a projects.yaml entry into the projects table, keyed by its yaml key. */
+function upsertProjectFromConfig(key, config) {
+	const db = getOverdeckDatabaseSync();
+	const now = Date.now();
+	if (getProjectByKey(key)) {
+		db.prepare(`UPDATE projects SET name = ?, primary_path = ? WHERE id = ?`).run(config.name, config.path, key);
+		return;
+	}
+	db.prepare(`
+    INSERT INTO projects (id, name, primary_path, created_at, last_accessed_at, is_system)
+    VALUES (?, ?, ?, ?, ?, 0)
+  `).run(key, config.name, config.path, now, now);
+}
+/** Create a workspace row. Generates a fresh UUID and enforces main-singleton per project. */
+async function createWorkspace$1(opts) {
+	const db = getOverdeckDatabaseSync();
+	if (opts.kind === "main" && getMainWorkspace(opts.projectId)) throw new Error(`Project ${opts.projectId} already has a main workspace`);
+	const id = opts.id ?? randomUUID$1();
+	const now = opts.createdAt ?? Date.now();
+	db.prepare(`
+    INSERT INTO workspaces (
+      id, project_id, kind, name, path, branch_name, parent_branch, parent_branch_guessed,
+      is_git_repository, issue_id, layout_config, is_favorite, is_archived, title,
+      created_at, last_accessed_at
+    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, 0, 0, ?, ?, ?)
+  `).run(id, opts.projectId, opts.kind, opts.name, opts.path, opts.branchName ?? null, opts.parentBranch ?? null, opts.parentBranchGuessed ? 1 : 0, opts.isGitRepository === false ? 0 : 1, opts.issueId ?? null, opts.title ?? null, now, now);
+	await writeWorkspaceIdentity({
+		id,
+		projectId: opts.projectId,
+		kind: opts.kind,
+		name: opts.name,
+		path: opts.path,
+		branchName: opts.branchName ?? null,
+		parentBranch: opts.parentBranch ?? null,
+		issueId: opts.issueId ?? null,
+		createdAt: now
+	}).catch(() => {});
+	return id;
+}
+function touchWorkspaceAccessed(id) {
+	getOverdeckDatabaseSync().prepare(`UPDATE workspaces SET last_accessed_at = ? WHERE id = ?`).run(Date.now(), id);
+}
+function updateWorkspaceLayout(id, layoutConfig) {
+	getOverdeckDatabaseSync().prepare(`UPDATE workspaces SET layout_config = ? WHERE id = ?`).run(layoutConfig, id);
+}
+function setWorkspaceFavorite(id, isFavorite) {
+	getOverdeckDatabaseSync().prepare(`UPDATE workspaces SET is_favorite = ? WHERE id = ?`).run(isFavorite ? 1 : 0, id);
+}
+async function archiveWorkspace(id) {
+	getOverdeckDatabaseSync().prepare(`UPDATE workspaces SET is_archived = 1 WHERE id = ?`).run(id);
+	const workspace = getWorkspaceById(id);
+	if (workspace) await writeWorkspaceIdentity({
+		id: workspace.id,
+		projectId: workspace.projectId,
+		kind: workspace.kind,
+		name: workspace.name,
+		path: workspace.path,
+		branchName: workspace.branchName,
+		parentBranch: workspace.parentBranch,
+		issueId: workspace.issueId,
+		createdAt: workspace.createdAt
+	}).catch(() => {});
+}
+function unarchiveWorkspace(id) {
+	getOverdeckDatabaseSync().prepare(`UPDATE workspaces SET is_archived = 0 WHERE id = ?`).run(id);
+}
+/**
+* Delete a non-main workspace row. Conversations attributed to it are
+* preserved with workspace_id set to NULL — never deleted. Workspace-scoped
+* pins are removed, including their committed overdeck-state mirror
+* descriptors (FR-10/FR-11 — the mirror is the durable representation, so a
+* pin row deleted here without unmirroring it would let a future recovery
+* from state resurrect a pin the workspace deletion was supposed to remove).
+* Project-scoped pins are untouched. Never touches JSONL transcripts or the
+* memory home (memory purge is a separate explicit flag on the CLI destroy
+* verb).
+*
+* Review fix (durability): the durable mirror is unmirrored FIRST, before
+* the SQLite rows are ever touched. If a state-door commit/push fails here,
+* the function throws and the workspace + pin rows are untouched — a caller
+* retry re-lists the same pins from the unharmed DB row and re-attempts.
+* Doing the DB delete first (the previous ordering) would forget the pin
+* list before the mirror cleanup could be retried, permanently stranding it.
+* unmirrorPin/removeMemoryStateMirror already no-op on an already-removed
+* target, so retrying an already-unmirrored pin is safe.
+*/
+async function deleteWorkspace(id) {
+	const db = getOverdeckDatabaseSync();
+	const workspace = getWorkspaceById(id);
+	if (!workspace) return;
+	if (workspace.kind === "main") throw new Error(`Cannot delete the main workspace for project ${workspace.projectId}`);
+	const workspacePins = listPinnedDocs("workspace", id);
+	await Promise.all(workspacePins.map((pin) => unmirrorPin(workspace.projectId, "workspace", id, pin.docPath)));
+	db.transaction(() => {
+		db.prepare(`UPDATE conversations SET workspace_id = NULL WHERE workspace_id = ?`).run(id);
+		db.prepare(`DELETE FROM pinned_docs WHERE scope = 'workspace' AND scope_id = ?`).run(id);
+		db.prepare(`DELETE FROM workspaces WHERE id = ?`).run(id);
+	})();
+}
+var init_writer = __esmMin((() => {
+	init_infra();
+	init_identity_record();
+	init_state_mirror();
+	init_resolver();
+}));
+//#endregion
 //#region ../../lib/workspace-manager/create.ts
 /**
 * PAN-2386: ensure a polyrepo scaffold workspace has a .gitignore that excludes
@@ -959,317 +1151,351 @@ async function createWorkspacePromise(options) {
 		result.steps.push("[DRY RUN] Would create workspace at: " + workspacePath);
 		return result;
 	}
-	let stagedMetadataPath = null;
-	if (existsSync(workspacePath)) {
-		stagedMetadataPath = stagePreWorktreeMetadataSync(workspacePath);
-		if (stagedMetadataPath) result.steps.push("Staged pre-worktree .pan metadata");
-		else {
-			result.success = false;
-			result.errors.push(`Workspace already exists at ${workspacePath}`);
-			return result;
+	const issueId = featureName.toUpperCase();
+	let createdWorkspaceRowId = null;
+	let worktreeCreated = false;
+	if (!getWorkspaceForIssue(issueId)) {
+		let project = getProjectByPath(projectConfig.path);
+		if (!project) {
+			const projectKey = listProjectsSync().find((p) => p.config.path === projectConfig.path)?.key;
+			if (!projectKey) {
+				result.success = false;
+				result.errors.push(`No projects.yaml entry found for path ${projectConfig.path}; cannot create workspace row for ${issueId}.`);
+				return result;
+			}
+			upsertProjectFromConfig(projectKey, projectConfig);
+			project = getProjectByPath(projectConfig.path);
 		}
+		createdWorkspaceRowId = await createWorkspace$1({
+			projectId: project.id,
+			kind: "issue",
+			name: featureFolder,
+			path: workspacePath,
+			branchName: `feature/${featureName}`,
+			issueId
+		});
 	}
-	const placeholders = createWorkspacePlaceholdersSync(projectConfig, featureName, workspacePath);
-	progress("Creating git worktree", `feature/${featureName}`);
-	if (workspaceConfig.type === "polyrepo" && workspaceConfig.repos) {
-		mkdirSync(workspacePath, { recursive: true });
-		result.steps.push("Created workspace directory");
-		const reposToCreate = workspaceConfig.progressive && workspaceConfig.always_include ? workspaceConfig.repos.filter((r) => workspaceConfig.always_include.includes(r.name)) : workspaceConfig.repos;
-		for (const repo of reposToCreate) {
-			const rawRepoPath = join$1(projectConfig.path, repo.path);
-			const repoPath = existsSync(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
-			const targetPath = join$1(workspacePath, repo.name);
-			if (repo.link_type === "symlink") try {
-				symlinkSync(repoPath, targetPath);
-				result.steps.push(`Created symlink for ${repo.name} (readonly, no feature branch)`);
-			} catch (symlinkErr) {
-				result.errors.push(`${repo.name}: ${symlinkErr.message}`);
+	const outcome = await (async () => {
+		let stagedMetadataPath = null;
+		if (existsSync(workspacePath)) {
+			stagedMetadataPath = stagePreWorktreeMetadataSync(workspacePath);
+			if (stagedMetadataPath) result.steps.push("Staged pre-worktree .pan metadata");
+			else {
 				result.success = false;
+				result.errors.push(`Workspace already exists at ${workspacePath}`);
+				return result;
 			}
-			else {
-				const branchName = `${repo.branch_prefix || "feature/"}${featureName}`;
-				const defaultBranch = repo.default_branch || workspaceConfig.default_branch || "main";
-				const worktreeResult = await createWorktree(repoPath, targetPath, branchName, defaultBranch);
-				if (worktreeResult.success) result.steps.push(`Created worktree for ${repo.name}: ${branchName} (from ${defaultBranch})`);
-				else {
-					result.errors.push(`${repo.name}: ${worktreeResult.message}`);
+		}
+		const placeholders = createWorkspacePlaceholdersSync(projectConfig, featureName, workspacePath);
+		progress("Creating git worktree", `feature/${featureName}`);
+		if (workspaceConfig.type === "polyrepo" && workspaceConfig.repos) {
+			mkdirSync(workspacePath, { recursive: true });
+			result.steps.push("Created workspace directory");
+			worktreeCreated = true;
+			const reposToCreate = workspaceConfig.progressive && workspaceConfig.always_include ? workspaceConfig.repos.filter((r) => workspaceConfig.always_include.includes(r.name)) : workspaceConfig.repos;
+			for (const repo of reposToCreate) {
+				const rawRepoPath = join$1(projectConfig.path, repo.path);
+				const repoPath = existsSync(rawRepoPath) ? realpathSync(rawRepoPath) : rawRepoPath;
+				const targetPath = join$1(workspacePath, repo.name);
+				if (repo.link_type === "symlink") try {
+					symlinkSync(repoPath, targetPath);
+					result.steps.push(`Created symlink for ${repo.name} (readonly, no feature branch)`);
+				} catch (symlinkErr) {
+					result.errors.push(`${repo.name}: ${symlinkErr.message}`);
 					result.success = false;
 				}
+				else {
+					const branchName = `${repo.branch_prefix || "feature/"}${featureName}`;
+					const defaultBranch = repo.default_branch || workspaceConfig.default_branch || "main";
+					const worktreeResult = await createWorktree(repoPath, targetPath, branchName, defaultBranch);
+					if (worktreeResult.success) result.steps.push(`Created worktree for ${repo.name}: ${branchName} (from ${defaultBranch})`);
+					else {
+						result.errors.push(`${repo.name}: ${worktreeResult.message}`);
+						result.success = false;
+					}
+				}
+			}
+		} else {
+			const branchName = `feature/${featureName}`;
+			const defaultBranch = workspaceConfig.default_branch || "main";
+			const worktreeResult = await createWorktree(projectConfig.path, workspacePath, branchName, defaultBranch);
+			if (worktreeResult.success) result.steps.push(`Created worktree: ${branchName} (from ${defaultBranch})`);
+			else {
+				result.errors.push(worktreeResult.message);
+				result.success = false;
 			}
 		}
-	} else {
-		const branchName = `feature/${featureName}`;
-		const defaultBranch = workspaceConfig.default_branch || "main";
-		const worktreeResult = await createWorktree(projectConfig.path, workspacePath, branchName, defaultBranch);
-		if (worktreeResult.success) result.steps.push(`Created worktree: ${branchName} (from ${defaultBranch})`);
-		else {
-			result.errors.push(worktreeResult.message);
-			result.success = false;
+		if (!result.success) {
+			restorePreWorktreeMetadataSync(stagedMetadataPath, workspacePath);
+			progress("Creating git worktree", "Worktree creation failed", "error");
+			return result;
 		}
-	}
-	if (!result.success) {
+		worktreeCreated = true;
 		restorePreWorktreeMetadataSync(stagedMetadataPath, workspacePath);
-		progress("Creating git worktree", "Worktree creation failed", "error");
-		return result;
-	}
-	restorePreWorktreeMetadataSync(stagedMetadataPath, workspacePath);
-	if (workspaceConfig.type === "polyrepo" && workspaceConfig.repos) try {
-		const { added, removed } = ensurePolyrepoWorkspaceGitignoreSync(workspacePath, workspaceConfig.repos);
-		if (added.length > 0 || removed.length > 0) {
-			result.steps.push(`Updated .gitignore for polyrepo workspace (${added.length} added, ${removed.length} removed)`);
-			const commitMessage = await commitPolyrepoWorkspaceGitignoreAsync(workspacePath);
-			if (commitMessage) result.steps.push(commitMessage);
+		if (workspaceConfig.type === "polyrepo" && workspaceConfig.repos) try {
+			const { added, removed } = ensurePolyrepoWorkspaceGitignoreSync(workspacePath, workspaceConfig.repos);
+			if (added.length > 0 || removed.length > 0) {
+				result.steps.push(`Updated .gitignore for polyrepo workspace (${added.length} added, ${removed.length} removed)`);
+				const commitMessage = await commitPolyrepoWorkspaceGitignoreAsync(workspacePath);
+				if (commitMessage) result.steps.push(commitMessage);
+			}
+		} catch (gitignoreErr) {
+			result.steps.push(`Warning: could not create workspace .gitignore: ${gitignoreErr.message}`);
 		}
-	} catch (gitignoreErr) {
-		result.steps.push(`Warning: could not create workspace .gitignore: ${gitignoreErr.message}`);
-	}
-	progress("Creating git worktree", "Worktree ready", "complete");
-	const resolvedWorkspace = resolve$1(workspacePath);
-	const resolvedPanDir = resolve$1(resolvedWorkspace, PAN_DIRNAME);
-	if (resolvedWorkspace.match(/\/workspaces\/feature-[a-z0-9-]+$/) && existsSync(join$1(resolvedWorkspace, ".git"))) {
-		if (resolvedPanDir === join$1(resolvedWorkspace, ".pan") && existsSync(resolvedPanDir)) {
-			for (const filePath of [
-				join$1(resolvedPanDir, PAN_CONTINUE_FILENAME),
-				join$1(resolvedPanDir, PAN_SESSIONS_FILENAME),
-				join$1(resolvedPanDir, PAN_CONTEXT_FILENAME)
-			]) if (existsSync(filePath)) unlinkSync(filePath);
-			const feedbackDir = join$1(resolvedPanDir, PAN_FEEDBACK_DIRNAME);
-			if (existsSync(feedbackDir)) rmSync(feedbackDir, {
-				recursive: true,
-				force: true
-			});
+		progress("Creating git worktree", "Worktree ready", "complete");
+		const resolvedWorkspace = resolve$1(workspacePath);
+		const resolvedPanDir = resolve$1(resolvedWorkspace, PAN_DIRNAME);
+		if (resolvedWorkspace.match(/\/workspaces\/feature-[a-z0-9-]+$/) && existsSync(join$1(resolvedWorkspace, ".git"))) {
+			if (resolvedPanDir === join$1(resolvedWorkspace, ".pan") && existsSync(resolvedPanDir)) {
+				for (const filePath of [
+					join$1(resolvedPanDir, PAN_CONTINUE_FILENAME),
+					join$1(resolvedPanDir, PAN_SESSIONS_FILENAME),
+					join$1(resolvedPanDir, PAN_CONTEXT_FILENAME)
+				]) if (existsSync(filePath)) unlinkSync(filePath);
+				const feedbackDir = join$1(resolvedPanDir, PAN_FEEDBACK_DIRNAME);
+				if (existsSync(feedbackDir)) rmSync(feedbackDir, {
+					recursive: true,
+					force: true
+				});
+			}
+			result.steps.push("Cleared stale workspace-local .pan runtime state");
 		}
-		result.steps.push("Cleared stale workspace-local .pan runtime state");
-	}
-	try {
-		ensurePanGitignoreSync(projectConfig.path);
-		result.steps.push("Verified runtime-only Overdeck and Claude Code sync paths are in .gitignore");
-	} catch (gitignoreErr) {
-		result.steps.push(`Warning: could not update .gitignore: ${gitignoreErr.message}`);
-	}
-	const devcontainerDir = join$1(workspacePath, ".devcontainer");
-	if (existsSync(devcontainerDir)) {
-		const composeFiles = readdirSync(devcontainerDir).filter((f) => f.includes("compose") && (f.endsWith(".yml") || f.endsWith(".yaml")));
-		for (const composeFile of composeFiles) sanitizeComposeFileSync(join$1(devcontainerDir, composeFile));
-		if (composeFiles.length > 0) result.steps.push(`Sanitized ${composeFiles.length} compose file(s) for platform compatibility`);
-	}
-	progress("Installing dependencies", projectConfig.package_manager || "detecting...");
-	const pkgManager = projectConfig.package_manager || (existsSync(join$1(workspacePath, "bun.lock")) ? "bun" : "npm");
-	const staleModulesDirs = [join$1(workspacePath, "node_modules"), ...(projectConfig.workspace_packages ?? []).map((p) => join$1(workspacePath, p.path, "node_modules"))];
-	for (const dir of staleModulesDirs) if (existsSync(dir)) await execAsync$1(`rm -rf "${dir}"`);
-	const installCmd = pkgManager === "bun" ? "bun install" : `${pkgManager} install`;
-	try {
-		await execAsync$1(installCmd, {
-			cwd: workspacePath,
-			encoding: "utf-8"
-		});
-		result.steps.push(`Installed dependencies (${pkgManager})`);
-		progress("Installing dependencies", `${pkgManager} — done`, "complete");
-	} catch (installErr) {
-		const msg = `Dependency install failed (${pkgManager}): ${installErr.message?.slice(0, 200)}`;
-		result.errors.push(msg);
-		progress("Installing dependencies", "Failed — workspace creation aborted", "complete");
-		return result;
-	}
-	const hookTargets = workspaceConfig.type === "polyrepo" && workspaceConfig.repos ? workspaceConfig.repos.filter((repo) => repo.link_type !== "symlink").map((repo) => join$1(workspacePath, repo.name)).filter((path) => existsSync(join$1(path, ".git"))) : [workspacePath];
-	try {
-		for (const hookTarget of hookTargets) await installPreRebaseHook(hookTarget);
-	} catch (hookErr) {
-		result.errors.push(`Pre-rebase guard install failed: ${hookErr.message?.slice(0, 200)}`);
-		return result;
-	}
-	const workspacePackages = projectConfig.workspace_packages;
-	if (workspacePackages && workspacePackages.length > 0) {
-		progress("Building workspace packages", workspacePackages.map((p) => p.path).join(", "));
-		for (const pkg of workspacePackages) try {
-			await execAsync$1(pkg.build_command, {
-				cwd: join$1(workspacePath, pkg.path),
+		try {
+			ensurePanGitignoreSync(projectConfig.path);
+			result.steps.push("Verified runtime-only Overdeck and Claude Code sync paths are in .gitignore");
+		} catch (gitignoreErr) {
+			result.steps.push(`Warning: could not update .gitignore: ${gitignoreErr.message}`);
+		}
+		const devcontainerDir = join$1(workspacePath, ".devcontainer");
+		if (existsSync(devcontainerDir)) {
+			const composeFiles = readdirSync(devcontainerDir).filter((f) => f.includes("compose") && (f.endsWith(".yml") || f.endsWith(".yaml")));
+			for (const composeFile of composeFiles) sanitizeComposeFileSync(join$1(devcontainerDir, composeFile));
+			if (composeFiles.length > 0) result.steps.push(`Sanitized ${composeFiles.length} compose file(s) for platform compatibility`);
+		}
+		progress("Installing dependencies", projectConfig.package_manager || "detecting...");
+		const pkgManager = projectConfig.package_manager || (existsSync(join$1(workspacePath, "bun.lock")) ? "bun" : "npm");
+		const staleModulesDirs = [join$1(workspacePath, "node_modules"), ...(projectConfig.workspace_packages ?? []).map((p) => join$1(workspacePath, p.path, "node_modules"))];
+		for (const dir of staleModulesDirs) if (existsSync(dir)) await execAsync$1(`rm -rf "${dir}"`);
+		const installCmd = pkgManager === "bun" ? "bun install" : `${pkgManager} install`;
+		try {
+			await execAsync$1(installCmd, {
+				cwd: workspacePath,
 				encoding: "utf-8"
 			});
-			result.steps.push(`Built workspace package: ${pkg.path}`);
-		} catch (buildErr) {
-			const msg = `Workspace package build failed (${pkg.path}): ${buildErr.message?.slice(0, 200)}`;
+			result.steps.push(`Installed dependencies (${pkgManager})`);
+			progress("Installing dependencies", `${pkgManager} — done`, "complete");
+		} catch (installErr) {
+			const msg = `Dependency install failed (${pkgManager}): ${installErr.message?.slice(0, 200)}`;
 			result.errors.push(msg);
-			progress("Building workspace packages", `Failed on ${pkg.path} — workspace creation aborted`, "complete");
+			progress("Installing dependencies", "Failed — workspace creation aborted", "complete");
 			return result;
 		}
-		progress("Building workspace packages", "Packages built", "complete");
-	}
-	try {
-		await execAsync$1("python3 --version");
-		const venvPath = join$1(workspacePath, ".venv");
-		const tldrBin = join$1(venvPath, "bin", "tldr");
-		if (existsSync(join$1(projectConfig.path, ".venv", "bin", "tldr"))) {
-			const mainVenvPath = join$1(projectConfig.path, ".venv");
-			await execAsync$1(`cp -a "${mainVenvPath}" "${venvPath}"`);
-			relocateVenvScripts(mainVenvPath, venvPath);
-			result.steps.push("Copied Python venv from main branch (shebangs relocated)");
-		} else {
-			await execAsync$1(`python3 -m venv "${venvPath}"`, { cwd: workspacePath });
-			await execAsync$1(`"${join$1(venvPath, "bin", "pip")}" install llm-tldr`, {
-				cwd: workspacePath,
-				timeout: 12e4
-			});
-			result.steps.push("Created Python venv and installed llm-tldr");
-			const patchScript = join$1(projectConfig.path, "scripts", "patches", "llm-tldr-tsx-support.py");
-			if (existsSync(patchScript)) {
-				await execAsync$1(`python3 "${patchScript}" "${venvPath}"`);
-				result.steps.push("Applied llm-tldr .tsx/.jsx patch");
+		const hookTargets = workspaceConfig.type === "polyrepo" && workspaceConfig.repos ? workspaceConfig.repos.filter((repo) => repo.link_type !== "symlink").map((repo) => join$1(workspacePath, repo.name)).filter((path) => existsSync(join$1(path, ".git"))) : [workspacePath];
+		try {
+			for (const hookTarget of hookTargets) await installPreRebaseHook(hookTarget);
+		} catch (hookErr) {
+			result.errors.push(`Pre-rebase guard install failed: ${hookErr.message?.slice(0, 200)}`);
+			return result;
+		}
+		const workspacePackages = projectConfig.workspace_packages;
+		if (workspacePackages && workspacePackages.length > 0) {
+			progress("Building workspace packages", workspacePackages.map((p) => p.path).join(", "));
+			for (const pkg of workspacePackages) try {
+				await execAsync$1(pkg.build_command, {
+					cwd: join$1(workspacePath, pkg.path),
+					encoding: "utf-8"
+				});
+				result.steps.push(`Built workspace package: ${pkg.path}`);
+			} catch (buildErr) {
+				const msg = `Workspace package build failed (${pkg.path}): ${buildErr.message?.slice(0, 200)}`;
+				result.errors.push(msg);
+				progress("Building workspace packages", `Failed on ${pkg.path} — workspace creation aborted`, "complete");
+				return result;
 			}
+			progress("Building workspace packages", "Packages built", "complete");
 		}
-		if (!existsSync(tldrBin)) result.steps.push("TLDR setup incomplete: tldr binary not found after venv creation");
-		else {
-			const mainTldrDir = join$1(projectConfig.path, ".tldr");
-			const workspaceTldrDir = join$1(workspacePath, ".tldr");
-			if (existsSync(mainTldrDir)) {
-				await execAsync$1(`cp -r "${mainTldrDir}" "${workspaceTldrDir}"`);
-				result.steps.push("Copied TLDR index from main branch");
+		try {
+			await execAsync$1("python3 --version");
+			const venvPath = join$1(workspacePath, ".venv");
+			const tldrBin = join$1(venvPath, "bin", "tldr");
+			if (existsSync(join$1(projectConfig.path, ".venv", "bin", "tldr"))) {
+				const mainVenvPath = join$1(projectConfig.path, ".venv");
+				await execAsync$1(`cp -a "${mainVenvPath}" "${venvPath}"`);
+				relocateVenvScripts(mainVenvPath, venvPath);
+				result.steps.push("Copied Python venv from main branch (shebangs relocated)");
+			} else {
+				await execAsync$1(`python3 -m venv "${venvPath}"`, { cwd: workspacePath });
+				await execAsync$1(`"${join$1(venvPath, "bin", "pip")}" install llm-tldr`, {
+					cwd: workspacePath,
+					timeout: 12e4
+				});
+				result.steps.push("Created Python venv and installed llm-tldr");
+				const patchScript = join$1(projectConfig.path, "scripts", "patches", "llm-tldr-tsx-support.py");
+				if (existsSync(patchScript)) {
+					await execAsync$1(`python3 "${patchScript}" "${venvPath}"`);
+					result.steps.push("Applied llm-tldr .tsx/.jsx patch");
+				}
+			}
+			if (!existsSync(tldrBin)) result.steps.push("TLDR setup incomplete: tldr binary not found after venv creation");
+			else {
+				const mainTldrDir = join$1(projectConfig.path, ".tldr");
+				const workspaceTldrDir = join$1(workspacePath, ".tldr");
+				if (existsSync(mainTldrDir)) {
+					await execAsync$1(`cp -r "${mainTldrDir}" "${workspaceTldrDir}"`);
+					result.steps.push("Copied TLDR index from main branch");
+				}
+				const { getTldrDaemonServiceSync } = await import("./tldr-daemon-B1Jhrtc8.js");
+				const tldrService = getTldrDaemonServiceSync(workspacePath, venvPath);
+				await tldrService.start(true);
+				result.steps.push("Started TLDR daemon");
+				try {
+					await tldrService.warm(true);
+					result.steps.push("TLDR index warm initiated (background)");
+				} catch {}
+			}
+		} catch (error) {
+			if (error.message?.includes("python3")) result.steps.push("Skipped TLDR setup (python3 not available)");
+			else {
+				console.warn(`⚠ TLDR setup failed: ${error.message}`);
+				result.steps.push(`TLDR setup failed: ${error.message}`);
 			}
-			const { getTldrDaemonServiceSync } = await import("./tldr-daemon-CvWXBhX1.js");
-			const tldrService = getTldrDaemonServiceSync(workspacePath, venvPath);
-			await tldrService.start(true);
-			result.steps.push("Started TLDR daemon");
-			try {
-				await tldrService.warm(true);
-				result.steps.push("TLDR index warm initiated (background)");
-			} catch {}
 		}
-	} catch (error) {
-		if (error.message?.includes("python3")) result.steps.push("Skipped TLDR setup (python3 not available)");
-		else {
-			console.warn(`⚠ TLDR setup failed: ${error.message}`);
-			result.steps.push(`TLDR setup failed: ${error.message}`);
+		if (workspaceConfig.dns) {
+			const dnsMethod = workspaceConfig.dns.sync_method || "wsl2hosts";
+			for (const entryPattern of workspaceConfig.dns.entries) {
+				const hostname = replacePlaceholdersSync(entryPattern, placeholders);
+				if (addDnsEntry(dnsMethod, hostname)) result.steps.push(`Added DNS entry: ${hostname} (${dnsMethod})`);
+			}
+			if (dnsMethod === "wsl2hosts") {
+				if (await syncDnsToWindows()) result.steps.push("Synced DNS to Windows hosts file");
+			}
 		}
-	}
-	if (workspaceConfig.dns) {
-		const dnsMethod = workspaceConfig.dns.sync_method || "wsl2hosts";
-		for (const entryPattern of workspaceConfig.dns.entries) {
-			const hostname = replacePlaceholdersSync(entryPattern, placeholders);
-			if (addDnsEntry(dnsMethod, hostname)) result.steps.push(`Added DNS entry: ${hostname} (${dnsMethod})`);
+		if (workspaceConfig.ports) for (const [portName, portConfig] of Object.entries(workspaceConfig.ports)) {
+			const portFile = join$1(projectConfig.path, `.${portName}-ports`);
+			try {
+				const port = assignPort(portFile, featureFolder, portConfig.range);
+				result.steps.push(`Assigned ${portName} port: ${port}`);
+				placeholders[`${portName.toUpperCase()}_PORT`] = String(port);
+			} catch (error) {
+				result.errors.push(`Failed to assign ${portName} port: ${error}`);
+			}
 		}
-		if (dnsMethod === "wsl2hosts") {
-			if (await syncDnsToWindows()) result.steps.push("Synced DNS to Windows hosts file");
+		progress("Installing skills & templates", "Overdeck skills, agents, rules");
+		const mergeResult = mergeSkillsIntoWorkspaceSync(workspacePath);
+		const mergeTotal = mergeResult.added.length + mergeResult.updated.length;
+		if (mergeTotal > 0) result.steps.push(`Installed ${mergeTotal} Overdeck files (${mergeResult.added.length} new, ${mergeResult.updated.length} updated)`);
+		const panMergeResult = mergePanSkillsIntoWorkspaceSync(projectConfig.path, workspacePath);
+		if (panMergeResult.added.length > 0) result.steps.push(`Installed ${panMergeResult.added.length} project-local skill file(s) from .pan/skills/ (${panMergeResult.overlayed.join(", ")})`);
+		if (workspaceConfig.agent?.template_dir) {
+			const templateDir = join$1(projectConfig.path, workspaceConfig.agent.template_dir);
+			const templateSteps = processTemplatesSync(templateDir, workspacePath, placeholders, workspaceConfig.agent.templates);
+			result.steps.push(...templateSteps);
+			const dirsToSync = workspaceConfig.agent.copy_dirs || workspaceConfig.agent.symlinks;
+			if (dirsToSync) {
+				const copySteps = copyProjectTemplateDirs(templateDir, workspacePath, dirsToSync, placeholders);
+				result.steps.push(...copySteps);
+			}
 		}
-	}
-	if (workspaceConfig.ports) for (const [portName, portConfig] of Object.entries(workspaceConfig.ports)) {
-		const portFile = join$1(projectConfig.path, `.${portName}-ports`);
-		try {
-			const port = assignPort(portFile, featureFolder, portConfig.range);
-			result.steps.push(`Assigned ${portName} port: ${port}`);
-			placeholders[`${portName.toUpperCase()}_PORT`] = String(port);
-		} catch (error) {
-			result.errors.push(`Failed to assign ${portName} port: ${error}`);
+		if (workspaceConfig.env?.template) {
+			const envContent = replacePlaceholdersSync(workspaceConfig.env.template, placeholders);
+			writeFileSync(join$1(workspacePath, ".env"), envContent);
+			result.steps.push("Created .env file");
 		}
-	}
-	progress("Installing skills & templates", "Overdeck skills, agents, rules");
-	const mergeResult = mergeSkillsIntoWorkspaceSync(workspacePath);
-	const mergeTotal = mergeResult.added.length + mergeResult.updated.length;
-	if (mergeTotal > 0) result.steps.push(`Installed ${mergeTotal} Overdeck files (${mergeResult.added.length} new, ${mergeResult.updated.length} updated)`);
-	const panMergeResult = mergePanSkillsIntoWorkspaceSync(projectConfig.path, workspacePath);
-	if (panMergeResult.added.length > 0) result.steps.push(`Installed ${panMergeResult.added.length} project-local skill file(s) from .pan/skills/ (${panMergeResult.overlayed.join(", ")})`);
-	if (workspaceConfig.agent?.template_dir) {
-		const templateDir = join$1(projectConfig.path, workspaceConfig.agent.template_dir);
-		const templateSteps = processTemplatesSync(templateDir, workspacePath, placeholders, workspaceConfig.agent.templates);
-		result.steps.push(...templateSteps);
-		const dirsToSync = workspaceConfig.agent.copy_dirs || workspaceConfig.agent.symlinks;
-		if (dirsToSync) {
-			const copySteps = copyProjectTemplateDirs(templateDir, workspacePath, dirsToSync, placeholders);
-			result.steps.push(...copySteps);
+		if (workspaceConfig.docker?.compose_template) try {
+			const renderResult = renderDevcontainerSync({
+				workspacePath,
+				projectConfig,
+				featureName
+			});
+			result.steps.push(...renderResult.steps);
+			for (const warning of renderResult.warnings) result.errors.push(warning);
+		} catch (err) {
+			result.errors.push(`Failed to render .devcontainer/: ${err.message ?? err}`);
 		}
-	}
-	if (workspaceConfig.env?.template) {
-		const envContent = replacePlaceholdersSync(workspaceConfig.env.template, placeholders);
-		writeFileSync(join$1(workspacePath, ".env"), envContent);
-		result.steps.push("Created .env file");
-	}
-	if (workspaceConfig.docker?.compose_template) try {
-		const renderResult = renderDevcontainerSync({
-			workspacePath,
-			projectConfig,
-			featureName
-		});
-		result.steps.push(...renderResult.steps);
-		for (const warning of renderResult.warnings) result.errors.push(warning);
-	} catch (err) {
-		result.errors.push(`Failed to render .devcontainer/: ${err.message ?? err}`);
-	}
-	if (workspaceConfig.tunnel) {
-		const tunnelResult = await Effect.runPromise(addTunnelIngress(workspaceConfig.tunnel, placeholders));
-		result.steps.push(...tunnelResult.steps);
-		if (!tunnelResult.success) result.errors.push("Tunnel setup had failures (see steps for details)");
-	}
-	if (workspaceConfig.hume) {
-		const humeResult = await Effect.runPromise(createHumeConfig(workspaceConfig.hume, placeholders));
-		result.steps.push(...humeResult.steps);
-		if (humeResult.configId) {
-			writeFileSync(join$1(workspacePath, ".hume-config"), `HUME_CONFIG_ID=${humeResult.configId}\nVITE_HUME_CONFIG_ID=${humeResult.configId}\n`);
-			result.steps.push("Wrote .hume-config with Hume EVI config ID");
+		if (workspaceConfig.tunnel) {
+			const tunnelResult = await Effect.runPromise(addTunnelIngress(workspaceConfig.tunnel, placeholders));
+			result.steps.push(...tunnelResult.steps);
+			if (!tunnelResult.success) result.errors.push("Tunnel setup had failures (see steps for details)");
 		}
-		if (!humeResult.success) result.errors.push("Hume EVI config setup had failures (see steps for details)");
-	}
-	progress("Installing skills & templates", "Skills and templates ready", "complete");
-	if (startDocker) {
-		progress("Starting Docker containers", "Building and starting services");
-		if (workspaceConfig.docker?.traefik) {
-			const traefikPath = join$1(homedir(), ".overdeck", "traefik", "docker-compose.yml");
-			if (existsSync(traefikPath)) try {
-				await execAsync$1(`docker compose -f "${traefikPath}" up -d`, { cwd: join$1(homedir(), ".overdeck", "traefik") });
-				result.steps.push("Started Traefik");
-			} catch (error) {
-				const msg = error?.message || String(error);
-				if (msg.includes("port is already allocated") || msg.includes("address already in use")) result.steps.push("Traefik already running (port in use)");
-				else result.errors.push(`Failed to start Traefik: ${error}`);
+		if (workspaceConfig.hume) {
+			const humeResult = await Effect.runPromise(createHumeConfig(workspaceConfig.hume, placeholders));
+			result.steps.push(...humeResult.steps);
+			if (humeResult.configId) {
+				writeFileSync(join$1(workspacePath, ".hume-config"), `HUME_CONFIG_ID=${humeResult.configId}\nVITE_HUME_CONFIG_ID=${humeResult.configId}\n`);
+				result.steps.push("Wrote .hume-config with Hume EVI config ID");
 			}
+			if (!humeResult.success) result.errors.push("Hume EVI config setup had failures (see steps for details)");
 		}
-		const composeLocations = [
-			join$1(workspacePath, "docker-compose.yml"),
-			join$1(workspacePath, "docker-compose.yaml"),
-			join$1(workspacePath, ".devcontainer", "docker-compose.yml"),
-			join$1(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml")
-		];
-		for (const composePath of composeLocations) if (existsSync(composePath)) {
-			try {
-				await execAsync$1(`docker compose -f "${composePath}" up -d --build`, {
-					cwd: dirname$1(composePath),
-					timeout: 3e5
-				});
-				result.steps.push(`Started containers from ${basename$1(composePath)}`);
-			} catch (error) {
-				result.errors.push(`Failed to start containers: ${error}`);
+		progress("Installing skills & templates", "Skills and templates ready", "complete");
+		if (startDocker) {
+			progress("Starting Docker containers", "Building and starting services");
+			if (workspaceConfig.docker?.traefik) {
+				const traefikPath = join$1(homedir(), ".overdeck", "traefik", "docker-compose.yml");
+				if (existsSync(traefikPath)) try {
+					await execAsync$1(`docker compose -f "${traefikPath}" up -d`, { cwd: join$1(homedir(), ".overdeck", "traefik") });
+					result.steps.push("Started Traefik");
+				} catch (error) {
+					const msg = error?.message || String(error);
+					if (msg.includes("port is already allocated") || msg.includes("address already in use")) result.steps.push("Traefik already running (port in use)");
+					else result.errors.push(`Failed to start Traefik: ${error}`);
+				}
+			}
+			const composeLocations = [
+				join$1(workspacePath, "docker-compose.yml"),
+				join$1(workspacePath, "docker-compose.yaml"),
+				join$1(workspacePath, ".devcontainer", "docker-compose.yml"),
+				join$1(workspacePath, ".devcontainer", "docker-compose.devcontainer.yml")
+			];
+			for (const composePath of composeLocations) if (existsSync(composePath)) {
+				try {
+					await execAsync$1(`docker compose -f "${composePath}" up -d --build`, {
+						cwd: dirname$1(composePath),
+						timeout: 3e5
+					});
+					result.steps.push(`Started containers from ${basename$1(composePath)}`);
+				} catch (error) {
+					result.errors.push(`Failed to start containers: ${error}`);
+				}
+				break;
 			}
-			break;
 		}
+		if (startDocker) progress("Starting Docker containers", "Containers running", "complete");
+		try {
+			preTrustDirectorySync(workspacePath);
+			result.steps.push("Pre-trusted workspace in Claude Code");
+		} catch {}
+		try {
+			const { determineCavemanVariant, injectCavemanSettings } = await import("./workspace-Cn9ywfSW.js");
+			const cavemanConfig = loadConfigSync().config.caveman;
+			const variant = determineCavemanVariant(cavemanConfig);
+			await Effect.runPromise(injectCavemanSettings(workspacePath, variant));
+			if (variant === "enabled") result.steps.push("Injected caveman compression hooks into .claude/settings.json");
+			else if (variant === "disabled") result.steps.push("Caveman A/B test: assigned disabled variant for this workspace");
+		} catch (cavemanErr) {
+			result.steps.push(`Caveman setup skipped: ${cavemanErr instanceof Error ? cavemanErr.message : String(cavemanErr)}`);
+		}
+		try {
+			const settingsResult = copyOverdeckSettingsToWorkspaceSync(workspacePath);
+			if (settingsResult.copied.length > 0) result.steps.push(`Copied Overdeck settings into workspace (${settingsResult.copied.length} file(s))`);
+		} catch (settingsErr) {
+			result.steps.push(`Overdeck settings copy skipped: ${settingsErr instanceof Error ? settingsErr.message : String(settingsErr)}`);
+		}
+		try {
+			const { injectMemoryHookSettings } = await import("./workspace-Cn9ywfSW.js");
+			await injectMemoryHookSettings(workspacePath);
+			result.steps.push("Injected memory hooks into .claude/settings.json");
+		} catch (memoryHookErr) {
+			result.steps.push(`Memory hook setup skipped: ${memoryHookErr instanceof Error ? memoryHookErr.message : String(memoryHookErr)}`);
+		}
+		result.success = result.errors.length === 0;
+		return result;
+	})();
+	if (!outcome.success && createdWorkspaceRowId && !worktreeCreated) try {
+		await deleteWorkspace(createdWorkspaceRowId);
+	} catch (err) {
+		outcome.errors.push(`Also failed to compensate the pre-created workspace row: ${err instanceof Error ? err.message : String(err)}`);
 	}
-	if (startDocker) progress("Starting Docker containers", "Containers running", "complete");
-	try {
-		preTrustDirectorySync(workspacePath);
-		result.steps.push("Pre-trusted workspace in Claude Code");
-	} catch {}
-	try {
-		const { determineCavemanVariant, injectCavemanSettings } = await import("./workspace-COWvdibH.js");
-		const cavemanConfig = loadConfigSync().config.caveman;
-		const variant = determineCavemanVariant(cavemanConfig);
-		await Effect.runPromise(injectCavemanSettings(workspacePath, variant));
-		if (variant === "enabled") result.steps.push("Injected caveman compression hooks into .claude/settings.json");
-		else if (variant === "disabled") result.steps.push("Caveman A/B test: assigned disabled variant for this workspace");
-	} catch (cavemanErr) {
-		result.steps.push(`Caveman setup skipped: ${cavemanErr instanceof Error ? cavemanErr.message : String(cavemanErr)}`);
-	}
-	try {
-		const settingsResult = copyOverdeckSettingsToWorkspaceSync(workspacePath);
-		if (settingsResult.copied.length > 0) result.steps.push(`Copied Overdeck settings into workspace (${settingsResult.copied.length} file(s))`);
-	} catch (settingsErr) {
-		result.steps.push(`Overdeck settings copy skipped: ${settingsErr instanceof Error ? settingsErr.message : String(settingsErr)}`);
-	}
-	try {
-		const { injectMemoryHookSettings } = await import("./workspace-COWvdibH.js");
-		await injectMemoryHookSettings(workspacePath);
-		result.steps.push("Injected memory hooks into .claude/settings.json");
-	} catch (memoryHookErr) {
-		result.steps.push(`Memory hook setup skipped: ${memoryHookErr instanceof Error ? memoryHookErr.message : String(memoryHookErr)}`);
-	}
-	result.success = result.errors.length === 0;
-	return result;
+	return outcome;
 }
 var execAsync$1;
 var init_create = __esmMin((() => {
@@ -1282,6 +1508,9 @@ var init_create = __esmMin((() => {
 	init_pan_dir();
 	init_migration();
 	init_worktree_ops();
+	init_resolver();
+	init_writer();
+	init_projects();
 	init_devcontainer_renderer();
 	execAsync$1 = promisify(exec);
 }));
@@ -1347,7 +1576,7 @@ async function removeWorkspacePromise(options) {
 	}
 	const venvPath = join$1(workspacePath, ".venv");
 	if (existsSync(venvPath)) try {
-		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-CvWXBhX1.js");
+		const { getTldrDaemonServiceSync } = await import("./tldr-daemon-B1Jhrtc8.js");
 		await getTldrDaemonServiceSync(workspacePath, venvPath).stop();
 		result.steps.push("Stopped TLDR daemon");
 	} catch (error) {
@@ -1467,6 +1696,6 @@ var init_workspace_manager = __esmMin((() => {
 	});
 }));
 //#endregion
-export { removeWorkspace as a, installGitHooksInDir as c, relocateVenvScripts as d, detectPlatform as f, ensurePanGitignoreSync as h, preTrustDirectory as i, installPreRebaseHook as l, copyOverdeckSettingsToWorkspaceSync as m, getContainersReferencingWorkspacePath as n, stopWorkspaceDocker as o, init_platform as p, init_workspace_manager as r, init_git_hooks as s, createWorkspace as t, preTrustDirectorySync as u };
+export { detectPlatform as C, ensurePanGitignoreSync as E, relocateVenvScripts as S, copyOverdeckSettingsToWorkspaceSync as T, init_identity_record as _, removeWorkspace as a, installPreRebaseHook as b, installGitHooksInDir as c, init_writer as d, setWorkspaceFavorite as f, upsertProjectFromConfig as g, updateWorkspaceLayout as h, preTrustDirectory as i, archiveWorkspace as l, unarchiveWorkspace as m, getContainersReferencingWorkspacePath as n, stopWorkspaceDocker as o, touchWorkspaceAccessed as p, init_workspace_manager as r, init_git_hooks as s, createWorkspace as t, createWorkspace$1 as u, readWorkspaceIdentity as v, init_platform as w, preTrustDirectorySync as x, writeWorkspaceIdentity as y };
 
-//# sourceMappingURL=workspace-manager-BPgTrG66.js.map
+//# sourceMappingURL=workspace-manager-Bem7ZBs9.js.map