@remnic/core 9.3.716 → 9.3.718

package/src/correction/passive-correction-detector.ts

@@ -0,0 +1,325 @@
+/**
+ * correction/passive-correction-detector.ts — morphology-aware heuristic detector
+ * for corrections expressed passively in conversation turns (issue #1581).
+ *
+ * Users correct their agents constantly in conversation: "no, we renamed that
+ * service", "I don't use Vim anymore", "the deadline moved to Friday". This
+ * module detects those corrections from turn text — NO extra LLM call — so the
+ * passive-capture module can route them to the Correction Contract (#1580).
+ *
+ * Design:
+ *   - Pure function: `detectPassiveCorrections(turns)` → `PassiveCorrection[]`.
+ *   - Only USER turns are scanned (assistants don't correct their own memory).
+ *   - Morphology-aware: matches conjugations/variants per AGENTS.md intent
+ *     guardrail ("heuristics must be morphology-aware and precedence-tested").
+ *   - Anti-fixture guards reject: hypotheticals, third-party corrections,
+ *     quoted-speech corrections, and self-resolving corrections.
+ *
+ * The detector is deliberately CONSERVATIVE — it prefers false negatives
+ * (missing a correction) over false positives (flooding the review queue).
+ * The nightly contradiction scan and the interactive correction chat (#1583)
+ * catch what passive detection misses.
+ */
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export type PassiveCorrectionPolarity = "update" | "retract" | "stop_storing";
+
+export interface PassiveCorrection {
+  /** What the user says is wrong ("Redis", "the deadline", "my editor preference"). */
+  targetHint: string;
+  /** The new truth, or "" for pure retractions. */
+  correctedAssertion: string;
+  polarity: PassiveCorrectionPolarity;
+  /** `[m:xxxx]` handle references found verbatim in the turn (#1582). */
+  handles: string[];
+  /** Heuristic confidence in [0, 1] — influences auto-apply gating. */
+  confidence: number;
+  /** The verbatim source text that triggered the detection. */
+  sourceExcerpt: string;
+  /** Index of the turn in the input array that produced this correction. */
+  turnIndex: number;
+}
+
+export interface DetectorTurn {
+  role: "user" | "assistant" | "other";
+  content: string;
+}
+
+// ---------------------------------------------------------------------------
+// Pattern definitions
+// ---------------------------------------------------------------------------
+
+interface CorrectionPattern {
+  polarity: PassiveCorrectionPolarity;
+  /** Regex MUST be case-insensitive and use word boundaries where appropriate. */
+  regex: RegExp;
+  /** Confidence assigned when this pattern is the sole signal. */
+  confidence: number;
+}
+
+/**
+ * Strong correction signals — these phrases reliably indicate the user is
+ * correcting a stored memory about their own world. Each is morphology-aware
+ * (covers present/progressive/past tenses and common variants).
+ */
+const PATTERNS: readonly CorrectionPattern[] = [
+  // ── update: new fact replaces / corrects an old one ──────────────────────
+  {
+    polarity: "update",
+    // "actually, it's X not Y" / "actually we use X now"
+    regex: /\bactually[,\s]+(?:it'?s|we|the|i|our|my|\[m:)/i,
+    confidence: 0.85,
+  },
+  {
+    polarity: "update",
+    // "we switched/switching/switched to X"
+    regex: /\bwe\b\s*(?:(?:'re|'ve|are|have)\s+)?(?:switch(?:ed|ing)?|migrat(?:ed|ing)?|mov(?:ed|ing)?|chang(?:ed|ing)?)\s+(?:to|over to|from)\b/i,
+    confidence: 0.9,
+  },
+  {
+    polarity: "update",
+    // "we renamed X to Y" / "i renamed"
+    regex: /\b(?:we|i)\s+renam(?:ed|ing)\b/i,
+    confidence: 0.9,
+  },
+  {
+    polarity: "update",
+    // "it's now X" / "the deadline moved to X" / "the date changed to X"
+    regex: /\b(?:it'?s now|the\s+(?:deadline|date|meeting|standup|review)\s+(?:moved|chang(?:ed|ing))?\s*to)\b/i,
+    confidence: 0.85,
+  },
+  {
+    polarity: "update",
+    // "no, " at the start of a turn or clause — strong correction signal
+    regex: /(?:^|\.\s+|\n)\s*no[,\s]+(?:we|i|it|the|our|my|that)\b/i,
+    confidence: 0.8,
+  },
+  {
+    polarity: "update",
+    // "no longer" / "not anymore" + an activity
+    regex: /\b(?:no longer|not anymore)\b/i,
+    confidence: 0.8,
+  },
+  {
+    polarity: "update",
+    // Standalone "outdated" — catches "are both outdated", "is outdated", etc.
+    regex: /\boutdated\b/i,
+    confidence: 0.75,
+  },
+  {
+    polarity: "update",
+    // "that's outdated" / "that's old"
+    regex: /\bthat'?s\s+(?:outdated|old|no longer (?:true|correct|accurate))\b/i,
+    confidence: 0.85,
+  },
+  // ── retract: user says a fact is simply wrong ────────────────────────────
+  {
+    polarity: "retract",
+    regex: /\bthat'?s\s+(?:wrong|not right|incorrect|not true|false)\b/i,
+    confidence: 0.85,
+  },
+  {
+    polarity: "retract",
+    // "we don't use X anymore" / "I don't use X anymore"
+    regex: /\b(?:we|i)\s+don'?t\s+use\s+\S+\s+anymore\b/i,
+    confidence: 0.9,
+  },
+  {
+    polarity: "retract",
+    regex: /\bforget about\b/i,
+    confidence: 0.8,
+  },
+  // ── stop_storing: user wants the agent to stop a behavior ────────────────
+  {
+    polarity: "stop_storing",
+    regex: /\bstop\s+(?:suggesting|bringing\s+up|recommending|reminding\s+me\s+(?:about)?)\b/i,
+    confidence: 0.9,
+  },
+  {
+    polarity: "stop_storing",
+    regex: /\b(?:don'?t|never)\s+(?:mention|suggest|recommend|store|bring\s+up)\b/i,
+    confidence: 0.85,
+  },
+];
+
+// ---------------------------------------------------------------------------
+// Anti-fixture guards
+// ---------------------------------------------------------------------------
+
+/**
+ * Hypothetical markers — if present near the correction signal, the turn is
+ * discussing a hypothetical scenario, not correcting a stored fact.
+ */
+const HYPOTHETICAL_REGEX =
+  /\b(?:if\s+(?:we|you|i|they)\s+(?:ever|were|could|might|should|decide)|what\s+if|suppose|hypothetically|in\s+(?:theory|principle)|let'?s\s+say|imagine\s+if)\b/i;
+
+/**
+ * Third-party correction markers — the user is correcting someone else, not
+ * their agent's memory of their own world.
+ */
+const THIRD_PARTY_REGEX =
+  /\b(?:tell\s+\w+\s+(?:he|she|they|you)'?re?\s+wrong|he'?s\s+wrong\s+about|she'?s\s+wrong\s+about|they'?re\s+wrong\s+about|correct\s+\w+\s+on)\b/i;
+
+/**
+ * Tool-output correction — the user is saying a tool's output is wrong, not
+ * that their stored memory is wrong.
+ */
+const TOOL_OUTPUT_REGEX =
+  /\b(?:the\s+(?:output|result|response|error|log)|your\s+(?:output|result|response|code|answer))\s+(?:is\s+)?(?:wrong|incorrect|bad|off)\b/i;
+
+/**
+ * Self-resolving correction — the user corrects themselves within the same
+ * turn ("actually wait, no, the original was right"). These turn back and
+ * cancel out.
+ */
+const SELF_RESOLVE_REGEX =
+  /(?:actually|wait|no)[,\s]+(?:never\s*mind|forget\s*(?:that|it)|the\s+(?:original|first)\s+(?:was|is)\s+(?:right|correct)|scratch\s+that|disregard)/i;
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/** Extract `[m:xxxx]` handle references from text (#1582). */
+export function extractHandles(text: string): string[] {
+  const matches = text.match(/\[m:[0-9a-fA-F]{4,}\]/g);
+  return matches ?? [];
+}
+
+/**
+ * Extract a target hint from the matched correction text. Returns a short
+ * phrase (≤80 chars) the planner can use to locate the affected memory.
+ */
+function extractTargetHint(text: string, match: RegExpMatchArray): string {
+  const matchStart = match.index ?? 0;
+  // Take a window around the match: 20 chars before to 60 chars after.
+  const start = Math.max(0, matchStart - 20);
+  const end = Math.min(text.length, matchStart + match[0].length + 60);
+  const window = text.slice(start, end).replace(/\s+/g, " ").trim();
+  return window.length > 80 ? window.slice(0, 77) + "..." : window;
+}
+
+/**
+ * Extract the corrected assertion — the new truth the user is expressing.
+ * For "update" polarity, this is the full turn text (the planner searches for
+ * the old fact and drafts a replacement). For "retract", it's "" (no
+ * replacement). For "stop_storing", it's the behavior to suppress.
+ */
+function extractCorrectedAssertion(
+  text: string,
+  polarity: PassiveCorrectionPolarity,
+): string {
+  if (polarity === "retract") return "";
+  // For update/stop_storing, the full turn IS the assertion (truncated).
+  const trimmed = text.replace(/\s+/g, " ").trim();
+  return trimmed.length > 200 ? trimmed.slice(0, 197) + "..." : trimmed;
+}
+
+/**
+ * Check whether a regex match at the given index is within quotation marks.
+ * Used to reject corrections that are actually quoted speech (someone else's
+ * words the user is relaying, not the user correcting their own memory).
+ */
+function isWithinQuotes(text: string, matchIndex: number): boolean {
+  // Only DOUBLE quotes delimit quoted speech. Single quotes (ASCII apostrophe
+  // and smart single quotes) are deliberately NOT treated as delimiters: in
+  // English they are overwhelmingly contractions/possessives
+  // ("I don't think we switched"), which would falsely mark a
+  // correction as quoted speech and suppress a valid detection (false
+  // negative). A contraction before the correction phrase must not flip the
+  // detector into quoted mode.
+  let inQuote = false;
+  for (let i = 0; i < matchIndex && i < text.length; i++) {
+    const c = text[i];
+    if (c === '"' || c === '\u201c' || c === '\u201d') {
+      inQuote = !inQuote;
+    }
+  }
+  return inQuote;
+}
+
+/**
+ * Check whether any anti-fixture guard fires on the turn text.
+ * Returns the guard name that blocked detection, or null if clean.
+ */
+function detectAntiFixture(text: string): string | null {
+  if (SELF_RESOLVE_REGEX.test(text)) return "self_resolving";
+  if (HYPOTHETICAL_REGEX.test(text)) return "hypothetical";
+  if (THIRD_PARTY_REGEX.test(text)) return "third_party";
+  if (TOOL_OUTPUT_REGEX.test(text)) return "tool_output";
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+
+/**
+ * Detect passive corrections in a sequence of conversation turns.
+ *
+ * Only USER turns are scanned — assistant turns don't express corrections to
+ * the agent's stored memory. Each user turn is checked against the correction
+ * patterns; anti-fixture guards reject turns that look like hypotheticals,
+ * third-party corrections, tool-output complaints, or self-resolving double-
+ * corrections.
+ *
+ * A single turn may produce multiple corrections if different patterns match
+ * different parts of the text. Dedup by (turnIndex, targetHint) so overlapping
+ * patterns on the same phrase (e.g. "actually, we don't use Redis anymore"
+ * matching both update + retract) produce one correction.
+ */
+export function detectPassiveCorrections(
+  turns: readonly DetectorTurn[],
+): PassiveCorrection[] {
+  const results: PassiveCorrection[] = [];
+  const seen = new Set<string>();
+
+  for (let i = 0; i < turns.length; i++) {
+    const turn = turns[i];
+    if (turn.role !== "user") continue;
+    const content = turn.content?.trim();
+    if (!content) continue;
+
+    // Anti-fixture guards take precedence — one guard kills ALL corrections
+    // from this turn (a hypothetical turn can't contain a real correction).
+    const guard = detectAntiFixture(content);
+    if (guard) continue;
+
+    const handles = extractHandles(content);
+
+    for (const pattern of PATTERNS) {
+      const match = pattern.regex.exec(content);
+      if (!match) continue;
+
+      // Reject corrections that appear within quotation marks — the user is
+      // relaying someone else's words, not correcting their own stored memory.
+      if (match.index !== undefined && isWithinQuotes(content, match.index)) {
+        continue;
+      }
+
+      const targetHint = extractTargetHint(content, match);
+      const correctedAssertion = extractCorrectedAssertion(content, pattern.polarity);
+      // Polarity-agnostic: "actually, we don't use Redis anymore" matches
+      // both the update ("actually") and retract ("don't use ... anymore")
+      // patterns with the same targetHint — emit one correction, not two
+      // (review: "deduplicate overlapping passive-correction cues").
+      const dedupKey = `${i}:${targetHint}`;
+      if (seen.has(dedupKey)) continue;
+      seen.add(dedupKey);
+
+      results.push({
+        targetHint,
+        correctedAssertion,
+        polarity: pattern.polarity,
+        handles,
+        confidence: pattern.confidence,
+        sourceExcerpt: content.slice(0, 200),
+        turnIndex: i,
+      });
+    }
+  }
+
+  return results;
+}

package/src/correction/passive-correction-notifications.ts

@@ -0,0 +1,123 @@
+/**
+ * correction/passive-correction-notifications.ts — JSONL notification queue
+ * for auto-applied passive corrections (issue #1581).
+ *
+ * When passive capture auto-applies a correction, it enqueues a one-line
+ * notification here: `✎ Memory updated: <summary> (auto-applied (plan <planId>))`.
+ * The plan id is referenced (not a revert command) because `remnic correct`
+ * has no `--revert` flag — corrections are page-versioned for manual revert.
+ * The next session-start briefing drains the queue ONCE (temp-file-then-rename,
+ * rule 54) and clears it, so a notification is shown exactly once.
+ *
+ * File location: `<storageDir>/state/corrections/notifications.jsonl`
+ */
+
+import { mkdir, readFile, rename, writeFile, unlink } from "node:fs/promises";
+import path from "node:path";
+import { serializeMutations } from "../utils/serialize-mutations.js";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+export interface PassiveCorrectionNotification {
+  planId: string;
+  /** One-line human-readable summary of what changed. */
+  summary: string;
+  /** Undo command the user can run. */
+  undoCommand: string;
+  createdAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Path
+// ---------------------------------------------------------------------------
+
+function notificationsPath(storageDir: string): string {
+  return path.join(storageDir, "state", "corrections", "notifications.jsonl");
+}
+
+// ---------------------------------------------------------------------------
+// Enqueue
+// ---------------------------------------------------------------------------
+
+/**
+ * Append a notification line to the JSONL queue. Atomic (rule 54): the line
+ * is written to a temp file then renamed over the real file. Multiple
+ * notifications accumulate across calls — the queue is drained, not replaced.
+ */
+export async function enqueuePassiveCorrectionNotification(
+  storageDir: string,
+  notification: PassiveCorrectionNotification,
+): Promise<void> {
+  const filePath = notificationsPath(storageDir);
+  await serializeMutations(`passive-notification:${filePath}`, async () => {
+    // Read existing content (if any) so we accumulate rather than overwrite.
+    let existing = "";
+    try {
+      existing = await readFile(filePath, "utf-8");
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException)?.code;
+      if (code !== "ENOENT") throw err;
+    }
+
+    await mkdir(path.dirname(filePath), { recursive: true });
+    const line = `${JSON.stringify(notification)}\n`;
+    const content = existing + line;
+
+    const tmp = `${filePath}.${process.pid}.${Date.now().toString(36)}.tmp`;
+    await writeFile(tmp, content, "utf-8");
+    await rename(tmp, filePath);
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Drain (read + clear — exactly once)
+// ---------------------------------------------------------------------------
+
+/**
+ * Read all pending notifications and atomically clear the file. Returns the
+ * notifications in insertion order. If the file does not exist, returns [].
+ *
+ * Drain-once semantics: the file is deleted after reading, so calling this
+ * twice in a row returns notifications only the first time.
+ */
+export async function drainPassiveCorrectionNotifications(
+  storageDir: string,
+): Promise<PassiveCorrectionNotification[]> {
+  const filePath = notificationsPath(storageDir);
+  return serializeMutations(`passive-notification:${filePath}`, async () => {
+    let raw: string;
+    try {
+      raw = await readFile(filePath, "utf-8");
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException)?.code;
+      if (code === "ENOENT") return [];
+      throw err;
+    }
+
+    const notifications: PassiveCorrectionNotification[] = [];
+    for (const line of raw.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      try {
+        notifications.push(JSON.parse(trimmed) as PassiveCorrectionNotification);
+      } catch {
+        // Skip malformed lines (rule 34 — best-effort, never crash a briefing).
+        continue;
+      }
+    }
+
+    // Clear the file atomically (delete is atomic enough for this use case —
+    // the worst case is a duplicate notification, never a lost one, because
+    // the read already captured the content).
+    try {
+      await unlink(filePath);
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException)?.code;
+      if (code !== "ENOENT") throw err;
+    }
+
+    return notifications;
+  });
+}

package/src/maintenance/namespace-planner.ts

@@ -9,6 +9,7 @@ import { namespaceIdentityToken } from "../namespaces/identity.js";
 import { resolveNamespaceStorageRoot } from "../namespaces/storage.js";
 import { displayErrorDetail } from "../runtime/better-sqlite.js";
 import type { PluginConfig } from "../types.js";
+import { getConfiguredNamespaces } from "../scopes/scope-plan.js";
 
 export type NamespaceMaintenanceJobName = string;
 
@@ -110,15 +111,7 @@ export function __setNamespaceMaintenanceFsForTest(overrides: Partial<typeof nam
   };
 }
 
-function configuredNamespaces(config: PluginConfig): string[] {
-  return Array.from(
-    new Set(
-      [config.defaultNamespace, config.sharedNamespace, ...config.namespacePolicies.map((policy) => policy.name)]
-        .map((value) => value.trim())
-        .filter(Boolean)
-    )
-  );
-}
+
 
 function inferConfiguredKind(config: PluginConfig, namespace: string): NamespaceKind {
   if (namespace === config.defaultNamespace.trim()) return "default";
@@ -219,7 +212,7 @@ export async function planNamespaceMaintenance(
   // once per configured name. The #1500 contract is "namespaces disabled:
   // maintain the current default storage only," so collapse to the default.
   const configured = config.namespacesEnabled
-    ? configuredNamespaces(config)
+    ? getConfiguredNamespaces(config)
     : [config.defaultNamespace.trim()].filter(Boolean);
   const byNamespace = new Map<string, NamespaceMaintenanceCandidate>();
   const skipped: NamespaceMaintenanceSkippedNamespace[] = [];