@remnic/core 10.0.91 → 10.0.93

package/src/access-mcp.ts

@@ -32,7 +32,7 @@ import {
 import { EngramAccessInputError, type EngramAccessRecallResponse, type EngramAccessService } from "./access-service.js";
 import { EngramAccessForbiddenError, unknownToolError } from "./access-errors.js";
 import { log } from "./logger.js";
-import { McpFrameReader } from "./access-mcp-frames.js";
+import { McpFrameReader, type McpFrameForm } from "./access-mcp-frames.js";
 import "./access-operations.js";
 import { validateBriefingFormat } from "./briefing.js";
 import { processChatMessage } from "./chat/chat-factory.js";
@@ -470,6 +470,8 @@ async function getMcpServerVersion(): Promise<string> {
 
 export class EngramMcpServer {
   private readonly frames = new McpFrameReader();
+  /** The form of the first frame on this connection. Replies use the same form. */
+  private replyForm: McpFrameForm | null = null;
   private flushTask: Promise<void> | null = null;
   private readonly tools: McpTool[];
   private readonly resources: McpResource[];
@@ -2493,7 +2495,7 @@ export class EngramMcpServer {
   private async flushBuffer(output: Writable): Promise<void> {
     for (let frame = this.frames.next(); frame; frame = this.frames.next()) {
       if (frame.kind === "too-large") {
-        this.writeMessage(output, { jsonrpc: "2.0", id: null, error: { code: -32600, message: "frame too large" } });
+        this.writeRefusal(output, frame.form, -32600, "frame too large");
         continue;
       }
       let parsed: JsonRpcRequest;
@@ -2501,16 +2503,10 @@ export class EngramMcpServer {
         // SAFETY: handleRequest defaults missing fields; a non-object body throws and scheduleFlush answers -32700.
         parsed = JSON.parse(frame.text) as JsonRpcRequest;
       } catch {
-        this.writeMessage(output, {
-          jsonrpc: "2.0",
-          id: null,
-          error: {
-            code: -32700,
-            message: "Parse error",
-          },
-        });
+        this.writeRefusal(output, frame.form, -32700, "Parse error");
         continue;
       }
+      this.replyForm ??= frame.form;
       const response = await this.handleRequest(parsed);
       if (response) {
         this.writeMessage(output, response);
@@ -2519,9 +2515,19 @@ export class EngramMcpServer {
   }
 
   private writeMessage(output: Writable, payload: Record<string, unknown>): void {
-    const body = JSON.stringify(payload);
-    const message = `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n${body}`;
-    output.write(message);
+    output.write(this.frameBody(JSON.stringify(payload), this.replyForm));
+  }
+
+  /** Answers a frame that held no valid JSON in its own form, without fixing the connection's reply form. */
+  private writeRefusal(output: Writable, frameForm: McpFrameForm, code: number, message: string): void {
+    const body = JSON.stringify({ jsonrpc: "2.0", id: null, error: { code, message } });
+    output.write(this.frameBody(body, this.replyForm ?? frameForm));
+  }
+
+  private frameBody(body: string, form: McpFrameForm | null): string {
+    return form === "line"
+      ? `${body}\n`
+      : `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n${body}`;
   }
 
   private toolAcceptsArgument(name: string, key: string): boolean {

package/src/access-service-coding-write.test.ts

@@ -19,6 +19,8 @@
  *  - Precedence: explicit `namespace` wins; namespaces-disabled is a no-op.
  */
 import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
 import test from "node:test";
 
 import { EngramAccessService } from "./access-service.js";
@@ -39,9 +41,14 @@ import { sealedWriteToLegacyArgs, type SealedMemoryEnvelope } from "./write-enve
 // the PRODUCTION mapping (`sealedWriteToLegacyArgs`), so mock behavior
 // cannot drift from the real envelope→options translation.
 function withSealedWrite<T extends { writeMemory: (...args: never[]) => unknown }>(stub: T): T {
+  // SAFETY: the decorated stub only gains writeSealedMemory and dir, both assigned below before any caller reads them.
   const decorated = stub as T & {
     writeSealedMemory?: (envelope: SealedMemoryEnvelope, extras?: Record<string, unknown>) => unknown;
+    dir?: string;
   };
+  // #3354: the fact-dedup window keys its lock on storage.dir and takes a
+  // real file lock, so the fake needs a writable per-process dir.
+  decorated.dir = path.join(os.tmpdir(), `remnic-coding-write-fake-${process.pid}`);
   decorated.writeSealedMemory = (envelope, extras = {}) => {
     const { category, content, options } = sealedWriteToLegacyArgs(envelope, extras);
     return (stub.writeMemory as (c: unknown, b: unknown, o: unknown) => unknown)(category, content, options);

package/src/access-service.ts

@@ -1365,6 +1365,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
   }
   private readonly extractionLivenessWarn = new ExtractionLivenessWarnThrottle();
 
+  private readonly secretRefResolver: ResolveSecretRefFn | null;
   constructor(
     private readonly orchestrator: Orchestrator,
     options: {
@@ -1375,6 +1376,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
   ) {
     super();
     this.idempotency = new AccessIdempotencyStore(orchestrator.config.memoryDir);
+    this.secretRefResolver = options.resolveSecretRef ?? null;
     // Peer SecretRef tokens resolve at poll time through the host resolver, the
     // same indirection as agentAccessHttp.authToken (review round 1). Absent a
     // resolver, string/${ENV} tokens still work and a SecretRef degrades to a
@@ -3721,6 +3723,7 @@ export class EngramAccessService extends SupportPassportAccessServiceBase {
     this.writableNamespaceFor(undefined, undefined, request.authenticatedPrincipal ?? principal);
     return this.orchestrator.runLiveConnectors({
       force: request.force === true,
+      resolveSecretRef: this.secretRefResolver,
     });
   }
 

package/src/activity/journal-extract-storage.test.ts

@@ -6,6 +6,7 @@ import test from "node:test";
 import { parseConfig } from "../config.js";
 import { NamespaceStorageRouter } from "../namespaces/storage.js";
 import { StorageManager } from "../storage.js";
+import { persistUnderFactDedupWindow } from "../orchestration/fact-dedup-window.js";
 import { withTempDir } from "../testing/tmp-dir.js";
 import {
   createJournalMemoryWriter,
@@ -127,3 +128,33 @@ test("tombstoned journal facts are skipped and not written as pending_review", a
     assert.equal(pending.length, 0, "tombstoned content must not land as a new pending_review file");
   });
 });
+
+test("a fact an extraction run commits after the journal probe is not written again", async () => {
+  await withTempDir(async (dir) => {
+    const config = parseConfig({ memoryDir: dir });
+    const storage = new StorageManager(config.memoryDir);
+    await storage.ensureDirectories();
+    const real = createJournalMemoryWriter(storage);
+    const deps = extractDeps(storage, "fact");
+    deps.writer = {
+      writeSealedMemory: real.writeSealedMemory,
+      hasJournalMemoryContent: async (content) => {
+        const known = await real.hasJournalMemoryContent(content);
+        assert.equal(known, false, "the probe runs before the other writer commits");
+        await persistUnderFactDedupWindow(storage.dir, async () => false, () => storage.writeMemory("fact", FACT));
+        return known;
+      },
+    };
+    const result = await runJournalReviewExtraction({
+      date: "2026-08-20",
+      journalText: FACT,
+      source: "memoryDir",
+      journalConfig: { extractionMode: "review" },
+      deps,
+    });
+    assert.equal(result.pendingReview, 0);
+    assert.equal(result.skipped, 1);
+    const copies = (await storage.readAllMemories()).filter((memory) => memory.content.includes(FACT));
+    assert.equal(copies.length, 1, "the corpus holds one copy of the fact");
+  });
+});

package/src/activity/journal-extract.test.ts

@@ -298,6 +298,7 @@ test("memoryDir source provenance differs only in the attribute value", async ()
 test("createJournalMemoryWriter dedups journal-tagged memories beyond the fact hash", async () => {
   const calls: string[] = [];
   const storage = {
+    dir: "/tmp/journal-writer-test-unused",
     writeSealedMemory: async () => ({}),
     hasFactContentHash: async (content: string) => {
       calls.push(`hash:${content}`);

package/src/activity/journal-extract.ts

@@ -11,6 +11,7 @@
  * Per-day change detection lives in journal-state.ts (timeline.json);
  * this module is the pure pass over one day's POST-STRIP text.
  */
+import { persistUnderFactDedupWindow } from "../orchestration/fact-dedup-window.js";
 import { scoreImportance } from "../importance.js";
 import { getVerdictKind, type JudgeCandidate, type JudgeVerdict } from "../extraction-judge.js";
 import { log } from "../logger.js";
@@ -29,6 +30,7 @@ import type { ActivityTimelineJournalConfig } from "./types.js";
 
 /** The subset of StorageManager the journal pass writes through. */
 export interface JournalStorageIo {
+  readonly dir: string;
   writeSealedMemory(
     envelope: SealedMemoryEnvelope,
     extras: { status: MemoryStatus; contentHashSource: string; importance?: ImportanceScore },
@@ -38,7 +40,14 @@ export interface JournalStorageIo {
 }
 
 export interface JournalMemoryWriter {
-  writeSealedMemory: JournalStorageIo["writeSealedMemory"];
+  /**
+   * `duplicate` is true when a concurrent writer committed the same fact
+   * first and nothing was written.
+   */
+  writeSealedMemory(
+    envelope: SealedMemoryEnvelope,
+    extras: { status: MemoryStatus; contentHashSource: string; importance?: ImportanceScore },
+  ): Promise<{ tombstoneBlocked?: boolean; duplicate?: boolean }>;
   /** Dedup beyond the fact-only hash index: scans journal-tagged memories. */
   hasJournalMemoryContent(content: string): Promise<boolean>;
 }
@@ -51,7 +60,19 @@ export interface JournalMemoryWriter {
  */
 export function createJournalMemoryWriter(storage: JournalStorageIo): JournalMemoryWriter {
   return {
-    writeSealedMemory: storage.writeSealedMemory.bind(storage),
+    writeSealedMemory: async (envelope, extras) => {
+      // Facts register in the fact hash index, so extraction and this pass can
+      // commit the same new fact. Commit it under the same window extraction
+      // uses and recheck the index there. The scan in hasJournalMemoryContent
+      // stays outside: it is corpus-sized and the window is bounded.
+      if (envelope.category !== "fact") return storage.writeSealedMemory(envelope, extras);
+      const outcome = await persistUnderFactDedupWindow(
+        storage.dir,
+        () => storage.hasFactContentHash(extras.contentHashSource),
+        () => storage.writeSealedMemory(envelope, extras),
+      );
+      return outcome.suppressed ? { duplicate: true } : outcome.result;
+    },
     hasJournalMemoryContent: async (content: string) => {
       if (await storage.hasFactContentHash(content)) return true;
       const needle = stripAttributesSuffix(content);
@@ -210,7 +231,7 @@ export async function runJournalReviewExtraction(input: {
       contentHashSource: normalizedKey,
       importance: scoreImportance(fact.content, fact.category, fact.tags),
     });
-    if (write.tombstoneBlocked) {
+    if (write.tombstoneBlocked || write.duplicate) {
       result.skipped += 1;
       continue;
     }

package/src/cli.ts

@@ -6107,8 +6107,7 @@ export function registerCli(
                   priorState: state,
                   syncFn: (cursor) =>
                     connector.syncIncremental({
-                      cursor,
-                      config: validatedCfg,
+                      cursor, config: validatedCfg, resolveSecretRef: hostSecretRefResolver(registerOptions),
                     }),
                   ingestFn: sharedIngestFn,
                   writeCursorFn: makeWriteCursorFn(name),

package/src/config.test.ts

@@ -1891,6 +1891,23 @@ test("parseConfig connectors.googleDrive accepts valid overrides", () => {
   ]);
 });
 
+test("parseConfig connectors.googleDrive keeps a SecretRef credential verbatim", () => {
+  const secretRef = { source: "keychain", id: "projects/drive-secret" };
+  const result = parseConfig({
+    openaiApiKey: "sk-test",
+    connectors: {
+      googleDrive: {
+        enabled: true,
+        clientId: "synthetic-client",
+        clientSecret: secretRef,
+        refreshToken: "synthetic-token",
+      },
+    },
+  });
+  assert.deepEqual(result.connectors.googleDrive.clientSecret, secretRef);
+  assert.equal(result.connectors.googleDrive.clientId, "synthetic-client");
+});
+
 test("parseConfig rejects malformed connectors top-level", () => {
   assert.throws(
     () => parseConfig({ openaiApiKey: "sk-test", connectors: "nope" }),

package/src/config.ts

@@ -19,6 +19,7 @@ import type {
   RecallSectionConfig,
   ReasoningEffort,
   SemanticChunkingConfigShape,
+  SecretRef,
   SessionObserverBandConfig,
   SlotBehaviorConfig,
   SlotMismatchMode,
@@ -3719,16 +3720,33 @@ export function parseConfig(
           ? (rawConnectors.googleDrive as Record<string, unknown>)
           : {};
       const driveEnabled = coerceBool(rawDrive.enabled) === true;
+      const driveClientIdRaw = rawDrive.clientId;
+      // SAFETY: a string value is a string; an object with a string source is a SecretRef, kept verbatim.
       const driveClientId =
-        typeof rawDrive.clientId === "string" ? rawDrive.clientId : "";
+        Object.prototype.toString.call(driveClientIdRaw) === "[object String]"
+          ? (driveClientIdRaw as string)
+          : Object.prototype.toString.call(driveClientIdRaw) === "[object Object]" &&
+            Object.prototype.toString.call((driveClientIdRaw as { source?: object }).source) === "[object String]"
+            ? (driveClientIdRaw as SecretRef)
+            : "";
+      const driveClientSecretRaw = rawDrive[CLIENT_SECRET_FIELD];
+      // SAFETY: a string value is a string; an object with a string source is a SecretRef, kept verbatim.
       const driveClientSecret =
-        typeof rawDrive[CLIENT_SECRET_FIELD] === "string"
-          ? rawDrive[CLIENT_SECRET_FIELD]
-          : "";
+        Object.prototype.toString.call(driveClientSecretRaw) === "[object String]"
+          ? (driveClientSecretRaw as string)
+          : Object.prototype.toString.call(driveClientSecretRaw) === "[object Object]" &&
+            Object.prototype.toString.call((driveClientSecretRaw as { source?: object }).source) === "[object String]"
+            ? (driveClientSecretRaw as SecretRef)
+            : "";
+      const driveRefreshTokenRaw = rawDrive[REFRESH_TOKEN_FIELD];
+      // SAFETY: a string value is a string; an object with a string source is a SecretRef, kept verbatim.
       const driveRefreshToken =
-        typeof rawDrive[REFRESH_TOKEN_FIELD] === "string"
-          ? rawDrive[REFRESH_TOKEN_FIELD]
-          : "";
+        Object.prototype.toString.call(driveRefreshTokenRaw) === "[object String]"
+          ? (driveRefreshTokenRaw as string)
+          : Object.prototype.toString.call(driveRefreshTokenRaw) === "[object Object]" &&
+            Object.prototype.toString.call((driveRefreshTokenRaw as { source?: object }).source) === "[object String]"
+            ? (driveRefreshTokenRaw as SecretRef)
+            : "";
       const drivePollCoerced = coerceNumber(rawDrive.pollIntervalMs);
       let drivePollIntervalMs = 300_000;
       if (drivePollCoerced !== undefined) {

package/src/connectors/live/framework.ts

@@ -1,3 +1,5 @@
+import type { ResolveSecretRefFn } from "../../resolve-auth-token.js";
+
 /**
  * @remnic/core — Live Connectors Framework (issue #683 PR 1/N)
  *
@@ -139,6 +141,12 @@ export interface SyncIncrementalArgs {
   readonly config: ConnectorConfig;
   /** Optional abort signal. Connectors SHOULD honor it for cooperative cancellation. */
   readonly abortSignal?: AbortSignal;
+  /**
+   * Host resolver for credential fields that hold a SecretRef. A connector
+   * resolves those at poll time. Absent a resolver, a plain string still works
+   * and a SecretRef fails that connector only.
+   */
+  readonly resolveSecretRef?: ResolveSecretRefFn | null;
 }
 
 /**

package/src/connectors/live/google-drive.test.ts

@@ -14,6 +14,7 @@ import {
   type GoogleDriveClientFactory,
   type GoogleDriveSyncResult,
 } from "./index.js";
+import { SECRET_RESOLVE_DEADLINE_MS } from "./google-drive.js";
 import type { ConnectorConfig, ConnectorCursor } from "./framework.js";
 
 /**
@@ -88,6 +89,79 @@ test("validateGoogleDriveConfig accepts a minimal valid config", () => {
   assert.deepEqual([...cfg.folderIds], []);
 });
 
+test("a SecretRef credential resolves at poll time and never reaches the persisted config", async () => {
+  const client = makeMockClient({});
+  let seenSecret = "";
+  const factory: GoogleDriveClientFactory = async (config) => {
+    seenSecret = config.clientSecret;
+    return client;
+  };
+  const connector = createGoogleDriveConnector({ clientFactory: factory });
+  const ref = { source: "keychain", id: "projects/drive-secret" };
+  const config: ConnectorConfig = { ...SYNTHETIC_CREDS, clientSecret: ref };
+  await connector.syncIncremental({
+    cursor: null,
+    config,
+    resolveSecretRef: async () => "resolved-drive-secret",
+  });
+  assert.equal(seenSecret, "resolved-drive-secret");
+  const persisted = JSON.stringify(connector.persistConfig?.(config) ?? {});
+  assert.equal(persisted.includes("resolved-drive-secret"), false);
+  assert.equal(persisted.includes("projects/drive-secret"), false);
+});
+
+test("a SecretRef with no resolver fails the connector and hides the reference", async () => {
+  const connector = createGoogleDriveConnector({ clientFactory: makeFactory(makeMockClient({})) });
+  const config: ConnectorConfig = { ...SYNTHETIC_CREDS, clientSecret: { source: "keychain", id: "projects/drive-secret" } };
+  let message = "";
+  try {
+    await connector.syncIncremental({ cursor: null, config });
+  } catch (err) {
+    message = err instanceof Error ? err.message : "";
+  }
+  assert.match(message, /clientSecret is a secret reference but no resolver is configured/);
+  assert.equal(message.includes("projects/drive-secret"), false);
+  assert.equal(message.includes("keychain"), false);
+});
+
+const DRIVE_REF_CONFIG: ConnectorConfig = {
+  ...SYNTHETIC_CREDS,
+  clientSecret: { source: "keychain", id: "projects/drive-secret" },
+};
+
+async function driveSyncError(args: { resolveSecretRef: () => Promise<string | undefined>; abortSignal?: AbortSignal }): Promise<Error> {
+  const connector = createGoogleDriveConnector({ clientFactory: makeFactory(makeMockClient({})) });
+  try {
+    await connector.syncIncremental({ cursor: null, config: DRIVE_REF_CONFIG, ...args });
+  } catch (err) {
+    return err instanceof Error ? err : new Error("non-error thrown");
+  }
+  return new Error("sync did not fail");
+}
+
+test("a SecretRef resolver that never settles is cut off by the abort signal", async () => {
+  const controller = new AbortController();
+  const failure = driveSyncError({ resolveSecretRef: () => new Promise(() => undefined), abortSignal: controller.signal });
+  await new Promise((resolve) => setImmediate(resolve));
+  controller.abort();
+  assert.equal((await failure).name, "AbortError");
+});
+
+test("a SecretRef resolver that never settles fails at the deadline", async (t) => {
+  t.mock.timers.enable({ apis: ["setTimeout"] });
+  const failure = driveSyncError({ resolveSecretRef: () => new Promise(() => undefined) });
+  await new Promise((resolve) => setImmediate(resolve));
+  t.mock.timers.tick(SECRET_RESOLVE_DEADLINE_MS);
+  const err = await failure;
+  assert.match(err.message, /clientSecret secret reference was not resolved within 30000 ms/);
+  assert.equal(err.message.includes("projects/drive-secret"), false);
+});
+
+test("a SecretRef that resolves to no value says the resolver may be unavailable", async () => {
+  const err = await driveSyncError({ resolveSecretRef: async () => undefined });
+  assert.match(err.message, /resolved to no value \(the host secret resolver may be unavailable\)/);
+});
+
 test("validateGoogleDriveConfig rejects non-object input", () => {
   assert.throws(() => validateGoogleDriveConfig(null), /must be an object/);
   assert.throws(() => validateGoogleDriveConfig([]), /must be an object/);

package/src/connectors/live/google-drive.ts

@@ -64,7 +64,9 @@ import type {
   SyncIncrementalResult,
 } from "./framework.js";
 import { isTransientHttpError } from "./transient-errors.js";
-import { throwIfAborted } from "../../abort-error.js";
+import { raceAbort, throwIfAborted } from "../../abort-error.js";
+import type { ResolveSecretRefFn } from "../../resolve-auth-token.js";
+import type { SecretRef } from "../../types.js";
 
 /**
  * Stable connector id. Lives in the registry under this exact string.
@@ -122,15 +124,40 @@ const FOLDER_ID_PATTERN = /^[A-Za-z0-9_-]{8,256}$/;
  * Validated, frozen view of `connectors.googleDrive.*`.
  */
 export interface GoogleDriveConnectorConfig {
+  readonly clientId: DriveCredential;
+  readonly clientSecret: DriveCredential;
+  readonly refreshToken: DriveCredential;
+  /** Poll interval surfaced to the scheduler. */
+  readonly pollIntervalMs: number;
+  /** Folder ids to scope import to. Empty = "all accessible". */
+  readonly folderIds: readonly string[];
+}
+
+/** A credential field as configured: a plain string, or a SecretRef resolved at poll time. */
+type DriveCredential = string | SecretRef;
+
+interface DriveCredentialFields {
+  clientId: DriveCredential;
+  clientSecret: DriveCredential;
+  refreshToken: DriveCredential;
+}
+
+/** Resolved credentials passed to the Drive client. Always plain strings. */
+interface GoogleDriveResolvedConfig {
   readonly clientId: string;
   readonly clientSecret: string;
   readonly refreshToken: string;
-  /** Poll interval surfaced to the scheduler. */
   readonly pollIntervalMs: number;
-  /** Folder ids to scope import to. Empty = "all accessible". */
   readonly folderIds: readonly string[];
 }
 
+/** Disk form of a Drive config. A SecretRef clientId is omitted, never written. */
+interface PersistedGoogleDriveConfig {
+  pollIntervalMs: number;
+  folderIds: readonly string[];
+  clientId?: string;
+}
+
 /**
  * Optional injection point for tests. The real connector dynamically imports
  * `googleapis`; tests pass a stub here to avoid the optional-peer-dep
@@ -139,7 +166,7 @@ export interface GoogleDriveConnectorConfig {
  * The shape only covers the tiny slice of the SDK we actually use.
  */
 export interface GoogleDriveClientFactory {
-  (config: GoogleDriveConnectorConfig): Promise<GoogleDriveClient>;
+  (config: GoogleDriveResolvedConfig): Promise<GoogleDriveClient>;
 }
 
 /**
@@ -243,9 +270,30 @@ export function validateGoogleDriveConfig(raw: unknown): GoogleDriveConnectorCon
     );
   }
   const r = raw as Record<string, unknown>;
-  const clientId = requireNonEmptyString(r.clientId, "clientId");
-  const clientSecret = requireNonEmptyString(r[CLIENT_SECRET_FIELD], CLIENT_SECRET_FIELD);
-  const refreshToken = requireNonEmptyString(r[REFRESH_TOKEN_FIELD], REFRESH_TOKEN_FIELD);
+  const credentialKeys = ["clientId", CLIENT_SECRET_FIELD, REFRESH_TOKEN_FIELD] as const;
+  const credentials: DriveCredentialFields = {
+    clientId: "",
+    clientSecret: "",
+    refreshToken: "",
+  };
+  for (const key of credentialKeys) {
+    const value = r[key];
+    if (Object.prototype.toString.call(value) === "[object Object]") {
+      // SAFETY: the toString check proves value is a non-null object.
+      const source = (value as { source?: object }).source;
+      if (Object.prototype.toString.call(source) === "[object String]") {
+        // SAFETY: a string `source` on this object is the SecretRef discriminator.
+        credentials[key] = value as SecretRef;
+      } else {
+        credentials[key] = requireNonEmptyString(value, key);
+      }
+    } else {
+      credentials[key] = requireNonEmptyString(value, key);
+    }
+  }
+  const clientId = credentials.clientId;
+  const clientSecret = credentials.clientSecret;
+  const refreshToken = credentials.refreshToken;
 
   let pollIntervalMs: number;
   if (r.pollIntervalMs === undefined) {
@@ -321,6 +369,76 @@ function requireNonEmptyString(value: unknown, key: string): string {
   return trimmed;
 }
 
+
+/** Longest wait for the host secret resolver, so a stalled secret store cannot hold the sync loop. */
+export const SECRET_RESOLVE_DEADLINE_MS = 30_000;
+
+async function resolveWithinDeadline(
+  ref: SecretRef,
+  key: string,
+  resolver: ResolveSecretRefFn,
+  abortSignal: AbortSignal | undefined,
+): Promise<string | undefined> {
+  throwIfAborted(abortSignal, "googleDrive: sync aborted");
+  const deadline = new AbortController();
+  const timer = setTimeout(() => deadline.abort(), SECRET_RESOLVE_DEADLINE_MS);
+  const signal = abortSignal ? AbortSignal.any([abortSignal, deadline.signal]) : deadline.signal;
+  try {
+    return await raceAbort(Promise.resolve(resolver(ref)), signal, "googleDrive: secret resolve aborted");
+  } catch {
+    throwIfAborted(abortSignal, "googleDrive: sync aborted");
+    if (deadline.signal.aborted) {
+      throw new Error(`googleDrive: ${key} secret reference was not resolved within ${SECRET_RESOLVE_DEADLINE_MS} ms`);
+    }
+    throw new Error(`googleDrive: ${key} secret reference could not be resolved`);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function resolveCredential(
+  value: DriveCredential,
+  key: string,
+  resolver: ResolveSecretRefFn | null | undefined,
+  abortSignal: AbortSignal | undefined,
+): Promise<string> {
+  if (Object.prototype.toString.call(value) !== "[object Object]") {
+    // SAFETY: a DriveCredential that is not an object is the plain string form.
+    return value as string;
+  }
+  // SAFETY: the toString check proves value is a non-null object, so it is a SecretRef.
+  const ref = value as SecretRef;
+  if (resolver == null) {
+    throw new Error(`googleDrive: ${key} is a secret reference but no resolver is configured`);
+  }
+  const resolved = await resolveWithinDeadline(ref, key, resolver, abortSignal);
+  if (resolved === undefined) {
+    throw new Error(`googleDrive: ${key} secret reference resolved to no value (the host secret resolver may be unavailable)`);
+  }
+  if (Object.prototype.toString.call(resolved) !== "[object String]") {
+    throw new Error(`googleDrive: ${key} secret reference resolved to a non-string value`);
+  }
+  const text = resolved.trim();
+  if (text.length === 0) {
+    throw new Error(`googleDrive: ${key} secret reference resolved to an empty value`);
+  }
+  return text;
+}
+
+async function resolveGoogleDriveConfig(
+  stored: GoogleDriveConnectorConfig,
+  resolver: ResolveSecretRefFn | null | undefined,
+  abortSignal: AbortSignal | undefined,
+): Promise<GoogleDriveResolvedConfig> {
+  return {
+    clientId: await resolveCredential(stored.clientId, "clientId", resolver, abortSignal),
+    [CLIENT_SECRET_FIELD]: await resolveCredential(stored[CLIENT_SECRET_FIELD], CLIENT_SECRET_FIELD, resolver, abortSignal),
+    [REFRESH_TOKEN_FIELD]: await resolveCredential(stored[REFRESH_TOKEN_FIELD], REFRESH_TOKEN_FIELD, resolver, abortSignal),
+    pollIntervalMs: stored.pollIntervalMs,
+    folderIds: stored.folderIds,
+  };
+}
+
 /**
  * Decide whether a Drive `change` corresponds to an importable text file
  * scoped to (optionally) the configured folder set.
@@ -405,16 +523,25 @@ export function createGoogleDriveConnector(
 
     persistConfig(validated: ConnectorConfig): ConnectorConfig {
       const config = validateGoogleDriveConfig(validated);
-      return Object.freeze({
-        clientId: config.clientId,
+      const persisted: PersistedGoogleDriveConfig = {
         pollIntervalMs: config.pollIntervalMs,
         folderIds: config.folderIds,
-      });
+      };
+      if (Object.prototype.toString.call(config.clientId) === "[object String]") {
+        // SAFETY: the toString check proves clientId is a string, not a SecretRef.
+        persisted.clientId = config.clientId as string;
+      }
+      return Object.freeze(persisted);
+
     },
 
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       // Re-validate on every pass: a JS caller could mutate it between passes.
-      const config = validateGoogleDriveConfig(args.config);
+      const config = await resolveGoogleDriveConfig(
+        validateGoogleDriveConfig(args.config),
+        args.resolveSecretRef,
+        args.abortSignal,
+      );
       throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
 
       const client = await clientFactory(config);