@remnic/core 10.0.92 → 10.0.93

package/dist/{chunk-IQWUACVG.js → chunk-UHMHJX5G.js}

@@ -4,7 +4,7 @@ import {
 import {
   judgeContradictionPairs,
   resolveScanStorage
-} from "./chunk-RMXS4I66.js";
+} from "./chunk-TVDJEUV5.js";
 import {
   CONTRADICTION_VERBS,
   PREFERENCE_DRIFT_VERBS,
@@ -15,7 +15,7 @@ import {
 } from "./chunk-CTVWELNK.js";
 import {
   composeMemoryEnvelope
-} from "./chunk-QEYTRFR3.js";
+} from "./chunk-X26YOFGS.js";
 import {
   readJsonFile,
   writeJsonFileAtomic
@@ -878,4 +878,4 @@ export {
   isValidResolutionVerb,
   executeResolution
 };
-//# sourceMappingURL=chunk-IQWUACVG.js.map
+//# sourceMappingURL=chunk-UHMHJX5G.js.map

package/dist/{chunk-YODUDA6R.js → chunk-UN4RVUG2.js}

@@ -1,15 +1,24 @@
+import {
+  applyWorkExtractionBoundary
+} from "./chunk-EI6V5UXY.js";
 import {
   applyGroundingWithConnector,
   headerConnector,
   renderExtractionConversation,
   resolveSourceConnector
-} from "./chunk-7HTUYFR3.js";
+} from "./chunk-LLPMMMWG.js";
 import {
   normalizeReasoningTrace
 } from "./chunk-54V4BZWP.js";
 import {
   shouldRunProactivePass
 } from "./chunk-2CGLBUW3.js";
+import {
+  ProfilingCollector
+} from "./chunk-DOWACHYO.js";
+import {
+  ModelRegistry
+} from "./chunk-QNUNAXBE.js";
 import {
   extractionProviderJsonSchema,
   extractionProviderResponseFormat
@@ -39,7 +48,7 @@ import {
 } from "./chunk-BVRZSI7Q.js";
 import {
   attachExtractionProvenance
-} from "./chunk-O55EKIEC.js";
+} from "./chunk-D3ZKHLN2.js";
 import {
   LocalLlmRejectedError,
   classifyExtractionThrownError,
@@ -55,6 +64,9 @@ import {
   formatDaySummaryMemories,
   loadDaySummaryPrompt
 } from "./chunk-7G5NTS7F.js";
+import {
+  LocalLlmClient
+} from "./chunk-RQFXZYTF.js";
 import {
   CONSOLIDATION_RESPONSE_SCHEMA,
   CUE_ANCHOR_PROMPT_INSTRUCTION,
@@ -70,36 +82,24 @@ import {
 import {
   looksLikeMechanicalTelemetryTranscript
 } from "./chunk-4RA3C3EV.js";
-import {
-  AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT,
-  clampAmbientCaptureConfidence
-} from "./chunk-QW27DOHG.js";
-import {
-  applyWorkExtractionBoundary
-} from "./chunk-EI6V5UXY.js";
-import {
-  ProfilingCollector
-} from "./chunk-DOWACHYO.js";
-import {
-  ModelRegistry
-} from "./chunk-QNUNAXBE.js";
-import {
-  LocalLlmClient
-} from "./chunk-IPT2OY4B.js";
 import {
   normalizeProcedureSteps
 } from "./chunk-QDW3E4RD.js";
 import {
   FallbackLlmClient,
   gatewayTaskChainOptions
-} from "./chunk-ZU5JDLOH.js";
+} from "./chunk-MMRTPH3J.js";
 import {
   buildChatCompletionTokenLimit,
   shouldAssumeOpenAiChatCompletions
 } from "./chunk-L2EXJQJP.js";
 import {
   fallbackLlmRuntimeContextFromConfig
-} from "./chunk-ZU3NJNO7.js";
+} from "./chunk-QSF5SJAM.js";
+import {
+  AMBIENT_CAPTURE_PROMPT_SECTION_COMPACT,
+  clampAmbientCaptureConfidence
+} from "./chunk-QW27DOHG.js";
 import {
   extractJsonCandidates
 } from "./chunk-YBA52OKG.js";
@@ -111,7 +111,7 @@ import {
 } from "./chunk-C5LWPYS3.js";
 import {
   isMemoryCategory
-} from "./chunk-QEYTRFR3.js";
+} from "./chunk-X26YOFGS.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -2443,4 +2443,4 @@ export {
   shouldEnableLocalExtractionThinking,
   ExtractionEngine
 };
