@remnic/core 9.3.727 → 9.3.729

package/dist/transfer/types.d.ts

@@ -313,6 +313,7 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     }>;
 }, "strip", z.ZodTypeAny, {
+    id: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
@@ -320,7 +321,6 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     };
     schemaVersion: string;
-    id: string;
     version: string;
     description: string;
     parentCapsule: string | null;
@@ -334,6 +334,7 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         directAnswerEnabled: boolean;
     };
 }, {
+    id: string;
     includes: {
         procedural: boolean;
         taxonomy: boolean;
@@ -341,7 +342,6 @@ declare const CapsuleBlockSchema: z.ZodObject<{
         peerProfiles: boolean;
     };
     schemaVersion: string;
-    id: string;
     version: string;
     description: string;
     parentCapsule: string | null;
@@ -464,6 +464,7 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         }>;
     }, "strip", z.ZodTypeAny, {
+        id: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
@@ -471,7 +472,6 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         };
         schemaVersion: string;
-        id: string;
         version: string;
         description: string;
         parentCapsule: string | null;
@@ -485,6 +485,7 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             directAnswerEnabled: boolean;
         };
     }, {
+        id: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
@@ -492,7 +493,6 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         };
         schemaVersion: string;
-        id: string;
         version: string;
         description: string;
         parentCapsule: string | null;
@@ -518,6 +518,7 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        id: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
@@ -525,7 +526,6 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         };
         schemaVersion: string;
-        id: string;
         version: string;
         description: string;
         parentCapsule: string | null;
@@ -551,6 +551,7 @@ declare const ExportManifestV2Schema: z.ZodObject<{
     pluginVersion: string;
     includesTranscripts: boolean;
     capsule: {
+        id: string;
         includes: {
             procedural: boolean;
             taxonomy: boolean;
@@ -558,7 +559,6 @@ declare const ExportManifestV2Schema: z.ZodObject<{
             peerProfiles: boolean;
         };
         schemaVersion: string;
-        id: string;
         version: string;
         description: string;
         parentCapsule: string | null;
@@ -683,6 +683,7 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             }>;
         }, "strip", z.ZodTypeAny, {
+            id: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
@@ -690,7 +691,6 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             };
             schemaVersion: string;
-            id: string;
             version: string;
             description: string;
             parentCapsule: string | null;
@@ -704,6 +704,7 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 directAnswerEnabled: boolean;
             };
         }, {
+            id: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
@@ -711,7 +712,6 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             };
             schemaVersion: string;
-            id: string;
             version: string;
             description: string;
             parentCapsule: string | null;
@@ -737,6 +737,7 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            id: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
@@ -744,7 +745,6 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             };
             schemaVersion: string;
-            id: string;
             version: string;
             description: string;
             parentCapsule: string | null;
@@ -770,6 +770,7 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            id: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
@@ -777,7 +778,6 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             };
             schemaVersion: string;
-            id: string;
             version: string;
             description: string;
             parentCapsule: string | null;
@@ -819,6 +819,7 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            id: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
@@ -826,7 +827,6 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             };
             schemaVersion: string;
-            id: string;
             version: string;
             description: string;
             parentCapsule: string | null;
