@overdeck/desktop 0.45.16 → 0.45.18

package/server/{deacon-nudge-log-B-naf89q.js → deacon-nudge-log-ilDfxrhK.js}

@@ -25,4 +25,4 @@ function recordDeaconNudge(nudge) {
 //#endregion
 export { recordDeaconNudge as t };
 
-//# sourceMappingURL=deacon-nudge-log-B-naf89q.js.map
+//# sourceMappingURL=deacon-nudge-log-ilDfxrhK.js.map

package/server/{deacon-swarm-BNGkmYR_.js → deacon-swarm-BPmBmSoU.js}

@@ -1,16 +1,18 @@
-import { C as init_tier_table, Et as getIssueRecordPathForWorkspace, Fn as init_projects, Nt as readIssueRecordForWorkspaceSync, dn as init_state_plane, f as loadConfigSync, fn as isStatePlaneOnlyStatus, kt as init_record, t as init_config_yaml, w as resolveTieredExecutionEnabled, zn as listProjectsSync, zt as writeIssueRecordForWorkspaceSync } from "./config-yaml-cNOZcEww.js";
-import { C as isPaneDead, E as listPaneValues, L as sessionExists, O as listSessionNames, i as capturePane, x as init_tmux } from "./tmux-C3g9VFcg.js";
-import { c as init_review_status, s as getReviewStatusSync, y as setReviewStatusSync } from "./review-status-Dc1l4dVz.js";
-import { A as init_messaging, Fn as init_agent_state, Ft as init_spawn_prep, G as init_termination, H as init_spawn, Ht as resolveTier, K as stopAgent, Pn as getAgentStateSync, Pt as defaultRunWorkspace, Vt as init_resolve_tier, W as spawnRun, _ as init_slot_reconcile, _r as init_agent_runtime, _t as init_config, at as init_concurrency, c as init_tier_supervisor, d as spawnTierSupervisor, f as supervisorAgentId, ft as getCachedMemoryVerdict, gr as getAgentRuntimeSnapshot, it as getConcurrencyLimits, j as messageAgent, jn as getAgentResumeGateBlockReason, kn as decideResumeGate, l as loadPrdDraft, m as init_tier_feed, p as broadcastCommit, pt as init_memory_verdict_cache, s as deliverCommitForReview, st as releaseSwarmSlot, tt as countRunningSwarmSlotsForIssue, u as shouldSupervise, ut as tryReserveSwarmSlot, v as listSlotAssignments, y as reconcileSlotState, yt as loadCloisterConfigSync } from "./agents-B9GwfCyp.js";
-import { C as findSpecByIssue, T as init_specs, n as applyStatusOverrides, o as init_io } from "./io-VEGSAqsd.js";
-import { s as init_control_settings, u as isDeaconGloballyPausedSync } from "./control-settings-D4EFsRBd.js";
-import { a as createActiveSlice, n as applyTaskOperationToPlanFile, r as blockingParentCount, s as getDispatchableItems, u as init_dag } from "./dag-DKI3sOmX.js";
-import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-h6-pwY8w.js";
-import { i as writeSwarmFinalizedAt, n as clearSwarmSlotCompletion, r as createMinimalIssueRecord, t as recordRecoveryFailure } from "./recovery-trip-BT7nb9OV.js";
+import { C as init_tier_table, Et as getIssueRecordPathForWorkspace, Fn as init_projects, It as resolveProjectForIssue, Nt as readIssueRecordForWorkspaceSync, Ot as getProjectConfigFromWorkspacePath, Pt as readIssueRecordSync, cn as init_state_plane, f as loadConfigSync, kn as getProjectSync, kt as init_record, ln as isStatePlaneOnlyStatus, qn as resolveProjectFromIssueSync, t as init_config_yaml, w as resolveTieredExecutionEnabled, zn as listProjectsSync } from "./config-yaml-CqaAyn8y.js";
+import { n as updateIssueRecord, r as updateIssueRecordForWorkspace, t as init_record_update } from "./record-update-BltEmPge.js";
+import { D as listPaneValues, R as sessionExists, S as init_tmux, i as capturePane, k as listSessionNames, w as isPaneDead } from "./tmux-U55cNGFG.js";
+import { c as init_review_status, s as getReviewStatusSync, y as setReviewStatusSync } from "./review-status-DANr0t-v.js";
+import { An as decideResumeGate, C as init_slot_reconcile, Fn as getAgentStateSync, Ft as init_spawn_prep, Ht as init_resolve_tier, I as init_messaging, In as init_agent_state, J as init_spawn, L as messageAgent, Mn as getAgentResumeGateBlockReason, Pt as defaultRunWorkspace, Q as stopAgent, T as reconcileSlotState, Ut as resolveTier, X as spawnRun, Z as init_termination, _ as spawnTierSupervisor, _r as getAgentRuntimeSnapshot, _t as init_config, at as init_concurrency, b as init_tier_feed, ft as getCachedMemoryVerdict, g as shouldSupervise, h as loadPrdDraft, it as getConcurrencyLimits, m as init_tier_supervisor, p as deliverCommitForReview, pt as init_memory_verdict_cache, st as releaseSwarmSlot, tt as countRunningSwarmSlotsForIssue, ut as tryReserveSwarmSlot, v as supervisorAgentId, vr as init_agent_runtime, w as listSlotAssignments, y as broadcastCommit, yt as loadCloisterConfigSync } from "./queries-C0LCGG21.js";
+import { C as init_specs, d as readPlanSync, i as findPlanSync, n as applyStatusOverrides, o as init_io, v as init_types, x as findSpecByIssue, y as subItemsOf } from "./io-DkC4sFSy.js";
+import { s as init_control_settings, u as isDeaconGloballyPausedSync } from "./control-settings-BguNQ1F_.js";
+import { i as createActiveSlice, l as init_dag, n as blockingParentCount, o as getDispatchableItems } from "./dag-C6kYyF17.js";
+import { r as init_swarm_readiness, t as analyzeSwarmReadiness } from "./swarm-readiness-sXB1vhzo.js";
+import { t as recordRecoveryFailure } from "./recovery-trip-Cn7KJVkS.js";
 import { 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";
@@ -22,6 +24,7 @@ init_config_yaml();
 init_tmux();
 init_review_status();
 init_specs();
+init_types();
 init_io();
 init_agent_runtime();
 init_agent_state();
@@ -125,9 +128,188 @@ function commandFailure(error) {
 	};
 }
 //#endregion
-//#region ../../lib/cloister/deacon-workspaces.ts
+//#region ../../lib/pan-dir/task-door.ts
 init_swarm_readiness();
 init_slot_reconcile();
+/** Single task-mutation write door over the immutable vBRIEF 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 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 vBRIEF 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 vBRIEF 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];
+		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)) 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 (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 && !allowedFrom(operation.type, currentStatus)) throw taskError(normalizedIssueId, operation.itemId, operation.type, currentStatus, existingClaim?.writerId);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		const nextStatus = statusFor(operation.type);
+		record.tasks ??= {
+			sequence: 0,
+			claims: {}
+		};
+		record.statusOverrides = {
+			...record.statusOverrides ?? {},
+			[operation.itemId]: nextStatus
+		};
+		const subIds = operation.subItemIds?.length ? new Set(operation.subItemIds) : new Set(operation.type === "done" ? subItemsOf(item).map(({ id }) => id) : []);
+		for (const subId of subIds) record.statusOverrides[`${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
+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();
@@ -293,6 +475,7 @@ async function defaultSendCompletionNudge(agentId, issueId) {
 }
 //#endregion
 //#region ../../lib/cloister/deacon-swarm-finalization.ts
+init_io();
 async function defaultRequestIssueReview(issueId, workspacePath) {
 	setReviewStatusSync(issueId, {
 		reviewStatus: "pending",
@@ -304,7 +487,7 @@ async function defaultRequestIssueReview(issueId, workspacePath) {
 		autoRequeueCount: 0,
 		reviewRequestedAt: (/* @__PURE__ */ new Date()).toISOString()
 	});
