@remnic/core 10.0.65 → 10.0.66

package/src/orchestration/extraction-persist.ts

@@ -127,6 +127,16 @@ import {
   normalizeStoredHashSource as normalizeStoredHashSourceContent,
 } from "./extraction-persist-citation.js";
 
+/** One extraction run's persist outcome: per-run values, no shared side channels (#1526). */
+export interface ExtractionPersistResult {
+  persistedIds: string[];
+  memoryPathById: Map<string, string>;
+  /** Facts the judge deferred — drives this run's buffer retention (#562). */
+  deferredCount: number;
+  /** Persisted pending_review ids, excluded from the thread episode set (#1635). */
+  pendingReviewIds: string[];
+}
+
 export class ExtractionPersistCoordinator {
   constructor(
     private readonly deps: ExtractionPersistDeps,
@@ -149,7 +159,7 @@ export class ExtractionPersistCoordinator {
     sourceText?: string,
     graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.deps.config),
     lifecycleCaps: MemoryLifecycleCapabilitySet = resolveMemoryLifecycleCapabilities(this.deps.config),
-  ): Promise<{ persistedIds: string[]; memoryPathById: Map<string, string> }> {
+  ): Promise<ExtractionPersistResult> {
     const citationEnabled = resolvePipelineProcessingCapabilities(this.deps.config).inlineSourceAttribution === true;
     const citationTemplate = this.deps.config.inlineSourceAttributionFormat;
     const factDedupEnabled = resolveRecallAuxiliaryCapabilities(this.deps.config).factDeduplication;
@@ -190,6 +200,10 @@ export class ExtractionPersistCoordinator {
       validAt && validAt.length > 0 ? validAt : new Date().toISOString();
     // #1635: pending_review persisted ids, excluded from the thread episode set below.
     const pendingReviewPersistedIds: string[] = [];
+    // This run's judge-deferred count, returned to the caller (issue #562 PR 2)
+    // instead of shared side-channel state, so concurrent extractions cannot
+    // read each other's retention decision.
+    let deferredCount = 0;
     const persistedIdsByStorage = new Map<string, { storage: StorageManager; ids: string[] }>();
     const trackPersistedId = (
       targetStorage: StorageManager,
@@ -1071,7 +1085,7 @@ export class ExtractionPersistCoordinator {
         "persistExtraction: result or result.facts is invalid, skipping",
         { resultType: typeof result, factsType: typeof result?.facts },
       );
-      return { persistedIds, memoryPathById };
+      return { persistedIds, memoryPathById, deferredCount, pendingReviewIds: pendingReviewPersistedIds };
     }
 
     // Chunking config from plugin settings
@@ -1243,10 +1257,6 @@ export class ExtractionPersistCoordinator {
     // be persisted, not the raw extraction-time category.
     let judgeVerdictsByFactIndex: Map<number, import("../extraction-judge.js").JudgeVerdict> | null = null;
     let judgeGatedCount = 0;
-    // Reset the side-channel defer count at the start of every
-    // persistExtraction call so stale state from a prior call cannot leak
-    // into the caller's buffer-retention decision.
-    this.deps.setLastPersistExtractionDeferredCount(0);
     if (lifecycleCaps.extractionJudge) {
       // #1669 P1 + #1713 Item 1: pre-filter redacted facts from judge candidates
       // so never-store content is not persisted as judge training data.
@@ -1433,7 +1443,7 @@ export class ExtractionPersistCoordinator {
         );
         // Expose defer count to the caller (issue #562 PR 2) so it can decide
         // whether to retain buffer turns for the next extraction pass.
-        this.deps.setLastPersistExtractionDeferredCount(judgeResult.deferred);
+        deferredCount = judgeResult.deferred;
       } catch (err) {
         // Fail-open: if the entire judge pipeline errors, proceed without filtering
         log.warn(
@@ -2978,9 +2988,7 @@ export class ExtractionPersistCoordinator {
       `persisted: ${facts.length - dedupedCount - importanceGatedCount - judgeGatedCount - redactionGatedCount - semanticMergedCount} facts${dedupSuffix}${gatedSuffix}${judgeSuffix}${redactionSuffix}, ${entities.length} entities, ${questions.length} questions, ${profileUpdates.length} profile updates`,
     );
 
-    // #1635: surface pending_review ids so the thread episode set excludes them.
-    this.deps.setLastPersistExtractionPendingReviewIds(pendingReviewPersistedIds);
     // Return the persisted fact IDs for threading
-    return { persistedIds, memoryPathById };
+    return { persistedIds, memoryPathById, deferredCount, pendingReviewIds: pendingReviewPersistedIds };
   }
 }

package/src/orchestration/extraction-run-helpers.ts

@@ -177,7 +177,7 @@ export async function runExtractionPostPersistBestEffort(
 export interface ExtractionDeferRetentionOptions {
   clearBufferAfterExtraction: boolean;
   extractionJudgeShadow: boolean;
-  getDeferredCount: () => number;
+  deferredCount: number;
   normalizedTurns: BufferTurn[];
   bufferKey: string;
   retainDeferredTurns: (bufferKey: string, turns: BufferTurn[], max: number) => Promise<void>;
@@ -193,7 +193,7 @@ export async function runExtractionDeferRetention(
 ): Promise<void> {
   await runPostPersistBestEffort("during_defer_retention", async () => {
     if (options.clearBufferAfterExtraction && !options.extractionJudgeShadow) {
-      const deferredCount = options.getDeferredCount();
+      const deferredCount = options.deferredCount;
       if (deferredCount > 0 && options.normalizedTurns.length > 0) {
         await options.retainDeferredTurns(options.bufferKey, options.normalizedTurns, 10);
       } else {
@@ -229,7 +229,8 @@ export interface ExtractionPostPersistOptions {
     options?: { ignoreAbort?: boolean; ignoreDeadline?: boolean; propagateErrors?: boolean },
   ) => Promise<void>;
   extractionJudgeShadow: boolean;
-  getDeferredCount: () => number;
+  /** Facts this run's persist deferred to the judge — drives retention (#1523). */
+  deferredCount: number;
   normalizedTurns: BufferTurn[];
   bufferKey: string;
   retainDeferredTurns: (bufferKey: string, turns: BufferTurn[], max: number) => Promise<void>;
@@ -283,7 +284,7 @@ export async function runExtractionPostPersist(
   await runExtractionDeferRetention(runBestEffort, {
     clearBufferAfterExtraction: options.clearBufferAfterExtraction,
     extractionJudgeShadow: options.extractionJudgeShadow,
-    getDeferredCount: options.getDeferredCount,
+    deferredCount: options.deferredCount,
     normalizedTurns: options.normalizedTurns,
     bufferKey: options.bufferKey,
     retainDeferredTurns: options.retainDeferredTurns,

package/src/orchestration/extraction-run.test.ts

@@ -175,7 +175,7 @@ async function makeHarness(overrides: Record<string, unknown> = {}): Promise<Har
     persistExtraction: async () => {
       persistCalls += 1;
       await persistHandler();
-      return { persistedIds: ["memory-1"], memoryPathById: new Map() };
+      return { persistedIds: ["memory-1"], memoryPathById: new Map(), deferredCount: 0, pendingReviewIds: [] };
     },
     maybeCapturePassiveCorrections: async (_turns, options) => {
       await passiveCaptureHandler();
@@ -193,7 +193,6 @@ async function makeHarness(overrides: Record<string, unknown> = {}): Promise<Har
     maybeScheduleConsolidation: () => {},
     requestQmdMaintenance: () => {},
     runTierMigrationCycle: async () => migrationSummary,
-    getLastPersistExtractionDeferredCount: () => 0,
     recordProcessedExtractionFingerprint: async (storage, fingerprint, meta) => {
       recordedProcessedCount += 1;
       await fingerprintRecorder(storage, fingerprint, meta);

package/src/orchestration/extraction-run.ts

@@ -71,7 +71,7 @@ export interface ExtractionRunCoordinatorDeps {
     sourceText?: string,
     graphCaps?: GraphConstructionCapabilitySet,
     lifecycleCaps?: MemoryLifecycleCapabilitySet
-  ) => Promise<{ persistedIds: string[]; memoryPathById: Map<string, string> }>;
+  ) => Promise<ExtractionPersistResult>;
 
   maybeCapturePassiveCorrections: (
     turns: readonly BufferTurn[],
@@ -89,7 +89,7 @@ export interface ExtractionRunCoordinatorDeps {
   getCodingContextForSession: (sessionKey: string) => CodingContext | null;
   applyCodingNamespaceOverlay: (sessionKey: string, namespace: string) => string;
   boxBuilderFor: (storage: StorageManager) => Pick<BoxBuilder, "onExtraction">;
-  appendPersistedThreadEpisodes: (threadId: string, ids: string[]) => Promise<void>;
+  appendPersistedThreadEpisodes: (threadId: string, ids: string[], pendingReviewIds: string[]) => Promise<void>;
   maybeScheduleConsolidation: (nonZero: boolean) => void;
   requestQmdMaintenance: () => void;
   runTierMigrationCycle: (
@@ -101,7 +101,6 @@ export interface ExtractionRunCoordinatorDeps {
       force?: boolean;
     }
   ) => Promise<TierMigrationCycleSummary>;
-  getLastPersistExtractionDeferredCount: () => number;
   recordProcessedExtractionFingerprint: (
     storage: StorageManager,
     fingerprint: string,
@@ -125,6 +124,7 @@ import {
   EXTRACTION_RETRY_STATE_MAX_ENTRIES,
 } from "./extraction-run-helpers.js";
 import type { ExtractionResilienceStatus, ExtractionRetryStateEntry } from "./extraction-run-helpers.js";
+import type { ExtractionPersistResult } from "./extraction-persist.js";
 
 export {
   capExtractionRetryStateEntries,
@@ -1069,7 +1069,7 @@ export class ExtractionRunCoordinator {
     throwIfDeadlineExceeded("before_persist");
     throwIfAborted("before_persist");
 
-    const { persistedIds } = await this.deps.persistExtraction(
+    const { persistedIds, deferredCount, pendingReviewIds } = await this.deps.persistExtraction(
       result,
       storage,
       threadIdForExtraction,
@@ -1106,7 +1106,7 @@ export class ExtractionRunCoordinator {
       clearBufferAfterExtraction,
       runPostPersistBestEffort,
       extractionJudgeShadow: this.config.extractionJudgeShadow,
-      getDeferredCount: () => this.deps.getLastPersistExtractionDeferredCount(),
+      deferredCount,
       normalizedTurns: normalizedTurns as BufferTurn[],
       bufferKey,
       retainDeferredTurns: (key, retainedTurns, max) =>
@@ -1155,7 +1155,7 @@ export class ExtractionRunCoordinator {
     // always attached to the thread. The helper excludes pending_review ids (#1635).
     if (resolvePresentationCapabilities(this.config).threading && threadIdForExtraction && persistedIds.length > 0) {
       await runPostPersistBestEffort("during_thread_episode_append", () =>
-        this.deps.appendPersistedThreadEpisodes(threadIdForExtraction, persistedIds),
+        this.deps.appendPersistedThreadEpisodes(threadIdForExtraction, persistedIds, pendingReviewIds),
       );
     }
 

package/src/orchestrator.ts

@@ -123,7 +123,7 @@ import {
   type ExtractionResilienceStatus,
 } from "./orchestration/extraction-run.js";
 import { ConsolidationRunCoordinator } from "./orchestration/consolidation-run.js";
-import { ExtractionPersistCoordinator } from "./orchestration/extraction-persist.js";
+import { ExtractionPersistCoordinator, type ExtractionPersistResult } from "./orchestration/extraction-persist.js";
 import type { ExtractionSourceContext } from "./orchestration/extraction-origin-context.js";
 import { drainExtractionAndShutdownDependencyPropagation } from "./orchestration/extraction-shutdown.js";
 import {
@@ -614,19 +614,6 @@ export class Orchestrator {
    * (rule 11) — these hang off the orchestrator instance.
    */
   private faithfulnessCounters: FaithfulnessGateCounters = 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.
-   */
-  private lastPersistExtractionDeferredCount: number = 0;
-  /**
-   * Side-channel (#1635): pending_review persisted ids from the last
-   * persistExtraction; runExtraction excludes them from the thread episode set.
-   */
-  private lastPersistExtractionPendingReviewIds: string[] = [];
   private readonly _fastGatewayLlm: FallbackLlmClient | null;
 
   get fastGatewayLlm(): FallbackLlmClient | null {
@@ -785,11 +772,11 @@ export class Orchestrator {
         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),
       });
@@ -841,8 +828,6 @@ export class Orchestrator {
         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) =>
@@ -3197,8 +3182,8 @@ export class Orchestrator {
     sourceText?: string,
     graphCaps: GraphConstructionCapabilitySet = resolveGraphConstructionCapabilities(this.config),
     lifecycleCaps: MemoryLifecycleCapabilitySet = resolveMemoryLifecycleCapabilities(this.config),
-  ): Promise<{ persistedIds: string[]; memoryPathById: Map<string, string> }> {
-    const { persistedIds, memoryPathById } = await this.extractionPersistCoordinator.persistExtraction(
+  ): Promise<ExtractionPersistResult> {
+    return await this.extractionPersistCoordinator.persistExtraction(
       result,
       storage,
       threadIdForExtraction,
@@ -3209,7 +3194,6 @@ export class Orchestrator {
       graphCaps,
       lifecycleCaps,
     );
-    return { persistedIds, memoryPathById };
   }
   /**
    * Append persisted ids to the thread episode set, excluding pending_review
@@ -3219,8 +3203,8 @@ export class Orchestrator {
   private async appendPersistedThreadEpisodes(
     threadId: string,
     persistedIds: string[],
+    pendingReviewIds: string[],
   ): Promise<void> {
-    const pendingReviewIds = this.lastPersistExtractionPendingReviewIds ?? [];
     const episodeIds =
       pendingReviewIds.length > 0
         ? persistedIds.filter((id) => !pendingReviewIds.includes(id))

package/src/testing/orchestrator-lite.ts

@@ -166,7 +166,7 @@ export function stubPersistExtraction(
   const impl: PersistExtractionFn = async (...args) => {
     calls.push(args);
     const persistedIds = factory ? await factory(args, calls.length) : [];
-    return { persistedIds, memoryPathById: new Map() };
+    return { persistedIds, memoryPathById: new Map(), deferredCount: 0, pendingReviewIds: [] };
   };
   seam.persistExtraction = impl;
   return calls;

package/src/threading.test.ts

@@ -0,0 +1,153 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { ThreadingManager } from "./threading.js";
+import type { BufferTurn, ConversationThread } from "./types.js";
+
+function turn(sessionKey: string, content: string): BufferTurn {
+  return { role: "user", content, timestamp: "2026-11-04T10:00:00.000Z", sessionKey };
+}
+
+async function makeThreading(): Promise<{ threading: ThreadingManager; cleanup: () => Promise<void> }> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "remnic-threads-"));
+  return { threading: new ThreadingManager(dir), cleanup: () => rm(dir, { recursive: true, force: true }) };
+}
+
+test("the state being inserted is never evicted, even with every older session in flight", async () => {
+  const { threading, cleanup } = await makeThreading();
+  try {
+    const realSave = threading.saveThread.bind(threading);
+    const floodGate = Promise.withResolvers<void>();
+    const allEntered = Promise.withResolvers<void>();
+    let entered = 0;
+    threading.saveThread = async (thread: ConversationThread): Promise<void> => {
+      if (thread.sessionKey?.startsWith("flood-")) {
+        entered += 1;
+        if (entered === 512) allEntered.resolve();
+        await floodGate.promise;
+      }
+      await realSave(thread);
+    };
+
+    // Park all 512 flood sessions inside saveThread so every one of their run
+    // states is in-flight while the next session inserts its own.
+    const floodRuns: Promise<ConversationThread["id"]>[] = [];
+    for (let i = 0; i < 512; i++) {
+      floodRuns.push(threading.processTurn(turn(`flood-${i}`, `flood ${i}`), []));
+    }
+    await allEntered.promise;
+
+    // The new session's state is the map's last entry and not yet registered
+    // in-flight when runStateFor's eviction loop runs; eviction must skip it
+    // or this turn's state is orphaned and the follow-up turn forks a new
+    // thread (PRRT_kwDORJXyws6ztlO2).
+    const idN1 = await threading.processTurn(turn("session-new", "n1"), []);
+    const idN2 = await threading.processTurn(turn("session-new", "n2"), []);
+    assert.equal(idN2, idN1, "follow-up turn must append to the same thread");
+
+    floodGate.resolve();
+    await Promise.all(floodRuns);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("a recently used session is not evicted FIFO when the cap overflows", async () => {
+  const { threading, cleanup } = await makeThreading();
+  try {
+    const threadA = await threading.processTurn(turn("session-a", "a1"), []);
+    // Fill the map to exactly the cap with inactive sessions (session-a is
+    // now the OLDEST entry).
+    for (let i = 0; i < 511; i++) {
+      await threading.processTurn(turn(`flood-${i}`, `flood ${i}`), []);
+    }
+    // Touch session-a: under LRU this makes it the most recent entry; under
+    // FIFO it stays oldest and the next insertion evicts it.
+    await threading.processTurn(turn("session-a", "a2"), ["episode-a2"]);
+    await threading.processTurn(turn("flood-new", "the straw"), []);
+
+    const idA3 = await threading.processTurn(turn("session-a", "a3"), ["episode-a3"]);
+    assert.equal(idA3, threadA, "a just-used session must not be evicted before inactive ones");
+    assert.ok((await threading.loadThread(threadA))?.episodeIds.includes("episode-a2"));
+  } finally {
+    await cleanup();
+  }
+});
+
+test("concurrent turns for two sessions never share thread run state", async () => {
+  const { threading, cleanup } = await makeThreading();
+  try {
+    const realSave = threading.saveThread.bind(threading);
+    const aSaveEntered = Promise.withResolvers<void>();
+    const aGate = Promise.withResolvers<void>();
+    let holdArmed = false;
+    // Hold session A's save open, and only let it resume after session B has
+    // run a full processTurn to completion through the shared manager — the
+    // exact interleaving a shared run-state slot corrupts.
+    threading.saveThread = async (thread: ConversationThread): Promise<void> => {
+      if (holdArmed && thread.sessionKey === "session-a") {
+        aSaveEntered.resolve();
+        await aGate.promise;
+      }
+      await realSave(thread);
+    };
+    holdArmed = true;
+    const pendingA = threading.processTurn(turn("session-a", "a1"), []);
+    await aSaveEntered.promise;
+    const idB = await threading.processTurn(turn("session-b", "b1"), []);
+    aGate.resolve();
+    const idA = await pendingA;
+
+    assert.notEqual(idA, idB);
+    assert.equal((await threading.loadThread(idA))?.sessionKey, "session-a");
+    assert.equal((await threading.loadThread(idB))?.sessionKey, "session-b");
+
+    // Each session's follow-up turn must append to its OWN thread. With the
+    // shared slot, A resumed last and left its session key in the global
+    // state, so B's next turn sees "session-a" and starts a fresh thread.
+    assert.equal(await threading.processTurn(turn("session-a", "a2"), []), idA);
+    assert.equal(await threading.processTurn(turn("session-b", "b2"), []), idB);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("an in-flight session survives a 512-session flood arriving mid-await", async () => {
+  const { threading, cleanup } = await makeThreading();
+  try {
+    const threadA = await threading.processTurn(turn("session-a", "a1"), []);
+
+    const realSave = threading.saveThread.bind(threading);
+    const gate = Promise.withResolvers<void>();
+    const a2SaveEntered = Promise.withResolvers<void>();
+    let floodArmed = false;
+    threading.saveThread = async (thread: ConversationThread): Promise<void> => {
+      if (floodArmed && thread.id === threadA) {
+        a2SaveEntered.resolve();
+        await gate.promise;
+      }
+      await realSave(thread);
+    };
+    floodArmed = true;
+    const secondTurn = threading.processTurn(turn("session-a", "a2"), ["episode-a2"]);
+    await a2SaveEntered.promise;
+
+    // Session A is parked inside saveThread. 512 other sessions insert their
+    // run state while it waits; eviction must not take an in-flight session's
+    // state, or A's thread id is lost and its next turn starts a new thread.
+    for (let i = 0; i < 512; i++) {
+      await threading.processTurn(turn(`flood-${i}`, `flood ${i}`), []);
+    }
+    gate.resolve();
+
+    const idA2 = await secondTurn;
+    assert.equal(idA2, threadA, "resumed turn must still own its session's thread");
+    const idA3 = await threading.processTurn(turn("session-a", "a3"), ["episode-a3"]);
+    assert.equal(idA3, threadA);
+    assert.ok((await threading.loadThread(threadA))?.episodeIds.includes("episode-a2"));
+  } finally {
+    await cleanup();
+  }
+});

package/src/threading.ts

@@ -85,10 +85,56 @@ function parseConversationThread(raw: string): ConversationThread | null {
   }
 }
 
+/** One session's thread-run state: its current thread and last turn time. */
+interface ThreadingRunState {
+  currentThreadId: string | null;
+  lastTurnTimestamp: number | null;
+}
+
 export class ThreadingManager {
-  private currentThreadId: string | null = null;
-  private lastTurnTimestamp: number | null = null;
-  private lastSessionKey: string | null = 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.
+   */
+  private readonly runStateBySession = new Map<string, ThreadingRunState>();
+  /**
+   * 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).
+   */
+  private readonly inFlightRunStates = new Set<ThreadingRunState>();
+  private static readonly RUN_STATE_MAX_SESSIONS = 512;
+
+  private runStateFor(turn: BufferTurn): ThreadingRunState {
+    const key = turn.sessionKey ?? "";
+    let state = this.runStateBySession.get(key);
+    if (state) {
+      // Refresh recency: Map iteration is insertion-ordered, so re-putting a
+      // touched session makes eviction true LRU instead of first-in-first-out —
+      // an active session must not be the oldest entry just because it started
+      // first.
+      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) {
+          // Never evict the state being inserted: before the caller registers
+          // it in-flight, every older entry can be in flight and the loop
+          // would otherwise delete this turn's own state and fork the thread.
+          if (oldest === state || this.inFlightRunStates.has(oldest)) continue;
+          this.runStateBySession.delete(oldestKey);
+          if (this.runStateBySession.size <= ThreadingManager.RUN_STATE_MAX_SESSIONS) break;
+        }
+      }
+    }
+    return state;
+  }
 
   constructor(
     private readonly threadsDir: string,
@@ -164,18 +210,16 @@ export class ThreadingManager {
 
   /**
    * 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: BufferTurn): boolean {
     const turnTime = new Date(turn.timestamp).getTime();
-
-    // Different session key = new thread
-    if (turn.sessionKey && this.lastSessionKey && turn.sessionKey !== this.lastSessionKey) {
-      return true;
-    }
+    const state = this.runStateFor(turn);
 
     // Time gap > threshold = new thread
-    if (this.lastTurnTimestamp) {
-      const gapMs = turnTime - this.lastTurnTimestamp;
+    if (state.lastTurnTimestamp) {
+      const gapMs = turnTime - state.lastTurnTimestamp;
       const gapMinutes = gapMs / (1000 * 60);
       if (gapMinutes > this.gapMinutes) {
         return true;
@@ -183,7 +227,7 @@ export class ThreadingManager {
     }
 
     // No current thread = new thread
-    if (!this.currentThreadId) {
+    if (!state.currentThreadId) {
       return true;
     }
 
@@ -198,41 +242,45 @@ export class ThreadingManager {
     await this.ensureDirectory();
 
     const turnTime = new Date(turn.timestamp).getTime();
+    const state = this.runStateFor(turn);
+    this.inFlightRunStates.add(state);
+    try {
+      if (this.shouldStartNewThread(turn)) {
+        // Create new thread
+        const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+        const thread: ConversationThread = {
+          id: threadId,
+          title: "New Thread", // Will be updated later with keywords
+          createdAt: turn.timestamp,
+          updatedAt: turn.timestamp,
+          sessionKey: turn.sessionKey,
+          episodeIds: [...episodeIds],
+          linkedThreadIds: [],
+        };
 
-    if (this.shouldStartNewThread(turn)) {
-      // Create new thread
-      const threadId = `thread-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
-      const thread: ConversationThread = {
-        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) {
-      // Add episodes to current thread
-      const thread = await this.loadThread(this.currentThreadId);
-      if (thread) {
-        for (const id of episodeIds) {
-          if (!thread.episodeIds.includes(id)) {
-            thread.episodeIds.push(id);
+        await this.saveThread(thread);
+        state.currentThreadId = threadId;
+        log.debug(`created new thread ${threadId}`);
+      } else if (state.currentThreadId) {
+        // Add episodes to current thread
+        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);
       }
-    }
 
-    this.lastTurnTimestamp = turnTime;
-    this.lastSessionKey = turn.sessionKey ?? null;
+      state.lastTurnTimestamp = turnTime;
 
-    return this.currentThreadId!;
+      return state.currentThreadId!;
+    } finally {
+      this.inFlightRunStates.delete(state);
+    }
   }
 
   /**
@@ -378,18 +426,20 @@ export class ThreadingManager {
   }
 
   /**
-   * 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(): string | null {
-    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(): void {
-    this.currentThreadId = null;
-    this.lastTurnTimestamp = null;
-    this.lastSessionKey = null;
+    this.runStateBySession.clear();
   }
 }