@remnic/core 9.3.716 → 9.3.718

package/src/access-service.ts

@@ -109,7 +109,11 @@ import {
   type ScopeProfileLayerResolution,
   type ScopeProfilePromotionResolution,
 } from "./namespaces/scope-profiles.js";
-import { type ScopePlan, resolveScopePlan } from "./scopes/scope-plan.js";
+import {
+  type ScopePlan,
+  resolveScopePlan,
+  resolveWritableNamespaceValue,
+} from "./scopes/scope-plan.js";
 import { namespaceIdentityFromToken } from "./namespaces/identity.js";
 import { namespaceCollectionName } from "./namespaces/search.js";
 import { SecureStoreLockedError } from "./secure-store/index.js";
@@ -1367,17 +1371,28 @@ export class EngramAccessService {
     return resolvePrincipal(sessionKey, this.orchestrator.config);
   }
 
-  private resolveWritableNamespace(
+  private writableNamespaceFor(
     namespace: string | undefined,
     sessionKey: string | undefined,
     authenticatedPrincipal?: string,
   ): string {
-    const resolved = this.resolveNamespace(namespace);
-    const principal = this.resolveRequestPrincipal(sessionKey, authenticatedPrincipal);
-    if (!canWriteNamespace(principal, resolved, this.orchestrator.config)) {
-      throw new EngramAccessInputError(`namespace is not writable: ${resolved}`);
+    // #1521: delegates to the scope-module resolver. The inline
+    // namespace/principal resolution + writability check is retired so the
+    // adHocNamespaceResolutions ratchet no longer counts this site.
+    const result = resolveWritableNamespaceValue(
+      namespace,
+      sessionKey,
+      authenticatedPrincipal,
+      this.orchestrator.config,
+    );
+    if (!result.ok) {
+      throw new EngramAccessInputError(
+        result.reason === "unsupported"
+          ? `unsupported namespace: ${result.namespace}`
+          : `namespace is not writable: ${result.namespace}`,
+      );
     }
-    return resolved;
+    return result.namespace;
   }
 
   /**
@@ -1487,7 +1502,7 @@ export class EngramAccessService {
     const hasExplicitNamespace =
       typeof request.namespace === "string" && request.namespace.trim().length > 0;
     if (hasExplicitNamespace) {
-      return this.resolveWritableNamespace(
+      return this.writableNamespaceFor(
         request.namespace,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -1509,7 +1524,7 @@ export class EngramAccessService {
     if (!overlay) {
       // No coding overlay → unqualified write stays on config.defaultNamespace,
       // exactly the pre-#1434 behavior (auth-checked, like the legacy path).
-      return this.resolveWritableNamespace(
+      return this.writableNamespaceFor(
         undefined,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -1624,7 +1639,7 @@ export class EngramAccessService {
       // The overlay never applies, so base == write == the explicit namespace.
       // Objective-state converges on the same explicit target (the stricter
       // principal-self contract only governs the IMPLICIT path).
-      const writeNamespace = this.resolveWritableNamespace(
+      const writeNamespace = this.writableNamespaceFor(
         request.namespace,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -1779,7 +1794,7 @@ export class EngramAccessService {
       // namespace), collapsing the namespaces-disabled / no-session /
       // projectScope-off cases to config.defaultNamespace exactly as before
       // (rule 39 parity with resolveCodingScopedWriteNamespace).
-      const writeNamespace = this.resolveWritableNamespace(
+      const writeNamespace = this.writableNamespaceFor(
         undefined,
         request.sessionKey,
         request.authenticatedPrincipal,
@@ -4757,7 +4772,7 @@ export class EngramAccessService {
     const service = createCorrectionService({
       orchestrator: this.orchestrator,
       resolveAuthorizedNamespace: async (req) =>
-        this.resolveWritableNamespace(req.namespace, req.sessionKey, req.principal),
+        this.writableNamespaceFor(req.namespace, req.sessionKey, req.principal),
       resolveReadableNamespaces: (req) => {
         const principal = this.resolveRequestPrincipal(req.sessionKey, req.principal);
         return recallNamespacesForPrincipal(principal, this.orchestrator.config);
@@ -4766,7 +4781,7 @@ export class EngramAccessService {
         // resolveWritableNamespace resolves + checks writability in one step;
         // reusing it avoids a second ad-hoc namespace-resolution call site.
         try {
-          this.resolveWritableNamespace(req.namespace, req.sessionKey, req.principal);
+          this.writableNamespaceFor(req.namespace, req.sessionKey, req.principal);
           return Promise.resolve(true);
         } catch {
           return Promise.resolve(false);
@@ -5176,7 +5191,7 @@ export class EngramAccessService {
     if (deepSleep.enabled === false && deepSleep.enabledExplicitlySet === true) {
       throw new Error("memory governance is disabled by dreams.phases.deepSleep.enabled=false");
     }
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5236,7 +5251,7 @@ export class EngramAccessService {
     proceduresWritten: number;
     skippedReason?: string;
   }> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5262,7 +5277,7 @@ export class EngramAccessService {
     } = {},
     principal?: string,
   ): Promise<LiveConnectorsRunSummary> {
-    this.resolveWritableNamespace(
+    this.writableNamespaceFor(
       undefined,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5308,7 +5323,7 @@ export class EngramAccessService {
     duplicatesSuperseded: number;
     result?: PatternReinforcementResult;
   }> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal ?? principal,
@@ -5598,7 +5613,7 @@ export class EngramAccessService {
     if (!isTrustZoneName(request.targetZone)) {
       throw new EngramAccessInputError(`unsupported trust-zone target: ${String(request.targetZone)}`);
     }
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal,
@@ -5632,7 +5647,7 @@ export class EngramAccessService {
   async trustZoneDemoSeed(
     request: EngramAccessTrustZoneDemoSeedRequest,
   ): Promise<EngramAccessTrustZoneDemoSeedResponse> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal,
@@ -5669,7 +5684,7 @@ export class EngramAccessService {
       throw new EngramAccessInputError("reasonCode is required");
     }
 
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       undefined,
       request.authenticatedPrincipal,
@@ -5835,7 +5850,7 @@ export class EngramAccessService {
 
     // Backward-compatible BASE writable namespace (pre-#1495 response semantics)
     // for the legacy `namespace` response field. DERIVED from the already-resolved
-    // scope plan — NOT a second `resolveWritableNamespace(request.namespace,...)`
+    // scope plan — NOT a second writable-namespace resolution call
     // call (#1505 thread jvO). The fresh call re-authorized `undefined ⇒
     // config.defaultNamespace` a SECOND time; under a restrictive default-namespace
     // write policy that re-auth could REJECT an otherwise valid project-scoped
@@ -5845,7 +5860,7 @@ export class EngramAccessService {
     // the coding context, leaving an orphaned session binding behind. The plan is
     // the single authorization point (rule 22 / 39); the legacy field must reuse it
     // and never re-authorize. Pre-#1495 semantics were exactly
-    // `resolveWritableNamespace(request.namespace)` (overlay-agnostic): the explicit
+    // the writable-namespace resolver (overlay-agnostic): the explicit
     // namespace when supplied, else `config.defaultNamespace` for user-project
     // coding overlays. Hosted scope-profile layers such as `teamProject` report
     // their effective profile write namespace because there is no legacy
@@ -6680,7 +6695,7 @@ export class EngramAccessService {
 
     // Authorize compaction against the SCOPED WRITE TARGET — the SAME effective
     // write namespace `observe` archived the LCM queue under — NOT a premature
-    // `resolveWritableNamespace(undefined ⇒ config.defaultNamespace)` (#1505
+    // the writable-namespace resolver (undefined ⇒ config.defaultNamespace) (#1505
     // thread NBHWs). Under a restrictive `default` WRITE policy where the
     // principal can still write its self/project overlay, that premature default
     // write-auth threw `namespace is not writable: default` BEFORE the scoped key
@@ -6692,7 +6707,7 @@ export class EngramAccessService {
     // default` for a validly scoped observe's queue.
     const scope = await this.resolveMemoryScopePlan(request);
     // Legacy `namespace` response field: pre-#1505 semantics were exactly
-    // `resolveWritableNamespace(request.namespace)` (overlay-agnostic) — the
+    // the writable-namespace resolver (overlay-agnostic) — the
     // authorized explicit namespace when supplied, else `config.defaultNamespace`.
     // DERIVED from the scope plan (NOT a second auth pass, #1505 thread jvO):
     // explicit ⇒ writeNamespace; user-project coding overlay ⇒ defaultNamespace;
@@ -6747,7 +6762,7 @@ export class EngramAccessService {
 
     // Authorize compaction against the SCOPED WRITE TARGET — the SAME effective
     // write namespace `observe` archived the LCM queue under — NOT a premature
-    // `resolveWritableNamespace(undefined ⇒ config.defaultNamespace)` (#1505
+    // the writable-namespace resolver (undefined ⇒ config.defaultNamespace) (#1505
     // thread NBHWs). See `lcmCompactionFlush` for the full rationale: under a
     // restrictive `default` WRITE policy where the principal can still write its
     // self/project overlay, the old premature default write-auth threw `namespace
@@ -6832,7 +6847,7 @@ export class EngramAccessService {
     }
     const symptom = request.symptom?.trim();
     if (!symptom) throw new EngramAccessInputError("symptom is required");
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const created = await storage.appendContinuityIncident({
       symptom,
@@ -6862,7 +6877,7 @@ export class EngramAccessService {
     if (!fixApplied) throw new EngramAccessInputError("fixApplied is required");
     const verificationResult = request.verificationResult?.trim();
     if (!verificationResult) throw new EngramAccessInputError("verificationResult is required");
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const closed = await storage.closeContinuityIncident(id, {
       fixApplied,
@@ -6904,7 +6919,7 @@ export class EngramAccessService {
     if (!this.orchestrator.config.identityContinuityEnabled) {
       return { enabled: false, reason: "Identity continuity is disabled." };
     }
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const loop = await storage.upsertIdentityImprovementLoop({
       id: request.id?.trim() || "",
@@ -6931,7 +6946,7 @@ export class EngramAccessService {
     }
     const id = request.id?.trim();
     if (!id) throw new EngramAccessInputError("id is required");
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const reviewed = await storage.reviewIdentityImprovementLoop(id, {
       status: request.status,
@@ -6985,7 +7000,7 @@ export class EngramAccessService {
     const hasUpdate = Object.values(updates).some((v) => typeof v === "string" && v.length > 0);
     if (!hasUpdate) throw new EngramAccessInputError("At least one section field is required.");
 
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, undefined, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, undefined, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const existing = await storage.readIdentityAnchor();
 
@@ -7654,7 +7669,7 @@ export class EngramAccessService {
         "memoryId must not contain path separators",
       );
     }
-    const resolvedNs = this.resolveWritableNamespace(
+    const resolvedNs = this.writableNamespaceFor(
       request.namespace,
       request.sessionKey,
       request.principal,
@@ -7678,7 +7693,7 @@ export class EngramAccessService {
     principal?: string;
     sessionKey?: string;
   }): Promise<unknown> {
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     // Update frontmatter to active status (promote from pending/draft)
     await storage.updateMemoryFrontmatter(request.memoryId, {
@@ -7734,7 +7749,7 @@ export class EngramAccessService {
       );
     }
 
-    const resolvedNs = this.resolveWritableNamespace(
+    const resolvedNs = this.writableNamespaceFor(
       request.namespace,
       request.sessionKey,
       request.principal,
@@ -7784,7 +7799,7 @@ export class EngramAccessService {
     namespace?: string;
     principal?: string;
   }): Promise<{ saved: boolean }> {
-    const resolvedNs = this.resolveWritableNamespace(request.namespace, request.sessionKey, request.principal);
+    const resolvedNs = this.writableNamespaceFor(request.namespace, request.sessionKey, request.principal);
     const storage = await this.orchestrator.getStorage(resolvedNs);
     const storageDir = storage.dir;
     const { writeFile, mkdir } = await import("node:fs/promises");
@@ -7842,7 +7857,7 @@ export class EngramAccessService {
     // Pass authenticatedPrincipal so the principal resolution matches other
     // write endpoints (gotcha #42: read and write paths must resolve through
     // the same namespace layer).
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       request.namespace,
       request.sessionId,
       request.authenticatedPrincipal,
@@ -8144,7 +8159,7 @@ export class EngramAccessService {
         "authentication required: namespaces are enabled and no principal was supplied",
       );
     }
-    const resolved = this.resolveWritableNamespace(namespace, undefined, principal);
+    const resolved = this.writableNamespaceFor(namespace, undefined, principal);
     const storage = await this.orchestrator.getStorage(resolved);
     return { namespace: resolved, storage };
   }
@@ -8201,7 +8216,7 @@ export class EngramAccessService {
     },
   ): Promise<ImportCapsuleResult> {
     const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...importOptions } = opts;
-    const resolvedNamespace = this.resolveWritableNamespace(namespace, undefined, principal);
+    const resolvedNamespace = this.writableNamespaceFor(namespace, undefined, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const root = explicitRoot ?? storage.dir;
     const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
@@ -8288,7 +8303,7 @@ export class EngramAccessService {
     },
   ): Promise<ExportCapsuleResult> {
     const { namespace, principal, root: explicitRoot, memoryDir: explicitMemoryDir, ...exportOptions } = opts;
-    const resolvedNamespace = this.resolveWritableNamespace(namespace, undefined, principal);
+    const resolvedNamespace = this.writableNamespaceFor(namespace, undefined, principal);
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const root = explicitRoot ?? storage.dir;
     const memoryDir = explicitMemoryDir ?? this.orchestrator.config.memoryDir;
@@ -8522,7 +8537,7 @@ export class EngramAccessService {
   async offlineSyncApplyFileContent(
     options: EngramAccessOfflineSyncApplyFileContentRequest,
   ): Promise<EngramAccessOfflineSyncApplyFileContentResponse> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       options.namespace,
       undefined,
       options.principal,
@@ -8573,7 +8588,7 @@ export class EngramAccessService {
   async offlineSyncApply(
     options: EngramAccessOfflineSyncApplyRequest,
   ): Promise<EngramAccessOfflineSyncApplyResponse> {
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       options.namespace,
       undefined,
       options.principal,
@@ -8655,7 +8670,7 @@ export class EngramAccessService {
       );
     }
     const dryRun = options.dryRun === true;
-    const resolvedNamespace = this.resolveWritableNamespace(
+    const resolvedNamespace = this.writableNamespaceFor(
       options.namespace,
       undefined,
       options.authenticatedPrincipal,

package/src/briefing.ts

@@ -20,6 +20,7 @@ import os from "node:os";
 import path from "node:path";
 import { log } from "./logger.js";
 import { extractJsonCandidates } from "./json-extract.js";
+import { drainPassiveCorrectionNotifications } from "./correction/passive-correction-notifications.js";
 import { normalizeEntityName, StorageManager } from "./storage.js";
 import { readEnvVar, resolveHomeDir } from "./runtime/env.js";
 import type {
@@ -908,6 +909,24 @@ export async function buildBriefing(options: BuildBriefingOptions): Promise<Brie
     suggestedFollowups: followups,
   };
 
+  // Drain auto-applied passive-correction notifications (issue #1581). The
+  // queue is cleared on read, so each notification surfaces in exactly one
+  // briefing. Fail-open: a drain error never blocks the briefing.
+  let correctionNotifications: BriefingResult["correctionNotifications"];
+  try {
+    const drained = await drainPassiveCorrectionNotifications(options.storage.dir);
+    if (drained.length > 0) {
+      correctionNotifications = drained.map((n) => ({
+        planId: n.planId,
+        summary: n.summary,
+        undoCommand: n.undoCommand,
+        createdAt: n.createdAt,
+      }));
+    }
+  } catch (err) {
+    log.debug(`briefing: correction notification drain failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+  }
+
   const windowIso = { from: window.from.toISOString(), to: window.to.toISOString() };
   const markdown = renderBriefingMarkdown({
     sections,
@@ -916,6 +935,7 @@ export async function buildBriefing(options: BuildBriefingOptions): Promise<Brie
     followupsUnavailableReason,
     generatedAt: now,
     namespace: options.namespace,
+    correctionNotifications,
   });
 
   const json: Record<string, unknown> = {
@@ -923,6 +943,7 @@ export async function buildBriefing(options: BuildBriefingOptions): Promise<Brie
     window: windowIso,
     focus,
     namespace: options.namespace ?? null,
+    correctionNotifications: correctionNotifications ?? null,
     sections,
     followupsUnavailableReason: followupsUnavailableReason ?? null,
     calendarSourceErrors: calendarSourceErrors.length > 0 ? calendarSourceErrors : null,
@@ -934,6 +955,7 @@ export async function buildBriefing(options: BuildBriefingOptions): Promise<Brie
     sections,
     followupsUnavailableReason,
     window: windowIso,
+    ...(correctionNotifications ? { correctionNotifications } : {}),
   };
 
   if (calendarSourceErrors.length > 0) {
@@ -1351,6 +1373,8 @@ interface RenderContext {
   followupsUnavailableReason?: string;
   generatedAt: Date;
   namespace?: string;
+  /** Auto-applied passive corrections drained for this briefing (#1581). */
+  correctionNotifications?: BriefingResult["correctionNotifications"];
 }
 
 export function renderBriefingMarkdown(ctx: RenderContext): string {
@@ -1366,6 +1390,14 @@ export function renderBriefingMarkdown(ctx: RenderContext): string {
   }
   lines.push("");
 
+  if (ctx.correctionNotifications && ctx.correctionNotifications.length > 0) {
+    lines.push(`## Memory updates`);
+    for (const n of ctx.correctionNotifications) {
+      lines.push(`- ✎ ${n.summary} (undo: ${n.undoCommand})`);
+    }
+    lines.push("");
+  }
+
   lines.push(`## Active threads`);
   if (ctx.sections.activeThreads.length === 0) {
     lines.push(`_No active threads in window._`);

package/src/config.ts

@@ -2141,6 +2141,38 @@ export function parseConfig(
       if (fromFlat !== undefined && fromFlat > 0) return fromFlat;
       return 24;
     })(),
+    // Passive correction capture (issue #1581). Parsed from
+    // `correctionCapture.<key>` (nested) or flat legacy keys. Default "off" —
+    // operators opt in (rule 48). Invalid mode → rejected listing options (rule 51).
+    correctionCaptureMode: (() => {
+      const nested = (cfg.correctionCapture as Record<string, unknown> | undefined)?.mode;
+      const raw = nested !== undefined ? nested : cfg.correctionCaptureMode;
+      if (raw === undefined || raw === null) return "off" as const;
+      if (raw === "off" || raw === "queue" || raw === "auto") return raw;
+      throw new Error(
+        `Invalid correctionCapture.mode: expected one of "off", "queue", "auto", got ${JSON.stringify(raw)}`,
+      );
+    })(),
+    correctionCaptureConfidenceFloor: (() => {
+      const nested = (cfg.correctionCapture as Record<string, unknown> | undefined)?.confidenceFloor;
+      const raw = nested !== undefined ? nested : cfg.correctionCaptureConfidenceFloor;
+      if (raw === undefined || raw === null) return 0.85;
+      const n = coerceNumber(raw);
+      if (n === undefined || !Number.isFinite(n) || n < 0 || n > 1) {
+        throw new Error(`Invalid correctionCapture.confidenceFloor: expected a number in [0, 1], got ${JSON.stringify(raw)}`);
+      }
+      return n;
+    })(),
+    correctionCaptureAutoApplyMaxAffected: (() => {
+      const nested = (cfg.correctionCapture as Record<string, unknown> | undefined)?.autoApplyMaxAffected;
+      const raw = nested !== undefined ? nested : cfg.correctionCaptureAutoApplyMaxAffected;
+      if (raw === undefined || raw === null) return 2;
+      const n = coerceNumber(raw);
+      if (n === undefined || !Number.isFinite(n) || n < 1) {
+        throw new Error(`Invalid correctionCapture.autoApplyMaxAffected: expected an integer >= 1, got ${JSON.stringify(raw)}`);
+      }
+      return Math.floor(n);
+    })(),
     // Tombstones — non-resurrection invariant (issue #1579). The invariant is
     // the point, so it ships ON by default; `false` restores pre-feature
     // behavior for rollback safety (rule 30). Uses coerceBool so CLI string

package/src/correction/index.ts

@@ -41,3 +41,27 @@ export type { CorrectionNamespacePolicy, CorrectionServiceDeps } from "./correct
 
 export { createCorrectionService, isCorrectionFeatureEnabled } from "./correction-access-wiring.js";
 export type { CorrectionAccessWiring } from "./correction-access-wiring.js";
+
+export { detectPassiveCorrections, extractHandles } from "./passive-correction-detector.js";
+export type { PassiveCorrection, PassiveCorrectionPolarity, DetectorTurn } from "./passive-correction-detector.js";
+
+export {
+  capturePassiveCorrections,
+  evaluateAutoApplyGuards,
+  emptyTelemetry,
+} from "./passive-capture.js";
+export type {
+  CorrectionCaptureMode,
+  PassiveCaptureConfig,
+  PassiveCaptureContext,
+  PassiveCaptureDeps,
+  PassiveCaptureResult,
+  PassiveCaptureTelemetry,
+  AutoApplySuppressionReason,
+} from "./passive-capture.js";
+
+export {
+  enqueuePassiveCorrectionNotification,
+  drainPassiveCorrectionNotifications,
+} from "./passive-correction-notifications.js";
+export type { PassiveCorrectionNotification } from "./passive-correction-notifications.js";