@overdeck/desktop 0.49.1 → 0.50.0

package/server/deacon-swarm-BiLfNm_v.js

@@ -1,1522 +0,0 @@
-import { E as init_tier_table, It as isStatePlaneOnlyStatus, J as getProjectConfigFromWorkspacePath, K as getIssueRecordPathForWorkspace, Mt as init_state_plane, O as resolveTieredExecutionEnabled, On as resolveProjectFromIssueSync, Y as init_record, et as readIssueRecordForWorkspaceSync, fn as init_projects, on as getProjectSync, p as loadConfigSync, rt as resolveProjectForIssue, t as init_config_yaml, tt as readIssueRecordSync, vn as listProjectsSync } from "./config-yaml-BwOEANMr.js";
-import { a as updateIssueRecord, i as init_record_update, o as updateIssueRecordForWorkspace } from "./record-update-D23jPU6b.js";
-import { A as listSessionNames, B as sessionExists, O as listPaneValues, S as init_tmux, r as capturePane, w as isPaneDead } from "./tmux-BqXzRuaH.js";
-import { $ as loadPrdDraft, Dr as resolveTier, Er as init_resolve_tier, Fn as getConcurrencyLimits, Gn as getCachedMemoryVerdict, In as init_concurrency, Kn as init_memory_verdict_cache, Lt as init_messaging, Mn as countRunningSwarmSlotsForIssue, Q as init_tier_supervisor, Qt as init_spawn, Rn as releaseSwarmSlot, Rt as messageAgent, Si as init_agent_runtime, Vn as tryReserveSwarmSlot, Z as deliverCommitForReview, _r as defaultRunWorkspace, ct as listSlotAssignments, d as getAgentResumeGateBlockReason, en as spawnRun, et as shouldSupervise, h as init_agent_state, ht as init_pending_decision_gate, in as stopAgent, it as init_tier_feed, l as decideResumeGate, lt as reconcileSlotState, m as getAgentStateSync, mt as detectPendingOperatorDecision, nt as supervisorAgentId, rn as init_termination, rt as broadcastCommit, st as init_slot_reconcile, tt as spawnTierSupervisor, u as getAgentDir, vr as init_spawn_prep, xi as getAgentRuntimeSnapshot } from "./agent-state-Bb3UUxQm.js";
-import { c as init_control_settings, d as isDeaconGloballyPausedSync } from "./control-settings-5k6ixdFW.js";
-import { C as init_specs, S as findSpecByIssue, b as subItemsOf, f as readPlanSync, i as findPlanSync, n as applyStatusOverrides, s as init_io, y as init_types } from "./io-DfvO2xyh.js";
-import { i as createActiveSlice, l as init_dag, n as blockingParentCount, o as getDispatchableItems } from "./dag-DI9LaK_q.js";
-import { a as loadCloisterConfigSync, r as init_config } from "./config-DC75T4Mr.js";
-import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-D8R-LWX5.js";
-import { d as getReviewStatusSync, p as init_review_status, w as setReviewStatusSync } from "./review-status-DBnR5t4z.js";
-import { i as recordRecoveryFailure, r as init_recovery_trip, t as acknowledgeRecoveryTrip } from "./recovery-trip-C4dTl8DO.js";
-import { basename, join } from "node:path";
-import { Effect } from "effect";
-import { existsSync, readdirSync } from "fs";
-import { join as join$1 } from "path";
-import { hostname } from "node:os";
-import { existsSync as existsSync$1 } from "node:fs";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-//#region ../../lib/agents/slot-merge.ts
-init_projects();
-init_record();
-init_tier_table();
-init_config_yaml();
-init_tmux();
-init_agent_runtime();
-init_control_settings();
-init_specs();
-init_types();
-init_io();
-init_dag();
-init_config();
-init_memory_verdict_cache();
-init_concurrency();
-init_termination();
-init_spawn();
-init_agent_state();
-init_spawn_prep();
-const execAsync$3 = promisify(exec);
-async function verifyAndMergeSlot(issue, slotIndex, item, options = {}) {
-	const issueId = typeof issue === "string" ? issue : issue.issueId;
-	const featureWorkspace = typeof issue === "string" ? defaultRunWorkspace(issue) : issue.featureWorkspace ?? defaultRunWorkspace(issue.issueId);
-	const slotWorkspace = `${featureWorkspace}-slot-${slotIndex}`;
-	const slotBranch = `feature/${issueId.toLowerCase()}-slot-${slotIndex}`;
-	const deps = {
-		run: async (command, cwd) => execAsync$3(command, { cwd }),
-		...options.deps
-	};
-	const verifyCommands = item.metadata?.verify_commands ?? [];
-	const expectedOutputs = item.metadata?.expected_outputs ?? [];
-	const evidence = {
-		verifyCommands,
-		expectedOutputs,
-		commandOutputs: []
-	};
-	if (!Number.isInteger(slotIndex) || slotIndex < 1) return {
-		verified: false,
-		merged: false,
-		conflicts: false,
-		evidence,
-		failure: `Invalid slot index: ${slotIndex}`
-	};
-	if (verifyCommands.length === 0) return {
-		verified: false,
-		merged: false,
-		conflicts: false,
-		evidence,
-		failure: `Item ${item.id} has no verify_commands`
-	};
-	if (expectedOutputs.length === 0) return {
-		verified: false,
-		merged: false,
-		conflicts: false,
-		evidence,
-		failure: `Item ${item.id} has no expected_outputs`
-	};
-	for (const command of verifyCommands) try {
-		const output = await deps.run(command, slotWorkspace);
-		evidence.commandOutputs.push({
-			command,
-			stdout: output.stdout,
-			stderr: output.stderr
-		});
-	} catch (error) {
-		const failed = commandFailure(error);
-		evidence.commandOutputs.push({
-			command,
-			stdout: failed.stdout,
-			stderr: failed.stderr
-		});
-		return {
-			verified: false,
-			merged: false,
-			conflicts: false,
-			evidence,
-			failure: `Verify command failed for ${item.id}: ${command}`
-		};
-	}
-	try {
-		evidence.mergeOutput = await deps.run(`git merge --no-ff ${JSON.stringify(slotBranch)}`, featureWorkspace);
-		return {
-			verified: true,
-			merged: true,
-			conflicts: false,
-			evidence
-		};
-	} catch (error) {
-		const failed = commandFailure(error);
-		evidence.mergeOutput = {
-			stdout: failed.stdout,
-			stderr: failed.stderr
-		};
-		await deps.run("git merge --abort", featureWorkspace).catch(() => {});
-		return {
-			verified: true,
-			merged: false,
-			conflicts: true,
-			evidence,
-			failure: `Slot branch ${slotBranch} did not merge cleanly`
-		};
-	}
-}
-function commandFailure(error) {
-	const partial = error;
-	return {
-		stdout: typeof partial.stdout === "string" ? partial.stdout : "",
-		stderr: typeof partial.stderr === "string" ? partial.stderr : typeof partial.message === "string" ? partial.message : String(error)
-	};
-}
-//#endregion
-//#region ../../lib/pan-dir/task-door.ts
-init_state_plane();
-init_swarm_readiness();
-init_slot_reconcile();
-/** Single task-mutation write door over the immutable xBRIEF specification. */
-init_record_update();
-var TaskStatusChangeError = class extends Error {
-	constructor(message, details) {
-		super(message);
-		this.details = details;
-		this.name = "TaskStatusChangeError";
-	}
-};
-const TERMINAL = new Set(["completed", "cancelled"]);
-function statusFor(type) {
-	if (type === "claim") return "running";
-	if (type === "done") return "completed";
-	if (type === "block") return "blocked";
-	if (type === "unblock") return "pending";
-	return "cancelled";
-}
-function subItemOverrideKey(itemId, subItemId) {
-	return subItemId.includes(".") ? subItemId : `${itemId}.${subItemId}`;
-}
-function allowedFrom(type, status) {
-	if (type === "claim") return status === "pending";
-	if (type === "done") return status === "running";
-	if (type === "block") return status === "pending" || status === "running";
-	if (type === "unblock") return status === "blocked";
-	return status === "pending" || status === "running" || status === "blocked";
-}
-function taskError(issueId, itemId, operation, currentStatus, owner, extra) {
-	const ownerText = owner ? ` The current claim owner is ${owner}.` : "";
-	const recovery = `Run \`pan task show ${issueId} ${itemId}\` to inspect the current task state before retrying.`;
-	return new TaskStatusChangeError(`Task ${itemId} on ${issueId} is ${currentStatus}, so ${operation} is not allowed.${ownerText}${extra ? ` ${extra}` : ""} ${recovery}`, {
-		issueId,
-		itemId,
-		operation,
-		currentStatus,
-		owner
-	});
-}
-function archiveClaim(record, itemId, outcome, reason, forced, now) {
-	const claim = record.tasks?.claims[itemId];
-	if (!claim || !record.tasks) return;
-	const entry = {
-		...claim,
-		itemId,
-		outcome,
-		reason,
-		forced: forced || void 0,
-		releasedAt: now
-	};
-	record.tasks.claimHistory = [...record.tasks.claimHistory ?? [], entry].slice(-50);
-	delete record.tasks.claims[itemId];
-}
-async function applyTaskStatusChange(project, issueId, operation) {
-	const normalizedIssueId = issueId.toUpperCase();
-	const writerId = operation.writerId ?? process.env.OVERDECK_AGENT_ID ?? `cli-${process.pid}@${hostname()}`;
-	let result;
-	await updateIssueRecord(project, normalizedIssueId, (record) => {
-		const planPath = findPlanSync(join(project.path, "workspaces", `feature-${normalizedIssueId.toLowerCase()}`));
-		if (!planPath) throw new Error(`The xBRIEF for ${normalizedIssueId} is missing or unreadable. Return the issue to planning before changing task state.`);
-		const item = applyStatusOverrides(readPlanSync(planPath), record.statusOverrides ?? {}).plan.items.find(({ id }) => id === operation.itemId);
-		if (!item) throw new Error(`Task ${operation.itemId} does not exist in the immutable xBRIEF for ${normalizedIssueId}. Return the issue to planning to change scope.`);
-		const currentStatus = item.status;
-		const currentSequence = record.tasks?.sequence ?? 0;
-		const existingClaim = record.tasks?.claims[operation.itemId];
-		const nextStatus = statusFor(operation.type);
-		const subItems = subItemsOf(item);
-		const subIds = operation.subItemIds?.length ? new Set(operation.subItemIds) : new Set(operation.type === "done" || operation.type === "cancel" ? subItems.map(({ id }) => id) : []);
-		const repeatedCancellation = operation.type === "cancel" && currentStatus === "cancelled";
-		if (operation.expectedSequence !== void 0 && operation.expectedSequence !== currentSequence) throw new TaskStatusChangeError(`Task sequence conflict for ${normalizedIssueId}: expected ${operation.expectedSequence}, but the current sequence is ${currentSequence}. Run \`pan task next ${normalizedIssueId}\` and retry with the new sequence.`, {
-			issueId: normalizedIssueId,
-			itemId: operation.itemId,
-			operation: operation.type,
-			currentStatus,
-			currentSequence
-		});
-		if (TERMINAL.has(currentStatus) && !repeatedCancellation) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId);
-		if (operation.force && !operation.reason) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId, "A forced transition requires --reason.");
-		if ((operation.type === "block" || operation.type === "cancel") && !operation.reason) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId, "This transition requires --reason.");
-		if (repeatedCancellation && subItems.every((subItem) => subItem.status === "cancelled")) {
-			result = {
-				issueId: normalizedIssueId,
-				itemId: operation.itemId,
-				status: "cancelled",
-				sequence: currentSequence,
-				idempotent: true
-			};
-			return record;
-		}
-		if (operation.type === "claim" && currentStatus === "running" && existingClaim?.writerId === writerId) {
-			result = {
-				issueId: normalizedIssueId,
-				itemId: operation.itemId,
-				status: "running",
-				sequence: currentSequence,
-				claim: existingClaim,
-				idempotent: true
-			};
-			return record;
-		}
-		const ownerRestricted = (operation.type === "done" || operation.type === "block" || operation.type === "cancel") && currentStatus === "running";
-		if (!operation.force && ownerRestricted && existingClaim?.writerId !== writerId) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId ?? "missing claim owner");
-		if (!operation.force && !repeatedCancellation && !allowedFrom(operation.type, currentStatus)) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId);
-		const now = (/* @__PURE__ */ new Date()).toISOString();
-		record.tasks ??= {
-			sequence: 0,
-			claims: {}
-		};
-		record.statusOverrides = {
-			...record.statusOverrides ?? {},
-			[operation.itemId]: nextStatus
-		};
-		for (const subId of subIds) record.statusOverrides[subItemOverrideKey(operation.itemId, subId)] = nextStatus;
-		if (operation.type === "claim") record.tasks.claims[operation.itemId] = {
-			writerId,
-			agentId: process.env.OVERDECK_AGENT_ID ?? null,
-			pid: process.pid,
-			host: hostname(),
-			claimedAt: now
-		};
-		else if (existingClaim) archiveClaim(record, operation.itemId, nextStatus === "completed" ? "completed" : nextStatus === "blocked" ? "blocked" : "cancelled", operation.reason, operation.force ?? false, now);
-		if (operation.reason) record.tasks.statusReasons = {
-			...record.tasks.statusReasons ?? {},
-			[operation.itemId]: {
-				reason: operation.reason,
-				updatedAt: now,
-				forced: operation.force || void 0
-			}
-		};
-		record.tasks.sequence = currentSequence + 1;
-		result = {
-			issueId: normalizedIssueId,
-			itemId: operation.itemId,
-			status: nextStatus,
-			sequence: record.tasks.sequence,
-			claim: record.tasks.claims[operation.itemId]
-		};
-		return record;
-	}, { writerId });
-	if (!result) throw new Error(`Task mutation for ${normalizedIssueId}/${operation.itemId} produced no result.`);
-	return result;
-}
-//#endregion
-//#region ../../lib/swarm-policy.ts
-init_review_status();
-function resolveSwarmPolicyLayers(global = {}, project = {}, issue = {}, cli = {}) {
-	const resolve = (key, fallback) => {
-		for (const [source, layer] of [
-			["cli", cli],
-			["issue", issue],
-			["project", project],
-			["global", global]
-		]) if (layer[key] !== void 0) return {
-			value: layer[key],
-			source
-		};
-		return {
-			value: fallback,
-			source: "default"
-		};
-	};
-	const mode = resolve("mode", "off");
-	const maxSlots = resolve("maxSlots", 3);
-	const autoAdvance = resolve("autoAdvance", true);
-	return {
-		mode: mode.value,
-		maxSlots: maxSlots.value,
-		autoAdvance: autoAdvance.value,
-		source: {
-			mode: mode.source,
-			maxSlots: maxSlots.source,
-			autoAdvance: autoAdvance.source
-		}
-	};
-}
-function resolveSwarmPolicy(issueId, cli = {}) {
-	const global = loadConfigSync().config.swarm;
-	if (!issueId) return resolveSwarmPolicyLayers(global, {}, {}, cli);
-	const resolved = resolveProjectFromIssueSync(issueId);
-	const project = resolved ? getProjectSync(resolved.projectKey) : void 0;
-	const issue = project ? readIssueRecordSync(project, issueId)?.swarm?.policy : void 0;
-	return resolveSwarmPolicyLayers(global, project?.swarm, issue, cli);
-}
-function resolveAutomaticSwarmPolicy(issueId, manual = false, inProgress = false) {
-	const policy = resolveSwarmPolicy(issueId);
-	return {
-		policy,
-		enabled: manual || policy.mode !== "off" && (policy.autoAdvance || !inProgress)
-	};
-}
-function resolveSwarmMaxSlots(issueId, configured) {
-	return Math.min(Math.max(1, Math.floor(configured)), Math.max(1, Math.floor(resolveSwarmPolicy(issueId).maxSlots)));
-}
-//#endregion
-//#region ../../lib/cloister/deacon-workspaces.ts
-init_projects();
-function listFeatureWorkspaces(options = {}) {
-	const includeSlotWorkspaces = options.includeSlotWorkspaces ?? true;
-	const projects = listProjectsSync();
-	const workspaces = [];
-	for (const { config: projectConfig } of projects) {
-		const workspacesRoot = join$1(projectConfig.path, "workspaces");
-		if (!existsSync(workspacesRoot)) continue;
-		let entries;
-		try {
-			entries = readdirSync(workspacesRoot, { withFileTypes: true }).filter((e) => e.isDirectory() && e.name.startsWith("feature-")).filter((e) => includeSlotWorkspaces || !/-slot-\d+$/.test(e.name)).map((e) => e.name);
-		} catch {
-			continue;
-		}
-		for (const entry of entries) workspaces.push({
-			issueId: entry.replace(/^feature-/, "").toUpperCase(),
-			workspacePath: join$1(workspacesRoot, entry),
-			projectPath: projectConfig.path
-		});
-	}
-	return workspaces;
-}
-//#endregion
-//#region ../../lib/cloister/deacon-swarm-orphan-gc.ts
-/**
-* Reconcile GC for truly-orphaned slots (PAN-2214, completes PAN-2213(c)).
-*
-* An orphan is a slot index with an on-disk worktree or a local slot branch but
-* no slotAssignments entry and no live agent tmux session. Zero-commit-ahead
-* orphans are removed; orphans with unmerged commits are only reported so the
-* operator can push them via `pan swarm reset` — never deleted.
-*/
-async function gcOrphanedSlots(issueId, workspacePath, reconciled, deps) {
-	const actions = [];
-	const issueLower = issueId.toLowerCase();
-	const worktreeSlotIndexes = await listSlotWorktreeIndexes(workspacePath, deps.runGitCommand);
-	const branchesBySlot = new Map(reconciled.branches.map((branch) => [branch.slotIndex, branch.branch]));
-	const candidateSlotIndexes = [...new Set([...worktreeSlotIndexes, ...branchesBySlot.keys()])].sort((a, b) => a - b);
-	if (candidateSlotIndexes.length === 0) return actions;
-	const ownedSlotIndexes = new Set([
-		...(deps.listSlotAssignments ?? listSlotAssignments)(issueId, workspacePath).map((assignment) => assignment.slotIndex),
-		...reconciled.merged.map((slot) => slot.slotIndex),
-		...reconciled.inFlight.map((slot) => slot.slotIndex)
-	]);
-	const sessionNames = new Set(await deps.listSessionNames());
-	for (const slotIndex of candidateSlotIndexes) {
-		if (ownedSlotIndexes.has(slotIndex)) continue;
-		if (sessionNames.has(`agent-${issueLower}-slot-${slotIndex}`)) continue;
-		const branch = branchesBySlot.get(slotIndex);
-		const aheadCount = branch ? await countCommitsAhead(workspacePath, branch, deps.runGitCommand) : 0;
-		if (aheadCount === null || aheadCount > 0) {
-			actions.push(`[swarm] orphan slot ${slotIndex} for ${issueId} preserved: ${branch} has ${aheadCount ?? "an unknown number of"} unmerged commit(s) — run \`pan swarm reset ${issueId}\` to push it to origin before cleanup`);
-			continue;
-		}
-		if (worktreeSlotIndexes.has(slotIndex)) await deps.runGitCommand(`git worktree remove --force ${JSON.stringify(`${workspacePath}-slot-${slotIndex}`)}`, workspacePath);
-		if (branch) await deps.runGitCommand(`git branch -D ${JSON.stringify(branch)}`, workspacePath);
-		actions.push(`[swarm] gc-orphan slot ${slotIndex} for ${issueId}`);
-	}
-	return actions;
-}
-async function listSlotWorktreeIndexes(workspacePath, runGitCommand) {
-	const indexes = /* @__PURE__ */ new Set();
-	try {
-		const result = await runGitCommand("git worktree list --porcelain", workspacePath);
-		const pattern = new RegExp(`^worktree ${escapeRegExp(workspacePath)}-slot-(\\d+)$`);
-		for (const line of String(result?.stdout ?? "").split("\n")) {
-			const match = pattern.exec(line.trim());
-			if (match) indexes.add(Number(match[1]));
-		}
-	} catch {}
-	return indexes;
-}
-async function countCommitsAhead(workspacePath, branch, runGitCommand) {
-	try {
-		const result = await runGitCommand(`git rev-list --count HEAD..${JSON.stringify(branch)}`, workspacePath);
-		const count = Number(String(result?.stdout ?? "").trim());
-		return Number.isFinite(count) ? count : null;
-	} catch {
-		return null;
-	}
-}
-function escapeRegExp(value) {
-	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-//#endregion
-//#region ../../lib/cloister/deacon-swarm-completion.ts
-init_messaging();
-const execAsync$2 = promisify(exec);
-const slotCompletionObservations = /* @__PURE__ */ new Map();
-async function classifyDoneWithoutSignal(slot, deps, options, observation) {
-	const mode = options.inferCompletion ?? "off";
-	if (mode === "off" || !slot.agentId || !slot.branch || !options.workspacePath || !options.issueId) {
-		slotCompletionObservations.delete(observation.progressKey);
-		return null;
-	}
-	const aheadCount = await (deps.getSlotBranchAheadCount ?? defaultGetSlotBranchAheadCount)(options.workspacePath, options.issueId, slot.branch).catch(() => 0);
-	const clean = await (deps.isSlotWorktreeClean ?? defaultIsSlotWorktreeClean)(`${options.workspacePath}-slot-${slot.slotIndex}`).catch(() => false);
-	if (aheadCount < 1 || !clean) {
-		slotCompletionObservations.delete(observation.progressKey);
-		return null;
-	}
-	const signature = `${observation.commitTime ?? "none"}:${observation.outputDigest}:${aheadCount}:clean`;
-	const previous = slotCompletionObservations.get(observation.progressKey);
-	const current = {
-		signature,
-		nudged: previous?.signature === signature ? previous.nudged : false,
-		consecutiveDoneCount: previous?.signature === signature ? previous.consecutiveDoneCount + 1 : 1
-	};
-	const actions = [];
-	const normalizedIssueId = options.issueId.toUpperCase();
-	if (!current.nudged) {
-		await (deps.sendCompletionNudge ?? defaultSendCompletionNudge)(slot.agentId, normalizedIssueId);
-		current.nudged = true;
-		actions.push(`[swarm] nudged slot ${slot.slotIndex} (item ${slot.itemId}) for ${normalizedIssueId}: run pan done ${normalizedIssueId}`);
-	}
-	slotCompletionObservations.set(observation.progressKey, current);
-	if (mode === "auto" && current.consecutiveDoneCount >= 2) return {
-		...slot,
-		lifecycle: "ready-to-merge",
-		exitStatus: 0,
-		signal: "inferred",
-		actions
-	};
-	return {
-		...slot,
-		lifecycle: "awaiting-completion-signal",
-		reason: "no-progress-timeout",
-		stalledForMs: observation.stalledForMs,
-		signal: "completion-nudge",
-		actions
-	};
-}
-async function classifyDurableReadySlot(slot, deps, options) {
-	if (!slot.branch || !options.workspacePath || !options.issueId) return null;
-	if (await (deps.getSlotBranchAheadCount ?? defaultGetSlotBranchAheadCount)(options.workspacePath, options.issueId, slot.branch).catch(() => 0) < 1) return null;
-	if (!await (deps.isSlotWorktreeClean ?? defaultIsSlotWorktreeClean)(`${options.workspacePath}-slot-${slot.slotIndex}`).catch(() => false)) return null;
-	return {
-		...slot,
-		lifecycle: "ready-to-merge",
-		exitStatus: 0,
-		signal: "inferred"
-	};
-}
-function clearSwarmCompletionObservation(progressKey) {
-	slotCompletionObservations.delete(progressKey);
-}
-function swarmInferCompletionMode() {
-	const raw = process.env.PAN_SWARM_INFER_COMPLETION ?? loadCloisterConfigSync().swarm?.infer_completion;
-	return raw === "off" || raw === "nudge" || raw === "auto" ? raw : "auto";
-}
-async function defaultGetSlotBranchAheadCount(workspacePath, issueId, branch) {
-	const baseBranch = `feature/${issueId.toLowerCase()}`;
-	const { stdout } = await execAsync$2(`git rev-list --count ${JSON.stringify(baseBranch)}..${JSON.stringify(branch)}`, { cwd: workspacePath });
-	const count = Number(stdout.trim());
-	return Number.isFinite(count) && count > 0 ? count : 0;
-}
-async function defaultIsSlotWorktreeClean(slotWorkspacePath) {
-	const { stdout } = await execAsync$2("git status --porcelain", { cwd: slotWorkspacePath });
-	return isStatePlaneOnlyStatus(stdout);
-}
-async function defaultSendCompletionNudge(agentId, issueId) {
-	await messageAgent(agentId, `You appear to have committed clean slot work but have not signaled completion. If the slot is complete, run exactly:\n\npan done ${issueId}`, "deacon:swarm-completion-inference");
-}
-//#endregion
-//#region ../../lib/cloister/deacon-swarm-finalization.ts
-init_io();
-async function defaultRequestIssueReview(issueId, workspacePath) {
-	setReviewStatusSync(issueId, {
-		reviewStatus: "pending",
-		testStatus: "pending",
-		mergeStatus: "pending",
-		readyForMerge: false,
-		verificationStatus: "pending",
-		verificationCycleCount: 0,
-		autoRequeueCount: 0,
-		reviewRequestedAt: (/* @__PURE__ */ new Date()).toISOString()
-	});
-	const { spawnReviewRoleForIssue } = await import("./review-agent-BUNTVJK2.js");
-	return Effect.runPromise(spawnReviewRoleForIssue({
-		issueId,
-		workspace: workspacePath,
-		branch: `feature/${issueId.toLowerCase()}`
-	}));
-}
-async function finalizeSwarmIssueIfComplete(issueId, workspacePath, baseDoc, deps) {
-	const overrides = deps.readStatusOverrides?.(workspacePath, issueId);
-	if (!(overrides && Object.keys(overrides).length > 0 ? applyStatusOverrides(baseDoc, overrides) : baseDoc).plan.items.every((item) => item.status === "completed")) return [];
-	if (deps.getFinalizedAt?.(issueId, workspacePath)) return [];
-	const currentStatus = getReviewStatusSync(issueId);
-	if (currentStatus?.mergeStatus === "merged") return [];
-	if (currentStatus?.reviewRequestedAt || currentStatus?.reviewStatus === "reviewing" || currentStatus?.reviewStatus === "passed") return [];
-	const result = await deps.requestIssueReview(issueId, workspacePath);
-	if (result.success) {
-		deps.setFinalizedAt?.(issueId, workspacePath, (/* @__PURE__ */ new Date()).toISOString());
-		return [`[swarm] finalized ${issueId}: issue-level review requested`];
-	}
-	return [`[swarm] finalization deferred ${issueId}: ${result.error || result.message}`];
-}
-//#endregion
-//#region ../../lib/cloister/deacon-swarm-gc.ts
-const MERGED_LIVE_SLOT_IDLE_MS = 1800 * 1e3;
-async function reapMergedSlotAgent(issueId, slot, stopSlotAgent = (id) => Effect.runPromise(stopAgent(id))) {
-	const agentId = slot.agentId ?? `agent-${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
-	try {
-		await stopSlotAgent(agentId);
-		return `[swarm] reaped merged agent ${agentId}`;
-	} catch (err) {
-		return `[swarm] could not reap merged agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`;
-	}
-}
-async function gcMergedSlots(issueId, workspacePath, slots, deps) {
-	const actions = [];
-	const sessionNames = new Set(await deps.listSessionNames());
-	const worktreeExists = deps.slotWorktreeExists ?? existsSync$1;
-	for (const slot of slots) {
-		if (slot.status !== "merged") continue;
-		const agentId = slot.agentId ?? `agent-${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
-		if (sessionNames.has(agentId)) {
-			const completionProven = slot.mergedVia === "completed-status";
-			const lastActivity = (deps.getAgentLastActivity ?? ((id) => getAgentStateSync(id)?.lastActivity))(agentId);
-			const idleFor = lastActivity ? Date.now() - Date.parse(lastActivity) : 0;
-			if (!completionProven && (!Number.isFinite(idleFor) || idleFor < MERGED_LIVE_SLOT_IDLE_MS)) {
-				actions.push(`[swarm] gc skipped slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: agent session alive`);
-				continue;
-			}
-			await (deps.stopSlotAgent ?? ((id) => Effect.runPromise(stopAgent(id))))(agentId);
-			actions.push(completionProven ? `[swarm] gc reaped merged agent ${agentId}` : `[swarm] gc reaped idle merged agent ${agentId}`);
-		}
-		const slotWorkspace = `${workspacePath}-slot-${slot.slotIndex}`;
-		const slotBranch = slot.branch ?? `feature/${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
-		if (worktreeExists(slotWorkspace)) try {
-			await deps.runGitCommand(`git worktree remove --force ${JSON.stringify(slotWorkspace)}`, workspacePath);
-		} catch (error) {
-			actions.push(`[swarm] gc deferred slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: worktree remove failed: ${error instanceof Error ? error.message : String(error)}`);
-			continue;
-		}
-		try {
-			await deps.runGitCommand(`git branch -D ${JSON.stringify(slotBranch)}`, workspacePath);
-		} catch (error) {
-			actions.push(`[swarm] gc deferred slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: branch delete failed: ${error instanceof Error ? error.message : String(error)}`);
-			continue;
-		}
-		deps.clearSlotAssignment(workspacePath, issueId, slot.slotIndex, slot.itemId);
-		actions.push(`[swarm] gc slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}`);
-	}
-	return actions;
-}
-//#endregion
-//#region ../../lib/cloister/deacon-swarm-record.ts
-init_record();
-init_record_update();
-async function writeSwarmFinalizedAt(workspacePath, issueId, finalizedAt) {
-	await updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => ({
-		...record,
-		swarm: {
-			...record.swarm ?? {},
-			finalizedAt
-		}
-	}));
-}
-/**
-* PAN-2372 WI-3 / FR-6: clear a slot's completion marker once the coordinator
-* (WI-4) has consumed it (merge/requeue). No-op when no marker exists for the
-* slot, so callers can clear unconditionally on the terminal transition.
-*/
-async function clearSwarmSlotCompletion(workspacePath, issueId, slotIndex) {
-	const normalizedIssueId = issueId.toUpperCase();
-	const current = readIssueRecordForWorkspaceSync(workspacePath, normalizedIssueId);
-	if (!current?.swarm?.slotCompletions || !(String(slotIndex) in current.swarm.slotCompletions)) return;
-	await updateIssueRecordForWorkspace(workspacePath, normalizedIssueId, (record) => {
-		const existing = record.swarm?.slotCompletions;
-		if (!existing || !(String(slotIndex) in existing)) return record;
-		const next = { ...existing };
-		delete next[String(slotIndex)];
-		return {
-			...record,
-			swarm: {
-				...record.swarm,
-				slotCompletions: next
-			}
-		};
-	});
-}
-//#endregion
-//#region ../../lib/cloister/swarm-tiered-hooks.ts
-/**
-* PAN-2385 — tiered-execution commit hooks for the swarm dispatch path.
-*
-* The tier-feed and tier-supervisor libraries shipped with PAN-1791/2222 but
-* had no production caller: commits landed and neither the standing crew nor
-* the subscribe-policy supervisor ever heard about them (found live during
-* the first Standing Crew run, PAN-2383). This module is the ignition.
-*
-* Fired from mergeReadySlots after a slot's bead commits merge into the
-* feature workspace:
-*   1. broadcastCommit — every live slot agent hears the rendered diff
-*      (ingestion-only; everyone-hears-everything per docs/TIERED-EXECUTION.md).
-*   2. shouldSupervise(item, subscribe) → deliverCommitForReview — the
-*      standing supervisor reviews per its subscribe policy. This is
-*      independent of supervisor.owns_inspection, which only routes
-*      `pan inspect`.
-*
-* Both hooks are best-effort: the commit has already landed, so a delivery
-* failure logs loudly and never blocks the merge loop.
-*/
-init_config_yaml();
-init_resolve_tier();
-init_tier_feed();
-init_tier_supervisor();
-init_slot_reconcile();
-const execAsync$1 = promisify(exec);
-const defaultDeps$1 = {
-	loadConfig: loadConfigSync,
-	getHeadSha: async (workspacePath) => (await execAsync$1("git rev-parse HEAD", { cwd: workspacePath })).stdout.trim(),
-	listAssignments: listSlotAssignments,
-	isSessionAlive: (sessionName) => Effect.runPromise(sessionExists(sessionName)),
-	broadcast: broadcastCommit,
-	ensureSupervisor: spawnTierSupervisor,
-	deliverReview: deliverCommitForReview,
-	loadPrd: loadPrdDraft
-};
-/** Resolve the tier name a bead belongs to, for the feed header. Falls back to
-* the slot label when the tier table cannot resolve the item (fail-open here is
-* correct: the feed is informational and the commit has already landed). */
-function tierNameForItem(item, tiered, slotIndex) {
-	if (item) try {
-		return resolveTier(item, tiered).tierName;
-	} catch {}
-	return `slot-${slotIndex}`;
-}
-/**
-* Fire the commit feed + supervisor review for a bead whose commits just
-* merged into the feature workspace. Returns deacon action-log lines.
-*/
-async function fireTieredCommitHooks(options, deps = defaultDeps$1) {
-	const actions = [];
-	const { issueId, workspacePath, item, doc } = options;
-	let tiered;
-	try {
-		tiered = deps.loadConfig().config.tieredExecution;
-	} catch (err) {
-		actions.push(`[tiered] skipped commit hooks for ${issueId}: config load failed (${err instanceof Error ? err.message : String(err)})`);
-		return actions;
-	}
-	if (!tiered || !resolveTieredExecutionEnabled(tiered, doc.plan.metadata)) return actions;
-	let sha;
-	try {
-		sha = await deps.getHeadSha(workspacePath);
-	} catch (err) {
-		actions.push(`[tiered] commit hooks for ${issueId} item ${item.id} could not resolve HEAD: ${err instanceof Error ? err.message : String(err)}`);
-		return actions;
-	}
-	try {
-		const itemsById = new Map(doc.plan.items.map((planItem) => [planItem.id, planItem]));
-		const assignments = deps.listAssignments(issueId, workspacePath);
-		const listeners = [];
-		for (const assignment of assignments) {
-			if (!assignment.agentId) continue;
-			if (!await deps.isSessionAlive(assignment.agentId)) continue;
-			listeners.push({
-				tierName: tierNameForItem(itemsById.get(assignment.itemId), tiered, assignment.slotIndex),
-				agentId: assignment.agentId
-			});
-		}
-		if (listeners.length > 0) {
-			const delivered = (await deps.broadcast({
-				workspace: workspacePath,
-				issueId,
-				sha,
-				itemTitle: item.title,
-				itemId: item.id,
-				tiers: listeners,
-				feedConfig: tiered.feed
-			})).filter((delivery) => delivery.result.ok).length;
-			actions.push(`[tiered] broadcast commit ${sha.slice(0, 10)} (item ${item.id}) for ${issueId} to ${delivered}/${listeners.length} standing agents`);
-		}
-	} catch (err) {
-		actions.push(`[tiered] feed broadcast FAILED for ${issueId} item ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	try {
-		const supervisor = tiered.supervisor;
-		if (supervisor && shouldSupervise(item, supervisor.subscribe)) {
-			const agentId = supervisorAgentId(issueId);
-			if (!await deps.isSessionAlive(agentId)) {
-				await deps.ensureSupervisor(issueId, supervisor, { workspace: workspacePath });
-				actions.push(`[tiered] spawned standing supervisor ${agentId} for ${issueId}`);
-			}
-			const prdMarkdown = await deps.loadPrd(workspacePath, issueId).catch(() => void 0);
-			await deps.deliverReview({
-				supervisorAgentId: agentId,
-				workspacePath,
-				issueId,
-				item,
-				sha,
-				itemId: item.id,
-				prdMarkdown
-			});
-			actions.push(`[tiered] supervisor review dispatched for ${issueId} item ${item.id} (subscribe=${supervisor.subscribe})`);
-		}
-	} catch (err) {
-		actions.push(`[tiered] supervisor review FAILED for ${issueId} item ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
-	}
-	return actions;
-}
-//#endregion
-//#region ../../lib/cloister/redrive-gate.ts
-init_recovery_trip();
-/**
-* PAN-2543 shared autonomous re-drive gate.
-*
-* Recovery entry points classify agent gates, apply the intent policy, and
-* consult the cached memory verdict through this one function before acting.
-* Callers still reserve their role-specific concurrency slot after admission.
-*/
-init_agent_state();
-init_pending_decision_gate();
-function decideAutonomousRedrive(state, context = {}) {
-	const gateDecision = decideResumeGate(getAgentResumeGateBlockReason(state), "autonomous", context);
-	if (gateDecision.decision !== "proceed") return {
-		decision: "defer",
-		reason: gateDecision.reason,
-		...gateDecision.decision === "block" && gateDecision.needsYou ? { needsYou: true } : {}
-	};
-	const memoryVerdict = getCachedMemoryVerdict();
-	if (memoryVerdict && memoryVerdict.band !== "ok") return {
-		decision: "defer",
-		reason: `memory pressure is ${memoryVerdict.band}`
-	};
-	return {
-		decision: "proceed",
-		gateDecision
-	};
-}
-async function decideAgentAutonomousRedrive(state, agentDir, owesRework, deps = {}) {
-	const admission = decideAutonomousRedrive(state, {
-		hasCompletedHandoff: existsSync$1(join(agentDir, "completed")) || existsSync$1(join(agentDir, "completed.processed")),
-		owesRework
-	});
-	if (admission.decision === "defer") return admission;
-	const agentId = basename(agentDir);
-	const pendingDecision = await (deps.detectPendingOperatorDecision ?? detectPendingOperatorDecision)(agentId);
-	if (pendingDecision) return {
-		decision: "defer",
-		reason: `agent is waiting on an operator decision (${pendingDecision.reason})`,
-		needsYou: true
-	};
-	return admission;
-}
-//#endregion
-//#region ../../lib/cloister/swarm-failed-slot.ts
-init_record_update();
-init_agent_state();
-async function archiveFailedSwarmSlot(issueId, workspacePath, slot, deps, now = /* @__PURE__ */ new Date()) {
-	const normalized = issueId.toUpperCase();
-	const suffix = now.toISOString().replace(/[-:.TZ]/g, "");
-	const archivedStem = `slot-${slot.slotIndex}-failed-${suffix}`;
-	const oldWorktree = `${workspacePath}-slot-${slot.slotIndex}`;
-	const archivedWorktree = `${workspacePath}-${archivedStem}`;
-	const oldBranch = slot.branch ?? `feature/${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
-	const archivedBranch = `feature/${issueId.toLowerCase()}-${archivedStem}`;
-	if (existsSync$1(oldWorktree)) await deps.runGitCommand(`git worktree move ${JSON.stringify(oldWorktree)} ${JSON.stringify(archivedWorktree)}`, workspacePath);
-	await deps.runGitCommand(`git branch -m ${JSON.stringify(oldBranch)} ${JSON.stringify(archivedBranch)}`, workspacePath);
-	const attempt = {
-		slotIndex: slot.slotIndex,
-		itemId: slot.itemId,
-		agentId: slot.agentId,
-		branch: oldBranch,
-		archivedBranch,
-		...existsSync$1(archivedWorktree) ? { archivedWorktree } : {},
-		reason: slot.reason ?? "failed swarm slot",
-		supersededAt: now.toISOString()
-	};
-	await updateIssueRecordForWorkspace(workspacePath, normalized, (existing) => ({
-		...existing,
-		swarm: {
-			...existing.swarm ?? {},
-			supersededAttempts: [...existing.swarm?.supersededAttempts ?? [], attempt]
-		}
-	}));
-	await clearSwarmSlotCompletion(workspacePath, normalized, slot.slotIndex);
-	await deps.clearSlotAssignment(workspacePath, normalized, slot.slotIndex, slot.itemId);
-	return attempt;
-}
-async function requeueFailedSwarmSlots(issueId, workspacePath, classified, doc, reconciled, deps, blockedSlotIndexes = /* @__PURE__ */ new Set()) {
-	let nextDoc = doc;
-	const actions = [];
-	const decideAgentRedrive = deps.decideAgentAutonomousRedrive ?? decideAgentAutonomousRedrive;
-	const decideUnownedRedrive = deps.decideAutonomousRedrive ?? decideAutonomousRedrive;
-	const recordFailure = deps.recordRecoveryFailure ?? recordRecoveryFailure;
-	const acknowledgeTrip = deps.acknowledgeRecoveryTrip ?? acknowledgeRecoveryTrip;
-	for (const slot of classified.filter((candidate) => candidate.lifecycle === "failed")) {
-		if (blockedSlotIndexes.has(slot.slotIndex)) {
-			actions.push(`[swarm] skipped requeue slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: failed-merge block — awaiting operator recovery`);
-			continue;
-		}
-		const pendingDecisionRecoveryPath = "swarm-slot-pending-operator-decision";
-		const pendingDecisionGeneration = `${slot.itemId}:${slot.agentId ?? `slot-${slot.slotIndex}`}`;
-		const admission = slot.agentId ? await decideAgentRedrive(getAgentStateSync(slot.agentId) ?? {}, getAgentDir(slot.agentId), true) : decideUnownedRedrive({}, { owesRework: true });
-		if (admission.decision === "defer") {
-			if (admission.needsYou) {
-				if ((await recordFailure(workspacePath, issueId, pendingDecisionRecoveryPath, pendingDecisionGeneration, 1)).emitNeedsYou) actions.push(`[swarm] needs-you ${issueId}: failed slot ${slot.slotIndex} ${admission.reason}`);
-			}
-			actions.push(`[swarm] deferred failed slot ${slot.slotIndex}: ${admission.reason}`);
-			continue;
-		}
-		await acknowledgeTrip(workspacePath, issueId, pendingDecisionRecoveryPath, pendingDecisionGeneration);
-		const attempt = await archiveFailedSwarmSlot(issueId, workspacePath, slot, deps);
-		await deps.applyTaskOperationToPlanFile(issueId, {
-			type: "unblock",
-			itemId: slot.itemId,
-			writerId: "deacon-swarm",
-			reason: `Redispatch after ${slot.reason ?? "slot failure"}`
-		}, workspacePath);
-		reconciled.inFlight = reconciled.inFlight.filter((candidate) => candidate.itemId !== slot.itemId);
-		reconciled.superseded = [...reconciled.superseded ?? [], attempt];
-		nextDoc = {
-			...nextDoc,
-			plan: {
-				...nextDoc.plan,
-				items: nextDoc.plan.items.map((item) => item.id === slot.itemId ? {
-					...item,
-					status: "pending"
-				} : item)
-			}
-		};
-		actions.push(`[swarm] archived failed slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}`);
-		const failure = await recordFailure(workspacePath, issueId, "swarm-slot-requeue", slot.itemId);
-		if (failure.emitNeedsYou) actions.push(`[swarm] needs-you ${issueId}: slot item ${slot.itemId} failed ${failure.trip.tripCount} times`);
-	}
-	return {
-		doc: nextDoc,
-		actions
-	};
-}
-function applySupersededSlotHighWater(occupied, reconciled, configuredMax) {
-	const highWater = Math.max(0, ...(reconciled.superseded ?? []).map((attempt) => attempt.slotIndex));
-	if (highWater > 0) for (let index = 1; index <= highWater; index++) occupied.add(index);
-	return Math.max(configuredMax, highWater + 1);
-}
-//#endregion
-//#region ../../lib/cloister/deacon-swarm.ts
-init_slot_reconcile();
-init_record();
-init_record_update();
-init_tmux();
-init_io();
-init_review_status();
-const execAsync = promisify(exec);
-const SLOT_MERGE_REFIRE_COOLDOWN_MS = 5e3;
-const SWARM_ADVANCE_FAILURE_THRESHOLD = 3;
-const SWARM_ADVANCE_FAILURE_COOLDOWN_MS = 6e4;
-const DEFAULT_SWARM_STALL_THRESHOLD_MS = 1800 * 1e3;
-const recentSlotMergeFires = /* @__PURE__ */ new Map();
-const issueAdvanceFailures = /* @__PURE__ */ new Map();
-const failedMergeBlocks = /* @__PURE__ */ new Map();
-const slotProgressObservations = /* @__PURE__ */ new Map();
-const defaultDeps = {
-	listFeatureWorkspaces: () => listFeatureWorkspaces({ includeSlotWorkspaces: false }),
-	reconcileSlotState,
-	listSessionNames: () => Effect.runPromise(listSessionNames()),
-	isPaneDead: (sessionName) => Effect.runPromise(isPaneDead(sessionName)),
-	getPaneExitStatus: async (sessionName) => {
-		const raw = (await Effect.runPromise(listPaneValues(sessionName, "#{pane_dead_status}")))[0]?.trim();
-		if (!raw) return null;
-		const status = Number(raw);
-		return Number.isFinite(status) ? status : null;
-	},
-	getAgentRuntimeState: (agentId) => Effect.runPromise(getAgentRuntimeSnapshot(agentId)),
-	getPaneOutputDigest: async (sessionName) => Effect.runPromise(capturePane(sessionName, 200)),
-	getBranchTipCommitTime: async (workspacePath, branch) => {
-		try {
-			const { stdout } = await execAsync(`git log -1 --format=%ct ${JSON.stringify(branch)}`, { cwd: workspacePath });
-			const seconds = Number(stdout.trim());
-			return Number.isFinite(seconds) ? seconds * 1e3 : null;
-		} catch {
-			return null;
-		}
-	},
-	getSlotBranchAheadCount: defaultGetSlotBranchAheadCount,
-	isSlotWorktreeClean: defaultIsSlotWorktreeClean,
-	sendCompletionNudge: defaultSendCompletionNudge,
-	slotWorktreeExists: existsSync$1,
-	verifyAndMergeSlot,
-	applyTaskOperationToPlanFile: (issueId, operation, workspacePath = "") => {
-		return applyTaskStatusChange(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId, operation);
-	},
-	fireTieredCommitHooks,
-	recordSlotAssignment,
-	clearSlotAssignment,
-	runGitCommand: (command, cwd) => execAsync(command, { cwd }),
-	registeredSlotCapacityAvailable: (issueId, selectedCount) => registeredSlotCapacityAvailable(issueId, selectedCount),
-	tryReserveSwarmSlot,
-	releaseSwarmSlot,
-	spawnRun,
-	getIssueHold: defaultGetIssueHold,
-	shouldDispatch: defaultShouldDispatch,
-	getMaxSlotIndex: defaultGetMaxSlotIndex,
-	listSlotAssignments,
-	readStatusOverrides: defaultReadStatusOverrides,
-	readSlotCompletion: defaultReadSlotCompletion,
-	getFinalizedAt: getSwarmFinalizedAt,
-	setFinalizedAt: recordSwarmFinalizedAt,
-	requestIssueReview: defaultRequestIssueReview
-};
-function defaultGetMaxSlotIndex() {
-	return Math.max(1, getConcurrencyLimits().reservedSwarmSlots);
-}
-function defaultGetIssueHold(issueId) {
-	try {
-		return getReviewStatusSync(issueId);
-	} catch {
-		return null;
-	}
-}
-function defaultReadStatusOverrides(workspacePath, issueId) {
-	const normalized = issueId.toUpperCase();
-	const record = readIssueRecordForWorkspaceSync(workspacePath, normalized);
-	if (record === null && existsSync$1(getIssueRecordPathForWorkspace(workspacePath, normalized))) {
-		console.warn(`[swarm] record unreadable for ${normalized} — treating as no overrides; see .corrupt sidecar`);
-		return;
-	}
-	return record?.statusOverrides;
-}
-/**
-* PAN-2372 WI-4 / FR-6: read a slot's durable completion marker from the record
-* door. Returns undefined when no record or no marker exists. Used by
-* classifyInFlightSlots to recognize a slot whose `pan done` durably recorded
-* completion even when the runtime plane (agent state, tmux session) is gone.
-*/
-function defaultReadSlotCompletion(workspacePath, issueId, slotIndex) {
-	try {
-		return readIssueRecordForWorkspaceSync(workspacePath, issueId.toUpperCase())?.swarm?.slotCompletions?.[String(slotIndex)];
-	} catch {
-		return;
-	}
-}
-function defaultShouldDispatch(issueId) {
-	if (isDeaconGloballyPausedSync()) return false;
-	const hold = defaultGetIssueHold(issueId);
-	return !(hold?.stuck || hold?.deaconIgnored);
-}
-async function coordinateSwarmSlots(opts = {}, deps = defaultDeps) {
-	const actions = [];
-	const filterIssueId = opts.issueId?.toUpperCase();
-	for (const workspace of deps.listFeatureWorkspaces()) {
-		const issueId = workspace.issueId.toUpperCase();
-		if (filterIssueId && issueId !== filterIssueId) continue;
-		const hold = (deps.getIssueHold ?? defaultGetIssueHold)(issueId);
-		if (hold?.deaconIgnored) {
-			actions.push(`[swarm] skipped ${issueId}: deacon-ignored — operator hold`);
-			continue;
-		}
-		if (hold?.stuck) actions.push(`[swarm] ${issueId} is system-stuck (${hold.stuckReason ?? "unknown"}) — coordinating anyway (stuck no longer halts assembly, PAN-2469)`);
-		if (isSwarmAdvanceCoolingDown(issueId)) {
-			actions.push(`[swarm] deferred ${issueId}: advance backoff active`);
-			continue;
-		}
-		const failedMergeBlocks = getFailedMergeBlocks(issueId, workspace.workspacePath);
-		const blockedSlotIndexes = new Set(failedMergeBlocks.map((block) => block.slotIndex));
-		const blockedItemIds = new Set(failedMergeBlocks.map((block) => block.itemId));
-		if (failedMergeBlocks.length > 0) {
-			const slots = failedMergeBlocks.map((block) => `slot ${block.slotIndex} (item ${block.itemId})`).join(", ");
-			actions.push(`[swarm] blocked slots for ${issueId}: ${slots} — other slots continue; run \`pan swarm recover ${issueId} <slot>\``);
-		}
-		try {
-			const spec = await Effect.runPromise(findSpecByIssue(workspace.projectPath, issueId));
-			if (!spec) continue;
-			const planStatus = spec.document.plan.status;
-			if (planStatus === "completed" || planStatus === "cancelled") continue;
-			const overrides = (deps.readStatusOverrides ?? defaultReadStatusOverrides)(workspace.workspacePath, issueId);
-			const doc = overrides && Object.keys(overrides).length > 0 ? applyStatusOverrides(spec.document, overrides) : spec.document;
-			const readiness = analyzeSwarmReadiness(doc);
-			const slotEligibleCount = readiness.items.filter((item) => item.slotEligible).length;
-			const swarmInProgress = Object.entries(overrides ?? {}).some(([key, value]) => !key.includes(".") && value === "completed");
-			const { policy, enabled } = resolveAutomaticSwarmPolicy(issueId, opts.manual, swarmInProgress);
-			if (!enabled) {
-				actions.push(`[swarm] ${issueId}: swarming off (${policy.source.mode}) — no automatic dispatch, recovery, merge, or cleanup; use an explicit swarm command or stop the legacy sessions`);
-				continue;
-			}
-			const dispatchEligible = enabled && readiness.swarmEligible && (slotEligibleCount >= 2 || swarmInProgress);
-			if (dispatchEligible) actions.push(`[swarm] considered ${issueId}: swarm eligible`);
-			const reconciled = await deps.reconcileSlotState(issueId, workspace.workspacePath, doc);
-			if (!dispatchEligible) {
-				if (!(reconciled.merged.length > 0 || reconciled.inFlight.length > 0 || reconciled.branches.length > 0 || reconciled.agents.length > 0)) {
-					actions.push(...await finalizeSwarmIssueIfComplete(issueId, workspace.workspacePath, doc, deps));
-					continue;
-				}
-				actions.push(`[swarm] considered ${issueId}: endgame (merge/cleanup only)`);
-			}
-			const classified = await classifyInFlightSlots(reconciled.inFlight, deps, {
-				workspacePath: workspace.workspacePath,
-				issueId,
-				inferCompletion: swarmInferCompletionMode()
-			});
-			for (const slot of classified) {
-				actions.push(`[swarm] ${issueId} slot ${slot.slotIndex} ${slot.lifecycle}${slot.signal ? ` signal: ${slot.signal}` : ""}`);
-				if (slot.actions) actions.push(...slot.actions);
-			}
-			const requeue = await requeueFailedSwarmSlots(issueId, workspace.workspacePath, classified, doc, reconciled, deps, blockedSlotIndexes);
-			actions.push(...requeue.actions);
-			actions.push(...await recordStalledSlotRecovery(issueId, classified, workspace.workspacePath));
-			actions.push(...await mergeReadySlots(issueId, workspace.workspacePath, doc, classified, deps, blockedSlotIndexes));
-			actions.push(...await gcMergedSlots(issueId, workspace.workspacePath, reconciled.merged, deps));
-			actions.push(...await gcOrphanedSlots(issueId, workspace.workspacePath, reconciled, deps));
-			actions.push(...await finalizeSwarmIssueIfComplete(issueId, workspace.workspacePath, spec.document, deps));
-			if (dispatchEligible) actions.push(...await dispatchNextWave(issueId, workspace.workspacePath, requeue.doc, reconciled, analyzeSwarmReadiness(requeue.doc), deps, blockedSlotIndexes, blockedItemIds));
-			recordSwarmAdvanceSuccess(issueId);
-		} catch (err) {
-			recordSwarmAdvanceFailure(issueId);
-			console.warn(`[deacon] Error coordinating swarm ${issueId}: ${err instanceof Error ? err.message : String(err)}`);
-		}
-	}
-	return actions;
-}
-async function classifyInFlightSlots(slots, deps = defaultDeps, options = {}) {
-	const sessionNames = new Set(await deps.listSessionNames());
-	const classified = [];
-	const now = options.now ?? Date.now();
-	const stallThresholdMs = options.stallThresholdMs ?? swarmStallThresholdMs();
-	for (const slot of slots) {
-		if (options.workspacePath && options.issueId) {
-			const completion = await (deps.readSlotCompletion ?? defaultReadSlotCompletion)(options.workspacePath, options.issueId, slot.slotIndex);
-			if (completion && (!completion.itemId || completion.itemId === slot.itemId)) {
-				classified.push({
-					...slot,
-					lifecycle: "ready-to-merge",
-					exitStatus: 0,
-					signal: "durable-completion"
-				});
-				continue;
-			}
-		}
-		const durableReady = await classifyDurableReadySlot(slot, deps, options);
-		if (!slot.agentId) {
-			if (durableReady) {
-				classified.push(durableReady);
-				continue;
-			}
-			classified.push({
-				...slot,
-				lifecycle: "failed",
-				reason: "missing-agent"
-			});
-			continue;
-		}
-		const runtimeState = deps.getAgentRuntimeState ? await deps.getAgentRuntimeState(slot.agentId) : null;
-		if (runtimeState?.resolution === "done" || runtimeState?.resolution === "completed") {
-			classified.push({
-				...slot,
-				lifecycle: "ready-to-merge",
-				exitStatus: 0
-			});
-			continue;
-		}
-		if (!sessionNames.has(slot.agentId)) {
-			if (durableReady) {
-				classified.push(durableReady);
-				continue;
-			}
-			classified.push({
-				...slot,
-				lifecycle: "failed",
-				reason: "vanished-session"
-			});
-			continue;
-		}
-		if (!await deps.isPaneDead(slot.agentId)) {
-			const outputDigest = deps.getPaneOutputDigest ? await deps.getPaneOutputDigest(slot.agentId).catch(() => "") : "";
-			const commitTime = slot.branch && options.workspacePath && deps.getBranchTipCommitTime ? await deps.getBranchTipCommitTime(options.workspacePath, slot.branch).catch(() => null) : null;
-			const progressKey = slotProgressKey(slot);
-			const previous = slotProgressObservations.get(progressKey);
-			if (!previous || previous.commitTime !== commitTime || previous.outputDigest !== outputDigest) {
-				slotProgressObservations.set(progressKey, {
-					commitTime,
-					outputDigest,
-					lastProgressAt: now
-				});
-				clearSwarmCompletionObservation(progressKey);
-				classified.push({
-					...slot,
-					lifecycle: "running"
-				});
-				continue;
-			}
-			const stalledForMs = now - previous.lastProgressAt;
-			if (stalledForMs > stallThresholdMs) {
-				const inferred = await classifyDoneWithoutSignal(slot, deps, options, {
-					commitTime,
-					outputDigest,
-					progressKey,
-					stalledForMs
-				});
-				if (inferred) {
-					classified.push(inferred);
-					continue;
-				}
-				classified.push({
-					...slot,
-					lifecycle: "stalled",
-					reason: "no-progress-timeout",
-					stalledForMs
-				});
-				continue;
-			}
-			classified.push({
-				...slot,
-				lifecycle: "running"
-			});
-			continue;
-		}
-		const exitStatus = await deps.getPaneExitStatus(slot.agentId);
-		if (exitStatus === 0) {
-			classified.push({
-				...slot,
-				lifecycle: "ready-to-merge",
-				exitStatus
-			});
-			continue;
-		}
-		classified.push({
-			...slot,
-			lifecycle: "failed",
-			exitStatus,
-			reason: exitStatus === null ? "pane-exit-unknown" : "pane-exit-nonzero"
-		});
-	}
-	return classified;
-}
-function slotProgressKey(slot) {
-	return slot.agentId ?? slot.branch ?? `${slot.itemId}:${slot.slotIndex}`;
-}
-function swarmStallThresholdMs() {
-	const raw = process.env.PAN_SWARM_STALL_THRESHOLD_MS;
-	if (!raw) return DEFAULT_SWARM_STALL_THRESHOLD_MS;
-	const parsed = Number(raw);
-	return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_SWARM_STALL_THRESHOLD_MS;
-}
-async function mergeReadySlots(issueId, workspacePath, doc, slots, deps = defaultDeps, blockedSlotIndexes = /* @__PURE__ */ new Set()) {
-	const actions = [];
-	const itemsById = new Map(doc.plan.items.map((item) => [item.id, item]));
-	join$1(workspacePath, ".pan", "spec.vbrief.json");
-	for (const slot of slots) {
-		if (slot.lifecycle !== "ready-to-merge") continue;
-		if (blockedSlotIndexes.has(slot.slotIndex)) {
-			actions.push(`[swarm] skipped merge slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}: failed-merge block — awaiting \`pan swarm recover\``);
-			continue;
-		}
-		const item = itemsById.get(slot.itemId);
-		if (!item) {
-			actions.push(`[swarm] cannot merge slot ${slot.slotIndex} for ${issueId}: itemId "${slot.itemId}" not in the current plan (spec drift?) — needs operator attention`);
-			continue;
-		}
-		const branchKey = slot.branch ?? `feature/${issueId.toLowerCase()}-slot-${slot.slotIndex}`;
-		if (isSlotMergeCoolingDown(branchKey)) {
-			actions.push(`[swarm] skipped merge slot ${slot.slotIndex} (item ${item.id}) for ${issueId}: refire cooldown`);
-			continue;
-		}
-		recordSlotMergeFire(branchKey);
-		const result = await deps.verifyAndMergeSlot({
-			issueId,
-			featureWorkspace: workspacePath
-		}, slot.slotIndex, item);
-		if (result.merged) {
-			await deps.applyTaskOperationToPlanFile(issueId, {
-				type: "done",
-				itemId: item.id,
-				writerId: "deacon-swarm"
-			}, workspacePath);
-			await clearSwarmSlotCompletion(workspacePath, issueId, slot.slotIndex);
-			actions.push(await reapMergedSlotAgent(issueId, slot, deps.stopSlotAgent), `[swarm] merged slot ${slot.slotIndex} (item ${item.id}) for ${issueId}`);
-			try {
-				actions.push(...await deps.fireTieredCommitHooks({
-					issueId,
-					workspacePath,
-					item,
-					doc
-				}));
-			} catch (err) {
-				actions.push(`[tiered] commit hooks threw for ${issueId} item ${item.id}: ${err instanceof Error ? err.message : String(err)}`);
-			}
-			continue;
-		}
-		if (result.conflicts) {
-			await recordFailedMergeBlock({
-				issueId,
-				itemId: item.id,
-				slotIndex: slot.slotIndex,
-				branch: slot.branch,
-				note: `Slot branch ${slot.branch ?? slot.slotIndex} did not merge cleanly`
-			}, workspacePath);
-			actions.push(`[swarm] failed-merge slot ${slot.slotIndex} (item ${item.id}) for ${issueId}`);
-			continue;
-		}
-		actions.push(`[swarm] verify-failed slot ${slot.slotIndex} (item ${item.id}) for ${issueId}: ${result.failure ?? "verification failed"}`);
-	}
-	return actions;
-}
-function recordSwarmAdvanceFailure(issueId, now = Date.now()) {
-	const normalized = issueId.toUpperCase();
-	const previous = issueAdvanceFailures.get(normalized);
-	const count = (previous?.count ?? 0) + 1;
-	issueAdvanceFailures.set(normalized, {
-		count,
-		cooldownUntil: count >= SWARM_ADVANCE_FAILURE_THRESHOLD ? now + SWARM_ADVANCE_FAILURE_COOLDOWN_MS : previous?.cooldownUntil ?? 0
-	});
-}
-function recordSwarmAdvanceSuccess(issueId) {
-	issueAdvanceFailures.delete(issueId.toUpperCase());
-}
-function isSwarmAdvanceCoolingDown(issueId, now = Date.now()) {
-	const record = issueAdvanceFailures.get(issueId.toUpperCase());
-	return record !== void 0 && record.cooldownUntil > now;
-}
-function getFailedMergeBlock(issueId, slotIndex, workspacePath) {
-	const normalized = issueId.toUpperCase();
-	if (workspacePath) {
-		const swarm = readIssueRecordForWorkspaceSync(workspacePath, normalized)?.swarm;
-		const keyed = swarm?.failedMergeBlocks?.[String(slotIndex)];
-		if (keyed) return {
-			...keyed,
-			issueId: keyed.issueId.toUpperCase()
-		};
-		const legacy = swarm?.failedMergeBlock;
-		if (legacy && legacy.slotIndex === slotIndex) return {
-			...legacy,
-			issueId: legacy.issueId.toUpperCase()
-		};
-	}
-	return failedMergeBlocks.get(`${normalized}:${slotIndex}`);
-}
-function getFailedMergeBlocks(issueId, workspacePath) {
-	const normalized = issueId.toUpperCase();
-	const bySlot = /* @__PURE__ */ new Map();
-	if (workspacePath) {
-		const swarm = readIssueRecordForWorkspaceSync(workspacePath, normalized)?.swarm;
-		if (swarm?.failedMergeBlock) {
-			const legacy = swarm.failedMergeBlock;
-			bySlot.set(legacy.slotIndex, {
-				...legacy,
-				issueId: legacy.issueId.toUpperCase()
-			});
-		}
-		if (swarm?.failedMergeBlocks) for (const [key, block] of Object.entries(swarm.failedMergeBlocks)) bySlot.set(Number(key), {
-			...block,
-			issueId: block.issueId.toUpperCase()
-		});
-	}
-	for (const [key, block] of failedMergeBlocks.entries()) if (key.startsWith(`${normalized}:`) && !bySlot.has(block.slotIndex)) bySlot.set(block.slotIndex, { ...block });
-	return [...bySlot.values()].sort((a, b) => a.slotIndex - b.slotIndex);
-}
-function getSwarmFinalizedAt(issueId, workspacePath) {
-	return workspacePath ? readIssueRecordForWorkspaceSync(workspacePath, issueId.toUpperCase())?.swarm?.finalizedAt : void 0;
-}
-async function recordSwarmFinalizedAt(issueId, workspacePath, finalizedAt) {
-	await writeSwarmFinalizedAt(workspacePath, issueId.toUpperCase(), finalizedAt);
-}
-async function recordFailedMergeBlock(block, workspacePath) {
-	const normalizedBlock = {
-		...block,
-		issueId: block.issueId.toUpperCase()
-	};
-	failedMergeBlocks.set(`${normalizedBlock.issueId}:${normalizedBlock.slotIndex}`, normalizedBlock);
-	if (workspacePath) await writeSwarmFailedMergeBlock(workspacePath, normalizedBlock.issueId, normalizedBlock.slotIndex, normalizedBlock);
-}
-async function recordStalledSlotRecovery(issueId, slots, workspacePath) {
-	const actions = [];
-	const normalizedIssueId = issueId.toUpperCase();
-	for (const slot of slots.filter((s) => s.lifecycle === "stalled")) {
-		if (getFailedMergeBlock(normalizedIssueId, slot.slotIndex, workspacePath)) continue;
-		await recordFailedMergeBlock({
-			issueId: normalizedIssueId,
-			itemId: slot.itemId,
-			slotIndex: slot.slotIndex,
-			branch: slot.branch,
-			note: `Slot ${slot.slotIndex} stalled with no branch commit or pane output progress`
-		}, workspacePath);
-		actions.push(`[swarm] stalled slot ${slot.slotIndex} (item ${slot.itemId}) for ${normalizedIssueId}: recovery required`);
-	}
-	return actions;
-}
-function writeSwarmFailedMergeBlock(workspacePath, issueId, slotIndex, block) {
-	return updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => {
-		const existingSwarm = record.swarm ?? {};
-		const foldedBlocks = { ...existingSwarm.failedMergeBlocks ?? {} };
-		if (existingSwarm.failedMergeBlock) foldedBlocks[String(existingSwarm.failedMergeBlock.slotIndex)] = existingSwarm.failedMergeBlock;
-		if (block) foldedBlocks[String(slotIndex)] = block;
-		else delete foldedBlocks[String(slotIndex)];
-		return {
-			...record,
-			swarm: {
-				...existingSwarm,
-				failedMergeBlocks: foldedBlocks,
-				failedMergeBlock: void 0
-			}
-		};
-	}).then(() => void 0);
-}
-function recordSlotMergeFire(branchKey, now = Date.now()) {
-	recentSlotMergeFires.set(branchKey, now + SLOT_MERGE_REFIRE_COOLDOWN_MS);
-}
-function isSlotMergeCoolingDown(branchKey, now = Date.now()) {
-	const until = recentSlotMergeFires.get(branchKey);
-	if (until === void 0) return false;
-	if (until > now) return true;
-	recentSlotMergeFires.delete(branchKey);
-	return false;
-}
-async function dispatchNextWave(issueId, workspacePath, doc, reconciled, readiness, deps = defaultDeps, blockedSlotIndexes = /* @__PURE__ */ new Set(), blockedItemIds = /* @__PURE__ */ new Set()) {
-	const actions = [];
-	const mergedItemIds = new Set(reconciled.merged.map((slot) => slot.itemId));
-	const slotEligibleIds = new Set(readiness.items.filter((item) => item.slotEligible).map((item) => item.id));
-	const configuredMaxSlotIndex = resolveSwarmMaxSlots(issueId, (deps.getMaxSlotIndex ?? defaultGetMaxSlotIndex)());
-	const occupiedSlotIndexes = new Set([
-		...blockedSlotIndexes,
-		...reconciled.inFlight.map((slot) => slot.slotIndex),
-		...reconciled.branches.map((branch) => branch.slotIndex),
-		...reconciled.agents.map((agent) => agent.slotIndex),
-		...(deps.listSlotAssignments ?? listSlotAssignments)(issueId, workspacePath).map((assignment) => assignment.slotIndex),
-		...(reconciled.superseded ?? []).map((attempt) => attempt.slotIndex)
-	]);
-	const maxSlotIndex = applySupersededSlotHighWater(occupiedSlotIndexes, reconciled, configuredMaxSlotIndex);
-	if (deps.slotWorktreeExists) {
-		for (let index = 1; index <= maxSlotIndex; index++) if (!occupiedSlotIndexes.has(index) && deps.slotWorktreeExists(`${workspacePath}-slot-${index}`)) occupiedSlotIndexes.add(index);
-	}
-	const sessionNames = deps.listSessionNames ? await deps.listSessionNames() : [];
-	const inFlightItemIds = new Set(reconciled.inFlight.map((slot) => slot.itemId));
-	const selectedItemIds = [];
-	for (const item of getDispatchableItems(doc, mergedItemIds)) {
-		if (blockedItemIds.has(item.id)) continue;
-		if (!slotEligibleIds.has(item.id)) continue;
-		if (inFlightItemIds.has(item.id)) continue;
-		const overlapItemId = firstOverlappingItemId(item.id, [...inFlightItemIds, ...selectedItemIds], readiness);
-		if (overlapItemId) {
-			actions.push(`[swarm] deferred ${item.id} for ${issueId}: files_scope overlaps ${overlapItemId}`);
-			continue;
-		}
-		if (!deps.registeredSlotCapacityAvailable(issueId, selectedItemIds.length)) {
-			actions.push(`[swarm] deferred ${item.id} for ${issueId}: registered slot cap reached`);
-			continue;
-		}
-		let slotIndex = null;
-		for (;;) {
-			const candidate = allocateSlotIndex(occupiedSlotIndexes, maxSlotIndex);
-			if (candidate === null) break;
-			const conflict = slotIndexConflictReason(issueId, workspacePath, candidate, sessionNames, reconciled, deps);
-			if (!conflict) {
-				slotIndex = candidate;
-				break;
-			}
-			occupiedSlotIndexes.add(candidate);
-			actions.push(`[swarm] slot ${candidate} occupied for ${issueId}: ${conflict} — advancing`);
-		}
-		if (slotIndex === null) {
-			const occupying = [...occupiedSlotIndexes].filter((index) => index >= 1 && index <= maxSlotIndex).sort((a, b) => a - b);
-			actions.push(`[swarm] deferred ${item.id} for ${issueId}: all slot indexes 1..${maxSlotIndex} are occupied (slots ${occupying.join(", ")}) — run \`pan swarm reset ${issueId}\` if these slots are orphans`);
-			break;
-		}
-		if (!deps.tryReserveSwarmSlot()) {
-			actions.push(`[swarm] deferred ${item.id} for ${issueId}: swarm dispatch budget exhausted`);
-			continue;
-		}
-		try {
-			await deps.applyTaskOperationToPlanFile(issueId, {
-				type: "claim",
-				itemId: item.id,
-				writerId: "deacon-swarm"
-			}, workspacePath);
-			await deps.recordSlotAssignment(workspacePath, issueId, {
-				slotIndex,
-				itemId: item.id,
-				agentId: `agent-${issueId.toLowerCase()}-slot-${slotIndex}`,
-				branch: `feature/${issueId.toLowerCase()}-slot-${slotIndex}`
-			});
-			if (!(deps.shouldDispatch ?? defaultShouldDispatch)(issueId)) {
-				await deps.applyTaskOperationToPlanFile(issueId, {
-					type: "unblock",
-					itemId: item.id,
-					writerId: "deacon-swarm",
-					reason: "dispatch halted: freeze/hold active"
-				}, workspacePath).catch(() => void 0);
-				await deps.clearSlotAssignment(workspacePath, issueId, slotIndex, item.id);
-				deps.releaseSwarmSlot();
-				actions.push(`[swarm] dispatch-halted ${item.id}: freeze/hold active`);
-				continue;
-			}
-			await deps.spawnRun(issueId, "work", {
-				workspace: workspacePath,
-				slotIndex,
-				slotItemId: item.id,
-				prompt: promptForDispatchItem(issueId, doc, item),
-				startedBy: "deacon:swarm-slot"
-			});
-			occupiedSlotIndexes.add(slotIndex);
-			selectedItemIds.push(item.id);
-			actions.push(`[swarm] dispatched ${dispatchPhaseForItem(doc, item)} slot ${slotIndex} (item ${item.id}) for ${issueId}`);
-		} catch (error) {
-			await deps.applyTaskOperationToPlanFile(issueId, {
-				type: "unblock",
-				itemId: item.id,
-				writerId: "deacon-swarm",
-				reason: `slot dispatch failed: ${error instanceof Error ? error.message : String(error)}`
-			}, workspacePath).catch(() => void 0);
-			await deps.clearSlotAssignment(workspacePath, issueId, slotIndex, item.id);
-			deps.releaseSwarmSlot();
-			actions.push(`[swarm] failed-dispatch ${item.id} for ${issueId}: ${error instanceof Error ? error.message : String(error)}`);
-		}
-	}
-	return actions;
-}
-function recordSlotAssignment(workspacePath, issueId, assignment) {
-	return writeSwarmSlotAssignments(workspacePath, issueId, (existing) => [...existing.filter((slot) => slot.slotIndex !== assignment.slotIndex && slot.itemId !== assignment.itemId), {
-		...assignment,
-		assignedAt: (/* @__PURE__ */ new Date()).toISOString()
-	}]);
-}
-function clearSlotAssignment(workspacePath, issueId, slotIndex, itemId) {
-	return writeSwarmSlotAssignments(workspacePath, issueId, (existing) => existing.filter((slot) => slot.slotIndex !== slotIndex && (itemId === void 0 || slot.itemId !== itemId)));
-}
-function writeSwarmSlotAssignments(workspacePath, issueId, update) {
-	return updateIssueRecordForWorkspace(workspacePath, issueId.toUpperCase(), (record) => {
-		const slotAssignments = update(record.swarm?.slotAssignments ?? []).filter((assignment) => Number.isInteger(assignment.slotIndex) && assignment.slotIndex > 0 && assignment.itemId.trim().length > 0).sort((a, b) => a.slotIndex - b.slotIndex);
-		return {
-			...record,
-			swarm: {
-				...record.swarm ?? {},
-				slotAssignments
-			}
-		};
-	}).then(() => void 0);
-}
-function slotIndexConflictReason(issueId, workspacePath, slotIndex, sessionNames, reconciled, deps) {
-	const issueLower = issueId.toLowerCase();
-	const agentId = `agent-${issueLower}-slot-${slotIndex}`;
-	const branch = `feature/${issueLower}-slot-${slotIndex}`;
-	if (sessionNames.includes(agentId)) return `live ${agentId} session already exists`;
-	if (reconciled.branches.find((slotBranch) => slotBranch.slotIndex === slotIndex && slotBranch.branch === branch && !slotBranch.merged)) return `unmerged ${branch} branch already exists`;
-	const slotWorkspacePath = `${workspacePath}-slot-${slotIndex}`;
-	if (deps.slotWorktreeExists?.(slotWorkspacePath)) return `slot worktree already exists at ${slotWorkspacePath}`;
-}
-function dispatchPhaseForItem(doc, item) {
-	return itemRequiresSynthesis(doc, item) && !synthesisContextForItem(item) ? "synthesis" : "implementation";
-}
-function promptForDispatchItem(issueId, doc, item) {
-	if (!itemRequiresSynthesis(doc, item)) return void 0;
-	const synthesisContext = synthesisContextForItem(item);
-	if (synthesisContext) return createActiveSlice(doc, {
-		issueId,
-		itemId: item.id,
-		currentItemIds: [item.id],
-		synthesisOutputs: { [item.id]: { contextUpdate: synthesisContext } }
-	}).prompt;
-	const parentIds = doc.plan.edges.filter((edge) => edge.type === "blocks" && edge.to === item.id).map((edge) => edge.from);
-	return [
-		`SYNTHESIS PHASE for ${item.id}`,
-		"",
-		"Do not implement this item yet. Summarize the blocking parent outputs into a concise context update for the implementation slot.",
-		`Blocking parents: ${parentIds.join(", ") || "(none)"}`,
-		"",
-		"Persist the synthesis context on the xBRIEF item metadata as synthesisContext, commit it, then stop."
-	].join("\n");
-}
-function itemRequiresSynthesis(doc, item) {
-	return item.metadata?.requiresSynthesis === true || blockingParentCount(doc, item.id) > 1;
-}
-function synthesisContextForItem(item) {
-	const raw = item.metadata?.synthesisContext;
-	return typeof raw === "string" && raw.trim().length > 0 ? raw : void 0;
-}
-/**
-* Lowest free slot index within the bound, derived purely from the occupied
-* set. Returns null — never an index above the bound — when indexes 1..bound
-* are all occupied (PAN-2214: unbounded allocation climbed slot-5..slot-20).
-*/
-function allocateSlotIndex(occupiedSlotIndexes, bound) {
-	const maxIndex = Math.max(1, Math.floor(bound));
-	for (let slotIndex = 1; slotIndex <= maxIndex; slotIndex++) if (!occupiedSlotIndexes.has(slotIndex)) return slotIndex;
-	return null;
-}
-function firstOverlappingItemId(itemId, activeItemIds, readiness) {
-	for (const activeItemId of activeItemIds) if ((readiness.overlapMatrix[itemId]?.[activeItemId]?.length ?? 0) > 0) return activeItemId;
-}
-/**
-* Whether the issue may register another slot. Counts only tmux-ALIVE slot
-* sessions (stale agents-table rows blocked all dispatch at zero live slots
-* after a reset), capped by the same swarm reserve tryReserveSwarmSlot
-* enforces — never maxWorkAgents (PAN-2214).
-*/
-function registeredSlotCapacityAvailable(issueId, selectedCount, liveSlotCount = countRunningSwarmSlotsForIssue(issueId), limits = getConcurrencyLimits()) {
-	return liveSlotCount + selectedCount < limits.reservedSwarmSlots;
-}
-//#endregion
-export { gcMergedSlots as _, getFailedMergeBlock as a, resolveSwarmPolicy as b, isSwarmAdvanceCoolingDown as c, recordStalledSlotRecovery as d, recordSwarmAdvanceFailure as f, decideAgentAutonomousRedrive as g, registeredSlotCapacityAvailable as h, dispatchNextWave as i, mergeReadySlots as l, recordSwarmFinalizedAt as m, classifyInFlightSlots as n, getFailedMergeBlocks as o, recordSwarmAdvanceSuccess as p, coordinateSwarmSlots as r, getSwarmFinalizedAt as s, allocateSlotIndex as t, recordFailedMergeBlock as u, gcOrphanedSlots as v, listFeatureWorkspaces as y };
-
-//# sourceMappingURL=deacon-swarm-BiLfNm_v.js.map