@remnic/core 9.3.716 → 9.3.718

package/dist/{chunk-SQ4LU27I.js → chunk-NFRBADNR.js}

@@ -7,7 +7,7 @@ import {
 } from "./chunk-DGTDRIUO.js";
 import {
   MaintenanceScheduler
-} from "./chunk-O62P2LFL.js";
+} from "./chunk-APUJIMDM.js";
 import {
   migrateFromEngram
 } from "./chunk-7HYPN2GC.js";
@@ -23,7 +23,7 @@ import {
 import {
   CompoundingEngine,
   defaultTierMigrationCycleBudget
-} from "./chunk-WI4QX7GH.js";
+} from "./chunk-A66YRSOS.js";
 import {
   SharedContextManager
 } from "./chunk-UFS7OXGL.js";
@@ -176,7 +176,7 @@ import {
   buildEntityRecallSection,
   entityRecentTranscriptLookbackHours,
   readRecentEntityTranscriptEntries
-} from "./chunk-DXGS5YOQ.js";
+} from "./chunk-EH27LHML.js";
 import {
   formatDaySummaryMemories
 } from "./chunk-EO5QWINU.js";
@@ -189,14 +189,14 @@ import {
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-V7GDTQ6I.js";
+} from "./chunk-S35FX6MU.js";
 import {
   ThreadingManager
 } from "./chunk-QRDOSYOR.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
-} from "./chunk-JVEMUX6L.js";
+} from "./chunk-OZ2KQ7HF.js";
 import {
   searchWorkProductLedgerEntries
 } from "./chunk-ZRWB5D4H.js";
@@ -206,14 +206,14 @@ import {
 import {
   runNamespaceMaintenanceFanout,
   summarizeNamespaceMaintenanceHealth
-} from "./chunk-GM3BMWKR.js";
+} from "./chunk-REWQAFSA.js";
 import {
   NamespaceCatalog,
   planNamespaceMaintenance
-} from "./chunk-6QUPUTT7.js";
+} from "./chunk-HLIR3RJ7.js";
 import {
   NamespaceStorageRouter
-} from "./chunk-MPHDVHIB.js";
+} from "./chunk-DIFU33GU.js";
 import {
   PolicyRuntimeManager
 } from "./chunk-33JBK2XP.js";
@@ -258,7 +258,7 @@ import {
   materializeAfterSemanticConsolidation,
   parseConsolidationResponse,
   parseOperatorAwareConsolidationResponse
-} from "./chunk-2Y6LMOQQ.js";
+} from "./chunk-2VHMVWPU.js";
 import {
   buildRecallQueryPolicy
 } from "./chunk-LBJBNWS2.js";
@@ -295,12 +295,11 @@ import {
   describeErrorForOperator
 } from "./chunk-7WV3F5DQ.js";
 import {
+  capturePassiveCorrections,
   clusterByKey,
-  combineNamespaces,
-  resolveCodingNamespaceOverlay,
-  resolveScopePlan,
-  resolveScopeProfilePlan
-} from "./chunk-SHRRWOVY.js";
+  createCorrectionService,
+  detectPassiveCorrections
+} from "./chunk-OJU73BUX.js";
 import {
   listTrustZoneRecords,
   searchTrustZoneRecords
@@ -310,7 +309,15 @@ import {
 } from "./chunk-FF4KLI5W.js";
 import {
   buildXraySnapshot
-} from "./chunk-AJOIM6UR.js";
+} from "./chunk-L5ASZA2F.js";
+import {
+  combineNamespaces,
+  getConfiguredNamespaces,
+  resolveCodingNamespaceOverlay,
+  resolveNamespaceFromStorageDir,
+  resolveScopePlan,
+  resolveScopeProfilePlan
+} from "./chunk-J6BH2OBA.js";
 import {
   NamespaceSearchRouter
 } from "./chunk-CTOQEZSN.js";
