@overdeck/desktop 0.45.21 → 0.45.22

package/server/{state-home-DixkE-up.js → state-home-CONQvZR0.js}

@@ -1,5 +1,5 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Zn as resolveInfraRepo, bn as projectKey, cn as STATE_BRANCH_PATHS, dn as init_state_plane, ei as getOverdeckHome, ti as init_paths, yn as init_project_key, zn as init_projects } from "./config-yaml-Ciyp2mYe.js";
+import { Cn as projectKey, Hn as init_projects, Sn as init_project_key, dn as STATE_BRANCH_PATHS, er as resolveInfraRepo, ii as init_paths, mn as init_state_plane, ri as getOverdeckHome } from "./config-yaml-ig8Nwtiw.js";
 import { dirname, join } from "node:path";
 import { existsSync } from "node:fs";
 import { mkdir, rm } from "node:fs/promises";
@@ -14,13 +14,15 @@ import { promisify } from "node:util";
 * An unmarked branch is an in-progress migration and continues using legacy
 * project-root state paths.
 */
-async function git(repoPath, args) {
+async function git(repoPath, args, signal) {
+	signal?.throwIfAborted();
 	const { stdout } = await execFileAsync("git", args, {
 		cwd: repoPath,
 		encoding: "utf8",
 		maxBuffer: 16 * 1024 * 1024,
 		timeout: 15e3,
-		killSignal: "SIGTERM"
+		killSignal: "SIGTERM",
+		signal
 	});
 	return stdout.trim();
 }
@@ -38,27 +40,28 @@ function parseMigrationCompleteMarker(value) {
 	if (!Number.isInteger(marker.version) || (marker.version ?? 0) < 1) return null;
 	return marker;
 }
-async function remoteStateTip(repoPath) {
+async function remoteStateTip(repoPath, signal) {
 	const sha = (await git(repoPath, [
 		"ls-remote",
 		"--heads",
 		"origin",
 		`refs/heads/${STATE_BRANCH}`
-	])).split(/\s+/)[0];
+	], signal)).split(/\s+/)[0];
 	return isSha(sha) ? sha : null;
 }
-async function markerAtRemoteTip(repoPath, tip) {
+async function markerAtRemoteTip(repoPath, tip, signal) {
 	await git(repoPath, [
 		"fetch",
 		"--quiet",
 		"origin",
 		`refs/heads/${STATE_BRANCH}:refs/remotes/origin/${STATE_BRANCH}`
-	]);
-	if (await git(repoPath, ["rev-parse", `refs/remotes/origin/overdeck-state`]) !== tip) return null;
+	], signal);
+	if (await git(repoPath, ["rev-parse", `refs/remotes/origin/overdeck-state`], signal) !== tip) return null;
 	let raw;
 	try {
-		raw = await git(repoPath, ["show", `${tip}:${MIGRATION_COMPLETE_MARKER}`]);
+		raw = await git(repoPath, ["show", `${tip}:${MIGRATION_COMPLETE_MARKER}`], signal);
 	} catch {
+		signal?.throwIfAborted();
 		return null;
 	}
 	let marker;
@@ -73,14 +76,18 @@ async function markerAtRemoteTip(repoPath, tip) {
 		"--is-ancestor",
 		marker.stateBranchSha,
 		tip
-	]).then(() => true).catch(() => false) ? marker : null;
+	], signal).then(() => true).catch(() => {
+		signal?.throwIfAborted();
+		return false;
+	}) ? marker : null;
 }
