@remnic/core 9.63.3 → 9.63.4

package/src/admin/admin-surfaces.test.ts

@@ -200,20 +200,15 @@ test("listAdminNamespaces lists configured + discovered namespaces and marks sta
   }
 });
 
-test("listAdminNamespaces filters by principal", async () => {
+test("listAdminNamespaces filters by kind", async () => {
   const memoryDir = await makeTempDir();
   try {
-    const config = makeConfig({
-      memoryDir,
-      namespacePolicies: [
-        { name: "alice", readPrincipals: ["alice"], writePrincipals: ["alice"] },
-        { name: "bob", readPrincipals: ["bob"], writePrincipals: ["bob"] },
-      ],
-    });
+    const config = makeConfig({ memoryDir });
     const catalog = new NamespaceCatalog(config);
     await catalog.registerConfiguredNamespaces();
-    const result = await listAdminNamespaces({ catalog, filter: { principal: "alice" } });
-    assert.ok(result.entries.every((entry) => entry.principal === "alice"));
+    const result = await listAdminNamespaces({ catalog, filter: { kind: "default" } });
+    assert.ok(result.entries.length > 0, "default kind filter must return the default namespace");
+    assert.ok(result.entries.every((entry) => entry.kind === "default"));
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }

package/src/admin/admin-surfaces.ts

@@ -322,8 +322,6 @@ export function inspectScope(options: InspectScopeOptions): ScopeInspection {
 /** Filters the namespace browser accepts (superset of {@link NamespaceCatalogFilter}). */
 export interface AdminNamespaceFilter {
   kind?: NamespaceRecord["kind"];
-  principal?: string;
-  projectId?: string;
   discoveredBy?: NamespaceRecord["discoveredBy"];
   /** Only namespaces with a write at/after this instant. */
   writtenSince?: Date;
@@ -336,10 +334,6 @@ export interface AdminNamespaceEntry {
   namespace: string;
   identityToken: string;
   kind: NamespaceRecord["kind"];
-  principal?: string;
-  projectId?: string;
-  branch?: string;
-  parentNamespace?: string;
   createdAt: string;
   lastReadAt?: string;
   lastWriteAt?: string;
@@ -386,12 +380,6 @@ export async function listAdminNamespaces(options: ListAdminNamespacesOptions):
 
   let entries: AdminNamespaceEntry[] = records.map((record) => toAdminEntry(record, staleBefore));
 
-  if (filter?.principal) {
-    entries = entries.filter((entry) => entry.principal === filter.principal);
-  }
-  if (filter?.projectId) {
-    entries = entries.filter((entry) => entry.projectId === filter.projectId);
-  }
   if (filter?.staleBefore) {
     const cutoff = filter.staleBefore.getTime();
     entries = entries.filter((entry) => {
@@ -411,10 +399,6 @@ function toAdminEntry(record: NamespaceRecord, staleBefore: Date): AdminNamespac
     namespace: record.namespace,
     identityToken: record.identityToken,
     kind: record.kind,
-    principal: record.principal,
-    projectId: record.projectId,
-    branch: record.branch,
-    parentNamespace: record.parentNamespace,
     createdAt: record.createdAt,
     lastReadAt: record.lastReadAt,
     lastWriteAt: record.lastWriteAt,

package/src/binary-lifecycle/pipeline.test.ts

@@ -587,7 +587,7 @@ test("binary lifecycle resumes redirects after verification read failures", asyn
     assert.match(firstResult.errors.join("\n"), /injected verification read failure/);
     assert.equal(await readFile(notePath, "utf8"), "![img](remote/image.png)");
     assert.equal(manifest.assets[0]?.status, "error");
-    assert.equal(typeof manifest.assets[0]?.redirectedAt, "string");
+    assert.equal(manifest.assets[0]?.redirectedAt, undefined);
 
     const secondResult = await runBinaryLifecyclePipeline(memoryDir, baseConfig, nestedRemoteBackend, noopLogger);
     manifest = JSON.parse(

package/src/binary-lifecycle/pipeline.ts

@@ -294,11 +294,25 @@ async function stageRedirect(
         }
 
         if (asset.redirectedAt === undefined) {
-          if (!dryRun) {
-            asset.status = "mirrored";
+          let remoteSeen = false;
+          for (const mdPath of mdFiles) {
+            try {
+              const content = await readMarkdownFile(mdPath);
+              if (content.includes(asset.mirroredPath)) {
+                remoteSeen = true;
+                break;
+              }
+            } catch {
+              // Verify already succeeded; a later read error is not a local ref.
+            }
+          }
+          if (!remoteSeen) {
+            if (!dryRun) {
+              asset.status = "mirrored";
+            }
+            log.info(`[binary-lifecycle] preserved mirrored asset without redirected marker: ${asset.originalPath}${dryRun ? " [dry-run]" : ""}`);
+            continue;
           }
-          log.info(`[binary-lifecycle] preserved mirrored asset without redirected marker: ${asset.originalPath}${dryRun ? " [dry-run]" : ""}`);
-          continue;
         }
 
         if (!Number.isFinite(new Date(asset.mirroredAt).getTime())) {
@@ -400,9 +414,6 @@ async function stageRedirect(
       continue;
     }
 
-    const redirectedAt = new Date().toISOString();
-    asset.redirectedAt = redirectedAt;
-
     const verifyResult = await countRemainingLocalReferences(
       memoryDir,
       asset,
@@ -411,7 +422,10 @@ async function stageRedirect(
       readMarkdownFile,
     );
     if (verifyResult.errors.length > 0 || verifyResult.remaining > 0) {
-      asset.status = "error";
+asset.status = "error";
+// Failed verify must not read as a completed redirect (#2471); this also
+// clears stale stamps written by manifests from before that fix.
+delete asset.redirectedAt;
       for (const msg of verifyResult.errors) {
         log.error(`[binary-lifecycle] ${msg}`);
         errors.push(msg);
@@ -424,7 +438,7 @@ async function stageRedirect(
       continue;
     }
     asset.status = "redirected";
-    asset.redirectedAt = redirectedAt;
+asset.redirectedAt = new Date().toISOString();
     redirected++;
     log.info(`[binary-lifecycle] redirected: ${asset.originalPath}`);
   }

package/src/buffer.ts

@@ -619,6 +619,12 @@ export class SmartBuffer {
     log.debug(
       `buffer[${bufferKey}]: ${mutation.turnCountInWindow} turns, signal=${mutation.signalLevel}, decision=${decision}`,
     );
+    if (decision !== "keep_buffering" && extractionTurns === undefined) {
+      extractionTurns = [
+        ...mutation.retainedTurnsSnapshot,
+        ...mutation.activeTurnsSnapshot,
+      ];
+    }
     return extractionTurns ? { decision, extractionTurns } : { decision };
   }
 

package/src/maintenance/namespace-planner.ts

@@ -177,8 +177,6 @@ function candidatePriority(candidate: NamespaceMaintenanceCandidate): number {
   if (candidate.source === "configured") return 2;
   if (candidate.kind === "team-project") return 3;
   if (candidate.kind === "project") return 4;
-  if (candidate.kind === "self") return 5;
-  if (candidate.kind === "legacy") return 6;
   if (candidate.kind === "branch") return 8;
   return 7;
 }

package/src/namespaces/catalog.test.ts

@@ -600,15 +600,16 @@ test("catalog quarantines malformed JSONL record fields at the parse boundary",
 
     assert.deepEqual(
       list.map((r) => r.namespace),
-      ["valid"],
-      "invalid enum/token/timestamp records must not surface",
+      ["bad-kind", "valid"],
+      "unknown kinds coerce to explicit; other malformed records stay quarantined",
     );
-    assert.equal(list[0]?.identityToken, validToken);
-    assert.equal(list[0]?.kind, "project");
-    assert.equal(list[0]?.discoveredBy, "write");
-    assert.equal(list[0]?.lastReadAt, undefined);
-    assert.equal(list[0]?.lastWriteAt, undefined);
-    assert.deepEqual(list[0]?.lastMaintenanceAt, { ok: now });
+    assert.equal(list.find((r) => r.namespace === "bad-kind")?.kind, "explicit");
+    const valid = list.find((r) => r.namespace === "valid");
+    assert.equal(valid?.kind, "project");
+    assert.equal(valid?.discoveredBy, "write");
+    assert.equal(valid?.lastReadAt, undefined);
+    assert.equal(valid?.lastWriteAt, undefined);
+    assert.deepEqual(valid?.lastMaintenanceAt, { ok: now });
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }
@@ -3952,3 +3953,47 @@ test("#1903 cross-instance compaction never drops another instance's rows", asyn
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
+
+test("#2469 persisted self/legacy kinds coerce to explicit and drop unused hints", async () => {
+  const memoryDir = await mkMemoryDir();
+  try {
+    const ns = "project-origin-dead-kind";
+    const token = namespaceIdentityToken(ns);
+    const stateDir = path.join(memoryDir, "state");
+    await mkdir(stateDir, { recursive: true });
+    const line = JSON.stringify({
+      namespace: ns,
+      identityToken: token,
+      kind: "self",
+      principal: "unused",
+      projectId: "unused",
+      branch: "unused",
+      parentNamespace: "unused",
+      createdAt: "2026-08-17T00:00:00.000Z",
+      storageDir: path.join(memoryDir, "namespaces", token),
+      discoveredBy: "write",
+    });
+    const legacyLine = JSON.stringify({
+      namespace: "shared",
+      identityToken: namespaceIdentityToken("shared"),
+      kind: "legacy",
+      createdAt: "2026-08-17T00:00:00.000Z",
+      storageDir: path.join(memoryDir, "namespaces", namespaceIdentityToken("shared")),
+      discoveredBy: "config",
+    });
+    await writeFile(path.join(stateDir, "namespaces.jsonl"), `${line}\n${legacyLine}\n`, "utf8");
+
+    const catalog = new NamespaceCatalog(makeConfig(memoryDir));
+    const selfRecord = await catalog.getNamespaceRecord(ns);
+    assert.equal(selfRecord?.kind, "explicit");
+    assert.equal(
+      (selfRecord as { principal?: string } | null)?.principal,
+      undefined,
+    );
+    const legacyRecord = await catalog.getNamespaceRecord("shared");
+    assert.equal(legacyRecord?.kind, "explicit");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+

package/src/namespaces/catalog.ts

@@ -59,13 +59,11 @@ import { ALL_CATEGORY_DIRS } from "../utils/category-dir.js";
 
 export type NamespaceKind =
   | "default"
-  | "self"
   | "shared"
   | "project"
   | "branch"
   | "team-project"
-  | "explicit"
-  | "legacy";
+  | "explicit";
 
 export type NamespaceDiscoverySource = "config" | "write" | "read" | "scan" | "migration";
 
@@ -73,10 +71,6 @@ export interface NamespaceRecord {
   namespace: string;
   identityToken: string;
   kind: NamespaceKind;
-  principal?: string;
-  projectId?: string;
-  branch?: string;
-  parentNamespace?: string;
   createdAt: string;
   lastReadAt?: string;
   lastWriteAt?: string;
@@ -95,10 +89,6 @@ export interface NamespaceCatalogFilter {
 export interface NamespaceTouchMetadata {
   discoveredBy?: NamespaceDiscoverySource;
   kind?: NamespaceKind;
-  principal?: string;
-  projectId?: string;
-  branch?: string;
-  parentNamespace?: string;
   /** Explicit storage dir (when the caller already resolved it). */
   storageDir?: string;
   /** Override the touch timestamp (mainly for tests / migration replay). */
@@ -129,13 +119,11 @@ export interface NamespaceCatalogRebuildResult {
 
 const NAMESPACE_KINDS: readonly NamespaceKind[] = [
   "default",
-  "self",
   "shared",
   "project",
   "branch",
   "team-project",
   "explicit",
-  "legacy",
 ];
 
 const NAMESPACE_DISCOVERY_SOURCES: readonly NamespaceDiscoverySource[] = [
@@ -275,7 +263,7 @@ function isValidIsoTimestamp(value: string): boolean {
   return Number.isFinite(ms);
 }
 
-function isNamespaceKind(value: unknown): value is NamespaceKind {
+export function isNamespaceKind(value: unknown): value is NamespaceKind {
   return typeof value === "string" && (NAMESPACE_KINDS as readonly string[]).includes(value);
 }
 
@@ -301,8 +289,7 @@ function coerceRecord(value: unknown): NamespaceRecord | null {
   if (typeof v.storageDir !== "string" || v.storageDir.length === 0) return null;
   if (typeof v.createdAt !== "string" || v.createdAt.length === 0) return null;
   if (!isValidIsoTimestamp(v.createdAt)) return null;
-  const kind = v.kind === undefined ? "explicit" : isNamespaceKind(v.kind) ? v.kind : null;
-  if (!kind) return null;
+  const kind = isNamespaceKind(v.kind) ? v.kind : "explicit";
   const discoveredBy =
     v.discoveredBy === undefined
       ? "scan"
@@ -318,10 +305,6 @@ function coerceRecord(value: unknown): NamespaceRecord | null {
     storageDir: v.storageDir,
     discoveredBy,
   };
-  if (typeof v.principal === "string") record.principal = v.principal;
-  if (typeof v.projectId === "string") record.projectId = v.projectId;
-  if (typeof v.branch === "string") record.branch = v.branch;
-  if (typeof v.parentNamespace === "string") record.parentNamespace = v.parentNamespace;
   if (typeof v.lastReadAt === "string" && isValidIsoTimestamp(v.lastReadAt)) {
     record.lastReadAt = v.lastReadAt;
   }
@@ -792,12 +775,6 @@ export class NamespaceCatalog {
     if (kind === "read" && cached.lastReadAt === undefined) return true;
     if (!metadata) return false;
     if (metadata.kind !== undefined && metadata.kind !== cached.kind) return true;
-    if (metadata.principal !== undefined && metadata.principal !== cached.principal) return true;
-    if (metadata.projectId !== undefined && metadata.projectId !== cached.projectId) return true;
-    if (metadata.branch !== undefined && metadata.branch !== cached.branch) return true;
-    if (metadata.parentNamespace !== undefined && metadata.parentNamespace !== cached.parentNamespace) {
-      return true;
-    }
     // A changed storageDir repoints routing/containment for this namespace —
     // must be observable at once, not held stale by the coalesce window (#1903, Cursor).
     if (metadata.storageDir !== undefined && metadata.storageDir !== cached.storageDir) return true;
@@ -1399,15 +1376,10 @@ export class NamespaceCatalog {
                 (kind === "register" ? "config" : kind === "maintenance" ? "scan" : kind),
             };
 
-        // Update mutable fields. storageDir, kind, and the principal/project hints
-        // may legitimately change over a namespace's lifetime, so they upsert.
+        // Update mutable fields. storageDir and kind may change over a
+        // namespace's lifetime, so they upsert.
         record.storageDir = storageDir;
         if (metadata?.kind) record.kind = metadata.kind;
-        if (metadata?.principal !== undefined) record.principal = metadata.principal;
-        if (metadata?.projectId !== undefined) record.projectId = metadata.projectId;
-        if (metadata?.branch !== undefined) record.branch = metadata.branch;
-        if (metadata?.parentNamespace !== undefined)
-          record.parentNamespace = metadata.parentNamespace;
         // PROVENANCE (creation-only, with one upgrade — round 6, codex P2 NBPmT):
         // `discoveredBy` is otherwise preserved for existing records (a routine
         // read/register/resolve never relabels it). The single exception is a real
@@ -2109,10 +2081,6 @@ export class NamespaceCatalog {
     if (prior.lastReadAt) merged.lastReadAt = prior.lastReadAt;
     if (prior.lastWriteAt) merged.lastWriteAt = prior.lastWriteAt;
     if (prior.lastMaintenanceAt) merged.lastMaintenanceAt = { ...prior.lastMaintenanceAt };
-    if (prior.principal !== undefined) merged.principal = prior.principal;
-    if (prior.projectId !== undefined) merged.projectId = prior.projectId;
-    if (prior.branch !== undefined) merged.branch = prior.branch;
-    if (prior.parentNamespace !== undefined) merged.parentNamespace = prior.parentNamespace;
     return merged;
   }
   // ── Persistence ──────────────────────────────────────────────────────────

package/src/orchestration/turn-ingestion-snapshot.test.ts

@@ -0,0 +1,167 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { SmartBuffer } from "../buffer.js";
+import { parseConfig } from "../config.js";
+import type { BufferState, BufferTurn } from "../types.js";
+import {
+  TurnIngestionCoordinator,
+  type TurnIngestionDeps,
+} from "./turn-ingestion.js";
+
+class FakeStorage {
+  constructor(private readonly initial: BufferState) {}
+  async loadBuffer(): Promise<BufferState> {
+    return structuredClone(this.initial);
+  }
+  async saveBuffer(_state: BufferState): Promise<void> {}
+}
+
+function makeTurn(content: string): BufferTurn {
+  return {
+    role: "user",
+    content,
+    timestamp: "2026-08-17T00:00:00.000Z",
+    sessionKey: "k",
+  };
+}
+
+test("#2468 extract trigger returns the mutation snapshot", async () => {
+  const buffer = new SmartBuffer(
+    parseConfig({ triggerMode: "every_n", bufferMaxTurns: 1 }),
+    new FakeStorage({ turns: [], lastExtractionAt: null, extractionCount: 0 }) as never,
+  );
+  const outcome = await buffer.addTurnWithOutcome("k", makeTurn("only"));
+  assert.equal(outcome.decision, "extract_batch");
+  assert.equal(outcome.extractionTurns?.length, 1);
+  assert.equal(outcome.extractionTurns?.[0]?.content, "only");
+});
+
+test("#2468 built-in trigger includes retained turns in the snapshot", async () => {
+  const buffer = new SmartBuffer(
+    parseConfig({ triggerMode: "every_n", bufferMaxTurns: 1 }),
+    new FakeStorage({ turns: [], lastExtractionAt: null, extractionCount: 0 }) as never,
+  );
+  await buffer.retainDeferredTurns("k", [makeTurn("retained")], 10);
+  const outcome = await buffer.addTurnWithOutcome("k", makeTurn("live"));
+  assert.equal(outcome.decision, "extract_batch");
+  assert.deepEqual(
+    outcome.extractionTurns?.map((turn) => turn.content),
+    ["retained", "live"],
+  );
+});
+
+test("#2468 processTurn does not adopt a later getTurns() batch", async () => {
+  const snapshot = [makeTurn("first")];
+  const later = [makeTurn("first"), makeTurn("later")];
+  const queued: BufferTurn[][] = [];
+  const buffer = {
+    addTurnWithOutcome: async () => ({
+      decision: "extract_now" as const,
+      extractionTurns: snapshot,
+    }),
+    getTurns: () => later,
+  };
+  const deps = {
+    buffer,
+    config: parseConfig({}),
+    getStorage: async () => {
+      throw new Error("unexpected getStorage");
+    },
+    bulkImportWriteNamespace: () => "default",
+    get extractionQueueCoordinator(): never {
+      throw new Error("unexpected extractionQueueCoordinator");
+    },
+    heartbeatObserverChains: new Map(),
+    lcmEngine: null,
+    passiveCorrectionDedup: new Set(),
+    passiveCorrectionService: () => {
+      throw new Error("unexpected passiveCorrectionService");
+    },
+    passiveCorrectionTelemetry: {
+      detected: 0,
+      queued: 0,
+      autoApplied: 0,
+      suppressedReasonCounts: {},
+    },
+    queueBufferedExtraction: async (turns: BufferTurn[]) => {
+      queued.push(turns);
+    },
+    resolveMemoryIdOrHandle: () => {
+      throw new Error("unexpected resolveMemoryIdOrHandle");
+    },
+    runExtraction: async () => {
+      throw new Error("unexpected runExtraction");
+    },
+    get sessionObserver(): never {
+      throw new Error("unexpected sessionObserver");
+    },
+    shouldQueueExtraction: () => {
+      throw new Error("unexpected shouldQueueExtraction");
+    },
+    get transcript(): never {
+      throw new Error("unexpected transcript");
+    },
+  } as unknown as TurnIngestionDeps;
+  await new TurnIngestionCoordinator(deps).processTurn("user", "first", "k");
+  assert.equal(queued.length, 1);
+  assert.equal(queued[0]?.length, 1);
+  assert.equal(queued[0]?.[0]?.content, "first");
+});
+test("#2468 concurrent processTurn first trigger keeps its mutation snapshot", async () => {
+  const queued: BufferTurn[][] = [];
+  const buffer = new SmartBuffer(
+    parseConfig({ triggerMode: "every_n", bufferMaxTurns: 1, bufferSaveDebounceMs: 0 }),
+    new FakeStorage({ turns: [], lastExtractionAt: null, extractionCount: 0 }) as never,
+  );
+  const deps = {
+    buffer,
+    config: parseConfig({ triggerMode: "every_n", bufferMaxTurns: 1 }),
+    getStorage: async () => {
+      throw new Error("unexpected getStorage");
+    },
+    bulkImportWriteNamespace: () => "default",
+    get extractionQueueCoordinator(): never {
+      throw new Error("unexpected extractionQueueCoordinator");
+    },
+    heartbeatObserverChains: new Map(),
+    lcmEngine: null,
+    passiveCorrectionDedup: new Set(),
+    passiveCorrectionService: () => {
+      throw new Error("unexpected passiveCorrectionService");
+    },
+    passiveCorrectionTelemetry: {
+      detected: 0,
+      queued: 0,
+      autoApplied: 0,
+      suppressedReasonCounts: {},
+    },
+    queueBufferedExtraction: async (turns: BufferTurn[]) => {
+      queued.push(turns);
+    },
+    resolveMemoryIdOrHandle: () => {
+      throw new Error("unexpected resolveMemoryIdOrHandle");
+    },
+    runExtraction: async () => {
+      throw new Error("unexpected runExtraction");
+    },
+    get sessionObserver(): never {
+      throw new Error("unexpected sessionObserver");
+    },
+    shouldQueueExtraction: () => {
+      throw new Error("unexpected shouldQueueExtraction");
+    },
+    get transcript(): never {
+      throw new Error("unexpected transcript");
+    },
+  } as unknown as TurnIngestionDeps;
+  const coordinator = new TurnIngestionCoordinator(deps);
+  await Promise.all([
+    coordinator.processTurn("user", "alpha", "shared-key"),
+    coordinator.processTurn("user", "beta", "shared-key"),
+  ]);
+  assert.equal(queued.length, 2);
+  assert.ok(
+    queued.some((batch) => batch.length === 1),
+    "the first trigger must extract only its mutation snapshot",
+  );
+});

package/src/orchestration/turn-ingestion.ts

@@ -201,8 +201,9 @@ export class TurnIngestionCoordinator {
         : { decision: await this.deps.buffer.addTurn(bufferKey, turn) };
 
     if (outcome.decision === "keep_buffering") return;
+    if (!outcome.extractionTurns) return;
     await this.deps.queueBufferedExtraction(
-      outcome.extractionTurns ?? this.deps.buffer.getTurns(bufferKey),
+      outcome.extractionTurns,
       "trigger_mode",
       { bufferKey },
     );