-	const { spawnReviewRoleForIssue } = await import("./review-agent-u5q3ip7H.js");
+	const { spawnReviewRoleForIssue } = await import("./review-agent-CpSHLzed.js");
 	return Effect.runPromise(spawnReviewRoleForIssue({
 		issueId,
 		workspace: workspacePath,
@@ -365,6 +548,42 @@ async function gcMergedSlots(issueId, workspacePath, slots, deps) {
 	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.
@@ -386,6 +605,7 @@ async function gcMergedSlots(issueId, workspacePath, slots, deps) {
 * 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();
@@ -449,8 +669,8 @@ async function fireTieredCommitHooks(options, deps = defaultDeps$1) {
 				workspace: workspacePath,
 				issueId,
 				sha,
-				beadTitle: item.title,
-				beadId: item.id,
+				itemTitle: item.title,
+				itemId: item.id,
 				tiers: listeners,
 				feedConfig: tiered.feed
 			})).filter((delivery) => delivery.result.ok).length;
@@ -474,7 +694,7 @@ async function fireTieredCommitHooks(options, deps = defaultDeps$1) {
 				issueId,
 				item,
 				sha,
-				beadId: item.id,
+				itemId: item.id,
 				prdMarkdown
 			});
 			actions.push(`[tiered] supervisor review dispatched for ${issueId} item ${item.id} (subscribe=${supervisor.subscribe})`);
@@ -519,6 +739,7 @@ function decideAgentAutonomousRedrive(state, agentDir, owesRework) {
 }
 //#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();
@@ -540,16 +761,15 @@ async function archiveFailedSwarmSlot(issueId, workspacePath, slot, deps, now =
 		reason: slot.reason ?? "failed swarm slot",
 		supersededAt: now.toISOString()
 	};
-	const existing = readIssueRecordForWorkspaceSync(workspacePath, normalized) ?? createMinimalIssueRecord(normalized);
-	writeIssueRecordForWorkspaceSync(workspacePath, normalized, {
+	await updateIssueRecordForWorkspace(workspacePath, normalized, (existing) => ({
 		...existing,
 		swarm: {
 			...existing.swarm ?? {},
 			supersededAttempts: [...existing.swarm?.supersededAttempts ?? [], attempt]
 		}
-	});
-	clearSwarmSlotCompletion(workspacePath, normalized, slot.slotIndex);
-	deps.clearSlotAssignment(workspacePath, normalized, slot.slotIndex, slot.itemId);
+	}));
+	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()) {
@@ -566,7 +786,7 @@ async function requeueFailedSwarmSlots(issueId, workspacePath, classified, doc,
 			continue;
 		}
 		const attempt = await archiveFailedSwarmSlot(issueId, workspacePath, slot, deps);
-		await deps.applyTaskOperationToPlanFile(`${workspacePath}/.pan/spec.vbrief.json`, {
+		await deps.applyTaskOperationToPlanFile(issueId, {
 			type: "unblock",
 			itemId: slot.itemId,
 			writerId: "deacon-swarm",
@@ -585,7 +805,7 @@ async function requeueFailedSwarmSlots(issueId, workspacePath, classified, doc,
 			}
 		};
 		actions.push(`[swarm] archived failed slot ${slot.slotIndex} (item ${slot.itemId}) for ${issueId}`);
-		const failure = recordRecoveryFailure(workspacePath, issueId, "swarm-slot-requeue", slot.itemId);
+		const failure = await recordRecoveryFailure(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 {
@@ -602,6 +822,7 @@ function applySupersededSlotHighWater(occupied, reconciled, configuredMax) {
 //#region ../../lib/cloister/deacon-swarm.ts
 init_slot_reconcile();
 init_record();
+init_record_update();
 init_tmux();
 init_io();
 init_review_status();
@@ -641,7 +862,9 @@ const defaultDeps = {
 	sendCompletionNudge: defaultSendCompletionNudge,
 	slotWorktreeExists: existsSync$1,
 	verifyAndMergeSlot,
-	applyTaskOperationToPlanFile: (planPath, operation, workspacePath) => Effect.runPromise(applyTaskOperationToPlanFile(planPath, operation, workspacePath)),
+	applyTaskOperationToPlanFile: (issueId, operation, workspacePath = "") => {
+		return applyTaskStatusChange(resolveProjectForIssue(issueId) ?? getProjectConfigFromWorkspacePath(workspacePath), issueId, operation);
+	},
 	fireTieredCommitHooks,
 	recordSlotAssignment,
 	clearSlotAssignment,
@@ -730,7 +953,12 @@ async function coordinateSwarmSlots(opts = {}, deps = defaultDeps) {
 			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 dispatchEligible = readiness.swarmEligible && (slotEligibleCount >= 2 || swarmInProgress);
+			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) {
@@ -751,7 +979,7 @@ async function coordinateSwarmSlots(opts = {}, deps = defaultDeps) {
 			}
 			const requeue = await requeueFailedSwarmSlots(issueId, workspace.workspacePath, classified, doc, reconciled, deps, blockedSlotIndexes);
 			actions.push(...requeue.actions);
-			actions.push(...recordStalledSlotRecovery(issueId, classified, workspace.workspacePath));
+			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));
@@ -891,7 +1119,7 @@ function swarmStallThresholdMs() {
 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]));
-	const planPath = join$1(workspacePath, ".pan", "spec.vbrief.json");
+	join$1(workspacePath, ".pan", "spec.vbrief.json");
 	for (const slot of slots) {
 		if (slot.lifecycle !== "ready-to-merge") continue;
 		if (blockedSlotIndexes.has(slot.slotIndex)) {
@@ -914,12 +1142,12 @@ async function mergeReadySlots(issueId, workspacePath, doc, slots, deps = defaul
 			featureWorkspace: workspacePath
 		}, slot.slotIndex, item);
 		if (result.merged) {
-			await deps.applyTaskOperationToPlanFile(planPath, {
+			await deps.applyTaskOperationToPlanFile(issueId, {
 				type: "done",
 				itemId: item.id,
 				writerId: "deacon-swarm"
 			}, workspacePath);
-			clearSwarmSlotCompletion(workspacePath, issueId, slot.slotIndex);
+			await clearSwarmSlotCompletion(workspacePath, issueId, slot.slotIndex);
 			actions.push(`[swarm] merged slot ${slot.slotIndex} (item ${item.id}) for ${issueId}`);
 			try {
 				actions.push(...await deps.fireTieredCommitHooks({
@@ -934,7 +1162,7 @@ async function mergeReadySlots(issueId, workspacePath, doc, slots, deps = defaul
 			continue;
 		}
 		if (result.conflicts) {
-			recordFailedMergeBlock({
+			await recordFailedMergeBlock({
 				issueId,
 				itemId: item.id,
 				slotIndex: slot.slotIndex,
@@ -1004,23 +1232,23 @@ function getFailedMergeBlocks(issueId, workspacePath) {
 function getSwarmFinalizedAt(issueId, workspacePath) {
 	return workspacePath ? readIssueRecordForWorkspaceSync(workspacePath, issueId.toUpperCase())?.swarm?.finalizedAt : void 0;
 }
-function recordSwarmFinalizedAt(issueId, workspacePath, finalizedAt) {
-	writeSwarmFinalizedAt(workspacePath, issueId.toUpperCase(), finalizedAt);
+async function recordSwarmFinalizedAt(issueId, workspacePath, finalizedAt) {
+	await writeSwarmFinalizedAt(workspacePath, issueId.toUpperCase(), finalizedAt);
 }
-function recordFailedMergeBlock(block, workspacePath) {
+async function recordFailedMergeBlock(block, workspacePath) {
 	const normalizedBlock = {
 		...block,
 		issueId: block.issueId.toUpperCase()
 	};
 	failedMergeBlocks.set(`${normalizedBlock.issueId}:${normalizedBlock.slotIndex}`, normalizedBlock);
-	if (workspacePath) writeSwarmFailedMergeBlock(workspacePath, normalizedBlock.issueId, normalizedBlock.slotIndex, normalizedBlock);
+	if (workspacePath) await writeSwarmFailedMergeBlock(workspacePath, normalizedBlock.issueId, normalizedBlock.slotIndex, normalizedBlock);
 }
-function recordStalledSlotRecovery(issueId, slots, workspacePath) {
+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;
-		recordFailedMergeBlock({
+		await recordFailedMergeBlock({
 			issueId: normalizedIssueId,
 			itemId: slot.itemId,
 			slotIndex: slot.slotIndex,
@@ -1032,22 +1260,21 @@ function recordStalledSlotRecovery(issueId, slots, workspacePath) {
 	return actions;
 }
 function writeSwarmFailedMergeBlock(workspacePath, issueId, slotIndex, block) {
-	const normalizedIssueId = issueId.toUpperCase();
-	const record = readIssueRecordForWorkspaceSync(workspacePath, normalizedIssueId) ?? createMinimalIssueRecord(normalizedIssueId);
-	const existingSwarm = record.swarm ?? {};
-	const foldedBlocks = { ...existingSwarm.failedMergeBlocks ?? {} };
-	if (existingSwarm.failedMergeBlock) foldedBlocks[String(existingSwarm.failedMergeBlock.slotIndex)] = existingSwarm.failedMergeBlock;
-	const nextBlocks = { ...foldedBlocks };
-	if (block) nextBlocks[String(slotIndex)] = block;
-	else delete nextBlocks[String(slotIndex)];
-	writeIssueRecordForWorkspaceSync(workspacePath, normalizedIssueId, {
-		...record,
-		swarm: {
-			...existingSwarm,
-			failedMergeBlocks: nextBlocks,
-			failedMergeBlock: void 0
-		}
-	});
+	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);
@@ -1063,7 +1290,7 @@ async function dispatchNextWave(issueId, workspacePath, doc, reconciled, readine
 	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 = Math.max(1, Math.floor((deps.getMaxSlotIndex ?? defaultGetMaxSlotIndex)()));
+	const configuredMaxSlotIndex = resolveSwarmMaxSlots(issueId, (deps.getMaxSlotIndex ?? defaultGetMaxSlotIndex)());
 	const occupiedSlotIndexes = new Set([
 		...blockedSlotIndexes,
 		...reconciled.inFlight.map((slot) => slot.slotIndex),
@@ -1079,7 +1306,6 @@ async function dispatchNextWave(issueId, workspacePath, doc, reconciled, readine
 	const sessionNames = deps.listSessionNames ? await deps.listSessionNames() : [];
 	const inFlightItemIds = new Set(reconciled.inFlight.map((slot) => slot.itemId));
 	const selectedItemIds = [];
-	const planPath = join$1(workspacePath, ".pan", "spec.vbrief.json");
 	for (const item of getDispatchableItems(doc, mergedItemIds)) {
 		if (blockedItemIds.has(item.id)) continue;
 		if (!slotEligibleIds.has(item.id)) continue;
@@ -1115,25 +1341,25 @@ async function dispatchNextWave(issueId, workspacePath, doc, reconciled, readine
 			continue;
 		}
 		try {
-			await deps.applyTaskOperationToPlanFile(planPath, {
+			await deps.applyTaskOperationToPlanFile(issueId, {
 				type: "claim",
 				itemId: item.id,
 				writerId: "deacon-swarm"
 			}, workspacePath);
-			deps.recordSlotAssignment(workspacePath, issueId, {
+			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(planPath, {
+				await deps.applyTaskOperationToPlanFile(issueId, {
 					type: "unblock",
 					itemId: item.id,
 					writerId: "deacon-swarm",
 					reason: "dispatch halted: freeze/hold active"
 				}, workspacePath).catch(() => void 0);
-				deps.clearSlotAssignment(workspacePath, issueId, slotIndex, item.id);
+				await deps.clearSlotAssignment(workspacePath, issueId, slotIndex, item.id);
 				deps.releaseSwarmSlot();
 				actions.push(`[swarm] dispatch-halted ${item.id}: freeze/hold active`);
 				continue;
@@ -1148,13 +1374,13 @@ async function dispatchNextWave(issueId, workspacePath, doc, reconciled, readine
 			selectedItemIds.push(item.id);
 			actions.push(`[swarm] dispatched ${dispatchPhaseForItem(doc, item)} slot ${slotIndex} (item ${item.id}) for ${issueId}`);
 		} catch (error) {
-			await deps.applyTaskOperationToPlanFile(planPath, {
+			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);
-			deps.clearSlotAssignment(workspacePath, issueId, slotIndex, item.id);
+			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)}`);
 		}
@@ -1162,25 +1388,25 @@ async function dispatchNextWave(issueId, workspacePath, doc, reconciled, readine
 	return actions;
 }
 function recordSlotAssignment(workspacePath, issueId, assignment) {
-	writeSwarmSlotAssignments(workspacePath, issueId, (existing) => [...existing.filter((slot) => slot.slotIndex !== assignment.slotIndex && slot.itemId !== assignment.itemId), {
+	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) {
-	writeSwarmSlotAssignments(workspacePath, issueId, (existing) => existing.filter((slot) => slot.slotIndex !== slotIndex && (itemId === void 0 || slot.itemId !== itemId)));
+	return writeSwarmSlotAssignments(workspacePath, issueId, (existing) => existing.filter((slot) => slot.slotIndex !== slotIndex && (itemId === void 0 || slot.itemId !== itemId)));
 }
 function writeSwarmSlotAssignments(workspacePath, issueId, update) {
-	const normalizedIssueId = issueId.toUpperCase();
-	const record = readIssueRecordForWorkspaceSync(workspacePath, normalizedIssueId) ?? createMinimalIssueRecord(normalizedIssueId);
-	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);
-	writeIssueRecordForWorkspaceSync(workspacePath, normalizedIssueId, {
-		...record,
-		swarm: {
-			...record.swarm ?? {},
-			slotAssignments
-		}
-	});
+	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();
@@ -1243,6 +1469,6 @@ function registeredSlotCapacityAvailable(issueId, selectedCount, liveSlotCount =
 	return liveSlotCount + selectedCount < limits.reservedSwarmSlots;
 }
 //#endregion
-export { gcMergedSlots as _, getFailedMergeBlock as a, 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 };
+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-BNGkmYR_.js.map
+//# sourceMappingURL=deacon-swarm-BPmBmSoU.js.map

package/server/deacon-swarm-CKyGJng1.js

@@ -0,0 +1,2 @@
+import { r as coordinateSwarmSlots } from "./deacon-swarm-BPmBmSoU.js";
+export { coordinateSwarmSlots };

package/server/deacon.js

@@ -1,11 +1,11 @@
-import { in as init_auto_commit, nn as flushAllPendingAutoCommits } from "./config-yaml-cNOZcEww.js";
+import { en as flushAllPendingAutoCommits, nn as init_auto_commit } from "./config-yaml-CqaAyn8y.js";
 import { a as init_activity_logger, o as setActivityEventStoreProvider } from "./activity-logger-pcbf-e30.js";
-import { c as init_review_status, s as getReviewStatusSync } from "./review-status-Dc1l4dVz.js";
-import { Mn as getAgentState, t as init_agents } from "./agents-B9GwfCyp.js";
-import { r as setCloisterEventStoreProvider, t as getCloisterService } from "./service-DfTVoqJg.js";
-import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-BtqSbKTx.js";
-import { F as setAgentStatusChangedNotifier, I as setAgentStoppedNotifier, L as setMergeReadyNotifier, M as resetPatrolHeartbeatForStartup, N as runPatrol } from "./deacon-DdARMjZq.js";
-import { t as enrichReviewStatus } from "./review-status-enrichment-C1a1OG_1.js";
+import { c as init_review_status, s as getReviewStatusSync } from "./review-status-DANr0t-v.js";
+import { Nn as getAgentState, s as init_agents } from "./queries-C0LCGG21.js";
+import { r as setCloisterEventStoreProvider, t as getCloisterService } from "./service-CLVBC_1Y.js";
+import { i as ensureInternalTokenSync, s as init_internal_token, t as INTERNAL_TOKEN_HEADER } from "./internal-token-Cl-1IxaE.js";
+import { F as setAgentStatusChangedNotifier, I as setAgentStoppedNotifier, L as setMergeReadyNotifier, M as resetPatrolHeartbeatForStartup, N as runPatrol } from "./deacon-Dru5onpk.js";
+import { t as enrichReviewStatus } from "./review-status-enrichment-DwOg4UfL.js";
 import { Effect } from "effect";
 import { randomUUID } from "node:crypto";
 //#region ../../lib/cloister/deacon-event-client.ts
@@ -319,6 +319,13 @@ async function shutdown(signal) {
 	} catch (err) {
 		console.error("[deacon-child] Cloister stop failed:", err);
 	}
+	try {
+		const { killAllGateProcessGroups } = await import("./validation-DpTNakM6.js");
+		const reaped = killAllGateProcessGroups();
+		if (reaped > 0) console.log(`[deacon-child] reaped ${reaped} in-flight gate process group(s)`);
+	} catch (err) {
+		console.error("[deacon-child] gate process reap failed:", err);
+	}
 	await Effect.runPromise(flushAllPendingAutoCommits()).catch((err) => {
 		console.error("[deacon-child] auto-commit shutdown flush failed:", err);
 	});