@remnic/core 10.0.30 → 10.0.31

package/src/buffer.ts

@@ -10,8 +10,9 @@ import type {
   PluginConfig,
   SignalLevel,
 } from "./types.js";
-import { resolvePresentationCapabilities } from "./capabilities.js";
+import { resolvePresentationCapabilities, resolveNamespaceCapabilities } from "./capabilities.js";
 import { resolvePrincipal } from "./namespaces/principal.js";
+import { scopeProfilePlanIdentity } from "./buffer-turn-helpers.js";
 import { ExtractionDeadlineError } from "./orchestration/extraction-run.js";
 import type { ExtractionBufferSnapshot } from "./extraction-liveness.js";
 import {
@@ -20,9 +21,11 @@ import {
   bufferTurnsEqual,
   copyBufferTurn,
   describeError,
+  hasPinnedCaptureScope,
   liveTurnsFromExtractionSnapshot,
   matchingQueuedExtractionPrefixLength,
   probeWithTimeout,
+  selectRetainedDeferredTurns,
 } from "./buffer-turn-helpers.js";
 
 export type TriggerDecision = "extract_now" | "extract_batch" | "keep_buffering";
@@ -35,6 +38,11 @@ export interface AddTurnOutcome {
 export interface RetainedTurnCleanupOptions {
   abortSignal?: AbortSignal;
   deadlineMs?: number;
+  /** Keep cleanup within the accepted namespace. */
+  writeNamespaceOverride?: string;
+  /** Match the original profile and project binding, not just its write namespace. */
+  scopeProfileWritePlan?: import("./namespaces/scope-profiles.js").ResolvedScopeProfilePlan | null;
+  codingContext?: import("./types.js").CodingContext;
 }
 
 /**
@@ -65,6 +73,8 @@ export interface BufferSurpriseProbe {
 }
 
 const MAX_BUFFER_ENTRY_COUNT = 200;
+const isAcceptedTurn = (t: { acceptedCapture?: boolean; writeNamespaceOverride?: string }): boolean =>
+  t.acceptedCapture === true || t.writeNamespaceOverride !== undefined;
 
 /**
  * Upper bound on how long a debounced buffer save may be deferred under
@@ -272,7 +282,13 @@ export class SmartBuffer {
       if (leftAt !== rightAt) return leftAt - rightAt;
       return (insertionOrder.get(left) ?? 0) - (insertionOrder.get(right) ?? 0);
     };
-    const candidates = keys.filter((key) => key !== "default" && !retainKeys.includes(key));
+    const candidates = keys.filter(
+      (key) =>
+        key !== "default" &&
+        !retainKeys.includes(key) &&
+        // #3251: accepted captures exit via refusal/backpressure, never eviction.
+        !this.entryHoldsAcceptedCapture(entries[key]),
+    );
     const emptyRemovable = candidates
       .filter((key) => (entries[key]?.turns.length ?? 0) === 0)
       .sort(byOldestActivity);
@@ -524,11 +540,66 @@ export class SmartBuffer {
     return (await this.addTurnWithOutcome(bufferKey, turn)).decision;
   }
 
+  /** Admit atomically; refuse at capacity rather than evict accepted work. */
+  async addTurnBounded(bufferKey: string, turn: BufferTurn): Promise<AddTurnOutcome | null> {
+    const mutation = await this.enqueueMutation(async () => {
+      await this.loadUnlocked();
+      if (this.peekEntry(bufferKey) === null) {
+        this.makeRoomForEntryUnlocked();
+        if (Object.keys(this.state.entries ?? {}).length >= MAX_BUFFER_ENTRY_COUNT) {
+          log.warn(
+            `buffer[${bufferKey}]: durable capture refused at MAX_BUFFER_ENTRY_COUNT=${MAX_BUFFER_ENTRY_COUNT}`,
+          );
+          return null;
+        }
+      }
+      return this.recordTurnUnlocked(bufferKey, turn);
+    });
+    if (mutation === null) return null;
+    return this.completeAddTurnOutcome(bufferKey, turn, mutation);
+  }
+
+  /** Prune empty entries only; accepted work must survive capacity pressure. */
+  private makeRoomForEntryUnlocked(): void {
+    const entries = this.state.entries;
+    if (!entries) return;
+    const keys = Object.keys(entries);
+    if (keys.length < MAX_BUFFER_ENTRY_COUNT) return;
+    const byOldestActivity = (left: string, right: string): number =>
+      this.entryActivityAt(entries[left] ?? { turns: [], lastExtractionAt: null, extractionCount: 0 }) -
+      this.entryActivityAt(entries[right] ?? { turns: [], lastExtractionAt: null, extractionCount: 0 });
+    const emptyRemovable = keys
+      .filter(
+        (key) =>
+          key !== "default" &&
+          (entries[key]?.turns.length ?? 0) === 0 &&
+          (entries[key]?.retainedTurns?.length ?? 0) === 0,
+      )
+      .sort(byOldestActivity);
+    for (const key of emptyRemovable) {
+      if (Object.keys(entries).length < MAX_BUFFER_ENTRY_COUNT) break;
+      delete entries[key];
+    }
+  }
+
+  private entryHoldsAcceptedCapture(entry: BufferEntryState | undefined): boolean {
+    return (entry?.turns ?? []).some(isAcceptedTurn) || (entry?.retainedTurns ?? []).some(isAcceptedTurn);
+  }
+
   async addTurnWithOutcome(
     bufferKey: string,
     turn: BufferTurn,
   ): Promise<AddTurnOutcome> {
     const mutation = await this.enqueueMutation(() => this.recordTurnUnlocked(bufferKey, turn));
+    return this.completeAddTurnOutcome(bufferKey, turn, mutation);
+  }
+
+  /** Run probes outside the mutation lock to avoid reentrancy deadlocks. */
+  private async completeAddTurnOutcome(
+    bufferKey: string,
+    turn: BufferTurn,
+    mutation: AddTurnMutationResult,
+  ): Promise<AddTurnOutcome> {
     let decision = mutation.decision;
     let extractionTurns: BufferTurn[] | undefined;
 
@@ -874,61 +945,20 @@ export class SmartBuffer {
     bufferKey: string,
     turns: BufferTurn[],
     max = 10,
+    originalTurns?: readonly BufferTurn[],
   ): Promise<void> {
     await this.enqueueMutation(async () => {
       await this.loadUnlocked();
       const entry = this.entryFor(bufferKey);
-      if (!Array.isArray(turns) || turns.length === 0 || max <= 0) {
-        delete entry.retainedTurns;
-      } else {
-        // Guard `slice(-max)` against `max === 0` (CLAUDE.md gotcha 27):
-        // `slice(-0)` equals `slice(0)` and would return ALL entries. We
-        // already early-return above when max <= 0.
-        const tail = turns.slice(-max);
-        // Copy explicit fields only — never spread an external object into a
-        // plain object because spread preserves any own `__proto__` /
-        // `constructor` keys that may have arrived via JSON deserialization
-        // of untrusted input (CodeQL js/prototype-polluting-assignment).
-        entry.retainedTurns = tail.map<BufferTurn>((t) => {
-          const copy: BufferTurn = {
-            role: t.role,
-            content: typeof t.content === "string" ? t.content : "",
-            timestamp:
-              typeof t.timestamp === "string"
-                ? t.timestamp
-                : new Date().toISOString(),
-          };
-          if (typeof t.sessionKey === "string") copy.sessionKey = t.sessionKey;
-          if (typeof t.sessionOwnerPrincipal === "string") {
-            copy.sessionOwnerPrincipal = t.sessionOwnerPrincipal;
-          }
-          if (typeof t.logicalSessionKey === "string") {
-            copy.logicalSessionKey = t.logicalSessionKey;
-          }
-          if (
-            t.providerThreadId === null ||
-            typeof t.providerThreadId === "string"
-          ) {
-            copy.providerThreadId = t.providerThreadId;
-          }
-          if (typeof t.turnFingerprint === "string") {
-            copy.turnFingerprint = t.turnFingerprint;
-          }
-          if (typeof t.persistProcessedFingerprint === "boolean") {
-            copy.persistProcessedFingerprint = t.persistProcessedFingerprint;
-          }
-          if (typeof t.sourceConnector === "string") copy.sourceConnector = t.sourceConnector;
-          if (t.originRole === "user" || t.originRole === "assistant" || t.originRole === "tool") {
-            copy.originRole = t.originRole;
-          }
-          return copy;
-        });
-      }
+      const retained = selectRetainedDeferredTurns(
+        entry.retainedTurns ?? [], turns, max, originalTurns,
+      );
+      if (retained.length > 0) entry.retainedTurns = retained;
+      else delete entry.retainedTurns;
       await this.saveUnlocked();
     });
   }
 
-
   /**
    * Return the current retention window (issue #562, PR 2). Primarily for
    * tests and diagnostics.
@@ -953,6 +983,11 @@ export class SmartBuffer {
       typeof ownerPrincipal === "string" && ownerPrincipal.trim().length > 0
         ? ownerPrincipal.trim()
         : undefined;
+    const namespacesEnabled = resolveNamespaceCapabilities(this.config).namespaces === true;
+    const normalizedCleanupNamespace =
+      namespacesEnabled && options.writeNamespaceOverride !== undefined && options.writeNamespaceOverride.length > 0
+        ? options.writeNamespaceOverride
+        : undefined;
     const assertLifecycle = (): void => {
       throwIfAborted(options.abortSignal, "extraction force-flush aborted");
       if (typeof options.deadlineMs === "number" && Date.now() >= options.deadlineMs) {
@@ -978,8 +1013,39 @@ export class SmartBuffer {
         return;
       }
       let changed = false;
+      const matchesCleanupScope = (turn: BufferTurn): boolean => {
+        // Legacy unpinned turns keep their existing cleanup semantics.
+        if (
+          turn.writeNamespaceOverride !== undefined &&
+          normalizedCleanupNamespace !== undefined &&
+          turn.writeNamespaceOverride !== normalizedCleanupNamespace
+        ) {
+          return false;
+        }
+        // Equal write namespaces can still belong to different project bindings.
+        if (options.scopeProfileWritePlan && hasPinnedCaptureScope(turn)) {
+          if (
+            scopeProfilePlanIdentity(turn.scopeProfileWritePlan) !== scopeProfilePlanIdentity(options.scopeProfileWritePlan) &&
+            !(turn.acceptedCapture === true && turn.scopeProfileWritePlan === undefined)
+          ) {
+            return false;
+          }
+          const ctx = options.codingContext;
+          if (
+            ctx && turn.codingContext &&
+            (turn.codingContext.projectId !== ctx.projectId ||
+              turn.codingContext.rootPath !== ctx.rootPath ||
+              turn.codingContext.branch !== ctx.branch ||
+              turn.codingContext.defaultBranch !== ctx.defaultBranch)
+          ) {
+            return false;
+          }
+        }
+        return true;
+      };
       const belongsToOwner = (turn: BufferTurn): boolean => {
         if (turn.sessionKey !== sessionKey) return false;
+        if (!matchesCleanupScope(turn)) return false;
         if (normalizedOwnerPrincipal === undefined) return true;
         if (turn.sessionOwnerPrincipal === normalizedOwnerPrincipal) return true;
         return (

package/src/namespaces/scope-profiles.ts

@@ -87,7 +87,7 @@ function scopeProfileSelfNamespace(principal: string | undefined, config: Plugin
   return derivedScopeProfileSelfNamespace(principal, config) ?? existing;
 }
 
-function hasExplicitNamespacePolicy(namespace: string, config: PluginConfig): boolean {
+export function hasExplicitNamespacePolicy(namespace: string, config: PluginConfig): boolean {
   const identity = normalizeNamespaceIdentity(namespace);
   return (config.namespacePolicies ?? []).some(
     (policy) => normalizeNamespaceIdentity(policy.name) === identity,

package/src/orchestration/extraction-run.ts

@@ -1108,7 +1108,7 @@ export class ExtractionRunCoordinator {
       normalizedTurns: normalizedTurns as BufferTurn[],
       bufferKey,
       retainDeferredTurns: (key, retainedTurns, max) =>
-        this.deps.getBuffer().retainDeferredTurns(key, retainedTurns, max),
+        this.deps.getBuffer().retainDeferredTurns(key, retainedTurns, max, turns),
       clearBuffer,
       failOnExtractionFailure: options.failOnExtractionFailure === true,
     });

package/src/orchestration/session-context.ts

@@ -28,6 +28,7 @@ import type { ExtractionRunResult } from "./extraction-run.js";
 import type { EntitySynthesisCoordinator } from "./entity-synthesis-coordinator.js";
 import type { BufferTurn, CodingContext, DaySummaryResult, MemoryFile, PluginConfig } from "../types.js";
 import type { ResolvedScopeProfilePlan } from "../namespaces/scope-profiles.js";
+import { groupTurnsByExtractionScope, hasPinnedCaptureScope, scopeProfilePlanIdentity } from "../buffer-turn-helpers.js";
 import {
   Orchestrator,
 } from "../orchestrator.js";
@@ -103,6 +104,12 @@ export interface SessionFlushOptions {
   /** Resolved profile plan from access scope resolution; avoids recomputing from shared session context. */
   scopeProfileWritePlan?: ResolvedScopeProfilePlan | null;
   principalOverride?: string;
+  /**
+   * #3251: the ALREADY-resolved native coding context this flush's plan was
+   * resolved with — plan-pinned flushes drain only captures bound to the
+   * SAME project identity.
+   */
+  codingContext?: CodingContext;
 }
 
 /** Scoped flushes must never claim an opaque buffer without trusted ingestion ownership. */
@@ -475,8 +482,49 @@ export class SessionContextCoordinator {
       ownershipEnforced &&
       ownerPrincipal !== undefined &&
       (resolvedSessionPrincipal === undefined || resolvedSessionPrincipal === "default");
+    // #3251: the flush's effective write namespace. An explicit override pins
+    // it; otherwise it is the session principal's default store. Only PINNED
+    // captures are namespace-compared — legacy unpinned turns keep their
+    // prior semantics (any flush of their session drains them), while a
+    // pinned capture is never drained under a different namespace.
+    const flushNamespace =
+      options.writeNamespaceOverride !== undefined
+        ? options.writeNamespaceOverride
+        : namespacesEnabled && this.deps.config
+          ? defaultNamespaceForPrincipal(resolvePrincipal(sessionKey, this.deps.config), this.deps.config)
+          : undefined;
     const belongsToSession = (turn: BufferTurn): boolean => {
       if (turn.sessionKey !== sessionKey) return false;
+      if (
+        namespacesEnabled &&
+        turn.writeNamespaceOverride !== undefined &&
+        turn.writeNamespaceOverride !== flushNamespace
+      ) {
+        return false;
+      }
+      // Existing profile pins require the same profile and project binding.
+      // Accepted no-plan captures stay unprofiled within the matching namespace.
+      const flushPlanIdentity = scopeProfilePlanIdentity(options.scopeProfileWritePlan);
+      if (flushPlanIdentity !== "" && hasPinnedCaptureScope(turn)) {
+        if (
+          scopeProfilePlanIdentity(turn.scopeProfileWritePlan) !== flushPlanIdentity &&
+          !(turn.acceptedCapture === true && turn.scopeProfileWritePlan === undefined)
+        ) {
+          return false;
+        }
+        // Compare bindings only when the ORIGINAL capture is context-bound —
+        // an unbound capture must not be orphaned by a project attached later.
+        if (
+          options.codingContext &&
+          turn.codingContext &&
+          (turn.codingContext.projectId !== options.codingContext.projectId ||
+            turn.codingContext.rootPath !== options.codingContext.rootPath ||
+            turn.codingContext.branch !== options.codingContext.branch ||
+            turn.codingContext.defaultBranch !== options.codingContext.defaultBranch)
+        ) {
+          return false;
+        }
+      }
       if (!ownershipEnforced || ownerPrincipal === undefined) return true;
       if (turn.sessionOwnerPrincipal === ownerPrincipal) return true;
       return (
@@ -499,60 +547,80 @@ export class SessionContextCoordinator {
     }
     for (const bufferKey of bufferKeys) {
       const turns = this.deps.buffer.getTurns(bufferKey);
-      const turnsForSession = scopedRequest ? turns.filter(belongsToSession) : turns;
+      // #3251: EVERY flush filters — unqualified lifecycle drains must not
+      // clear another namespace's pinned capture; single-store mode no-ops
+      // the filter (namespacesEnabled gate inside belongsToSession).
+      const turnsForSession = turns.filter(belongsToSession);
       if (turnsForSession.length === 0) continue;
-      const retainedTurnsForOtherSessions =
-        scopedRequest && typeof this.deps.buffer.getRetainedDeferredTurns === "function"
-          ? this.deps.buffer
-              .getRetainedDeferredTurns(bufferKey)
-              .filter((turn) => !belongsToSession(turn))
-          : [];
-      try {
-        await new Promise<void>((resolve, reject) => {
-          void this.deps.queueBufferedExtraction(turnsForSession, "trigger_mode", {
-            bufferKey,
-            clearBufferAfterExtraction: true,
-            skipDedupeCheck: true,
-            skipCharThreshold: true,
-            skipUserTurnThreshold: true,
-            failOnExtractionFailure: options.failOnExtractionFailure === true,
-            forceExtractionAttempt: true,
-            abortSignal: options.abortSignal,
-            extractionDeadlineMs: options.extractionDeadlineMs,
-            writeNamespaceOverride: options.writeNamespaceOverride,
-            principalOverride: options.principalOverride,
-            scopeProfileWritePlan: options.scopeProfileWritePlan,
-            clearMatchingTurns: options.clearMatchingTurns ?? scopedRequest,
-            onDurableCommit: options.onCommitted,
-            onTaskSettled: (error) => (error ? reject(error) : resolve()),
-          })
-            .catch(reject);
-        });
-        if (options.reason === "session_end" && this.deps.config.sessionExperience?.enabled === true) {
-          await this.extractSessionEndExperience(turnsForSession, sessionKey, options);
+      const scopeGroups = groupTurnsByExtractionScope(turnsForSession);
+      // Filtered or grouped slices need identity clearing rather than prefix clearing.
+      const needsIdentityClear =
+        turnsForSession.length < turns.length || scopeGroups.length > 1;
+      const namespacesOn = this.deps.config
+        ? resolveNamespaceCapabilities(this.deps.config).namespaces === true
+        : true;
+      for (const group of scopeGroups) {
+        const groupPinned =
+          group.writeNamespaceOverride !== undefined ||
+          group.principalOverride !== undefined ||
+          group.scopeProfileWritePlan !== undefined;
+        // Preserve groups captured under another profile or project binding;
+        // the binding compares only when the ORIGINAL group is context-bound.
+        if (
+          group.scopeProfileWritePlan &&
+          options.scopeProfileWritePlan &&
+          (scopeProfilePlanIdentity(group.scopeProfileWritePlan) !==
+            scopeProfilePlanIdentity(options.scopeProfileWritePlan) ||
+            (options.codingContext &&
+              group.codingContext &&
+              (group.codingContext.projectId !== options.codingContext.projectId ||
+                group.codingContext.rootPath !== options.codingContext.rootPath ||
+                group.codingContext.branch !== options.codingContext.branch ||
+                group.codingContext.defaultBranch !== options.codingContext.defaultBranch)))
+        ) {
+          continue;
         }
-      } finally {
+        // Force-flush must reject preserved work before retained-turn cleanup can run.
         if (
-          retainedTurnsForOtherSessions.length > 0 &&
-          typeof this.deps.buffer.retainDeferredTurns === "function"
+          groupPinned &&
+          !namespacesOn &&
+          group.writeNamespaceOverride !== undefined &&
+          group.writeNamespaceOverride !== this.deps.config?.defaultNamespace
         ) {
-          const retainedAfterExtraction = this.deps.buffer.getRetainedDeferredTurns(bufferKey);
-          await this.deps.buffer
-            .retainDeferredTurns(
-              bufferKey,
-              [
-                ...retainedAfterExtraction.filter((turn) => belongsToSession(turn)),
-                ...retainedTurnsForOtherSessions,
-              ],
-              10,
-            )
-            .catch((error: unknown) => {
-              log.warn(
-                `session flush could not restore retained turns for other sessions in ${bufferKey}`,
-                error,
-              );
-            });
+          if (options.failOnExtractionFailure === true) {
+            throw new Error(
+              `accepted capture preserved: pinned_namespace_unavailable (${group.writeNamespaceOverride})`,
+            );
+          }
+          log.warn(
+            `flushSession: pinned namespace ${group.writeNamespaceOverride} unavailable while namespaces are disabled; capture stays pending`,
+          );
+          continue;
         }
+        const { promise, resolve, reject } = Promise.withResolvers<void>();
+        void this.deps.queueBufferedExtraction(group.turns, "trigger_mode", {
+          bufferKey,
+          clearBufferAfterExtraction: true,
+          skipDedupeCheck: true,
+          skipCharThreshold: true,
+          skipUserTurnThreshold: true,
+          failOnExtractionFailure: options.failOnExtractionFailure === true,
+          forceExtractionAttempt: true,
+          abortSignal: options.abortSignal,
+          extractionDeadlineMs: options.extractionDeadlineMs,
+          writeNamespaceOverride: group.writeNamespaceOverride ?? options.writeNamespaceOverride,
+          principalOverride: group.principalOverride ?? options.principalOverride,
+          scopeProfileWritePlan: group.turns.some((turn) => turn.acceptedCapture === true)
+            ? group.scopeProfileWritePlan ?? null
+            : group.scopeProfileWritePlan ?? options.scopeProfileWritePlan,
+          clearMatchingTurns: options.clearMatchingTurns === true || scopedRequest || groupPinned || needsIdentityClear,
+          onDurableCommit: options.onCommitted,
+          onTaskSettled: (error) => (error ? reject(error) : resolve()),
+        }).catch(reject);
+        await promise;
+      }
+      if (options.reason === "session_end" && this.deps.config.sessionExperience?.enabled === true) {
+        await this.extractSessionEndExperience(turnsForSession, sessionKey, options);
       }
     }
   }