opencode-swarm 7.143.4 → 7.143.6

package/dist/cli/{index-gz3z9d64.js → index-5d8ydxae.js}

@@ -1,13 +1,13 @@
 // @bun
 import {
   stableCanonicalStringify
-} from "./index-6htwcbxh.js";
+} from "./index-nd1j9wkw.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-ja15rdzd.js";
+} from "./index-whyrhjsk.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -54,7 +54,7 @@ import {
   updateTaskCheckpointReceipt,
   updateTaskStatus,
   validateProjectRoot
-} from "./index-c9d5y70c.js";
+} from "./index-w1q9yy1e.js";
 import {
   loadDatabaseCtor
 } from "./index-134d35c1.js";
@@ -106,7 +106,7 @@ import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-dmtq7tvd.js";
+} from "./index-92bm9ys3.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -141,7 +141,7 @@ import {
   startupOrphanRecovery,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-td2ga37v.js";
+} from "./index-bbv64s17.js";
 import {
   changedFilesSinceSnapshot,
   parsePorcelainV2Snapshot,
@@ -188,16 +188,16 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-19wyta2k.js";
+} from "./index-02nm8qhk.js";
 import {
   readRecentEscalations
-} from "./index-f3xf9dv5.js";
+} from "./index-scj2asek.js";
 import {
   MAX_PENDING_SCOPE_BINDINGS,
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-v9qmhrj9.js";
+} from "./index-z4cv77tq.js";
 import {
   appendLedgerEvent,
   computePlanHash,
@@ -210,7 +210,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-8qmnqd6g.js";
+} from "./index-hjy4txgr.js";
 import {
   isPathWithinDeclaredScope
 } from "./index-556ja8an.js";
@@ -232,13 +232,15 @@ import {
   removeWorktreeProvisioningOwner
 } from "./index-k3cxyk66.js";
 import {
+  DEFAULT_STALE_DELEGATION_TIMEOUT_MS,
   findByBatchId,
-  readDelegations
-} from "./index-8aabbfhv.js";
+  readDelegations,
+  sweepStaleDelegations
+} from "./index-6vmazy9f.js";
 import {
   provisionWorktree,
   removeWorktree
-} from "./index-gbr0jbxy.js";
+} from "./index-s7nb33pc.js";
 import {
   SandboxCapabilityProbe,
   init_capability_probe
@@ -262,10 +264,10 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-8fq18k02.js";
+} from "./index-0adcjpyx.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-9m5gz9ea.js";
+} from "./index-peqmw3wr.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-gprxjmm7.js";
@@ -275,7 +277,7 @@ import {
   init_loader,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-f39n8pbr.js";
+} from "./index-36vry26a.js";
 import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
