@remnic/core 9.7.9 → 9.7.11

package/src/access-http.ts

@@ -53,6 +53,7 @@ import { handleChatMessage, handleChatEventsSSE } from "./chat/chat-http.js";
 import { cleanupExpiredChatSessions, enforceChatSessionNamespace } from "./chat/chat-session.js";
 import { isDefaultReviewNamespace, listPairs, readPair } from "./contradiction/contradiction-review.js";
 import { isValidResolutionVerb, executeResolution } from "./contradiction/resolution.js";
+import { RelayMissionStoreError } from "./relay/mission.js";
 
 export interface AccessHttpReadinessState {
   ready: boolean;
@@ -339,6 +340,22 @@ function decodePeerIdSegment(raw: string): string {
   }
 }
 
+function decodeRelayMissionIdSegment(raw: string): string {
+  try {
+    return decodeURIComponent(raw);
+  } catch {
+    throw new EngramAccessInputError(
+      "missionId path segment is not valid percent-encoded input",
+    );
+  }
+}
+
+function rejectBlankRelayNamespace(value: string | null | undefined): void {
+  if (value !== undefined && value !== null && value.trim().length === 0) {
+    throw new EngramAccessInputError("Relay namespace must not be blank when provided");
+  }
+}
+
 function codingContextFromProjectTag(projectTag: string): {
   projectId: string;
   branch: string | null;
@@ -378,7 +395,7 @@ export class EngramAccessHttpServer {
     res: ServerResponse,
     ctx: { authorized: boolean },
   ) => Promise<boolean>;
-  private readonly writeRequestTimestamps: number[] = [];
+  private readonly writeRequestSlots: Array<{ readonly recordedAt: number }> = [];
   private readonly writeRateLimitMaxRequests: number;
   private readonly writeRateLimitWindowMs: number;
   private readonly mcpServer: EngramMcpServer;
@@ -499,6 +516,20 @@ export class EngramAccessHttpServer {
             this.respondJson(res, 400, { error: err.message, code: "correction_contract_error" });
             return;
           }
+          if (err instanceof RelayMissionStoreError) {
+            const status = err.code === "idempotency_conflict"
+              ? 409
+              : err.code === "limit_exceeded"
+                ? 413
+                : err.code === "lock_unavailable"
+                  ? 503
+                  : 500;
+            this.respondJson(res, status, {
+              error: status >= 500 ? "relay_backend_unavailable" : err.message,
+              code: `relay_${err.code}`,
+            });
+            return;
+          }
           if (res.headersSent) {
             res.destroy(err as Error);
             return;
@@ -1670,6 +1701,103 @@ export class EngramAccessHttpServer {
       return;
     }
 
+    // Remnic Relay mission receipts (issue #1966). These two routes share the
+    // access-boundary schemas and namespace-resolved storage contract. The
+    // browser receives an already-reduced snapshot; it never scans general
+    // memories, recall logs, or production state.
+    const relayEventMatch = /^\/engram\/v1\/relay\/missions\/([^/]+)\/events$/.exec(pathname);
+    if (req.method === "POST" && relayEventMatch) {
+      const missionId = decodeRelayMissionIdSegment(relayEventMatch[1] ?? "");
+      const body = await this.readJsonBody(req);
+      const unexpectedFields = Object.keys(body).filter(
+        (key) => key !== "namespace" && key !== "event",
+      );
+      if (unexpectedFields.length > 0) {
+        throw new EngramAccessInputError(
+          `Relay append body contains unexpected field(s): ${unexpectedFields.sort().join(", ")}`,
+        );
+      }
+      if (!Object.prototype.hasOwnProperty.call(body, "event")) {
+        throw new EngramAccessInputError("Relay append body must contain an event object");
+      }
+      if (
+        Object.prototype.hasOwnProperty.call(body, "namespace") &&
+        body.namespace !== undefined &&
+        body.namespace !== null &&
+        typeof body.namespace !== "string"
+      ) {
+        throw new EngramAccessInputError("namespace must be a string when provided");
+      }
+      rejectBlankRelayNamespace(
+        typeof body.namespace === "string" ? body.namespace : undefined,
+      );
+      const namespace = this.resolveNamespace(
+        req,
+        typeof body.namespace === "string" ? body.namespace : undefined,
+      );
+      const op = getOperation("relay_mission_append");
+      if (!op) {
+        throw new Error("access-boundary: operation not registered: relay_mission_append");
+      }
+      let releaseWriteQuota: (() => void) | undefined;
+      try {
+        const output = (await op.run(
+          { missionId, namespace, event: body.event },
+          {
+            service: this.service,
+            authenticatedPrincipal: this.resolveRequestPrincipal(req),
+            hooks: {
+              enforceWriteQuota: () => {
+                releaseWriteQuota ??= this.reserveWriteRateLimitSlot();
+              },
+            },
+          },
+        )) as { result: { appended: boolean; replayed: boolean; event: unknown } };
+        if (output.result.appended) {
+          // The reservation is now the committed quota hit. Do not record a
+          // second timestamp after the append returns.
+          releaseWriteQuota = undefined;
+        }
+        this.respondJson(res, output.result.appended ? 201 : 200, output.result);
+      } finally {
+        // Replays never invoke the hook. If a future store path invokes it but
+        // does not append, or persistence throws after reservation, return the
+        // slot so a failed write cannot exhaust the rolling window.
+        releaseWriteQuota?.();
+      }
+      return;
+    }
+
+    const relayMissionMatch = /^\/engram\/v1\/relay\/missions\/([^/]+)$/.exec(pathname);
+    if (req.method === "GET" && relayMissionMatch) {
+      const missionId = decodeRelayMissionIdSegment(relayMissionMatch[1] ?? "");
+      rejectBlankRelayNamespace(parsed.searchParams.get("namespace"));
+      const namespace = this.resolveNamespace(
+        req,
+        parsed.searchParams.get("namespace") ?? undefined,
+      );
+      const op = getOperation("relay_mission_read");
+      if (!op) {
+        throw new Error("access-boundary: operation not registered: relay_mission_read");
+      }
+      const output = (await op.run(
+        {
+          missionId,
+          namespace,
+          since: parsed.searchParams.get("since") ?? undefined,
+          until: parsed.searchParams.get("until") ?? undefined,
+          limit: parsed.searchParams.get("limit") ?? undefined,
+        },
+        {
+          service: this.service,
+          authenticatedPrincipal: this.resolveRequestPrincipal(req),
+        },
+      )) as { result: unknown };
+      res.setHeader("cache-control", "no-store");
+      this.respondJson(res, 200, output.result);
+      return;
+    }
+
     if (req.method === "POST" && pathname === "/engram/v1/memories") {
       // Migrated through the access boundary (issue #1525): the registry
       // entry owns schema validation, normalization, and service dispatch.
@@ -3711,18 +3839,31 @@ export class EngramAccessHttpServer {
   private ensureWriteRateLimitAvailable(): void {
     const now = Date.now();
     while (
-      this.writeRequestTimestamps.length > 0 &&
-      now - (this.writeRequestTimestamps[0] ?? 0) > this.writeRateLimitWindowMs
+      this.writeRequestSlots.length > 0 &&
+      now - (this.writeRequestSlots[0]?.recordedAt ?? 0) > this.writeRateLimitWindowMs
     ) {
-      this.writeRequestTimestamps.shift();
+      this.writeRequestSlots.shift();
     }
-    if (this.writeRequestTimestamps.length >= this.writeRateLimitMaxRequests) {
+    if (this.writeRequestSlots.length >= this.writeRateLimitMaxRequests) {
       throw new HttpError(429, "write_rate_limited", "write_rate_limited");
     }
   }
 
   private recordWriteRateLimitHit(): void {
-    this.writeRequestTimestamps.push(Date.now());
+    this.writeRequestSlots.push({ recordedAt: Date.now() });
+  }
+
+  private reserveWriteRateLimitSlot(): () => void {
+    this.ensureWriteRateLimitAvailable();
+    const slot = { recordedAt: Date.now() };
+    this.writeRequestSlots.push(slot);
+    let active = true;
+    return () => {
+      if (!active) return;
+      active = false;
+      const index = this.writeRequestSlots.indexOf(slot);
+      if (index >= 0) this.writeRequestSlots.splice(index, 1);
+    };
   }
 
   private shouldCountWriteRateLimit(response: { dryRun?: boolean; idempotencyReplay?: boolean }): boolean {

package/src/access-mcp-cancellation.test.ts

@@ -282,7 +282,7 @@ test("MCP write quota is recorded after commit even when the client disconnects
   });
   const serverHost = server as unknown as {
     mcpServer: EngramMcpServer;
-    writeRequestTimestamps: number[];
+    writeRequestSlots: Array<{ readonly recordedAt: number }>;
   };
   const originalHandleRequest = serverHost.mcpServer.handleRequest.bind(serverHost.mcpServer);
   serverHost.mcpServer.handleRequest = async (request, options) => {
@@ -318,7 +318,7 @@ test("MCP write quota is recorded after commit even when the client disconnects
 
     await waitFor(operationSettled.promise);
     await new Promise<void>((resolve) => setImmediate(resolve));
-    assert.equal(serverHost.writeRequestTimestamps.length, 1);
+    assert.equal(serverHost.writeRequestSlots.length, 1);
     assert.equal(responseStarted, false, "the disconnected client must not receive the committed write response");
   } finally {
     releaseOperation.resolve();

package/src/access-operations.ts

@@ -678,6 +678,8 @@ export const codegraphIngestTracesOperation = defineOperation<
 // Batch-migrated operations (issue #1525): registers all remaining
 // handlers through the boundary as a side effect of importing this module.
 import "./access-operations-batch.js";
+// Remnic Relay mission evidence operations (issue #1966).
+import "./relay/mission-access.js";
 
 export const REGISTERED_OPERATIONS = [
   memoryGetOperation.spec.name,

package/src/access-surface-catalog.ts

@@ -193,6 +193,8 @@ export const HTTP_ROUTES: readonly HttpRouteEntry[] = [
   { method: "POST", pathname: "/engram/v1/lcm/compaction/flush", operation: "lcm_compaction_flush" },
   { method: "POST", pathname: "/engram/v1/lcm/compaction/record", operation: "lcm_compaction_record" },
   { method: "GET", pathname: "/engram/v1/lcm/status", operation: "lcm_status" },
+  { method: "GET", pathname: "/engram/v1/relay/missions/:id", operation: "relay_mission_read" },
+  { method: "POST", pathname: "/engram/v1/relay/missions/:id/events", operation: "relay_mission_append" },
   // Correction Contract (issue #1580) — plan/apply/pending.
   { method: "POST", pathname: "/engram/v1/correction/plan", operation: "memory_correct_plan" },
   { method: "POST", pathname: "/engram/v1/correction/apply", operation: "memory_correct_apply" },

package/src/index.ts

@@ -387,6 +387,59 @@ export {
 } from "./access-http.js";
 export { EngramMcpServer } from "./access-mcp.js";
 
+// Remnic Relay — host-agnostic mission evidence and receipt contract.
+export {
+  RELAY_MISSION_DEFAULT_EVENT_LIMIT,
+  RELAY_MISSION_MAX_EVENT_LIMIT,
+  RELAY_MISSION_MAX_EVENTS,
+  RELAY_MISSION_MAX_FILE_BYTES,
+  RELAY_MISSION_MAX_LINE_BYTES,
+  RELAY_MISSION_SCHEMA_VERSION,
+  RelayEvidenceRefSchema,
+  RelayMissionEventInputSchema,
+  RelayMissionEventSchema,
+  RelayMissionPayloadSchema,
+  RelayMissionReadOptionsSchema,
+  RelayMissionStore,
+  RelayMissionStoreError,
+  compareRelayEvents,
+  reduceRelayMission,
+  relayMissionReceiptDigest,
+  type RelayAgentOutputSnapshot,
+  type RelayAgentSnapshot,
+  type RelayConflictSnapshot,
+  type RelayCorrectionSnapshot,
+  type RelayDecisionSnapshot,
+  type RelayEvidenceRef,
+  type RelayMissionAppendResult,
+  type RelayMissionEvent,
+  type RelayMissionEventInput,
+  type RelayMissionPayload,
+  type RelayMissionReadOptions,
+  type RelayMissionSnapshot,
+  type RelayMissionStatus,
+  type RelayMissionStoreErrorCode,
+  type RelayMissionStoreOptions,
+  type RelayPropagationSnapshot,
+  type RelayRecallSnapshot,
+  type RelayTestSnapshot,
+} from "./relay/mission.js";
+export {
+  RELAY_DEMO_MISSION_ID,
+  RELAY_DEMO_NAMESPACE,
+  createRelayMissionFixture,
+} from "./relay/mission-fixture.js";
+export {
+  appendRelayMissionEvent,
+  readRelayMission,
+  relayMissionAppendOperation,
+  relayMissionReadOperation,
+  type RelayMissionAppendAccessInput,
+  type RelayMissionAppendAccessOutput,
+  type RelayMissionReadAccessInput,
+  type RelayMissionReadAccessOutput,
+} from "./relay/mission-access.js";
+
 // agentAccessHttp.authToken SecretRef resolution (issue #757). Exposed so
 // host-specific bootstrap code (the OpenClaw plugin in `src/index.ts`, the
 // standalone server, the CLI) can resolve a SecretRef to a literal bearer

package/src/orchestration/consolidation-run.ts

@@ -30,7 +30,7 @@ import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { log } from "../logger.js";
 import { applyCommitmentLedgerLifecycle } from "../commitment-ledger.js";
 import { recordDreamsPhaseRun } from "../maintenance/dreams-ledger.js";
-import { clearIndexes, deindexMemory, indexMemoriesBatch, indexesExist } from "../temporal-index.js";
+import { deindexMemoryAsync } from "../temporal-index.js";
 import { isActiveMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
 import {
   resolveConsolidationCapabilities,
@@ -165,7 +165,7 @@ export class ConsolidationRunCoordinator {
             memoryItemMutated = true;
             await this.deps.embeddingFallback.removeFromIndex(item.existingId);
             if (toInvalidate?.path && toInvalidate.frontmatter?.created) {
-              deindexMemory(
+              await deindexMemoryAsync(
                 config.memoryDir,
                 toInvalidate.path,
                 toInvalidate.frontmatter.created,
@@ -216,7 +216,7 @@ export class ConsolidationRunCoordinator {
                 toMergeInvalidate?.path &&
                 toMergeInvalidate.frontmatter?.created
               ) {
-                deindexMemory(
+                await deindexMemoryAsync(
                   config.memoryDir,
                   toMergeInvalidate.path,
                   toMergeInvalidate.frontmatter.created,
@@ -293,7 +293,7 @@ export class ConsolidationRunCoordinator {
       log.info(`cleaned ${deletedCommitments.length} expired commitments`);
       if (resolveIndexingCapabilities(config).queryAwareIndexing) {
         for (const m of deletedCommitments) {
-          deindexMemory(
+          await deindexMemoryAsync(
             config.memoryDir,
             m.path,
             m.frontmatter.created,
@@ -336,7 +336,7 @@ export class ConsolidationRunCoordinator {
       log.info(`cleaned ${deletedTTL.length} TTL-expired memories`);
       if (resolveIndexingCapabilities(config).queryAwareIndexing) {
         for (const m of deletedTTL) {
-          deindexMemory(
+          await deindexMemoryAsync(
             config.memoryDir,
             m.path,
             m.frontmatter.created,

package/src/orchestration/contradiction-linking-coordinator.ts

@@ -27,7 +27,7 @@ import type { StorageManager } from "../index.js";
 import type { ExtractionEngine } from "../extraction.js";
 import { log } from "../logger.js";
 import { resolveIndexingCapabilities } from "../capabilities.js";
-import { deindexMemory } from "../temporal-index.js";
+import { deindexMemoryAsync } from "../temporal-index.js";
 
 /** Result type of {@link ContradictionLinkingCoordinator.checkForContradiction}. */
 export interface ContradictionResult {
@@ -253,7 +253,7 @@ export class ContradictionLinkingCoordinator {
         resolveIndexingCapabilities(config).queryAwareIndexing &&
         contradiction.supersededPath
       ) {
-        deindexMemory(
+        await deindexMemoryAsync(
           config.memoryDir,
           contradiction.supersededPath,
           contradiction.supersededCreated,

package/src/orchestration/lifecycle-policy-coordinator.ts

@@ -34,7 +34,7 @@ import {
   resolveCreationMemoryCapabilities,
 } from "../capabilities.js";
 import { isActiveMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
-import { deindexMemory } from "../temporal-index.js";
+import { deindexMemoryAsync } from "../temporal-index.js";
 import { extractTopics } from "../topics.js";
 import { log } from "../logger.js";
 import path from "node:path";
@@ -345,7 +345,7 @@ export class LifecyclePolicyCoordinator {
           memory.path &&
           memory.frontmatter?.created
         ) {
-          deindexMemory(
+          await deindexMemoryAsync(
             this.config.memoryDir,
             memory.path,
             memory.frontmatter.created,

package/src/orchestration/persistence-index.ts

@@ -23,7 +23,7 @@ import { ContentHashIndex, StorageManager } from "../index.js";
 import { log } from "../logger.js";
 import { isActiveMemoryStatus } from "../memory-lifecycle-ledger-utils.js";
 import { stripCitationForTemplate } from "../source-attribution.js";
-import { clearIndexes, indexMemoriesBatch, indexesExist } from "../temporal-index.js";
+import { clearIndexesAsync, indexMemoriesBatchAsync, indexesExistAsync } from "../temporal-index.js";
 import { normalizeSupersessionKey } from "../temporal-supersession.js";
 import type { MemoryFile, MemoryFrontmatter, PluginConfig } from "../types.js";
 import {
@@ -392,7 +392,7 @@ export class PersistenceIndexCoordinator {
       return;
     // Check for missing indexes BEFORE the early-return so first-time enablement
     // can bootstrap the full corpus even when this extraction turn persisted nothing.
-    const needsFullRebuild = !indexesExist(this.deps.config.memoryDir);
+    const needsFullRebuild = !(await indexesExistAsync(this.deps.config.memoryDir));
     if (!needsFullRebuild && persistedIds.length === 0) return;
     try {
       // Read the corpus once to avoid N separate full-corpus scans.
@@ -449,17 +449,17 @@ export class PersistenceIndexCoordinator {
       if (needsFullRebuild) {
         // Always write empty indexes on full rebuild — even when the active pool
         // is empty (e.g. store contains only archived/superseded entries).
-        // This marks bootstrap completion so indexesExist() returns true and
+        // This marks bootstrap completion so indexesExistAsync() returns true and
         // subsequent extractions skip the full-corpus scan.
-        clearIndexes(this.deps.config.memoryDir);
+        await clearIndexesAsync(this.deps.config.memoryDir);
         if (entries.length > 0) {
-          indexMemoriesBatch(this.deps.config.memoryDir, entries);
+          await indexMemoriesBatchAsync(this.deps.config.memoryDir, entries);
         }
         log.info(
           `temporal-index: bootstrapped from ${entries.length} active memories`,
         );
       } else if (entries.length > 0) {
-        indexMemoriesBatch(this.deps.config.memoryDir, entries);
+        await indexMemoriesBatchAsync(this.deps.config.memoryDir, entries);
       }
     } catch (err) {
       log.debug(`temporal-index update failed (non-fatal): ${err}`);

package/src/orchestration/recall-search-pipeline.ts

@@ -33,7 +33,7 @@ import { RerankCache, rerankLocalOrNoop } from "../rerank.js";
 import type { SearchBackend, SearchDegradation, SearchExecutionOptions, SearchQueryOptions } from "../search/port.js";
 import { SecureStoreLockedError } from "../secure-store/index.js";
 import { isPathInsideStorageRoot } from "../storage-paths.js";
-import { extractTagsFromPrompt, isTemporalQuery, queryByDateRangeAsync, queryByTagsAsync, recencyWindowFromPrompt, resolvePromptTagPrefilterAsync } from "../temporal-index.js";
+import { extractTagsFromPrompt, isTemporalQuery, queryByDateRangeAsync, queryByTagsAsync, readIndexSnapshotAsync, recencyWindowFromPrompt, resolvePromptTagPrefilterAsync } from "../temporal-index.js";
 import { shouldFilterSupersededFromRecall } from "../temporal-supersession.js";
 import { isValidAsOf, isValidityExpiredNow } from "../temporal-validity.js";
 import type { TrustStageResultItem } from "../trust-score-stage.js";
@@ -305,18 +305,26 @@ export class RecallSearchPipelineCoordinator {
     const temporalFromDate = isTemporalQuery(prompt)
       ? recencyWindowFromPrompt(prompt, Date.now())
       : null;
-    const [rawTemporal, tagSignals] = await Promise.all([
-      temporalFromDate
-        ? queryByDateRangeAsync(this.deps.config.memoryDir, temporalFromDate)
-        : Promise.resolve<Set<string> | null>(null),
-      resolvePromptTagPrefilterAsync(this.deps.config.memoryDir, prompt).catch(
-        () => ({
-          matchedTags: extractTagsFromPrompt(prompt),
-          expandedTags: extractTagsFromPrompt(prompt),
-          paths: null,
-        }),
-      ),
-    ]);
+    // Read the temporal + tag prefilter indexes as ONE consistent snapshot
+    // (issue #1911, Codex Medium) so a concurrent async index mutation can't be
+    // observed half-applied (new temporal row, tag membership not yet written),
+    // which would drop the current memory from the tag prefilter.
+    const [rawTemporal, tagSignals] = await readIndexSnapshotAsync(
+      this.deps.config.memoryDir,
+      () =>
+        Promise.all([
+          temporalFromDate
+            ? queryByDateRangeAsync(this.deps.config.memoryDir, temporalFromDate)
+            : Promise.resolve<Set<string> | null>(null),
+          resolvePromptTagPrefilterAsync(this.deps.config.memoryDir, prompt).catch(
+            () => ({
+              matchedTags: extractTagsFromPrompt(prompt),
+              expandedTags: extractTagsFromPrompt(prompt),
+              paths: null,
+            }),
+          ),
+        ]),
+    );
 
     const temporalCandidates = this.deps.scopeQueryAwarePaths(
       rawTemporal,
@@ -1516,14 +1524,21 @@ export class RecallSearchPipelineCoordinator {
       promptTags = extractTagsFromPrompt(prompt);
     }
 
-    const [rawTemporal, rawTags] = await Promise.all([
-      temporalFromDate !== null
-        ? queryByDateRangeAsync(this.deps.config.memoryDir, temporalFromDate)
-        : Promise.resolve<Set<string> | null>(null),
-      promptTags.length > 0
-        ? queryByTagsAsync(this.deps.config.memoryDir, promptTags)
-        : Promise.resolve<Set<string> | null>(null),
-    ]);
+    // Consistent temporal+tag snapshot (issue #1911, Codex Medium): read both
+    // indexes under one op-lock so an in-flight async mutation is never observed
+    // half-applied.
+    const [rawTemporal, rawTags] = await readIndexSnapshotAsync(
+      this.deps.config.memoryDir,
+      () =>
+        Promise.all([
+          temporalFromDate !== null
+            ? queryByDateRangeAsync(this.deps.config.memoryDir, temporalFromDate)
+            : Promise.resolve<Set<string> | null>(null),
+          promptTags.length > 0
+            ? queryByTagsAsync(this.deps.config.memoryDir, promptTags)
+            : Promise.resolve<Set<string> | null>(null),
+        ]),
+    );
 
     const queryIntent =
       resolveConversationContextCapabilities(this.deps.config).intentRouting && prompt

package/src/orchestration/semantic-consolidation-coordinator.ts

@@ -42,7 +42,7 @@ import {
   gatewayTaskChainOptions,
 } from "../fallback-llm.js";
 import { resolveIndexingCapabilities, resolveConsolidationCapabilities } from "../capabilities.js";
-import { deindexMemory } from "../temporal-index.js";
+import { deindexMemoryAsync } from "../temporal-index.js";
 import { runPeerProfileReasoner } from "../peers/index.js";
 import type { StorageManager } from "../index.js";
 import type { LocalLlmClient } from "../local-llm.js";
@@ -342,7 +342,7 @@ export class SemanticConsolidationCoordinator {
                 m.path &&
                 m.frontmatter?.created
               ) {
-                deindexMemory(
+                await deindexMemoryAsync(
                   targetStorage.dir,
                   m.path,
                   m.frontmatter.created,

package/src/orchestrator.ts

@@ -326,10 +326,6 @@ import {
 } from "./lifecycle.js";
 import { isActiveMemoryStatus } from "./memory-lifecycle-ledger-utils.js";
 import {
-  indexMemoriesBatch,
-  clearIndexes,
-  indexesExist,
-  deindexMemory,
   queryByDateRangeAsync,
   queryByTagsAsync,
   isTemporalQuery,