@remnic/core 9.3.652 → 9.3.654

package/dist/types.d.ts

@@ -1,3 +1,3 @@
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
-export { y as AccessTrackingEntry, A as ActiveRecallChatType, d as ActiveRecallModelFallbackPolicy, b as ActiveRecallPromptStyle, a as ActiveRecallQueryMode, c as ActiveRecallThinking, a7 as AgentAccessAuthToken, b2 as AgentAccessHttpConfig, b3 as AgentDefaultsConfig, b4 as AgentPersona, f as AgentPersonaModelConfig, b5 as BehaviorLoopAdjustment, e as BehaviorLoopPolicyState, b6 as BehaviorSignalDirection, B as BehaviorSignalEvent, b7 as BehaviorSignalType, aH as BootstrapOptions, aI as BootstrapResult, V as BriefingActiveThread, b8 as BriefingCalendarSourceError, aO as BriefingConfig, Q as BriefingFocus, O as BriefingFollowup, aP as BriefingOpenCommitment, X as BriefingRecentEntity, W as BriefingResult, N as BriefingSections, aQ as BriefingWindow, b9 as BufferEntryState, k as BufferState, o as BufferSurpriseEvent, Y as BufferTurn, U as CalendarEvent, S as CalendarSource, ba as CaptureMode, $ as Checkpoint, bb as CodexCliReasoningEffort, bc as CodexCompactionFlushMode, aR as CodexCompatConfig, bd as CodexConnectorConfig, aG as CodingContext, aL as CodingModeConfig, be as CompressionGuidelineActivationState, a9 as CompressionGuidelineOptimizerActionSummary, a8 as CompressionGuidelineOptimizerEventCounts, aa as CompressionGuidelineOptimizerRuleUpdate, bf as CompressionGuidelineOptimizerSourceWindow, C as CompressionGuidelineOptimizerState, bg as ConfidenceTier, bh as ConsolidationAction, bi as ConsolidationItem, aJ as ConsolidationObservation, ag as ConsolidationResult, s as ContinuityImprovementLoop, r as ContinuityIncidentCloseInput, p as ContinuityIncidentOpenInput, q as ContinuityIncidentRecord, bj as ContinuityIncidentState, bk as ContinuityLoopCadence, u as ContinuityLoopReviewInput, bl as ContinuityLoopStatus, t as ContinuityLoopUpsertInput, bm as ContradictionScanConfig, as as ConversationThread, bn as CronConversationRecallMode, bo as CronRecallMode, aS as DEFAULT_RECALL_DISCLOSURE, ah as DaySummaryResult, bp as DreamingConfig, bq as DreamingNarrativePromptStyle, br as DreamsDeepSleepConfig, bs as DreamsLightSleepConfig, au as DreamsPhase, bt as DreamsPhaseStatus, bu as DreamsPhasesConfig, bv as DreamsRemConfig, av as DreamsRunResult, at as DreamsStatusResult, bw as EngramTraceEvent, w as EntityActivityEntry, x as EntityFile, ac as EntityMention, v as EntityRelationship, ad as EntitySchemaDefinition, ae as EntitySchemaSectionDefinition, E as EntityStructuredSection, aK as EntityTimelineEntry, aT as ExtractedFact, bx as ExtractedProcedureStep, by as ExtractedQuestion, bz as ExtractedReasoningTrace, bA as ExtractedReasoningTraceStep, bB as ExtractedRelationship, bC as ExtractionPassSource, af as ExtractionResult, F as FileHygieneConfig, G as GatewayConfig, bD as GitHubLiveConnectorConfig, bE as GmailLiveConnectorConfig, bF as GoogleDriveLiveConnectorConfig, bG as HeartbeatConfig, bH as HeartbeatDetectionMode, a0 as HourlySummary, J as IdentityInjectionMode, a5 as ImportanceLevel, I as ImportanceScore, a2 as LifecycleState, L as LiveConnectorsConfig, bI as LlmTraceCallback, bJ as LlmTraceEvent, ak as MemoryActionEligibilityContext, aU as MemoryActionEligibilitySource, m as MemoryActionEvent, bK as MemoryActionOutcome, bL as MemoryActionPolicyDecision, al as MemoryActionPolicyResult, bM as MemoryActionStatus, ab as MemoryActionType, M as MemoryCategory, g as MemoryFile, j as MemoryFrontmatter, ai as MemoryIntent, n as MemoryLifecycleEvent, am as MemoryLifecycleEventType, an as MemoryLifecycleStateSummary, i as MemoryLink, bN as MemoryLinkType, aV as MemoryObservation, bO as MemoryOsPresetName, z as MemoryProjectionCurrentState, aW as MemoryScope, h as MemoryStatus, D as MemorySummary, l as MetaState, bP as ModelApi, bQ as ModelDefinitionConfig, bR as ModelProviderAuthMode, ao as ModelProviderConfig, bS as NamespacePolicy, ap as NativeKnowledgeConfig, bT as NativeKnowledgeFolderRuleConfig, bU as NativeKnowledgeObsidianVaultConfig, bV as NativeKnowledgeOpenClawWorkspaceConfig, bW as NotionLiveConnectorConfig, P as PluginConfig, a4 as PolicyClass, bX as PrincipalFromSessionKeyMode, bY as PrincipalRule, bZ as ProceduralConfig, aj as QmdSearchExplain, Z as QmdSearchResult, b_ as QuestionEntry, aX as RECALL_DISCLOSURE_LEVELS, b$ as ReasoningEffort, K as RecallDisclosure, c0 as RecallPipelineConfig, H as RecallPlanMode, c1 as RecallSectionConfig, R as RecallTierExplain, c2 as RecallTraceEvent, c3 as RelevanceFeedback, aq as RetrievalTier, c4 as SPECULATIVE_TTL_DAYS, c5 as ScoredEntity, a6 as SecretRef, c6 as SemanticChunkingConfigShape, a1 as SessionObserverBandConfig, c7 as SignalLevel, ar as SignalScanResult, c8 as SlotBehaviorConfig, c9 as SlotMismatchMode, T as TopicScore, _ as TranscriptEntry, ca as TriggerMode, a3 as VerificationState, cb as confidenceTier, b1 as isRecallDisclosure } from './types-D8yUmSik.js';
+export { y as AccessTrackingEntry, A as ActiveRecallChatType, d as ActiveRecallModelFallbackPolicy, b as ActiveRecallPromptStyle, a as ActiveRecallQueryMode, c as ActiveRecallThinking, a7 as AgentAccessAuthToken, b2 as AgentAccessHttpConfig, b3 as AgentDefaultsConfig, b4 as AgentPersona, f as AgentPersonaModelConfig, b5 as BehaviorLoopAdjustment, e as BehaviorLoopPolicyState, b6 as BehaviorSignalDirection, B as BehaviorSignalEvent, b7 as BehaviorSignalType, aH as BootstrapOptions, aI as BootstrapResult, V as BriefingActiveThread, b8 as BriefingCalendarSourceError, aO as BriefingConfig, Q as BriefingFocus, O as BriefingFollowup, aP as BriefingOpenCommitment, X as BriefingRecentEntity, W as BriefingResult, N as BriefingSections, aQ as BriefingWindow, b9 as BufferEntryState, k as BufferState, o as BufferSurpriseEvent, Y as BufferTurn, U as CalendarEvent, S as CalendarSource, ba as CaptureMode, $ as Checkpoint, bb as CodexCliReasoningEffort, bc as CodexCompactionFlushMode, aR as CodexCompatConfig, bd as CodexConnectorConfig, aG as CodingContext, aL as CodingModeConfig, be as CompressionGuidelineActivationState, a9 as CompressionGuidelineOptimizerActionSummary, a8 as CompressionGuidelineOptimizerEventCounts, aa as CompressionGuidelineOptimizerRuleUpdate, bf as CompressionGuidelineOptimizerSourceWindow, C as CompressionGuidelineOptimizerState, bg as ConfidenceTier, bh as ConsolidationAction, bi as ConsolidationItem, aJ as ConsolidationObservation, ag as ConsolidationResult, s as ContinuityImprovementLoop, r as ContinuityIncidentCloseInput, p as ContinuityIncidentOpenInput, q as ContinuityIncidentRecord, bj as ContinuityIncidentState, bk as ContinuityLoopCadence, u as ContinuityLoopReviewInput, bl as ContinuityLoopStatus, t as ContinuityLoopUpsertInput, bm as ContradictionScanConfig, as as ConversationThread, bn as CronConversationRecallMode, bo as CronRecallMode, aS as DEFAULT_RECALL_DISCLOSURE, ah as DaySummaryResult, bp as DreamingConfig, bq as DreamingNarrativePromptStyle, br as DreamsDeepSleepConfig, bs as DreamsLightSleepConfig, au as DreamsPhase, bt as DreamsPhaseStatus, bu as DreamsPhasesConfig, bv as DreamsRemConfig, av as DreamsRunResult, at as DreamsStatusResult, bw as EngramTraceEvent, w as EntityActivityEntry, x as EntityFile, ac as EntityMention, v as EntityRelationship, ad as EntitySchemaDefinition, ae as EntitySchemaSectionDefinition, E as EntityStructuredSection, aK as EntityTimelineEntry, aT as ExtractedFact, bx as ExtractedProcedureStep, by as ExtractedQuestion, bz as ExtractedReasoningTrace, bA as ExtractedReasoningTraceStep, bB as ExtractedRelationship, bC as ExtractionPassSource, af as ExtractionResult, F as FileHygieneConfig, G as GatewayConfig, bD as GitHubLiveConnectorConfig, bE as GmailLiveConnectorConfig, bF as GoogleDriveLiveConnectorConfig, bG as HeartbeatConfig, bH as HeartbeatDetectionMode, a0 as HourlySummary, J as IdentityInjectionMode, a5 as ImportanceLevel, I as ImportanceScore, a2 as LifecycleState, L as LiveConnectorsConfig, bI as LlmTraceCallback, bJ as LlmTraceEvent, ak as MemoryActionEligibilityContext, aU as MemoryActionEligibilitySource, m as MemoryActionEvent, bK as MemoryActionOutcome, bL as MemoryActionPolicyDecision, al as MemoryActionPolicyResult, bM as MemoryActionStatus, ab as MemoryActionType, M as MemoryCategory, g as MemoryFile, j as MemoryFrontmatter, ai as MemoryIntent, n as MemoryLifecycleEvent, am as MemoryLifecycleEventType, an as MemoryLifecycleStateSummary, i as MemoryLink, bN as MemoryLinkType, aV as MemoryObservation, bO as MemoryOsPresetName, z as MemoryProjectionCurrentState, aW as MemoryScope, h as MemoryStatus, D as MemorySummary, l as MetaState, bP as ModelApi, bQ as ModelDefinitionConfig, bR as ModelProviderAuthMode, ao as ModelProviderConfig, bS as NamespacePolicy, ap as NativeKnowledgeConfig, bT as NativeKnowledgeFolderRuleConfig, bU as NativeKnowledgeObsidianVaultConfig, bV as NativeKnowledgeOpenClawWorkspaceConfig, bW as NotionLiveConnectorConfig, P as PluginConfig, a4 as PolicyClass, bX as PrincipalFromSessionKeyMode, bY as PrincipalRule, bZ as ProceduralConfig, aj as QmdSearchExplain, Z as QmdSearchResult, b_ as QuestionEntry, aX as RECALL_DISCLOSURE_LEVELS, b$ as ReasoningEffort, K as RecallDisclosure, c0 as RecallPipelineConfig, H as RecallPlanMode, c1 as RecallSectionConfig, R as RecallTierExplain, c2 as RecallTraceEvent, c3 as RelevanceFeedback, aq as RetrievalTier, c4 as SPECULATIVE_TTL_DAYS, c5 as ScoredEntity, a6 as SecretRef, c6 as SemanticChunkingConfigShape, a1 as SessionObserverBandConfig, c7 as SignalLevel, ar as SignalScanResult, c8 as SlotBehaviorConfig, c9 as SlotMismatchMode, T as TopicScore, _ as TranscriptEntry, ca as TriggerMode, a3 as VerificationState, cb as confidenceTier, b1 as isRecallDisclosure } from './types-BgChEr0M.js';