-//# sourceMappingURL=chunk-YODUDA6R.js.map
+//# sourceMappingURL=chunk-UN4RVUG2.js.map

package/dist/{chunk-E6Z4FBX6.js → chunk-V2QSNFCT.js}

@@ -1,6 +1,6 @@
 import {
   getConfiguredNamespaces
-} from "./chunk-I6QGI65T.js";
+} from "./chunk-QRMG4HK4.js";
 import {
   drainPendingLifecycleForSyncOrThrow,
   drainPendingLifecycleLedgerForSync
@@ -181,4 +181,4 @@ export {
   offlineSyncStorageForSnapshot,
   drainPendingLifecycleForOfflineSync
 };
-//# sourceMappingURL=chunk-E6Z4FBX6.js.map
+//# sourceMappingURL=chunk-V2QSNFCT.js.map

package/dist/{chunk-NBH6K6G5.js → chunk-V65H7MI6.js}

@@ -1,10 +1,19 @@
 import {
-  isValidConnectorId
+  ConnectorStateLockLostError,
+  isValidConnectorId,
+  readConnectorState,
+  withConnectorStateLock,
+  writeConnectorState
 } from "./chunk-MDPT6QFK.js";
 import {
   isTransientHttpError
 } from "./chunk-C7SRUWBW.js";
 import {
+  runConnectorPollOnce
+} from "./chunk-OKTXM5H4.js";
+import {
+  abortError,
+  raceAbort,
   throwIfAborted
 } from "./chunk-R2MBW2S4.js";
 
@@ -209,7 +218,25 @@ function requireNonEmptyString(value, key) {
   }
   return trimmed;
 }
