@remnic/core 9.39.0 → 9.41.0

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-export { aS as AccessTrackingEntry, a1 as ActiveRecallChatType, a5 as ActiveRecallModelFallbackPolicy, a3 as ActiveRecallPromptStyle, a2 as ActiveRecallQueryMode, a4 as ActiveRecallThinking, t as AgentAccessAuthToken, ck as AgentAccessHttpConfig, cl as AgentDefaultsConfig, cm as AgentPersona, A as AgentPersonaModelConfig, cn as BehaviorLoopAdjustment, r as BehaviorLoopPolicyState, co as BehaviorSignalDirection, a6 as BehaviorSignalEvent, cp as BehaviorSignalType, bb as BootstrapOptions, bc as BootstrapResult, g as BriefingActiveThread, cq as BriefingCalendarSourceError, bw as BriefingConfig, e as BriefingFocus, d as BriefingFollowup, bx as BriefingOpenCommitment, i as BriefingRecentEntity, h as BriefingResult, B as BriefingSections, by as BriefingWindow, cr as BufferEntryState, aN as BufferState, a7 as BufferSurpriseEvent, j as BufferTurn, f as CalendarEvent, C as CalendarSource, w as CaptureMode, cs as ChatConfig, m as Checkpoint, ct as CodexCliReasoningEffort, cu as CodexCompactionFlushMode, bB as CodexCompatConfig, cv as CodexConnectorConfig, b8 as CodingContext, cw as CodingGraphLspConfig, bk as CodingKnowledgeConfig, be as CodingModeConfig, cx as CompressionGuidelineActivationState, ad as CompressionGuidelineOptimizerActionSummary, ac as CompressionGuidelineOptimizerEventCounts, ae as CompressionGuidelineOptimizerRuleUpdate, cy as CompressionGuidelineOptimizerSourceWindow, ah as CompressionGuidelineOptimizerState, cz as ConfidenceTier, cA as ConsolidationAction, cB as ConsolidationItem, bd as ConsolidationObservation, K as ConsolidationResult, cC as ContradictionScanConfig, V as ConversationThread, cD as CronConversationRecallMode, cE as CronRecallMode, bC as DEFAULT_RECALL_DISCLOSURE, N as DaySummaryResult, cF as DreamingConfig, cG as DreamingNarrativePromptStyle, cH as DreamsDeepSleepConfig, cI as DreamsLightSleepConfig, D as DreamsPhase, cJ as DreamsPhaseStatus, cK as DreamsPhasesConfig, cL as DreamsRemConfig, a as DreamsRunResult, b9 as DreamsStatusResult, cM as EngramTraceEvent, aR as EntityActivityEntry, E as EntityFile, ai as EntityMention, aQ as EntityRelationship, aj as EntitySchemaDefinition, ak as EntitySchemaSectionDefinition, al as EntityStructuredSection, aL as EntityTimelineEntry, bE as ExtractedFact, cN as ExtractedProcedureStep, cO as ExtractedQuestion, cP as ExtractedReasoningTrace, cQ as ExtractedReasoningTraceStep, cR as ExtractedRelationship, $ as ExtractionFailureClass, cS as ExtractionPassSource, J as ExtractionResult, F as FaithfulnessFrontmatter, aP as FileHygieneConfig, G as GatewayConfig, cT as GitHubLiveConnectorConfig, cU as GmailLiveConnectorConfig, cV as GoogleDriveLiveConnectorConfig, cW as HeartbeatConfig, cX as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, a0 as ImportanceLevel, an as ImportanceScore, W as LifecycleState, L as LiveConnectorsConfig, cY as LlmTraceCallback, cZ as LlmTraceEvent, ap as MemoryActionEligibilityContext, bN as MemoryActionEligibilitySource, ag as MemoryActionEvent, c_ as MemoryActionOutcome, c$ as MemoryActionPolicyDecision, aq as MemoryActionPolicyResult, d0 as MemoryActionStatus, af as MemoryActionType, v as MemoryCategory, M as MemoryFile, l as MemoryFrontmatter, ao as MemoryIntent, z as MemoryLifecycleEvent, ar as MemoryLifecycleEventType, as as MemoryLifecycleStateSummary, aM as MemoryLink, d1 as MemoryLinkType, bO as MemoryObservation, d2 as MemoryOsPresetName, y as MemoryProjectionCurrentState, bP as MemoryScope, x as MemoryStatus, aT as MemorySummary, aO as MetaState, d3 as ModelApi, d4 as ModelDefinitionConfig, d5 as ModelProviderAuthMode, at as ModelProviderConfig, d6 as NamespacePolicy, au as NativeKnowledgeConfig, d7 as NativeKnowledgeFolderRuleConfig, d8 as NativeKnowledgeObsidianVaultConfig, d9 as NativeKnowledgeOpenClawWorkspaceConfig, da as NotionLiveConnectorConfig, P as PluginConfig, Y as PolicyClass, db as PrincipalFromSessionKeyMode, dc as PrincipalRule, dd as ProceduralConfig, am as ProvenanceConfig, O as ProvenanceSource, aA as QmdSearchExplain, Q as QmdSearchResult, de as QuestionEntry, bQ as RECALL_DISCLOSURE_LEVELS, df as ReasoningEffort, b as RecallDisclosure, dg as RecallPipelineConfig, R as RecallPlanMode, ba as RecallSectionConfig, c as RecallTierExplain, dh as RecallTraceEvent, di as RelevanceFeedback, ax as RetrievalTier, dj as SPECULATIVE_TTL_DAYS, dk as ScopeProfileAutoPromoteConfig, o as ScopeProfileConfig, p as ScopeProfileLayerId, q as ScopeProfilePromotionTarget, dl as ScopeProfileTeamProjectConfig, dm as ScopeTeamConfig, dn as ScoredEntity, s as SecretRef, dp as SemanticChunkingConfigShape, S as SessionObserverBandConfig, dq as SignalLevel, ay as SignalScanResult, dr as SlotBehaviorConfig, ds as SlotMismatchMode, n as SourceConnectorProvenance, az as TopicScore, T as TranscriptEntry, dt as TriggerMode, U as TrustWeights, X as VerificationState, du as confidenceTier, bY as isRecallDisclosure } from './types-5398p7Zm.js';
+export { aS as AccessTrackingEntry, a1 as ActiveRecallChatType, a5 as ActiveRecallModelFallbackPolicy, a3 as ActiveRecallPromptStyle, a2 as ActiveRecallQueryMode, a4 as ActiveRecallThinking, t as AgentAccessAuthToken, co as AgentAccessHttpConfig, cp as AgentDefaultsConfig, cq as AgentPersona, A as AgentPersonaModelConfig, cr as BehaviorLoopAdjustment, r as BehaviorLoopPolicyState, cs as BehaviorSignalDirection, a6 as BehaviorSignalEvent, ct as BehaviorSignalType, bb as BootstrapOptions, bc as BootstrapResult, g as BriefingActiveThread, cu as BriefingCalendarSourceError, bw as BriefingConfig, e as BriefingFocus, d as BriefingFollowup, bx as BriefingOpenCommitment, i as BriefingRecentEntity, h as BriefingResult, B as BriefingSections, by as BriefingWindow, cv as BufferEntryState, aO as BufferState, a7 as BufferSurpriseEvent, j as BufferTurn, f as CalendarEvent, C as CalendarSource, w as CaptureMode, cw as ChatConfig, m as Checkpoint, cx as CodexCliReasoningEffort, cy as CodexCompactionFlushMode, bB as CodexCompatConfig, cz as CodexConnectorConfig, b8 as CodingContext, cA as CodingGraphLspConfig, bk as CodingKnowledgeConfig, be as CodingModeConfig, cB as CompressionGuidelineActivationState, ad as CompressionGuidelineOptimizerActionSummary, ac as CompressionGuidelineOptimizerEventCounts, ae as CompressionGuidelineOptimizerRuleUpdate, cC as CompressionGuidelineOptimizerSourceWindow, ah as CompressionGuidelineOptimizerState, cD as ConfidenceTier, cE as ConsolidationAction, cF as ConsolidationItem, bd as ConsolidationObservation, K as ConsolidationResult, cG as ContradictionScanConfig, V as ConversationThread, cH as CronConversationRecallMode, cI as CronRecallMode, bC as DEFAULT_RECALL_DISCLOSURE, N as DaySummaryResult, cJ as DreamingConfig, cK as DreamingNarrativePromptStyle, cL as DreamsDeepSleepConfig, cM as DreamsLightSleepConfig, D as DreamsPhase, cN as DreamsPhaseStatus, cO as DreamsPhasesConfig, cP as DreamsRemConfig, a as DreamsRunResult, b9 as DreamsStatusResult, cQ as EngramTraceEvent, aR as EntityActivityEntry, E as EntityFile, ai as EntityMention, aQ as EntityRelationship, aj as EntitySchemaDefinition, ak as EntitySchemaSectionDefinition, al as EntityStructuredSection, aM as EntityTimelineEntry, bE as ExtractedFact, cR as ExtractedProcedureStep, cS as ExtractedQuestion, cT as ExtractedReasoningTrace, cU as ExtractedReasoningTraceStep, cV as ExtractedRelationship, $ as ExtractionFailureClass, cW as ExtractionPassSource, J as ExtractionResult, F as FaithfulnessFrontmatter, aP as FileHygieneConfig, G as GatewayConfig, cX as GitHubLiveConnectorConfig, cY as GmailLiveConnectorConfig, cZ as GoogleDriveLiveConnectorConfig, c_ as HeartbeatConfig, c$ as HeartbeatDetectionMode, H as HourlySummary, I as IdentityInjectionMode, a0 as ImportanceLevel, an as ImportanceScore, W as LifecycleState, L as LiveConnectorsConfig, d0 as LlmTraceCallback, d1 as LlmTraceEvent, ap as MemoryActionEligibilityContext, bN as MemoryActionEligibilitySource, ag as MemoryActionEvent, d2 as MemoryActionOutcome, d3 as MemoryActionPolicyDecision, aq as MemoryActionPolicyResult, d4 as MemoryActionStatus, af as MemoryActionType, v as MemoryCategory, M as MemoryFile, l as MemoryFrontmatter, ao as MemoryIntent, z as MemoryLifecycleEvent, ar as MemoryLifecycleEventType, as as MemoryLifecycleStateSummary, aN as MemoryLink, d5 as MemoryLinkType, bO as MemoryObservation, d6 as MemoryOsPresetName, y as MemoryProjectionCurrentState, bP as MemoryScope, x as MemoryStatus, aT as MemorySummary, aw as MetaState, d7 as ModelApi, d8 as ModelDefinitionConfig, d9 as ModelProviderAuthMode, at as ModelProviderConfig, da as NamespacePolicy, au as NativeKnowledgeConfig, db as NativeKnowledgeFolderRuleConfig, dc as NativeKnowledgeObsidianVaultConfig, dd as NativeKnowledgeOpenClawWorkspaceConfig, de as NotionLiveConnectorConfig, P as PluginConfig, Y as PolicyClass, df as PrincipalFromSessionKeyMode, dg as PrincipalRule, dh as ProceduralConfig, am as ProvenanceConfig, O as ProvenanceSource, aB as QmdSearchExplain, Q as QmdSearchResult, di as QuestionEntry, bQ as RECALL_DISCLOSURE_LEVELS, dj as ReasoningEffort, b as RecallDisclosure, dk as RecallPipelineConfig, R as RecallPlanMode, ba as RecallSectionConfig, c as RecallTierExplain, dl as RecallTraceEvent, dm as RelevanceFeedback, ay as RetrievalTier, dn as SPECULATIVE_TTL_DAYS, dp as ScopeProfileAutoPromoteConfig, o as ScopeProfileConfig, p as ScopeProfileLayerId, q as ScopeProfilePromotionTarget, dq as ScopeProfileTeamProjectConfig, dr as ScopeTeamConfig, ds as ScoredEntity, s as SecretRef, dt as SemanticChunkingConfigShape, S as SessionObserverBandConfig, du as SignalLevel, az as SignalScanResult, dv as SlotBehaviorConfig, dw as SlotMismatchMode, n as SourceConnectorProvenance, aA as TopicScore, T as TranscriptEntry, dx as TriggerMode, U as TrustWeights, X as VerificationState, dy as confidenceTier, bY as isRecallDisclosure } from './types-CqWwMPr_.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 export { ContinuityImprovementLoop, ContinuityIncidentCloseInput, ContinuityIncidentOpenInput, ContinuityIncidentRecord, ContinuityIncidentState, ContinuityLoopCadence, ContinuityLoopReviewInput, ContinuityLoopStatus, ContinuityLoopUpsertInput } from './types-continuity.js';

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-HXDWZFNP.js";
+} from "./chunk-GSL47NPM.js";
 import "./chunk-PZ5AY32C.js";
 export {
   DEFAULT_RECALL_DISCLOSURE,

package/dist/utility-runtime.d.ts

@@ -1,5 +1,5 @@
 import { TierRoutingPolicy } from './tier-routing.js';
-import './types-5398p7Zm.js';
+import './types-CqWwMPr_.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/dist/verified-recall.js

@@ -1,14 +1,14 @@
 import {
   compareVerifiedEpisodeResults,
   searchVerifiedEpisodes
-} from "./chunk-VGK33D3K.js";
+} from "./chunk-OEXKYYVH.js";
 import "./chunk-B7RWBZXW.js";
