opencode-swarm 7.143.5 → 7.144.0

package/dist/cli/{index-51axj9vd.js → index-j1scj25g.js}

@@ -1,13 +1,13 @@
 // @bun
 import {
   stableCanonicalStringify
-} from "./index-y8r7z30j.js";
+} from "./index-d45yrzkg.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-a4dkd7m7.js";
+} from "./index-evvbmbbv.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -54,7 +54,7 @@ import {
   updateTaskCheckpointReceipt,
   updateTaskStatus,
   validateProjectRoot
-} from "./index-5866smj5.js";
+} from "./index-3v3dxf75.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -106,7 +106,7 @@ import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-tmc43mkc.js";
+} from "./index-mw6p3nt6.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -141,7 +141,7 @@ import {
   startupOrphanRecovery,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-7en3eq3k.js";
+} from "./index-jvbfrwt2.js";
 import {
   changedFilesSinceSnapshot,
   parsePorcelainV2Snapshot,
@@ -188,16 +188,16 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-p844tcrm.js";
+} from "./index-269b52r3.js";
 import {
   readRecentEscalations
-} from "./index-mbczeqs3.js";
+} from "./index-vb9cpaz4.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-at0h6cd6.js";
+} from "./index-zv4pwyas.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -210,7 +210,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-qdarzed6.js";
+} from "./index-0ck3e366.js";
 import {
   isPathWithinDeclaredScope
 } from "./index-556ja8an.js";
