@overdeck/desktop 0.45.13 → 0.45.15

package/server/{archive-planning-CPitEZo4.js → archive-planning-DkivCk1A.js}

@@ -1,8 +1,8 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Ar as PROJECT_DOCS_SUBDIR, Hr as init_paths, Mr as PROJECT_PRDS_COMPLETED_SUBDIR, Nr as PROJECT_PRDS_PLANNED_SUBDIR, Pr as PROJECT_PRDS_SUBDIR, jr as PROJECT_PRDS_ACTIVE_SUBDIR, xr as ARCHIVES_DIR } from "./config-yaml-C_djSurJ.js";
+import { Fr as PROJECT_PRDS_SUBDIR, Mr as PROJECT_PRDS_ACTIVE_SUBDIR, Nr as PROJECT_PRDS_COMPLETED_SUBDIR, Pr as PROJECT_PRDS_PLANNED_SUBDIR, Sr as ARCHIVES_DIR, jr as PROJECT_DOCS_SUBDIR, qr as init_paths } from "./config-yaml-Dcz-8uit.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, u as PAN_SPEC_FILENAME } from "./types-CE1m_daD.js";
-import { t as init_pan_dir } from "./pan-dir-BlNrLzW7.js";
-import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed } from "./types-B5u3NxMl.js";
+import { t as init_pan_dir } from "./pan-dir-Bj7Hy8iu.js";
+import { a as stepSkipped, i as stepOk, n as init_types, r as stepFailed } from "./types-33JEP4LZ.js";
 import { Effect } from "effect";
 import { existsSync, readdirSync } from "fs";
 import { dirname, join } from "path";