@@ -357,7 +364,7 @@ import {
 } from "./chunk-TBBDFYXW.js";
 import {
   buildChainFollowupGenerator
-} from "./chunk-JEIROMLX.js";
+} from "./chunk-2COL35PK.js";
 import {
   ContentHashIndex,
   StorageManager,
@@ -365,7 +372,7 @@ import {
   fingerprintEntityStructuredFacts,
   normalizeAttributePairs,
   parseEntityFile
-} from "./chunk-OC56UWV5.js";
+} from "./chunk-YYOK4GVF.js";
 import {
   buildRetiredFactTombstoneInputs
 } from "./chunk-3JJWNZTT.js";
@@ -399,7 +406,7 @@ import {
 } from "./chunk-SVOZFLIQ.js";
 import {
   confidenceTier
-} from "./chunk-MSVSP5VO.js";
+} from "./chunk-N3DUH6OO.js";
 import {
   inferMemoryStatus,
   isActiveMemoryStatus
@@ -442,6 +449,7 @@ import {
 } from "./chunk-I4WBNM3M.js";
 import {
   canReadNamespace,
+  canWriteNamespace,
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal
@@ -2491,6 +2499,10 @@ var Orchestrator = class _Orchestrator {
   // Access tracking buffer (Phase 1A)
   // Maps memoryId -> {count, lastAccessed} for batched updates
   accessTrackingBuffer = /* @__PURE__ */ new Map();
+  // Passive correction capture (issue #1581) — dedup state + lazy service.
+  passiveCorrectionDedup = /* @__PURE__ */ new Set();
+  _passiveCorrectionService = null;
+  passiveCorrectionTelemetry = { detected: 0, queued: 0, autoApplied: 0, suppressedReasonCounts: {} };
   // Background serial queue for extractions (agent_end optimization)
   // Queue stores promises that resolve when extraction should run
   extractionQueue = [];
@@ -2779,16 +2791,8 @@ var Orchestrator = class _Orchestrator {
     const ns = typeof namespace === "string" && namespace.trim().length > 0 ? namespace.trim() : this.config.defaultNamespace;
     return this.storageRouter.storageFor(ns);
   }
-  configuredNamespaces() {
-    return Array.from(
-      new Set(
-        [
-          this.config.defaultNamespace,
-          this.config.sharedNamespace,
-          ...this.config.namespacePolicies.map((policy) => policy.name)
-        ].map((value) => value.trim()).filter(Boolean)
-      )
-    );
+  configuredNamespaceList() {
+    return getConfiguredNamespaces(this.config);
   }
   rememberNamespaceStorageDirHint(namespace, storageDir) {
     if (!this.config.namespacesEnabled || !storageDir) return;
@@ -2880,7 +2884,7 @@ var Orchestrator = class _Orchestrator {
       }
     }
     const configured = new Set(
-      this.configuredNamespaces().map((namespace) => normalizeNamespaceIdentity(namespace))
+      this.configuredNamespaceList().map((namespace) => normalizeNamespaceIdentity(namespace))
     );
     const preferredByStorageDir = /* @__PURE__ */ new Map();
     for (const record of compactedByNamespace.values()) {
@@ -2959,7 +2963,7 @@ var Orchestrator = class _Orchestrator {
     }
     const namespaces = this.config.namespacesEnabled ? Array.from(
       new Set(
-        (options.namespaces?.length ? options.namespaces : this.configuredNamespaces()).map((value) => value.trim()).filter(Boolean)
+        (options.namespaces?.length ? options.namespaces : this.configuredNamespaceList()).map((value) => value.trim()).filter(Boolean)
       )
     ) : [this.config.defaultNamespace];
     if (!this.config.namespacesEnabled) {
@@ -4089,7 +4093,7 @@ ${doc.content}` : doc.content,
     if (options?.dryRun !== true) {
       try {
         await this.processEntitySynthesisQueue(
-          this.namespaceFromStorageDir(targetStorage.dir),
+          this.storageDirNamespace(targetStorage.dir),
           5
         );
       } catch (error) {
@@ -10617,6 +10621,120 @@ ${normalized}`).digest("hex");
       log.error(failed, err);
     }
   }
+  /**
+   * Passive correction capture (issue #1581) — detects corrections expressed
+   * passively in conversation turns and routes them to the Correction Contract
+   * (#1580). Called from `runExtraction` after persistence completes.
+   *
+   * Thin wiring: delegates ALL correction logic to the detector + capture
+   * modules + the CorrectionService. This method only checks gates, calls the
+   * detector, and routes results. Fail-open: capture errors never block the
+   * extraction return path.
+   */
+  async maybeCapturePassiveCorrections(turns, opts) {
+    const mode = this.config.correctionCaptureMode;
+    if (mode === "off") return;
+    if (!this.config.correctionEnabled) return;
+    try {
+      const corrections = detectPassiveCorrections(
+        turns.map((t) => ({ role: t.role, content: t.content }))
+      );
+      if (corrections.length === 0) return;
+      const effectiveMode = opts.isLiveSession ? mode : "queue";
+      const captureConfig = {
+        mode: effectiveMode,
+        confidenceFloor: this.config.correctionCaptureConfidenceFloor,
+        autoApplyMaxAffected: this.config.correctionCaptureAutoApplyMaxAffected
+      };
+      const service = this.passiveCorrectionService();
+      const result = await capturePassiveCorrections(
+        corrections,
+        {
+          correctionEnabled: this.config.correctionEnabled,
+          isLiveSession: opts.isLiveSession,
+          bufferKey: opts.bufferKey,
+          sessionKey: opts.sessionKey,
+          principal: opts.principal,
+          namespace: opts.namespace
+        },
+        captureConfig,
+        {
+          planCorrection: (req) => service.plan(req),
+          applyCorrection: (planId, applyOpts) => service.apply(planId, applyOpts),
+          storageDir: async (ns) => (await this.getStorage(ns)).dir,
+          // Resolve `[m:xxxx]` handles to concrete memory ids via the single
+          // shared helper (#1582). Returns null on miss/ambiguity so the
+          // capture loop drops the handle and the planner falls back to text
+          // search (review: "memory handles not resolved").
+          resolveHandle: (ref, sessionKey) => {
+            try {
+              return this.resolveMemoryIdOrHandle(ref, sessionKey);
+            } catch {
+              return null;
+            }
+          }
+        },
+        this.passiveCorrectionDedup
+      );
+      this.passiveCorrectionTelemetry.detected += result.telemetry.detected;
+      this.passiveCorrectionTelemetry.queued += result.telemetry.queued;
+      this.passiveCorrectionTelemetry.autoApplied += result.telemetry.autoApplied;
+      for (const [reason, count] of Object.entries(result.telemetry.suppressedReasons)) {
+        this.passiveCorrectionTelemetry.suppressedReasonCounts[reason] = (this.passiveCorrectionTelemetry.suppressedReasonCounts[reason] ?? 0) + count;
+      }
+    } catch (err) {
+      log.debug(
+        `passive-correction: capture failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  /** Lazily construct the CorrectionService for passive capture. Stateless
+   *  across requests (per #1580 design); cached for the orchestrator's life. */
+  passiveCorrectionService() {
+    if (this._passiveCorrectionService) return this._passiveCorrectionService;
+    this._passiveCorrectionService = createCorrectionService({
+      orchestrator: this,
+      // Session-scoped write ACL (review: "passive capture bypasses write
+      // ACL"). A correction detected in session S plans only against S readable
+      // namespaces and applies only to writable ones (rule 42) — passive
+      // capture never becomes a cross-tenant mutation vector. Mirrors the
+      // access-service createCorrectionService wiring rather than bypassing it.
+      resolveAuthorizedNamespace: async (req) => {
+        const principal = req.principal || resolvePrincipal(req.sessionKey, this.config);
+        const ns = req.namespace ?? defaultNamespaceForPrincipal(principal, this.config);
+        if (!canWriteNamespace(principal, ns, this.config)) {
+          throw new Error(
+            `passive correction: namespace "${ns}" is not writable for principal ${principal ?? "(none)"}`
+          );
+        }
+        return ns;
+      },
+      resolveReadableNamespaces: (req) => {
+        const principal = req.principal || resolvePrincipal(req.sessionKey, this.config);
+        return recallNamespacesForPrincipal(principal, this.config);
+      },
+      canWriteNamespace: async (req) => {
+        const principal = req.principal || resolvePrincipal(req.sessionKey, this.config);
+        return canWriteNamespace(principal, req.namespace, this.config);
+      },
+      llmComplete: async ({ system, user }) => {
+        const llmResult = await this.localLlm.chatCompletion(
+          [
+            { role: "system", content: system },
+            { role: "user", content: user }
+          ],
+          { operation: "correction-classify", priority: "background" }
+        );
+        if (!llmResult) {
+          throw new Error(
+            "passive correction classify+draft: local LLM unavailable (disabled or in cooldown)"
+          );
+        }
+        return llmResult.content;
+      }
+    });
+    return this._passiveCorrectionService;
+  }
   async runExtraction(turns, options = {}) {
     log.debug(`running extraction on ${turns.length} turns`);
     const clearBufferAfterExtraction = options.clearBufferAfterExtraction ?? true;
@@ -10662,13 +10780,11 @@ ${normalized}`).digest("hex");
     );
     if (targetTurns.length === 0) {
       log.debug("skipping extraction: no non-context turns after normalization");
+      if (normalizedTurns.length > 0) {
+        await this.maybeCapturePassiveCorrections(normalizedTurns, { sessionKey, principal: resolvePrincipal(sessionKey, this.config), namespace: this.resolveSelfNamespace(sessionKey), bufferKey, isLiveSession: clearBufferAfterExtraction });
+      }
       await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "empty_normalized_turns",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
+      return { status: "skipped", reason: "empty_normalized_turns", persistedCount: 0, durableOutputCount: 0 };
     }
     const sourceValidAt = latestSourceValidAtFromTurns(targetTurns);
     throwIfDeadlineExceeded("before_extract");
@@ -10685,6 +10801,21 @@ ${normalized}`).digest("hex");
         `skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`
       );
       await clearBuffer();
+      {
+        const capturePrincipal = typeof options.principalOverride === "string" && options.principalOverride.length > 0 ? options.principalOverride : resolvePrincipal(sessionKey, this.config);
+        const captureWO = typeof options.writeNamespaceOverride === "string" && options.writeNamespaceOverride.length > 0 ? options.writeNamespaceOverride : void 0;
+        const captureCodingCtx = sessionKey ? this.getCodingContextForSession(sessionKey) : null;
+        const captureCodingOv = resolveCodingNamespaceOverlay(captureCodingCtx, this.config.codingMode, this.config.defaultNamespace);
+        const captureScopePlan = resolveScopeProfilePlan({ config: this.config, principal: capturePrincipal, codingContext: captureCodingCtx, codingOverlay: captureCodingOv });
+        const captureNamespace = captureWO ?? captureScopePlan?.writeNamespace ?? this.resolveSelfNamespace(sessionKey);
+        await this.maybeCapturePassiveCorrections(normalizedTurns, {
+          sessionKey,
+          principal: capturePrincipal,
+          namespace: captureNamespace,
+          bufferKey,
+          isLiveSession: clearBufferAfterExtraction
+        });
+      }
       return {
         status: "skipped",
         reason: "below_threshold",
@@ -10828,13 +10959,9 @@ ${normalized}`).digest("hex");
         meta.lastExtractionAt = (/* @__PURE__ */ new Date()).toISOString();
         await storage.saveMeta(meta);
       }
+      await this.maybeCapturePassiveCorrections(normalizedTurns, { sessionKey, principal, namespace: selfNamespace, bufferKey, isLiveSession: clearBufferAfterExtraction });
       await clearBuffer();
-      return {
-        status: "skipped",
-        reason: "empty_extraction_result",
-        persistedCount: 0,
-        durableOutputCount: 0
-      };
+      return { status: "skipped", reason: "empty_extraction_result", persistedCount: 0, durableOutputCount: 0 };
     }
     let threadIdForExtraction = null;
     if (this.config.threadingEnabled && turns.length > 0) {
@@ -10911,6 +11038,13 @@ ${normalized}`).digest("hex");
       );
     }
     await clearBuffer({ ignoreAbort: true });
+    await this.maybeCapturePassiveCorrections(normalizedTurns, {
+      sessionKey,
+      principal,
+      namespace: selfNamespace,
+      bufferKey,
+      isLiveSession: clearBufferAfterExtraction
+    });
     if (this.config.memoryBoxesEnabled && persistedIds.length > 0) {
       const extractionTopics = deriveTopicsFromExtraction(result);
       const firstUserTurn = turns.find((t) => t.role === "user");
@@ -11274,7 +11408,7 @@ ${normalized}`).digest("hex");
     const shouldPromoteToShared = (targetStorage, category, confidence) => {
       if (!this.config.namespacesEnabled || !profileAllowsSharedWrites || !sharedAutoPromotionAllows(category, confidence))
         return false;
-      if (this.namespaceFromStorageDir(targetStorage.dir) === this.config.sharedNamespace)
+      if (this.storageDirNamespace(targetStorage.dir) === this.config.sharedNamespace)
         return false;
       return true;
     };
@@ -11714,7 +11848,7 @@ ${normalized}`).digest("hex");
       const biTemporal = this.config.temporalBiTemporal && sourceContext?.validAt ? resolveFactEventTime(fact.eventTime, sourceContext.validAt) : void 0;
       let writeCategory = fact.category;
       let targetStorage = storage;
-      let targetNamespaceName = baseNamespace && baseNamespace.length > 0 ? baseNamespace : this.namespaceFromStorageDir(targetStorage.dir);
+      let targetNamespaceName = baseNamespace && baseNamespace.length > 0 ? baseNamespace : this.storageDirNamespace(targetStorage.dir);
       let routedRuleId;
       let routedNamespaceExplicit = false;
       if (routeRules.length > 0) {
@@ -11741,7 +11875,7 @@ ${normalized}`).digest("hex");
         }
       }
       if (this.config.extractionScopeClassificationEnabled && this.config.namespacesEnabled && fact.scope === "global" && !routedNamespaceExplicit) {
-        const currentNs = this.namespaceFromStorageDir(targetStorage.dir);
+        const currentNs = this.storageDirNamespace(targetStorage.dir);
         if (currentNs !== this.config.sharedNamespace && profileAllowsSharedWrites) {
           try {
             targetStorage = await this.storageRouter.storageFor(
@@ -11889,7 +12023,7 @@ ${normalized}`).digest("hex");
       let links = [];
       let contradictionDetected = false;
       if (this.config.contradictionDetectionEnabled && this.qmd.isAvailable() && faithfulnessEnforceStatus !== "pending_review") {
-        const targetNamespace = this.namespaceFromStorageDir(targetStorage.dir);
+        const targetNamespace = this.storageDirNamespace(targetStorage.dir);
         const contradiction = await this.checkForContradiction(
           fact.content,
           writeCategory,
@@ -12154,7 +12288,7 @@ ${normalized}`).digest("hex");
               memoryId: parentId,
               category: writeCategory,
               content: fact.content,
-              namespace: this.namespaceFromStorageDir(targetStorage.dir),
+              namespace: this.storageDirNamespace(targetStorage.dir),
               confidence: fact.confidence,
               source: "extraction"
             })
@@ -12163,7 +12297,7 @@ ${normalized}`).digest("hex");
         }
       }
       if (this.config.memoryLinkingEnabled && this.qmd.isAvailable()) {
-        const targetNamespace = this.namespaceFromStorageDir(targetStorage.dir);
+        const targetNamespace = this.storageDirNamespace(targetStorage.dir);
         const suggestedLinks = await this.suggestLinksForMemory(
           fact.content,
           writeCategory,
@@ -12232,7 +12366,7 @@ ${normalized}`).digest("hex");
             memoryId,
             category: writeCategory,
             content: fact.content,