-import "./chunk-ENLZOWYK.js";
+import "./chunk-ZERSIPFC.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-ENTCVTQR.js";
 import "./chunk-WIPEXG6R.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-HXDWZFNP.js";
+import "./chunk-GSL47NPM.js";
 import "./chunk-4VXGRIH6.js";
 import "./chunk-EGGE52UU.js";
 import "./chunk-ZA53AZND.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { v as MemoryCategory } from './types-5398p7Zm.js';
+import { v as MemoryCategory } from './types-CqWwMPr_.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './operator-doctor-types.js';

package/package.json

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

package/src/access-http.test.ts

@@ -61,6 +61,66 @@ test("parseConfig validates agentAccessHttp.port bounds and CLI strings", () =>
   }
 });
 
+test("HTTP liveness is authenticated and does not run detailed health diagnostics", async () => {
+  let healthCalls = 0;
+  const service = {
+    health: async () => {
+      healthCalls += 1;
+      return new Promise<never>(() => {});
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const denied = await fetch(`http://127.0.0.1:${status.port}/engram/v1/live`);
+    assert.equal(denied.status, 401);
+
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/live`, {
+      headers: { authorization: "Bearer test-token" },
+      signal: AbortSignal.timeout(500),
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), { ok: true, ready: true });
+    assert.equal(healthCalls, 0);
+  } finally {
+    await server.stop();
+  }
+});
+
+test("HTTP detailed health route still runs service diagnostics", async () => {
+  let healthCalls = 0;
+  const service = {
+    health: async () => {
+      healthCalls += 1;
+      return { ok: true, diagnostics: "complete" };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramAccessHttpServer({
+    service,
+    port: 0,
+    authToken: "test-token",
+    adminConsoleEnabled: false,
+  });
+
+  const status = await server.start();
+  try {
+    const response = await fetch(`http://127.0.0.1:${status.port}/engram/v1/health`, {
+      headers: { authorization: "Bearer test-token" },
+    });
+    assert.equal(response.status, 200);
+    assert.deepEqual(await response.json(), { ok: true, diagnostics: "complete" });
+    assert.equal(healthCalls, 1);
+  } finally {
+    await server.stop();
+  }
+});
+
 test("HTTP memory browse rejects malformed pagination and sort query values", async () => {
   const calls: unknown[] = [];
   const service = {
@@ -1933,7 +1993,7 @@ test("HTTP externalRequestHandler runs pre-auth, can end responses, and falls th
         oldestBufferedTurnAgeMs: null,
         degraded: false,
         degradedReason: null,
-        watermarkScope: "root-store",
+        watermarkScope: "aggregate",
       },
       corpus: [],
       corpusComplete: true,
@@ -2060,7 +2120,7 @@ test("HTTP authTokenEntriesGetter is authoritative: scope policy binds connector
         oldestBufferedTurnAgeMs: null,
         degraded: false,
         degradedReason: null,
-        watermarkScope: "root-store",
+        watermarkScope: "aggregate",
       },
       corpus: [],
       corpusComplete: true,

package/src/access-http.ts

@@ -806,7 +806,7 @@ export class EngramAccessHttpServer {
       return;
     }
 
-    if (req.method === "GET" && pathname === "/engram/v1/health") {
+    if (req.method === "GET" && (pathname === "/engram/v1/live" || pathname === "/engram/v1/health")) {
       const { ready, warmupAttempts, lastError } = this.readiness();
       if (!ready) {
         this.respondJson(res, 503, {
@@ -888,6 +888,7 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    if (req.method === "GET" && pathname === "/engram/v1/live") return this.respondJson(res, 200, { ok: true, ready: true });
     if (req.method === "GET" && pathname === "/engram/v1/health") {
       const { degraded, warmupAttempts, lastError } = this.readiness();
       const health = await this.service.health();

package/src/access-service-health.test.ts

@@ -1,11 +1,12 @@
 import assert from "node:assert/strict";
-import { mkdtemp, rm } from "node:fs/promises";
+import { mkdir, mkdtemp, rm } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
 import { EngramAccessService } from "./access-service.js";
 import { parseConfig } from "./config.js";
+import { TOKEN_CAPABILITIES_VERSION, tokenCapabilityStore } from "./access-token-capabilities.js";
 import { namespaceCollectionName } from "./namespaces/search.js";
 import type { Orchestrator } from "./orchestrator.js";
 import type { SearchBackend } from "./search/port.js";
@@ -548,16 +549,27 @@ test("health reports extraction liveness ok when the buffer is empty (nothing to
     assert.equal(health.extraction.degraded, false);
     assert.equal(health.extraction.bufferedSessionCount, 0);
     assert.equal(health.extraction.lastExtractionAt, oldTs);
+    const scopedHealth = await tokenCapabilityStore.run(
+      { version: TOKEN_CAPABILITIES_VERSION, namespaces: ["default"] },
+      () => service.health(),
+    );
+    assert.equal(scopedHealth.extraction.degraded, health.extraction.degraded);
+    assert.equal(scopedHealth.extraction.lastExtractionAt, null);
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
 
-test("health returns the same daemon-global extraction verdict for every namespace (issue #2151)", async () => {
+test("health returns one daemon-global aggregate extraction verdict for every namespace", async () => {
   const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-health-liveness-ns-"));
   try {
-    const rootTs = new Date().toISOString(); // fresh daemon-global watermark
-    const staleTs = new Date(Date.now() - 7_200_000).toISOString(); // 2h old
+    const namespaceDirs: Record<string, string> = {
+      fresh: path.join(memoryDir, "namespaces", "fresh"),
+      stale: path.join(memoryDir, "namespaces", "stale"),
+    };
+    await Promise.all(Object.values(namespaceDirs).map((dir) => mkdir(dir, { recursive: true })));
+    const freshTs = new Date().toISOString();
+    const staleTs = new Date(Date.now() - 7_200_000).toISOString();
     const config = parseConfig({
       memoryDir,
       qmdEnabled: false,
@@ -565,20 +577,25 @@ test("health returns the same daemon-global extraction verdict for every namespa
       defaultNamespace: "default",
       extractionLiveness: { staleWindowMs: 3_600_000 },
     });
-    // Per-namespace stores return DIVERGING watermarks (fresh vs 2h stale vs
-    // never), but the global buffer is shared and the watermark must be sourced
-    // from the root store. Pre-fix, the extraction verdict tracked the
-    // namespace argument; post-fix it is identical for every namespace.
-    const perNamespaceMeta: Record<string, string | null> = { fresh: rootTs, stale: staleTs };
+    const perNamespaceMeta: Record<string, string | null> = {
+      default: staleTs,
+      fresh: freshTs,
+      stale: staleTs,
+    };
     const service = new EngramAccessService({
       config,
       qmd: makeQmd({}),
       buffer: {
-        getBufferSnapshot: async () => ({ bufferedSessionCount: 3, pendingTurnCount: 12, oldestTurnTimestamp: staleTs }),
+        getBufferSnapshot: async () => ({
+          bufferedSessionCount: 3,
+          pendingTurnCount: 12,
+          oldestTurnTimestamp: staleTs,
+        }),
       },
       storage: {
+        dir: memoryDir,
         loadMeta: async () => ({
-          lastExtractionAt: rootTs,
+          lastExtractionAt: staleTs,
           extractionCount: 4,
           lastConsolidationAt: null,
           totalMemories: 0,
@@ -586,10 +603,11 @@ test("health returns the same daemon-global extraction verdict for every namespa
         }),
       },
       async getStorage(namespace?: string) {
+        const resolved = namespace ?? "default";
         return {
-          dir: memoryDir,
+          dir: namespaceDirs[resolved] ?? memoryDir,
           loadMeta: async () => ({
-            lastExtractionAt: namespace ? perNamespaceMeta[namespace] ?? null : staleTs,
+            lastExtractionAt: perNamespaceMeta[resolved] ?? null,
             extractionCount: 4,
             lastConsolidationAt: null,
             totalMemories: 0,
@@ -599,19 +617,23 @@ test("health returns the same daemon-global extraction verdict for every namespa
       },
     } as unknown as Orchestrator);
 
+    await service.health();
+    const serviceWithCache = service as unknown as {
+      corpusWatermarkCache: { whenIdle(): Promise<void> };
+    };
+    await serviceWithCache.corpusWatermarkCache.whenIdle();
+
     const fresh = (await service.health("fresh")).extraction;
     const stale = (await service.health("stale")).extraction;
     const def = (await service.health()).extraction;
-    // The namespace-governed fields must not vary with the namespace argument
-    // (oldestBufferedTurnAgeMs is time-derived and intentionally excluded).
     assert.equal(stale.degraded, fresh.degraded, "degraded must not vary by namespace");
     assert.equal(def.degraded, fresh.degraded, "default health matches namespaced health");
     assert.equal(stale.lastExtractionAt, fresh.lastExtractionAt, "watermark must not vary by namespace");
     assert.equal(def.lastExtractionAt, fresh.lastExtractionAt);
     assert.equal(stale.degradedReason, fresh.degradedReason);
-    // Sourced from the fresh root watermark → healthy despite stale per-namespace stores.
     assert.equal(fresh.degraded, false);
-    assert.equal(fresh.lastExtractionAt, rootTs);
+    assert.equal(fresh.lastExtractionAt, freshTs);
+    assert.equal(fresh.watermarkScope, "aggregate");
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }

package/src/access-service.ts

@@ -7,6 +7,7 @@ import { createHash } from "node:crypto";
 import { ZodError } from "zod";
 import { AccessIdempotencyStore, hashAccessIdempotencyPayload } from "./access-idempotency.js";
 import { computeExtractionLivenessStatus, ExtractionLivenessWarnThrottle } from "./extraction-liveness.js";
+import { readAggregateExtractionWatermark } from "./orchestration/extraction-watermark.js";
 import { enforceNamespaceAllowList, tokenCapabilityStore } from "./access-token-capabilities.js";
 import {
   recordCitationUsage as recordCitationUsageForAccess,
@@ -2369,10 +2370,31 @@ export class EngramAccessService {
     const storage = await this.orchestrator.getStorage(resolvedNamespace);
     const searchBackend = this.orchestrator.config.searchBackend ?? "qmd";
     const qmdEnabled = resolveQmdCapabilities(this.orchestrator.config).qmd === true;
-    const extraction = await computeExtractionLivenessStatus(this.orchestrator, this.extractionLivenessWarn);
+    const caps = tokenCapabilityStore.getStore();
+    const extractionWatermark = await readAggregateExtractionWatermark({
+      config: this.orchestrator.config,
+      rootStorage: this.orchestrator.storage,
+      storageForNamespace: (candidate) => this.orchestrator.getStorage(candidate),
+      rootsCache: this.corpusWatermarkCache,
+    });
+    const extraction = await computeExtractionLivenessStatus(
+      this.orchestrator,
+      extractionWatermark,
+      caps?.namespaces !== undefined ? undefined : this.extractionLivenessWarn,
+    );
+    const visibleExtraction =
+      caps?.namespaces !== undefined
+        ? {
+            ...extraction,
+            lastExtractionAt: null,
+            bufferedSessionCount: 0,
+            pendingTurnCount: 0,
+            oldestBufferedTurnAgeMs: null,
+            degradedReason: extraction.degraded ? "daemon extraction pipeline degraded" : null,
+          }
+        : extraction;
     // ONE call: the corpus array and the flag describing it must not come from
     // two independently-cached scans (round 8, codex P1).
-    const caps = tokenCapabilityStore.getStore();
     const corpusCensus = await computeServiceCorpusCensus(this.orchestrator, {
       cache: this.corpusWatermarkCache, caps });
     let projectionAvailable = false;
@@ -2398,7 +2420,7 @@ export class EngramAccessService {
       ),
       nativeKnowledgeEnabled: this.orchestrator.config.nativeKnowledge?.enabled === true,
       projectionAvailable,
-      extraction,
+      extraction: visibleExtraction,
       corpus: corpusCensus.watermarks,
       // Describes THIS response's array (round 8): a separate scan could report
       // complete while the shipped corpus was partial, and peers trust it.

package/src/access-surface-catalog.test.ts

@@ -566,6 +566,7 @@ test("HTTP handler source routes match the catalog (static completeness)", () =>
 
   const INFRA = [
     /^\/engram\/v1\/health$/,
+    /^\/engram\/v1\/live$/,
     /^\/engram\/v1\/capabilities$/,
     /^\/engram\/v1\/authorization$/,
     /^\/engram\/v1\/admin\//,

package/src/cli.ts

@@ -31,6 +31,7 @@ import { chunkContent } from "./chunking.js";
 import { rescoreMemoryImportance } from "./importance.js";
 import { renderQmdBacklogStatus } from "./qmd-status.js";
 import { renderExtractionLivenessStats } from "./extraction-liveness.js";
+import { readAggregateExtractionWatermark } from "./orchestration/extraction-watermark.js";
 import { exportJsonBundle } from "./transfer/export-json.js";
 import { exportMarkdownBundle } from "./transfer/export-md.js";
 import { backupMemoryDir } from "./transfer/backup.js";
@@ -3653,9 +3654,7 @@ export function registerCli(
         .command("stats")
         .description("Show memory system statistics")
         .action(async () => {
-          // Ensure QMD is probed before checking availability
           await orchestrator.qmd.probe();
-
           const memories = await orchestrator.storage.readAllMemories();
           const entities = await orchestrator.storage.readEntities();
           const profile = await orchestrator.storage.readProfile();
@@ -3664,7 +3663,8 @@ export function registerCli(
           console.log(`Total memories: ${memories.length}`);
           console.log(`Total entities: ${entities.length}`);
           console.log(`Profile size: ${profile.length} chars`);
-          for (const line of await renderExtractionLivenessStats(orchestrator)) console.log(line);
+          const extractionWatermark = await readAggregateExtractionWatermark({ config: orchestrator.config, rootStorage: orchestrator.storage, storageForNamespace: (ns) => orchestrator.getStorage(ns) });
+          for (const line of await renderExtractionLivenessStats(orchestrator, extractionWatermark)) console.log(line);
           console.log(`QMD: ${orchestrator.qmd.isAvailable() ? "available" : "not available"}`);
           for (const line of await renderQmdBacklogStatus(orchestrator.qmd, orchestrator.config.qmdEmbeddingBacklogThreshold)) console.log(line);
 

package/src/config.test.ts

@@ -2412,3 +2412,7 @@ test("parseConfig forwards bridgeMode as a raw passthrough (validation is in res
   // silently defaulting to embedded.
   assert.equal(parseConfig({ bridgeMode: true }).bridgeMode, "true");
 });
+
+test("parseConfig leaves the OpenClaw delegate timeout to the plugin parser", () => {
+  assert.equal("bridgeHealthTimeoutMs" in parseConfig({ bridgeHealthTimeoutMs: 7_500 }), false);
+});

package/src/config.ts

@@ -2318,11 +2318,7 @@ export function parseConfig(
         ? "resolved-only"
         : "default-remote",
     activeRecallPersistTranscripts: cfg.activeRecallPersistTranscripts === true,
-    activeRecallTranscriptDir:
-      typeof cfg.activeRecallTranscriptDir === "string" &&
-      cfg.activeRecallTranscriptDir.trim().length > 0
-        ? cfg.activeRecallTranscriptDir.trim()
-        : "active-recall",
+    activeRecallTranscriptDir: parseOptionalNonEmptyString(cfg.activeRecallTranscriptDir) ?? "active-recall",
     activeRecallEntityGraphDepth:
       typeof cfg.activeRecallEntityGraphDepth === "number"
         ? Math.min(3, Math.max(0, Math.floor(cfg.activeRecallEntityGraphDepth)))

package/src/corpus-watermark.test.ts

@@ -780,6 +780,22 @@ test("finding round-7: namespace enumeration is cached (resolved once per TTL, s
   assert.equal(resolveCalls, 2, "re-enumerated once the TTL elapsed");
 });
 
+test("computeServiceCorpusCensus returns incomplete when roots refresh error is set in cache", async () => {
+  const cache = new CorpusWatermarkCache();
+  const host = {
+    config: parseConfig({ namespacesEnabled: true }),
+    getStorage: async () => ({ readAllMemories: async () => [] } as unknown as StorageManager),
+  };
+  const failingResolve = async (): Promise<CorpusNamespaceRoot[]> => {
+    throw new Error("disk unreadable");
+  };
+  cache.getResolvedRootsStatus(failingResolve);
+  await cache.whenIdle();
+  const census = await computeServiceCorpusCensus(host, { cache });
+  assert.equal(census.complete, false);
+  assert.deepEqual(census.watermarks, []);
+});
+
 test("finding round-9: background refresh scans are bounded to maxConcurrentRefreshes", async () => {
   const cache = new CorpusWatermarkCache({ maxConcurrentRefreshes: 2 });
   let active = 0;

package/src/corpus-watermark.ts

@@ -312,9 +312,13 @@ export interface CorpusNamespaceRoot {
  */
 export async function resolveCorpusNamespaceRoots(options: {
   config: PluginConfig;
+  propagateDiscoveryErrors?: boolean;
 }): Promise<CorpusNamespaceRoot[]> {
   const { config } = options;
-  const configDriven = await listNamespaces({ config });
+  const configDriven = await listNamespaces({
+    config,
+    propagateDiscoveryErrors: options.propagateDiscoveryErrors,
+  });
   // Default namespace first so it wins the representative label when several
   // configured names collapse onto one root (namespaces disabled → memoryDir).
   const ordered = [
@@ -376,6 +380,7 @@ export class CorpusWatermarkCache {
   private readonly clock: () => number;
   private rootsEntry: { value: CorpusNamespaceRoot[]; expiresAt: number } | undefined;
   private rootsInFlight: Promise<void> | undefined;
+  private rootsRefreshError: unknown;
   private readonly queued = new Map<string, () => void>();
   private activeRefreshes = 0;
   private readonly maxConcurrentRefreshes: number;
@@ -444,9 +449,12 @@ export class CorpusWatermarkCache {
       this.rootsInFlight = compute()
         .then((value) => {
           this.rootsEntry = { value, expiresAt: this.clock() + this.ttlMs };
+          this.rootsRefreshError = undefined;
         })
-        .catch(() => {
-          // Enumeration failed: keep serving any stale roots; retry next probe.
+        .catch((error: unknown) => {
+          this.rootsRefreshError = error;
+          // Keep serving any stale roots; callers that require completeness
+          // inspect the refresh status before trusting them.
         })
         .finally(() => {
           this.rootsInFlight = undefined;
@@ -454,6 +462,14 @@ export class CorpusWatermarkCache {
     }
     return this.rootsEntry?.value;
   }
+
+  getResolvedRootsStatus(compute: () => Promise<CorpusNamespaceRoot[]>): {
+    roots: CorpusNamespaceRoot[] | undefined;
+    refreshError: unknown;
+  } {
+    const roots = this.getResolvedRoots(compute);
+    return { roots, refreshError: this.rootsRefreshError };
+  }
   /** Await every background refresh — in-flight AND queued (issue #2156 round-9) —
    *  plus any roots refresh (shutdown / deterministic tests). */
   async whenIdle(): Promise<void> {
@@ -518,10 +534,17 @@ export async function computeServiceCorpusCensus(
 ): Promise<{ watermarks: CorpusWatermark[]; complete: boolean }> {
   let roots: CorpusNamespaceRoot[] | undefined;
   if (options.cache) {
-    roots = options.cache.getResolvedRoots(() => resolveCorpusNamespaceRoots({ config: host.config }));
+    const { roots: cachedRoots, refreshError } = options.cache.getResolvedRootsStatus(() =>
+      resolveCorpusNamespaceRoots({ config: host.config, propagateDiscoveryErrors: true }),
+    );
+    if (refreshError !== undefined) return { watermarks: [], complete: false };
+    roots = cachedRoots;
   } else {
     try {
-      roots = await resolveCorpusNamespaceRoots({ config: host.config });
+      roots = await resolveCorpusNamespaceRoots({
+        config: host.config,
+        propagateDiscoveryErrors: true,
+      });
     } catch {
       return { watermarks: [], complete: false }; // never enumerated — not an empty corpus
     }