-async function inspectStateMigration(project) {
+async function inspectStateMigration(project, options = {}) {
 	const { repoPath } = resolveInfraRepo(project);
 	let tip;
 	try {
-		tip = await remoteStateTip(repoPath);
+		tip = await remoteStateTip(repoPath, options.signal);
 	} catch {
+		options.signal?.throwIfAborted();
 		return {
 			migrated: false,
 			migrationInProgress: false,
@@ -93,7 +100,7 @@ async function inspectStateMigration(project) {
 		migrationInProgress: tip !== null && !cached.migrated,
 		remoteTip: tip
 	};
-	const migrated = tip !== null && await markerAtRemoteTip(repoPath, tip) !== null;
+	const migrated = tip !== null && await markerAtRemoteTip(repoPath, tip, options.signal) !== null;
 	migrationCache.set(repoPath, {
 		remoteTip: tip,
 		migrated
@@ -112,14 +119,18 @@ async function findRecreatedLegacyStatePaths(project) {
 	const legacyStateRoot = project.path;
 	return STATE_BRANCH_PATHS.map((statePath) => join(legacyStateRoot, ".pan", statePath.slice(0, -1))).filter(existsSync);
 }
-async function addStateWorktree(repoPath, path) {
+async function addStateWorktree(repoPath, path, signal) {
+	signal?.throwIfAborted();
 	await mkdir(dirname(path), { recursive: true });
 	await git(repoPath, await git(repoPath, [
 		"show-ref",
 		"--verify",
 		"--quiet",
 		`refs/heads/overdeck-state`
-	]).then(() => true, () => false) ? [
+	], signal).then(() => true).catch(() => {
+		signal?.throwIfAborted();
+		return false;
+	}) ? [
 		"worktree",
 		"add",
 		path,
@@ -132,10 +143,10 @@ async function addStateWorktree(repoPath, path) {
 		STATE_BRANCH,
 		path,
 		`origin/${STATE_BRANCH}`
-	]);
+	], signal);
 }
 async function ensureStateWorktree(project, options = {}) {
-	const migration = await inspectStateMigration(project);
+	const migration = await inspectStateMigration(project, options);
 	const path = stateWorktreePath(project, options);
 	if (!migration.migrated) return {
 		status: "legacy",
@@ -143,7 +154,7 @@ async function ensureStateWorktree(project, options = {}) {
 	};
 	const { repoPath } = resolveInfraRepo(project);
 	if (!existsSync(path)) {
-		await addStateWorktree(repoPath, path);
+		await addStateWorktree(repoPath, path, options.signal);
 		return {
 			status: "created",
 			path
@@ -151,8 +162,9 @@ async function ensureStateWorktree(project, options = {}) {
 	}
 	let branch;
 	try {
-		branch = await git(path, ["branch", "--show-current"]);
+		branch = await git(path, ["branch", "--show-current"], options.signal);
 	} catch (error) {
+		options.signal?.throwIfAborted();
 		return {
 			status: "error",
 			path,
@@ -164,7 +176,7 @@ async function ensureStateWorktree(project, options = {}) {
 		path
 	};
 	try {
-		if (await git(path, ["status", "--porcelain"])) return {
+		if (await git(path, ["status", "--porcelain"], options.signal)) return {
 			status: "dirty",
 			path,
 			detail: "state worktree has uncommitted changes; refusing destructive repair"
@@ -173,17 +185,18 @@ async function ensureStateWorktree(project, options = {}) {
 			"worktree",
 			"remove",
 			path
-		]);
+		], options.signal);
 		await rm(path, {
 			recursive: true,
 			force: true
 		});
-		await addStateWorktree(repoPath, path);
+		await addStateWorktree(repoPath, path, options.signal);
 		return {
 			status: "recreated",
 			path
 		};
 	} catch (error) {
+		options.signal?.throwIfAborted();
 		return {
 			status: "error",
 			path,
@@ -208,4 +221,4 @@ var init_state_home = __esmMin((() => {
 //#endregion
 export { findRecreatedLegacyStatePaths as a, isStateMigrated as c, ensureStateWorktree as i, stateWorktreePath as l, STATE_BRANCH as n, init_state_home as o, clearStateMigrationCache as r, inspectStateMigration as s, MIGRATION_COMPLETE_MARKER as t };
 
-//# sourceMappingURL=state-home-DixkE-up.js.map
+//# sourceMappingURL=state-home-CONQvZR0.js.map

package/server/state-migrate-BeBW0KXA.js

@@ -0,0 +1,478 @@
+import { Hn as init_projects, In as getProjectSync, _n as acquireStateMigrationLock, cn as init_auto_commit, dn as STATE_BRANCH_PATHS, er as resolveInfraRepo, mn as init_state_plane, sn as flushAutoCommits, vn as init_state_migration_lock } from "./config-yaml-ig8Nwtiw.js";
+import { l as stateWorktreePath, n as STATE_BRANCH, o as init_state_home, r as clearStateMigrationCache, t as MIGRATION_COMPLETE_MARKER } from "./state-home-CONQvZR0.js";
+import { dirname, join } from "node:path";
+import { Effect } from "effect";
+import { tmpdir } from "node:os";
+import { createReadStream, createWriteStream, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { chmod, lstat, mkdir, readdir, rename, rm, utimes } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { pipeline } from "node:stream/promises";
+//#region ../../lib/state-migration-manifest.ts
+init_projects();
+init_state_migration_lock();
+init_state_plane();
+init_auto_commit();
+init_state_home();
+async function sha256(path, signal) {
+	const hash = createHash("sha256");
+	for await (const chunk of createReadStream(path, { signal })) {
+		signal?.throwIfAborted();
+		hash.update(chunk);
+	}
+	return hash.digest("hex");
+}
+async function manifestEntry(source, destination, signal) {
+	signal?.throwIfAborted();
+	const [stat, digest] = await Promise.all([lstat(source), sha256(source, signal)]);
+	signal?.throwIfAborted();
+	return {
+		source,
+		destination,
+		mode: stat.mode & 511,
+		size: stat.size,
+		sha256: digest
+	};
+}
+async function verifyStateMigrationManifest(entries) {
+	for (const expected of entries) {
+		const actual = await manifestEntry(expected.destination, expected.destination);
+		if ((actual.mode & 64) !== (expected.mode & 64) || actual.size !== expected.size || actual.sha256 !== expected.sha256) throw new Error(`State migration no-loss mismatch: ${expected.source} -> ${expected.destination}`);
+	}
+}
+//#endregion
+//#region ../../cli/commands/admin/state-migrate.ts
+const GIT_COMMAND_TIMEOUT_MS = 3e4;
+const execFileDetached = execFile;
+function killProcessTree(child) {
+	if (!child?.pid) return;
+	try {
+		if (process.platform === "win32") child.kill("SIGKILL");
+		else process.kill(-child.pid, "SIGKILL");
+	} catch {
+		try {
+			child.kill("SIGKILL");
+		} catch {}
+	}
+}
+async function git(cwd, args, signal, env) {
+	signal?.throwIfAborted();
+	const command = `git ${args.join(" ")}`;
+	return new Promise((resolve, reject) => {
+		let child;
+		let termination;
+		const terminate = (kind) => {
+			if (termination) return;
+			termination = kind;
+			killProcessTree(child);
+		};
+		const timeout = setTimeout(() => terminate("timeout"), GIT_COMMAND_TIMEOUT_MS);
+		const onAbort = () => terminate("abort");
+		signal?.addEventListener("abort", onAbort, { once: true });
+		child = execFileDetached("git", args, {
+			cwd,
+			env: {
+				...process.env,
+				...env
+			},
+			encoding: "utf8",
+			maxBuffer: 32 * 1024 * 1024,
+			detached: process.platform !== "win32"
+		}, (error, stdout, stderr) => {
+			clearTimeout(timeout);
+			signal?.removeEventListener("abort", onAbort);
+			if (termination === "abort") reject(signal?.reason ?? new DOMException(`${command} was cancelled`, "AbortError"));
+			else if (termination === "timeout") reject(/* @__PURE__ */ new Error(`${command} timed out after ${GIT_COMMAND_TIMEOUT_MS / 1e3}s`));
+			else if (error) reject(Object.assign(error, {
+				stdout,
+				stderr
+			}));
+			else resolve(stdout.trim());
+		});
+		if (signal?.aborted) terminate("abort");
+	});
+}
+function destinationForTracked(path) {
+	if (!path.startsWith(".pan/")) return null;
+	const flat = path.slice(5);
+	return STATE_BRANCH_PATHS.some((prefix) => flat.startsWith(prefix)) ? flat : null;
+}
+async function trackedManifest(repo, sourceSha, stateRoot, signal, copyFile = copyFileAbortable) {
+	const paths = (await git(repo, [
+		"ls-tree",
+		"-r",
+		"--name-only",
+		sourceSha,
+		"--",
+		".pan"
+	], signal)).split("\n").filter(Boolean);
+	const manifest = [];
+	for (const path of paths) {
+		signal?.throwIfAborted();
+		const destination = destinationForTracked(path);
+		if (!destination) continue;
+		const source = join(repo, path);
+		const target = join(stateRoot, destination);
+		if (!existsSync(target)) await copyFile(source, target, signal);
+		manifest.push(await manifestEntry(source, target, signal));
+	}
+	return manifest;
+}
+async function createOrphanStateCommit(repo, sourceSha, signal) {
+	const index = join(tmpdir(), `overdeck-state-index-${process.pid}-${Date.now()}`);
+	const env = { GIT_INDEX_FILE: index };
+	try {
+		await git(repo, ["read-tree", "--empty"], signal, env);
+		const rows = (await git(repo, [
+			"ls-tree",
+			"-r",
+			sourceSha,
+			"--",
+			".pan"
+		], signal)).split("\n").filter(Boolean);
+		for (const row of rows) {
+			const match = row.match(/^(\d+)\s+\w+\s+([0-9a-f]+)\t(.+)$/);
+			if (!match) continue;
+			const destination = destinationForTracked(match[3]);
+			if (destination) await git(repo, [
+				"update-index",
+				"--add",
+				"--cacheinfo",
+				`${match[1]},${match[2]},${destination}`
+			], signal, env);
+		}
+		return await git(repo, [
+			"commit-tree",
+			await git(repo, ["write-tree"], signal, env),
+			"-m",
+			"chore(state): seed overdeck-state"
+		], signal, env);
+	} finally {
+		rmSync(index, { force: true });
+	}
+}
+let copySequence = 0;
+async function copyFileAbortable(source, destination, signal) {
+	signal?.throwIfAborted();
+	const stat = await lstat(source);
+	const temporary = join(dirname(destination), `.overdeck-migrate-${process.pid}-${copySequence++}`);
+	await mkdir(dirname(destination), { recursive: true });
+	try {
+		await pipeline(createReadStream(source, { signal }), createWriteStream(temporary, { mode: stat.mode & 511 }), { signal });
+		signal?.throwIfAborted();
+		await chmod(temporary, stat.mode & 511);
+		await utimes(temporary, stat.atime, stat.mtime);
+		signal?.throwIfAborted();
+		await rename(temporary, destination);
+	} catch (error) {
+		if (signal?.aborted) throw signal.reason;
+		throw error;
+	} finally {
+		await rm(temporary, { force: true });
+	}
+}
+async function filesEqualAbortable(source, destination, signal) {
+	const [sourceEntry, destinationEntry] = await Promise.all([manifestEntry(source, source, signal), manifestEntry(destination, destination, signal)]);
+	return sourceEntry.size === destinationEntry.size && sourceEntry.sha256 === destinationEntry.sha256;
+}
+async function preserveUntrackedNotes(legacyStateSource, stateRoot, paths, signal, copyFile = copyFileAbortable) {
+	const manifest = [];
+	for (const path of paths) {
+		signal?.throwIfAborted();
+		const source = join(legacyStateSource, path);
+		let sourceStat;
+		try {
+			sourceStat = await lstat(source);
+		} catch (error) {
+			if (error.code === "ENOENT") continue;
+			throw error;
+		}
+		if (sourceStat.isSymbolicLink()) throw new Error(`Legacy state changed during migration: symbolic link appeared at ${source}`);
+		if (!sourceStat.isFile()) continue;
+		const destination = join(stateRoot, "notes", path.slice(5));
+		if (existsSync(destination)) {
+			if (!await filesEqualAbortable(source, destination, signal)) throw new Error(`Untracked-note destination collision: ${destination}`);
+		} else await copyFile(source, destination, signal);
+		manifest.push(await manifestEntry(source, destination, signal));
+	}
+	return manifest;
+}
+async function assertNoLegacySymlinks(source, signal, allowMissing = false) {
+	signal?.throwIfAborted();
+	let stat;
+	try {
+		stat = await lstat(source);
+	} catch (error) {
+		if (allowMissing && error.code === "ENOENT") return;
+		throw error;
+	}
+	if (stat.isSymbolicLink()) throw new Error(`Legacy state contains unsupported symbolic link: ${source}. Resolve it before migrating so canonical state cannot depend on the legacy tree.`);
+	if (!stat.isDirectory()) return;
+	for (const entry of await readdir(source, { withFileTypes: true })) await assertNoLegacySymlinks(join(source, entry.name), signal);
+}
+async function copyLegacyState(sourceRoot, stateRoot, signal, copyFile = copyFileAbortable) {
+	const manifest = [];
+	const sources = STATE_BRANCH_PATHS.map((sourcePath) => ({
+		source: join(sourceRoot, ".pan", sourcePath),
+		destination: join(stateRoot, sourcePath)
+	})).filter(({ source }) => existsSync(source));
+	await assertNoLegacySymlinks(join(sourceRoot, ".pan"), signal, true);
+	const visit = async (sourceDir, destinationDir) => {
+		await mkdir(destinationDir, { recursive: true });
+		for (const entry of await readdir(sourceDir, { withFileTypes: true })) {
+			signal?.throwIfAborted();
+			const sourceEntry = join(sourceDir, entry.name);
+			const destinationEntry = join(destinationDir, entry.name);
+			if (entry.isDirectory()) await visit(sourceEntry, destinationEntry);
+			else if (entry.isFile()) {
+				await copyFile(sourceEntry, destinationEntry, signal);
+				signal?.throwIfAborted();
+				manifest.push(await manifestEntry(sourceEntry, destinationEntry, signal));
+			} else if (entry.isSymbolicLink()) throw new Error(`Legacy state changed during migration: symbolic link appeared at ${sourceEntry}`);
+		}
+	};
+	for (const { source, destination } of sources) {
+		signal?.throwIfAborted();
+		await visit(source, destination);
+	}
+	return manifest;
+}
+function hasNonStateDirtyState(porcelain) {
+	return porcelain.split("\n").filter(Boolean).some((line) => {
+		const path = line.slice(3).split(" -> ").at(-1) ?? "";
+		if (path === ".pan" || path.startsWith(".pan/")) return false;
+		return true;
+	});
+}
+function dedupeManifest(entries) {
+	return [...new Map(entries.map((entry) => [entry.destination, entry])).values()];
+}
+const GITIGNORE_MANAGED_LINES = [
+	"# PAN-2541: permanent state is on overdeck-state; workspace runtime stays local.",
+	".pan/",
+	".overdeck/continue.json",
+	".overdeck/spec.vbrief.json",
+	".overdeck/sessions.jsonl",
+	".overdeck/feedback/",
+	".overdeck/review/",
+	".overdeck/test/",
+	".overdeck/kickoff.md",
+	".overdeck/agent-mcp.json"
+];
+function rewriteGitignore(repo) {
+	const path = join(repo, ".gitignore");
+	const prior = existsSync(path) ? readFileSync(path, "utf8") : "";
+	const managed = new Set([...GITIGNORE_MANAGED_LINES, ".overdeck/"]);
+	const kept = prior.split("\n").filter((line) => !managed.has(line.trim()));
+	while (kept.length > 0 && kept[kept.length - 1]?.trim() === "") kept.pop();
+	writeFileSync(path, [
+		...kept,
+		"",
+		...GITIGNORE_MANAGED_LINES,
+		""
+	].join("\n"));
+}
+async function migrateProjectState(projectKey, options = {}, projectOverride) {
+	const project = projectOverride ?? getProjectSync(projectKey);
+	if (!project) throw new Error(`Unknown project: ${projectKey}`);
+	const { repoPath: repo } = resolveInfraRepo(project);
+	const legacyStateSource = project.path;
+	const sourceIsHostRepo = legacyStateSource === repo;
+	const stateRoot = stateWorktreePath(project, { projectKey });
+	console.log(`PAN-2541 state migration plan for ${projectKey}:`);
+	console.log(`  ${legacyStateSource}/.pan/{${STATE_BRANCH_PATHS.map((p) => p.slice(0, -1)).join(",")}} -> ${stateRoot}/`);
+	console.log(`  ${legacyStateSource}/.pan/context -> ${legacyStateSource}/.overdeck/context`);
+	if (options.dryRun) return;
+	options.signal?.throwIfAborted();
+	const release = acquireStateMigrationLock(projectKey);
+	try {
+		const flush = await Effect.runPromise(flushAutoCommits(repo, options.signal));
+		if (flush.errored) throw new Error(`State writer did not quiesce before migration: ${flush.reason ?? "unknown error"}`);
+		options.signal?.throwIfAborted();
+		await assertNoLegacySymlinks(join(legacyStateSource, ".pan"), options.signal, true);
+		if (hasNonStateDirtyState(await git(repo, ["status", "--porcelain"], options.signal))) throw new Error("Primary checkout is dirty outside legacy state paths; migration refused before mutation");
+		await git(repo, [
+			"fetch",
+			"--prune",
+			"origin"
+		], options.signal);
+		const sourceMainSha = await git(repo, ["rev-parse", "main"], options.signal);
+		if (sourceMainSha !== await git(repo, ["rev-parse", "origin/main"], options.signal)) throw new Error("main is not exactly at origin/main; migration refused");
+		if (await git(repo, ["show", `origin/overdeck-state:migration-complete.json`], options.signal).catch(() => {
+			options.signal?.throwIfAborted();
+			return "";
+		})) {
+			console.log("State migration already complete on origin; nothing to do.");
+			return;
+		}
+		let stateSha = await git(repo, ["rev-parse", STATE_BRANCH], options.signal).catch(() => {
+			options.signal?.throwIfAborted();
+			return "";
+		});
+		const remoteStateSha = await git(repo, ["rev-parse", `origin/${STATE_BRANCH}`], options.signal).catch(() => {
+			options.signal?.throwIfAborted();
+			return "";
+		});
+		if (stateSha && remoteStateSha && stateSha !== remoteStateSha) throw new Error("Local and remote overdeck-state diverged; refusing non-fast-forward migration");
+		if (!stateSha) {
+			stateSha = remoteStateSha || await createOrphanStateCommit(repo, sourceMainSha, options.signal);
+			await git(repo, [
+				"update-ref",
+				`refs/heads/${STATE_BRANCH}`,
+				stateSha
+			], options.signal);
+		}
+		if (!remoteStateSha) await git(repo, [
+			"push",
+			"origin",
+			STATE_BRANCH
+		], options.signal);
+		if (!existsSync(stateRoot)) {
+			options.signal?.throwIfAborted();
+			mkdirSync(dirname(stateRoot), { recursive: true });
+			await git(repo, [
+				"worktree",
+				"add",
+				stateRoot,
+				STATE_BRANCH
+			], options.signal);
+		}
+		const manifest = sourceIsHostRepo ? dedupeManifest([...await trackedManifest(repo, sourceMainSha, stateRoot, options.signal), ...await copyLegacyState(legacyStateSource, stateRoot, options.signal)]) : await copyLegacyState(legacyStateSource, stateRoot, options.signal);
+		if (manifest.length > 0) {
+			await git(stateRoot, ["add", "--all"], options.signal);
+			if (await git(stateRoot, [
+				"diff",
+				"--cached",
+				"--name-only"
+			], options.signal)) await git(stateRoot, [
+				"commit",
+				"-m",
+				"chore(state): seed legacy project state"
+			], options.signal);
+			await git(stateRoot, [
+				"push",
+				"origin",
+				STATE_BRANCH
+			], options.signal);
+		}
+		const untracked = sourceIsHostRepo ? (await git(repo, [
+			"ls-files",
+			"--others",
+			"--",
+			".pan"
+		], options.signal)).split("\n").filter((path) => path.split("/").length === 2 && existsSync(join(repo, path)) && lstatSync(join(repo, path)).isFile()) : existsSync(join(legacyStateSource, ".pan")) ? readdirSync(join(legacyStateSource, ".pan"), { withFileTypes: true }).filter((entry) => entry.isFile()).map((entry) => `.pan/${entry.name}`) : [];
+		manifest.push(...await preserveUntrackedNotes(legacyStateSource, stateRoot, untracked, options.signal));
+		if (untracked.length > 0) {
+			await git(stateRoot, ["add", "notes"], options.signal);
+			if (await git(stateRoot, [
+				"diff",
+				"--cached",
+				"--name-only"
+			], options.signal)) await git(stateRoot, [
+				"commit",
+				"-m",
+				"chore(state): preserve untracked operator notes"
+			], options.signal);
+			await git(stateRoot, [
+				"push",
+				"origin",
+				STATE_BRANCH
+			], options.signal);
+		}
+		if (await git(repo, ["rev-parse", "main"], options.signal) !== sourceMainSha) throw new Error("main advanced during migration; refusing cleanup");
+		options.signal?.throwIfAborted();
+		if (sourceIsHostRepo) await git(repo, [
+			"rm",
+			"-r",
+			"--cached",
+			"--ignore-unmatch",
+			".pan/records",
+			".pan/continues",
+			".pan/specs",
+			".pan/drafts",
+			".pan/review",
+			".pan/test",
+			".pan/feedback",
+			".pan/backlog",
+			".pan/notes"
+		]);
+		const oldContext = join(legacyStateSource, ".pan", "context");
+		const newContext = join(legacyStateSource, ".overdeck", "context");
+		let movedContext = false;
+		if (existsSync(oldContext) && !existsSync(newContext)) {
+			mkdirSync(dirname(newContext), { recursive: true });
+			renameSync(oldContext, newContext);
+			movedContext = true;
+		}
+		rewriteGitignore(legacyStateSource);
+		if (sourceIsHostRepo) {
+			if (await git(repo, [
+				"ls-files",
+				"--",
+				".pan/context"
+			])) await git(repo, [
+				"add",
+				"-u",
+				"--",
+				".pan/context"
+			]);
+			const addPaths = [".gitignore"];
+			if (movedContext || existsSync(newContext)) addPaths.push(".overdeck/context");
+			await git(repo, [
+				"add",
+				"--",
+				...addPaths
+			]);
+			if (await git(repo, [
+				"diff",
+				"--cached",
+				"--name-only"
+			])) await git(repo, [
+				"commit",
+				"-m",
+				"chore(state): move permanent state to overdeck-state"
+			]);
+		}
+		await verifyStateMigrationManifest(manifest);
+		for (const entry of manifest) rmSync(entry.source, { force: true });
+		if (!sourceIsHostRepo) rmSync(join(legacyStateSource, ".pan"), {
+			recursive: true,
+			force: true
+		});
+		stateSha = await git(stateRoot, ["rev-parse", "HEAD"]);
+		writeFileSync(join(stateRoot, MIGRATION_COMPLETE_MARKER), `${JSON.stringify({
+			sourceMainSha,
+			stateBranchSha: stateSha,
+			completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			version: 1
+		}, null, 2)}\n`);
+		await git(stateRoot, ["add", MIGRATION_COMPLETE_MARKER]);
+		await git(stateRoot, [
+			"commit",
+			"-m",
+			"chore(state): complete state migration"
+		]);
+		await git(repo, [
+			"push",
+			"--atomic",
+			"--dry-run",
+			"origin",
+			"main",
+			STATE_BRANCH
+		]);
+		await git(repo, [
+			"push",
+			"--atomic",
+			"origin",
+			"main",
+			STATE_BRANCH
+		]);
+		clearStateMigrationCache();
+	} finally {
+		release();
+	}
+}
+//#endregion
+export { migrateProjectState };
+
+//# sourceMappingURL=state-migrate-BeBW0KXA.js.map