@@ -271,4 +271,4 @@ var init_archive_planning = __esmMin((() => {
 //#endregion
 export { inferBranchFromWorkspace as a, findPrdAtStatusSync as c, findWorkspacePath as i, init_prd_locations as l, archiveWorkspaceArtifacts as n, init_archive_planning as o, findAllWorkspacePaths as r, movePrd as s, archivePlanning as t };
 
-//# sourceMappingURL=archive-planning-CPitEZo4.js.map
+//# sourceMappingURL=archive-planning-DkivCk1A.js.map

package/server/{artifact-index-jobs-sMnNtPhy.js → artifact-index-jobs-CmsvQ1ey.js}

@@ -1,4 +1,4 @@
-import { Hr as init_paths, Vr as getOverdeckHome } from "./config-yaml-C_djSurJ.js";
+import { Kr as getOverdeckHome, qr as init_paths } from "./config-yaml-Dcz-8uit.js";
 import { n as openDatabase, t as init_driver } from "./driver-D-HBOQa_.js";
 import { dirname, join } from "node:path";
 import { mkdirSync } from "node:fs";
@@ -208,4 +208,4 @@ function unshareArtifactBySlugJob(slug) {
 //#endregion
 export { getArtifactBySlugJob, listArtifactsForWorkspaceOrIssueJob, unshareArtifactBySlugJob };
 
-//# sourceMappingURL=artifact-index-jobs-sMnNtPhy.js.map
+//# sourceMappingURL=artifact-index-jobs-CmsvQ1ey.js.map

package/server/auto-commit-QAfsu3Sb.js

@@ -0,0 +1,3 @@
+import { in as init_auto_commit, on as queueBeadsAutoCommit, rn as flushAutoCommits } from "./config-yaml-Dcz-8uit.js";
+init_auto_commit();
+export { flushAutoCommits, queueBeadsAutoCommit };

package/server/{backlog-auto-trigger-Cf9C8fwD.js → backlog-auto-trigger-ueRaT8Dy.js}

@@ -1,6 +1,6 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
 import { r as isNoResumeValueEnabled, t as init_no_resume_mode } from "./no-resume-mode-yrPEQ_pC.js";
-import { a as spawnSequencerAgent, i as init_sequencer_agent } from "./sequencer-agent-BEDEHfd2.js";
+import { a as spawnSequencerAgent, i as init_sequencer_agent } from "./sequencer-agent-i-b2u4SJ.js";
 //#region ../../lib/backlog/backlog-auto-trigger.ts
 /**
 * PAN-2396: --no-resume is the operator's full-quiescence escape hatch —
@@ -37,4 +37,4 @@ __esmMin((() => {
 }))();
 export { triggerDebouncedIncrementalPass };
 
-//# sourceMappingURL=backlog-auto-trigger-Cf9C8fwD.js.map
+//# sourceMappingURL=backlog-auto-trigger-ueRaT8Dy.js.map

package/server/{bd-process-lock-D1aJxeYv.js → bd-process-lock-D3S4T4o-.js}

@@ -1,9 +1,28 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Hr as init_paths, Vr as getOverdeckHome } from "./config-yaml-C_djSurJ.js";
+import { Kr as getOverdeckHome, Pn as init_projects, mn as resolveStateReadHomeSync, pn as init_state_read_home, qr as init_paths, xn as findProjectByPathSync } from "./config-yaml-Dcz-8uit.js";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { Data } from "effect";
+import "node:fs";
 import { mkdir, open, readFile, realpath, unlink } from "node:fs/promises";
 import { createHash } from "node:crypto";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region ../../lib/beads/home.ts
+function resolveCanonicalBeadsHome(workspacePath = process.cwd(), project) {
+	let resolvedProject = project;
+	if (resolvedProject === void 0) try {
+		resolvedProject = findProjectByPathSync(workspacePath);
+	} catch {
+		resolvedProject = null;
+	}
+	if (!resolvedProject) return null;
+	const stateHome = resolveStateReadHomeSync(resolvedProject);
+	return resolve(stateHome.migrated ? stateHome.root : resolvedProject.path, ".beads");
+}
+var init_home = __esmMin((() => {
+	init_projects();
+	init_state_read_home();
+}));
+//#endregion
 //#region ../../lib/bd-process-lock.ts
 function isRecord(value) {
 	return typeof value === "object" && value !== null;
@@ -68,6 +87,8 @@ async function realpathIfExists(path) {
 	}
 }
 async function resolveSharedBeadsDir(workspacePath = process.cwd()) {
+	const canonical = resolveCanonicalBeadsHome(workspacePath);
+	if (canonical) return realpathIfExists(canonical);
 	const beadsDir = resolve(workspacePath, ".beads");
 	const redirectPath = join(beadsDir, "redirect");
 	try {
@@ -113,9 +134,6 @@ async function readHolderFromPath(path) {
 	const state = await readLockFileState(path);
 	return state.kind === "valid" ? state.holder : null;
 }
-async function readBdProcessLockHolder(options = {}) {
-	return readHolderFromPath(options.lockPath ?? await bdProcessLockPath(options.workspacePath));
-}
 function isProcessAlive(pid) {
 	try {
 		process.kill(pid, 0);
@@ -145,8 +163,8 @@ async function unlinkIfExists(path) {
 function matchesHolder(actual, expected) {
 	return actual?.pid === expected.pid && actual.ts === expected.ts && actual.caller === expected.caller;
 }
-function isLockHeldByCurrentProcess(path) {
-	return heldBdProcessLocks.has(path);
+function isLockHeldByCurrentExecution(path) {
+	return bdLockExecution.getStore()?.has(path) === true && heldBdProcessLocks.has(path);
 }
 async function acquireStaleBreaker(path, caller, options) {
 	const breakerPath = `${path}.break`;
@@ -200,7 +218,7 @@ async function acquireBdProcessLock(caller, options = {}) {
 	const now = options.now ?? Date.now;
 	const deadline = now() + acquisitionTimeoutMs;
 	await mkdir(dirname(path), { recursive: true });
-	if (isLockHeldByCurrentProcess(path)) {
+	if (isLockHeldByCurrentExecution(path)) {
 		const held = heldBdProcessLocks.get(path);
 		held.count += 1;
 		let released = false;
@@ -286,7 +304,8 @@ async function acquireBdProcessLock(caller, options = {}) {
 async function withBdProcessLock(caller, fn, options = {}) {
 	const handle = await acquireBdProcessLock(caller, options);
 	try {
-		return await fn();
+		const inherited = bdLockExecution.getStore() ?? /* @__PURE__ */ new Set();
+		return await bdLockExecution.run(new Set([...inherited, handle.path]), fn);
 	} finally {
 		await handle.release();
 	}
@@ -333,9 +352,10 @@ async function runBdWithRetry(caller, fn, options = {}) {
 	});
 	throw lastError;
 }
-var TRANSIENT_BD_ERRNO_CODES, TRANSIENT_BD_LOCK_PATTERNS, DEFAULT_STALE_LOCK_MS, DEFAULT_ACQUIRE_TIMEOUT_MS, DEFAULT_ACQUIRE_POLL_MS, DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, BdProcessLockError, BdTransientFailure, heldBdProcessLocks;
+var TRANSIENT_BD_ERRNO_CODES, TRANSIENT_BD_LOCK_PATTERNS, DEFAULT_STALE_LOCK_MS, DEFAULT_ACQUIRE_TIMEOUT_MS, DEFAULT_ACQUIRE_POLL_MS, DEFAULT_RETRY_ATTEMPTS, DEFAULT_RETRY_INITIAL_DELAY_MS, DEFAULT_RETRY_MAX_DELAY_MS, BdProcessLockError, BdTransientFailure, heldBdProcessLocks, bdLockExecution;
 var init_bd_process_lock = __esmMin((() => {
 	init_paths();
+	init_home();
 	TRANSIENT_BD_ERRNO_CODES = new Set([
 		"EAGAIN",
 		"EBUSY",
@@ -362,8 +382,9 @@ var init_bd_process_lock = __esmMin((() => {
 	BdProcessLockError = class extends Data.TaggedError("BdProcessLockError") {};
 	BdTransientFailure = class extends Data.TaggedError("BdTransientFailure") {};
 	heldBdProcessLocks = /* @__PURE__ */ new Map();
+	bdLockExecution = new AsyncLocalStorage();
 }));
 //#endregion
-export { withBdProcessLock as a, runBdWithRetry as i, init_bd_process_lock as n, readBdProcessLockHolder as r, BdTransientFailure as t };
+export { withBdProcessLock as a, runBdWithRetry as i, init_bd_process_lock as n, init_home as o, resolveSharedBeadsDir as r, resolveCanonicalBeadsHome as s, BdTransientFailure as t };
 
-//# sourceMappingURL=bd-process-lock-D1aJxeYv.js.map
+//# sourceMappingURL=bd-process-lock-D3S4T4o-.js.map

package/server/{beads-DRoj6-e1.js → beads-BGGxrkZ5.js}

@@ -1,13 +1,44 @@
-import { _ as updateItemStatus, b as init_types, d as readPlanSync, m as readWorkspacePlanSync, o as init_io, v as updateSubItemStatus, x as subItemsOf } from "./io-CbAFXQge.js";
-import { a as withBdProcessLock, i as runBdWithRetry, n as init_bd_process_lock, t as BdTransientFailure } from "./bd-process-lock-D1aJxeYv.js";
-import { n as withBdMutexPromise } from "./bd-mutex-BItGvLQ8.js";
-import { n as init_acceptance_criteria, t as extractACFromDocument } from "./acceptance-criteria-CfujPRrz.js";
+import { _ as updateItemStatus, b as init_types, d as readPlanSync, m as readWorkspacePlanSync, o as init_io, v as updateSubItemStatus, x as subItemsOf } from "./io-BiQ2Cs3k.js";
+import { i as runBdWithRetry, n as init_bd_process_lock, o as init_home, s as resolveCanonicalBeadsHome, t as BdTransientFailure } from "./bd-process-lock-D3S4T4o-.js";
+import { n as init_resolver, t as createBeadsResolver } from "./resolver-dTpSSzaH.js";
+import { t as init_beads_restore } from "./beads-restore-CyygSmmn.js";
+import { n as init_writer, r as runMutationBatch, t as formatMutationBatchFailure } from "./writer-fe1-8iGc.js";
+import { n as init_acceptance_criteria, t as extractACFromDocument } from "./acceptance-criteria-DHZk2ceV.js";
 import { Data, Effect } from "effect";
 import { chmodSync, existsSync, mkdirSync, writeFileSync } from "fs";
-import { basename, join, resolve } from "path";
-import { readFile } from "node:fs/promises";
+import { join } from "path";
 import { execFile } from "child_process";
 import { promisify } from "util";
+//#region ../../lib/bd-mutex.ts
+/**
+* Global mutex for bd (beads) CLI commands.
+*
+* Embedded Dolt uses file-based locking — only one process can hold the
+* database lock at a time. When the dashboard spawns concurrent `bd` commands
+* (e.g. planning-state queries for every kanban card), each process blocks
+* waiting for the lock, creating a cascade of hundreds of hung processes.
+*
+* This mutex serializes all bd operations so only one runs at a time,
+* preventing lock contention and process pile-up.
+*/
+init_beads_restore();
+let pending = Promise.resolve();
+async function withBdMutexPromise(fn) {
+	const result = pending.then(fn, fn);
+	pending = result.then(() => {}, () => {});
+	return result;
+}
+/**
+* Effect-native variant of withBdMutex over a thunk that returns a no-context
+* Effect. Serializes against all other bd-mutex callers via the Promise queue.
+* The wrapped Effect must be no-context (R = never) since it is launched from
+* inside a tryPromise — Layers cannot be threaded through the global mutex.
+*/
+const withBdMutex = (fn) => Effect.tryPromise({
+	try: () => withBdMutexPromise(() => Effect.runPromise(fn())),
+	catch: (e) => e
+});
+//#endregion
 //#region ../../lib/vbrief/beads.ts
 /**
 * createBeadsFromVBrief
@@ -20,17 +51,10 @@ init_bd_process_lock();
 init_io();
 init_acceptance_criteria();
 init_types();
+init_resolver();
+init_writer();
+init_home();
 const execFileAsync = promisify(execFile);
-/**
-* Derive a consistent project-level bead prefix from a workspace path.
-* Workspaces live at <projectRoot>/workspaces/feature-<id>/, so the project
-* root is two levels up. We use the repo directory name as the prefix.
-* This prevents each issue from getting a different prefix (e.g. pan-569,
-* pan-821) which breaks cross-issue bead scoping.
-*/
-function deriveProjectPrefix(workspacePath) {
-	return basename(resolve(workspacePath, "..", "..")).toLowerCase().replace(/[^a-z0-9-]/g, "-");
-}
 function normalizeClearBeadsOptions(value = {}) {
 	if (typeof value === "number") return { timeoutMs: value };
 	return {
@@ -89,27 +113,9 @@ function beadIdsFromList(beads) {
 	return beads.map((bead) => bead?.id).filter((id) => id !== void 0 && id !== null && String(id).length > 0).map((id) => String(id));
 }
 async function listBeadsForIssue(workspacePath, issueLabel, options = {}) {
-	const { timeoutMs = BD_TIMEOUT_FLOOR_MS, ...retryOptions } = normalizeClearBeadsOptions(options);
-	return runBdWithRetry(`list beads for ${issueLabel}`, async () => {
-		const { stdout } = await execFileAsync("bd", [
-			"list",
-			"--json",
-			"-l",
-			issueLabel,
-			"--status",
-			"all",
-			"--limit",
-			"0"
-		], {
-			encoding: "utf-8",
-			cwd: workspacePath,
-			timeout: timeoutMs
-		});
-		return parseBdList(stdout);
-	}, {
-		...retryOptions,
-		workspacePath
-	});
+	const result = await createBeadsResolver(workspacePath, { retry: normalizeClearBeadsOptions(options) }).getBeadsForIssue(issueLabel);
+	if (!result.ok) throw result.error;
+	return result.value;
 }
 /**
 * After a bd create timeout or empty-stdout, recover the bead ID by exact-title
@@ -180,7 +186,7 @@ async function retryBd(fn, options = {}) {
 * causes success:false so finalize exits non-zero rather than silently shipping
 * a corrupt DAG.
 */
-async function verifyAndRepairDependencyEdges(workspacePath, planEdges, beadIds, timeoutMs, retryOptions = {}) {
+async function verifyAndRepairDependencyEdges(client, workspacePath, planEdges, beadIds, timeoutMs, retryOptions = {}) {
 	const blockEdges = planEdges.filter((edge) => edge.type === "blocks");
 	if (blockEdges.length === 0 || beadIds.size === 0) return {
 		success: true,
@@ -189,20 +195,15 @@ async function verifyAndRepairDependencyEdges(workspacePath, planEdges, beadIds,
 	const createdBeadIds = Array.from(new Set(beadIds.values()));
 	let actualDeps;
 	try {
-		const { stdout } = await runBdWithRetry(`dep list for ${createdBeadIds.length} beads`, () => execFileAsync("bd", [
+		actualDeps = parseBdList(await runBdWithRetry(`dep list for ${createdBeadIds.length} beads`, () => client.run([
 			"dep",
 			"list",
 			...createdBeadIds,
 			"--json"
-		], {
-			encoding: "utf-8",
-			cwd: workspacePath,
-			timeout: timeoutMs
-		}), {
+		]), {
 			...retryOptions,
 			workspacePath
-		});
-		actualDeps = parseBdList(stdout);
+		}));
 	} catch (error) {
 		return {
 			success: false,
@@ -229,16 +230,12 @@ async function verifyAndRepairDependencyEdges(workspacePath, planEdges, beadIds,
 		});
 	}
 	for (const repair of missingRepairs) try {
-		await runBdWithRetry(`dep add ${repair.beadTo} ${repair.beadFrom}`, () => execFileAsync("bd", [
+		await runBdWithRetry(`dep add ${repair.beadTo} ${repair.beadFrom}`, () => client.mutate([
 			"dep",
 			"add",
 			repair.beadTo,
 			repair.beadFrom
-		], {
-			encoding: "utf-8",
-			cwd: workspacePath,
-			timeout: timeoutMs
-		}), {
+		]), {
 			...retryOptions,
 			workspacePath
 		});
@@ -263,17 +260,13 @@ async function verifyAndRepairDependencyEdges(workspacePath, planEdges, beadIds,
 * a delete can time out client-side while committing server-side; a retry then
 * sees the bead as already gone. Catching that case makes deletion idempotent.
 */
-async function deleteBead(workspacePath, id, timeoutMs) {
+async function deleteBead(client, id) {
 	try {
-		await execFileAsync("bd", [
+		await client.mutate([
 			"delete",
 			id,
 			"--force"
-		], {
-			encoding: "utf-8",
-			cwd: workspacePath,
-			timeout: timeoutMs
-		});
+		]);
 	} catch (error) {
 		if (execFileErrorMessage(error).toLowerCase().includes("not found")) return;
 		throw error;
@@ -281,7 +274,17 @@ async function deleteBead(workspacePath, id, timeoutMs) {
 }
 async function clearBeadsForIssue(workspacePath, issueLabel, timeoutMsOrOptions = {}) {
 	const options = normalizeClearBeadsOptions(timeoutMsOrOptions);
-	const { timeoutMs = BD_TIMEOUT_FLOOR_MS } = options;
+	const batch = await runMutationBatch({
+		project: { workspacePath },
+		reason: `clear beads for ${issueLabel}`,
+		lockOptions: options
+	}, (client) => clearBeadsForIssueWithClient(client, workspacePath, issueLabel, options));
+	return batch.ok ? batch.value : {
+		cleared: 0,
+		errors: [formatMutationBatchFailure(batch)]
+	};
+}
+async function clearBeadsForIssueWithClient(client, workspacePath, issueLabel, options) {
 	let existingBeads;
 	try {
 		existingBeads = await listBeadsForIssue(workspacePath, issueLabel, options);
@@ -295,7 +298,7 @@ async function clearBeadsForIssue(workspacePath, issueLabel, timeoutMsOrOptions
 	const errors = [];
 	let cleared = 0;
 	for (const id of beadIdsFromList(existingBeads)) try {
-		await runBdWithRetry(`delete bead ${id} for ${issueLabel}`, () => deleteBead(workspacePath, id, timeoutMs), {
+		await runBdWithRetry(`delete bead ${id} for ${issueLabel}`, () => deleteBead(client, id), {
 			...options,
 			workspacePath
 		});
@@ -341,7 +344,11 @@ function resolveInspectionMetadata(policy, item) {
 }
 async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
 	const { planPath, lockOptions, ...retryOptions } = options;
-	return withBdProcessLock("create beads from vBRIEF", async () => withBdMutexPromise(async () => {
+	const batch = await runMutationBatch({
+		project: { workspacePath },
+		reason: "create beads from vBRIEF",
+		lockOptions
+	}, async (bd) => withBdMutexPromise(async () => {
 		const created = [];
 		const errors = [];
 		const beadIds = /* @__PURE__ */ new Map();
@@ -361,48 +368,9 @@ async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
 		const beadsDir = join(workspacePath, ".beads");
 		const redirectPath = join(beadsDir, "redirect");
 		if (!existsSync(redirectPath)) {
-			if (existsSync(join(resolve(workspacePath, "..", ".."), ".beads"))) {
-				mkdirSync(beadsDir, { recursive: true });
-				chmodSync(beadsDir, 448);
-				writeFileSync(redirectPath, "../../.beads", "utf-8");
-				console.log(`[beads] Created redirect to main repo .beads/ in ${workspacePath}`);
-			} else if (!existsSync(beadsDir)) {
-				const prefix = deriveProjectPrefix(workspacePath);
-				try {
-					await execFileAsync("bd", [
-						"init",
-						"--prefix",
-						prefix
-					], {
-						encoding: "utf-8",
-						cwd: workspacePath,
-						timeout: BD_TIMEOUT_FLOOR_MS
-					});
-					await execFileAsync("git", [
-						"config",
-						"beads.role",
-						"contributor"
-					], { cwd: workspacePath }).catch(() => {});
-					await execFileAsync("bd", [
-						"config",
-						"set",
-						"export.git-add",
-						"false"
-					], {
-						encoding: "utf-8",
-						cwd: workspacePath,
-						timeout: BD_TIMEOUT_FLOOR_MS
-					}).catch(() => {});
-					console.log(`[beads] Initialized beads database in ${workspacePath} (prefix: ${prefix})`);
-				} catch (initErr) {
-					return {
-						success: false,
-						created: [],
-						errors: [`Failed to initialize beads: ${initErr.message}`],
-						beadIds
-					};
-				}
-			}
+			mkdirSync(beadsDir, { recursive: true });
+			chmodSync(beadsDir, 448);
+			writeFileSync(redirectPath, resolveCanonicalBeadsHome(workspacePath) ?? "../../.beads", "utf8");
 		}
 		const doc = planPath ? readPlanSync(planPath) : readWorkspacePlanSync(workspacePath);
 		if (!doc) return {
@@ -416,86 +384,34 @@ async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
 		const inspectionPolicy = doc.vBRIEFInfo.inspectionPolicy ?? "auto";
 		const bdTimeoutMs = await resolveBdTimeout(workspacePath);
 		const issueLabel = plan.id.toLowerCase();
-		const redirectExists = existsSync(redirectPath);
 		try {
 			await retryBd(() => execFileAsync("bd", ["ping", "--json"], {
 				encoding: "utf-8",
 				cwd: workspacePath,
 				timeout: bdTimeoutMs
 			}), { sleep: retryOptions.sleep });
-		} catch (connectErr) {
-			const firstLine = String(connectErr?.message ?? connectErr?.stderr ?? "").split("\n")[0] || "unknown connectivity error";
-			const mainBeadsDir = join(resolve(workspacePath, "..", ".."), ".beads");
-			console.warn(`[beads] bd ping failed (${firstLine}); running bd doctor --fix before retry`);
+		} catch (connectError) {
 			try {
 				await execFileAsync("bd", ["doctor", "--fix"], {
 					encoding: "utf-8",
 					cwd: workspacePath,
 					timeout: bdTimeoutMs
 				});
-			} catch (doctorErr) {
-				const doctorFirstLine = String(doctorErr?.message ?? doctorErr?.stderr ?? "").split("\n")[0] || "unknown doctor error";
-				console.warn(`[beads] bd doctor --fix failed: ${doctorFirstLine}`);
-			}
-			try {
 				await retryBd(() => execFileAsync("bd", ["ping", "--json"], {
 					encoding: "utf-8",
 					cwd: workspacePath,
 					timeout: bdTimeoutMs
 				}), { sleep: retryOptions.sleep });
-			} catch (retryErr) {
-				if (!redirectExists && !existsSync(mainBeadsDir)) {
-					const prefix = deriveProjectPrefix(workspacePath);
-					console.log(`[beads] No redirect and no main beads — bd init --prefix ${prefix}`);
-					try {
-						await execFileAsync("bd", [
-							"init",
-							"--prefix",
-							prefix
-						], {
-							encoding: "utf-8",
-							cwd: workspacePath,
-							timeout: bdTimeoutMs
-						});
-						await execFileAsync("git", [
-							"config",
-							"beads.role",
-							"contributor"
-						], { cwd: workspacePath }).catch(() => {});
-						await execFileAsync("bd", [
-							"config",
-							"set",
-							"export.git-add",
-							"false"
-						], {
-							encoding: "utf-8",
-							cwd: workspacePath,
-							timeout: bdTimeoutMs
-						}).catch(() => {});
-						console.log(`[beads] bd init succeeded for prefix ${prefix}`);
-					} catch (initErr) {
-						const detail = `database init failed: ${String(initErr?.message ?? initErr?.stderr ?? "").split("\n")[0]}`;
-						console.warn(`[beads] ${detail}`);
-						return {
-							success: false,
-							created: [],
-							errors: [detail],
-							beadIds
-						};
-					}
-				} else {
-					const detail = `beads probe failed after recovery (${String(retryErr?.message ?? retryErr?.stderr ?? "").split("\n")[0] || "unknown connectivity error"})`;
-					console.warn(`[beads] ${detail}`);
-					return {
-						success: false,
-						created: [],
-						errors: [detail],
-						beadIds
-					};
-				}
+			} catch (retryError) {
+				return {
+					success: false,
+					created: [],
+					errors: [`beads probe failed after recovery (${execFileErrorMessage(retryError ?? connectError).split("\n")[0]})`],
+					beadIds
+				};
 			}
 		}
-		const clearResult = await clearBeadsForIssue(workspacePath, issueLabel, {
+		const clearResult = await clearBeadsForIssueWithClient(bd, workspacePath, issueLabel, {
 			...retryOptions,
 			timeoutMs: bdTimeoutMs
 		});
@@ -572,12 +488,7 @@ async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
 			let capturedBeadId = null;
 			let createFailureMessage = null;
 			try {
-				const { stdout } = await execFileAsync("bd", args, {
-					encoding: "utf-8",
-					cwd: workspacePath,
-					timeout: bdTimeoutMs
-				});
-				capturedBeadId = stdout.trim() || null;
+				capturedBeadId = (await bd.mutate(args)).trim() || null;
 				if (!capturedBeadId) createFailureMessage = `Created "${item.title}" but could not capture bead ID`;
 			} catch (error) {
 				const timedOut = error?.killed === true || /ETIMEDOUT/i.test(String(error?.code ?? ""));
@@ -599,7 +510,7 @@ async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
 				} else errors.push(createFailureMessage ?? `Failed to create "${item.title}"`);
 			}
 		}
-		const edgeVerification = await verifyAndRepairDependencyEdges(workspacePath, planEdges, beadIds, bdTimeoutMs, retryOptions);
+		const edgeVerification = await verifyAndRepairDependencyEdges(bd, workspacePath, planEdges, beadIds, bdTimeoutMs, retryOptions);
 		errors.push(...edgeVerification.errors);
 		return {
 			success: errors.length === 0,
@@ -607,40 +518,29 @@ async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
 			errors,
 			beadIds
 		};
-	}), {
-		workspacePath,
-		...lockOptions
-	});
+	}));
+	return batch.ok ? batch.value : {
+		success: false,
+		created: [],
+		errors: [formatMutationBatchFailure(batch)],
+		beadIds: /* @__PURE__ */ new Map()
+	};
 }
 /**
 * Syncs a bead's status to the corresponding vBRIEF item.
 * Returns the vBRIEF item ID that was updated, or null if no match was found.
 * Callers must provide knownTitle (from bd list/show output).
 */
-/** Read a bead title from .beads/issues.jsonl by bead ID. */
-async function readBeadTitleFromJsonl(beadId, workspacePath) {
-	try {
-		const jsonlPath = join(workspacePath, ".beads", "issues.jsonl");
-		if (!existsSync(jsonlPath)) return null;
-		const raw = await readFile(jsonlPath, "utf-8");
-		for (const line of raw.split("\n")) {
-			if (!line.trim()) continue;
-			try {
-				const entry = JSON.parse(line);
-				if (entry.id === beadId && typeof entry.title === "string") return entry.title;
-			} catch {}
-		}
-		return null;
-	} catch {
-		return null;
-	}
+async function readBeadTitle(beadId, workspacePath) {
+	const result = await createBeadsResolver(workspacePath).getBeadById(beadId);
+	return result.ok ? result.value?.title ?? null : null;
 }
 async function syncBeadStatusToVBriefPromise(beadId, workspacePath, status = "completed", knownTitle) {
 	try {
 		const doc = readWorkspacePlanSync(workspacePath);
 		if (!doc) return null;
 		let beadTitle = knownTitle ?? null;
-		if (!beadTitle) beadTitle = await readBeadTitleFromJsonl(beadId, workspacePath);
+		if (!beadTitle) beadTitle = await readBeadTitle(beadId, workspacePath);
 		if (!beadTitle) return null;
 		const planId = doc.plan.id;
 		const prefix = `${planId}: `;
@@ -744,6 +644,6 @@ const getVBriefACStatus = (workspacePath) => Effect.try({
 	})
 });
 //#endregion
-export { getVBriefACStatusSync as a, syncBeadStatusToVBrief as c, getVBriefACStatus as i, clearBeadsForIssue as n, resolveBdTimeout as o, createBeadsFromVBrief as r, retryBd as s, BeadsOperationError as t };
+export { getVBriefACStatusSync as a, syncBeadStatusToVBrief as c, getVBriefACStatus as i, withBdMutex as l, clearBeadsForIssue as n, resolveBdTimeout as o, createBeadsFromVBrief as r, retryBd as s, BeadsOperationError as t };
 
-//# sourceMappingURL=beads-DRoj6-e1.js.map
+//# sourceMappingURL=beads-BGGxrkZ5.js.map

package/server/{beads-CivpXztb.js → beads-CYsLiyIM.js}

@@ -1,2 +1,2 @@
-import { a as getVBriefACStatusSync, c as syncBeadStatusToVBrief, i as getVBriefACStatus, n as clearBeadsForIssue, o as resolveBdTimeout, r as createBeadsFromVBrief, s as retryBd, t as BeadsOperationError } from "./beads-DRoj6-e1.js";
+import { a as getVBriefACStatusSync, c as syncBeadStatusToVBrief, i as getVBriefACStatus, n as clearBeadsForIssue, o as resolveBdTimeout, r as createBeadsFromVBrief, s as retryBd, t as BeadsOperationError } from "./beads-BGGxrkZ5.js";
 export { BeadsOperationError, clearBeadsForIssue, createBeadsFromVBrief, getVBriefACStatus, getVBriefACStatusSync, resolveBdTimeout, retryBd, syncBeadStatusToVBrief };