@remnic/core 10.0.91 → 10.0.93

package/src/explicit-capture.test.ts

@@ -1,10 +1,13 @@
 import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
 import test from "node:test";
 
 import type { Orchestrator } from "./orchestrator.js";
 import type { StorageManager } from "./storage.js";
 import type { PluginConfig } from "./types.js";
 import type { SealedMemoryEnvelope } from "./write-envelope.js";
+import { withHeldFileLock } from "./utils/serialize-mutations.js";
 import {
   InlineExplicitCaptureProcessor,
   parseInlineExplicitCaptureNotes,
@@ -67,6 +70,7 @@ function createInlineCaptureProcessorProbe(
     failPrimaryWrites?: boolean;
     duplicateReadDelayMs?: number;
     lockBusyAttempts?: number;
+    peerFactCommitAfterFirstReadAll?: boolean;
   } = {}
 ) {
   const envelopes: SealedMemoryEnvelope[] = [];
@@ -86,19 +90,38 @@ function createInlineCaptureProcessorProbe(
   let nextId = 1;
   let writeTail = Promise.resolve();
   let lockBusyAttemptsRemaining = options.lockBusyAttempts ?? 0;
+  let peerCommitted = false;
+  const peerFactContent = "A concurrent writer committed this fact before the capture could.";
+  // #3354: the dedup window takes a real per-dir file lock, so the fake needs
+  // a writable per-process dir even though its reads/writes stay in memory.
+  const storageDir = path.join(os.tmpdir(), `remnic-explicit-capture-probe-${process.pid}`);
   const storage = {
+    dir: storageDir,
     readAllMemories: async () => {
       readAllCalls += 1;
       activeReadAllCalls += 1;
       maxConcurrentReadAllCalls = Math.max(maxConcurrentReadAllCalls, activeReadAllCalls);
+      // A read reflects the corpus as it was when the read began, so a write
+      // that lands during the delay is invisible to this caller.
+      const snapshot = memories.map((memory) => ({
+        ...memory,
+        frontmatter: { ...memory.frontmatter },
+      }));
       if (options.duplicateReadDelayMs !== undefined) {
         await new Promise((resolve) => setTimeout(resolve, options.duplicateReadDelayMs));
       }
       activeReadAllCalls -= 1;
-      return memories.map((memory) => ({
-        ...memory,
-        frontmatter: { ...memory.frontmatter },
-      }));
+      // Simulate a concurrent extraction writer committing between this read
+      // and a later one: the caller sees the snapshot above without the peer
+      // row, while subsequent reads include it.
+      if (options.peerFactCommitAfterFirstReadAll && !peerCommitted) {
+        peerCommitted = true;
+        memories.push({
+          frontmatter: { id: `peer-fact-${nextId++}`, category: "fact", tags: [] },
+          content: peerFactContent,
+        });
+      }
+      return snapshot;
     },
     readAllColdMemories: async () =>
       coldMemories.map((memory) => ({
@@ -140,12 +163,9 @@ function createInlineCaptureProcessorProbe(
         release();
       }
     },
-    ...(options.authoritativeFactHashMiss
-      ? {
-          hasFactContentHash: async () => false,
-          isFactContentHashAuthoritative: () => true,
-        }
-      : {}),
+    lookupContentHash: options.authoritativeFactHashMiss
+      ? async () => ({ present: false, authoritative: true })
+      : undefined,
     ...(options.tombstoneBlockedCaptureIndexHit !== undefined
       ? {
           checkTombstoneBlockedExplicitCapture: async (content: string, category: string, sourceConnector?: string) => {
@@ -279,6 +299,43 @@ test("persistExplicitCapture serializes duplicate checks across concurrent calls
   assert.equal(probe.lifecycleEvents.length, 1);
 });
 
+test("persistExplicitCapture keeps the duplicate gate and the write atomic for non-fact categories (#3354)", async () => {
+  const probe = createInlineCaptureProcessorProbe({ duplicateReadDelayMs: 15 });
+  const candidate = {
+    content: "Concurrent preference captures must produce one durable capture.",
+    category: "preference" as const,
+    confidence: 0.9,
+    tags: [],
+  };
+  const [first, second] = await Promise.all([
+    persistExplicitCapture(probe.orchestrator, candidate, "memory_store"),
+    persistExplicitCapture(probe.orchestrator, candidate, "memory_store"),
+  ]);
+  assert.equal(Number(first.duplicateOf !== undefined) + Number(second.duplicateOf !== undefined), 1);
+  assert.equal(probe.envelopes.length, 1);
+  assert.equal(probe.lifecycleEvents.length, 1);
+});
+
+test("explicit capture suppresses a fact a concurrent writer commits between the gate and the write", async () => {
+  const probe = createInlineCaptureProcessorProbe({ peerFactCommitAfterFirstReadAll: true });
+  const candidate = validateExplicitCaptureInput({
+    content: "A concurrent writer committed this fact before the capture could.",
+    category: "fact",
+  });
+
+  const result = await persistExplicitCapture(probe.orchestrator, candidate, "memory_store");
+
+  // The peer row committed between the persist-time gate and the dedup
+  // window, so the capture must report the raced copy instead of writing a
+  // second active fact (#3354).
+  assert.equal(result.id, "peer-fact-1");
+  assert.equal(result.duplicateOf, "peer-fact-1");
+  assert.equal(probe.envelopes.length, 0, "no second sealed write of the raced fact");
+  assert.equal(probe.lifecycleEvents.length, 0);
+  const active = probe.memories.filter((memory) => (memory.frontmatter.status ?? "active") === "active");
+  assert.equal(active.length, 1);
+});
+
 test("inline capture processor hashes the effective authorized input for replay dedupe", async () => {
   const probe = createInlineCaptureProcessorProbe({ tombstoneBlocked: true });
   const request = {
@@ -403,6 +460,40 @@ test("inline capture processor queues invalid complete markup and never leaves i
   assert.equal(probe.envelopes.length, 1);
 });
 
+test("an inline fact capture that cannot take the dedup window fails closed and stays retryable (#3354)", async () => {
+  const probe = createInlineCaptureProcessorProbe();
+  const request = {
+    captureMode: "hybrid" as const,
+    content: [
+      "<memory_note>",
+      "content: A contended fact capture must stay retryable.",
+      "category: fact",
+      "</memory_note>",
+    ].join("\n"),
+    dedupeKeys: ["window-contention-1"],
+    namespace: "principal-project",
+    namespacePreResolved: true,
+  };
+
+  // A second process holding fact-dedup.lock: the window waits its bounded
+  // 2s, then throws instead of writing unlocked.
+  const contended = await withHeldFileLock(
+    path.join(probe.storage.dir, "fact-dedup.lock"),
+    { staleMs: 60_000, maxWaitMs: 1_000 },
+    async (acquired) => {
+      assert.ok(acquired, "the test must hold the window lock");
+      return await probe.processor.process(request);
+    }
+  );
+  assert.equal(contended.failed, 1);
+  assert.equal(probe.envelopes.length, 0);
+
+  // The failed delivery left its dedupe key unremembered, so the replay commits.
+  const replay = await probe.processor.process(request);
+  assert.equal(replay.accepted, 1);
+  assert.equal(probe.envelopes.length, 1);
+});
+
 test("inline capture review fallback serializes duplicate checks across processor instances", async () => {
   const probe = createInlineCaptureProcessorProbe({ duplicateReadDelayMs: 15 });
   const secondProcessor = new InlineExplicitCaptureProcessor(probe.orchestrator, {
@@ -1117,13 +1208,14 @@ test("explicit capture keeps the authoritative fact-hash miss fast path", async
   const result = await persistExplicitCapture(probe.orchestrator, candidate, "memory_store");
 
   assert.equal(result.duplicateOf, undefined);
-  assert.deepEqual(probe.blockedIndexArguments(), [
-    {
-      content: candidate.content,
-      category: "fact",
-      sourceConnector: undefined,
-    },
-  ]);
+  // The gate probes once outside the window and the in-window recheck
+  // (#3354) probes again; both take the authoritative-miss fast path.
+  const blockedProbe = {
+    content: candidate.content,
+    category: "fact",
+    sourceConnector: undefined,
+  };
+  assert.deepEqual(probe.blockedIndexArguments(), [blockedProbe, blockedProbe]);
   assert.equal(probe.envelopes.length, 1);
   assert.equal(probe.readAllCalls(), 0);
 });

package/src/explicit-capture.ts

@@ -1,4 +1,6 @@
 import { composeMemoryEnvelope, TAG_LIMITS } from "./write-envelope.js";
+import type { SealedMemoryEnvelope } from "./write-envelope.js";
+import { persistUnderFactDedupWindow } from "./orchestration/fact-dedup-window.js";
 import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { createHash, randomUUID } from "node:crypto";
 import type { Orchestrator } from "./orchestrator.js";
@@ -419,19 +421,18 @@ async function findDuplicateExplicitCapture(
   // authoritative miss can therefore skip the corpus scan only after the
   // targeted blocked-row index reports a miss and remains authoritative.
   let authoritativeFactHashMiss = false;
-  if (candidate.category === "fact" && typeof storage.hasFactContentHash === "function") {
+  if (candidate.category === "fact") {
     try {
-      const hasHash = await storage.hasFactContentHash(candidate.content);
-      if (!hasHash) {
-        const authoritative =
-          typeof storage.isFactContentHashAuthoritative === "function"
-            ? await storage.isFactContentHashAuthoritative()
-            : false;
-        authoritativeFactHashMiss = authoritative;
+      // One lookup returns the MISS together with the authority behind it, so
+      // a stale MISS is never paired with authority from another moment
+      // (#3312, #3354 — each separate call may rebuild the index).
+      const lookup = await storage.lookupContentHash(sanitizeMemoryContent(candidate.content).text);
+      if (!lookup.present && lookup.authoritative) {
+        authoritativeFactHashMiss = true;
       }
     } catch (err) {
       // Fail open: hash indexes are only an optimization, so fall back to the
-      // full corpus scan when either index cannot answer.
+      // full corpus scan when the lookup cannot answer.
       void err;
     }
   }
@@ -503,18 +504,55 @@ async function findDuplicateExplicitCapture(
       }
     : null;
 }
+type PersistedExplicitCapture = { id: string; duplicateOf?: string; tombstoneBlocked?: boolean };
+type RacedDuplicate = { match: { id: string; tombstoneBlocked: boolean } | null };
+
+function duplicatePersistResult(duplicate: { id: string; tombstoneBlocked: boolean }): PersistedExplicitCapture {
+  return duplicate.tombstoneBlocked
+    ? { id: duplicate.id, duplicateOf: duplicate.id, tombstoneBlocked: true }
+    : { id: duplicate.id, duplicateOf: duplicate.id };
+}
+
+async function persistSealedExplicitCapture(
+  storage: StorageManager,
+  captureEnvelope: SealedMemoryEnvelope,
+  candidate: ValidExplicitCapture,
+  source: ExplicitCaptureSource
+): Promise<PersistedExplicitCapture> {
+  const { id, duplicateOf, tombstoneBlocked } = await storage.writeSealedMemory(captureEnvelope);
+  if (duplicateOf) return { id, duplicateOf, tombstoneBlocked };
+  // #1522: catalog touch handled at the storage chokepoint — the StorageManager's
+  // post-write hook records the namespace touch automatically.
+
+  const created = new Date().toISOString();
+  const event: MemoryLifecycleEvent = {
+    eventId: `mle-${randomUUID()}`,
+    memoryId: id,
+    eventType: tombstoneBlocked ? "explicit_capture_queued" : "explicit_capture_accepted",
+    timestamp: created,
+    actor: explicitCaptureActor(source),
+    reasonCode: candidate.sourceReason,
+    ruleVersion: "explicit-capture.v1",
+  };
+  await storage.appendMemoryLifecycleEvents([event]);
+
+  return { id, duplicateOf, tombstoneBlocked };
+}
+
 async function persistExplicitCaptureUnlocked(
   orchestrator: Orchestrator,
   candidate: ValidExplicitCapture,
   source: ExplicitCaptureSource,
   resolvedNamespace: string | undefined,
   storage: StorageManager
-): Promise<{ id: string; duplicateOf?: string; tombstoneBlocked?: boolean }> {
-  const duplicate = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate, storage);
-  if (duplicate) {
-    return duplicate.tombstoneBlocked
-      ? { id: duplicate.id, duplicateOf: duplicate.id, tombstoneBlocked: true }
-      : { id: duplicate.id, duplicateOf: duplicate.id };
+): Promise<PersistedExplicitCapture> {
+  const isFact = candidate.category === "fact";
+  // Facts take a cheap early exit here and re-check inside the dedup window.
+  // Every other category checks only under the capture lock, so its gate and
+  // its write stay one atomic step per dedup key (#3354).
+  if (isFact) {
+    const duplicate = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate, storage);
+    if (duplicate) return duplicatePersistResult(duplicate);
   }
 
   // #1645 (review thread yG-): surface the tombstone block so callers
@@ -534,39 +572,54 @@ async function persistExplicitCaptureUnlocked(
     },
     { source: source === "inline" ? "explicit-inline" : "explicit" }
   );
-  const { id, duplicateOf, tombstoneBlocked } = await storage.writeSealedMemory(captureEnvelope);
-  if (duplicateOf) return { id, duplicateOf, tombstoneBlocked };
-  // #1522: catalog touch handled at the storage chokepoint — the StorageManager's
-  // post-write hook records the namespace touch automatically.
 
-  const created = new Date().toISOString();
-  const event: MemoryLifecycleEvent = {
-    eventId: `mle-${randomUUID()}`,
-    memoryId: id,
-    eventType: tombstoneBlocked ? "explicit_capture_queued" : "explicit_capture_accepted",
-    timestamp: created,
-    actor: explicitCaptureActor(source),
-    reasonCode: candidate.sourceReason,
-    ruleVersion: "explicit-capture.v1",
-  };
-  await storage.appendMemoryLifecycleEvents([event]);
-
-  return { id, duplicateOf, tombstoneBlocked };
+  // Test fakes may omit the lock; the real StorageManager always has it.
+  const withCaptureLock = <T>(run: () => Promise<T>): Promise<T> =>
+    storage.withTombstoneBlockedCaptureWriteLock?.(
+      run,
+      buildExplicitCaptureDedupKey(candidate.content, candidate.category, candidate.sourceConnector)
+    ) ?? run();
+  const writeSealed = (): Promise<PersistedExplicitCapture> =>
+    persistSealedExplicitCapture(storage, captureEnvelope, candidate, source);
+
+  if (!isFact) {
+    return await withCaptureLock(async () => {
+      const duplicate = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate, storage);
+      return duplicate ? duplicatePersistResult(duplicate) : await writeSealed();
+    });
+  }
+  // #3354: fact captures commit inside the per-dir fact-dedup window so a
+  // concurrent extraction write of the same fact is caught by the recheck
+  // instead of racing the persist-time gate. The tombstone capture write
+  // lock stays INSIDE the window: every other window writer (extraction,
+  // promotion) acquires the tombstone lock only inside writeMemory, so
+  // taking it here first would order tombstone→window against their
+  // window→tombstone and stall the capture on the 60s write-lock backoff.
+  const raced: RacedDuplicate = { match: null };
+  const outcome = await persistUnderFactDedupWindow(
+    storage.dir,
+    async () => {
+      raced.match = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate, storage);
+      return raced.match !== null;
+    },
+    () => withCaptureLock(writeSealed)
+  );
+  if (!outcome.suppressed) return outcome.result;
+  if (!raced.match) throw new Error("explicit capture suppressed by the dedup window without a matched duplicate");
+  log.info(`dedup: raced explicit capture suppressed in fact-dedup window for ${storage.dir}`);
+  return duplicatePersistResult(raced.match);
 }
 
 export async function persistExplicitCapture(
   orchestrator: Orchestrator,
   candidate: ValidExplicitCapture,
   source: ExplicitCaptureSource
-): Promise<{ id: string; duplicateOf?: string; tombstoneBlocked?: boolean }> {
+): Promise<PersistedExplicitCapture> {
   const resolvedNamespace = candidate.namespacePreResolved
     ? asTrimmed(candidate.namespace)
     : resolveExplicitCaptureNamespace(orchestrator, candidate.namespace);
   const storage = await orchestrator.getStorage(resolvedNamespace);
-  const persist = () => persistExplicitCaptureUnlocked(orchestrator, candidate, source, resolvedNamespace, storage);
-  if (typeof storage.withTombstoneBlockedCaptureWriteLock !== "function") return await persist();
-  const lockIdentity = buildExplicitCaptureDedupKey(candidate.content, candidate.category, candidate.sourceConnector);
-  return await storage.withTombstoneBlockedCaptureWriteLock(persist, lockIdentity);
+  return await persistExplicitCaptureUnlocked(orchestrator, candidate, source, resolvedNamespace, storage);
 }
 
 function buildExplicitCaptureReviewContent(input: ExplicitCaptureInput, reason: string): string {

package/src/extraction-quote-grounding.test.ts

@@ -459,6 +459,26 @@ test("a negator in a claim clause that shares only the subject does not keep the
   assert.equal(grounded.facts.length, 0);
 });
 
+test("a negated clause about another subject does not keep the quote's denial (#3356)", () => {
+  const source =
+    "Alice did not approve the budget. Bob did not approve the budget either. Carol asked about the plan.";
+  const quote = "Alice did not approve the budget.";
+  const kept = [
+    "Alice did not approve the budget.",
+    "The budget was not approved by Alice.",
+    "The budget was not approved.",
+  ];
+  const grounded = filterExtractionResultBySource(
+    resultOf([
+      { content: "Alice approved the budget, but Bob did not approve the budget.", quote },
+      ...kept.map((content) => ({ content, quote })),
+    ]),
+    source,
+    source,
+  );
+  assert.deepEqual(keptContents(grounded), kept);
+});
+
 test("a claim that inverts a denial verb in the quote is rejected", () => {
   const source = "Notes: Alice denied approving the budget. Bob reviewed it.";
   const grounded = filterExtractionResultBySource(

package/src/extraction-quote-grounding.ts

@@ -192,17 +192,19 @@ function negatedScope(clause: string): string {
   return match ? clause.slice(match.index + match[0].length) : clause;
 }
 
+/** The words before a clause's first negator, empty when it has none. */
+function textBeforeNegator(clause: string): string {
+  const match = NEGATOR_PATTERN.exec(clause.replace(/[\u2018\u2019]/gu, "'"));
+  return match ? clause.slice(0, match.index) : "";
+}
+
 /**
- * True when the claim asserts what a quote clause denies or does not assert:
- * "did not approve the budget" or "denied approving it" restated as "approved
- * the budget", "suspects Bob stole funds" or "Is Alice the CEO?" restated as a
- * plain statement. The claim must restate the quote clause, and none of its
- * clauses that share a word with what the negator governs may keep the
- * negator, exclusion word, or reporting marker ("do not X" reworded as "X is
- * excluded", or "Alice reviewed it, but she did not approve it"). A negator in
- * a clause about something else does not count, so a claim that keeps one
- * quote negation can still misstate another quote clause, and a claim clause
- * that shares only the subject does not satisfy the check.
+ * True when the claim asserts what a quote clause denies or does not assert.
+ * A quote denial is kept only by a claim clause that shares what the negator
+ * governs and does not name a different subject, so a negator about Bob does
+ * not keep a denial about Alice. A clause that names no subject of its own
+ * still counts, which keeps a pronoun clause and a subject-less passive. A
+ * quote clause with no subject of its own keeps the clause-level check.
  */
 function misstatesQuote(content: string, quote: string): boolean {
   const claimClauses = splitClaimClauses(content);
@@ -217,8 +219,16 @@ function misstatesQuote(content: string, quote: string): boolean {
       claimClauses.filter((claimClause) => clauseOverlap(tokens, claimClause).shared > 0);
     if (needsNegation) {
       const scopeTokens = [...tokenize(negatedScope(quoteClause))];
+      const subjectTokens = [...tokenize(textBeforeNegator(quoteClause))];
+      const scopeHas = new Set(scopeTokens);
       const related = clausesSharing(scopeTokens.length > 0 ? scopeTokens : clauseTokens);
-      if (!related.some((text) => hasNegation(text) || EXCLUSION_PATTERN.test(text))) return true;
+      const keepsDenial = related.some((text) => {
+        if (!hasNegation(text) && !EXCLUSION_PATTERN.test(text)) return false;
+        if (subjectTokens.length === 0 || clauseOverlap(subjectTokens, text).shared > 0) return true;
+        const ownSubject = [...tokenize(textBeforeNegator(text))].filter((token) => !scopeHas.has(token));
+        return ownSubject.length === 0;
+      });
+      if (!keepsDenial) return true;
     }
     return needsReporting
       && !clausesSharing(clauseTokens).some((text) => hasNonAssertiveReporting(text) || text.trim().endsWith("?"));

package/src/fact-dedup-window.test.ts

@@ -6,6 +6,8 @@ import path from "node:path";
 import { StorageManager } from "./storage.js";
 import { withHeldFileLock } from "./utils/serialize-mutations.js";
 import { confirmActiveFactDuplicate, persistUnderFactDedupWindow } from "./orchestration/fact-dedup-window.js";
+import { persistExplicitCapture } from "./explicit-capture.js";
+import { Orchestrator } from "./orchestrator.js";
 
 const SKY_OPTS = {
   category: "fact",
@@ -185,6 +187,41 @@ test("two managers on one directory commit the same fact through the window exac
   }
 });
 
+test("explicit capture and an extraction write race the same new fact to exactly one active copy (#3354)", async () => {
+  const { storage, cleanup } = await makeStorage();
+  try {
+    const content = "An extraction run and an explicit capture hold this new fact.";
+    // SAFETY: persistExplicitCapture reads only getStorage here (namespacePreResolved skips the config-based namespace resolver); the prototype stub exists for the type only.
+    const orchestrator = Object.create(Orchestrator.prototype) as Orchestrator;
+    orchestrator.getStorage = async () => storage;
+    const candidate = { content, category: "fact" as const, confidence: 0.9, tags: [], namespacePreResolved: true };
+    const extractionCommit = persistUnderFactDedupWindow(
+      storage.dir,
+      () => confirmActiveFactDuplicate(storage, { ...SKY_OPTS, contentHashDedupKey: content }),
+      () => storage.writeMemory("fact", content),
+    );
+    const [capture, extraction] = await Promise.all([
+      persistExplicitCapture(orchestrator, candidate, "memory_store"),
+      extractionCommit,
+    ]);
+    const stored = await storage.readAllMemories();
+    const active = stored.filter(
+      (memory) => memory.frontmatter.category === "fact" && (memory.frontmatter.status ?? "active") === "active",
+    );
+    assert.equal(active.length, 1, `exactly one active copy of the raced fact, got ${active.length}`);
+    const winner = active[0];
+    assert.ok(winner, "the single active copy must exist");
+    assert.ok(winner.content.includes(content));
+    if (capture.duplicateOf === undefined) {
+      assert.equal(extraction.suppressed, true, "the extraction write is the loser and must be suppressed");
+    } else {
+      assert.equal(winner.frontmatter.id, capture.duplicateOf, "the capture reports the winning copy");
+    }
+  } finally {
+    await cleanup();
+  }
+});
+
 test("confirmActiveFactDuplicate keeps the authoritative MISS fast path", async () => {
   const { storage, cleanup } = await makeStorage();
   try {

package/src/live-connectors-runner.ts

@@ -31,6 +31,7 @@ import {
 } from "./connectors/live/index.js";
 import { abortError } from "./abort-error.js";
 import type { LiveConnectorsConfig } from "./types.js";
+import type { ResolveSecretRefFn } from "./resolve-auth-token.js";
 
 export type LiveConnectorSkipReason =
   | "disabled"
@@ -138,6 +139,7 @@ export async function runLiveConnectorsOnce(options: {
   now?: LiveConnectorsNow;
   abortSignal?: AbortSignal;
   definitions?: LiveConnectorDefinition[];
+  resolveSecretRef?: ResolveSecretRefFn | null;
 }): Promise<LiveConnectorsRunSummary> {
   const ranAt = resolveNow(options.now);
   const force = options.force === true;
@@ -228,6 +230,7 @@ export async function runLiveConnectorsOnce(options: {
               cursor,
               config: validatedConfig,
               abortSignal: pollAbortSignal,
+              resolveSecretRef: options.resolveSecretRef,
             }),
           ingestFn: async (docs) => {
             throwIfAborted(pollAbortSignal);

package/src/live-connectors-secretref.test.ts

@@ -0,0 +1,126 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+
+import { parseConfig } from "./config.js";
+import {
+  builtInLiveConnectorDefinitions,
+  runLiveConnectorsOnce,
+} from "./live-connectors-runner.js";
+import {
+  GOOGLE_DRIVE_CONNECTOR_ID,
+  NOTION_CONNECTOR_ID,
+  createGoogleDriveConnector,
+  type GoogleDriveClient,
+} from "./connectors/live/index.js";
+import type { LiveConnector } from "./connectors/live/framework.js";
+
+const RESOLVED_SECRET = "resolved-drive-secret";
+const SECRET_REF = { source: "keychain", id: "projects/drive-secret" };
+
+function driveConfig() {
+  return {
+    openaiApiKey: "sk-test",
+    connectors: {
+      googleDrive: {
+        enabled: true,
+        clientId: "synthetic-client",
+        clientSecret: SECRET_REF,
+        refreshToken: "synthetic-token",
+      },
+      notion: { enabled: true, token: "secret_synthetic_notion_token" },
+    },
+  };
+}
+
+function notionStub(): LiveConnector {
+  return {
+    id: NOTION_CONNECTOR_ID,
+    displayName: "Notion",
+    validateConfig: () => ({}),
+    async syncIncremental() {
+      return { newDocs: [], nextCursor: { kind: "notion", value: "cursor-1", updatedAt: "2026-11-11T00:00:00.000Z" } };
+    },
+  };
+}
+
+test("a Drive SecretRef resolves through parseConfig and the runner, and stays out of the state file", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-drive-secretref-"));
+  try {
+    const parsed = parseConfig(driveConfig());
+    const definitions = builtInLiveConnectorDefinitions(parsed.connectors);
+    let seenSecret = "";
+    const client: GoogleDriveClient = {
+      async getStartPageToken() {
+        return { startPageToken: "seed-token" };
+      },
+      async listChanges() {
+        return { changes: [], newStartPageToken: "next-token" };
+      },
+      async exportFile() {
+        return "";
+      },
+      async getFileMedia() {
+        return "";
+      },
+    };
+    for (const definition of definitions) {
+      if (definition.id === GOOGLE_DRIVE_CONNECTOR_ID) {
+        definition.createConnector = () =>
+          createGoogleDriveConnector({
+            clientFactory: async (config) => {
+              seenSecret = config.clientSecret;
+              return client;
+            },
+          });
+      }
+      if (definition.id === NOTION_CONNECTOR_ID) {
+        definition.createConnector = notionStub;
+      }
+    }
+    const summary = await runLiveConnectorsOnce({
+      memoryDir,
+      connectors: parsed.connectors,
+      definitions,
+      force: true,
+      resolveSecretRef: async () => RESOLVED_SECRET,
+      ingestDocuments: async () => {},
+    });
+    assert.equal(seenSecret, RESOLVED_SECRET);
+    const drive = summary.results.find((item) => item.id === GOOGLE_DRIVE_CONNECTOR_ID);
+    assert.equal(drive?.ran, true);
+    const statePath = path.join(memoryDir, "state", "connectors", `${GOOGLE_DRIVE_CONNECTOR_ID}.json`);
+    const stateText = await readFile(statePath, "utf-8");
+    assert.equal(stateText.includes(RESOLVED_SECRET), false);
+    assert.equal(stateText.includes(SECRET_REF.id), false);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("a Drive SecretRef with no resolver fails that connector and the others still run", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-drive-secretref-"));
+  try {
+    const parsed = parseConfig(driveConfig());
+    const definitions = builtInLiveConnectorDefinitions(parsed.connectors);
+    for (const definition of definitions) {
+      if (definition.id === NOTION_CONNECTOR_ID) definition.createConnector = notionStub;
+    }
+    const summary = await runLiveConnectorsOnce({
+      memoryDir,
+      connectors: parsed.connectors,
+      definitions,
+      force: true,
+      ingestDocuments: async () => {},
+    });
+    const drive = summary.results.find((item) => item.id === GOOGLE_DRIVE_CONNECTOR_ID);
+    const notion = summary.results.find((item) => item.id === NOTION_CONNECTOR_ID);
+    assert.match(drive?.error ?? "", /clientSecret is a secret reference but no resolver is configured/);
+    assert.equal((drive?.error ?? "").includes(SECRET_REF.id), false);
+    assert.equal(notion?.ran, true);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});

package/src/local-llm-helpers.ts

@@ -40,6 +40,18 @@ export function isAbortError(err: unknown): boolean {
   );
 }
 
+/** Caller signal combined with a client-wide shutdown signal, so a daemon
+ *  stop aborts in-flight requests and retry loops at once — even for
+ *  callers that pass no signal of their own. */
+export function combineClientAbortSignals(
+  caller: AbortSignal | undefined,
+  shutdown: AbortSignal | undefined,
+): AbortSignal | undefined {
+  if (shutdown === undefined) return caller;
+  if (caller === undefined) return shutdown;
+  return AbortSignal.any([caller, shutdown]);
+}
+
 export function waitForRetryBackoff(backoffMs: number, signal?: AbortSignal): Promise<boolean> {
   return new Promise((resolve) => {
     let settled = false;