@remnic/core 10.0.64 → 10.0.66

package/dist/{chunk-R7WYAXPO.js → chunk-VHSQU3RO.js}

@@ -119,16 +119,48 @@ function parseConversationThread(raw) {
     return null;
   }
 }
-var ThreadingManager = class {
+var ThreadingManager = class _ThreadingManager {
   constructor(threadsDir, gapMinutes = 30) {
     this.threadsDir = threadsDir;
     this.gapMinutes = gapMinutes;
   }
   threadsDir;
   gapMinutes;
-  currentThreadId = null;
-  lastTurnTimestamp = null;
-  lastSessionKey = null;
+  /**
+   * Per-session thread-run state. One global slot let two concurrent
+   * extractions (bounded-parallel queue) interleave sessions and attach
+   * turns to the wrong thread, so the run state is keyed by session.
+   * Bounded: a long-lived daemon sees one entry per active session.
+   */
+  runStateBySession = /* @__PURE__ */ new Map();
+  /**
+   * Run states with a processTurn awaiting inside them. A session parked on
+   * `saveThread` can watch 512 other sessions insert and evict; dropping its
+   * state mid-await loses its thread id and forks its thread, so eviction
+   * never takes an in-flight state (the cap may be exceeded briefly by the
+   * number of in-flight extractions, which is bounded by the queue).
+   */
+  inFlightRunStates = /* @__PURE__ */ new Set();
+  static RUN_STATE_MAX_SESSIONS = 512;
+  runStateFor(turn) {
+    const key = turn.sessionKey ?? "";
+    let state = this.runStateBySession.get(key);
+    if (state) {
+      this.runStateBySession.delete(key);
+      this.runStateBySession.set(key, state);
+    } else {
+      state = { currentThreadId: null, lastTurnTimestamp: null };
+      this.runStateBySession.set(key, state);
+      if (this.runStateBySession.size > _ThreadingManager.RUN_STATE_MAX_SESSIONS) {
+        for (const [oldestKey, oldest] of this.runStateBySession) {
+          if (oldest === state || this.inFlightRunStates.has(oldest)) continue;
+          this.runStateBySession.delete(oldestKey);
+          if (this.runStateBySession.size <= _ThreadingManager.RUN_STATE_MAX_SESSIONS) break;
+        }
+      }
+    }
+    return state;
+  }
   async ensureDirectory() {
     await mkdir(this.threadsDir, { recursive: true });
   }
@@ -182,20 +214,20 @@ var ThreadingManager = class {
   }
   /**
    * Check if we should start a new thread based on session key and time gap.
+   * State is per session, so the cross-session check the shared slot needed
+   * is gone: different sessions never share run state at all.
    */
   shouldStartNewThread(turn) {
     const turnTime = new Date(turn.timestamp).getTime();
-    if (turn.sessionKey && this.lastSessionKey && turn.sessionKey !== this.lastSessionKey) {
-      return true;
-    }
-    if (this.lastTurnTimestamp) {
-      const gapMs = turnTime - this.lastTurnTimestamp;
+    const state = this.runStateFor(turn);
+    if (state.lastTurnTimestamp) {
+      const gapMs = turnTime - state.lastTurnTimestamp;
       const gapMinutes = gapMs / (1e3 * 60);
       if (gapMinutes > this.gapMinutes) {
         return true;
       }
     }
-    if (!this.currentThreadId) {
+    if (!state.currentThreadId) {
       return true;
     }
     return false;
@@ -207,36 +239,41 @@ var ThreadingManager = class {
   async processTurn(turn, episodeIds) {
     await this.ensureDirectory();
     const turnTime = new Date(turn.timestamp).getTime();
-    if (this.shouldStartNewThread(turn)) {
-      const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-      const thread = {
-        id: threadId,
-        title: "New Thread",
-        // Will be updated later with keywords
-        createdAt: turn.timestamp,
-        updatedAt: turn.timestamp,
-        sessionKey: turn.sessionKey,
-        episodeIds: [...episodeIds],
-        linkedThreadIds: []
-      };
-      await this.saveThread(thread);
-      this.currentThreadId = threadId;
-      log.debug(`created new thread ${threadId}`);
-    } else if (this.currentThreadId) {
-      const thread = await this.loadThread(this.currentThreadId);
-      if (thread) {
-        for (const id of episodeIds) {
-          if (!thread.episodeIds.includes(id)) {
-            thread.episodeIds.push(id);
+    const state = this.runStateFor(turn);
+    this.inFlightRunStates.add(state);
+    try {
+      if (this.shouldStartNewThread(turn)) {
+        const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const thread = {
+          id: threadId,
+          title: "New Thread",
+          // Will be updated later with keywords
+          createdAt: turn.timestamp,
+          updatedAt: turn.timestamp,
+          sessionKey: turn.sessionKey,
+          episodeIds: [...episodeIds],
+          linkedThreadIds: []
+        };
+        await this.saveThread(thread);
+        state.currentThreadId = threadId;
+        log.debug(`created new thread ${threadId}`);
+      } else if (state.currentThreadId) {
+        const thread = await this.loadThread(state.currentThreadId);
+        if (thread) {
+          for (const id of episodeIds) {
+            if (!thread.episodeIds.includes(id)) {
+              thread.episodeIds.push(id);
+            }
           }
+          thread.updatedAt = turn.timestamp;
+          await this.saveThread(thread);
         }
-        thread.updatedAt = turn.timestamp;
-        await this.saveThread(thread);
       }
+      state.lastTurnTimestamp = turnTime;
+      return state.currentThreadId;
+    } finally {
+      this.inFlightRunStates.delete(state);
     }
-    this.lastTurnTimestamp = turnTime;
-    this.lastSessionKey = turn.sessionKey ?? null;
-    return this.currentThreadId;
   }
   /**
    * Append persisted memory IDs to an existing thread.
@@ -351,22 +388,24 @@ var ThreadingManager = class {
     return true;
   }
   /**
-   * Get the current thread ID (if any).
+   * Get the current thread ID (if any). With per-session run state there is
+   * no single current thread; null unless exactly one session is tracked.
    */
   getCurrentThreadId() {
-    return this.currentThreadId;
+    if (this.runStateBySession.size === 1) {
+      return this.runStateBySession.values().next().value?.currentThreadId ?? null;
+    }
+    return null;
   }
   /**
    * Reset threading state (e.g., on plugin restart).
    */
   reset() {
-    this.currentThreadId = null;
-    this.lastTurnTimestamp = null;
-    this.lastSessionKey = null;
+    this.runStateBySession.clear();
   }
 };
 
 export {
   ThreadingManager
 };
-//# sourceMappingURL=chunk-R7WYAXPO.js.map
+//# sourceMappingURL=chunk-VHSQU3RO.js.map

package/dist/chunk-VHSQU3RO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/threading.ts"],"sourcesContent":["/**\n * Conversation Threading (Phase 3B)\n *\n * Groups related memories into conversation threads with auto-generated titles.\n * Thread boundary detection: new session key OR time gap > threshold.\n */\n\nimport { readdir, readFile, writeFile, mkdir, stat } from \"node:fs/promises\";\nimport { log } from \"./logger.js\";\nimport type { BufferTurn, ConversationThread } from \"./types.js\";\nimport {\n  encodeStoragePathSegment,\n  encodeStoragePathSegmentWithHash,\n  isSafeLegacyPathSegment,\n  resolveSafeStoragePath,\n} from \"./storage-paths.js\";\n\n/** Stop words for title extraction */\nconst STOP_WORDS = new Set([\n  \"a\", \"an\", \"the\", \"is\", \"are\", \"was\", \"were\", \"be\", \"been\", \"being\",\n  \"have\", \"has\", \"had\", \"do\", \"does\", \"did\", \"will\", \"would\", \"could\",\n  \"should\", \"may\", \"might\", \"must\", \"shall\", \"can\", \"need\", \"to\", \"of\",\n  \"in\", \"for\", \"on\", \"with\", \"at\", \"by\", \"from\", \"as\", \"into\", \"through\",\n  \"during\", \"before\", \"after\", \"above\", \"below\", \"between\", \"this\", \"that\",\n  \"these\", \"those\", \"i\", \"me\", \"my\", \"we\", \"our\", \"you\", \"your\", \"he\",\n  \"she\", \"it\", \"they\", \"them\", \"their\", \"what\", \"which\", \"who\", \"how\",\n  \"when\", \"where\", \"why\", \"and\", \"but\", \"or\", \"if\", \"because\", \"so\",\n  \"just\", \"about\", \"like\", \"also\", \"very\", \"really\", \"here\", \"there\",\n]);\n\n/**\n * Extract top keywords from content for thread title.\n * Simple TF approach (no IDF needed for single thread).\n */\nfunction extractKeywords(content: string, maxKeywords: number = 3): string[] {\n  const words = content\n    .toLowerCase()\n    .replace(/[^a-z0-9\\s-]/g, \" \")\n    .split(/\\s+/)\n    .filter((w) => w.length >= 4 && !STOP_WORDS.has(w));\n\n  // Count frequencies\n  const freq = new Map<string, number>();\n  for (const word of words) {\n    freq.set(word, (freq.get(word) ?? 0) + 1);\n  }\n\n  // Sort by frequency, take top N\n  return [...freq.entries()]\n    .sort((a, b) => b[1] - a[1])\n    .slice(0, maxKeywords)\n    .map(([word]) => word);\n}\n\n/**\n * Generate a thread title from keywords.\n */\nfunction generateTitle(keywords: string[]): string {\n  if (keywords.length === 0) return \"Untitled Thread\";\n  // Capitalize and join\n  return keywords\n    .map((k) => k.charAt(0).toUpperCase() + k.slice(1))\n    .join(\", \");\n}\n\nfunction isConversationThread(value: unknown): value is ConversationThread {\n  if (value === null || typeof value !== \"object\") return false;\n  const candidate = value as Partial<ConversationThread>;\n  return (\n    typeof candidate.id === \"string\" &&\n    typeof candidate.title === \"string\" &&\n    typeof candidate.createdAt === \"string\" &&\n    typeof candidate.updatedAt === \"string\" &&\n    Array.isArray(candidate.episodeIds) &&\n    Array.isArray(candidate.linkedThreadIds)\n  );\n}\n\nfunction parseConversationThread(raw: string): ConversationThread | null {\n  try {\n    const parsed = JSON.parse(raw) as unknown;\n    return isConversationThread(parsed) ? parsed : null;\n  } catch {\n    return null;\n  }\n}\n\n/** One session's thread-run state: its current thread and last turn time. */\ninterface ThreadingRunState {\n  currentThreadId: string | null;\n  lastTurnTimestamp: number | null;\n}\n\nexport class ThreadingManager {\n  /**\n   * Per-session thread-run state. One global slot let two concurrent\n   * extractions (bounded-parallel queue) interleave sessions and attach\n   * turns to the wrong thread, so the run state is keyed by session.\n   * Bounded: a long-lived daemon sees one entry per active session.\n   */\n  private readonly runStateBySession = new Map<string, ThreadingRunState>();\n  /**\n   * Run states with a processTurn awaiting inside them. A session parked on\n   * `saveThread` can watch 512 other sessions insert and evict; dropping its\n   * state mid-await loses its thread id and forks its thread, so eviction\n   * never takes an in-flight state (the cap may be exceeded briefly by the\n   * number of in-flight extractions, which is bounded by the queue).\n   */\n  private readonly inFlightRunStates = new Set<ThreadingRunState>();\n  private static readonly RUN_STATE_MAX_SESSIONS = 512;\n\n  private runStateFor(turn: BufferTurn): ThreadingRunState {\n    const key = turn.sessionKey ?? \"\";\n    let state = this.runStateBySession.get(key);\n    if (state) {\n      // Refresh recency: Map iteration is insertion-ordered, so re-putting a\n      // touched session makes eviction true LRU instead of first-in-first-out —\n      // an active session must not be the oldest entry just because it started\n      // first.\n      this.runStateBySession.delete(key);\n      this.runStateBySession.set(key, state);\n    } else {\n      state = { currentThreadId: null, lastTurnTimestamp: null };\n      this.runStateBySession.set(key, state);\n      if (this.runStateBySession.size > ThreadingManager.RUN_STATE_MAX_SESSIONS) {\n        for (const [oldestKey, oldest] of this.runStateBySession) {\n          // Never evict the state being inserted: before the caller registers\n          // it in-flight, every older entry can be in flight and the loop\n          // would otherwise delete this turn's own state and fork the thread.\n          if (oldest === state || this.inFlightRunStates.has(oldest)) continue;\n          this.runStateBySession.delete(oldestKey);\n          if (this.runStateBySession.size <= ThreadingManager.RUN_STATE_MAX_SESSIONS) break;\n        }\n      }\n    }\n    return state;\n  }\n\n  constructor(\n    private readonly threadsDir: string,\n    private readonly gapMinutes: number = 30,\n  ) {}\n\n  async ensureDirectory(): Promise<void> {\n    await mkdir(this.threadsDir, { recursive: true });\n  }\n\n  private encodedThreadFileName(threadId: string): string {\n    return `${encodeStoragePathSegment(threadId)}.json`;\n  }\n\n  private collisionSafeThreadFileName(threadId: string): string {\n    return `${encodeStoragePathSegmentWithHash(threadId)}.json`;\n  }\n\n  private legacyThreadFileName(threadId: string): string | undefined {\n    if (!isSafeLegacyPathSegment(threadId)) return undefined;\n    const legacyFile = `${threadId}.json`;\n    return legacyFile === this.encodedThreadFileName(threadId) ? undefined : legacyFile;\n  }\n\n  private async threadCandidateStatus(\n    filePath: string,\n    threadId: string,\n  ): Promise<\"missing\" | \"matches\" | \"invalid\" | \"mismatches\"> {\n    try {\n      if (!(await stat(filePath)).isFile()) return \"mismatches\";\n      const thread = parseConversationThread(await readFile(filePath, \"utf-8\"));\n      if (!thread) return \"invalid\";\n      return thread.id === threadId ? \"matches\" : \"mismatches\";\n    } catch (err) {\n      const code =\n        err && typeof err === \"object\" && \"code\" in err\n          ? (err as { code?: string }).code\n          : undefined;\n      if (code === \"ENOENT\") return \"missing\";\n      throw err;\n    }\n  }\n\n  private async threadFilePathForWrite(threadId: string): Promise<string> {\n    const encodedPath = await resolveSafeStoragePath(\n      this.threadsDir,\n      this.encodedThreadFileName(threadId),\n    );\n    const encodedStatus = await this.threadCandidateStatus(encodedPath, threadId);\n    if (encodedStatus === \"matches\") return encodedPath;\n\n    const legacyFile = this.legacyThreadFileName(threadId);\n    if (legacyFile) {\n      const legacyPath = await resolveSafeStoragePath(this.threadsDir, legacyFile);\n      if ((await this.threadCandidateStatus(legacyPath, threadId)) === \"matches\") {\n        return legacyPath;\n      }\n    }\n\n    if (encodedStatus === \"missing\") return encodedPath;\n\n    const collisionSafePath = await resolveSafeStoragePath(\n      this.threadsDir,\n      this.collisionSafeThreadFileName(threadId),\n    );\n    const collisionSafeStatus = await this.threadCandidateStatus(collisionSafePath, threadId);\n    if (collisionSafeStatus === \"mismatches\") {\n      throw new Error(`thread storage path collision for thread id: ${threadId}`);\n    }\n\n    return collisionSafePath;\n  }\n\n  /**\n   * Check if we should start a new thread based on session key and time gap.\n   * State is per session, so the cross-session check the shared slot needed\n   * is gone: different sessions never share run state at all.\n   */\n  shouldStartNewThread(turn: BufferTurn): boolean {\n    const turnTime = new Date(turn.timestamp).getTime();\n    const state = this.runStateFor(turn);\n\n    // Time gap > threshold = new thread\n    if (state.lastTurnTimestamp) {\n      const gapMs = turnTime - state.lastTurnTimestamp;\n      const gapMinutes = gapMs / (1000 * 60);\n      if (gapMinutes > this.gapMinutes) {\n        return true;\n      }\n    }\n\n    // No current thread = new thread\n    if (!state.currentThreadId) {\n      return true;\n    }\n\n    return false;\n  }\n\n  /**\n   * Process a turn and return the thread ID it belongs to.\n   * Creates a new thread if needed.\n   */\n  async processTurn(turn: BufferTurn, episodeIds: string[]): Promise<string> {\n    await this.ensureDirectory();\n\n    const turnTime = new Date(turn.timestamp).getTime();\n    const state = this.runStateFor(turn);\n    this.inFlightRunStates.add(state);\n    try {\n      if (this.shouldStartNewThread(turn)) {\n        // Create new thread\n        const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;\n        const thread: ConversationThread = {\n          id: threadId,\n          title: \"New Thread\", // Will be updated later with keywords\n          createdAt: turn.timestamp,\n          updatedAt: turn.timestamp,\n          sessionKey: turn.sessionKey,\n          episodeIds: [...episodeIds],\n          linkedThreadIds: [],\n        };\n\n        await this.saveThread(thread);\n        state.currentThreadId = threadId;\n        log.debug(`created new thread ${threadId}`);\n      } else if (state.currentThreadId) {\n        // Add episodes to current thread\n        const thread = await this.loadThread(state.currentThreadId);\n        if (thread) {\n          for (const id of episodeIds) {\n            if (!thread.episodeIds.includes(id)) {\n              thread.episodeIds.push(id);\n            }\n          }\n          thread.updatedAt = turn.timestamp;\n          await this.saveThread(thread);\n        }\n      }\n\n      state.lastTurnTimestamp = turnTime;\n\n      return state.currentThreadId!;\n    } finally {\n      this.inFlightRunStates.delete(state);\n    }\n  }\n\n  /**\n   * Append persisted memory IDs to an existing thread.\n   * Keeps IDs unique and updates the thread timestamp.\n   */\n  async appendEpisodeIds(threadId: string, episodeIds: string[]): Promise<void> {\n    if (episodeIds.length === 0) return;\n    const thread = await this.loadThread(threadId);\n    if (!thread) return;\n\n    let changed = false;\n    for (const id of episodeIds) {\n      if (!thread.episodeIds.includes(id)) {\n        thread.episodeIds.push(id);\n        changed = true;\n      }\n    }\n    if (!changed) return;\n\n    thread.updatedAt = new Date().toISOString();\n    await this.saveThread(thread);\n  }\n\n  /**\n   * Update thread title based on accumulated content.\n   */\n  async updateThreadTitle(threadId: string, content: string): Promise<void> {\n    const thread = await this.loadThread(threadId);\n    if (!thread) return;\n\n    const keywords = extractKeywords(content);\n    const title = generateTitle(keywords);\n\n    if (title !== thread.title) {\n      thread.title = title;\n      thread.updatedAt = new Date().toISOString();\n      await this.saveThread(thread);\n      log.debug(`updated thread ${threadId} title: ${title}`);\n    }\n  }\n\n  /**\n   * Get all threads, sorted by updatedAt desc.\n   */\n  async getAllThreads(): Promise<ConversationThread[]> {\n    try {\n      const files = await readdir(this.threadsDir);\n      const threadsById = new Map<\n        string,\n        { thread: ConversationThread; storagePriority: number }\n      >();\n\n      for (const file of files) {\n        if (!file.endsWith(\".json\")) continue;\n        try {\n          const raw = await readFile(\n            await resolveSafeStoragePath(this.threadsDir, file),\n            \"utf-8\",\n          );\n          const thread = parseConversationThread(raw);\n          if (!thread) continue;\n\n          const legacyFile = this.legacyThreadFileName(thread.id);\n          const storagePriority =\n            file === this.encodedThreadFileName(thread.id)\n              ? 3\n              : file === this.collisionSafeThreadFileName(thread.id)\n                ? 2\n                : legacyFile && file === legacyFile\n                  ? 1\n                  : 0;\n          const current = threadsById.get(thread.id);\n          if (!current || storagePriority > current.storagePriority) {\n            threadsById.set(thread.id, { thread, storagePriority });\n          }\n        } catch {\n          // skip unreadable or malformed thread files\n        }\n      }\n\n      return [...threadsById.values()].map(({ thread }) => thread).sort(\n        (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime(),\n      );\n    } catch {\n      return [];\n    }\n  }\n\n  /**\n   * Get a thread by ID.\n   */\n  async loadThread(threadId: string): Promise<ConversationThread | null> {\n    const candidates = [\n      this.encodedThreadFileName(threadId),\n      this.legacyThreadFileName(threadId),\n      this.collisionSafeThreadFileName(threadId),\n    ];\n    for (const file of candidates) {\n      if (!file) continue;\n      try {\n        const filePath = await resolveSafeStoragePath(this.threadsDir, file);\n        const raw = await readFile(filePath, \"utf-8\");\n        const thread = parseConversationThread(raw);\n        if (thread?.id === threadId) return thread;\n      } catch {\n        // try the next candidate\n      }\n    }\n    return null;\n  }\n\n  /**\n   * Save a thread.\n   */\n  async saveThread(thread: ConversationThread): Promise<void> {\n    await this.ensureDirectory();\n    const filePath = await this.threadFilePathForWrite(thread.id);\n    await writeFile(filePath, JSON.stringify(thread, null, 2), \"utf-8\");\n  }\n\n  /**\n   * Link two threads together.\n   */\n  async linkThreads(threadId1: string, threadId2: string): Promise<boolean> {\n    const thread1 = await this.loadThread(threadId1);\n    const thread2 = await this.loadThread(threadId2);\n\n    if (!thread1 || !thread2) return false;\n\n    // Add bidirectional links\n    if (!thread1.linkedThreadIds.includes(threadId2)) {\n      thread1.linkedThreadIds.push(threadId2);\n      await this.saveThread(thread1);\n    }\n\n    if (!thread2.linkedThreadIds.includes(threadId1)) {\n      thread2.linkedThreadIds.push(threadId1);\n      await this.saveThread(thread2);\n    }\n\n    return true;\n  }\n\n  /**\n   * Get the current thread ID (if any). With per-session run state there is\n   * no single current thread; null unless exactly one session is tracked.\n   */\n  getCurrentThreadId(): string | null {\n    if (this.runStateBySession.size === 1) {\n      return this.runStateBySession.values().next().value?.currentThreadId ?? null;\n    }\n    return null;\n  }\n\n  /**\n   * Reset threading state (e.g., on plugin restart).\n   */\n  reset(): void {\n    this.runStateBySession.clear();\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-JL5HXL25.js → chunk-VSZNPAGL.js}

@@ -21,7 +21,7 @@ import {
   defineOperation,
   parseNamespacePreflightWriteOp,
   resolveAuthorizedNamespaceWritablePreflight
-} from "./chunk-GRAUQXQB.js";
+} from "./chunk-RAU25Q6J.js";
 import {
   parseSharedWriteOutputControls
 } from "./chunk-IFBSZGW3.js";
@@ -618,4 +618,4 @@ defineOperation({ name: "graph_events", description: "SSE graph events.", schema
 defineOperation({ name: "chat_message", description: "Chat message.", schema: strictSchema({ message: S.str, chatSessionId: S.str }), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
 defineOperation({ name: "chat_events", description: "SSE chat events.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { stream: "sse" } }) });
 defineOperation({ name: "adapters_status", description: "Adapter registry metadata (issue #1850 round 5). Marker op: the HTTP transport builds the response from its own adapterRegistry, but the op still must be registered so it appears in listRegisteredOperations and enforceTokenOp can gate it for scoped tokens.", schema: strictSchema({}), handler: async (_i, _ctx) => ({ result: { ok: true } }) });
-//# sourceMappingURL=chunk-JL5HXL25.js.map
+//# sourceMappingURL=chunk-VSZNPAGL.js.map

package/dist/{chunk-2ZSRACNK.js → chunk-XMBDI725.js}

@@ -175,7 +175,7 @@ import {
 } from "./chunk-VA3GNAWQ.js";
 import {
   ExtractionEngine
-} from "./chunk-FKGLJJVS.js";
+} from "./chunk-A5FOXI3B.js";
 import {
   parseMemoryActionEligibilityContext
 } from "./chunk-JHU4EYDV.js";
@@ -234,7 +234,7 @@ import {
   runTimelinePublishCli,
   screenCandidateFact,
   summarizeVaultPublish
-} from "./chunk-HOR4RMUM.js";
+} from "./chunk-KFPJIKUW.js";
 import {
   normalizeReplaySessionKey
 } from "./chunk-AJVLDJU6.js";
@@ -247,7 +247,7 @@ import {
 } from "./chunk-SHHZWSSE.js";
 import {
   ThreadingManager
-} from "./chunk-R7WYAXPO.js";
+} from "./chunk-VHSQU3RO.js";
 import {
   compareVerifiedSemanticRuleResults,
   searchVerifiedSemanticRules
@@ -299,7 +299,7 @@ import {
 } from "./chunk-ECF627KC.js";
 import {
   SmartBuffer
-} from "./chunk-3LSTL6EY.js";
+} from "./chunk-3H25IRJJ.js";
 import {
   semanticChunkContent
 } from "./chunk-2GBFKHBZ.js";
@@ -373,7 +373,7 @@ import {
 } from "./chunk-QW27DOHG.js";
 import {
   MeetingsInputError
-} from "./chunk-HRRAOTOQ.js";
+} from "./chunk-3NJJQAL3.js";
 import {
   WearablesInputError,
   describeErrorForOperator
@@ -400,7 +400,7 @@ import {
   detectPassiveCorrections,
   renderSessionExperiencePreview,
   scoreSessionExperienceForPrompt
-} from "./chunk-GRAUQXQB.js";
+} from "./chunk-RAU25Q6J.js";
 import {
   importCapsule
 } from "./chunk-QDZWQBLU.js";
@@ -480,7 +480,7 @@ import {
   ExtractionDeadlineError,
   ExtractionRunCoordinator,
   classifyExtractionOrigin
-} from "./chunk-6D3IWYNY.js";
+} from "./chunk-QNZPYH36.js";
 import {
   ARTIFACT_STATUS_CACHE_TTL_MS,
   BulkImportBatchPartialFailureError,
@@ -6454,6 +6454,7 @@ var ExtractionPersistCoordinator = class {
     });
     const supersessionOrderingAt = (validAt) => validAt && validAt.length > 0 ? validAt : (/* @__PURE__ */ new Date()).toISOString();
     const pendingReviewPersistedIds = [];
+    let deferredCount = 0;
     const persistedIdsByStorage = /* @__PURE__ */ new Map();
     const trackPersistedId = (targetStorage, id, options = {}) => {
       if (options.includeReturnedIds !== false) {
@@ -6960,7 +6961,7 @@ var ExtractionPersistCoordinator = class {
         "persistExtraction: result or result.facts is invalid, skipping",
         { resultType: typeof result, factsType: typeof result?.facts }
       );
-      return { persistedIds, memoryPathById };
+      return { persistedIds, memoryPathById, deferredCount, pendingReviewIds: pendingReviewPersistedIds };
     }
     const chunkingConfig = {
       targetTokens: this.deps.config.chunkingTargetTokens,
@@ -7067,7 +7068,6 @@ var ExtractionPersistCoordinator = class {
     }
     let judgeVerdictsByFactIndex = null;
     let judgeGatedCount = 0;
-    this.deps.setLastPersistExtractionDeferredCount(0);
     if (lifecycleCaps.extractionJudge) {
       let preJudgeRedactionRules = [];
       try {
@@ -7195,7 +7195,7 @@ var ExtractionPersistCoordinator = class {
         log.info(
           `extraction-judge: ${judgeResult.verdicts.size}/${judgeCandidates.length} facts evaluated, ${judgeResult.cached} cached, ${judgeResult.judged} judged, ${judgeResult.deferred} deferred` + (judgeResult.deferredCappedToReject > 0 ? ` (${judgeResult.deferredCappedToReject} cap-rejected)` : "") + `, ${judgeResult.elapsed}ms`
         );
-        this.deps.setLastPersistExtractionDeferredCount(judgeResult.deferred);
+        deferredCount = judgeResult.deferred;
       } catch (err) {
         log.warn(
           `extraction-judge: pipeline error, proceeding without filtering (fail-open): ${err instanceof Error ? err.message : String(err)}`
@@ -8226,8 +8226,7 @@ ${q.context ?? ""}`], entityScreenOn, entityScreenProfile);
     log.info(
       `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount - semanticMergedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`
     );
-    this.deps.setLastPersistExtractionPendingReviewIds(pendingReviewPersistedIds);
-    return { persistedIds, memoryPathById };
+    return { persistedIds, memoryPathById, deferredCount, pendingReviewIds: pendingReviewPersistedIds };
   }
 };
 
@@ -21874,19 +21873,6 @@ var Orchestrator = class {
    * (rule 11) — these hang off the orchestrator instance.
    */
   faithfulnessCounters = createFaithfulnessCounters();
-  /**
-   * Side-channel: number of facts deferred in the most recent
-   * `persistExtraction` call (issue #562, PR 2). The caller reads this after
-   * `persistExtraction` returns to decide whether to retain buffer turns for
-   * the next extraction pass. Not part of the return signature because many
-   * callers already destructure `persistedIds` by position.
-   */
-  lastPersistExtractionDeferredCount = 0;
-  /**
-   * Side-channel (#1635): pending_review persisted ids from the last
-   * persistExtraction; runExtraction excludes them from the thread episode set.
-   */
-  lastPersistExtractionPendingReviewIds = [];
   _fastGatewayLlm;
   get fastGatewayLlm() {
     return this._fastGatewayLlm;
@@ -22014,11 +22000,10 @@ var Orchestrator = class {
         getCodingContextForSession: (sessionKey) => this.getCodingContextForSession(sessionKey),
         applyCodingNamespaceOverlay: (sessionKey, namespace) => this.applyCodingNamespaceOverlay(sessionKey, namespace),
         boxBuilderFor: (storage) => this.boxBuilderFor(storage),
-        appendPersistedThreadEpisodes: (threadId, ids) => this.appendPersistedThreadEpisodes(threadId, ids),
+        appendPersistedThreadEpisodes: (threadId, ids, pendingReviewIds) => this.appendPersistedThreadEpisodes(threadId, ids, pendingReviewIds),
         maybeScheduleConsolidation: (nonZero) => this.maybeScheduleConsolidation(nonZero),
         requestQmdMaintenance: () => this.requestQmdMaintenance(),
         runTierMigrationCycle: (storage, trigger, options) => this.runTierMigrationCycle(storage, trigger, options),
-        getLastPersistExtractionDeferredCount: () => this.lastPersistExtractionDeferredCount,
         recordProcessedExtractionFingerprint: (storage, fingerprint, preloadedMeta) => this.recordProcessedExtractionFingerprint(storage, fingerprint, preloadedMeta)
       });
     }
@@ -22067,12 +22052,6 @@ var Orchestrator = class {
         getJudgeDeferCounts: () => this.judgeDeferCounts,
         getFaithfulnessCounters: () => this.faithfulnessCounters,
         getEmbeddingFallback: () => this.embeddingFallback,
-        setLastPersistExtractionDeferredCount: (v) => {
-          this.lastPersistExtractionDeferredCount = v;
-        },
-        setLastPersistExtractionPendingReviewIds: (ids) => {
-          this.lastPersistExtractionPendingReviewIds = ids;
-        },
         addContentHashDedup: (targetStorage, content) => this.addContentHashDedup(targetStorage, content),
         hasContentHashDedup: (targetStorage, content) => this.hasContentHashDedup(targetStorage, content),
         backfillTemporalBoundsOnDedupHit: (targetStorage, dedupContent, bounds, entityRef, sourceConnector) => this.backfillTemporalBoundsOnDedupHit(targetStorage, dedupContent, bounds, entityRef, sourceConnector),
@@ -23712,7 +23691,7 @@ ${doc.content}` : doc.content,
     this.maintenanceScheduler.requestQmdMaintenanceForTool(reason);
   }
   async persistExtraction(result, storage, threadIdForExtraction, sourceContext, baseNamespace, scopeProfileWritePlan, sourceText, graphCaps = resolveGraphConstructionCapabilities(this.config), lifecycleCaps = resolveMemoryLifecycleCapabilities(this.config)) {
-    const { persistedIds, memoryPathById } = await this.extractionPersistCoordinator.persistExtraction(
+    return await this.extractionPersistCoordinator.persistExtraction(
       result,
       storage,
       threadIdForExtraction,
@@ -23723,15 +23702,13 @@ ${doc.content}` : doc.content,
       graphCaps,
       lifecycleCaps
     );
-    return { persistedIds, memoryPathById };
   }
   /**
    * Append persisted ids to the thread episode set, excluding pending_review
    * fact ids (#1635) so they don't re-seed predecessor edges. Fail-open like
    * the raw appendEpisodeIds call it replaces.
    */
-  async appendPersistedThreadEpisodes(threadId, persistedIds) {
-    const pendingReviewIds = this.lastPersistExtractionPendingReviewIds ?? [];
+  async appendPersistedThreadEpisodes(threadId, persistedIds, pendingReviewIds) {
     const episodeIds = pendingReviewIds.length > 0 ? persistedIds.filter((id) => !pendingReviewIds.includes(id)) : persistedIds;
     if (episodeIds.length === 0) return;
     try {
@@ -31644,4 +31621,4 @@ export {
   qmdStartupCollectionChecksWithTimeout,
   Orchestrator
 };
-//# sourceMappingURL=chunk-2ZSRACNK.js.map
+//# sourceMappingURL=chunk-XMBDI725.js.map