package/dist/types.js

@@ -4,7 +4,7 @@ import {
   SPECULATIVE_TTL_DAYS,
   confidenceTier,
   isRecallDisclosure
-} from "./chunk-C43KEWEV.js";
+} from "./chunk-NE2JBMLN.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-D8yUmSik.js';
+import './types-BgChEr0M.js';
 import './types-ByK7T3L6.js';
 import './index-DJ9QWMw-.js';
 import './lifecycle.js';

package/dist/verified-recall.js

@@ -1,12 +1,12 @@
 import {
   searchVerifiedEpisodes
-} from "./chunk-JF7SFXTG.js";
+} from "./chunk-QKK64Z6M.js";
 import "./chunk-HQ6NIBL6.js";
-import "./chunk-Y7NWBBHV.js";
+import "./chunk-6CVI6BP6.js";
 import "./chunk-M7XQSUBB.js";
 import "./chunk-5UZXUTVO.js";
 import "./chunk-J6A3CX5N.js";
-import "./chunk-C43KEWEV.js";
+import "./chunk-NE2JBMLN.js";
 import "./chunk-CPPS65WS.js";
 import "./chunk-RULE4VG5.js";
 import "./chunk-SCU65EZI.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.3.652",
+  "version": "9.3.654",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",

package/src/access-http.ts