-            namespace: this.namespaceFromStorageDir(targetStorage.dir),
+            namespace: this.storageDirNamespace(targetStorage.dir),
             confidence: fact.confidence,
             source: "extraction"
           })
@@ -12330,7 +12464,7 @@ ${normalized}`).digest("hex");
     let durableNonFactWritten = false;
     let durableNonFactTouchRecorded = false;
     const touchBaseNonFactNamespace = () => {
-      const baseTouchNamespace = baseNamespace && baseNamespace.length > 0 ? baseNamespace : this.namespaceFromStorageDir(storage.dir);
+      const baseTouchNamespace = baseNamespace && baseNamespace.length > 0 ? baseNamespace : this.storageDirNamespace(storage.dir);
     };
     const recordDurableNonFactWrite = () => {
       durableNonFactWritten = true;
@@ -13905,7 +14039,7 @@ ${lines.join("\n\n")}`;
         seenStorageDirs.add(storageKey);
         storages.push(storage);
       };
-      const fallbackNamespace = fallbackStorageDir !== null ? this.namespaceFromStorageDir(fallbackStorageDir) : this.config.defaultNamespace;
+      const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : this.config.defaultNamespace;
       if (recallNamespaces.length === 0 || !this.config.namespacesEnabled || recallNamespaces.includes(fallbackNamespace)) {
         addStorage(fallbackStorage);
       }
