@remnic/core 9.3.628 → 9.3.630

package/src/orchestrator.ts

@@ -1,4 +1,8 @@
 import { log } from "./logger.js";
+import {
+  buildChainFollowupGenerator,
+  type BriefingFollowupGenerator,
+} from "./briefing.js";
 import path from "node:path";
 import os from "node:os";
 import { createHash, randomBytes } from "node:crypto";
@@ -2516,6 +2520,28 @@ export class Orchestrator {
     };
   }
 
+  /**
+   * Build a briefing follow-up generator backed by the configured LLM chain
+   * (gateway model source or local LLM). Returns `undefined` when no chain
+   * is available so `buildBriefing` can surface a clear unavailable reason
+   * instead of failing at call time. Used by the access service and CLI as
+   * the fallback when no direct `openaiApiKey` is configured, so briefing
+   * follow-ups ride the same routing as every other fast-tier LLM feature.
+   */
+  get briefingChainFollowupGenerator(): BriefingFollowupGenerator | undefined {
+    // Plugin mode gates on `localLlmEnabled` alone: `LocalLlmClient.chatCompletion`
+    // returns null when the master switch is off, so `localLlmFastEnabled` by
+    // itself cannot serve requests (Cursor review on PR #1463).
+    const chainAvailable =
+      this.config.modelSource === "gateway"
+        ? this._fastGatewayLlm?.isAvailable(
+            this.config.fastGatewayAgentId || this.config.gatewayAgentId || undefined,
+          ) === true
+        : this.config.localLlmEnabled;
+    if (!chainAvailable) return undefined;
+    return buildChainFollowupGenerator(this.fastLlmForRerank);
+  }
+
   async initialize(): Promise<void> {
     // Recreate the deferred-ready gate on every initialize() call.
     // The same Orchestrator instance may be reused across stop/start cycles
@@ -10781,6 +10807,22 @@ export class Orchestrator {
         getStorage: async () =>
           await this.getStorageForNamespace(this.bulkImportWriteNamespace()),
         extract: (turns) => this.extraction.extract(turns),
+        // Smart memoryMode runs candidates through the SAME extraction
+        // judge (cache + defer counters included) the live extraction
+        // pipeline uses, so wearable facts get identical LLM-as-judge
+        // durability gating.
+        judgeFacts: (candidates) =>
+          judgeFactDurability(
+            candidates,
+            this.config,
+            this.localLlm,
+            new FallbackLlmClient(
+              this.config.gatewayConfig,
+              fallbackLlmRuntimeContextFromConfig(this.config),
+            ),
+            this.judgeVerdictCache,
+            this.judgeDeferCounts,
+          ),
         searchBackend: {
           search: async (query, maxResults) => {
             if (!this.qmd.isAvailable()) return null;

package/src/storage.ts

@@ -1168,6 +1168,27 @@ export class ContentHashIndex {
  *   normalizeAttributePairs({ foo: "bar", BAZ: "qux" })
  *   // → "baz: qux; foo: bar"
  */
+/**
+ * Remove the "[Attributes: ...]" suffix `writeMemory` appends to the
+ * stored body when structuredAttributes are present, yielding the raw
+ * fact text for content comparison. Inverse companion of
+ * `normalizeAttributePairs` enrichment. String operations, not regex —
+ * CodeQL js/polynomial-redos on a suffix-anchored pattern over
+ * library-supplied content.
+ */
+export function stripAttributesSuffix(content: string): string {
+  const trimmed = content.trimEnd();
+  if (!trimmed.endsWith("]")) return content.trim();
+  const marker = "\n[Attributes: ";
+  const markerIndex = trimmed.lastIndexOf(marker);
+  if (markerIndex === -1) return content.trim();
+  // The block must be the FINAL line and contain no "]" before the
+  // closing bracket (mirrors the shape normalizeAttributePairs emits).
+  const inner = trimmed.slice(markerIndex + marker.length, -1);
+  if (inner.includes("]") || inner.includes("\n")) return content.trim();
+  return trimmed.slice(0, markerIndex).trim();
+}
+
 export function normalizeAttributePairs(pairs: Record<string, string>): string {
   return Object.entries(pairs)
     .map(([k, v]) => [k.trim().toLowerCase(), v.trim()] as [string, string])
@@ -2596,6 +2617,85 @@ export class StorageManager {
     return days;
   }
 
+  /**
+   * Locate a wearable-sourced memory by exact (trimmed) content,
+   * ignoring the "[Attributes: ...]" suffix writeMemory appends for
+   * structuredAttributes — callers pass the raw fact text. Used by the
+   * smart trust pipeline to find an earlier borderline write when the
+   * same fact re-extracts with stronger evidence.
+   */
+  async findWearableMemoryByContent(
+    content: string,
+  ): Promise<{ id: string; status: MemoryStatus | undefined } | null> {
+    const needle = stripAttributesSuffix(content);
+    const memories = await this.readAllMemories();
+    for (const memory of memories) {
+      if (
+        typeof memory.frontmatter.source === "string" &&
+        memory.frontmatter.source.startsWith("wearable:") &&
+        stripAttributesSuffix(memory.content) === needle
+      ) {
+        return { id: memory.frontmatter.id, status: memory.frontmatter.status };
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Promote a pending_review wearable memory to active in place,
+   * merging updated trust evidence into structuredAttributes. Returns
+   * false when the memory is missing or no longer pending_review (a
+   * concurrent review decision wins).
+   */
+  async promoteWearableMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+    confidence?: number,
+  ): Promise<boolean> {
+    const memories = await this.readAllMemories();
+    const memory = memories.find((entry) => entry.frontmatter.id === id);
+    if (!memory) return false;
+    if (memory.frontmatter.status !== "pending_review") return false;
+    return this.writeMemoryFrontmatter(memory, {
+      status: "active",
+      // Keep frontmatter confidence in step with the re-scored trust —
+      // new smart writes persist trust as confidence, and a promoted
+      // row must not keep its stale borderline value.
+      ...(typeof confidence === "number" && Number.isFinite(confidence)
+        ? { confidence: Math.min(1, Math.max(0, confidence)) }
+        : {}),
+      structuredAttributes: {
+        ...(memory.frontmatter.structuredAttributes ?? {}),
+        ...attributeUpdates,
+      },
+    });
+  }
+
+  /**
+   * Demote a pending_review wearable memory to rejected when a re-pass
+   * produced an explicit judge-reject verdict, merging the evidence.
+   * Returns false when the memory is missing or no longer
+   * pending_review — active rows are NEVER auto-demoted (operator
+   * approvals and accrued recall signals win; contradiction scans and
+   * supersession own active-row retirement).
+   */
+  async demoteWearableMemory(
+    id: string,
+    attributeUpdates: Record<string, string>,
+  ): Promise<boolean> {
+    const memories = await this.readAllMemories();
+    const memory = memories.find((entry) => entry.frontmatter.id === id);
+    if (!memory) return false;
+    if (memory.frontmatter.status !== "pending_review") return false;
+    return this.writeMemoryFrontmatter(memory, {
+      status: "rejected",
+      structuredAttributes: {
+        ...(memory.frontmatter.structuredAttributes ?? {}),
+        ...attributeUpdates,
+      },
+    });
+  }
+
   private get factsDir(): string {
     return path.join(this.baseDir, "facts");
   }

package/src/wearables/cli.ts

@@ -125,6 +125,12 @@ function renderSyncSummary(summary: WearableSyncSummary): string {
     `  transcripts written:    ${summary.transcriptsWritten.length > 0 ? summary.transcriptsWritten.join(", ") : "(none — unchanged)"}`,
     `  memories created:       ${summary.memoriesCreated} (skipped ${summary.memoriesSkipped})`,
   ];
+  if (summary.memoriesPromoted > 0) {
+    lines.push(`  memories promoted:      ${summary.memoriesPromoted}`);
+  }
+  if (summary.memoriesDemoted > 0) {
+    lines.push(`  memories demoted:       ${summary.memoriesDemoted}`);
+  }
   if (summary.nativeMemoriesImported > 0) {
     lines.push(`  native memories queued: ${summary.nativeMemoriesImported}`);
   }

package/src/wearables/config.test.ts

@@ -25,17 +25,20 @@ test("boolean-ish strings coerce; garbage booleans throw", () => {
   assert.throws(() => parseWearablesConfig({ enabled: "fales" }), /wearables.enabled/);
 });
 
-test("source settings default to the least-privileged memory mode", () => {
+test("source settings default to the fully-automated smart pipeline", () => {
   const parsed = parseWearablesConfig({
     enabled: true,
     sources: { limitless: { enabled: true } },
   });
   const source = parsed.sources.limitless;
-  assert.equal(source.memoryMode, "review");
+  assert.equal(source.memoryMode, "smart");
+  assert.equal(source.sourceTrust, 0.8);
+  assert.equal(source.autoApproveTrust, 0.7);
+  assert.equal(source.reviewTrust, 0.45);
   assert.equal(source.minConfidence, 0.6);
   assert.equal(source.minImportance, "low");
-  assert.equal(source.maxMemoriesPerDay, 20);
-  assert.equal(source.importNativeMemories, "off");
+  assert.equal(source.maxMemoriesPerDay, 50);
+  assert.equal(source.importNativeMemories, "smart");
   assert.deepEqual(source.cleanup, {
     mergeSameSpeaker: true,
     stripFillers: true,
@@ -44,6 +47,32 @@ test("source settings default to the least-privileged memory mode", () => {
   });
 });
 
+test("top-level defaults are full-featured: digest and off-the-record on", () => {
+  const parsed = parseWearablesConfig({});
+  assert.equal(parsed.digestEnabled, true);
+  assert.equal(parsed.offTheRecordEnabled, true);
+  assert.equal(parsed.redactionEnabled, true);
+});
+
+test("trust knobs validate range and ordering", () => {
+  assert.throws(
+    () => parseWearablesConfig({ sources: { bee: { sourceTrust: 1.5 } } }),
+    /sourceTrust must be a number between 0 and 1/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ sources: { bee: { autoApproveTrust: -1 } } }),
+    /autoApproveTrust/,
+  );
+  assert.throws(
+    () => parseWearablesConfig({ sources: { bee: { reviewTrust: 0.9, autoApproveTrust: 0.7 } } }),
+    /reviewTrust .* must be below autoApproveTrust/,
+  );
+  const parsed = parseWearablesConfig({
+    sources: { bee: { sourceTrust: 0.5, autoApproveTrust: 0.8, reviewTrust: 0.3 } },
+  });
+  assert.equal(parsed.sources.bee.sourceTrust, 0.5);
+});
+
 test("invalid enum values list the valid options", () => {
   assert.throws(
     () =>

package/src/wearables/config.ts

@@ -22,7 +22,7 @@ import type {
 
 export const KNOWN_WEARABLE_SOURCE_IDS = ["limitless", "bee", "omi"] as const;
 
-const MEMORY_MODES: WearableMemoryMode[] = ["off", "review", "auto"];
+const MEMORY_MODES: WearableMemoryMode[] = ["off", "review", "auto", "smart"];
 const IMPORTANCE_LEVELS: ImportanceLevel[] = [
   "trivial",
   "low",
@@ -30,12 +30,15 @@ const IMPORTANCE_LEVELS: ImportanceLevel[] = [
   "high",
   "critical",
 ];
-const NATIVE_IMPORT_MODES = ["off", "review"] as const;
+const NATIVE_IMPORT_MODES = ["off", "review", "smart"] as const;
 
 const DEFAULT_MIN_CONFIDENCE = 0.6;
 const DEFAULT_MIN_IMPORTANCE: ImportanceLevel = "low";
-const DEFAULT_MAX_MEMORIES_PER_DAY = 20;
+const DEFAULT_MAX_MEMORIES_PER_DAY = 50;
 const MAX_MEMORIES_PER_DAY_CEILING = 500;
+const DEFAULT_SOURCE_TRUST = 0.8;
+const DEFAULT_AUTO_APPROVE_TRUST = 0.7;
+const DEFAULT_REVIEW_TRUST = 0.45;
 
 export function defaultWearableCleanupSettings(): WearableCleanupSettings {
   return {
@@ -49,11 +52,14 @@ export function defaultWearableCleanupSettings(): WearableCleanupSettings {
 export function defaultWearableSourceSettings(): WearableSourceSettings {
   return {
     enabled: false,
-    memoryMode: "review",
+    memoryMode: "smart",
+    sourceTrust: DEFAULT_SOURCE_TRUST,
+    autoApproveTrust: DEFAULT_AUTO_APPROVE_TRUST,
+    reviewTrust: DEFAULT_REVIEW_TRUST,
     minConfidence: DEFAULT_MIN_CONFIDENCE,
     minImportance: DEFAULT_MIN_IMPORTANCE,
     maxMemoriesPerDay: DEFAULT_MAX_MEMORIES_PER_DAY,
-    importNativeMemories: "off",
+    importNativeMemories: "smart",
     cleanup: defaultWearableCleanupSettings(),
   };
 }
@@ -63,8 +69,8 @@ export function defaultWearablesConfig(): WearablesConfig {
     enabled: false,
     redactionEnabled: true,
     redactionPatterns: [],
-    offTheRecordEnabled: false,
-    digestEnabled: false,
+    offTheRecordEnabled: true,
+    digestEnabled: true,
     corrections: [],
     sources: {},
   };
@@ -203,6 +209,29 @@ function parseSourceSettings(
   // the schema minimum (CLAUDE.md rule 45).
   const maxMemoriesPerDay = maxPerDayRaw ?? defaults.maxMemoriesPerDay;
 
+  const parseUnitInterval = (value: unknown, name: string, fallback: number): number => {
+    if (value === undefined) return fallback;
+    const coerced = coerceNumber(value);
+    if (coerced === undefined || coerced < 0 || coerced > 1) {
+      throw new Error(
+        `${keyPath}.${name} must be a number between 0 and 1 (got ${JSON.stringify(value)})`,
+      );
+    }
+    return coerced;
+  };
+  const sourceTrust = parseUnitInterval(raw.sourceTrust, "sourceTrust", defaults.sourceTrust);
+  const autoApproveTrust = parseUnitInterval(
+    raw.autoApproveTrust,
+    "autoApproveTrust",
+    defaults.autoApproveTrust,
+  );
+  const reviewTrust = parseUnitInterval(raw.reviewTrust, "reviewTrust", defaults.reviewTrust);
+  if (reviewTrust >= autoApproveTrust) {
+    throw new Error(
+      `${keyPath}.reviewTrust (${reviewTrust}) must be below autoApproveTrust (${autoApproveTrust})`,
+    );
+  }
+
   const rawCleanup =
     raw.cleanup === undefined ? {} : requireObject(raw.cleanup, `${keyPath}.cleanup`);
   const cleanup: WearableCleanupSettings = {
@@ -240,6 +269,9 @@ function parseSourceSettings(
       MEMORY_MODES,
       defaults.memoryMode,
     ),
+    sourceTrust,
+    autoApproveTrust,
+    reviewTrust,
     minConfidence,
     minImportance: parseEnum(
       raw.minImportance,