@@ -232,13 +232,19 @@ import {
   removeWorktreeProvisioningOwner
 } from "./index-k3cxyk66.js";
 import {
+  DEFAULT_STALE_DELEGATION_TIMEOUT_MS,
+  DELEGATION_COMPACTION_HIGH_WATER_BYTES,
+  DELEGATION_COMPACTION_LOW_WATER_BYTES,
+  MAX_RECOVERY_LEDGER_BYTES,
+  collectDelegationLedgerHealth,
   findByBatchId,
-  readDelegations
-} from "./index-8aabbfhv.js";
+  readDelegations,
+  sweepStaleDelegations
+} from "./index-4fda8kkw.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-q2nd6q9e.js";
+} from "./index-tfkfyshg.js";
 import {
   SandboxCapabilityProbe,
   init_capability_probe
@@ -262,10 +268,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-47z3jbxk.js";
+} from "./index-ez18gjk2.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-xmje20we.js";
+} from "./index-1pr8x10a.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -275,7 +281,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-a1p87gew.js";
+} from "./index-d45d4zyq.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -289,7 +295,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-04x9wx7d.js";
+} from "./index-3q9w6e6v.js";
 import {
   readSwarmFileAsync,
   safeHook,
@@ -324,7 +330,7 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-dg1v2gnh.js";
+} from "./index-ewzmjm7m.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
@@ -361,7 +367,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-m7v7gggs.js";
+} from "./index-jqabjy7t.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -4153,7 +4159,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-bv41gn3k.js");
+  } = await import("./worktree-isolation-4628yaka.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -4232,7 +4238,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-bv41gn3k.js");
+        } = await import("./worktree-isolation-4628yaka.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -6261,7 +6267,8 @@ var V2ReceiptSchema = ReceiptEnvelopeSchema.extend({
   not_triggered_count: exports_external.number().int().min(0),
   no_match_count: exports_external.number().int().min(0),
   rows: exports_external.array(V2RowSchema),
-  coverage_degradations: exports_external.array(TriggerCoverageDegradationSchema).default([])
+  coverage_degradations: exports_external.array(TriggerCoverageDegradationSchema).default([]),
+  base_verification: exports_external.enum(["live", "bound_fallback"]).optional()
 }).strict();
 function assertCanonicalDefinitionFields(rows) {
   const definitions = new Map(PR_REVIEW_TRIGGER_DEFINITIONS.map((definition) => [
@@ -6303,13 +6310,14 @@ var V1ReceiptSchema = ReceiptEnvelopeSchema.extend({
   rows: exports_external.array(LegacyRowSchema)
 }).strict();
 var UnversionedRowOnlyReceiptSchema = exports_external.object({ rows: exports_external.array(exports_external.unknown()) }).strict();
-function parsedReceipt(schemaVersion, rows, coverageDegradations = []) {
+function parsedReceipt(schemaVersion, rows, coverageDegradations = [], baseVerification) {
   return {
     schemaVersion,
     rows,
     matchedRows: rows.filter((row) => row.result === "MATCHED"),
     notTriggeredRows: rows.filter((row) => row.result === "NOT_TRIGGERED"),
-    coverageDegradations
+    coverageDegradations,
+    ...baseVerification ? { baseVerification } : {}
   };
 }
 function parsePrReviewTriggerReceipt(input) {
@@ -6342,7 +6350,7 @@ function parsePrReviewTriggerReceipt(input) {
         throw new Error(`PR_REVIEW trigger receipt ${field} is inconsistent: expected ${expected}`);
       }
     }
-    return parsedReceipt(2, validated2.rows, receipt.coverage_degradations);
+    return parsedReceipt(2, validated2.rows, receipt.coverage_degradations, receipt.base_verification);
   }
   if (schemaVersion !== undefined && schemaVersion !== 1) {
     throw new Error(`Unsupported PR_REVIEW trigger schema_version: ${schemaVersion}`);
@@ -6594,6 +6602,7 @@ var MAX_WORKFLOW_BATCHES = 128;
 var MAX_RETIRED_REVIEWER_SESSION_IDS = 1024;
 var MAX_RETIRED_CONSOLIDATED_LANES = 64;
 var MAX_RETIRED_FEEDBACK_ITEM_OWNERS = 4096;
+var MAX_PR_FEEDBACK_INVENTORY_AMENDMENTS = 128;
 var WINDOWS_RENAME_MAX_RETRIES = 3;
 var RENAME_RETRY_DELAY_MS = 10;
 var STATE_MUTATION_LOCK_MAX_ATTEMPTS = 50;
@@ -6700,6 +6709,11 @@ var PrFeedbackReadyToPublishRecordSchema = exports_external.object({
   remoteRef: exports_external.string().startsWith("refs/remotes/"),
   validatedAt: exports_external.string().min(1)
 }).strict();
+var PrFeedbackInventoryAmendmentRecordSchema = exports_external.object({
+  entry: exports_external.string().min(1),
+  amendedAt: exports_external.string().min(1),
+  batch: exports_external.number().int().positive()
+}).strict();
 var PrReviewValidationBatchRecordSchema = exports_external.object({
   batchId: exports_external.string().min(1),
   phase: exports_external.enum(["council", "reviewer", "critic"]),
@@ -6789,6 +6803,7 @@ var PrWorkflowGateStateSchema = exports_external.object({
   prFeedbackTargetUrl: exports_external.string().url().max(2000).optional(),
   prFeedbackReviewHandoff: PrFeedbackReviewHandoffRecordSchema.optional(),
   prFeedbackInventory: exports_external.array(exports_external.string().min(1)).min(1).optional(),
+  prFeedbackInventoryAmendments: exports_external.array(PrFeedbackInventoryAmendmentRecordSchema).max(MAX_PR_FEEDBACK_INVENTORY_AMENDMENTS).optional(),
   prFeedbackVerifications: exports_external.array(PrFeedbackVerificationRecordSchema).max(MAX_WORKFLOW_BATCHES).optional(),
   prFeedbackRetiredItemOwnership: exports_external.record(exports_external.string().min(1), exports_external.string().min(1)).refine((entries) => Object.keys(entries).length <= MAX_RETIRED_FEEDBACK_ITEM_OWNERS, `prFeedbackRetiredItemOwnership may not exceed ${MAX_RETIRED_FEEDBACK_ITEM_OWNERS} entries`).optional(),
   prFeedbackVerification: PrFeedbackVerificationRecordSchema.optional(),
@@ -6880,11 +6895,11 @@ async function readPrWorkflowGateState(directory, sessionID) {
   }
   return state;
 }
-async function clearPrWorkflowGateState(directory, sessionID, expectedRevision) {
+async function clearPrWorkflowGateState(directory, sessionID, expectedRevision, options = {}) {
   const normalizedSessionID = normalizeSessionID(sessionID);
   await withSessionStateMutation(directory, normalizedSessionID, async () => {
     if (expectedRevision !== undefined) {
-      const current = await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
+      const current = options.allowSalvagedRead ? (await readPrWorkflowGateStateForRecovery(directory, normalizedSessionID))?.state ?? null : await readPrWorkflowGateStateFromDisk(directory, normalizedSessionID);
       if (!current || current.revision !== expectedRevision) {
         throw new Error("BLOCKED: PR workflow gate state changed during terminal completion; revalidate the current session state before retrying");
       }
@@ -6901,18 +6916,71 @@ async function clearPrWorkflowGateState(directory, sessionID, expectedRevision)
     trackedStatesByProjectSession.delete(stateCacheKey(directory, normalizedSessionID));
   });
 }
+var PR_WORKFLOW_STALE_LANE_TIMEOUT_MS = DEFAULT_STALE_DELEGATION_TIMEOUT_MS;
+var MAX_DISCLOSED_LANE_IDS = 10;
+var PR_WORKFLOW_SWEEPABLE_LANE_STATUSES = new Set(["pending", "running"]);
+var CAS_ESCAPE_DISCLOSURE = "state revision unsalvageable; cleared without compare-and-swap";
+function prWorkflowLaneLabel(record) {
+  return record.laneId ?? record.subagentSessionId ?? "unknown";
+}
+function isOpenPrWorkflowLane(record, sessionID) {
+  return record.parentSessionId === sessionID && record.mode?.startsWith("swarm-pr-") === true && (record.status === "pending" || record.status === "running");
+}
+async function settlePresumedStalePrWorkflowLanes(directory, sessionID) {
+  const now = Date.now();
+  const open2 = [];
+  const presumedStale = [];
+  for (const record of readDelegations(directory)) {
+    if (!isOpenPrWorkflowLane(record, sessionID))
+      continue;
+    if (now - record.updatedAt > PR_WORKFLOW_STALE_LANE_TIMEOUT_MS) {
+      presumedStale.push(record);
+    } else {
+      open2.push(record);
+    }
+  }
+  const presumedStaleLaneIds = presumedStale.map(prWorkflowLaneLabel);
+  const openLaneIds = open2.map(prWorkflowLaneLabel);
+  if (presumedStale.length === 0) {
+    return { openLaneIds, openLanes: open2.length, presumedStaleLaneIds };
+  }
+  const disclosure = `${presumedStaleLaneIds.length} lane(s) stale >` + `${Math.round(PR_WORKFLOW_STALE_LANE_TIMEOUT_MS / 60000)}min, ` + `treated as settled: ${presumedStaleLaneIds.slice(0, MAX_DISCLOSED_LANE_IDS).join(", ")}`;
+  await sweepStaleDelegations(directory, PR_WORKFLOW_STALE_LANE_TIMEOUT_MS, {
+    statuses: PR_WORKFLOW_SWEEPABLE_LANE_STATUSES
+  });
+  try {
+    await fsp2.appendFile(validateSwarmPath(directory, "events.jsonl"), `${JSON.stringify({
+      type: "pr_workflow_lanes_presumed_stale",
+      timestamp: isoNow(),
+      sessionID,
+      presumedStaleLanes: presumedStaleLaneIds.slice(0, MAX_DISCLOSED_LANE_IDS),
+      staleTimeoutMs: PR_WORKFLOW_STALE_LANE_TIMEOUT_MS,
+      disclosure
+    })}
+`, "utf-8");
+  } catch {}
+  return {
+    openLaneIds,
+    openLanes: open2.length,
+    presumedStaleLaneIds,
+    disclosure
+  };
+}
 async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery", reason: "" }) {
-  const state = await requireAnyActiveState(directory, sessionID);
+  const recovery = await readPrWorkflowGateStateForRecovery(directory, sessionID);
+  if (!recovery)
+    throw noActiveGateError(sessionID);
+  const state = recovery.state;
   if (options.expectedMode && state.mode !== options.expectedMode) {
     throw wrongModeError(state, options.expectedMode);
   }
-  if (state.prFeedbackReadyToPublish) {
-    throw new Error(`BLOCKED: ${state.mode} is armed for publication; abort is blocked. Complete the workflow with complete_pr_workflow (or push the bound commit first) before aborting.`);
+  if (state.prFeedbackReadyToPublish || recovery.armedShapeUnreadable) {
+    throw new Error(`BLOCKED: ${state.mode} is armed for publication; abort is blocked. Complete the workflow with complete_pr_workflow (or push the bound commit first) before aborting.` + (recovery.armedShapeUnreadable ? " The publication-arming record is itself unreadable, so it is treated as armed (fail-closed)." : ""));
   }
-  const openLanes = readDelegations(directory).filter((record) => record.parentSessionId === state.sessionID && record.mode?.startsWith("swarm-pr-") && (record.status === "pending" || record.status === "running"));
-  if (openLanes.length > 0) {
-    const laneIds = openLanes.map((record) => record.laneId ?? record.subagentSessionId ?? "unknown").filter(Boolean).slice(0, 10).join(", ");
-    throw new Error(`BLOCKED: ${state.mode} abort refused while ${openLanes.length} PR workflow lane(s) are still in flight (lane ids: ${laneIds}). Collect their results or let them settle before aborting.`);
+  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
+  if (laneSettlement.openLanes > 0) {
+    const laneIds = laneSettlement.openLaneIds.filter(Boolean).slice(0, MAX_DISCLOSED_LANE_IDS).join(", ");
+    throw new Error(`BLOCKED: ${state.mode} abort refused while ${laneSettlement.openLanes} PR workflow lane(s) are still in flight (lane ids: ${laneIds}). Collect their results or let them settle before aborting.`);
   }
   const sanitizedReason = typeof options.reason === "string" && options.reason.trim().length > 0 ? options.reason.trim().slice(0, 500) : undefined;
   if (sanitizedReason === undefined) {
@@ -6926,7 +6994,16 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
     kind: options.kind,
     ...state.prHeadSha ? { prHeadSha: state.prHeadSha } : {},
     ...state.checkoutRecovery ? { hadTerminalRecovery: true } : {},
-    openLanes: openLanes.length,
+    openLanes: laneSettlement.openLanes,
+    ...laneSettlement.presumedStaleLaneIds.length > 0 ? {
+      presumedStaleLanes: laneSettlement.presumedStaleLaneIds.slice(0, MAX_DISCLOSED_LANE_IDS),
+      presumedStaleDisclosure: laneSettlement.disclosure
+    } : {},
+    ...recovery.salvaged ? {
+      stateSalvaged: true,
+      stateSalvageDisclosure: recovery.disclosure,
+      ...recovery.revisionSalvageable ? {} : { casEscapeDisclosure: CAS_ESCAPE_DISCLOSURE }
+    } : {},
     reason: sanitizedReason
   };
   try {
@@ -6934,11 +7011,39 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
     await fsp2.appendFile(eventsPath, `${JSON.stringify(abortEvent)}
 `, "utf-8");
   } catch {}
-  await clearPrWorkflowGateState(directory, sessionID, state.revision);
+  const casEscape = recovery.salvaged && !recovery.revisionSalvageable;
+  await _test_exports.beforeAbortClear?.();
+  try {
+    await clearPrWorkflowGateState(directory, sessionID, casEscape ? undefined : state.revision, { allowSalvagedRead: recovery.salvaged });
+  } catch (error2) {
+    try {
+      await fsp2.appendFile(validateSwarmPath(directory, "events.jsonl"), `${JSON.stringify({
+        type: "pr_workflow_abort_not_completed",
+        timestamp: isoNow(),
+        sessionID: state.sessionID,
+        mode: state.mode,
+        ...state.prHeadSha ? { prHeadSha: state.prHeadSha } : {},
+        reason: sanitizedReason,
+        failure: (error2 instanceof Error ? error2.message : String(error2)).slice(0, MAX_BASE_COVERAGE_DIAGNOSTIC_CHARS),
+        disclosure: "RETRACTION: the pr_workflow_aborted record for this session did NOT complete \u2014 " + "the clear failed and the gate state may still be active. Revalidate the current " + "session state before retrying the abort."
+      })}
+`, "utf-8");
+    } catch {}
+    throw error2;
+  }
   return {
     mode: state.mode,
     ...state.prHeadSha ? { prHeadSha: state.prHeadSha } : {},
-    openLanes: openLanes.length
+    openLanes: laneSettlement.openLanes,
+    ...laneSettlement.presumedStaleLaneIds.length > 0 ? {
+      presumedStaleLanes: laneSettlement.presumedStaleLaneIds,
+      presumedStaleDisclosure: laneSettlement.disclosure
+    } : {},
+    ...recovery.salvaged ? {
+      stateSalvaged: true,
+      stateSalvageDisclosure: recovery.disclosure
+    } : {},
+    ...casEscape ? { casEscapeDisclosure: CAS_ESCAPE_DISCLOSURE } : {}
   };
 }
 async function bindPrWorkflowHeadWhileLocked(directory, normalizedSessionID, prHeadSha) {
@@ -7343,9 +7448,9 @@ function assertSamePrFeedbackHandoff(state, relativePath, read, requestedPrUrl)
 async function assertPrReviewTerminalReady(directory, sessionID) {
   const state = await requireBoundState(directory, sessionID, "PR_REVIEW");
   await assertPrReviewCleanCheckout(directory, "PR_REVIEW");
-  const open2 = readDelegations(directory).filter((record) => record.parentSessionId === state.sessionID && record.mode?.startsWith("swarm-pr-") && (record.status === "pending" || record.status === "running"));
-  if (open2.length > 0) {
-    throw new Error(`BLOCKED: PR_REVIEW transition has ${open2.length} unsettled PR workflow lane(s)`);
+  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
+  if (laneSettlement.openLanes > 0) {
+    throw new Error(`BLOCKED: PR_REVIEW transition has ${laneSettlement.openLanes} unsettled PR workflow lane(s)`);
   }
   const ctx = await createPrReviewGateContext(directory, state);
   await assertPrReviewBaseCoverageSettled(directory, sessionID, ctx);
@@ -7490,6 +7595,7 @@ var _test_exports = {
     pendingCheckoutMutationsByProject.clear();
     completedCheckoutLockOwners.clear();
     _test_exports.beforeTerminalClear = undefined;
+    _test_exports.beforeAbortClear = undefined;
     _test_exports.beforePrFeedbackTransitionLock = undefined;
     _test_exports.beforePrFeedbackTrackingSwitch = undefined;
     _test_exports.afterPrFeedbackTrackingSwitch = undefined;
@@ -7506,6 +7612,7 @@ var _test_exports = {
     _test_exports.classifyPrWorkflowGitStateAsync = classifyPrWorkflowGitState;
   },
   beforeTerminalClear: undefined,
+  beforeAbortClear: undefined,
   beforePrFeedbackTransitionLock: undefined,
   beforePrFeedbackTrackingSwitch: undefined,
   afterPrFeedbackTrackingSwitch: undefined,
@@ -7565,11 +7672,13 @@ var _test_exports = {
   rename: fsp2.rename,
   nowMs: () => Date.now()
 };
+function noActiveGateError(sessionID) {
+  return new Error(`BLOCKED: no active PR workflow gate for session "${normalizeSessionID(sessionID)}". ` + `The gate is activated by running \`/swarm pr-review <pr-ref>\` (PR_REVIEW) or \`/swarm pr-feedback <pr-ref>\` (PR_FEEDBACK), ` + `or by the first dispatch_lanes_async call with mode "swarm-pr-review:*" / "swarm-pr-feedback:*".`);
+}
 async function requireAnyActiveState(directory, sessionID) {
   const state = await readPrWorkflowGateState(directory, sessionID);
-  if (!state) {
-    throw new Error(`BLOCKED: no active PR workflow gate for session "${normalizeSessionID(sessionID)}". ` + `The gate is activated by running \`/swarm pr-review <pr-ref>\` (PR_REVIEW) or \`/swarm pr-feedback <pr-ref>\` (PR_FEEDBACK), ` + `or by the first dispatch_lanes_async call with mode "swarm-pr-review:*" / "swarm-pr-feedback:*".`);
-  }
+  if (!state)
+    throw noActiveGateError(sessionID);
   return state;
 }
 async function requireBoundState(directory, sessionID, expectedMode) {
@@ -9263,6 +9372,76 @@ async function readPrWorkflowGateStateFileFromDisk(filePath, stateLabel) {
   }
   return parsed.data;
 }
+var MAX_SALVAGED_SCHEMA_ERRORS = 10;
+var MAX_SALVAGED_SCHEMA_ERROR_CHARS = 240;
+function boundSalvagedSchemaError(message) {
+  return message.length <= MAX_SALVAGED_SCHEMA_ERROR_CHARS ? message : `${message.slice(0, MAX_SALVAGED_SCHEMA_ERROR_CHARS - 1)}\u2026`;
+}
+async function readPrWorkflowGateStateForRecovery(directory, sessionID) {
+  const normalizedSessionID = normalizeSessionID(sessionID);
+  const filePath = workflowGateStatePath(directory, normalizedSessionID);
+  let raw;
+  try {
+    raw = await fsp2.readFile(filePath, "utf-8");
+  } catch (error2) {
+    if (error2.code === "ENOENT")
+      return null;
+    throw error2;
+  }
+  let parsedJson;
+  try {
+    parsedJson = JSON.parse(raw);
+  } catch {
+    throw new Error(`BLOCKED: PR workflow gate state for session "${normalizedSessionID}" is not valid JSON`);
+  }
+  const parsed = PrWorkflowGateStateSchema.safeParse(parsedJson);
+  if (parsed.success) {
+    return {
+      state: parsed.data,
+      salvaged: false,
+      schemaErrors: [],
+      revisionSalvageable: true,
+      armedShapeUnreadable: false
+    };
+  }
+  const invalidError = new Error(`BLOCKED: PR workflow gate state for session "${normalizedSessionID}" is invalid`);
+  if (typeof parsedJson !== "object" || parsedJson === null || Array.isArray(parsedJson)) {
+    throw invalidError;
+  }
+  const rawRecord = parsedJson;
+  const salvagedSessionID = exports_external.string().min(1).safeParse(rawRecord.sessionID);
+  const salvagedMode = exports_external.enum(["PR_REVIEW", "PR_FEEDBACK"]).safeParse(rawRecord.mode);
+  if (!salvagedSessionID.success || !salvagedMode.success)
+    throw invalidError;
+  const salvagedRevision = exports_external.number().int().nonnegative().safeParse(rawRecord.revision);
+  const salvagedHead = exports_external.string().min(1).safeParse(rawRecord.prHeadSha);
+  const salvagedActivatedAt = exports_external.string().min(1).safeParse(rawRecord.activatedAt);
+  const salvagedUpdatedAt = exports_external.string().min(1).safeParse(rawRecord.updatedAt);
+  const armedKeyPresent = rawRecord.prFeedbackReadyToPublish !== undefined;
+  const salvagedArmed = PrFeedbackReadyToPublishRecordSchema.safeParse(rawRecord.prFeedbackReadyToPublish);
+  const salvagedCheckoutRecovery = PrWorkflowCheckoutRecoveryRecordSchema.safeParse(rawRecord.checkoutRecovery);
+  const armedShapeUnreadable = armedKeyPresent && !salvagedArmed.success;
+  const schemaErrors = parsed.error.issues.slice(0, MAX_SALVAGED_SCHEMA_ERRORS).map((issue) => boundSalvagedSchemaError(`${issue.path.join(".") || "(root)"}: ${issue.message}`));
+  const disclosure = `DEGRADED: PR workflow gate state for session "${normalizedSessionID}" failed schema validation ` + `and was SALVAGED for recovery only (abort/status; write and completion paths still refuse it). ` + `Schema errors: ${schemaErrors.join("; ")}.` + (salvagedRevision.success ? "" : " state revision unsalvageable.") + (armedShapeUnreadable ? " prFeedbackReadyToPublish is present but unreadable; treated as ARMED (fail-closed)." : "");
+  return {
+    state: {
+      schemaVersion: GATE_SCHEMA_VERSION,
+      revision: salvagedRevision.success ? salvagedRevision.data : 0,
+      sessionID: salvagedSessionID.data,
+      mode: salvagedMode.data,
+      activatedAt: salvagedActivatedAt.success ? salvagedActivatedAt.data : isoNow(),
+      updatedAt: salvagedUpdatedAt.success ? salvagedUpdatedAt.data : isoNow(),
+      ...salvagedHead.success ? { prHeadSha: salvagedHead.data } : {},
+      ...salvagedArmed.success ? { prFeedbackReadyToPublish: salvagedArmed.data } : {},
+      ...salvagedCheckoutRecovery.success ? { checkoutRecovery: salvagedCheckoutRecovery.data } : {}
+    },
+    salvaged: true,
+    schemaErrors,
+    disclosure,
+    revisionSalvageable: salvagedRevision.success,
+    armedShapeUnreadable
+  };
+}
 function rememberState(directory, state) {
   const cacheKey = stateCacheKey(directory, state.sessionID);
   trackedStatesByProjectSession.delete(cacheKey);
@@ -14931,7 +15110,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-mnj0ter5.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8xertnqz.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -16015,7 +16194,7 @@ async function runCuratorPhase(directory, phase, agentsDispatched, config, knowl
     }
     if (config.skill_generation_enabled === true && skillCandidates.length > 0) {
       try {
-        const skillModule = await import("./skill-generator-khaw3jjw.js");
+        const skillModule = await import("./skill-generator-4d2t5gem.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -16475,7 +16654,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-1g4p844a.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-rmy3jcx4.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -17294,7 +17473,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-qvky2yem.js");
+      const { getScanStatus } = await import("./scan-cursor-ahgm4f5p.js");
       const scanStatus = await getScanStatus(directory);
       if (scanStatus.remaining_estimate > 0) {
         warnings.push(`Fair scan: reviewed ${knowledgeSummary.length} entries this sweep (generation ${scanStatus.generation}); ${scanStatus.remaining_estimate} more eligible entries will be visited in future curation sweeps.`);
@@ -17466,9 +17645,9 @@ var _internals23 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-wgb37f83.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-epdq7ykx.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-mnj0ter5.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8xertnqz.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -17476,11 +17655,11 @@ var _internals23 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-e2sp925h.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-v97jnwn2.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-cw08380z.js");
+    const { checkHivePromotions } = await import("./hive-promoter-vwq1dbh1.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -17489,7 +17668,7 @@ var _internals23 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-khaw3jjw.js");
+    } = await import("./skill-generator-4d2t5gem.js");
     const result = {
       approved: [],
       rejected: [],
@@ -18825,9 +19004,9 @@ function hashContent(content) {
   return createHash7("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-wgb37f83.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-epdq7ykx.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-mnj0ter5.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8xertnqz.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -27267,7 +27446,11 @@ var ARCHIVE_ARTIFACTS = [
   "session-reflection.md",
   "spec.md",
   "spec-staleness.json",
-  "spec-snapshot.md"
+  "spec-snapshot.md",
+  "background-delegations.jsonl",
+  "background-delegations.checkpoint.json",
+  "background-delegations.manifest.json",
+  "background-delegations-health.json"
 ];
 var ACTIVE_STATE_TO_CLEAN = [
   "plan.json",
@@ -27669,7 +27852,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-wgb37f83.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-epdq7ykx.js");
     const { config: pmLoadedConfig } = _internals36.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -29947,9 +30130,9 @@ var _internals41 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-wgb37f83.js"),
-      import("./curator-e2sp925h.js"),
-      import("./curator-llm-factory-xsg7wesn.js")
+      import("./schema-epdq7ykx.js"),
+      import("./curator-v97jnwn2.js"),
+      import("./curator-llm-factory-fyjmgxyp.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -30854,7 +31037,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-qvky2yem.js");
+    const { getScanStatus } = await import("./scan-cursor-ahgm4f5p.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -30864,10 +31047,10 @@ async function computeCurationDiagnostics(directory, entries) {
   try {
     const { isLinked: isLinked2 } = await import("./knowledge-link-fn5j3r4q.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-wgb37f83.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-epdq7ykx.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-mnj0ter5.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-8xertnqz.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
@@ -32085,7 +32268,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-y8wfw196.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-7gy47evn.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -32922,7 +33105,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-pfppq7mv.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-79mtxzhd.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -32957,12 +33140,13 @@ async function handleEvidenceSummaryCommand(directory) {
 `);
 }
 // src/services/export-service.ts
+init_package();
 async function getExportData(directory) {
   const planStructured = await loadPlanJsonOnly(directory);
   const planContent = await readSwarmFileAsync(directory, "plan.md");
   const contextContent = await readSwarmFileAsync(directory, "context.md");
   return {
-    version: "4.5.0",
+    version: package_default.version,
     exported: new Date().toISOString(),
     plan: planStructured || planContent,
     context: contextContent,
@@ -43175,6 +43359,7 @@ var _internals63 = {
 };
 
 // src/services/preflight-service.ts
+init_zod();
 import * as fs33 from "fs";
 import * as path78 from "path";
 
@@ -48546,6 +48731,15 @@ async function runEvidenceCheck(dir) {
     };
   }
 }
+var ReqCoverageReportSchema = exports_external.object({
+  success: exports_external.boolean(),
+  phase: exports_external.number().int().nonnegative(),
+  totalRequirements: exports_external.number().int().nonnegative(),
+  coveredCount: exports_external.number().int().nonnegative(),
+  missingCount: exports_external.number().int().nonnegative(),
+  requirements: exports_external.array(exports_external.unknown())
+});
+var REQ_COVERAGE_MAX_JSON_BYTES = 500 * 1024;
 async function runRequirementCoverageCheck(dir, currentPhase) {
   const startTime = Date.now();
   try {
@@ -48559,20 +48753,156 @@ async function runRequirementCoverageCheck(dir, currentPhase) {
       };
     }
     const coverage = await checkRequirementCoverage(currentPhase, dir);
-    if (coverage.exists) {
+    if (!coverage.exists) {
       return {
         type: "req_coverage",
-        status: "pass",
-        message: "Requirement coverage report found",
+        status: "fail",
+        message: "Requirement coverage report missing but effective spec exists",
+        details: { expectedPath: coverage.path },
+        durationMs: Date.now() - startTime
+      };
+    }
+    let raw;
+    try {
+      const stat7 = await fs33.promises.stat(coverage.path);
+      if (stat7.size > REQ_COVERAGE_MAX_JSON_BYTES) {
+        return {
+          type: "req_coverage",
+          status: "fail",
+          message: `Requirement coverage report exceeds ${REQ_COVERAGE_MAX_JSON_BYTES} byte cap and cannot be validated`,
+          details: { path: coverage.path, sizeBytes: stat7.size },
+          durationMs: Date.now() - startTime
+        };
+      }
+      raw = await fs33.promises.readFile(coverage.path, "utf-8");
+    } catch (readError) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: `Requirement coverage report unreadable: ${readError instanceof Error ? readError.message : String(readError)}`,
+        details: { path: coverage.path },
+        durationMs: Date.now() - startTime
+      };
+    }
+    const trimmed = raw.trim();
+    if (trimmed.length === 0) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: "Requirement coverage report is empty",
+        details: { path: coverage.path },
+        durationMs: Date.now() - startTime
+      };
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch (parseError) {
+      const parseErrorMessage = parseError instanceof Error ? parseError.message : String(parseError);
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: `Requirement coverage report is not valid JSON: ${parseErrorMessage}`,
+        details: { path: coverage.path },
+        durationMs: Date.now() - startTime
+      };
+    }
+    const report = ReqCoverageReportSchema.safeParse(parsed);
+    if (!report.success) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: "Requirement coverage report does not match the expected report shape",
         details: { path: coverage.path },
         durationMs: Date.now() - startTime
       };
     }
+    const {
+      success,
+      phase,
+      totalRequirements,
+      coveredCount,
+      missingCount,
+      requirements
+    } = report.data;
+    if (!success) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: "Requirement coverage report indicates the coverage run itself failed (success: false)",
+        details: { path: coverage.path },
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (phase !== currentPhase) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: `Requirement coverage report phase (${phase}) does not match the current phase (${currentPhase})`,
+        details: { path: coverage.path, reportPhase: phase, currentPhase },
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (totalRequirements === 0) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: "Requirement coverage report contains no requirements (totalRequirements is 0) but effective spec exists",
+        details: { path: coverage.path, totalRequirements },
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (coveredCount + missingCount !== totalRequirements) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: `Requirement coverage report counts are inconsistent: coveredCount (${coveredCount}) + missingCount (${missingCount}) !== totalRequirements (${totalRequirements})`,
+        details: {
+          path: coverage.path,
+          totalRequirements,
+          coveredCount,
+          missingCount
+        },
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (requirements.length !== totalRequirements) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: `Requirement coverage report requirements array length (${requirements.length}) does not match totalRequirements (${totalRequirements})`,
+        details: {
+          path: coverage.path,
+          totalRequirements,
+          requirementsLength: requirements.length
+        },
+        durationMs: Date.now() - startTime
+      };
+    }
+    if (missingCount > 0) {
+      return {
+        type: "req_coverage",
+        status: "fail",
+        message: `Requirement coverage report has ${missingCount} uncovered requirement(s)`,
+        details: {
+          path: coverage.path,
+          totalRequirements,
+          coveredCount,
+          missingCount
+        },
+        durationMs: Date.now() - startTime
+      };
+    }
     return {
       type: "req_coverage",
-      status: "fail",
-      message: "Requirement coverage report missing but effective spec exists",
-      details: { expectedPath: coverage.path },
+      status: "pass",
+      message: `Requirement coverage report found: ${coveredCount}/${totalRequirements} requirement(s) covered`,
+      details: {
+        path: coverage.path,
+        totalRequirements,
+        coveredCount,
+        missingCount
+      },
       durationMs: Date.now() - startTime
     };
   } catch (error2) {
@@ -56157,11 +56487,11 @@ async function handleSpecifyCommand(_directory, args) {
 }
 
 // src/services/status-service.ts
-init_loader();
-init_schema();
 import * as fsSync3 from "fs";
 import { readFile as readFile23 } from "fs/promises";
 import * as path100 from "path";
+init_loader();
+init_schema();
 
 // src/consensus/store.ts
 import { readdir as readdir5, unlink as unlink4 } from "fs/promises";
@@ -56558,6 +56888,15 @@ var _internals85 = {
   getActiveFullAutoSessionID,
   loadFullAutoRunState
 };
+function formatLedgerBytes(bytes) {
+  if (bytes >= 1024 * 1024) {
+    return `${Math.round(bytes / (1024 * 1024) * 10) / 10} MiB`;
+  }
+  if (bytes >= 1024) {
+    return `${Math.round(bytes / 1024 * 10) / 10} KiB`;
+  }
+  return `${bytes} B`;
+}
 function readSpecStalenessSnapshot(directory) {
   try {
     const p = path100.join(directory, ".swarm", "spec-staleness.json");
@@ -56675,6 +57014,15 @@ async function getStatusData(directory, agents, sessionId) {
   } catch {
     status.consensusReports = 0;
   }
+  try {
+    status.delegationLedgerHealth = collectDelegationLedgerHealth(directory, {
+      ledgerLimitBytes: MAX_RECOVERY_LEDGER_BYTES,
+      lowWaterBytes: DELEGATION_COMPACTION_LOW_WATER_BYTES,
+      highWaterBytes: DELEGATION_COMPACTION_HIGH_WATER_BYTES
+    }) ?? undefined;
+  } catch {
+    status.delegationLedgerHealth = undefined;
+  }
   try {
     const pointer = readLinkPointer(directory);
     if (pointer) {
@@ -56973,6 +57321,32 @@ function formatStatusMarkdown(status) {
   } else {
     lines.push("", "**Memory Cohort**: local (not linked \u2014 run `/swarm memory link` to share memory across worktrees; requires `memory.link.enabled: true`)");
   }
+  const delegationHealth = status.delegationLedgerHealth;
+  if (delegationHealth) {
+    lines.push("", "**Background Delegations**:");
+    lines.push(`  - Ledger tail: ${formatLedgerBytes(delegationHealth.ledger.bytes)} / ${formatLedgerBytes(delegationHealth.ledger.limitBytes)} recovery bound (${delegationHealth.ledger.pressurePct}% \u2014 ${delegationHealth.ledger.band})`);
+    if (delegationHealth.checkpoint) {
+      const checkpoint2 = delegationHealth.checkpoint;
+      lines.push(`  - Checkpoint #${checkpoint2.sequence}: ${checkpoint2.liveRecords} live records, ${checkpoint2.closedSummaries} archived summaries (${formatLedgerBytes(checkpoint2.bytes)}, ${new Date(checkpoint2.createdAt).toISOString()})`);
+    } else {
+      lines.push("  - Checkpoint: none (full-history recovery)");
+    }
+    if (delegationHealth.recovery) {
+      const recovery = delegationHealth.recovery;
+      lines.push(`  - Recovery: ${recovery.source} (${recovery.ok ? "ok" : `FAILED: ${recovery.reason ?? "uncertain"}`})`);
+    }
+    if (delegationHealth.lastUncertainty) {
+      const uncertainty = delegationHealth.lastUncertainty;
+      lines.push(`  - \u26A0 Last uncertainty (${new Date(uncertainty.at).toISOString()}, ${uncertainty.source}): ${uncertainty.reason}`);
+      if (uncertainty.repairHint) {
+        lines.push(`    repair: ${uncertainty.repairHint}`);
+      }
+    }
+    const counts = delegationHealth.counts;
+    if (counts.activeOwners > 0 || counts.pendingAdvisories > 0 || counts.lateTerminals > 0 || counts.orphanWorktreeOwners > 0) {
+      lines.push(`  - Live set: ${counts.activeOwners} active owners, ${counts.pendingAdvisories} pending advisories, ${counts.lateTerminals} late terminals, ${counts.orphanWorktreeOwners} unsettled worktree owners`);
+    }
+  }
   return lines.join(`
 `);
 }
@@ -56989,6 +57363,33 @@ async function handleStatusCommand(directory, agents, sessionId) {
         `**Spec drift detected**: ${reason} (stored: ${stored}, current: ${current})`,
         "Run `/swarm clarify` to enter spec repair mode. Clarify alone does not clear drift: rewrite the spec so recovery can reconcile it, or run `/swarm acknowledge-spec-drift` to dismiss."
       ].join(`
+`);
+    }
+    const delegationHealth = statusData.delegationLedgerHealth;
+    if (delegationHealth && (delegationHealth.checkpoint || delegationHealth.recovery || delegationHealth.lastUncertainty || delegationHealth.ledger.band !== "ok" || delegationHealth.counts.activeOwners > 0 || delegationHealth.counts.pendingAdvisories > 0 || delegationHealth.counts.lateTerminals > 0 || delegationHealth.counts.orphanWorktreeOwners > 0)) {
+      const lines = [
+        "No active swarm plan found.",
+        "",
+        "**Background Delegations**:"
+      ];
+      lines.push(`  - Ledger tail: ${formatLedgerBytes(delegationHealth.ledger.bytes)} / ${formatLedgerBytes(delegationHealth.ledger.limitBytes)} recovery bound (${delegationHealth.ledger.pressurePct}% \u2014 ${delegationHealth.ledger.band})`);
+      if (delegationHealth.checkpoint) {
+        lines.push(`  - Checkpoint #${delegationHealth.checkpoint.sequence} (${delegationHealth.checkpoint.liveRecords} live, ${delegationHealth.checkpoint.closedSummaries} archived)`);
+      }
+      if (delegationHealth.recovery) {
+        lines.push(`  - Recovery: ${delegationHealth.recovery.source} (${delegationHealth.recovery.ok ? "ok" : `FAILED: ${delegationHealth.recovery.reason ?? "uncertain"}`})`);
+      }
+      const compactCounts = delegationHealth.counts;
+      if (compactCounts.activeOwners > 0 || compactCounts.pendingAdvisories > 0 || compactCounts.lateTerminals > 0 || compactCounts.orphanWorktreeOwners > 0) {
+        lines.push(`  - Live set: ${compactCounts.activeOwners} active owners, ${compactCounts.pendingAdvisories} pending advisories, ${compactCounts.lateTerminals} late terminals, ${compactCounts.orphanWorktreeOwners} unsettled worktree owners`);
+      }
+      if (delegationHealth.lastUncertainty) {
+        lines.push(`  - \u26A0 Last uncertainty (${new Date(delegationHealth.lastUncertainty.at).toISOString()}): ${delegationHealth.lastUncertainty.reason}`);
+        if (delegationHealth.lastUncertainty.repairHint) {
+          lines.push(`    repair: ${delegationHealth.lastUncertainty.repairHint}`);
+        }
+      }
+      return lines.join(`
 `);
     }
     return "No active swarm plan found.";
@@ -57474,7 +57875,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-1kr1vey5.js");
+    const { buildHelpText } = await import("./index-e70d3xr7.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -57483,7 +57884,7 @@ async function handleHelpCommand(ctx) {
     return _internals87.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals87.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-1kr1vey5.js");
+  const { buildHelpText: fullHelp } = await import("./index-e70d3xr7.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -57660,7 +58061,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-byzmrgg1.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-9ry66z5g.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -57670,7 +58071,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-byzmrgg1.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-9ry66z5g.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -57680,7 +58081,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-nr2g7hbw.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-fe6smme1.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -64892,7 +65293,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-bfz3drxm.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-j6d33p49.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function precreateStandardWorktreeSession(args) {
@@ -65040,7 +65441,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-zszmexgm.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-cpcspaw5.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -65539,7 +65940,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-zszmexgm.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-cpcspaw5.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);