@remnic/core 10.0.92 → 10.0.93

package/src/access-mcp-frames.ts

@@ -1,28 +1,41 @@
 /**
- * Content-Length framing for the MCP stdio transport.
+ * Framing for the MCP stdio transport.
  *
- * `push` appends raw bytes. `next` returns one frame at a time and `null` when
- * the buffered bytes hold no complete frame yet. The header and the body are
- * each bounded to MCP_STDIO_MAX_FRAME_BYTES, which matches the HTTP access
- * default `maxBodyBytes`, so a peer cannot grow the buffer without limit.
+ * The MCP spec sends one JSON message per line. Some clients send a
+ * `Content-Length` header instead. `push` appends raw bytes. `next` returns one
+ * frame at a time and `null` when the buffered bytes hold no complete frame
+ * yet. A buffer whose first non-blank byte is `{` or `[` is read up to the next
+ * newline. Any other buffer is a header block. Each form is bounded to
+ * MCP_STDIO_MAX_FRAME_BYTES, so a peer cannot grow the buffer without limit.
  */
 export const MCP_STDIO_MAX_FRAME_BYTES = 131072;
 
-export type McpFrame = { kind: "body"; text: string } | { kind: "too-large" };
+export type McpFrameForm = "header" | "line";
 
-const TOO_LARGE: McpFrame = { kind: "too-large" };
+export type McpFrame =
+  | { kind: "body"; text: string; form: McpFrameForm }
+  | { kind: "too-large"; form: McpFrameForm };
+
+const HEADER_PREFIX = "content-length:";
 
 export class McpFrameReader {
   private buffer = Buffer.alloc(0);
-  /** Body bytes of a refused oversized frame that have not arrived yet. */
+  /** Body bytes of a refused oversized header frame that have not arrived yet. */
   private skipBytes = 0;
+  /** True while the rest of a refused oversized line has not arrived yet. */
+  private skipLine = false;
   /** Buffer length when `next` last stopped on an incomplete frame. */
   private waitingBytes = 0;
 
   push(chunk: Buffer): void {
     const dropped = Math.min(this.skipBytes, chunk.length);
     this.skipBytes -= dropped;
-    const kept = chunk.subarray(dropped);
+    let kept = chunk.subarray(dropped);
+    if (this.skipLine) {
+      const newline = kept.indexOf("\n");
+      this.skipLine = newline < 0;
+      kept = kept.subarray(newline < 0 ? kept.length : newline + 1);
+    }
     if (kept.length > 0) this.buffer = Buffer.concat([this.buffer, kept]);
   }
 
@@ -33,15 +46,33 @@ export class McpFrameReader {
 
   next(): McpFrame | null {
     this.waitingBytes = 0;
+    // A blank line carries no message. Skip it and read the next frame, so a
+    // run of blank lines cannot stall the frames that follow in this buffer.
+    for (;;) {
+      const frame = this.isHeaderFrame() ? this.nextHeader() : this.nextLine();
+      if (frame !== "blank") return frame;
+    }
+  }
+
+  /** A line frame starts with `{` or `[`, as every JSON-RPC message does. Any other first byte starts a header block. */
+  private isHeaderFrame(): boolean {
+    const first = this.buffer.find((byte) => byte > 0x20);
+    return first !== undefined && first !== 0x7b && first !== 0x5b;
+  }
+
+  private nextHeader(): McpFrame | null {
+    // Blank lines before a header block carry no message; drop them so they
+    // cannot end up inside the first header line.
+    this.buffer = this.release(this.buffer.subarray(this.buffer.findIndex((byte) => byte > 0x20)));
     const headerEnd = this.buffer.indexOf("\r\n\r\n");
     if (headerEnd < 0) {
       if (this.buffer.length <= MCP_STDIO_MAX_FRAME_BYTES) return this.wait();
-      return this.discardBuffer();
+      return this.discardBuffer("header");
     }
-    if (headerEnd > MCP_STDIO_MAX_FRAME_BYTES) return this.discardBuffer();
+    if (headerEnd > MCP_STDIO_MAX_FRAME_BYTES) return this.discardBuffer("header");
 
     const headers = this.buffer.subarray(0, headerEnd).toString("utf-8").split("\r\n");
-    const lengthHeader = headers.find((line) => line.toLowerCase().startsWith("content-length:"));
+    const lengthHeader = headers.find((line) => line.toLowerCase().startsWith(HEADER_PREFIX));
     const contentLength = lengthHeader ? Number.parseInt(lengthHeader.split(":")[1]?.trim() ?? "0", 10) : NaN;
     if (!Number.isFinite(contentLength) || contentLength < 0) {
       this.buffer = Buffer.alloc(0);
@@ -52,14 +83,37 @@ export class McpFrameReader {
     if (contentLength > MCP_STDIO_MAX_FRAME_BYTES) {
       const rest = this.buffer.subarray(bodyStart);
       this.skipBytes = Math.max(0, contentLength - rest.length);
-      this.buffer = rest.subarray(Math.min(contentLength, rest.length));
-      return TOO_LARGE;
+      this.buffer = this.release(rest.subarray(Math.min(contentLength, rest.length)));
+      return { kind: "too-large", form: "header" };
     }
     const bodyEnd = bodyStart + contentLength;
     if (this.buffer.length < bodyEnd) return this.wait();
     const text = this.buffer.subarray(bodyStart, bodyEnd).toString("utf-8");
-    this.buffer = this.buffer.subarray(bodyEnd);
-    return { kind: "body", text };
+    this.buffer = this.release(this.buffer.subarray(bodyEnd));
+    return { kind: "body", text, form: "header" };
+  }
+
+  /** A line frame, `"blank"` for an empty line, or `null` when more bytes must arrive. */
+  private nextLine(): McpFrame | "blank" | null {
+    const newline = this.buffer.indexOf("\n");
+    if (newline < 0) {
+      if (this.buffer.length <= MCP_STDIO_MAX_FRAME_BYTES) return this.wait();
+      this.skipLine = true;
+      return this.discardBuffer("line");
+    }
+    if (newline > MCP_STDIO_MAX_FRAME_BYTES) {
+      this.buffer = this.release(this.buffer.subarray(newline + 1));
+      return { kind: "too-large", form: "line" };
+    }
+    const text = this.buffer.subarray(0, newline).toString("utf-8").replace(/\r$/, "");
+    this.buffer = this.release(this.buffer.subarray(newline + 1));
+    if (text.trim().length === 0) return "blank";
+    return { kind: "body", text, form: "line" };
+  }
+
+  /** An empty view would keep the old allocation alive while the connection idles. */
+  private release(view: Buffer<ArrayBuffer>): Buffer<ArrayBuffer> {
+    return view.length === 0 ? Buffer.alloc(0) : view;
   }
 
   private wait(): null {
@@ -67,8 +121,8 @@ export class McpFrameReader {
     return null;
   }
 
-  private discardBuffer(): McpFrame {
+  private discardBuffer(form: McpFrameForm): McpFrame {
     this.buffer = Buffer.alloc(0);
-    return TOO_LARGE;
+    return { kind: "too-large", form };
   }
 }

package/src/access-mcp.test.ts

@@ -1624,6 +1624,15 @@ function stdioFrame(payload: StdioRequest): string {
 }
 
 function readStdioMessages(raw: string): StdioMessage[] {
+  if (!raw.toLowerCase().startsWith("content-length:")) {
+    return raw
+      .split("\n")
+      .filter((line) => line.trim().length > 0)
+      .map((line) => {
+        const message: StdioMessage = JSON.parse(line);
+        return message;
+      });
+  }
   const messages: StdioMessage[] = [];
   let rest = raw;
   while (rest.length > 0) {
@@ -1638,7 +1647,7 @@ function readStdioMessages(raw: string): StdioMessage[] {
 }
 
 /** Feeds each chunk in its own tick so the server sees separate data events. */
-async function runStdioChunks(chunks: string[]): Promise<StdioMessage[]> {
+async function runStdioRaw(chunks: string[]): Promise<string> {
   const input = new PassThrough();
   const output = new PassThrough();
   output.setEncoding("utf8");
@@ -1653,7 +1662,11 @@ async function runStdioChunks(chunks: string[]): Promise<StdioMessage[]> {
   }
   input.end();
   await running;
-  return readStdioMessages(raw);
+  return raw;
+}
+
+async function runStdioChunks(chunks: string[]): Promise<StdioMessage[]> {
+  return readStdioMessages(await runStdioRaw(chunks));
 }
 
 const stdioPing = (id: number) => stdioFrame({ jsonrpc: "2.0", id, method: "ping" });
@@ -1685,3 +1698,54 @@ test("MCP stdio reassembles a frame split inside its header and inside its body"
   assert.equal(messages.length, 1);
   assert.equal(messages[0]?.id, 9);
 });
+
+// Issue #3357: a spec client sends one JSON message per line and reads the
+// reply in the same form. The server keeps Content-Length for a header client.
+type StdioLineRequest = { jsonrpc: "2.0"; id: number; method: string; params?: { protocolVersion?: string } };
+const stdioInit: StdioLineRequest = { jsonrpc: "2.0", id: 1, method: "initialize", params: { protocolVersion: "2025-06-18" } };
+const stdioTools: StdioLineRequest = { jsonrpc: "2.0", id: 2, method: "tools/list" };
+
+function stdioLine(payload: StdioLineRequest): string {
+  return `${JSON.stringify(payload)}\n`;
+}
+
+test("MCP stdio answers a newline-delimited initialize and tools/list with newline-delimited replies", async () => {
+  const messages = await runStdioChunks([stdioLine(stdioInit), stdioLine(stdioTools)]);
+  assert.equal(messages.length, 2);
+  assert.equal(messages[0]?.id, 1);
+  assert.equal(messages[1]?.id, 2);
+  assert.ok(messages[1]?.result, "tools/list returns a result");
+});
+
+test("MCP stdio answers a Content-Length initialize and tools/list with Content-Length replies", async () => {
+  const header = (payload: StdioLineRequest): string => {
+    const body = JSON.stringify(payload);
+    return `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n${body}`;
+  };
+  const messages = await runStdioChunks([header(stdioInit), header(stdioTools)]);
+  assert.equal(messages.length, 2);
+  assert.equal(messages[0]?.id, 1);
+  assert.equal(messages[1]?.id, 2);
+});
+
+test("MCP stdio refuses an oversized newline-delimited line and answers the next line", async () => {
+  const messages = await runStdioChunks([
+    `{${"A".repeat(MCP_STDIO_MAX_FRAME_BYTES + 1)}\n`,
+    stdioLine({ jsonrpc: "2.0", id: 4, method: "ping" }),
+  ]);
+  assert.equal(messages.length, 2);
+  assert.match(messages[0]?.error?.message ?? "", /frame too large/);
+  assert.equal(messages[1]?.id, 4);
+});
+
+test("MCP stdio takes the reply form from the first JSON frame, not from a refused first frame", async () => {
+  const raw = await runStdioRaw([
+    "A".repeat(MCP_STDIO_MAX_FRAME_BYTES + 1),
+    stdioLine({ jsonrpc: "2.0", id: 5, method: "ping" }),
+    stdioLine({ jsonrpc: "2.0", id: 6, method: "ping" }),
+  ]);
+  assert.equal(raw.split("Content-Length").length - 1, 1, "only the reply to the refused frame is Content-Length framed");
+  const afterHeader = raw.slice(raw.indexOf("\r\n\r\n") + 4);
+  const replies = afterHeader.slice(afterHeader.indexOf("}}") + 2).split("\n").filter((line) => line.length > 0);
+  assert.deepEqual(replies.map((line) => JSON.parse(line).id), [5, 6]);
+});

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/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/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";
 
 /**
@@ -123,6 +124,44 @@ test("a SecretRef with no resolver fails the connector and hides the reference",
   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,7 @@ 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";
 
@@ -370,10 +370,37 @@ function requireNonEmptyString(value: unknown, key: string): string {
 }
 
 
+/** 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.
@@ -384,17 +411,14 @@ async function resolveCredential(
   if (resolver == null) {
     throw new Error(`googleDrive: ${key} is a secret reference but no resolver is configured`);
   }
-  let resolved: unknown;
-  try {
-    resolved = await resolver(ref);
-  } catch {
-    throw new Error(`googleDrive: ${key} secret reference could not be resolved`);
+  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`);
   }
-  // SAFETY: the toString check above proves `resolved` is a string.
-  const text = (resolved as string).trim();
+  const text = resolved.trim();
   if (text.length === 0) {
     throw new Error(`googleDrive: ${key} secret reference resolved to an empty value`);
   }
@@ -404,11 +428,12 @@ async function resolveCredential(
 async function resolveGoogleDriveConfig(
   stored: GoogleDriveConnectorConfig,
   resolver: ResolveSecretRefFn | null | undefined,
+  abortSignal: AbortSignal | undefined,
 ): Promise<GoogleDriveResolvedConfig> {
   return {
-    clientId: await resolveCredential(stored.clientId, "clientId", resolver),
-    [CLIENT_SECRET_FIELD]: await resolveCredential(stored[CLIENT_SECRET_FIELD], CLIENT_SECRET_FIELD, resolver),
-    [REFRESH_TOKEN_FIELD]: await resolveCredential(stored[REFRESH_TOKEN_FIELD], REFRESH_TOKEN_FIELD, resolver),
+    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,
   };
@@ -512,7 +537,11 @@ export function createGoogleDriveConnector(
 
     async syncIncremental(args: SyncIncrementalArgs): Promise<SyncIncrementalResult> {
       // Re-validate on every pass: a JS caller could mutate it between passes.
-      const config = await resolveGoogleDriveConfig(validateGoogleDriveConfig(args.config), args.resolveSecretRef);
+      const config = await resolveGoogleDriveConfig(
+        validateGoogleDriveConfig(args.config),
+        args.resolveSecretRef,
+        args.abortSignal,
+      );
       throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
 
       const client = await clientFactory(config);