opencode-swarm 7.166.4 → 7.167.0

package/dist/cli/{index-5qws47d4.js → index-wyca2c0w.js}

@@ -25,13 +25,13 @@ import {
   protectedRoots,
   redactDecisionLineForArchive,
   stableCanonicalStringify
-} from "./index-n189w64j.js";
+} from "./index-9qceke8g.js";
 import {
   detectStraySwarmDirs,
   readDoctorArtifact,
   removeStraySwarmDir,
   runConfigDoctor
-} from "./index-gccxen4x.js";
+} from "./index-jhna6xnb.js";
 import {
   MAX_TRANSIENT_RETRIES,
   archiveEvidence,
@@ -72,7 +72,7 @@ import {
   updateTaskCheckpointReceipt,
   updateTaskStatus,
   validateProjectRoot
-} from "./index-kwervbv6.js";
+} from "./index-n5bqrkgw.js";
 import {
   EvaluationTaskV1Schema,
   GateAuditManifestV1Schema,
@@ -128,15 +128,15 @@ import {
   retireSkill,
   selectCandidateEntries,
   syncBundledProjectSkillsIfMissingAsync
-} from "./index-qv4byzwp.js";
+} from "./index-chdyjg3s.js";
 import {
   readRecentEscalations
-} from "./index-n65x6e1y.js";
+} from "./index-ywa4jvg9.js";
 import {
   alreadyCuratedThisGeneration,
   claimNextScanBatch,
   resolveCohortId
-} from "./index-7g5kdtvw.js";
+} from "./index-t6hdjtfy.js";
 import {
   CURATOR_INIT_PROMPT,
   CURATOR_PHASE_PROMPT,
@@ -179,7 +179,7 @@ import {
   listCoderSettlementWalStates,
   recoverCoderSettlement,
   recoverStaleCoderSettlements
-} from "./index-z62gdhkd.js";
+} from "./index-wkj8m6wh.js";
 import {
   parsePorcelainV2Snapshot,
   resolveCommitCountSince,
@@ -248,13 +248,13 @@ import {
   transitionTaskWorkflowEvidence,
   withTaskEvidenceTransaction,
   writeWorkflowWalFile
-} from "./index-bxrxqwce.js";
+} from "./index-qmqn59mw.js";
 import {
   isPathUnderSwarmWorktreeBase,
   makeWorktreeBranchName,
   provisionWorktree,
   removeWorktree
-} from "./index-8ewgab6z.js";
+} from "./index-gw2d37dz.js";
 import {
   DEFAULT_STALE_DELEGATION_TIMEOUT_MS,
   DELEGATION_COMPACTION_HIGH_WATER_BYTES,
@@ -288,7 +288,7 @@ import {
   scanBackgroundCoderReservationsForAdmission,
   scanDelegationsForRecovery,
   sweepStaleDelegations
-} from "./index-3ct7fd75.js";
+} from "./index-zq0btxga.js";
 import {
   MAX_EVENT_LOG_ENTRIES,
   _internals,
@@ -304,7 +304,7 @@ import {
   recordKnowledgeEvent,
   recordPhaseCloseIntent,
   resolveKnowledgeEventsPath
-} from "./index-kz44j3qe.js";
+} from "./index-gbbahxhw.js";
 import {
   estimateTokens,
   readSwarmFileAsync,
@@ -330,7 +330,7 @@ import {
   validateActionableFields,
   validateLesson,
   validateSkillPath
-} from "./index-wd86yj53.js";
+} from "./index-7yax969v.js";
 import {
   MAX_CURATION_PROPOSALS,
   authorizeCuration,
@@ -341,7 +341,7 @@ import {
 } from "./index-rtry5xyf.js";
 import {
   resolveWorktreeIsolationConfig
-} from "./index-st1zw5ps.js";
+} from "./index-d2phtxg2.js";
 import {
   RetrospectiveEvidenceSchema
 } from "./index-3qf1vxtb.js";
