@remnic/core 9.3.717 → 9.3.718

package/src/orchestrator.ts

@@ -24,6 +24,10 @@ import { SmartBuffer } from "./buffer.js";
 import { chunkContent, type ChunkingConfig } from "./chunking.js";
 import { semanticChunkContent, type SemanticChunkResult } from "./semantic-chunking.js";
 import { ExtractionEngine } from "./extraction.js";
+import { detectPassiveCorrections } from "./correction/passive-correction-detector.js";
+import { capturePassiveCorrections, type PassiveCaptureConfig } from "./correction/passive-capture.js";
+import { createCorrectionService } from "./correction/correction-access-wiring.js";
+import type { CorrectionService } from "./correction/correction-service.js";
 import { isAboveImportanceThreshold, scoreImportance } from "./importance.js";
 import {
   judgeFactDurability,
@@ -338,6 +342,7 @@ import {
 } from "./namespaces/identity.js";
 import {
   canReadNamespace,
+  canWriteNamespace,
   defaultNamespaceForPrincipal,
   recallNamespacesForPrincipal,
   resolvePrincipal,
@@ -1980,6 +1985,16 @@ export class Orchestrator {
     { count: number; lastAccessed: string }
   > = new Map();
 
+  // Passive correction capture (issue #1581) — dedup state + lazy service.
+  private passiveCorrectionDedup: Set<string> = new Set();
+  private _passiveCorrectionService: CorrectionService | null = null;
+  private passiveCorrectionTelemetry: {
+    detected: number;
+    queued: number;
+    autoApplied: number;
+    suppressedReasonCounts: Record<string, number>;
+  } = { detected: 0, queued: 0, autoApplied: 0, suppressedReasonCounts: {} };
+
   // Background serial queue for extractions (agent_end optimization)
   // Queue stores promises that resolve when extraction should run
   private extractionQueue: Array<() => Promise<void>> = [];
@@ -13012,6 +13027,139 @@ export class Orchestrator {
     }
   }
 
+  /**
+   * 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.
+   */
+  private async maybeCapturePassiveCorrections(
+    turns: readonly BufferTurn[],
+    opts: {
+      sessionKey: string;
+      principal?: string;
+      namespace: string;
+      bufferKey: string;
+      isLiveSession: boolean;
+    },
+  ): Promise<void> {
+    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;
+
+      // Replay/import: force queue-only mode even if config says auto.
+      const effectiveMode = opts.isLiveSession ? mode : "queue";
+      const captureConfig: PassiveCaptureConfig = {
+        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,
+      );
+
+      // Accumulate telemetry
+      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) {
+      // Fail-open: passive capture never blocks extraction.
+      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. */
+  private passiveCorrectionService(): CorrectionService {
+    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;
+  }
+
   private async runExtraction(
     turns: BufferTurn[],
     options: {
@@ -13097,13 +13245,13 @@ export class Orchestrator {
     );
     if (targetTurns.length === 0) {
       log.debug("skipping extraction: no non-context turns after normalization");
+      // Context-only turns may still contain corrections (review: "context-only
+      // turns skip capture"). Scan normalizedTurns before clearing the buffer.
+      if (normalizedTurns.length > 0) {
+        await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], { 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");
@@ -13123,6 +13271,30 @@ export class Orchestrator {
         `skipping extraction: below threshold (totalChars=${totalChars}, userTurns=${userTurns.length})`,
       );
       await clearBuffer();
+      // Passive correction capture runs even when extraction is skipped for
+      // being below the char/user-turn threshold (review: "skipped extraction
+      // skips capture"). A short correction like "stop using Vim" is under
+      // extractionMinChars but is exactly the high-value case this feature
+      // exists for. The write namespace resolves through the SAME scope-profile
+      // plan as the full extraction path so corrections target the active
+      // profile's write layer, not just resolveSelfNamespace (review:
+      // "below-threshold wrong namespace"). The ACL in passiveCorrectionService
+      // authorizes the actual plan/apply.
+      {
+        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 : undefined;
+        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 as BufferTurn[], {
+          sessionKey, principal: capturePrincipal, namespace: captureNamespace, bufferKey, isLiveSession: clearBufferAfterExtraction,
+        });
+      }
       return {
         status: "skipped",
         reason: "below_threshold",
@@ -13322,13 +13494,12 @@ export class Orchestrator {
         meta.lastExtractionAt = new Date().toISOString();
         await storage.saveMeta(meta);
       }
+      // Correction-only turns that meet char/user-turn thresholds but yield
+      // zero facts still need passive capture (review: "empty extraction skips
+      // capture"). selfNamespace/principal already resolved above.
+      await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], { 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: string | null = null;
@@ -13445,6 +13616,19 @@ export class Orchestrator {
 
     await clearBuffer({ ignoreAbort: true });
 
+    // Passive correction capture (issue #1581) — detect corrections expressed
+    // passively in the extracted turns and route to the Correction Contract.
+    // Runs AFTER persistence + buffer clear so a capture failure never blocks
+    // the extraction return. `clearBufferAfterExtraction` gates live-session
+    // auto-apply (replay/import → queue-only).
+    await this.maybeCapturePassiveCorrections(normalizedTurns as BufferTurn[], {
+      sessionKey,
+      principal,
+      namespace: selfNamespace,
+      bufferKey,
+      isLiveSession: clearBufferAfterExtraction,
+    });
+
     // Build memory box from this extraction (v8.0 Phase 2A)
     // Topics are derived from the current extraction's facts and entities only —
     // not from readAllMemories() — so box topics accurately reflect the current

package/src/types.ts

@@ -862,6 +862,29 @@ export interface PluginConfig {
    * `24`. Parsed from `correction.planTtlHours` / `correctionPlanTtlHours`.
    */
   correctionPlanTtlHours: number;
+  /**
+   * Passive correction capture (issue #1581) — detects corrections expressed
+   * passively in conversation turns during extraction and routes them to the
+   * Correction Contract (#1580). `"off"` disables detection entirely; `"queue"`
+   * plans corrections for human review (conservative); `"auto"` applies
+   * immediately when all safety guards pass, otherwise falls back to queue.
+   * Default `"off"` — operators opt in (rule 48). Parsed from
+   * `correctionCapture.mode` / `correctionCaptureMode`.
+   */
+  correctionCaptureMode: "off" | "queue" | "auto";
+  /**
+   * Minimum planner confidence for auto-apply (issue #1581). Plans below this
+   * floor are queued even in `"auto"` mode. Default `0.85`. Parsed from
+   * `correctionCapture.confidenceFloor` / `correctionCaptureConfidenceFloor`.
+   */
+  correctionCaptureConfidenceFloor: number;
+  /**
+   * Maximum affected memories for auto-apply (issue #1581). Plans touching more
+   * memories than this are queued even in `"auto"` mode — a blast-radius cap.
+   * Default `2`. Parsed from `correctionCapture.autoApplyMaxAffected` /
+   * `correctionCaptureAutoApplyMaxAffected`.
+   */
+  correctionCaptureAutoApplyMaxAffected: number;
   // Tombstones — non-resurrection invariant (issue #1579).
   /**
    * Master gate for the tombstone non-resurrection invariant. When `true`
@@ -2178,6 +2201,19 @@ export interface BriefingResult {
    * Allows callers to distinguish "no events today" from "source unavailable".
    */
   calendarSourceErrors?: BriefingCalendarSourceError[];
+  /**
+   * Auto-applied passive corrections drained from the notification queue at
+   * briefing time (issue #1581). Each carries a one-line summary and the undo
+   * command. Drained exactly once — the queue file is cleared on read, so a
+   * notification appears in at most one briefing. Absent when the correction
+   * capture feature is off or no corrections were auto-applied.
+   */
+  correctionNotifications?: ReadonlyArray<{
+    planId: string;
+    summary: string;
+    undoCommand: string;
+    createdAt: string;
+  }>;
 }
 
 /**

package/dist/chunk-2KF4HDG2.js

@@ -1,24 +0,0 @@
-// src/procedural/reinforcement-core.ts
-function clusterByKey(items, keyFn) {
-  const clusters = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const key = keyFn(item);
-    if (typeof key !== "string") {
-      throw new TypeError(
-        `clusterByKey: keyFn must return a string, got ${key === null ? "null" : typeof key}`
-      );
-    }
-    const existing = clusters.get(key);
-    if (existing) {
-      existing.push(item);
-    } else {
-      clusters.set(key, [item]);
-    }
-  }
-  return clusters;
-}
-
-export {
-  clusterByKey
-};
-//# sourceMappingURL=chunk-2KF4HDG2.js.map

package/dist/chunk-2KF4HDG2.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/procedural/reinforcement-core.ts"],"sourcesContent":["/**\n * Generic reinforcement-core primitives extracted from `procedure-miner.ts`\n * (issue #687 PR 1/4). Procedure-specific scoring (success rate, step\n * normalization) intentionally stays in the miner — this module only\n * exposes category-agnostic clustering and cluster summarization helpers\n * so future PRs can run reinforcement across non-procedural categories.\n *\n * Pure refactor — no behavior change.\n */\n\n/**\n * Group `items` into clusters keyed by `keyFn(item)`.\n *\n * - Preserves the original input order within each cluster's array.\n * - The returned `Map` insertion order matches first-seen key order, so\n *   downstream iteration is deterministic for a given input.\n * - Throws `TypeError` if `keyFn` returns a non-string (e.g. `undefined`,\n *   `null`, or a number). Callers must produce a stable string key.\n */\nexport function clusterByKey<T>(items: readonly T[], keyFn: (item: T) => string): Map<string, T[]> {\n  const clusters = new Map<string, T[]>();\n  for (const item of items) {\n    const key = keyFn(item);\n    if (typeof key !== \"string\") {\n      throw new TypeError(\n        `clusterByKey: keyFn must return a string, got ${key === null ? \"null\" : typeof key}`,\n      );\n    }\n    const existing = clusters.get(key);\n    if (existing) {\n      existing.push(item);\n    } else {\n      clusters.set(key, [item]);\n    }\n  }\n  return clusters;\n}\n\nexport interface ClusterSummary {\n  /** Number of items in the cluster. */\n  count: number;\n  /** Earliest timestamp seen in the cluster (string min via `localeCompare`). */\n  firstSeen: string;\n  /** Latest timestamp seen in the cluster (string max via `localeCompare`). */\n  lastSeen: string;\n}\n\n/**\n * Summarize a cluster by counting items and tracking earliest/latest\n * timestamps. Timestamp comparison uses `String#localeCompare`, which is\n * correct for ISO-8601 strings (lexicographic order matches chronological\n * order).\n *\n * - Throws `RangeError` on empty clusters — `firstSeen`/`lastSeen` are not\n *   meaningful without at least one item.\n * - When all timestamps are equal, `firstSeen === lastSeen`.\n */\nexport function summarizeCluster<T>(\n  cluster: readonly T[],\n  extractTimestamp: (item: T) => string,\n): ClusterSummary {\n  if (cluster.length === 0) {\n    throw new RangeError(\"summarizeCluster: cluster must contain at least one item\");\n  }\n  let firstSeen = extractTimestamp(cluster[0]);\n  let lastSeen = firstSeen;\n  for (let i = 1; i < cluster.length; i += 1) {\n    const ts = extractTimestamp(cluster[i]);\n    if (ts.localeCompare(firstSeen) < 0) firstSeen = ts;\n    if (ts.localeCompare(lastSeen) > 0) lastSeen = ts;\n  }\n  return { count: cluster.length, firstSeen, lastSeen };\n}\n"],"mappings":";AAmBO,SAAS,aAAgB,OAAqB,OAA8C;AACjG,QAAM,WAAW,oBAAI,IAAiB;AACtC,aAAW,QAAQ,OAAO;AACxB,UAAM,MAAM,MAAM,IAAI;AACtB,QAAI,OAAO,QAAQ,UAAU;AAC3B,YAAM,IAAI;AAAA,QACR,iDAAiD,QAAQ,OAAO,SAAS,OAAO,GAAG;AAAA,MACrF;AAAA,IACF;AACA,UAAM,WAAW,SAAS,IAAI,GAAG;AACjC,QAAI,UAAU;AACZ,eAAS,KAAK,IAAI;AAAA,IACpB,OAAO;AACL,eAAS,IAAI,KAAK,CAAC,IAAI,CAAC;AAAA,IAC1B;AAAA,EACF;AACA,SAAO;AACT;","names":[]}