-async function resolveCredential(value, key, resolver) {
+var SECRET_RESOLVE_DEADLINE_MS = 3e4;
+async function resolveWithinDeadline(ref, key, resolver, abortSignal) {
+  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, key, resolver, abortSignal) {
   if (Object.prototype.toString.call(value) !== "[object Object]") {
     return value;
   }
@@ -217,11 +244,9 @@ async function resolveCredential(value, key, resolver) {
   if (resolver == null) {
     throw new Error(`googleDrive: ${key} is a secret reference but no resolver is configured`);
   }
-  let resolved;
-  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 === void 0) {
+    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`);
@@ -232,11 +257,11 @@ async function resolveCredential(value, key, resolver) {
   }
   return text;
 }
-async function resolveGoogleDriveConfig(stored, resolver) {
+async function resolveGoogleDriveConfig(stored, resolver, abortSignal) {
   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
   };
@@ -300,7 +325,11 @@ function createGoogleDriveConnector(options = {}) {
       return Object.freeze(persisted);
     },
     async syncIncremental(args) {
-      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);
       throwIfAborted(args.abortSignal, "googleDrive: sync aborted");
@@ -2069,6 +2098,305 @@ function buildTitle(repo, kind, comment) {
   return `${kindLabel} in ${repo} (#${comment.id})`;
 }
 
+// src/live-connectors-runner.ts
+function builtInLiveConnectorDefinitions(config) {
+  return [
+    {
+      id: GOOGLE_DRIVE_CONNECTOR_ID,
+      displayName: "Google Drive",
+      enabled: config.googleDrive.enabled,
+      pollIntervalMs: config.googleDrive.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+      rawConfig: config.googleDrive,
+      createConnector: createGoogleDriveConnector,
+      validateConfig: (raw) => validateGoogleDriveConfig(raw)
+    },
+    {
+      id: NOTION_CONNECTOR_ID,
+      displayName: "Notion",
+      enabled: config.notion.enabled,
+      pollIntervalMs: config.notion.pollIntervalMs ?? NOTION_DEFAULT_POLL_INTERVAL_MS,
+      rawConfig: config.notion,
+      createConnector: createNotionConnector,
+      validateConfig: (raw) => validateNotionConfig(raw)
+    },
+    {
+      id: GMAIL_CONNECTOR_ID,
+      displayName: "Gmail",
+      enabled: config.gmail.enabled,
+      pollIntervalMs: config.gmail.pollIntervalMs ?? GMAIL_DEFAULT_POLL_INTERVAL_MS,
+      rawConfig: config.gmail,
+      createConnector: createGmailConnector,
+      validateConfig: (raw) => validateGmailConfig(raw)
+    },
+    {
+      id: GITHUB_CONNECTOR_ID,
+      displayName: "GitHub",
+      enabled: config.github.enabled,
+      pollIntervalMs: config.github.pollIntervalMs ?? GITHUB_DEFAULT_POLL_INTERVAL_MS,
+      rawConfig: config.github,
+      createConnector: createGitHubConnector,
+      validateConfig: (raw) => validateGitHubConfig(raw)
+    }
+  ];
+}
+function hasEnabledLiveConnector(config) {
+  return config.googleDrive.enabled || config.notion.enabled || config.gmail.enabled || config.github.enabled;
+}
+async function runLiveConnectorsOnce(options) {
+  const ranAt = resolveNow(options.now);
+  const force = options.force === true;
+  const definitions = options.definitions ?? builtInLiveConnectorDefinitions(options.connectors);
+  const results = [];
+  for (const definition of definitions) {
+    const checkAt = resolveNow(options.now);
+    if (!definition.enabled) {
+      results.push(skipResult(definition, null, "disabled"));
+      continue;
+    }
+    let state;
+    try {
+      state = await readConnectorState(options.memoryDir, definition.id);
+    } catch (err) {
+      results.push({
+        id: definition.id,
+        displayName: definition.displayName,
+        enabled: true,
+        ran: false,
+        skippedReason: "state_read_error",
+        docsImported: 0,
+        error: err instanceof Error ? err.message : String(err),
+        lastSyncAt: null,
+        nextDueAt: null
+      });
+      continue;
+    }
+    if (!force && !isConnectorDue(state, definition.pollIntervalMs, checkAt)) {
+      results.push(skipResult(definition, state, "not_due"));
+      continue;
+    }
+    let validatedConfig;
+    try {
+      validatedConfig = definition.validateConfig(definition.rawConfig);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      let stateWriteError;
+      let writtenErrorState;
+      const errorAt = resolveNow(options.now);
+      try {
+        writtenErrorState = await writeConnectorErrorState({
+          memoryDir: options.memoryDir,
+          connectorId: definition.id,
+          state,
+          error: message,
+          now: errorAt
+        });
+      } catch (writeErr) {
+        stateWriteError = writeErr instanceof Error ? writeErr.message : String(writeErr);
+      }
+      const reportedState = writtenErrorState ?? state;
+      results.push({
+        id: definition.id,
+        displayName: definition.displayName,
+        enabled: true,
+        ran: false,
+        skippedReason: "invalid_config",
+        docsImported: 0,
+        error: message,
+        ...stateWriteError !== void 0 ? { stateWriteError } : {},
+        lastSyncAt: reportedState?.lastSyncAt ?? null,
+        nextDueAt: nextDueAt(reportedState, definition.pollIntervalMs)
+      });
+      continue;
+    }
+    let runResult;
+    let lastStateWrittenAt;
+    try {
+      const connector = definition.createConnector();
+      runResult = await withConnectorStateLock(options.memoryDir, definition.id, async (lockSignal) => {
+        const pollAbortSignal = combineAbortSignals(options.abortSignal, lockSignal);
+        const lockedState = await readConnectorState(options.memoryDir, definition.id);
+        if (!force && !isConnectorDue(lockedState, definition.pollIntervalMs, checkAt)) {
+          return { docsImported: 0 };
+        }
+        state = lockedState;
+        return runConnectorPollOnce({
+          connectorId: definition.id,
+          priorState: lockedState,
+          syncFn: (cursor) => connector.syncIncremental({
+            cursor,
+            config: validatedConfig,
+            abortSignal: pollAbortSignal,
+            resolveSecretRef: options.resolveSecretRef
+          }),
+          ingestFn: async (docs) => {
+            throwIfAborted2(pollAbortSignal);
+            await options.ingestDocuments(docs);
+            throwIfAborted2(pollAbortSignal);
+          },
+          writeCursorFn: (writeState) => {
+            throwIfAborted2(pollAbortSignal);
+            const writeAt = resolveNow(options.now);
+            return writeConnectorState(options.memoryDir, definition.id, {
+              id: definition.id,
+              cursor: writeState.cursor,
+              lastSyncAt: writeAt.toISOString(),
+              lastSyncStatus: writeState.lastSyncStatus,
+              ...writeState.lastSyncError !== void 0 ? { lastSyncError: writeState.lastSyncError } : {},
+              totalDocsImported: writeState.totalDocsImported
+            }).then(() => {
+              lastStateWrittenAt = writeAt;
+            });
+          }
+        });
+      });
+      if (runResult.docsImported === 0 && runResult.error === void 0 && runResult.stateWriteError === void 0 && lastStateWrittenAt === void 0) {
+        const lockedState = await readConnectorState(options.memoryDir, definition.id);
+        if (!force && !isConnectorDue(lockedState, definition.pollIntervalMs, checkAt)) {
+          results.push(skipResult(definition, lockedState, "not_due"));
+          continue;
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      let stateWriteError;
+      let writtenErrorState;
+      const errorAt = resolveNow(options.now);
+      if (!(err instanceof ConnectorStateLockLostError)) {
+        try {
+          writtenErrorState = await writeConnectorErrorState({
+            memoryDir: options.memoryDir,
+            connectorId: definition.id,
+            state,
+            error: message,
+            now: errorAt
+          });
+        } catch (writeErr) {
+          stateWriteError = writeErr instanceof Error ? writeErr.message : String(writeErr);
+        }
+      }
+      const reportedState = writtenErrorState ?? state;
+      results.push({
+        id: definition.id,
+        displayName: definition.displayName,
+        enabled: true,
+        ran: false,
+        skippedReason: "connector_error",
+        docsImported: 0,
+        error: message,
+        ...stateWriteError !== void 0 ? { stateWriteError } : {},
+        lastSyncAt: reportedState?.lastSyncAt ?? null,
+        nextDueAt: nextDueAt(reportedState, definition.pollIntervalMs)
+      });
+      continue;
+    }
+    results.push(
+      runItemFromResult(
+        definition,
+        runResult,
+        state,
+        lastStateWrittenAt ?? resolveNow(options.now)
+      )
+    );
+  }
+  return {
+    ranAt: ranAt.toISOString(),
+    force,
+    totalDocsImported: results.reduce((sum, item) => sum + item.docsImported, 0),
+    ranCount: results.filter((item) => item.ran).length,
+    skippedCount: results.filter((item) => !item.ran).length,
+    errorCount: results.filter(
+      (item) => item.error !== void 0 || item.stateWriteError !== void 0
+    ).length,
+    results
+  };
+}
+function resolveNow(now) {
+  return typeof now === "function" ? now() : now ?? /* @__PURE__ */ new Date();
+}
+function isConnectorDue(state, pollIntervalMs, now) {
+  if (state?.lastSyncAt === null || state?.lastSyncAt === void 0) return true;
+  const lastMs = Date.parse(state.lastSyncAt);
+  if (!Number.isFinite(lastMs)) return true;
+  return now.getTime() - lastMs >= Math.max(1, Math.floor(pollIntervalMs));
+}
+function nextDueAt(state, pollIntervalMs) {
+  if (state?.lastSyncAt === null || state?.lastSyncAt === void 0) return null;
+  const lastMs = Date.parse(state.lastSyncAt);
+  if (!Number.isFinite(lastMs)) return null;
+  return new Date(lastMs + Math.max(1, Math.floor(pollIntervalMs))).toISOString();
+}
+function skipResult(definition, state, skippedReason) {
+  return {
+    id: definition.id,
+    displayName: definition.displayName,
+    enabled: definition.enabled,
+    ran: false,
+    skippedReason,
+    docsImported: 0,
+    lastSyncAt: state?.lastSyncAt ?? null,
+    nextDueAt: skippedReason === "not_due" ? nextDueAt(state, definition.pollIntervalMs) : null
+  };
+}
+function runItemFromResult(definition, result, priorState, now) {
+  const stateWriteFailed = result.stateWriteError !== void 0;
+  const reportedLastSyncAt = stateWriteFailed ? priorState?.lastSyncAt ?? null : now.toISOString();
+  const reportedNextDueAt = stateWriteFailed ? nextDueAt(priorState, definition.pollIntervalMs) : new Date(
+    now.getTime() + Math.max(1, Math.floor(definition.pollIntervalMs))
+  ).toISOString();
+  return {
+    id: definition.id,
+    displayName: definition.displayName,
+    enabled: definition.enabled,
+    ran: true,
+    docsImported: result.docsImported,
+    ...result.error !== void 0 ? { error: result.error } : {},
+    ...result.stateWriteError !== void 0 ? { stateWriteError: result.stateWriteError } : {},
+    lastSyncAt: reportedLastSyncAt,
+    nextDueAt: reportedNextDueAt
+  };
+}
+function combineAbortSignals(...signals) {
+  const activeSignals = signals.filter((signal) => signal !== void 0);
+  if (activeSignals.length === 0) return void 0;
+  if (activeSignals.length === 1) return activeSignals[0];
+  const abortSignalAny = AbortSignal.any;
+  if (abortSignalAny !== void 0) {
+    return abortSignalAny(activeSignals);
+  }
+  const controller = new AbortController();
+  const abort = (signal) => {
+    if (!controller.signal.aborted) {
+      controller.abort(signal.reason);
+    }
+  };
+  for (const signal of activeSignals) {
+    if (signal.aborted) {
+      abort(signal);
+      break;
+    }
+    signal.addEventListener("abort", () => abort(signal), { once: true });
+  }
+  return controller.signal;
+}
+function throwIfAborted2(signal) {
+  if (signal?.aborted !== true) return;
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    throw reason;
+  }
+  throw abortError(reason === void 0 ? "operation aborted" : String(reason));
+}
+async function writeConnectorErrorState(options) {
+  return writeConnectorState(options.memoryDir, options.connectorId, {
+    id: options.connectorId,
+    cursor: options.state?.cursor ?? null,
+    lastSyncAt: options.now.toISOString(),
+    lastSyncStatus: "error",
+    lastSyncError: options.error,
+    totalDocsImported: options.state?.totalDocsImported ?? 0
+  });
+}
+
 export {
   LiveConnectorRegistryError,
   LiveConnectorRegistry,
@@ -2084,12 +2412,13 @@ export {
   validateNotionConfig,
   createNotionConnector,
   GMAIL_CONNECTOR_ID,
-  GMAIL_DEFAULT_POLL_INTERVAL_MS,
   validateGmailConfig,
   createGmailConnector,
   GITHUB_CONNECTOR_ID,
-  GITHUB_DEFAULT_POLL_INTERVAL_MS,
   validateGitHubConfig,
-  createGitHubConnector
+  createGitHubConnector,
+  builtInLiveConnectorDefinitions,
+  hasEnabledLiveConnector,
+  runLiveConnectorsOnce
 };
-//# sourceMappingURL=chunk-NBH6K6G5.js.map
+//# sourceMappingURL=chunk-V65H7MI6.js.map