@@ -351,7 +351,7 @@ import {
   clearAllScopes,
   clearScopeBindingFromDisk,
   clearScopeBindings
-} from "./index-gr5wg0nj.js";
+} from "./index-dczrrnzp.js";
 import {
   appendLedgerEvent,
   computePlanLedgerHash,
@@ -364,7 +364,7 @@ import {
   readPlanEpochIdentity,
   replayFromLedgerWithStatus,
   takeSnapshotEvent
-} from "./index-v5wanchr.js";
+} from "./index-va2m1y35.js";
 import {
   CORE_EVENT_LOCKED,
   appendCoreEventSync,
@@ -447,7 +447,7 @@ import {
   transactFile,
   transactKnowledge,
   wordBigrams
-} from "./index-3s194swm.js";
+} from "./index-r09mpxtp.js";
 import {
   readTailJsonl,
   readTailJsonlDetailed,
@@ -510,7 +510,7 @@ import {
   loadGateOverrides,
   loadPluginConfig,
   loadPluginConfigWithMeta
-} from "./index-9eswrdp5.js";
+} from "./index-kg74hnbc.js";
 import {
   init_git_executable,
   resolveGitExecutable,
@@ -527,6 +527,7 @@ import {
   DEFAULT_SKILL_OPT_CONFIG,
   FALLBACK_MODELS_MAX,
   KnowledgeConfigSchema,
+  LaneLivenessWatchdogConfigSchema,
   MemoryConfigSchema,
   SkillImproverConfigSchema,
   getCanonicalAgentRole,
@@ -537,7 +538,7 @@ import {
   resolveAutoReviewConfig,
   resolveGeneratedAgentRole,
   stripKnownSwarmPrefix
-} from "./index-shqhq68n.js";
+} from "./index-mqbgkv5h.js";
 import {
   AGENT_TOOL_MAP,
   ALL_AGENT_NAMES,
@@ -9488,7 +9489,7 @@ async function importLegacyPrWorkflowGateStateIfNeeded(directory, sessionID, all
       return null;
     throw error2;
   }
-  const legacy = allowSalvagedImport ? (await (await import("./pr-workflow-gate-px36rczj.js")).readPrWorkflowGateStateForRecovery(directory, sessionID))?.state ?? null : await readPrWorkflowGateStateFileFromDisk(filePath, sessionID);
+  const legacy = allowSalvagedImport ? (await (await import("./pr-workflow-gate-dgk3zzgs.js")).readPrWorkflowGateStateForRecovery(directory, sessionID))?.state ?? null : await readPrWorkflowGateStateFileFromDisk(filePath, sessionID);
   if (!legacy)
     return null;
   const namespace = workflowGateStateCoordinationNamespace(sessionID);
@@ -9558,7 +9559,7 @@ async function deleteStateWhileLocked(directory, sessionID, options = {}) {
   let recoveryState = null;
   if (!currentAuthoritative) {
     if (options.allowSalvagedRead) {
-      const { readPrWorkflowGateStateForRecovery } = await import("./pr-workflow-gate-px36rczj.js");
+      const { readPrWorkflowGateStateForRecovery } = await import("./pr-workflow-gate-dgk3zzgs.js");
       recoveryState = (await readPrWorkflowGateStateForRecovery(directory, normalizedSessionID))?.state ?? null;
     }
     if (!recoveryState) {
@@ -11883,6 +11884,49 @@ function bindingRejection(state, event) {
 // src/hooks/pr-workflow-gate.ts
 init_tool_metadata();
 init_logger();
+
+// src/hooks/lane-liveness-watchdog.ts
+init_schema();
+var LANE_LIVENESS_WATCHDOG_DEFAULTS = LaneLivenessWatchdogConfigSchema.parse({});
+var MAX_LANE_LIVENESS_DISCLOSED_IDS = 10;
+function classifyLaneLivenessCondition(input) {
+  if (input.recordStatus === "error") {
+    return "completed_failure";
+  }
+  const sessionLiveOrUnknown = input.sessionStatusType === undefined || input.sessionStatusType === "busy" || input.sessionStatusType === "retry";
+  if (input.waitBudgetExpired && sessionLiveOrUnknown) {
+    return "observer_deadline";
+  }
+  if (input.sessionStatusType === "retry") {
+    return "provider_retry_in_flight";
+  }
+  if (input.exceededEffectiveHorizon) {
+    return "execution_deadline";
+  }
+  return "idle_failed_child";
+}
+function resolveEffectivePrLaneHorizonMs(watchdog, backgroundPendingTimeoutMs) {
+  const watchdogOwnsHorizon = watchdog?.enabled === true && (watchdog.timeout_ms ?? 0) > 0;
+  const horizonMs = watchdogOwnsHorizon ? watchdog?.timeout_ms : DEFAULT_STALE_DELEGATION_TIMEOUT_MS;
+  return {
+    horizonMs,
+    source: watchdogOwnsHorizon ? "watchdog-timeout" : "reachability-floor",
+    conflictDisclosed: backgroundPendingTimeoutMs !== undefined && backgroundPendingTimeoutMs > 0 && backgroundPendingTimeoutMs !== horizonMs
+  };
+}
+var ZERO_LANE_ACTIVITY = {
+  stepsObserved: 0,
+  estimatedTokens: 0
+};
+var defaultReadLaneActivity = () => ZERO_LANE_ACTIVITY;
+function laneLivenessWatchdogFeatures(watchdog) {
+  const enabled = watchdog?.enabled === true;
+  return {
+    deadlineActive: enabled && (watchdog?.timeout_ms ?? 0) > 0,
+    stallActive: enabled && (watchdog?.stall_threshold_ms ?? 0) > 0 && (watchdog?.stall_min_steps ?? 0) > 0 && (watchdog?.stall_token_threshold ?? 0) > 0
+  };
+}
+// src/hooks/pr-workflow-gate.ts
 function readPrWorkflowGateStateFromDisk3(directory, sessionID) {
   return readPrWorkflowGateStateFromDisk(directory, sessionID);
 }
@@ -12694,39 +12738,266 @@ function prWorkflowLaneLabel(record) {
 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) {
+var laneLivenessWatchdogSurface = {
+  resolveEffectivePrLaneHorizonMs,
+  classifyLaneLivenessCondition,
+  evaluateLaneLivenessWatchdog: evaluateLaneLivenessWatchdogEscalation,
+  readLaneActivity: defaultReadLaneActivity,
+  hostStatusCalls: 0,
+  hostAbortCalls: 0,
+  evaluations: 0
+};
+async function abortLaneSessionForWatchdog(record) {
+  const session = _test_exports2.getSessionOps();
+  const abortOp = session?.abort;
+  if (!session || typeof abortOp !== "function" || !record.subagentSessionId) {
+    return false;
+  }
+  try {
+    await withTimeout(abortOp.call(session, { path: { id: record.subagentSessionId } }), _test_exports2.laneLivenessProbeTimeoutMs, new Error("lane-liveness watchdog abort exceeded its deadline"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function lastWatchdogEscalationsByLaneLabel(directory, sessionID) {
+  const escalations = new Map;
+  const activityObservations = new Map;
+  const deadlineLabels = new Set;
+  let text = "";
+  try {
+    text = readCoreEvents(directory).text;
+  } catch {
+    return { escalations, activityObservations, deadlineLabels };
+  }
+  for (const line of text.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || !trimmed.includes("pr_workflow_lane_watchdog"))
+      continue;
+    let event;
+    try {
+      event = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+    if (event.type !== "pr_workflow_lane_watchdog")
+      continue;
+    if (sessionID !== undefined && event.sessionID !== sessionID)
+      continue;
+    const isEscalation = event.escalated === true;
+    const isActivityObservation = !isEscalation && event.activityObserved === true;
+    const isDeadlineEvent = !isEscalation && !isActivityObservation && event.condition === "execution_deadline";
+    if (!isEscalation && !isActivityObservation && !isDeadlineEvent)
+      continue;
+    const timestamp = Date.parse(`${event.timestamp}`);
+    if (!Number.isFinite(timestamp))
+      continue;
+    const laneIds = event.laneIds;
+    if (!Array.isArray(laneIds))
+      continue;
+    const target = isEscalation ? escalations : activityObservations;
+    for (const label of laneIds) {
+      if (typeof label !== "string")
+        continue;
+      if (isDeadlineEvent) {
+        deadlineLabels.add(label);
+        continue;
+      }
+      const prior = target.get(label);
+      if (prior === undefined || timestamp > prior)
+        target.set(label, timestamp);
+    }
+  }
+  return { escalations, activityObservations, deadlineLabels };
+}
+function appendWatchdogActivityObservation(directory, sessionID, labels, horizon, condition) {
+  try {
+    appendCoreEventSync(directory, {
+      type: "pr_workflow_lane_watchdog",
+      timestamp: isoNow(),
+      sessionID,
+      condition,
+      laneIds: labels.slice(0, MAX_LANE_LIVENESS_DISCLOSED_IDS),
+      effectiveHorizonMs: horizon.horizonMs,
+      horizonSource: horizon.source,
+      escalated: false,
+      activityObserved: true,
+      disclosure: `${labels.length} lane(s) progressed (activity observed since the last escalation); stall escalation baseline reset`
+    });
+  } catch {}
+}
+async function evaluateLaneLivenessWatchdogEscalation(args) {
+  const { directory, sessionID, lanes, sessionTypes, watchdog, horizon } = args;
+  const candidates = lanes.filter((record) => {
+    if (!record.subagentSessionId)
+      return false;
+    const type = sessionTypes.get(record.subagentSessionId);
+    return type === "busy" || type === "retry";
+  });
+  if (candidates.length === 0)
+    return;
+  const lastEscalations = lastWatchdogEscalationsByLaneLabel(directory, sessionID);
+  const escalated = [];
+  const progressed = [];
+  let firstEscalatedSteps = 0;
+  let firstEscalatedTokens = 0;
+  for (const record of candidates) {
+    let activity = null;
+    try {
+      activity = await laneLivenessWatchdogSurface.readLaneActivity(directory, record.subagentSessionId);
+    } catch {
+      activity = null;
+    }
+    const steps = activity?.stepsObserved ?? 0;
+    const tokens = activity?.estimatedTokens ?? 0;
+    const progressing = steps >= watchdog.stall_min_steps || tokens >= watchdog.stall_token_threshold;
+    if (progressing) {
+      progressed.push(record);
+      continue;
+    }
+    const label = prWorkflowLaneLabel(record);
+    const lastEscalation = lastEscalations.escalations.get(label);
+    if (lastEscalation !== undefined) {
+      const lastActivity = activity?.lastActivityAtMs;
+      const activitySince = lastActivity !== undefined && lastActivity >= lastEscalation || (lastEscalations.activityObservations.get(label) ?? -Infinity) >= lastEscalation;
+      if (!activitySince)
+        continue;
+    }
+    if (escalated.length === 0) {
+      firstEscalatedSteps = steps;
+      firstEscalatedTokens = tokens;
+    }
+    escalated.push(record);
+  }
+  if (progressed.length > 0) {
+    const firstProgressed = progressed[0];
+    const firstProgressedType = firstProgressed.subagentSessionId ? sessionTypes.get(firstProgressed.subagentSessionId) : undefined;
+    appendWatchdogActivityObservation(directory, sessionID, progressed.map(prWorkflowLaneLabel), horizon, firstProgressedType === "retry" ? "provider_retry_in_flight" : "idle_failed_child");
+  }
+  if (escalated.length === 0)
+    return;
+  const first = escalated[0];
+  const condition = classifyLaneLivenessCondition({
+    sessionStatusType: first.subagentSessionId ? sessionTypes.get(first.subagentSessionId) : undefined,
+    recordStatus: first.status,
+    waitBudgetExpired: false,
+    exceededEffectiveHorizon: Date.now() - first.updatedAt > horizon.horizonMs
+  });
+  const laneLabels = escalated.map(prWorkflowLaneLabel);
+  const disclosure = `${laneLabels.length} lane(s) stalled (fewer than ${watchdog.stall_min_steps} steps ` + `and fewer than ~${watchdog.stall_token_threshold} estimated tokens in the last ` + `${watchdog.stall_threshold_ms}ms): inspect the lane transcript or abort via ` + `/swarm abort-pr-workflow (force): ${laneLabels.slice(0, MAX_LANE_LIVENESS_DISCLOSED_IDS).join(", ")}`;
+  try {
+    appendCoreEventSync(directory, {
+      type: "pr_workflow_lane_watchdog",
+      timestamp: isoNow(),
+      sessionID,
+      condition,
+      laneIds: laneLabels.slice(0, MAX_LANE_LIVENESS_DISCLOSED_IDS),
+      effectiveHorizonMs: horizon.horizonMs,
+      horizonSource: horizon.source,
+      escalated: true,
+      stall: {
+        stepsObserved: firstEscalatedSteps,
+        estimatedTokens: firstEscalatedTokens,
+        stallThresholdMs: watchdog.stall_threshold_ms,
+        stallMinSteps: watchdog.stall_min_steps,
+        stallTokenThreshold: watchdog.stall_token_threshold
+      },
+      disclosure
+    });
+  } catch {}
+}
+async function settlePresumedStalePrWorkflowLanes(directory, sessionID, options) {
+  const watchdog = options?.laneLivenessWatchdog;
+  const { deadlineActive, stallActive } = laneLivenessWatchdogFeatures(watchdog);
+  const watchdogWork = deadlineActive || stallActive;
+  const horizon = resolveEffectivePrLaneHorizonMs(watchdog, options?.backgroundPendingTimeoutMs);
+  const horizonConflictNote = horizon.conflictDisclosed ? horizon.source === "watchdog-timeout" ? `lane_liveness_watchdog.timeout_ms (${horizon.horizonMs}ms) governs the PR-lane settlement horizon; hooks.background_pending_timeout_minutes was also set and disagrees \u2014 it was not applied (one effective horizon)` : `PR-lane settlement uses the ${Math.round(horizon.horizonMs / 60000)}min reachability floor; hooks.background_pending_timeout_minutes disagrees with it and does not change this horizon` : undefined;
   const now = Date.now();
   const open4 = [];
   const presumedStale = [];
   for (const record of readDelegations(directory)) {
     if (!isOpenPrWorkflowLane(record, sessionID))
       continue;
-    if (now - record.updatedAt > PR_WORKFLOW_STALE_LANE_TIMEOUT_MS) {
+    if (now - record.updatedAt > horizon.horizonMs) {
       presumedStale.push(record);
     } else {
       open4.push(record);
     }
   }
+  if (watchdogWork && (open4.length > 0 || presumedStale.length > 0)) {
+    laneLivenessWatchdogSurface.evaluations += 1;
+  }
   if (presumedStale.length === 0) {
+    if (watchdogWork && stallActive && open4.length > 0) {
+      let statuses = new Map;
+      try {
+        const probe2 = await _test_exports2.probeLaneSessionStatusTypesAsync(directory, open4);
+        statuses = probe2.statuses;
+        if (!probe2.degradedReason)
+          laneLivenessWatchdogSurface.hostStatusCalls += 1;
+      } catch {}
+      if (statuses.size > 0) {
+        await evaluateLaneLivenessWatchdogEscalation({
+          directory,
+          sessionID,
+          lanes: open4,
+          sessionTypes: statuses,
+          watchdog,
+          horizon
+        });
+      }
+    }
     const freshOnlyLaneIds = open4.map(prWorkflowLaneLabel);
     return {
       openLaneIds: freshOnlyLaneIds,
       openLanes: open4.length,
       freshOpenLanes: open4.length,
-      presumedStaleLaneIds: []
+      presumedStaleLaneIds: [],
+      ...horizonConflictNote ? { horizonConflictNote } : {}
     };
   }
   let probe;
-  try {
-    probe = await _test_exports2.probeLaneLivenessAsync(directory, presumedStale);
-  } catch {
-    probe = { alive: new Set, degradedReason: "probe-error" };
+  let sessionTypes = new Map;
+  if (watchdogWork) {
+    try {
+      const typesProbe = await _test_exports2.probeLaneSessionStatusTypesAsync(directory, stallActive ? [...presumedStale, ...open4] : presumedStale);
+      sessionTypes = typesProbe.statuses;
+      if (!typesProbe.degradedReason) {
+        laneLivenessWatchdogSurface.hostStatusCalls += 1;
+      }
+      const alive = new Set;
+      for (const [sessionId, type] of typesProbe.statuses) {
+        if (isLiveSessionStatusType(type))
+          alive.add(sessionId);
+      }
+      probe = typesProbe.degradedReason ? {
+        alive: new Set,
+        degradedReason: typesProbe.degradedReason
+      } : { alive };
+    } catch {
+      probe = { alive: new Set, degradedReason: "probe-error" };
+    }
+  } else {
+    try {
+      probe = await _test_exports2.probeLaneLivenessAsync(directory, presumedStale);
+    } catch {
+      probe = { alive: new Set, degradedReason: "probe-error" };
+    }
   }
   const probeRetained = [];
   const settled = [];
+  const deadlineLanes = [];
   for (const record of presumedStale) {
-    if (record.subagentSessionId && probe.alive.has(record.subagentSessionId)) {
+    const type = record.subagentSessionId ? sessionTypes.get(record.subagentSessionId) : undefined;
+    if (deadlineActive && type !== "retry") {
+      deadlineLanes.push(record);
+      settled.push(record);
+    } else if (record.subagentSessionId && probe.alive.has(record.subagentSessionId)) {
       probeRetained.push(record);
+    } else if (deadlineActive) {
+      deadlineLanes.push(record);
+      settled.push(record);
     } else {
       settled.push(record);
     }
@@ -12742,19 +13013,60 @@ async function settlePresumedStalePrWorkflowLanes(directory, sessionID) {
     ...probe.degradedReason ? { probeDegradedReason: probe.degradedReason } : {}
   };
   if (settled.length === 0) {
+    if (watchdogWork && stallActive && probeRetained.length > 0) {
+      await evaluateLaneLivenessWatchdogEscalation({
+        directory,
+        sessionID,
+        lanes: probeRetained,
+        sessionTypes,
+        watchdog,
+        horizon
+      });
+    }
     return {
       openLaneIds,
       openLanes: openLaneIds.length,
       freshOpenLanes: open4.length,
       presumedStaleLaneIds: [],
+      ...horizonConflictNote ? { horizonConflictNote } : {},
       ...retentionFields,
       disclosure: retentionDisclosure
     };
   }
+  if (deadlineActive) {
+    const priorDeadlineLabels = lastWatchdogEscalationsByLaneLabel(directory, sessionID).deadlineLabels;
+    let abortAttempted = false;
+    for (const record of deadlineLanes) {
+      const type = record.subagentSessionId ? sessionTypes.get(record.subagentSessionId) : undefined;
+      if (type !== "busy" || !record.subagentSessionId)
+        continue;
+      if (priorDeadlineLabels.has(prWorkflowLaneLabel(record)))
+        continue;
+      abortAttempted = true;
+      const aborted = await abortLaneSessionForWatchdog(record);
+      if (aborted)
+        laneLivenessWatchdogSurface.hostAbortCalls += 1;
+    }
+    if (deadlineLanes.length > 0) {
+      try {
+        appendCoreEventSync(directory, {
+          type: "pr_workflow_lane_watchdog",
+          timestamp: isoNow(),
+          sessionID,
+          condition: "execution_deadline",
+          laneIds: deadlineLanes.map(prWorkflowLaneLabel).slice(0, MAX_LANE_LIVENESS_DISCLOSED_IDS),
+          effectiveHorizonMs: horizon.horizonMs,
+          horizonSource: horizon.source,
+          escalated: false,
+          disclosure: `${deadlineLanes.length} lane(s) exceeded the ${horizon.horizonMs}ms execution ` + `deadline (${horizon.source}); ` + (abortAttempted ? "sessions aborted best-effort and settled " : "no session abort was attempted (the liveness probe could not confirm these sessions were running); lanes settled ") + `through the shared path with the real outcome: no output observed (no ` + `transcript activity recorded for these lanes)`
+        });
+      } catch {}
+    }
+  }
   const presumedStaleLaneIds = settled.map(prWorkflowLaneLabel);
-  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(", ")}` + (probe.degradedReason ? `; settled despite liveness probe failure (${probe.degradedReason})` : "; liveness probe found no live session") + (retentionDisclosure ? `; ${retentionDisclosure}` : "");
+  const disclosure = `${presumedStaleLaneIds.length} lane(s) stale >` + `${Math.round(horizon.horizonMs / 60000)}min, ` + `treated as settled: ${presumedStaleLaneIds.slice(0, MAX_DISCLOSED_LANE_IDS).join(", ")}` + (probe.degradedReason ? `; settled despite liveness probe failure (${probe.degradedReason})` : "; liveness probe found no live session") + (retentionDisclosure ? `; ${retentionDisclosure}` : "");
   try {
-    await _test_exports2.sweepStaleDelegationsAsync(directory, PR_WORKFLOW_STALE_LANE_TIMEOUT_MS, {
+    await _test_exports2.sweepStaleDelegationsAsync(directory, horizon.horizonMs, {
       statuses: PR_WORKFLOW_SWEEPABLE_LANE_STATUSES,
       excludeCorrelationIds: new Set(probeRetained.map((record) => record.correlationId))
     });
@@ -12765,24 +13077,38 @@ async function settlePresumedStalePrWorkflowLanes(directory, sessionID) {
       timestamp: isoNow(),
       sessionID,
       presumedStaleLanes: presumedStaleLaneIds.slice(0, MAX_DISCLOSED_LANE_IDS),
-      staleTimeoutMs: PR_WORKFLOW_STALE_LANE_TIMEOUT_MS,
+      staleTimeoutMs: horizon.horizonMs,
       probeStatus: probe.degradedReason ?? "ok",
       probedAliveLanes: probedAliveLaneIds.slice(0, MAX_DISCLOSED_LANE_IDS),
       disclosure
     });
   } catch {}
+  if (watchdogWork && stallActive && !(deadlineActive && deadlineLanes.length > 0)) {
+    const stallCandidates = [...open4, ...probeRetained];
+    if (stallCandidates.length > 0 && sessionTypes.size > 0) {
+      await evaluateLaneLivenessWatchdogEscalation({
+        directory,
+        sessionID,
+        lanes: stallCandidates,
+        sessionTypes,
+        watchdog,
+        horizon
+      });
+    } else if (stallCandidates.length > 0) {}
+  }
   return {
     openLaneIds,
     openLanes: openLaneIds.length,
     freshOpenLanes: open4.length,
     presumedStaleLaneIds,
+    ...horizonConflictNote ? { horizonConflictNote } : {},
     ...retentionFields,
     disclosure
   };
 }
-async function finalizeOverriddenProbeRetainedLanes(directory, sessionID, correlationIds) {
+async function finalizeOverriddenProbeRetainedLanes(directory, sessionID, correlationIds, horizonMs = PR_WORKFLOW_STALE_LANE_TIMEOUT_MS) {
   try {
-    await _test_exports2.sweepStaleDelegationsAsync(directory, PR_WORKFLOW_STALE_LANE_TIMEOUT_MS, {
+    await _test_exports2.sweepStaleDelegationsAsync(directory, horizonMs, {
       statuses: PR_WORKFLOW_SWEEPABLE_LANE_STATUSES,
       includeCorrelationIds: new Set(correlationIds)
     });
@@ -12853,7 +13179,7 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
   if ((state.prFeedbackReadyToPublish || recovery.armedShapeUnreadable) && !options.cancelPublication) {
     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, or use the audited cancellation (abort_pr_workflow with cancel_publication and a reason).` + (recovery.armedShapeUnreadable ? " The publication-arming record is itself unreadable, so it is treated as armed (fail-closed)." : ""));
   }
-  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
+  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID, options.laneLiveness);
   const probeRetainedLanes = laneSettlement.probedAliveLaneIds ?? [];
   const overridesProbeRetention = options.kind === "force" && laneSettlement.freshOpenLanes === 0 && probeRetainedLanes.length > 0;
   if (laneSettlement.openLanes > 0 && !overridesProbeRetention) {
@@ -12920,7 +13246,7 @@ async function abortPrWorkflow(directory, sessionID, options = { kind: "recovery
     } catch {}
     throw error2;
   }
-  const overrideOutcome = overridesProbeRetention ? await finalizeOverriddenProbeRetainedLanes(directory, state.sessionID, overrideTargetedLaneIds) : {
+  const overrideOutcome = overridesProbeRetention ? await finalizeOverriddenProbeRetainedLanes(directory, state.sessionID, overrideTargetedLaneIds, resolveEffectivePrLaneHorizonMs(options.laneLiveness?.laneLivenessWatchdog, options.laneLiveness?.backgroundPendingTimeoutMs).horizonMs) : {
     sessionOpenLaneIds: [],
     finalizedLaneIds: [],
     sparedLaneDescriptions: []
@@ -12981,7 +13307,7 @@ async function recoverArmedPrWorkflow(directory, sessionID, request) {
     if (request.workflowInstanceId !== undefined && state.workflowInstanceId !== undefined && request.workflowInstanceId !== state.workflowInstanceId) {
       throw new Error(`BLOCKED: armed recovery workflow identity mismatch: active workflow is "${state.workflowInstanceId}", request declared "${request.workflowInstanceId}".`);
     }
-    const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
+    const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID, request.laneLiveness);
     if (laneSettlement.openLanes > 0) {
       const laneIds = laneSettlement.openLaneIds.filter(Boolean).slice(0, MAX_DISCLOSED_LANE_IDS).join(", ");
       throw new Error(`BLOCKED: armed recovery refused while ${laneSettlement.openLanes} PR workflow lane(s) are still in flight (lane ids: ${laneIds}). Collect their results or let them settle before recovering.` + describePrWorkflowLaneProbe(laneSettlement));
@@ -16284,10 +16610,10 @@ function assertSamePrFeedbackHandoff(state, relativePath, read, requestedPrUrl)
     throw new Error(`BLOCKED: session "${state.sessionID}" is already active in PR_FEEDBACK for a different handoff or PR`);
   }
 }
-async function assertPrReviewTerminalReady(directory, sessionID) {
+async function assertPrReviewTerminalReady(directory, sessionID, laneLiveness) {
   const state = await requireBoundState2(directory, sessionID, "PR_REVIEW");
   await assertPrReviewCleanCheckout(directory, "PR_REVIEW");
-  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
+  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID, laneLiveness);
   if (laneSettlement.openLanes > 0) {
     throw new Error(`BLOCKED: PR_REVIEW transition has ${laneSettlement.openLanes} unsettled PR workflow lane(s)` + describePrWorkflowLaneProbe(laneSettlement));
   }
@@ -16351,7 +16677,7 @@ async function transitionPrReviewToFeedback(directory, sessionID, request) {
     if (preliminary.mode !== "PR_REVIEW") {
       throw wrongModeError(preliminary, "PR_REVIEW");
     }
-    const ready = (await assertPrReviewTerminalReady(directory, normalizedSessionID)).state;
+    const ready = (await assertPrReviewTerminalReady(directory, normalizedSessionID, request.laneLiveness)).state;
     if (workflowIdentity(ready) !== workflowIdentity(preliminary) || ready.revision !== preliminary.revision || ready.mode !== "PR_REVIEW" || ready.prReviewHandoffPath !== normalizedHandoff.relativePath || ready.prReviewArtifactRunId !== request.runId || !ready.prHeadSha || ready.prHeadSha.toLowerCase() !== artifact.pr_head_sha.toLowerCase() || canonicalGitHubPrUrl(artifact.pr_url) !== canonicalGitHubPrUrl(request.prUrl ?? artifact.pr_url)) {
       throw new Error("BLOCKED: PR_REVIEW feedback handoff does not match the terminal active review state");
     }
@@ -16758,7 +17084,7 @@ async function completePrWorkflow(directory, sessionID, expectedMode, prHeadSha,
   if (state.prHeadSha !== normalizedHead) {
     throw new Error(`BLOCKED: cannot complete ${expectedMode} at PR head "${normalizedHead}"; workflow is bound to "${state.prHeadSha}"`);
   }
-  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID);
+  const laneSettlement = await settlePresumedStalePrWorkflowLanes(directory, state.sessionID, options?.laneLiveness);
   if (laneSettlement.openLanes > 0) {
     throw new Error(`BLOCKED: ${expectedMode} completion has ${laneSettlement.openLanes} unsettled PR workflow lane(s)` + describePrWorkflowLaneProbe(laneSettlement));
   }
@@ -16798,7 +17124,7 @@ async function completePrWorkflow(directory, sessionID, expectedMode, prHeadSha,
       if (!preAllowed.includes(verdict)) {
         throw new Error(`BLOCKED: PR_REVIEW ${settlement.kind} completion allows report_verdict ${preAllowed.join(" | ")}; got "${verdict}". Partial coverage never approves and never claims a full review.`);
       }
-      const ready = await assertPrReviewTerminalReady(directory, sessionID);
+      const ready = await assertPrReviewTerminalReady(directory, sessionID, options?.laneLiveness);
       const readyState = ready.state;
       if (workflowIdentity(readyState) !== workflowIdentity(state) || readyState.revision !== state.revision) {
         throw new Error("BLOCKED: PR_REVIEW state changed while checking terminal readiness; retry from current state");
@@ -17024,6 +17350,11 @@ var _test_exports2 = {
     _test_exports2.classifyPrWorkflowGitStateAsync = classifyPrWorkflowGitState;
     _test_exports2.sweepStaleDelegationsAsync = sweepStaleDelegations;
     _test_exports2.probeLaneLivenessAsync = probeAlivePrWorkflowLaneSessions;
+    _test_exports2.probeLaneSessionStatusTypesAsync = probePrWorkflowLaneSessionStatusTypes;
+    laneLivenessWatchdogSurface.hostStatusCalls = 0;
+    laneLivenessWatchdogSurface.hostAbortCalls = 0;
+    laneLivenessWatchdogSurface.evaluations = 0;
+    laneLivenessWatchdogSurface.readLaneActivity = defaultReadLaneActivity;
     _test_exports2.getSessionOps = defaultGetSessionOps;
     _test_exports2.laneLivenessProbeTimeoutMs = PR_WORKFLOW_LANE_LIVENESS_PROBE_TIMEOUT_MS;
     _test_exports2.pendingLaneLivenessThresholdMs = PR_WORKFLOW_PENDING_LIVENESS_THRESHOLD_MS;
@@ -17048,6 +17379,8 @@ var _test_exports2 = {
   classifyPrWorkflowGitStateAsync: classifyPrWorkflowGitState,
   sweepStaleDelegationsAsync: sweepStaleDelegations,
   probeLaneLivenessAsync: probeAlivePrWorkflowLaneSessions,
+  probeLaneSessionStatusTypesAsync: probePrWorkflowLaneSessionStatusTypes,
+  laneLivenessWatchdog: laneLivenessWatchdogSurface,
   getSessionOps: defaultGetSessionOps,
   laneLivenessProbeTimeoutMs: PR_WORKFLOW_LANE_LIVENESS_PROBE_TIMEOUT_MS,
   pendingLaneLivenessThresholdMs: PR_WORKFLOW_PENDING_LIVENESS_THRESHOLD_MS,
@@ -19136,6 +19469,7 @@ init_tool_metadata();
 init_logger();
 
 // src/commands/registry.ts
+init_loader();
 init_logger();
 
 // src/commands/abort-pr-workflow.ts
@@ -26291,7 +26625,7 @@ function planMerges(active, threshold, maxComparisons, maxMerges) {
   };
 }
 async function sweepActiveNearDuplicates(directory, options = {}) {
-  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gsftf6c8.js");
+  const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hdkt3n2k.js");
   const { config } = loadPluginConfigWithMeta2(directory);
   const sweepConfig = config.learning?.dedup_sweep;
   if (sweepConfig?.enabled === false)
@@ -27415,7 +27749,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-c0720k51.js");
+        const skillModule = await import("./skill-generator-yqgwds3s.js");
         for (const cand of skillCandidates) {
           if (cand.confidence < (config.min_skill_confidence ?? DEFAULT_SKILL_MIN_CONFIDENCE)) {
             continue;
@@ -27887,7 +28221,7 @@ async function applyCuratorKnowledgeUpdates(directory, recommendations, knowledg
     } catch {}
   }
   if (contradictedEntries.length > 0 && knowledgeConfig.contradiction_threshold_action === "quarantine") {
-    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-w4bfnks3.js");
+    const { maybeQuarantineOnContradiction } = await import("./knowledge-escalator-skbk8tq8.js");
     for (const { id } of contradictedEntries) {
       try {
         await maybeQuarantineOnContradiction(directory, id, knowledgeConfig.contradiction_quarantine_threshold, knowledgeConfig.contradiction_quarantine_window_days);
@@ -28719,7 +29053,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings.push("Failed to collect knowledge summary.");
     }
     try {
-      const { getScanStatus } = await import("./scan-cursor-efrage98.js");
+      const { getScanStatus } = await import("./scan-cursor-ag6y6c14.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.`);
@@ -28891,9 +29225,9 @@ var _internals27 = {
   verifyPostMortemKnowledgeActions,
   repairPostMortemActions,
   loadDefaultKnowledgeConfig: async (directory) => {
-    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-w2sds948.js");
+    const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-qmh504jp.js");
     try {
-      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gsftf6c8.js");
+      const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hdkt3n2k.js");
       const loaded = loadPluginConfigWithMeta2(directory);
       return KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
     } catch {
@@ -28901,11 +29235,11 @@ var _internals27 = {
     }
   },
   applyCuratorKnowledgeUpdates: async (directory, recommendations, knowledgeConfig, generation) => {
-    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-qk4xmkv4.js");
+    const { applyCuratorKnowledgeUpdates: applyCuratorKnowledgeUpdates2 } = await import("./curator-pd098ytk.js");
     return applyCuratorKnowledgeUpdates2(directory, recommendations, knowledgeConfig, generation);
   },
   checkHivePromotions: async (entries, knowledgeConfig, directory) => {
-    const { checkHivePromotions } = await import("./hive-promoter-9zzr28p2.js");
+    const { checkHivePromotions } = await import("./hive-promoter-j2pjzrdh.js");
     return checkHivePromotions(entries, knowledgeConfig, directory);
   },
   applyProposalTriage: async (directory, triage) => {
@@ -28914,7 +29248,7 @@ var _internals27 = {
       activateProposal,
       listSkills: listSkills2,
       sanitizeSlug
-    } = await import("./skill-generator-c0720k51.js");
+    } = await import("./skill-generator-yqgwds3s.js");
     const result = {
       approved: [],
       rejected: [],
@@ -30322,9 +30656,9 @@ function hashContent(content) {
   return createHash18("sha1").update(content).digest("hex");
 }
 async function loadConfigForPolicyCurator(directory) {
-  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-w2sds948.js");
+  const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-qmh504jp.js");
   try {
-    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gsftf6c8.js");
+    const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hdkt3n2k.js");
     const { config: loadedConfig } = loadPluginConfigWithMeta2(directory);
     return KnowledgeConfigSchema2.parse(loadedConfig.knowledge ?? {});
   } catch {
@@ -31807,7 +32141,7 @@ function serializeAgentSession(s) {
 }
 async function writeSnapshot(directory, state) {
   try {
-    const { ensureSnapshotCoordinationReady } = await import("./snapshot-coordination-init-dp42vvme.js");
+    const { ensureSnapshotCoordinationReady } = await import("./snapshot-coordination-init-62pxgka1.js");
     await ensureSnapshotCoordinationReady(directory);
     const snapshot = {
       version: 3,
@@ -45316,7 +45650,7 @@ async function runFinalizeStage(ctx) {
     }
   }
   try {
-    const { CuratorConfigSchema: CCS } = await import("./schema-w2sds948.js");
+    const { CuratorConfigSchema: CCS } = await import("./schema-qmh504jp.js");
     const { config: pmLoadedConfig } = _internals44.loadPluginConfigWithMeta(ctx.directory);
     const curatorCfg = CCS.parse(pmLoadedConfig.curator ?? {});
     if (curatorCfg.enabled && curatorCfg.postmortem_enabled) {
@@ -47604,9 +47938,9 @@ var _internals48 = {
   loadPluginConfigWithMeta,
   loadCuratorDeps: async () => {
     const [{ CuratorConfigSchema }, curator, { createCuratorLLMDelegate: createCuratorLLMDelegate2 }] = await Promise.all([
-      import("./schema-w2sds948.js"),
-      import("./curator-qk4xmkv4.js"),
-      import("./curator-llm-factory-rs4921ks.js")
+      import("./schema-qmh504jp.js"),
+      import("./curator-pd098ytk.js"),
+      import("./curator-llm-factory-vj5aqyd1.js")
     ]);
     return { CuratorConfigSchema, curator, createCuratorLLMDelegate: createCuratorLLMDelegate2 };
   }
@@ -48657,7 +48991,7 @@ async function computeCurationDiagnostics(directory, entries2) {
   let scanCompleted = false;
   let scanRemaining = 0;
   try {
-    const { getScanStatus } = await import("./scan-cursor-efrage98.js");
+    const { getScanStatus } = await import("./scan-cursor-ag6y6c14.js");
     const status = await getScanStatus(directory);
     scanGeneration = status.generation;
     scanCompleted = status.completed;
@@ -48667,10 +49001,10 @@ async function computeCurationDiagnostics(directory, entries2) {
   try {
     const { isLinked: isLinked2 } = await import("./knowledge-link-w1fwqts4.js");
     if (isLinked2(directory)) {
-      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-w2sds948.js");
+      const { KnowledgeConfigSchema: KnowledgeConfigSchema2 } = await import("./schema-qmh504jp.js");
       let config;
       try {
-        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-gsftf6c8.js");
+        const { loadPluginConfigWithMeta: loadPluginConfigWithMeta2 } = await import("./index-hdkt3n2k.js");
         const loaded = loadPluginConfigWithMeta2(directory);
         config = KnowledgeConfigSchema2.parse(loaded.config.knowledge ?? {});
       } catch {
@@ -50068,7 +50402,7 @@ async function handleDoctorCommand(directory, args) {
   const result = runConfigDoctor(config, directory);
   let output;
   if (enableAutoFix && result.hasAutoFixableIssues) {
-    const { runConfigDoctorWithFixes } = await import("./config-doctor-8asc35km.js");
+    const { runConfigDoctorWithFixes } = await import("./config-doctor-35pd2khv.js");
     const fixResult = await runConfigDoctorWithFixes(directory, config, true, {
       applyLossy: true
     });
@@ -51022,7 +51356,7 @@ async function handleEvidenceCommand(directory, args) {
   return formatTaskEvidenceMarkdown(evidenceData);
 }
 async function handleEvidenceSummaryCommand(directory) {
-  const { buildEvidenceSummary } = await import("./evidence-summary-service-rktcp3s4.js");
+  const { buildEvidenceSummary } = await import("./evidence-summary-service-kwcme5fz.js");
   const artifact = await buildEvidenceSummary(directory);
   if (!artifact) {
     return "No plan found. Run `/swarm plan` to check plan status.";
@@ -89583,7 +89917,7 @@ function buildDetailedHelp(commandName, entry) {
 async function handleHelpCommand(ctx) {
   const targetCommand = ctx.args.join(" ");
   if (!targetCommand) {
-    const { buildHelpText } = await import("./index-x8c42y8s.js");
+    const { buildHelpText } = await import("./index-zs0nyasy.js");
     return buildHelpText();
   }
   const tokens = targetCommand.split(/\s+/);
@@ -89597,7 +89931,7 @@ async function handleHelpCommand(ctx) {
 > Note: \`/swarm ${resolved.key}\` is a deprecated alias for \`/swarm ${aliasTarget}\`.` : detailed;
   }
   const similar = _internals105.findSimilarCommands(targetCommand);
-  const { buildHelpText: fullHelp } = await import("./index-x8c42y8s.js");
+  const { buildHelpText: fullHelp } = await import("./index-zs0nyasy.js");
   if (similar.length > 0) {
     return `Command '/swarm ${targetCommand}' not found.
 
@@ -89642,12 +89976,22 @@ async function handlePrFeedbackCommandWithTransition(ctx) {
   }
   if (parsed.continuation) {
     const exactCommand = parsed.prUrl ? `/swarm pr-feedback ${parsed.prUrl} continue from ${parsed.continuation.handoffPath}` : `/swarm pr-feedback continue from ${parsed.continuation.handoffPath}`;
+    let laneLiveness;
+    try {
+      const config = loadPluginConfig(ctx.directory);
+      const hooks2 = config.hooks;
+      laneLiveness = {
+        laneLivenessWatchdog: config.lane_liveness_watchdog,
+        backgroundPendingTimeoutMs: hooks2?.background_pending_timeout_minutes !== undefined ? hooks2.background_pending_timeout_minutes * 60000 : undefined
+      };
+    } catch {}
     await transitionPrReviewToFeedback(ctx.directory, ctx.sessionID, {
       runId: parsed.continuation.runId,
       handoffPath: parsed.continuation.handoffPath,
       prUrl: parsed.prUrl,
       exactCommand,
-      confirmedByUser: true
+      confirmedByUser: true,
+      ...laneLiveness ? { laneLiveness } : {}
     });
   } else {
     await activatePrWorkflow(ctx.directory, ctx.sessionID, "PR_FEEDBACK", {
@@ -89902,7 +90246,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail explain": {
     handler: async (ctx) => {
-      const { handleGuardrailExplain } = await import("./guardrail-explain-jdspxzjr.js");
+      const { handleGuardrailExplain } = await import("./guardrail-explain-2h9m8s4j.js");
       return handleGuardrailExplain(ctx.directory, ctx.args);
     },
     description: "Dry-run: show what the guardrails would do to a command or write target (executes nothing)",
@@ -89912,7 +90256,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail reset": {
     handler: async (ctx) => {
-      const { handleGuardrailReset } = await import("./guardrail-reset-dv02t0bm.js");
+      const { handleGuardrailReset } = await import("./guardrail-reset-v6ds2t78.js");
       return handleGuardrailReset(ctx.args, ctx.sessionID);
     },
     description: "Reset one exact active invocation/action circuit after repair",
@@ -89933,7 +90277,7 @@ var COMMAND_REGISTRY = {
   },
   "guardrail-log": {
     handler: async (ctx) => {
-      const { handleGuardrailLog } = await import("./guardrail-log-962pzjev.js");
+      const { handleGuardrailLog } = await import("./guardrail-log-p6trrsvy.js");
       return handleGuardrailLog(ctx.directory, ctx.args);
     },
     description: "Read the guardrail decision log (use --blocks-only for blocks)",
@@ -95979,7 +96323,7 @@ function getDisplayFinalPromptPressure() {
 async function rehydratePrSubscriptions(sessionID, directory) {
   const map = new Map;
   try {
-    const { listActive: listActive2 } = await import("./pr-subscriptions-yqxt0avv.js");
+    const { listActive: listActive2 } = await import("./pr-subscriptions-rdp58505.js");
     const records = await listActive2(directory);
     for (const record of records) {
       if (record.sessionID !== sessionID)
@@ -96425,7 +96769,7 @@ function isLaneOwnedByCurrentSession(branchName, expectedSessionId) {
   return extracted === expectedSessionId;
 }
 async function inspectStandardWorktreeCollisionOwnership(identity) {
-  const collisionOwnership = await import("./worktree-collision-ownership-emh2yhpx.js");
+  const collisionOwnership = await import("./worktree-collision-ownership-81773mwf.js");
   return collisionOwnership.inspectStandardWorktreeCollisionOwnership(identity);
 }
 async function runRecoveryGit(directory, args, timeoutMs = 15000) {
@@ -96838,7 +97182,7 @@ async function precreateStandardWorktreeSession(args) {
   const laneProfile = computeLaneRuntimeProfile(worktreeConfig.runtime_isolation, laneIndex, handle.worktreePath);
   if (laneProfile) {
     try {
-      const { writeLaneProfileToDiskReal } = await import("./core-qrbhs2q4.js");
+      const { writeLaneProfileToDiskReal } = await import("./core-92m54spz.js");
       await writeLaneProfileToDiskReal(handle.worktreePath, laneProfile.laneIndex, laneProfile.envOverrides);
     } catch {}
   }
@@ -97772,7 +98116,7 @@ async function finishStandardWorktreeDispatch(directory, dispatch, config, callI
       }
       clearWorktreeMergeStatus(statusKey);
       try {
-        const { removeLaneProfileFromDiskReal } = await import("./core-qrbhs2q4.js");
+        const { removeLaneProfileFromDiskReal } = await import("./core-92m54spz.js");
         await removeLaneProfileFromDiskReal(dispatch.handle.worktreePath, dispatch.laneIndex);
       } catch {}
       const state = serializationStateBySessionID.get(dispatch.parentSessionID);