@overdeck/desktop 0.45.16 → 0.45.18

package/server/beads-BeSMEjGT.js

@@ -1,649 +0,0 @@
-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-VEGSAqsd.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-XAXAet9O.js";
-import { n as init_resolver, t as createBeadsResolver } from "./resolver-C7dLn8OK.js";
-import { t as init_beads_restore } from "./beads-restore-BUItPOjI.js";
-import { n as init_writer, r as runMutationBatch, t as formatMutationBatchFailure } from "./writer-CrP2xuBn.js";
-import { n as init_acceptance_criteria, t as extractACFromDocument } from "./acceptance-criteria-BZ_nQS1f.js";
-import { Data, Effect } from "effect";
-import { chmodSync, existsSync, mkdirSync, writeFileSync } from "fs";
-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
-*
-* Converts a vBRIEF plan document into beads tasks, preserving dependency
-* relationships from blocking edges. This replaces LLM-generated `bd create`
-* shell commands with a deterministic, programmatic conversion.
-*/
-init_bd_process_lock();
-init_io();
-init_acceptance_criteria();
-init_types();
-init_resolver();
-init_writer();
-init_home();
-const execFileAsync = promisify(execFile);
-function normalizeClearBeadsOptions(value = {}) {
-	if (typeof value === "number") return { timeoutMs: value };
-	return {
-		timeoutMs: BD_TIMEOUT_FLOOR_MS,
-		...value
-	};
-}
-function firstLine(value) {
-	return (typeof value === "string" ? value : value instanceof Error ? value.message : String(value ?? "")).split("\n")[0] || "unknown error";
-}
-function execFileErrorMessage(error) {
-	return firstLine(error?.stderr?.toString() || error?.message || error);
-}
-/** Bootstrap timeout for the latency probe that derives the operational timeout. */
-const BD_PING_BOOTSTRAP_TIMEOUT_MS = 8e3;
-/** Floor for the adaptive bd operational timeout. Preserves today's 30s default. */
-const BD_TIMEOUT_FLOOR_MS = 3e4;
-/** Ceiling for the adaptive bd operational timeout. Prevents near-unbounded waits. */
-const BD_TIMEOUT_CEILING_MS = 18e4;
-/** Multiplier applied to bd ping total_ms to derive the operational timeout. */
-const BD_TIMEOUT_MULTIPLIER = 20;
-/**
-* Resolve the operational timeout for all bd calls in this finalize.
-*
-* - If OVERDECK_BD_TIMEOUT_MS is a positive integer, return it verbatim and
-*   do NOT probe bd.
-* - Otherwise run `bd ping --json` once with a fixed bootstrap timeout, read
-*   total_ms, and clamp(total_ms * 20, 30s, 180s).
-* - If the probe fails or returns unparseable JSON, return the 30s floor.
-*
-* The caller (createBeadsFromVBriefPromise) caches the result for the lifetime
-* of one finalize so the probe runs once.
-*/
-async function resolveBdTimeout(workspacePath) {
-	const envValue = Number(process.env.OVERDECK_BD_TIMEOUT_MS);
-	if (Number.isInteger(envValue) && envValue > 0) return Math.min(BD_TIMEOUT_CEILING_MS, Math.max(BD_TIMEOUT_FLOOR_MS, envValue));
-	try {
-		const { stdout } = await execFileAsync("bd", ["ping", "--json"], {
-			encoding: "utf-8",
-			cwd: workspacePath,
-			timeout: BD_PING_BOOTSTRAP_TIMEOUT_MS
-		});
-		const parsed = JSON.parse(stdout);
-		const totalMs = typeof parsed?.total_ms === "number" ? parsed.total_ms : 0;
-		return Math.min(BD_TIMEOUT_CEILING_MS, Math.max(BD_TIMEOUT_FLOOR_MS, totalMs * BD_TIMEOUT_MULTIPLIER));
-	} catch {
-		return BD_TIMEOUT_FLOOR_MS;
-	}
-}
-function parseBdList(stdout) {
-	const parsed = JSON.parse(String(stdout || "[]"));
-	if (!Array.isArray(parsed)) throw new Error("bd list returned non-array JSON");
-	return parsed;
-}
-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 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
-* re-query. A client-side timeout usually means the create succeeded on the
-* server, so the only missing piece is the ID.
-*
-* Returns the recovered id, or null if no unique match is found. ambiguity=true
-* means more than one bead matched the full title and the caller must NOT pick
-* one silently.
-*/
-async function recoverBeadIdByTitle(workspacePath, issueLabel, fullTitle, timeoutMs) {
-	let beads;
-	try {
-		beads = await listBeadsForIssue(workspacePath, issueLabel, { timeoutMs });
-	} catch {
-		return {
-			id: null,
-			ambiguity: false
-		};
-	}
-	const matches = beads.filter((bead) => bead?.title === fullTitle);
-	if (matches.length === 1) {
-		const id = matches[0]?.id;
-		if (id !== void 0 && id !== null && String(id).length > 0) return {
-			id: String(id),
-			ambiguity: false
-		};
-	} else if (matches.length > 1) return {
-		id: null,
-		ambiguity: true
-	};
-	return {
-		id: null,
-		ambiguity: false
-	};
-}
-async function defaultBdSleep(ms) {
-	await new Promise((resolve) => setTimeout(resolve, ms));
-}
-/**
-* Bounded exponential-backoff retry for idempotent bd operations.
-*
-* Retries `fn` up to `attempts` times (default 3), waiting
-* `baseDelayMs * 2^(attempt-1)` milliseconds between attempts. Surfaces the
-* last error once attempts are exhausted. Used only for reads/deletes — never
-* for bd create, which is not idempotent.
-*/
-async function retryBd(fn, options = {}) {
-	const attempts = options.attempts ?? 3;
-	const baseDelayMs = options.baseDelayMs ?? 500;
-	const sleep = options.sleep ?? defaultBdSleep;
-	let lastError;
-	for (let attempt = 1; attempt <= attempts; attempt++) try {
-		return await fn();
-	} catch (error) {
-		lastError = error;
-		if (attempt < attempts) await sleep(baseDelayMs * Math.pow(2, attempt - 1));
-	}
-	throw lastError;
-}
-/**
-* Post-condition verification for dependency edges.
-*
-* Issues one batched `bd dep list` over all created bead IDs, compares the
-* actual `blocks` dependencies against plan.edges, and repairs any missing edge
-* with `bd dep add`. Edges whose endpoints were not both captured are reported
-* as errors and not repaired. After repairs, any edge that is still missing
-* causes success:false so finalize exits non-zero rather than silently shipping
-* a corrupt DAG.
-*/
-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,
-		errors: []
-	};
-	const createdBeadIds = Array.from(new Set(beadIds.values()));
-	let actualDeps;
-	try {
-		actualDeps = parseBdList(await runBdWithRetry(`dep list for ${createdBeadIds.length} beads`, () => client.run([
-			"dep",
-			"list",
-			...createdBeadIds,
-			"--json"
-		]), {
-			...retryOptions,
-			workspacePath
-		}));
-	} catch (error) {
-		return {
-			success: false,
-			errors: [`dep list failed: ${execFileErrorMessage(error)}`]
-		};
-	}
-	const isBlocksDep = (dep) => dep?.dependency_type === "blocks" || dep?.type === "blocks" || dep?.relationship === "blocks";
-	const actualDepSet = new Set(actualDeps.filter(isBlocksDep).map((dep) => `${dep.issue_id}|${dep.depends_on_id ?? dep.id}`));
-	const errors = [];
-	const missingRepairs = [];
-	for (const edge of blockEdges) {
-		const beadFrom = beadIds.get(edge.from);
-		const beadTo = beadIds.get(edge.to);
-		if (!beadFrom || !beadTo) {
-			errors.push(`Missing bead IDs for dependency edge ${edge.from} -> ${edge.to}`);
-			continue;
-		}
-		const key = `${beadTo}|${beadFrom}`;
-		if (!actualDepSet.has(key)) missingRepairs.push({
-			from: edge.from,
-			to: edge.to,
-			beadFrom,
-			beadTo
-		});
-	}
-	for (const repair of missingRepairs) try {
-		await runBdWithRetry(`dep add ${repair.beadTo} ${repair.beadFrom}`, () => client.mutate([
-			"dep",
-			"add",
-			repair.beadTo,
-			repair.beadFrom
-		]), {
-			...retryOptions,
-			workspacePath
-		});
-		actualDepSet.add(`${repair.beadTo}|${repair.beadFrom}`);
-	} catch (error) {
-		errors.push(`Failed to repair dependency edge ${repair.from} -> ${repair.to}: ${execFileErrorMessage(error)}`);
-	}
-	for (const edge of blockEdges) {
-		const beadFrom = beadIds.get(edge.from);
-		const beadTo = beadIds.get(edge.to);
-		if (!beadFrom || !beadTo) continue;
-		const key = `${beadTo}|${beadFrom}`;
-		if (!actualDepSet.has(key)) errors.push(`Dependency edge ${edge.from} -> ${edge.to} still missing after repair`);
-	}
-	return {
-		success: errors.length === 0,
-		errors
-	};
-}
-/**
-* Delete a single bead, treating "issue not found" as success. Under contention
-* 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(client, id) {
-	try {
-		await client.mutate([
-			"delete",
-			id,
-			"--force"
-		]);
-	} catch (error) {
-		if (execFileErrorMessage(error).toLowerCase().includes("not found")) return;
-		throw error;
-	}
-}
-async function clearBeadsForIssue(workspacePath, issueLabel, timeoutMsOrOptions = {}) {
-	const options = normalizeClearBeadsOptions(timeoutMsOrOptions);
-	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);
-	} catch (error) {
-		return {
-			cleared: 0,
-			errors: [`list failed: ${execFileErrorMessage(error)}`],
-			transientFailure: error instanceof BdTransientFailure ? error : void 0
-		};
-	}
-	const errors = [];
-	let cleared = 0;
-	for (const id of beadIdsFromList(existingBeads)) try {
-		await runBdWithRetry(`delete bead ${id} for ${issueLabel}`, () => deleteBead(client, id), {
-			...options,
-			workspacePath
-		});
-		cleared++;
-	} catch (error) {
-		errors.push(`delete ${id}: ${execFileErrorMessage(error)}`);
-	}
-	let residualBeads;
-	try {
-		residualBeads = await listBeadsForIssue(workspacePath, issueLabel, options);
-	} catch (error) {
-		errors.push(`post-delete list failed: ${execFileErrorMessage(error)}`);
-		return {
-			cleared,
-			errors,
-			transientFailure: error instanceof BdTransientFailure ? error : void 0
-		};
-	}
-	const residualIds = beadIdsFromList(residualBeads);
-	if (residualIds.length > 0) errors.push(`residual ${residualIds.length} beads after delete: ${residualIds.join(", ")}`);
-	return {
-		cleared,
-		errors
-	};
-}
-function resolveInspectionMetadata(policy, item) {
-	if (policy === "never") return {
-		requiresInspection: false,
-		inspectionDepth: "fast"
-	};
-	if (policy === "fast") return {
-		requiresInspection: true,
-		inspectionDepth: "fast"
-	};
-	if (policy === "deep") return {
-		requiresInspection: true,
-		inspectionDepth: "deep"
-	};
-	return {
-		requiresInspection: typeof item.metadata?.requiresInspection === "boolean" ? item.metadata.requiresInspection : false,
-		inspectionDepth: item.metadata?.inspectionDepth === "deep" ? "deep" : "fast"
-	};
-}
-async function createBeadsFromVBriefPromise(workspacePath, options = {}) {
-	const { planPath, lockOptions, ...retryOptions } = options;
-	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();
-		try {
-			await execFileAsync("which", ["bd"], {
-				encoding: "utf-8",
-				timeout: 5e3
-			});
-		} catch {
-			return {
-				success: false,
-				created: [],
-				errors: ["bd (beads) CLI not found in PATH"],
-				beadIds
-			};
-		}
-		const beadsDir = join(workspacePath, ".beads");
-		const redirectPath = join(beadsDir, "redirect");
-		if (!existsSync(redirectPath)) {
-			mkdirSync(beadsDir, { recursive: true });
-			chmodSync(beadsDir, 448);
-			writeFileSync(redirectPath, resolveCanonicalBeadsHome(workspacePath) ?? "../../.beads", "utf8");
-		}
-		const doc = planPath ? readPlanSync(planPath) : readWorkspacePlanSync(workspacePath);
-		if (!doc) return {
-			success: false,
-			created: [],
-			errors: ["No plan.vbrief.json found in workspace"],
-			beadIds
-		};
-		const { plan } = doc;
-		const planEdges = plan.edges ?? [];
-		const inspectionPolicy = doc.vBRIEFInfo.inspectionPolicy ?? "auto";
-		const bdTimeoutMs = await resolveBdTimeout(workspacePath);
-		const issueLabel = plan.id.toLowerCase();
-		try {
-			await retryBd(() => execFileAsync("bd", ["ping", "--json"], {
-				encoding: "utf-8",
-				cwd: workspacePath,
-				timeout: bdTimeoutMs
-			}), { sleep: retryOptions.sleep });
-		} catch (connectError) {
-			try {
-				await execFileAsync("bd", ["doctor", "--fix"], {
-					encoding: "utf-8",
-					cwd: workspacePath,
-					timeout: bdTimeoutMs
-				});
-				await retryBd(() => execFileAsync("bd", ["ping", "--json"], {
-					encoding: "utf-8",
-					cwd: workspacePath,
-					timeout: bdTimeoutMs
-				}), { sleep: retryOptions.sleep });
-			} catch (retryError) {
-				return {
-					success: false,
-					created: [],
-					errors: [`beads probe failed after recovery (${execFileErrorMessage(retryError ?? connectError).split("\n")[0]})`],
-					beadIds
-				};
-			}
-		}
-		const clearResult = await clearBeadsForIssueWithClient(bd, workspacePath, issueLabel, {
-			...retryOptions,
-			timeoutMs: bdTimeoutMs
-		});
-		if (clearResult.errors.length > 0) return {
-			success: false,
-			created: [],
-			errors: clearResult.errors.map((error) => `dedup failed: ${error}`),
-			transientFailure: clearResult.transientFailure,
-			beadIds: /* @__PURE__ */ new Map()
-		};
-		if (clearResult.cleared > 0) console.log(`[beads] Cleared ${clearResult.cleared} existing beads for ${issueLabel} (verified)`);
-		const blockers = /* @__PURE__ */ new Map();
-		for (const item of plan.items) blockers.set(item.id, /* @__PURE__ */ new Set());
-		for (const edge of planEdges) if (edge.type === "blocks") {
-			const blockersOfTo = blockers.get(edge.to);
-			if (blockersOfTo) blockersOfTo.add(edge.from);
-		}
-		const inDegree = /* @__PURE__ */ new Map();
-		const adjacency = /* @__PURE__ */ new Map();
-		for (const item of plan.items) {
-			inDegree.set(item.id, 0);
-			adjacency.set(item.id, []);
-		}
-		for (const edge of planEdges) if (edge.type === "blocks") {
-			inDegree.set(edge.to, (inDegree.get(edge.to) ?? 0) + 1);
-			adjacency.get(edge.from)?.push(edge.to);
-		}
-		const queue = [];
-		for (const item of plan.items) if ((inDegree.get(item.id) ?? 0) === 0) queue.push(item.id);
-		const itemById = new Map(plan.items.map((i) => [i.id, i]));
-		const sortedIds = [];
-		while (queue.length > 0) {
-			const id = queue.shift();
-			sortedIds.push(id);
-			for (const dependent of adjacency.get(id) ?? []) {
-				const newDegree = (inDegree.get(dependent) ?? 1) - 1;
-				inDegree.set(dependent, newDegree);
-				if (newDegree === 0) queue.push(dependent);
-			}
-		}
-		const orderedIds = sortedIds.length === plan.items.length ? sortedIds : plan.items.map((i) => i.id);
-		for (let i = 0; i < orderedIds.length; i++) {
-			const itemId = orderedIds[i];
-			const item = itemById.get(itemId);
-			if (!item) continue;
-			const fullTitle = `${plan.id}: ${item.title}`;
-			const difficulty = item.metadata?.difficulty ?? "medium";
-			const issueLabel = item.metadata?.issueLabel ?? plan.id.toLowerCase();
-			const phase = item.metadata?.phase;
-			const beadMetadata = {
-				...item.metadata ?? {},
-				vbriefItemId: itemId,
-				...resolveInspectionMetadata(inspectionPolicy, item)
-			};
-			const labels = [issueLabel, `difficulty:${difficulty}`];
-			if (phase !== void 0) labels.push(`phase-${phase}`);
-			const labelStr = labels.join(",");
-			const description = [item.narrative?.Action ?? "", subItemsOf(item).filter((s) => s.metadata?.kind === "acceptance_criterion").map((s) => `- AC: ${s.title}`).join("\n")].filter(Boolean).join("\n");
-			const dependencyBeadIds = [...blockers.get(itemId) ?? []].map((blockerId) => beadIds.get(blockerId) ?? null).filter((d) => d !== null);
-			const args = [
-				"create",
-				fullTitle,
-				"--type",
-				"task",
-				"--silent",
-				"-l",
-				labelStr,
-				"--metadata",
-				JSON.stringify(beadMetadata)
-			];
-			if (description) args.push("-d", description);
-			if (dependencyBeadIds.length > 0) args.push("--deps", dependencyBeadIds.join(","));
-			console.log(`[beads] (${i + 1}/${orderedIds.length}) creating "${item.title}"`);
-			let capturedBeadId = null;
-			let createFailureMessage = null;
-			try {
-				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 ?? ""));
-				const errMsg = error?.stderr?.toString() || error?.message || String(error);
-				const prefix = timedOut ? `timed out after ${Math.round(bdTimeoutMs / 1e3)}s` : errMsg.split("\n")[0];
-				createFailureMessage = `Failed to create "${item.title}": ${prefix}`;
-			}
-			if (capturedBeadId) {
-				beadIds.set(itemId, capturedBeadId);
-				created.push(fullTitle);
-			} else {
-				console.warn(`[beads] (${i + 1}/${orderedIds.length}) FAILED/EMPTY "${item.title}"; attempting title-based recovery`);
-				const recovered = await recoverBeadIdByTitle(workspacePath, issueLabel, fullTitle, bdTimeoutMs);
-				if (recovered.ambiguity) errors.push(`${createFailureMessage}; recovery found multiple beads titled "${fullTitle}"`);
-				else if (recovered.id) {
-					beadIds.set(itemId, recovered.id);
-					created.push(fullTitle);
-					console.log(`[beads] (${i + 1}/${orderedIds.length}) RECOVERED "${item.title}" as ${recovered.id}`);
-				} else errors.push(createFailureMessage ?? `Failed to create "${item.title}"`);
-			}
-		}
-		const edgeVerification = await verifyAndRepairDependencyEdges(bd, workspacePath, planEdges, beadIds, bdTimeoutMs, retryOptions);
-		errors.push(...edgeVerification.errors);
-		return {
-			success: errors.length === 0,
-			created,
-			errors,
-			beadIds
-		};
-	}));
-	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).
-*/
-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 readBeadTitle(beadId, workspacePath);
-		if (!beadTitle) return null;
-		const planId = doc.plan.id;
-		const prefix = `${planId}: `;
-		const itemTitle = beadTitle.toLowerCase().startsWith(prefix.toLowerCase()) ? beadTitle.slice(prefix.length) : beadTitle;
-		const itemTitleLower = itemTitle.toLowerCase();
-		const matchingItem = doc.plan.items.find((i) => i.title.toLowerCase() === itemTitleLower);
-		if (!matchingItem) {
-			console.warn(`[vbrief-sync] No plan item matches bead ${beadId} (title "${itemTitle}") in plan ${planId} — AC statuses for this bead were NOT synced`);
-			return null;
-		}
-		updateItemStatus(workspacePath, matchingItem.id, status);
-		if (status === "completed") {
-			for (const sub of subItemsOf(matchingItem)) if (sub.metadata?.kind === "acceptance_criterion" && sub.status !== "completed") updateSubItemStatus(workspacePath, matchingItem.id, sub.id, "completed");
-		}
-		console.log(`[vbrief-sync] Updated item "${matchingItem.id}" to "${status}" from bead ${beadId}`);
-		return matchingItem.id;
-	} catch (err) {
-		console.warn(`[vbrief-sync] Failed to sync bead ${beadId}: ${err.message}`);
-		return null;
-	}
-}
-/**
-* Get structured AC status from a workspace's vBRIEF plan.
-*
-* Returns per-item AC counts (completed/pending/total) plus an overall
-* allCompleted flag. Returns null if no plan exists or no AC are found
-* (legacy workspace compatibility).
-*
-* Used by: verification gate, pan done, merge agent, prompt injection.
-*/
-function getVBriefACStatusSync(workspacePath) {
-	const doc = readWorkspacePlanSync(workspacePath);
-	if (!doc) return null;
-	const allCriteria = extractACFromDocument(doc);
-	if (allCriteria.length === 0) return null;
-	const itemMap = /* @__PURE__ */ new Map();
-	for (const ac of allCriteria) {
-		let item = itemMap.get(ac.itemId);
-		if (!item) {
-			item = {
-				itemId: ac.itemId,
-				itemTitle: ac.itemTitle,
-				completed: 0,
-				pending: 0,
-				total: 0,
-				criteria: []
-			};
-			itemMap.set(ac.itemId, item);
-		}
-		item.total++;
-		item.criteria.push(ac);
-		if (ac.status === "completed" || ac.status === "cancelled") item.completed++;
-		else item.pending++;
-	}
-	const items = Array.from(itemMap.values());
-	const totalCompleted = items.reduce((sum, i) => sum + i.completed, 0);
-	const totalPending = items.reduce((sum, i) => sum + i.pending, 0);
-	const totalCount = totalCompleted + totalPending;
-	return {
-		allCompleted: totalPending === 0,
-		items,
-		totalCompleted,
-		totalPending,
-		totalCount
-	};
-}
-/** Tagged error for beads Effect variants. */
-var BeadsOperationError = class extends Data.TaggedError("BeadsOperationError") {};
-/**
-* Idempotent and internally serialized via bd-mutex. Calling N times yields
-* exactly planItemCount beads or returns success:false with errors. Do NOT wrap
-* callers in withBdMutex — it will deadlock.
-*/
-const createBeadsFromVBrief = (workspacePath, options = {}) => Effect.tryPromise({
-	try: () => createBeadsFromVBriefPromise(workspacePath, options),
-	catch: (cause) => new BeadsOperationError({
-		operation: "createBeadsFromVBrief",
-		workspacePath,
-		message: cause instanceof Error ? cause.message : String(cause),
-		cause
-	})
-});
-/** Effect variant of `syncBeadStatusToVBrief`. */
-const syncBeadStatusToVBrief = (beadId, workspacePath, status = "completed", knownTitle) => Effect.tryPromise({
-	try: () => syncBeadStatusToVBriefPromise(beadId, workspacePath, status, knownTitle),
-	catch: (cause) => new BeadsOperationError({
-		operation: "syncBeadStatusToVBrief",
-		workspacePath,
-		message: cause instanceof Error ? cause.message : String(cause),
-		cause
-	})
-});
-/** Effect variant of `getVBriefACStatus`. */
-const getVBriefACStatus = (workspacePath) => Effect.try({
-	try: () => getVBriefACStatusSync(workspacePath),
-	catch: (cause) => new BeadsOperationError({
-		operation: "getVBriefACStatus",
-		workspacePath,
-		message: cause instanceof Error ? cause.message : String(cause),
-		cause
-	})
-});
-//#endregion
-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-BeSMEjGT.js.map