@@ -858,6 +858,7 @@ declare const ExportBundleV2Schema: z.ZodObject<{
         pluginVersion: string;
         includesTranscripts: boolean;
         capsule: {
+            id: string;
             includes: {
                 procedural: boolean;
                 taxonomy: boolean;
@@ -865,7 +866,6 @@ declare const ExportBundleV2Schema: z.ZodObject<{
                 peerProfiles: boolean;
             };
             schemaVersion: string;
-            id: string;
             version: string;
             description: string;
             parentCapsule: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.727",
+  "version": "9.3.729",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -2990,7 +2990,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.3.727"
+    "@remnic/coding-graph": "^9.3.729"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-service.ts

@@ -5,6 +5,7 @@ import { readdirSync, unlinkSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { ZodError } from "zod";
 import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-idempotency.js";
+import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
 import { AccessAuditAdapter, type AccessAuditConfig, type AccessAuditResult } from "./access-audit.js";
 import type { AnomalyDetectorResult } from "./recall-audit-anomaly.js";
 import { resolveGitContext } from "./coding/git-context.js";
@@ -8187,7 +8188,7 @@ export class EngramAccessService {
 
   get embeddingLookupFactoryRef(): (storage: import("./storage.js").StorageManager) => SemanticDedupLookup | undefined {
     return (storage) => {
-      if (!this.orchestrator.config.embeddingFallbackEnabled) return undefined;
+      if (!resolveMemoryLifecycleCapabilities(this.orchestrator.config).embeddingFallback) return undefined;
       return async (content: string, limit: number) => {
         try {
           return await this.orchestrator.semanticDedupLookup(content, limit, storage);

package/src/capabilities.test.ts

@@ -153,6 +153,12 @@ import {
   type GraphConstructionCapabilitySet,
 } from "./capabilities.js";
 
+import {
+  resolveMemoryLifecycleCapabilities,
+  type MemoryLifecycleCapabilitySet,
+} from "./capabilities.js";
+
+
 const GRAPH_FIELD_TO_FLAG: Record<keyof GraphConstructionCapabilitySet, string> = {
   entityGraph: "entityGraphEnabled",
   timeGraph: "timeGraphEnabled",
@@ -306,3 +312,152 @@ test("resolveGraphConstructionCapabilities matches pre-migration config reads (p
     );
   }
 });
+
+
+// ---------------------------------------------------------------------------
+// MemoryLifecycleCapabilitySet — gate-parity tests (issue #1523 batch 3).
+//
+// Same invariant as the sets above: every caps field must project from its
+// `<field>Enabled` config flag, so a future edit that maps a field to the wrong
+// flag fails loudly here. All ten flags are required booleans on PluginConfig
+// (defaults resolved at the parse boundary), so the projection is a pure
+// passthrough — no optional-default variants needed.
+//
+// Parity contract: a caps-resolved run and a config-derived run MUST produce
+// identical boolean values for every gate — on AND off.
+// ---------------------------------------------------------------------------
+
+const LIFECYCLE_FIELD_TO_FLAG: Record<keyof MemoryLifecycleCapabilitySet, string> = {
+  temporalSupersession: "temporalSupersessionEnabled",
+  temporalMemoryTree: "temporalMemoryTreeEnabled",
+  lifecyclePolicy: "lifecyclePolicyEnabled",
+  lifecycleFilterStale: "lifecycleFilterStaleEnabled",
+  lifecycleMetrics: "lifecycleMetricsEnabled",
+  extractionScopeClassification: "extractionScopeClassificationEnabled",
+  extractionJudge: "extractionJudgeEnabled",
+  extractionDedupe: "extractionDedupeEnabled",
+  extractionTelemetryPrefilter: "extractionTelemetryPrefilterEnabled",
+  extractionJudgeTelemetry: "extractionJudgeTelemetryEnabled",
+  embeddingFallback: "embeddingFallbackEnabled",
+};
+
+const LIFECYCLE_FIELDS = Object.keys(LIFECYCLE_FIELD_TO_FLAG) as Array<
+  keyof MemoryLifecycleCapabilitySet
+>;
+
+test("resolveMemoryLifecycleCapabilities projects every field from its flag (true variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(LIFECYCLE_FIELD_TO_FLAG)) overrides[flag] = true;
+  const config = parseConfig(overrides);
+  const caps = resolveMemoryLifecycleCapabilities(config);
+
+  for (const field of LIFECYCLE_FIELDS) {
+    const flag = LIFECYCLE_FIELD_TO_FLAG[field];
+    assert.equal(
+      caps[field],
+      (config as unknown as Record<string, boolean>)[flag],
+      `caps.${field} must equal config.${flag} (true variant)`,
+    );
+    assert.equal(caps[field], true, `caps.${field} should be true here`);
+  }
+});
+
+test("resolveMemoryLifecycleCapabilities projects every field from its flag (false variant)", () => {
+  const overrides: Record<string, boolean> = {};
+  for (const flag of Object.values(LIFECYCLE_FIELD_TO_FLAG)) overrides[flag] = false;
+  const config = parseConfig(overrides);
+  const caps = resolveMemoryLifecycleCapabilities(config);
+
+  for (const field of LIFECYCLE_FIELDS) {
+    const flag = LIFECYCLE_FIELD_TO_FLAG[field];
+    assert.equal(
+      caps[field],
+      (config as unknown as Record<string, boolean>)[flag],
+      `caps.${field} must equal config.${flag} (false variant)`,
+    );
+    assert.equal(caps[field], false, `caps.${field} should be false here`);
+  }
+});
+
+test("resolveMemoryLifecycleCapabilities returns a frozen object", () => {
+  const config = parseConfig({});
+  const caps = resolveMemoryLifecycleCapabilities(config);
+  assert.equal(Object.isFrozen(caps), true);
+});
+
+test("resolveMemoryLifecycleCapabilities matches pre-migration config reads (parity contract)", () => {
+  // For representative on/off combinations, the caps-resolved values MUST be
+  // identical to what the old scattered `this.config.<flag>Enabled` reads
+  // produced. All ten flags used bare reads (no `!== false`/`=== true` at the
+  // call site that would change the value — the two sites that wrote
+  // `=== true` were redundant coercion on an already-boolean config field),
+  // so parity is a direct equality against the resolved config boolean.
+  const cases: Record<string, Record<string, boolean>> = {
+    "all-off": {
+      temporalSupersessionEnabled: false,
+      temporalMemoryTreeEnabled: false,
+      lifecyclePolicyEnabled: false,
+      lifecycleFilterStaleEnabled: false,
+      lifecycleMetricsEnabled: false,
+      extractionScopeClassificationEnabled: false,
+      extractionJudgeEnabled: false,
+      extractionDedupeEnabled: false,
+      extractionTelemetryPrefilterEnabled: false,
+      extractionJudgeTelemetryEnabled: false,
+      embeddingFallbackEnabled: false,
+    },
+    "all-on": {
+      temporalSupersessionEnabled: true,
+      temporalMemoryTreeEnabled: true,
+      lifecyclePolicyEnabled: true,
+      lifecycleFilterStaleEnabled: true,
+      lifecycleMetricsEnabled: true,
+      extractionScopeClassificationEnabled: true,
+      extractionJudgeEnabled: true,
+      extractionDedupeEnabled: true,
+      extractionTelemetryPrefilterEnabled: true,
+      extractionJudgeTelemetryEnabled: true,
+      embeddingFallbackEnabled: true,
+    },
+    "temporal-on-rest-off": {
+      temporalSupersessionEnabled: true,
+      temporalMemoryTreeEnabled: true,
+      lifecyclePolicyEnabled: false,
+      lifecycleFilterStaleEnabled: false,
+      lifecycleMetricsEnabled: false,
+      extractionScopeClassificationEnabled: false,
+      extractionJudgeEnabled: false,
+      extractionDedupeEnabled: false,
+      extractionTelemetryPrefilterEnabled: false,
+      extractionJudgeTelemetryEnabled: false,
+      embeddingFallbackEnabled: false,
+    },
+    "extraction-on-rest-off": {
+      temporalSupersessionEnabled: false,
+      temporalMemoryTreeEnabled: false,
+      lifecyclePolicyEnabled: false,
+      lifecycleFilterStaleEnabled: false,
+      lifecycleMetricsEnabled: false,
+      extractionScopeClassificationEnabled: true,
+      extractionJudgeEnabled: true,
+      extractionDedupeEnabled: true,
+      extractionTelemetryPrefilterEnabled: true,
+      extractionJudgeTelemetryEnabled: true,
+      embeddingFallbackEnabled: true,
+    },
+  };
+
+  for (const [label, overrides] of Object.entries(cases)) {
+    const config = parseConfig(overrides);
+    const caps = resolveMemoryLifecycleCapabilities(config);
+
+    for (const field of LIFECYCLE_FIELDS) {
+      const flag = LIFECYCLE_FIELD_TO_FLAG[field];
+      assert.equal(
+        caps[field],
+        (config as unknown as Record<string, boolean>)[flag],
+        `[${label}] caps.${field} must equal config.${flag}`,
+      );
+    }
+  }
+});

package/src/capabilities.ts

@@ -203,3 +203,94 @@ export function resolveAccessSetupCapabilities(
     recallAuditAnomalyDetection: config.recallAuditAnomalyDetectionEnabled === true,
   });
 }
+
+// ---------------------------------------------------------------------------
+// Memory-lifecycle capability set (issue #1523 batch 3).
+//
+// The flags below gate memory WRITE/EXTRACTION (extraction judge, scope
+// classification, dedupe, telemetry prefilter), temporal supersession of
+// stored facts, and the lifecycle policy pass (promotion / decay / stale
+// filtering). They are read on the persistExtraction write path, the recall
+// candidate-filter path, and the maintenance / lifecycle-pass path — so, like
+// the graph-construction set above, they get their own projection resolved
+// ONCE at each operation entry that reads them (never re-derived from raw
+// config mid-operation — the gate-divergence defect class #1523 targets).
+//
+// Every field projects from an already-resolved PluginConfig boolean (defaults
+// are applied at the config-parse boundary, rule 36), so the resolver is a
+// pure projection — no `!== false` / `=== true` re-coercion here.
+// ---------------------------------------------------------------------------
+
+/**
+ * Frozen projection of memory-lifecycle feature gates (issue #1523 batch 3).
+ *
+ * Resolved once per write / recall-filter / maintenance operation and threaded
+ * down. Composition lives ONLY in {@link resolveMemoryLifecycleCapabilities}.
+ */
+export interface MemoryLifecycleCapabilitySet {
+  /** `temporalSupersessionEnabled` — supersede stale structured facts on write, filter on recall. */
+  readonly temporalSupersession: boolean;
+  /** `temporalMemoryTreeEnabled` — temporal-memory-tree build + recall tier. */
+  readonly temporalMemoryTree: boolean;
+  /** `lifecyclePolicyEnabled` — lifecycle promotion / decay metadata pass. */
+  readonly lifecyclePolicy: boolean;
+  /** `lifecycleFilterStaleEnabled` — filter stale-lifecycle memories from recall. */
+  readonly lifecycleFilterStale: boolean;
+  /** `lifecycleMetricsEnabled` — emit lifecycle-pass metrics. */
+  readonly lifecycleMetrics: boolean;
+  /** `extractionScopeClassificationEnabled` — LLM classifies each fact's scope. */
+  readonly extractionScopeClassification: boolean;
+  /** `extractionJudgeEnabled` — LLM-as-judge fact-worthiness gate. */
+  readonly extractionJudge: boolean;
+  /** `extractionDedupeEnabled` — dedupe against recent extractions. */
+  readonly extractionDedupe: boolean;
+  /** `extractionTelemetryPrefilterEnabled` — skip mechanical-telemetry transcripts. */
+  readonly extractionTelemetryPrefilter: boolean;
+  /** `extractionJudgeTelemetryEnabled` — collect judge verdict telemetry. */
+  readonly extractionJudgeTelemetry: boolean;
+  /** `embeddingFallbackEnabled` — semantic-dedup / archive-search embedding fallback. */
+  readonly embeddingFallback: boolean;
+}
+
+/**
+ * Config projection consumed by {@link resolveMemoryLifecycleCapabilities}.
+ */
+export type MemoryLifecycleConfigProjection = Pick<
+  PluginConfig,
+  | "temporalSupersessionEnabled"
+  | "temporalMemoryTreeEnabled"
+  | "lifecyclePolicyEnabled"
+  | "lifecycleFilterStaleEnabled"
+  | "lifecycleMetricsEnabled"
+  | "extractionScopeClassificationEnabled"
+  | "extractionJudgeEnabled"
+  | "extractionDedupeEnabled"
+  | "extractionTelemetryPrefilterEnabled"
+  | "extractionJudgeTelemetryEnabled"
+  | "embeddingFallbackEnabled"
+>;
+
+/**
+ * Resolve the {@link MemoryLifecycleCapabilitySet} from parsed config.
+ *
+ * Call this ONCE per write / recall-filter / maintenance operation entry and
+ * thread the result down — exactly the pattern {@link resolveCapabilities}
+ * established for recall.
+ */
+export function resolveMemoryLifecycleCapabilities(
+  config: MemoryLifecycleConfigProjection,
+): MemoryLifecycleCapabilitySet {
+  return Object.freeze({
+    temporalSupersession: config.temporalSupersessionEnabled,
+    temporalMemoryTree: config.temporalMemoryTreeEnabled,
+    lifecyclePolicy: config.lifecyclePolicyEnabled,
+    lifecycleFilterStale: config.lifecycleFilterStaleEnabled,
+    lifecycleMetrics: config.lifecycleMetricsEnabled,
+    extractionScopeClassification: config.extractionScopeClassificationEnabled,
+    extractionJudge: config.extractionJudgeEnabled,
+    extractionDedupe: config.extractionDedupeEnabled,
+    extractionTelemetryPrefilter: config.extractionTelemetryPrefilterEnabled,
+    extractionJudgeTelemetry: config.extractionJudgeTelemetryEnabled,
+    embeddingFallback: config.embeddingFallbackEnabled,
+  });
+}

package/src/chat/chat-engine.test.ts

@@ -7,7 +7,7 @@
  */
 
 import { strict as assert } from "node:assert";
-import { mkdir, rm, readFile, utimes, unlink } from "node:fs/promises";
+import { mkdir, rm, readFile, utimes, unlink, appendFile } from "node:fs/promises";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { test } from "node:test";
@@ -22,6 +22,7 @@ import {
   sessionBelongsToPrincipal,
   chatSessionFile,
   cleanupExpiredChatSessions,
+  __resetTranscriptSeqForTest,
 } from "./chat-session.js";
 import type { ChatSessionState } from "./chat-types.js";
 import type { ChatToolExecutor } from "./chat-engine.js";
@@ -335,3 +336,40 @@ test("appendTranscriptEntry refuses to recreate a swept session (chat_session_ex
     /chat_session_expired/,
   );
 });
+
+
+test("loadChatSession raises the seq counter above the on-disk max on backward clock skew (issue #1718)", async () => {
+  const dir = await makeTempDir();
+  const session = await createChatSession(dir, { principal: "skew" });
+  // Simulate a previous process that ran with a forward-skewed clock: append a
+  // transcript line whose seq is far in the future relative to the current
+  // Date.now(). A later restart with a normal (or backward-stepped) clock must
+  // still issue seqs strictly greater than this persisted line.
+  const futureSeq = Date.now() + 10_000_000;
+  await appendFile(
+    chatSessionFile(dir, session.id),
+    JSON.stringify({
+      seq: futureSeq,
+      ts: new Date().toISOString(),
+      role: "user",
+      content: "future-dated line from a forward-skewed prior process",
+    }) + "\n",
+    "utf8",
+  );
+  // Simulate a process restart whose module-level counter starts below the
+  // persisted on-disk seq (the backward-clock-skew window).
+  __resetTranscriptSeqForTest();
+  // Resume the session: loadChatSession must raise the counter above the
+  // on-disk max so the next append is strictly greater, regardless of the
+  // current Date.now().
+  const loaded = await loadChatSession(dir, session.id);
+  assert.ok(loaded, "session must load");
+  const next = await appendTranscriptEntry(dir, session.id, {
+    role: "assistant",
+    content: "resumed after backward clock skew",
+  });
+  assert.ok(
+    next.seq > futureSeq,
+    `seq ${next.seq} must exceed the on-disk max ${futureSeq} after a backward clock skew (issue #1718)`,
+  );
+});

package/src/chat/chat-session.ts

@@ -50,8 +50,10 @@ export function chatSessionFile(memoryDir: string, chatSessionId: string): strin
  * incremented when two appends land in the same millisecond, so `seq` is
  * strictly increasing within a process (review thread: `Date.now()` alone is
  * not monotonic — same-ms entries would share a seq and break the SSE
- * reconnect dedup-by-seq contract). Across process restarts `Date.now()` is
- * already forward-moving, so no collision occurs in practice.
+ * reconnect dedup-by-seq contract). Across process restarts the counter is
+ * raised above the on-disk max by `loadChatSession` (issue #1718), so a
+ * backward clock step (NTP, VM migration, manual change) cannot re-seed it
+ * below lines already persisted for a resumed session.
  */
 let lastTranscriptSeq = 0;
 
@@ -61,6 +63,14 @@ function nextTranscriptSeq(): number {
   return lastTranscriptSeq;
 }
 
+/**
+ * Test-only: reset the module-level transcript seq counter so a regression
+ * test can deterministically simulate a fresh process restart (issue #1718).
+ */
+export function __resetTranscriptSeqForTest(): void {
+  lastTranscriptSeq = 0;
+}
+
 /**
  * Create a new chat session.  The session binds the caller's principal and
  * sessionKey at creation (rule 42); every tool call flows through
@@ -175,6 +185,19 @@ export async function loadChatSession(
       // tolerated, never crash the engine).
     }
   }
+  // Issue #1718 — backward-clock-skew robustness: raise the module-level seq
+  // counter so the next append is strictly greater than any line already on
+  // disk for this session, regardless of clock direction across restarts
+  // (NTP step, VM migration, manual change). Without this, a backward clock
+  // skew would re-seed the counter below the on-disk max and the SSE
+  // reconnect dedup-by-seq contract could drop freshly-appended entries as
+  // duplicates. The transcript is already fully parsed above, so this is a
+  // single pass over the in-memory array.
+  for (const e of transcript) {
+    if (typeof e.seq === "number" && e.seq + 1 > lastTranscriptSeq) {
+      lastTranscriptSeq = e.seq + 1;
+    }
+  }
   return {
     id: chatSessionId,
     principal,

package/src/cli.ts

@@ -4,6 +4,7 @@ import { access, lstat, readFile, readdir, realpath, unlink } from "node:fs/prom
 import { createHash } from "node:crypto";
 import type { Readable, Writable } from "node:stream";
 import type { Orchestrator } from "./orchestrator.js";
+import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
 import { ThreadingManager } from "./threading.js";
 import { utcDayRange } from "./transcript.js";
 import { runWearablesCliCommand } from "./wearables/cli.js";
@@ -3728,7 +3729,7 @@ export function registerCli(
           console.log("=== Extraction Judge Verdict Stats ===\n");
           console.log(`Total verdicts: ${stats.total}`);
           if (stats.total === 0) {
-            if (!orchestrator.config.extractionJudgeTelemetryEnabled) {
+            if (!resolveMemoryLifecycleCapabilities(orchestrator.config).extractionJudgeTelemetry) {
               console.log(
                 "\nNote: extractionJudgeTelemetryEnabled is OFF. Enable it in plugin config to collect verdict telemetry.",
               );
@@ -8541,7 +8542,7 @@ export function registerCli(
             config: orchestrator.config,
             memoryDir: orchestrator.config.memoryDir,
             embeddingLookupFactory: (storage) => {
-              if (!orchestrator.config.embeddingFallbackEnabled) return undefined;
+              if (!resolveMemoryLifecycleCapabilities(orchestrator.config).embeddingFallback) return undefined;
               return async (content: string, limit: number) => {
                 try {
                   return await orchestrator.semanticDedupLookup(content, limit, storage);

package/src/embedding-fallback.ts

@@ -1,6 +1,7 @@
 import path from "node:path";
 import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { log } from "./logger.js";
+import { resolveMemoryLifecycleCapabilities } from "./capabilities.js";
 import { readEnvVar } from "./runtime/env.js";
 import type { PluginConfig } from "./types.js";
 import {
@@ -397,7 +398,7 @@ export class EmbeddingFallback {
   private async resolveProvider(
     options: { includeHost?: boolean } = {},
   ): Promise<ProviderConfig | null> {
-    if (!this.config.embeddingFallbackEnabled) return null;
+    if (!resolveMemoryLifecycleCapabilities(this.config).embeddingFallback) return null;
 
     if (
       options.includeHost !== false &&