@@ -289,7 +291,7 @@ import {
   package_default,
   resolveAutoReviewConfig,
   stripKnownSwarmPrefix
-} from "./index-z4g05zbr.js";
+} from "./index-7bs015gm.js";
 import {
   readSwarmFileAsync,
   safeHook,
@@ -324,7 +326,7 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-z0j133c4.js";
+} from "./index-gzxz0s50.js";
 import {
   authorizeCuration,
   buildConfigFingerprintInput
@@ -361,7 +363,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-5qqyvwqw.js";
+} from "./index-wjk00vwk.js";
 import {
   resolveHiveDataDir,
   resolveHiveEventsPath,
@@ -4153,7 +4155,7 @@ async function cleanupRecoveredWorktree(directory, descriptor) {
     awaitingMergeByCallID,
     cleanupStandardWorktreeForCallId,
     standardWorktreeByCallID
-  } = await import("./worktree-isolation-cc3x13ng.js");
+  } = await import("./worktree-isolation-fbfvxw9a.js");
   standardWorktreeByCallID.delete(descriptor.callID);
   if (hasResidue)
     awaitingMergeByCallID.set(descriptor.callID, {
@@ -4232,7 +4234,7 @@ async function recoverCoderSettlement(directory, taskId) {
           awaitingMergeByCallID,
           finishStandardWorktreeDispatch,
           standardWorktreeByCallID
-        } = await import("./worktree-isolation-cc3x13ng.js");
+        } = await import("./worktree-isolation-fbfvxw9a.js");
         const descriptor = wal.worktree;
         const reconstructedDispatch = {
           callID: descriptor.callID,
@@ -6261,7 +6263,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 +6306,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 +6346,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 +6598,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 +6705,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 +6799,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 +6891,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 +6912,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 +6990,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 +7007,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 +7444,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 +7591,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 +7608,7 @@ var _test_exports = {
     _test_exports.classifyPrWorkflowGitStateAsync = classifyPrWorkflowGitState;
   },
   beforeTerminalClear: undefined,
+  beforeAbortClear: undefined,
   beforePrFeedbackTransitionLock: undefined,
   beforePrFeedbackTrackingSwitch: undefined,
   afterPrFeedbackTrackingSwitch: undefined,
@@ -7565,11 +7668,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 +9368,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 +15106,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-seedt8m3.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-kc2x117y.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -16015,7 +16190,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-3jstr1sx.js");
+        const skillModule = await import("./skill-generator-t202jza0.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -16475,7 +16650,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-8akk4n18.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-ejpyrby0.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -17294,7 +17469,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-em4vrcw6.js");
+      const { getScanStatus } = await import("./scan-cursor-x7a99wmq.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 +17641,9 @@ var _internals23 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-1wmfgtm9.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-z141arx9.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-seedt8m3.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-kc2x117y.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -17476,11 +17651,11 @@ var _internals23 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-tbw9przg.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-2gt2835v.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-nksqxfs4.js");
+    const { checkHivePromotions } = await import("./hive-promoter-fyb40am9.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -17489,7 +17664,7 @@ var _internals23 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-3jstr1sx.js");
+    } = await import("./skill-generator-t202jza0.js");
     const result = {
       approved: [],
       rejected: [],
@@ -18825,9 +19000,9 @@ function hashContent(content) {
   return createHash7("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-1wmfgtm9.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-z141arx9.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-seedt8m3.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-kc2x117y.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -27669,7 +27844,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-1wmfgtm9.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-z141arx9.js");
     const { config: pmLoadedConfig } = _internals36.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -29947,9 +30122,9 @@ var _internals41 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-1wmfgtm9.js"),
-      import("./curator-tbw9przg.js"),
-      import("./curator-llm-factory-j42j5rcr.js")
+      import("./schema-z141arx9.js"),
+      import("./curator-2gt2835v.js"),
+      import("./curator-llm-factory-x1vjhrnc.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -30854,7 +31029,7 @@ async function computeCurationDiagnostics(directory, entries) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-em4vrcw6.js");
+    const { getScanStatus } = await import("./scan-cursor-x7a99wmq.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -30864,10 +31039,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-1wmfgtm9.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-z141arx9.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-seedt8m3.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-kc2x117y.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
@@ -32085,7 +32260,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-az6nqawx.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-72zp0k4x.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -32922,7 +33097,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-3f319cst.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-yjr0662r.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -32957,12 +33132,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 +43351,7 @@ var _internals63 = {
 };
 
 // src/services/preflight-service.ts
+init_zod();
 import * as fs33 from "fs";
 import * as path78 from "path";
 
@@ -48546,6 +48723,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 +48745,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) {
@@ -57474,7 +57796,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-mewk624g.js");
+    const { buildHelpText } = await import("./index-dtf2va28.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -57483,7 +57805,7 @@ async function handleHelpCommand(ctx) {
     return _internals87.buildDetailedHelp(resolved.key, resolved.entry);
   }
   const similar = _internals87.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-mewk624g.js");
+  const { buildHelpText: fullHelp } = await import("./index-dtf2va28.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -57660,7 +57982,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-tsgsw91f.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-f3zysesy.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 +57992,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-tsgsw91f.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-f3zysesy.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 +58002,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-70cxb3va.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-eat71fnh.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -64892,7 +65214,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-42bb3gcb.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function precreateStandardWorktreeSession(args) {
@@ -65040,7 +65362,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, provisionResult.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-a6rzajem.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-aj0wmbg8.js");
       await writeLaneProfileToDiskReal(provisionResult.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -65539,7 +65861,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-a6rzajem.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-aj0wmbg8.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);