@@ -1692,6 +1692,13 @@ export class EngramAccessHttpServer {
           const resolved = await this.service.getWritableStorageForNamespace(namespace, principal);
           return resolved.storage;
         },
+        // Catalog write touch (issue #1499 sweep): a contradiction merge writes a
+        // new memory directly to the resolved namespace storage, bypassing the
+        // extraction write path. Record it so QMD maintenance / writtenSince
+        // don't miss the write. Best-effort and failure-tolerant.
+        onMergedMemoryWritten: (namespace, storageDir) => {
+          this.service.recordCatalogWrite(namespace, storageDir);
+        },
       });
       this.respondJson(res, 200, result);
       return;

package/src/access-mcp.test.ts

@@ -371,11 +371,80 @@ test("MCP capsule tools tolerate client-injected cwd/projectTag (#1434)", async
   }
 });
 
+test("MCP capsule list tolerates client-injected sessionKey (#1513)", async () => {
+  let received: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    capsuleList: async (args: Record<string, unknown>) => {
+      received = args;
+      return { capsules: [] };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const response = await server.handleRequest(
+    makeToolRequest("engram.capsule_list", {
+      namespace: "team",
+      sessionKey: "pi-injected-session",
+      cwd: "/x",
+      projectTag: "t",
+    }),
+  );
+
+  assert.deepEqual(received, {
+    namespace: "team",
+    principal: undefined,
+  });
+  assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
+test("MCP capsule list derives namespace principal from client-injected sessionKey (#1513)", async () => {
+  let received: Record<string, unknown> | undefined;
+  const service = {
+    ...makeMockService(),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-mcp-capsule-list-session-principal",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      principalFromSessionKeyMode: "map",
+      principalFromSessionKeyRules: [{ match: "pi-session", principal: "pi-agent" }],
+      namespacePolicies: [
+        { name: "team", readPrincipals: ["pi-agent"], writePrincipals: [] },
+      ],
+    }),
+    capsuleList: async (args: Record<string, unknown>) => {
+      received = args;
+      return { capsules: [] };
+    },
+  } as unknown as EngramAccessService;
+  const server = new EngramMcpServer(service);
+
+  const response = await server.handleRequest(
+    makeToolRequest("engram.capsule_list", {
+      namespace: "team",
+      sessionKey: "pi-session",
+    }),
+  );
+
+  assert.deepEqual(received, {
+    namespace: "team",
+    principal: "pi-agent",
+  });
+  assert.equal((response as Record<string, unknown> & { result?: { isError?: boolean } }).result?.isError, false);
+});
+
 test("MCP session override is injected only into tools that accept sessionKey", async () => {
   let capsuleListArgs: Record<string, unknown> | undefined;
   let observeArgs: Record<string, unknown> | undefined;
   const service = {
     ...makeMockService(),
+    configRef: parseConfig({
+      memoryDir: "/tmp/remnic-mcp-session-override-test",
+      namespacesEnabled: true,
+      defaultNamespace: "default",
+      principalFromSessionKeyMode: "map",
+      principalFromSessionKeyRules: [{ match: "adapter-session", principal: "adapter-agent" }],
+    }),
     capsuleList: async (args: Record<string, unknown>) => {
       capsuleListArgs = args;
       return { capsules: [] };
@@ -400,7 +469,7 @@ test("MCP session override is injected only into tools that accept sessionKey",
 
   assert.deepEqual(capsuleListArgs, {
     namespace: undefined,
-    principal: undefined,
+    principal: "adapter-agent",
   });
   assert.deepEqual(observeArgs, {
     sessionKey: "adapter-session",

package/src/access-mcp.ts

@@ -20,6 +20,7 @@ import { validateBriefingFormat } from "./briefing.js";
 import { buildCitationGuidance, type CitationMetadata } from "./citations.js";
 import { projectTagProjectId } from "./coding/coding-namespace.js";
 import { expandTildePath } from "./utils/path.js";
+import { resolvePrincipal } from "./namespaces/principal.js";
 import {
   REMNIC_CHATGPT_MEMORY_INSPECTOR_MIME_TYPE,
   REMNIC_CHATGPT_MEMORY_INSPECTOR_TOOL,
@@ -155,7 +156,7 @@ const STRICT_MCP_SCHEMA_KEYS: Partial<Record<SchemaName, readonly string[]>> = {
     "projectTag",
   ],
   capsuleImport: ["archivePath", "namespace", "mode", "passphrase", "cwd", "projectTag"],
-  capsuleList: ["namespace", "cwd", "projectTag"],
+  capsuleList: ["namespace", "sessionKey", "cwd", "projectTag"],
 };
 
 // Shared JSON-schema fragments for the client-injected git/project context
@@ -852,6 +853,10 @@ export class EngramMcpServer {
           type: "object",
           properties: {
             namespace: { type: "string" },
+            sessionKey: {
+              type: "string",
+              description: "Optional session key used to derive namespace principal when no trusted transport principal is present.",
+            },
             ...MCP_GIT_CONTEXT_SCHEMA_PROPS_IGNORED,
           },
           additionalProperties: false,
@@ -2694,9 +2699,14 @@ export class EngramMcpServer {
       }
       case "engram.capsule_list": {
         const body: CapsuleListRequest = parseMcpRequest("capsuleList", args);
+        const requestPrincipal =
+          effectivePrincipal ??
+          (body.sessionKey && this.service.configRef
+            ? resolvePrincipal(body.sessionKey, this.service.configRef)
+            : undefined);
         return this.service.capsuleList({
           namespace: body.namespace,
-          principal: effectivePrincipal,
+          principal: requestPrincipal,
         });
       }
       case "engram.memory_governance_run":
@@ -3210,6 +3220,13 @@ export class EngramMcpServer {
             const resolved = await this.service.getWritableStorageForNamespace(namespace, effectivePrincipal);
             return resolved.storage;
           },
+          // Catalog write touch (issue #1499 sweep): a contradiction merge writes
+          // a new memory directly to the resolved namespace storage, bypassing the
+          // extraction write path. Record it so QMD maintenance / writtenSince
+          // don't miss the write. Best-effort and failure-tolerant.
+          onMergedMemoryWritten: (namespace, storageDir) => {
+            this.service.recordCatalogWrite(namespace, storageDir);
+          },
         });
       }
       case "engram.contradiction_scan_run":

package/src/access-schema.ts

@@ -410,6 +410,7 @@ export const capsuleImportRequestSchema = z
 export const capsuleListRequestSchema = z
   .object({
     namespace: namespaceSchema,
+    sessionKey: sessionKeySchema,
   });
 
 // ---------------------------------------------------------------------------

package/src/access-service.ts

@@ -7348,6 +7348,18 @@ export class EngramAccessService {
     return this.orchestrator.storage;
   }
 
+  /**
+   * Best-effort catalog write touch delegate (issue #1499 sweep). HTTP/MCP
+   * surfaces resolve a per-namespace storage and write through it directly (e.g.
+   * a contradiction merge), bypassing the extraction write path that owns
+   * `markCatalogWrite`. They call this to record the write so a (possibly
+   * dynamic) namespace's `lastWriteAt` stays accurate and QMD maintenance does
+   * not miss it. Fire-and-forget and failure-tolerant on the orchestrator side.
+   */
+  recordCatalogWrite(namespace?: string, storageDir?: string): void {
+    this.orchestrator.recordCatalogWrite(namespace, storageDir);
+  }
+
   get configRef(): PluginConfig {
     return this.orchestrator.config;
   }

package/src/briefing.test.ts

@@ -16,6 +16,7 @@ import {
   focusMatchesMemory,
   buildActiveThreads,
   buildBriefing,
+  buildChainFollowupGenerator,
   BRIEFING_FOLLOWUP_DEFAULT_MODEL,
 } from "./briefing.js";
 import type {
@@ -976,6 +977,75 @@ test("buildBriefing: unrelated LLM errors still produce generic message (no fals
   );
 });
 
+test("buildChainFollowupGenerator accepts markdown-fenced followup JSON", async () => {
+  const generator = buildChainFollowupGenerator({
+    chatCompletion: async () => ({
+      content: [
+        "```json",
+        "{",
+        '  "followups": [',
+        '    { "text": "Check the launch plan", "rationale": "Open commitment found" }',
+        "  ]",
+        "}",
+        "```",
+      ].join("\n"),
+    }),
+  });
+
+  const followups = await generator({
+    sections: {
+      activeThreads: [],
+      recentEntities: [],
+      openCommitments: [{ id: "commit-1", kind: "commitment", text: "Finish launch plan" }],
+      suggestedFollowups: [],
+    },
+    windowLabel: "today",
+    maxFollowups: 3,
+  });
+
+  assert.deepEqual(followups, [
+    {
+      text: "Check the launch plan",
+      rationale: "Open commitment found",
+    },
+  ]);
+});
+
+test("buildChainFollowupGenerator skips parseable non-followup JSON candidates", async () => {
+  const generator = buildChainFollowupGenerator({
+    chatCompletion: async () => ({
+      content: [
+        '{ "metadata": "not followups" }',
+        "```json",
+        "{",
+        '  "followups": [',
+        '    { "text": "Review the launch plan", "rationale": "Actual follow-up block" }',
+        "  ]",
+        "}",
+        "```",
+      ].join("\n"),
+    }),
+  });
+
+  const followups = await generator({
+    sections: {
+      activeThreads: [],
+      recentEntities: [],
+      openCommitments: [{ id: "commit-1", kind: "commitment", text: "Finish launch plan" }],
+      suggestedFollowups: [],
+    },
+    windowLabel: "today",
+    maxFollowups: 3,
+  });
+
+  assert.deepEqual(followups, [
+    {
+      text: "Review the launch plan",
+      rationale: "Actual follow-up block",
+    },
+  ]);
+});
+
 // ──────────────────────────────────────────────────────────────────────────
 // Round 8 Finding UXE4: buildActiveThreads must recompute reason from newer memory
 // ──────────────────────────────────────────────────────────────────────────

package/src/briefing.ts

@@ -1298,27 +1298,37 @@ function parseFollowupResponse(raw: string, max: number): BriefingFollowup[] {
   // JSON.parse throws on invalid JSON — let the caller catch it so the outer
   // try/catch in buildBriefing can set followupsUnavailableReason rather than
   // silently returning an empty array that masks the parse failure.
-  const parsed = JSON.parse(raw) as unknown;
-  if (!parsed || typeof parsed !== "object") {
-    throw new Error(`LLM returned non-object JSON: ${typeof parsed}`);
-  }
-  const arr = (parsed as { followups?: unknown }).followups;
-  if (!Array.isArray(arr)) {
-    throw new Error(`LLM response missing "followups" array`);
-  }
-  const out: BriefingFollowup[] = [];
-  for (const entry of arr) {
-    if (!entry || typeof entry !== "object") continue;
-    const text = (entry as Record<string, unknown>).text;
-    if (typeof text !== "string" || text.trim().length === 0) continue;
-    const rationale = (entry as Record<string, unknown>).rationale;
-    out.push({
-      text: text.trim(),
-      rationale: typeof rationale === "string" ? rationale.trim() : undefined,
-    });
-    if (out.length >= max) break;
+  const candidates = extractJsonCandidates(raw);
+  let lastError: unknown;
+  for (const candidate of candidates) {
+    try {
+      const parsed = JSON.parse(candidate) as unknown;
+      if (!parsed || typeof parsed !== "object") {
+        throw new Error(`LLM returned non-object JSON: ${typeof parsed}`);
+      }
+      const arr = (parsed as { followups?: unknown }).followups;
+      if (!Array.isArray(arr)) {
+        throw new Error(`LLM response missing "followups" array`);
+      }
+      const out: BriefingFollowup[] = [];
+      for (const entry of arr) {
+        if (!entry || typeof entry !== "object") continue;
+        const text = (entry as Record<string, unknown>).text;
+        if (typeof text !== "string" || text.trim().length === 0) continue;
+        const rationale = (entry as Record<string, unknown>).rationale;
+        out.push({
+          text: text.trim(),
+          rationale: typeof rationale === "string" ? rationale.trim() : undefined,
+        });
+        if (out.length >= max) break;
+      }
+      return out;
+    } catch (err) {
+      lastError = err;
+    }
   }
-  return out;
+  if (lastError) throw lastError;
+  throw new Error("LLM response contained no JSON candidates");
 }
 
 function stringifyError(err: unknown): string {

package/src/cli.ts

@@ -4155,6 +4155,103 @@ export function registerCli(
           console.log("\nOK");
         });
 
+      namespacesCmd
+        .command("rebuild")
+        .description(
+          "Rebuild the namespace catalog from disk (issue #1499). Scans configured + dynamic namespace roots safely and rewrites <memoryDir>/state/namespaces.jsonl",
+        )
+        .option("--dry-run", "Show the rebuilt catalog without writing it")
+        .option("--apply", "Write the rebuilt catalog to disk")
+        .option("--json", "Emit the rebuild result as JSON")
+        .action(async (optionsRaw: unknown) => {
+          const options =
+            optionsRaw && typeof optionsRaw === "object"
+              ? (optionsRaw as { dryRun?: boolean; apply?: boolean; json?: boolean })
+              : {};
+          // Default to a non-destructive dry run unless --apply is given.
+          // Reject contradictory flags rather than silently choosing one.
+          if (options.dryRun === true && options.apply === true) {
+            throw new Error("Pass only one of --dry-run or --apply, not both.");
+          }
+          const dryRun = options.apply !== true;
+
+          if (!orchestrator.namespaceCatalog.enabled) {
+            const note =
+              "Namespace catalog is inert: it only runs when namespacesEnabled is true and namespaceCatalogEnabled is not false.";
+            if (options.json === true) {
+              // Include `applied: false` so the inert JSON payload carries the SAME
+              // shape as the enabled path (cursor Low — NFDBM). An inert catalog
+              // rewrote nothing, so a `--apply` did NOT apply; automation that keys
+              // on `applied` must not misread a missing field as a completed rebuild.
+              console.log(
+                JSON.stringify(
+                  { dryRun, enabled: false, applied: false, records: [], skipped: [], note },
+                  null,
+                  2,
+                ),
+              );
+            } else {
+              console.log(note);
+            }
+            // Exit-code parity with the enabled path (cursor Medium — NFb5W): an
+            // inert catalog rewrote NOTHING, so a `--apply` (dryRun=false) did NOT
+            // apply. The enabled path sets `exitCode = 1` whenever a non-dry-run
+            // rebuild reports `applied: false`; an inert `--apply` is exactly that
+            // case, so exit-code-only automation must see a non-zero exit rather
+            // than read a no-op apply as a completed rebuild. A `--dry-run` (or the
+            // default dry run) inert call stays exit 0 — it never promised to write.
+            if (!dryRun) {
+              process.exitCode = 1;
+            }
+            return;
+          }
+
+          const result = await orchestrator.namespaceCatalog.rebuildFromDisk({ dryRun });
+
+          if (options.json === true) {
+            console.log(JSON.stringify({ enabled: true, ...result }, null, 2));
+            // Mirror the non-JSON failure signal (round 6, codex P2 — NEFoa): an
+            // `--apply` that could not acquire the lock returns `applied: false`
+            // and rewrote nothing, so automation must see a non-zero exit even in
+            // JSON mode rather than treating a no-op apply as a successful rebuild.
+            if (!dryRun && result.applied === false) {
+              process.exitCode = 1;
+            }
+            return;
+          }
+
+          console.log("=== Namespace Catalog Rebuild ===\n");
+          console.log(`mode: ${dryRun ? "dry-run" : "apply"}`);
+          console.log(`namespaces: ${result.records.length}`);
+          for (const record of result.records) {
+            console.log(
+              `${record.namespace}\n  kind: ${record.kind}\n  storage: ${record.storageDir}\n  discovered-by: ${record.discoveredBy}`,
+            );
+          }
+
+          if (result.skipped.length > 0) {
+            console.log("\nSkipped / ambiguous roots:");
+            for (const skip of result.skipped) {
+              console.log(`- ${skip.token} (${skip.reason})${skip.detail ? `: ${skip.detail}` : ""}`);
+            }
+          }
+
+          if (dryRun) {
+            console.log("\nDRY RUN");
+          } else if (result.applied) {
+            console.log("\nOK");
+          } else {
+            // An --apply that could not acquire the cross-process rebuild lock
+            // ran compute-only and did NOT rewrite the catalog (NBn3n/NBsGG).
+            // Report the non-mutation explicitly and exit non-zero so scripts
+            // and operators retry rather than assume the rebuild persisted.
+            console.log(
+              "\nNOT APPLIED: another rebuild holds the lock; the catalog was NOT rewritten. Retry shortly.",
+            );
+            process.exitCode = 1;
+          }
+        });
+
       cmd
         .command("export")
         .description("Export Remnic memory to JSON, Markdown bundle, or SQLite")
@@ -8858,6 +8955,13 @@ export function registerCli(
               }
               return orchestrator.getStorageForNamespace(requested || orchestrator.config.defaultNamespace);
             },
+            // Catalog write touch (issue #1499 sweep): a contradiction merge can
+            // write a new memory to a dynamic namespace via the CLI resolve path,
+            // bypassing the extraction write path. Record it so QMD maintenance /
+            // writtenSince don't miss the write. Best-effort and failure-tolerant.
+            onMergedMemoryWritten: (namespace, storageDir) => {
+              orchestrator.recordCatalogWrite(namespace, storageDir);
+            },
           });
           console.log(result.message);
           if (result.affectedIds.length > 0) {

package/src/config.test.ts

@@ -1291,3 +1291,43 @@ test("parseConfig rejects connectors.gmail.pollIntervalMs above maximum (25h)",
     /pollIntervalMs/,
   );
 });
+
+// ── issue #1499 / CLAUDE.md rule #36: namespaceCatalogEnabled opt-out coercion.
+// A string "false"/"0"/"no"/"off" from CLI/env/JSON config must disable the
+// catalog, not stay truthy. Defaults to enabled when absent/unrecognized.
+test("parseConfig namespaceCatalogEnabled defaults to true when absent", () => {
+  assert.equal(parseConfig({}).namespaceCatalogEnabled, true);
+});
+
+test('parseConfig namespaceCatalogEnabled="false" (string) → false (rule #36)', () => {
+  assert.equal(parseConfig({ namespaceCatalogEnabled: "false" }).namespaceCatalogEnabled, false);
+});
+
+test('parseConfig namespaceCatalogEnabled="0" (string) → false', () => {
+  assert.equal(parseConfig({ namespaceCatalogEnabled: "0" }).namespaceCatalogEnabled, false);
+});
+
+test('parseConfig namespaceCatalogEnabled="no"/"off" (strings) → false', () => {
+  assert.equal(parseConfig({ namespaceCatalogEnabled: "no" }).namespaceCatalogEnabled, false);
+  assert.equal(parseConfig({ namespaceCatalogEnabled: "off" }).namespaceCatalogEnabled, false);
+});
+
+test("parseConfig namespaceCatalogEnabled=false (boolean) → false", () => {
+  assert.equal(parseConfig({ namespaceCatalogEnabled: false }).namespaceCatalogEnabled, false);
+});
+
+test('parseConfig namespaceCatalogEnabled="true" (string) → true', () => {
+  assert.equal(parseConfig({ namespaceCatalogEnabled: "true" }).namespaceCatalogEnabled, true);
+});
+
+test("parseConfig namespaceCatalogEnabled present-but-unrecognized → throws (rule #51, codex NI42R)", () => {
+  // A PRESENT but unrecognized value is rejected, not silently defaulted to
+  // enabled — mirrors resolveEmitLegacyTools (CLAUDE.md rule #51: reject invalid
+  // input instead of silently defaulting). Absent still defaults to true.
+  assert.throws(
+    () => parseConfig({ namespaceCatalogEnabled: "maybe" }),
+    /namespaceCatalogEnabled must be a boolean-like value/,
+  );
+  assert.throws(() => parseConfig({ namespaceCatalogEnabled: "flase" }), /boolean-like value/);
+  assert.throws(() => parseConfig({ namespaceCatalogEnabled: 2 }), /boolean-like value/);
+});

package/src/config.ts

@@ -384,6 +384,27 @@ function resolveEmitLegacyTools(configValue: unknown): boolean {
   return true;
 }
 
+/**
+ * Resolve the `namespaceCatalogEnabled` opt-out (issue #1499). A boolean-like
+ * value ("false"/"0"/"no"/"off" etc.) is honored; a PRESENT but unrecognized
+ * value ("flase", 2) is REJECTED rather than silently defaulting to enabled
+ * (CLAUDE.md rule #51 — reject invalid input instead of silently defaulting),
+ * mirroring `resolveEmitLegacyTools`. Defaults to enabled only when absent.
+ */
+function resolveNamespaceCatalogEnabled(configValue: unknown): boolean {
+  const ACCEPTED = "true/false/1/0/yes/no/on/off";
+  if (configValue !== undefined && configValue !== null) {
+    const coerced = coerceBooleanLike(configValue);
+    if (coerced === undefined) {
+      throw new Error(
+        `namespaceCatalogEnabled must be a boolean-like value (${ACCEPTED}); got ${JSON.stringify(configValue)}`,
+      );
+    }
+    return coerced;
+  }
+  return true;
+}
+
 export function isOpenaiApiKeyDisabled(value: unknown): boolean {
   return value === false || (typeof value === "string" && value.trim().toLowerCase() === "false");
 }
@@ -2588,6 +2609,14 @@ export function parseConfig(raw: unknown): PluginConfig {
 
     // v3.0 namespaces (default off)
     namespacesEnabled: cfg.namespacesEnabled === true,
+    // Namespace catalog (issue #1499): default ON, but only does anything when
+    // namespacesEnabled is also true (the catalog is inert otherwise). Operators
+    // opt out with namespaceCatalogEnabled: false. Boolean-like opt-outs from
+    // CLI/env/JSON ("false", "0", "no", "off") are honored (CLAUDE.md rule #36);
+    // a PRESENT but unrecognized value ("flase", 2) is REJECTED rather than
+    // silently defaulting to enabled (CLAUDE.md rule #51); default to enabled
+    // only when the value is absent.
+    namespaceCatalogEnabled: resolveNamespaceCatalogEnabled(cfg.namespaceCatalogEnabled),
     // NOTE: namespace identifiers are intentionally NOT sanitized here — the
     // codebase rejects unsafe namespaces at the point of use (see
     // codex-materialize-runner and NamespaceStorageRouter / resolveNamespaceDir),