opencode-swarm 7.159.3 → 7.160.0

package/dist/cli/index-e75bzfgd.js

@@ -0,0 +1,785 @@
+// @bun
+import {
+  atomicWriteSwarmFile
+} from "./index-p39xem8b.js";
+import {
+  pseudonymousRef,
+  resolveLineageSalt,
+  telemetry
+} from "./index-dke4wzkn.js";
+
+// src/health/learning-health.ts
+import { promises as fs } from "fs";
+import path from "path";
+var HEALTH_SOURCES_TABLE = {
+  context_budget: {
+    producer: "src/hooks/context-budget.ts:199",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["headroom_dead_streak"]
+  },
+  model_limits: {
+    producer: "src/hooks/model-limits.ts:333",
+    readers: [
+      "src/tools/context-status.ts",
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["model_limit_fallback"]
+  },
+  knowledge_receipts: {
+    producer: "src/hooks/knowledge-receipt-ledger.ts:2219",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["retrieval_outcome_liveness"]
+  },
+  curator_compliance: {
+    producer: "src/hooks/curator.ts:1906",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["role_participation"]
+  },
+  promotion_evidence: {
+    producer: "src/hooks/promotion-evidence-store.ts:94",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["promoted_fixture_share"]
+  },
+  close_archive: {
+    producer: "src/commands/close.ts:754",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["archive_activity_mismatch"]
+  },
+  delegation_ledger: {
+    producer: "src/background/delegation-health.ts:581",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["recovery_ledger_pressure"]
+  },
+  store_health_events: {
+    producer: "src/events/core-events.ts:1616 (direct observeStoreHealth; one per audited store)",
+    readers: [
+      "src/services/status-service.ts",
+      "src/services/diagnose-service.ts"
+    ],
+    alarms: ["compaction_drop_coverage"]
+  }
+};
+var HEALTH_SOURCES = Object.freeze(HEALTH_SOURCES_TABLE);
+var LEARNING_HEALTH_ALARM_CONFIG = Object.freeze({
+  headroom_dead_streak: Object.freeze({
+    windowMs: 600000,
+    raiseFacts: 3,
+    cooldownMs: 1800000,
+    severity: "warning"
+  }),
+  model_limit_fallback: Object.freeze({
+    windowMs: 1800000,
+    cooldownMs: 3600000,
+    severity: "warning"
+  }),
+  retrieval_outcome_liveness: Object.freeze({
+    windowMs: 1800000,
+    cooldownMs: 900000,
+    severity: "warning",
+    gap2StalenessMs: 600000
+  }),
+  role_participation: Object.freeze({
+    windowMs: 86400000,
+    raiseFacts: 2,
+    cooldownMs: 43200000,
+    severity: "warning"
+  }),
+  promoted_fixture_share: Object.freeze({
+    windowMs: 604800000,
+    raiseShare: 0.5,
+    clearShare: 0.3,
+    minEvidence: 4,
+    cooldownMs: 86400000,
+    severity: "warning"
+  }),
+  archive_activity_mismatch: Object.freeze({
+    windowMs: 0,
+    cooldownMs: 86400000,
+    severity: "warning"
+  }),
+  recovery_ledger_pressure: Object.freeze({
+    windowMs: 900000,
+    raisePct: 0.8,
+    clearPct: 0.7,
+    cooldownMs: 1800000,
+    severity: "warning"
+  }),
+  compaction_drop_coverage: Object.freeze({
+    windowMs: 3600000,
+    corruptRaise: 1,
+    droppedRaise: 100,
+    cooldownMs: 3600000,
+    severity: "warning"
+  })
+});
+var FIELD_RECEIPT_SOURCES = new Set([
+  "delegate",
+  "reviewer",
+  "architect",
+  "architect_marker",
+  "test_engineer"
+]);
+var NON_FIELD_RECEIPT_SOURCES = new Set([
+  "phase_override",
+  "manual",
+  "migration",
+  "application_gate_staleness_release",
+  "application_gate_denial_limit_release",
+  "application_gate_session_reset_release",
+  "unknown"
+]);
+var MAX_HEALTH_SCOPES = 64;
+var MAX_FACTS_PER_SCOPE = 64;
+var MAX_LIVENESS_GAPS = 64;
+var MAX_TRANSITION_RING = 100;
+var PERSIST_DEBOUNCE_MS = 5000;
+var CLOCK_SKEW_TOLERANCE_MS = 300000;
+var ARTIFACT_FILENAME = "learning-health.json";
+var ARTIFACT_SCHEMA_VERSION = 1;
+var STORE_HEALTH_KINDS = new Set([
+  "context_telemetry_health",
+  "skill_usage_health",
+  "core_events_health",
+  "shell_audit_health",
+  "trajectory_health",
+  "pr_subscription_health"
+]);
+var STORE_LABEL_BY_KIND = Object.freeze({
+  context_telemetry_health: "context_telemetry",
+  skill_usage_health: "skill_usage",
+  core_events_health: "core_events",
+  shell_audit_health: "shell_audit",
+  trajectory_health: "trajectory",
+  pr_subscription_health: "pr_subscription"
+});
+var alarmScopes = new Map;
+var livenessGaps = new Map;
+var transitionRing = [];
+var lastPersistAtByDirectory = new Map;
+var recentPersistDirectories = [];
+var MAX_TRACKED_DIRECTORIES = 16;
+function rememberPersistDirectory(directory) {
+  if (recentPersistDirectories.includes(directory)) {
+    const idx = recentPersistDirectories.indexOf(directory);
+    recentPersistDirectories.splice(idx, 1);
+  }
+  recentPersistDirectories.push(directory);
+  while (recentPersistDirectories.length > MAX_TRACKED_DIRECTORIES) {
+    const evicted = recentPersistDirectories.shift();
+    if (evicted !== undefined)
+      lastPersistAtByDirectory.delete(evicted);
+  }
+}
+var _internals = {
+  now: () => Date.now(),
+  emitTelemetry: (payload) => {
+    telemetry.learningHealthAlarm(payload);
+  },
+  writeArtifact: (directory, contents) => atomicWriteSwarmFile(path.join(directory, ".swarm", ARTIFACT_FILENAME), contents),
+  readArtifact: async (directory) => {
+    try {
+      return await fs.readFile(path.join(directory, ".swarm", ARTIFACT_FILENAME), "utf-8");
+    } catch {
+      return null;
+    }
+  }
+};
+var projectRefCache = new Map;
+function projectRef(directory) {
+  const cached = projectRefCache.get(directory);
+  if (cached !== undefined)
+    return cached;
+  const ref = pseudonymousRef(directory, resolveLineageSalt());
+  if (!projectRefCache.has(directory)) {
+    while (projectRefCache.size >= MAX_TRACKED_DIRECTORIES) {
+      const oldest = projectRefCache.keys().next().value;
+      if (oldest === undefined)
+        break;
+      projectRefCache.delete(oldest);
+    }
+  }
+  projectRefCache.set(directory, ref);
+  return ref;
+}
+function getScopeMap(alarm) {
+  let map = alarmScopes.get(alarm);
+  if (!map) {
+    map = new Map;
+    alarmScopes.set(alarm, map);
+  }
+  return map;
+}
+function ensureScope(alarm, scopeKey, now) {
+  const map = getScopeMap(alarm);
+  let scope = map.get(scopeKey);
+  if (scope)
+    return scope;
+  while (map.size >= MAX_HEALTH_SCOPES) {
+    const oldest = map.keys().next().value;
+    if (oldest === undefined)
+      break;
+    if (oldest === scopeKey)
+      break;
+    map.delete(oldest);
+  }
+  scope = {
+    status: "idle",
+    severity: LEARNING_HEALTH_ALARM_CONFIG[alarm].severity,
+    windowStartMs: now,
+    factCount: 0,
+    lastFactAtMs: 0,
+    raisedAtMs: 0,
+    lastEmitAtMs: 0,
+    transitionCount: 0,
+    facts: []
+  };
+  map.set(scopeKey, scope);
+  return scope;
+}
+function appendFact(scope, kind, atMs, windowMs) {
+  const duplicate = scope.facts.some((f) => f.kind === kind && f.atMs === atMs);
+  if (!duplicate) {
+    scope.facts.push({ atMs, kind });
+    while (scope.facts.length > MAX_FACTS_PER_SCOPE)
+      scope.facts.shift();
+  }
+  const skewAdjusted = Math.min(atMs, _internals.now() + CLOCK_SKEW_TOLERANCE_MS);
+  scope.lastFactAtMs = Math.max(scope.lastFactAtMs, skewAdjusted);
+  if (skewAdjusted - scope.windowStartMs > windowMs) {
+    const edge = skewAdjusted - windowMs;
+    scope.facts = scope.facts.filter((f) => f.atMs >= edge);
+    scope.windowStartMs = edge;
+  }
+  scope.factCount = scope.facts.length;
+}
+function countFacts(scope, kind) {
+  let n = 0;
+  for (const fact of scope.facts)
+    if (fact.kind === kind)
+      n += 1;
+  return n;
+}
+var DETAIL_PAYLOAD_KEYS = Object.freeze({
+  sessionRef: "session_ref",
+  limitSource: "limit_source",
+  denominatorFallback: "denominator_fallback",
+  pressurePct: "pressure_pct",
+  sharePct: "share_pct",
+  fieldCount: "field_count",
+  nonFieldCount: "non_field_count",
+  gapType: "gap_type"
+});
+function emitTransition(alarm, scopeClass, scopeKey, transition, severity, detail, scope, now) {
+  scope.lastEmitAtMs = now;
+  scope.transitionCount += 1;
+  const payload = {
+    alarm,
+    transition,
+    severity,
+    scope_class: scopeClass,
+    window_ms: LEARNING_HEALTH_ALARM_CONFIG[alarm].windowMs,
+    coverage_facts: scope.factCount,
+    raise_facts: scope.raisedAtMs > 0 ? countRaiseFacts(alarm, scope) : 0,
+    age_ms: scope.raisedAtMs > 0 ? Math.max(0, now - scope.raisedAtMs) : 0
+  };
+  if (scopeClass === "session") {
+    payload.session_ref = scopeKey.split("/").pop();
+  }
+  for (const [key, value] of Object.entries(detail)) {
+    if (value === undefined)
+      continue;
+    const payloadKey = DETAIL_PAYLOAD_KEYS[key] ?? key;
+    payload[payloadKey] = value;
+  }
+  transitionRing.push({
+    alarm,
+    transition,
+    severity,
+    atMs: now,
+    coverageFacts: scope.factCount
+  });
+  while (transitionRing.length > MAX_TRANSITION_RING)
+    transitionRing.shift();
+  _internals.emitTelemetry(payload);
+}
+function countRaiseFacts(alarm, scope) {
+  switch (alarm) {
+    case "headroom_dead_streak":
+      return countFacts(scope, "dead");
+    case "role_participation":
+      return countFacts(scope, "gap");
+    case "promoted_fixture_share":
+      return countFacts(scope, "non_field");
+    case "compaction_drop_coverage":
+      return countFacts(scope, "corrupt") + countFacts(scope, "dropped");
+    default:
+      return scope.factCount;
+  }
+}
+function applyAlarmState(alarm, scopeClass, scopeKey, desired, severity, detail, directory, now) {
+  if (directory)
+    rememberPersistDirectory(directory);
+  const scope = ensureScope(alarm, scopeKey, now);
+  const config = LEARNING_HEALTH_ALARM_CONFIG[alarm];
+  if (desired === "active") {
+    scope.severity = severity;
+    if (scope.status === "idle") {
+      scope.status = "active";
+      scope.raisedAtMs = now;
+      emitTransition(alarm, scopeClass, scopeKey, "raised", severity, detail, scope, now);
+      schedulePersist(directory, now, true);
+    } else if (now - scope.lastEmitAtMs >= config.cooldownMs) {
+      emitTransition(alarm, scopeClass, scopeKey, "sustained", severity, detail, scope, now);
+      schedulePersist(directory, now, true);
+    }
+    return;
+  }
+  if (scope.status === "active") {
+    scope.status = "idle";
+    scope.severity = LEARNING_HEALTH_ALARM_CONFIG[alarm].severity;
+    emitTransition(alarm, scopeClass, scopeKey, "recovered", severity, detail, scope, now);
+    schedulePersist(directory, now, true);
+  }
+}
+function schedulePersist(directory, now, force) {
+  const target = directory ?? recentPersistDirectories.at(-1);
+  if (!target)
+    return;
+  const last = lastPersistAtByDirectory.get(target) ?? 0;
+  if (!force && now - last < PERSIST_DEBOUNCE_MS)
+    return;
+  lastPersistAtByDirectory.set(target, now);
+  persistLearningHealth(target).catch(() => {
+    return;
+  });
+}
+async function persistLearningHealth(directory) {
+  const artifact = {
+    schemaVersion: ARTIFACT_SCHEMA_VERSION,
+    updatedAtMs: _internals.now(),
+    alarms: {},
+    transitions: [...transitionRing]
+  };
+  for (const [alarm, scopes] of alarmScopes) {
+    if (scopes.size === 0)
+      continue;
+    const serialized = {};
+    for (const [key, scope] of scopes) {
+      serialized[key] = {
+        status: scope.status,
+        severity: scope.severity,
+        windowStartMs: scope.windowStartMs,
+        factCount: scope.factCount,
+        lastFactAtMs: scope.lastFactAtMs,
+        raisedAtMs: scope.raisedAtMs,
+        transitionCount: scope.transitionCount
+      };
+    }
+    artifact.alarms[alarm] = { scopes: serialized };
+  }
+  try {
+    await _internals.writeArtifact(directory, `${JSON.stringify(artifact)}
+`);
+  } catch {}
+}
+async function rehydrateFromArtifact(directory) {
+  const raw = await _internals.readArtifact(directory);
+  if (!raw)
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (parsed.schemaVersion !== ARTIFACT_SCHEMA_VERSION)
+    return;
+  const now = _internals.now();
+  if (transitionRing.length === 0 && Array.isArray(parsed.transitions)) {
+    for (const tr of parsed.transitions) {
+      if (!tr || typeof tr.alarm !== "string" || !Object.hasOwn(LEARNING_HEALTH_ALARM_CONFIG, tr.alarm) || typeof tr.atMs !== "number" || !Number.isFinite(tr.atMs)) {
+        continue;
+      }
+      transitionRing.push({
+        alarm: tr.alarm,
+        transition: tr.transition === "raised" || tr.transition === "sustained" || tr.transition === "recovered" ? tr.transition : "raised",
+        severity: tr.severity === "critical" ? "critical" : "warning",
+        atMs: tr.atMs,
+        coverageFacts: typeof tr.coverageFacts === "number" && Number.isFinite(tr.coverageFacts) ? tr.coverageFacts : 0
+      });
+    }
+    while (transitionRing.length > MAX_TRANSITION_RING)
+      transitionRing.shift();
+  }
+  for (const [alarm, section] of Object.entries(parsed.alarms ?? {})) {
+    if (!Object.hasOwn(LEARNING_HEALTH_ALARM_CONFIG, alarm))
+      continue;
+    if (!section?.scopes)
+      continue;
+    const map = getScopeMap(alarm);
+    for (const [key, persisted] of Object.entries(section.scopes)) {
+      if (map.has(key))
+        continue;
+      if (!isAdoptableScopeKey(key))
+        continue;
+      if (!persisted || persisted.status !== "idle" && persisted.status !== "active" || persisted.severity !== "warning" && persisted.severity !== "critical" || !isFiniteCounter(persisted.windowStartMs) || !isFiniteCounter(persisted.factCount) || !isFiniteCounter(persisted.lastFactAtMs) || !isFiniteCounter(persisted.raisedAtMs) || !isFiniteCounter(persisted.transitionCount)) {
+        continue;
+      }
+      map.set(key, {
+        status: persisted.status,
+        severity: persisted.severity,
+        windowStartMs: persisted.windowStartMs,
+        factCount: persisted.factCount,
+        lastFactAtMs: persisted.lastFactAtMs,
+        raisedAtMs: persisted.raisedAtMs,
+        lastEmitAtMs: now,
+        transitionCount: persisted.transitionCount,
+        facts: []
+      });
+    }
+  }
+}
+function isAdoptableScopeKey(key) {
+  if (typeof key !== "string" || key.length === 0 || key.length > 200) {
+    return false;
+  }
+  return /^[0-9a-zA-Z:_.-/]+$/.test(key);
+}
+function isFiniteCounter(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function livenessMap(directory) {
+  let map = livenessGaps.get(directory);
+  if (!map) {
+    if (livenessGaps.size >= MAX_TRACKED_DIRECTORIES) {
+      let victim;
+      let victimSize = Number.POSITIVE_INFINITY;
+      for (const [dir, entry] of livenessGaps) {
+        if (entry.size < victimSize) {
+          victim = dir;
+          victimSize = entry.size;
+        }
+      }
+      if (victim !== undefined)
+        livenessGaps.delete(victim);
+    }
+    map = new Map;
+    livenessGaps.set(directory, map);
+  }
+  return map;
+}
+function evaluateLiveness(directory, now) {
+  const config = LEARNING_HEALTH_ALARM_CONFIG.retrieval_outcome_liveness;
+  const gaps = livenessMap(directory);
+  const ageOutAt = config.windowMs * 4;
+  for (const [key, gap] of gaps) {
+    if (now - gap.openedAtMs > ageOutAt)
+      gaps.delete(key);
+  }
+  const scopeKey = `${projectRef(directory)}/liveness`;
+  const _scope = ensureScope("retrieval_outcome_liveness", scopeKey, now);
+  let stalled = 0;
+  let oldestAgeMs = 0;
+  let stalledType;
+  for (const gap of gaps.values()) {
+    if (gap.eligibleAtMs > now)
+      continue;
+    const age = now - gap.openedAtMs;
+    if (age > config.windowMs) {
+      stalled += 1;
+      if (age > oldestAgeMs) {
+        oldestAgeMs = age;
+        stalledType = gap.gapType;
+      }
+    }
+  }
+  if (stalled > 0) {
+    applyAlarmState("retrieval_outcome_liveness", "project", scopeKey, "active", config.severity, { reason: "gap_open", gapType: stalledType }, directory, now);
+  } else if (stalled === 0 && _scope.status === "active") {
+    applyAlarmState("retrieval_outcome_liveness", "project", scopeKey, "idle", config.severity, {}, directory, now);
+  }
+}
+function observeReceiptTransition(input) {
+  try {
+    ensureLearningHealth();
+    const now = input.atMs ?? _internals.now();
+    const config = LEARNING_HEALTH_ALARM_CONFIG.retrieval_outcome_liveness;
+    const gaps = livenessMap(input.directory);
+    const gapKey1 = `m:${input.traceId}`;
+    const gapKey2 = `a:${input.traceId}`;
+    switch (input.kind) {
+      case "membership_committed": {
+        const existing = gaps.get(gapKey1);
+        if (!existing) {
+          while (gaps.size >= MAX_LIVENESS_GAPS) {
+            const oldest = gaps.keys().next().value;
+            if (oldest === undefined)
+              break;
+            gaps.delete(oldest);
+          }
+          gaps.set(gapKey1, {
+            gapType: "membership_to_terminal",
+            openedAtMs: now,
+            eligibleAtMs: now
+          });
+        }
+        break;
+      }
+      case "legacy_imported":
+        break;
+      case "terminal_committed": {
+        gaps.delete(gapKey1);
+        if (input.receiptOutcome === "applied") {
+          const committedAt = input.membershipCommittedAtMs ?? now;
+          const existing = gaps.get(gapKey2);
+          if (!existing) {
+            while (gaps.size >= MAX_LIVENESS_GAPS) {
+              const oldest = gaps.keys().next().value;
+              if (oldest === undefined)
+                break;
+              gaps.delete(oldest);
+            }
+            gaps.set(gapKey2, {
+              gapType: "terminal_to_application",
+              openedAtMs: now,
+              eligibleAtMs: Math.max(now, committedAt + config.gap2StalenessMs)
+            });
+          }
+        } else {
+          gaps.delete(gapKey2);
+        }
+        break;
+      }
+      case "application_marker_committed": {
+        if (input.receiptSource === "architect_marker") {
+          gaps.delete(gapKey2);
+        }
+        break;
+      }
+      case "gate_release_committed":
+      case "phase_closed":
+      case "authorized_transition_committed": {
+        gaps.delete(gapKey1);
+        gaps.delete(gapKey2);
+        break;
+      }
+      default:
+        break;
+    }
+    evaluateLiveness(input.directory, now);
+  } catch {}
+}
+var PARTICIPATION_GAP_TYPES = new Set([
+  "missing_reviewer",
+  "missing_retro",
+  "missing_sme"
+]);
+var EXPECTED_ROLES_BY_GAP_TYPE = Object.freeze({
+  missing_reviewer: Object.freeze(["reviewer"]),
+  missing_sme: Object.freeze(["sme"]),
+  missing_retro: Object.freeze(["reviewer", "architect"])
+});
+function normalizeParticipationAgent(agent) {
+  const stripped = agent.includes("_") ? agent.split("_").pop() ?? agent : agent;
+  return stripped.trim().toLowerCase();
+}
+function observeCuratorCompliance(input) {
+  try {
+    ensureLearningHealth();
+    const now = _internals.now();
+    const scopeKey = `${projectRef(input.directory)}/participation`;
+    const scope = ensureScope("role_participation", scopeKey, now);
+    const config = LEARNING_HEALTH_ALARM_CONFIG.role_participation;
+    for (const type of input.gapTypes) {
+      if (!PARTICIPATION_GAP_TYPES.has(type))
+        continue;
+      appendFact(scope, `gap:${type}`, now, config.windowMs);
+    }
+    for (const agent of input.agentsUsed) {
+      appendFact(scope, `participated:${normalizeParticipationAgent(agent)}`, now, config.windowMs);
+    }
+    const gapFacts = scope.facts.filter((f) => f.kind.startsWith("gap:"));
+    let lastGapAtMs = 0;
+    const openTypes = new Set;
+    for (const fact of scope.facts) {
+      if (fact.kind.startsWith("gap:")) {
+        lastGapAtMs = Math.max(lastGapAtMs, fact.atMs);
+        openTypes.add(fact.kind.slice("gap:".length));
+      }
+    }
+    const matchingLateParticipation = scope.facts.some((fact) => {
+      if (!fact.kind.startsWith("participated:"))
+        return false;
+      if (fact.atMs < lastGapAtMs)
+        return false;
+      const agent = fact.kind.slice("participated:".length);
+      for (const type of openTypes) {
+        const expected = EXPECTED_ROLES_BY_GAP_TYPE[type];
+        if (expected?.includes(agent))
+          return true;
+      }
+      return false;
+    });
+    if (gapFacts.length >= config.raiseFacts && !matchingLateParticipation) {
+      applyAlarmState("role_participation", "project", scopeKey, "active", config.severity, { reason: "eligible_role_gap", phase: input.phase }, input.directory, now);
+    } else if (matchingLateParticipation) {
+      applyAlarmState("role_participation", "project", scopeKey, "idle", config.severity, {}, input.directory, now);
+    }
+  } catch {}
+}
+function observeCloseArchive(input) {
+  try {
+    ensureLearningHealth();
+    const now = _internals.now();
+    const scopeKey = `${projectRef(input.directory)}/archive`;
+    const scope = ensureScope("archive_activity_mismatch", scopeKey, now);
+    const config = LEARNING_HEALTH_ALARM_CONFIG.archive_activity_mismatch;
+    const mismatch = (!input.archiveValid || input.archiveEmpty) && input.activityPredictsContent;
+    appendFact(scope, mismatch ? "mismatch" : "ok", now, config.windowMs || 1);
+    const detail = {
+      reason: mismatch ? input.archiveEmpty ? "archive_empty_with_activity" : "archive_invalid_with_activity" : undefined
+    };
+    if (mismatch) {
+      applyAlarmState("archive_activity_mismatch", "project", scopeKey, "active", config.severity, detail, input.directory, now);
+    } else {
+      applyAlarmState("archive_activity_mismatch", "project", scopeKey, "idle", config.severity, {}, input.directory, now);
+    }
+  } catch {}
+}
+function observeDelegationLedgerPressure(input) {
+  try {
+    ensureLearningHealth();
+    const now = _internals.now();
+    const scopeKey = `${projectRef(input.directory)}/ledger`;
+    const scope = ensureScope("recovery_ledger_pressure", scopeKey, now);
+    const config = LEARNING_HEALTH_ALARM_CONFIG.recovery_ledger_pressure;
+    const badBand = input.band === "compact-overdue" || input.band === "fail-closed";
+    const high = badBand || input.pressurePct >= config.raisePct;
+    const low = !badBand && input.pressurePct < config.clearPct && !input.uncertain;
+    appendFact(scope, high ? "high" : "ok", now, config.windowMs);
+    const detail = {
+      pressurePct: Math.round(input.pressurePct * 100),
+      band: input.band,
+      reason: input.uncertain ? "recovery_observation_uncertain" : undefined
+    };
+    if (high) {
+      applyAlarmState("recovery_ledger_pressure", "project", scopeKey, "active", config.severity, detail, input.directory, now);
+    } else if (low) {
+      applyAlarmState("recovery_ledger_pressure", "project", scopeKey, "idle", config.severity, detail, input.directory, now);
+    }
+  } catch {}
+}
+function observeStoreHealth(input) {
+  try {
+    observeStoreHealthEvent(input.kind, input.payload, input.directory);
+  } catch {}
+}
+function observeStoreHealthEvent(event, data, directory) {
+  ensureLearningHealth();
+  if (!STORE_HEALTH_KINDS.has(event))
+    return;
+  const store = STORE_LABEL_BY_KIND[event];
+  if (!store)
+    return;
+  const corrupt = Math.max(toCount(data.corrupt_count), toCount(data.corrupt));
+  const dropped = Math.max(toCount(data.dropped_count), toCount(data.dropped), toCount(data.dropped_audit_count));
+  const retained = toCount(data.retained_count);
+  const accepted = Math.max(toCount(data.accepted_count), toCount(data.accepted));
+  const now = _internals.now();
+  const scopeKey = directory ? `${projectRef(directory)}/store/${store}` : `store/${store}`;
+  const scope = ensureScope("compaction_drop_coverage", scopeKey, now);
+  const config = LEARNING_HEALTH_ALARM_CONFIG.compaction_drop_coverage;
+  if (corrupt > 0) {
+    appendFact(scope, "corrupt", now, config.windowMs);
+  } else if (dropped >= config.droppedRaise) {
+    appendFact(scope, "dropped", now, config.windowMs);
+  } else {
+    appendFact(scope, "clean", now, config.windowMs);
+  }
+  const corruptFacts = countFacts(scope, "corrupt");
+  const droppedFacts = countFacts(scope, "dropped");
+  const cleanFacts = countFacts(scope, "clean");
+  const detail = {
+    store,
+    dropped,
+    corrupt,
+    retained,
+    accepted
+  };
+  if (corruptFacts >= config.corruptRaise || droppedFacts > 0) {
+    applyAlarmState("compaction_drop_coverage", "project", scopeKey, "active", droppedFacts > 0 ? "critical" : "warning", detail, directory, now);
+  } else if (cleanFacts > 0 && corruptFacts === 0 && droppedFacts === 0) {
+    applyAlarmState("compaction_drop_coverage", "project", scopeKey, "idle", "warning", detail, directory, now);
+  }
+}
+function toCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function ensureLearningHealth() {}
+async function readLearningHealth(directory) {
+  ensureLearningHealth();
+  try {
+    await rehydrateFromArtifact(directory);
+    const now = _internals.now();
+    evaluateLiveness(directory, now);
+    const scopeOwner = projectRef(directory);
+    const active = [];
+    for (const [alarm, scopes] of alarmScopes) {
+      for (const [key, scope] of scopes) {
+        if (scope.status !== "active")
+          continue;
+        const owned = key.startsWith(`${scopeOwner}/`) || key.startsWith("u/") || key.startsWith("store/");
+        if (!owned)
+          continue;
+        active.push({
+          alarm,
+          severity: scope.severity,
+          scopeClass: scopeClassFor(alarm),
+          scopeRef: key.split("/").pop() ?? key,
+          ageMs: scope.raisedAtMs > 0 ? Math.max(0, now - scope.raisedAtMs) : 0,
+          coverageFacts: scope.factCount,
+          transitionCount: scope.transitionCount
+        });
+      }
+    }
+    schedulePersist(directory, now, false);
+    return {
+      activeAlarms: active,
+      totalTransitions: transitionRing.length,
+      updatedAtMs: now
+    };
+  } catch {
+    return { activeAlarms: [], totalTransitions: 0, updatedAtMs: 0 };
+  }
+}
+function scopeClassFor(alarm) {
+  switch (alarm) {
+    case "headroom_dead_streak":
+      return "session";
+    case "model_limit_fallback":
+      return "identity";
+    default:
+      return "project";
+  }
+}
+
+export { observeReceiptTransition, observeCuratorCompliance, observeCloseArchive, observeDelegationLedgerPressure, observeStoreHealth, readLearningHealth };