@@ -14052,7 +14186,7 @@ ${lines.join("\n\n")}`;
       seenDirs.add(candidateRoot);
       matches.push({ storage, dir: candidateRoot, namespace });
     };
-    const fallbackNamespace = fallbackStorageDir !== null ? this.namespaceFromStorageDir(fallbackStorageDir) : this.config.defaultNamespace;
+    const fallbackNamespace = fallbackStorageDir !== null ? this.storageDirNamespace(fallbackStorageDir) : this.config.defaultNamespace;
     maybeAddStorage(fallbackStorage, fallbackNamespace);
     const candidateNamespaces = /* @__PURE__ */ new Set();
     candidateNamespaces.add(this.config.defaultNamespace);
@@ -15324,32 +15458,13 @@ ${lines.join("\n\n")}`;
     if (!m?.[1]) return this.config.defaultNamespace;
     return namespaceIdentityFromToken(m[1]) ?? m[1];
   }
-  namespaceFromStorageDir(storageDir) {
-    if (!this.config.namespacesEnabled) return this.config.defaultNamespace;
-    const resolvedStorageDir = path2.resolve(storageDir);
-    const resolvedMemoryDir = path2.resolve(this.config.memoryDir);
-    if (resolvedStorageDir === resolvedMemoryDir)
-      return this.config.defaultNamespace;
-    const m = resolvedStorageDir.match(/[\\/]namespaces[\\/]([^\\/]+)$/);
-    if (!m?.[1]) return this.config.defaultNamespace;
-    const dirName = m[1];
-    if (this.configuredNamespaces().includes(dirName)) {
-      return dirName;
-    }
-    this.loadNamespaceStorageDirHintsFromCatalog();
-    const hintedNamespaces = this.namespaceStorageDirHints.get(resolvedStorageDir);
-    if (hintedNamespaces?.has(dirName)) {
-      return dirName;
-    }
-    if (hintedNamespaces?.size === 1) {
-      const [hintedNamespace] = hintedNamespaces;
-      if (hintedNamespace) return hintedNamespace;
-    }
-    const decoded = namespaceIdentityFromToken(dirName);
-    if (decoded && namespaceIdentityToken(decoded) === dirName) {
-      return decoded;
-    }
-    return dirName;
+  storageDirNamespace(storageDir) {
+    return resolveNamespaceFromStorageDir(storageDir, {
+      config: this.config,
+      configuredNamespaces: this.configuredNamespaceList(),
+      hints: this.namespaceStorageDirHints,
+      loadHints: () => this.loadNamespaceStorageDirHintsFromCatalog()
+    });
   }
   // #1522: catalog touch methods removed — touches now happen at the storage chokepoint.
   /**
@@ -15437,4 +15552,4 @@ export {
   resolvePersistedMemoryRelativePath,
   Orchestrator
 };
-//# sourceMappingURL=chunk-SQ4LU27I.js.map
+//# sourceMappingURL=chunk-NFRBADNR.js.map