@remnic/core 9.3.758 → 9.3.760

package/src/orchestrator-background-writes.test.ts

@@ -0,0 +1,101 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import test from "node:test";
+import { parseConfig } from "./config.js";
+import { Orchestrator } from "./orchestrator.js";
+
+test("destroy cancels maintenance and waits for tracked writes before disposing search backends", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-background-writes-"));
+  const orchestrator = new Orchestrator(
+    parseConfig({
+      openaiApiKey: "sk-test",
+      memoryDir,
+      workspaceDir: path.join(memoryDir, "workspace"),
+      qmdEnabled: false,
+      knowledgeIndexEnabled: false,
+      identityContinuityEnabled: false,
+      transcriptEnabled: false,
+      hourlySummariesEnabled: false,
+      compoundingEnabled: false,
+    })
+  );
+  const maintenanceScheduler = (orchestrator as unknown as { maintenanceScheduler: { dispose(): void } })
+    .maintenanceScheduler;
+  const originalMaintenanceDispose = maintenanceScheduler.dispose.bind(maintenanceScheduler);
+  let maintenanceDisposed = false;
+  maintenanceScheduler.dispose = () => {
+    maintenanceDisposed = true;
+    originalMaintenanceDispose();
+  };
+  const writeGate = Promise.withResolvers<void>();
+  let destroySettled = false;
+  let destroyPromise: Promise<void> | undefined;
+
+  try {
+    orchestrator.trackRecallBackgroundWrite(writeGate.promise, "test background write");
+    destroyPromise = orchestrator.destroy().then(() => {
+      destroySettled = true;
+    });
+
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    assert.equal(destroySettled, false, "destroy must remain pending while a tracked write is pending");
+    assert.equal(maintenanceDisposed, true, "destroy must cancel maintenance before waiting for writes");
+
+    writeGate.resolve();
+    await destroyPromise;
+    assert.equal(destroySettled, true);
+  } finally {
+    writeGate.resolve();
+    await (destroyPromise ?? orchestrator.destroy());
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("destroy waits for a recall-initiated last-recall write", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-recall-background-write-"));
+  const orchestrator = new Orchestrator(
+    parseConfig({
+      openaiApiKey: "sk-test",
+      memoryDir,
+      workspaceDir: path.join(memoryDir, "workspace"),
+      qmdEnabled: false,
+      knowledgeIndexEnabled: false,
+      identityContinuityEnabled: false,
+      transcriptEnabled: false,
+      hourlySummariesEnabled: false,
+      compoundingEnabled: false,
+    })
+  );
+  const writeStarted = Promise.withResolvers<void>();
+  const writeGate = Promise.withResolvers<void>();
+  const originalRecord = orchestrator.lastRecall.record.bind(orchestrator.lastRecall);
+  orchestrator.lastRecall.record = async (...args: Parameters<typeof originalRecord>) => {
+    writeStarted.resolve();
+    await writeGate.promise;
+    await originalRecord(...args);
+  };
+  let destroySettled = false;
+  let destroyPromise: Promise<void> | undefined;
+
+  try {
+    await orchestrator.initialize();
+    await orchestrator.recall("recall state drain contract", "session-background-write");
+    await writeStarted.promise;
+    destroyPromise = orchestrator.destroy().then(() => {
+      destroySettled = true;
+    });
+
+    await new Promise<void>((resolve) => setImmediate(resolve));
+    assert.equal(destroySettled, false, "destroy must wait for the recall-initiated state write");
+
+    writeGate.resolve();
+    await destroyPromise;
+    assert.equal(destroySettled, true);
+  } finally {
+    writeGate.resolve();
+    await (destroyPromise ?? orchestrator.destroy());
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/orchestrator.ts

@@ -120,6 +120,7 @@ import { NamespaceReadFanoutCoordinator } from "./orchestration/namespace-read-f
 import { selfDeps } from "./orchestration/self-deps.js";
 import { RecallEntryCoordinator } from "./orchestration/recall-entry.js";
 import { SessionContextCoordinator } from "./orchestration/session-context.js";
+import { drainRecallWrites, trackRecallWrite } from "./orchestration/recall-background-writes.js";
 import {
   abortRecallError,
   buildCompressionGuidelinesMarkdown,
@@ -135,9 +136,8 @@ import {
   type QueryAwarePrefilter,
   type RecallInvocationOptions,
 } from "./orchestration/orchestrator-helpers.js";
-// Issue #1526 seam 25: module-level helpers moved to
-// orchestration/orchestrator-helpers.ts; re-exported here so existing
-// importers (coordinators, tests, root shims) keep working.
+// Issue #1526 seam 25: helpers moved to orchestration/orchestrator-helpers.ts and are
+// re-exported here so existing importers (coordinators, tests, root shims) keep working.
 export {
   BulkImportBatchPartialFailureError,
   COMPACTION_SIGNAL_MAX_AGE_MS,
@@ -701,8 +701,7 @@ export class Orchestrator {
   /** Read by NamespaceReadFanoutCoordinator (seam 26), hence not `private`. */
   static readonly ARTIFACT_STATUS_CACHE_TTL_MS = 60_000;
 
-  // Access tracking buffer (Phase 1A)
-  // Maps memoryId -> {count, lastAccessed} for batched updates
+  // Batched access-tracking counts and timestamps (Phase 1A).
   private accessTrackingBuffer: Map<
     string,
     { count: number; lastAccessed: string }
@@ -887,9 +886,7 @@ export class Orchestrator {
   private utilityRuntimeValues: UtilityRuntimeValues | null = null;
   private evalShadowWriteChain: Promise<void> = Promise.resolve();
 
-  // Pending background observation-mode direct-answer annotations (#518).
-  // Tracks fire-and-forget `annotateDirectAnswerTier` calls so callers (tests,
-  // waitForDirectAnswerObservationIdle) can await settlement.
+  // Pending fire-and-forget direct-answer tier annotations (#518).
   private directAnswerObservationChain: Promise<void> = Promise.resolve();
 
   // Initialization gate: recall() awaits this before proceeding
@@ -934,8 +931,9 @@ export class Orchestrator {
     }
   }
 
-  private async disposeSearchBackendIfNeeded(): Promise<void> {
-    await (this.qmd as { dispose?: () => void | Promise<void> }).dispose?.();
+  /** Track a recall-side write so destroy() can wait for it before teardown. @internal */
+  trackRecallBackgroundWrite(promise: Promise<void>, label: string): void {
+    trackRecallWrite(this, promise, label);
   }
 
   /**
@@ -952,8 +950,9 @@ export class Orchestrator {
       this.wearablesAutoSyncHandle = null;
     }
     this.maintenanceScheduler.dispose();
+    await drainRecallWrites(this);
     await this.namespaceSearchRouter.dispose();
-    await this.disposeSearchBackendIfNeeded();
+    await (this.qmd as { dispose?: () => void | Promise<void> }).dispose?.();
     if (this.conversationQmd && this.conversationQmd !== this.qmd) {
       await (this.conversationQmd as { dispose?: () => void | Promise<void> }).dispose?.();
     }
@@ -3713,8 +3712,9 @@ export class Orchestrator {
     if (
       this.accessTrackingBuffer.size >= this.config.accessTrackingBufferMaxSize
     ) {
-      this.flushAccessTracking().catch((err) =>
-        log.debug(`background access tracking flush failed: ${err}`),
+      this.trackRecallBackgroundWrite(
+        this.flushAccessTracking(),
+        "background access tracking flush",
       );
     }
   }

package/src/storage-contract/round-trip.test.ts

@@ -12,6 +12,8 @@
  */
 
 import assert from "node:assert/strict";
+import { utimes } from "node:fs/promises";
+import path from "node:path";
 import type { MemoryCategory } from "../types.js";
 import test from "node:test";
 
@@ -212,6 +214,9 @@ test("question-queue: writeQuestion → readQuestions → resolveQuestion round-
     // resolve marks it resolved
     const resolved = await storage.resolveQuestion(id);
     assert.equal(resolved, true);
+    // Directory mtimes are only a cross-process hint and may be coarser than
+    // the cache timestamp. Same-process resolution must invalidate directly.
+    await utimes(path.join(storage.dir, "questions"), new Date(0), new Date(0));
 
     const afterResolve = await storage.readQuestions({ unresolvedOnly: true });
     assert.ok(!afterResolve.some((x) => x.id === id), "resolved question must not appear in unresolvedOnly");

package/src/storage.ts

@@ -5463,9 +5463,7 @@ export class StorageManager {
       filePath: string;
     }>
   > {
-    return this.memoryReadStore.readQuestions(
-      opts,
-    );
+    return this.memoryReadStore.readQuestions(opts);
   }
 
   /** Invalidate the questions cache (call after writing a question). */
@@ -5535,6 +5533,7 @@ export class StorageManager {
       `resolvedAt: "${new Date().toISOString()}"\n---\n\n`,
     );
     await this.writeStorageSecureFile(q.filePath, raw);
+    this.invalidateQuestionsCache();
     log.debug(`resolved question ${id}`);
     return true;
   }

package/src/trust-score-recall-paths.test.ts

@@ -119,6 +119,7 @@ test("TrustScore runs on the recent-scan path: trust map reaches the X-ray snaps
       );
     }
   } finally {
+    await orchestrator.destroy();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });
@@ -152,6 +153,7 @@ test("TrustScore quarantine excludes a contradicted memory from injection but su
       "quarantined result carries a human-readable reason",
     );
   } finally {
+    await orchestrator.destroy();
     await rm(memoryDir, { recursive: true, force: true });
   }
 });