@remnic/core 9.6.28 → 9.6.30

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.6.28",
+  "version": "9.6.30",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3000,7 +3000,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.6.28"
+    "@remnic/coding-graph": "^9.6.30"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/src/access-lcm-surface.ts

@@ -11,6 +11,7 @@
 import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { combineNamespaces, lcmSessionKeyForNamespace, resolveCodingNamespaceOverlay } from "./coding/coding-namespace.js";
 import { log } from "./logger.js";
+import { lcmEvidenceIdentity } from "./lcm/evidence-identity.js";
 import { canWriteNamespace, defaultNamespaceForPrincipal, recallNamespacesForPrincipal } from "./namespaces/principal.js";
 import type { Orchestrator } from "./orchestrator.js";
 import {
@@ -207,8 +208,8 @@ export class AccessLcmSurface {
         lcmEnabled: true,
       };
     }
-    // Query each LCM read key in order, merging + deduping rows (by
-    // sessionId+turnIndex) and preserving first-seen order, capped at `limit`.
+    // Query each LCM read key in order, merging + deduping by stable archive-row
+    // identity and preserving first-seen order, capped at `limit`.
     // Use allSettled so one corrupt/failed namespace key cannot discard sibling
     // results from other authorized profile namespaces.
     const seenRows = new Set<string>();
@@ -216,7 +217,14 @@ export class AccessLcmSurface {
     const lcmSearches: Array<{
       key: string | undefined;
       prefix: string | undefined;
-      promise: Promise<Array<{ session_id: string; content: string; turn_index: number }>>;
+      promise: Promise<
+        Array<{
+          id?: number;
+          session_id: string;
+          content: string;
+          turn_index: number;
+        }>
+      >;
     }> = [];
     for (const lcmSessionKey of lcmSessionKeyIds) {
       for (const lcmSessionPrefix of lcmSessionPrefixes) {
@@ -228,7 +236,14 @@ export class AccessLcmSurface {
             limit,
             lcmSessionKey,
             lcmSessionPrefix,
-          ) as Promise<Array<{ session_id: string; content: string; turn_index: number }>>,
+          ) as Promise<
+            Array<{
+              id?: number;
+              session_id: string;
+              content: string;
+              turn_index: number;
+            }>
+          >,
         });
       }
     }
@@ -246,7 +261,7 @@ export class AccessLcmSurface {
         continue;
       }
       for (const r of settled.value) {
-        const dedupeKey = `${r.session_id}\0${r.turn_index}`;
+        const dedupeKey = lcmEvidenceIdentity(r, r.session_id).id;
         if (seenRows.has(dedupeKey)) continue;
         seenRows.add(dedupeKey);
         results.push({

package/src/access-recall-surface.ts

@@ -14,9 +14,11 @@
 import { createHash } from "node:crypto";
 import * as nodePath from "node:path";
 import { AccessAuditAdapter, type AccessAuditResult } from "./access-audit.js";
+import { throwIfAborted } from "./abort-error.js";
 import { resolveNamespaceCapabilities } from "./capabilities.js";
 import { resolveCodingNamespaceOverlay } from "./coding/coding-namespace.js";
 import { type BudgetDecision, CrossNamespaceBudget } from "./cross-namespace-budget.js";
+import { lcmEvidenceIdentity } from "./lcm/evidence-identity.js";
 import { normalizeProjectionTags } from "./memory-projection-format.js";
 import { namespaceIdentityFromToken } from "./namespaces/identity.js";
 import { canReadNamespace, defaultNamespaceForPrincipal, recallNamespacesForPrincipal, resolvePrincipal } from "./namespaces/principal.js";
@@ -173,7 +175,6 @@ export interface AccessRecallSurfaceDeps {
     primaryNamespace: string,
     recallNamespaces?: readonly string[],
   ): Promise<{ storage: StorageManager; dir: string } | null>;
-  xrayQueue: Promise<void>;
 }
 
 export class AccessRecallSurface {
@@ -593,7 +594,7 @@ export class AccessRecallSurface {
         if (excerpts.length >= limit) break;
         if (result.status !== "fulfilled") continue;
         for (const r of result.value) {
-          const dedupeKey = `${r.session_id} ${r.turn_index}`;
+          const dedupeKey = lcmEvidenceIdentity(r, r.session_id).id;
           if (seenRows.has(dedupeKey)) continue;
           seenRows.add(dedupeKey);
           excerpts.push({
@@ -1117,6 +1118,8 @@ export class AccessRecallSurface {
      * regular X-ray API/CLI/MCP surfaces keep their existing payload shape.
      */
     includeRecall?: boolean;
+    /** Cancel the capture before it starts and propagate cancellation to recall. */
+    abortSignal?: AbortSignal;
   }): Promise<{
     snapshotFound: boolean;
     snapshot?: RecallXraySnapshot;
@@ -1195,21 +1198,9 @@ export class AccessRecallSurface {
     const mode = this.deps.normalizeRecallMode(request.mode);
     const disclosure = request.disclosure ?? DEFAULT_RECALL_DISCLOSURE;
 
-    // Serialize x-ray invocations behind a per-service mutex so the
-    // per-process `getLastXraySnapshot()` slot cannot be clobbered by
-    // a concurrent capturing call before this caller reads it back.
-    // Budget and principal are now threaded through
-    // `RecallInvocationOptions`, so global config mutation is gone
-    // (CLAUDE.md rule 47: no shared mutable state across async
-    // boundaries).  The mutex stays only for the snapshot-slot
-    // ordering guarantee.
-    const previousQueue = this.deps.xrayQueue;
-    let release: () => void = () => {};
-    this.deps.xrayQueue = new Promise<void>((resolve) => {
-      release = resolve;
-    });
-    await previousQueue;
-    const recallStartedAt = Date.now();
+    // Reset when the orchestrator-owned snapshot lock is actually acquired so
+    // queue wait is not misreported as recall latency.
+    let recallStartedAt = Date.now();
 
     const recallSessionKey = request.sessionKey?.trim() || undefined;
     let xrayResponse: {
@@ -1217,37 +1208,46 @@ export class AccessRecallSurface {
       snapshot?: RecallXraySnapshot;
     } = { snapshotFound: false };
 
-    try {
-      // Clear any prior snapshot so a capture failure surfaces as
-      // `{snapshotFound: false}` rather than returning stale data
-      // from an earlier call on the same orchestrator.
-      this.deps.orchestrator.clearLastXraySnapshot();
-      await this.deps.orchestrator.recall(query, recallSessionKey, {
-        xrayCapture: true,
-        ...(requestedNamespace ? { namespace: requestedNamespace } : {}),
-        ...(budgetOverride !== undefined
-          ? { budgetCharsOverride: budgetOverride }
-          : {}),
-        ...(mode !== undefined ? { mode } : {}),
-        // When the caller supplies an authenticated principal, forward
-        // it via the dedicated override channel so orchestrator-side
-        // ACL decisions use the SAME principal the access-surface
-        // pre-check above authorized.  Threading an
-        // `authenticatedPrincipal` through `sessionKey` would be wrong:
-        // `resolvePrincipal(sessionKey)` only maps configured raw
-        // session keys and otherwise collapses to `"default"`, which
-        // in namespace-enabled deployments produces false denials /
-        // wrong-scope serving despite the pre-check passing
-        // (CLAUDE.md rule 42).
-        ...(authenticatedPrincipal
-          ? { principalOverride: authenticatedPrincipal }
-          : {}),
-        ...(request.currentContextScopes !== undefined
-          ? { currentContextScopes: request.currentContextScopes }
-          : {}),
-      });
-
-      const rawSnapshot = this.deps.orchestrator.getLastXraySnapshot();
+    {
+      // Capture through the orchestrator-owned critical section so every
+      // consumer of its mutable snapshot slot shares the same queue. The
+      // returned clone remains owned by this call after the lock is released.
+      const {
+        snapshot: rawSnapshot,
+        recallStartedAt: capturedRecallStartedAt,
+      } = await this.deps.orchestrator.recallWithXrayCapture(
+        query,
+        recallSessionKey,
+        {
+          ...(requestedNamespace ? { namespace: requestedNamespace } : {}),
+          ...(budgetOverride !== undefined
+            ? { budgetCharsOverride: budgetOverride }
+            : {}),
+          ...(mode !== undefined ? { mode } : {}),
+          // When the caller supplies an authenticated principal, forward
+          // it via the dedicated override channel so orchestrator-side
+          // ACL decisions use the SAME principal the access-surface
+          // pre-check above authorized.  Threading an
+          // `authenticatedPrincipal` through `sessionKey` would be wrong:
+          // `resolvePrincipal(sessionKey)` only maps configured raw
+          // session keys and otherwise collapses to `"default"`, which
+          // in namespace-enabled deployments produces false denials /
+          // wrong-scope serving despite the pre-check passing
+          // (CLAUDE.md rule 42).
+          ...(authenticatedPrincipal
+            ? { principalOverride: authenticatedPrincipal }
+            : {}),
+          ...(request.currentContextScopes !== undefined
+            ? { currentContextScopes: request.currentContextScopes }
+            : {}),
+          ...(request.abortSignal ? { abortSignal: request.abortSignal } : {}),
+        },
+      );
+      recallStartedAt = capturedRecallStartedAt;
+      // Cancellation covers queueing + recall/capture. Post-capture shaping is
+      // intentionally not wired for mid-I/O abort in this change, but do not
+      // begin that work after the caller has already canceled.
+      throwIfAborted(request.abortSignal, "recall X-ray aborted before postprocessing");
       // Re-check namespace after capture: the recall may have served
       // from a different namespace than the caller requested.  Drop
       // the snapshot rather than leak cross-tenant data (CLAUDE.md
@@ -1483,8 +1483,6 @@ export class AccessRecallSurface {
           };
         }
       }
-    } finally {
-      release();
     }
 
     if (

package/src/access-service.ts

@@ -2917,6 +2917,8 @@ export class EngramAccessService {
      * regular X-ray API/CLI/MCP surfaces keep their existing payload shape.
      */
     includeRecall?: boolean;
+    /** Cancel the capture before it starts and propagate cancellation to recall. */
+    abortSignal?: AbortSignal;
   }): Promise<{
     snapshotFound: boolean;
     snapshot?: RecallXraySnapshot;
@@ -2926,12 +2928,6 @@ export class EngramAccessService {
       request,
     );
   }
-  // Sequence lock for `recallXray` — see comment inside the method.
-  // Lives on the instance so every x-ray call on the same service
-  // shares it, and so separate services in the same process (e.g.
-  // per-tenant) do not block each other.
-  private xrayQueue: Promise<void> = Promise.resolve();
-
   async memoryStore(
     request: EngramAccessMemoryStoreRequest,
     hooks?: { enforceWriteQuota?: () => void | Promise<void> },
@@ -5906,4 +5902,3 @@ export class EngramAccessService {
     );
   }
 }
-

package/src/cli.ts

@@ -5756,16 +5756,10 @@ export function registerCli(
             args[0],
             (args[1] ?? {}) as Record<string, unknown>,
           );
-          // Route the xray capture through `EngramAccessService` so
-          // the CLI shares the same `xrayQueue` mutex that the HTTP
-          // and MCP surfaces use — otherwise the
-          // `clearLastXraySnapshot() → recall() → getLastXraySnapshot()`
-          // sequence races with concurrent callers (e.g., a gateway
-          // agent hitting the same orchestrator) and could swap in
-          // their snapshot mid-flight, or our capture could overwrite
-          // theirs (cursor Medium + codex P1 review on #597).  The
-          // service enforces CLAUDE.md rules 40 (serialized state) and
-          // 47 (no shared mutable state across async boundaries).
+          // Delegate through `EngramAccessService` to the orchestrator's atomic
+          // capture API, so CLI, HTTP, and MCP callers sharing an orchestrator
+          // also share one X-ray ordering domain and receive the snapshot owned
+          // by their invocation.
           const xrayService = new EngramAccessService(orchestrator);
           const response = await xrayService.recallXray({
             query: parsed.query,

package/src/event-order-recall.ts

@@ -1,5 +1,6 @@
 import { buildEvidencePack, type EvidencePackItem } from "./evidence-pack.js";
 import type { ExplicitCueRecallEngine } from "./explicit-cue-recall.js";
+import { lcmEvidenceIdentity } from "./lcm/evidence-identity.js";
 
 import {
   unifiedDedupeAndRank,
@@ -205,13 +206,14 @@ async function collectEventOrderItems(
       windowTokens,
     );
     for (const message of messages) {
-      const id = `${options.sessionId}:${message.turn_index}`;
+      const identity = lcmEvidenceIdentity(message, options.sessionId);
+      const id = identity.id;
       if (seen.has(id)) continue;
       if (!isEventOrderCandidate(message.content, message.role, options.query)) continue;
       seen.add(id);
       items.push({
-        id,
-        sessionId: options.sessionId,
+        ...identity,
+        sessionId: message.session_id ?? options.sessionId,
         turnIndex: message.turn_index,
         role: message.role,
         content: appendChronologicalCues(message.content, options.query),

package/src/evidence-pack.ts

@@ -1,5 +1,7 @@
 export interface EvidencePackItem {
   id?: string;
+  /** Stable SQLite row lineage for diagnostics; intentionally not rendered. */
+  archiveRowId?: number;
   sessionId?: string;
   turnIndex?: number;
   role?: string;

package/src/explicit-cue-recall.ts

@@ -4,6 +4,10 @@ import {
   resolveLcmReadSessionIds,
 } from "./lcm-fallback-read.js";
 import { unifiedDedupeAndRank } from "./recall-pipeline-stages.js";
+import {
+  lcmArchiveRowId,
+  lcmEvidenceIdentity,
+} from "./lcm/evidence-identity.js";
 
 export interface ExplicitCueRecallEngine {
   expandContext(
@@ -11,7 +15,15 @@ export interface ExplicitCueRecallEngine {
     fromTurn: number,
     toTurn: number,
     maxTokens: number,
-  ): Promise<Array<{ turn_index: number; role: string; content: string }>>;
+  ): Promise<
+    Array<{
+      id?: number;
+      session_id?: string;
+      turn_index: number;
+      role: string;
+      content: string;
+    }>
+  >;
   getStats?(sessionId?: string): Promise<{
     totalMessages: number;
     maxTurnIndex?: number;
@@ -22,6 +34,7 @@ export interface ExplicitCueRecallEngine {
     sessionId?: string,
   ): Promise<
     Array<{
+      id?: number;
       turn_index: number;
       role: string;
       content: string;
@@ -62,6 +75,16 @@ export type ExplicitTurnReference = {
   includeDirectTurn: boolean;
 };
 
+interface ExplicitCueEvidenceItem {
+  id: string;
+  archiveRowId?: number;
+  sessionId: string;
+  turnIndex: number;
+  role: string;
+  content: string;
+  score?: number;
+}
+
 const DEFAULT_MAX_CHARS = 2_400;
 const DEFAULT_MAX_ITEM_CHARS = 1_200;
 const DEFAULT_MAX_REFERENCES = 24;
@@ -326,23 +349,17 @@ export async function buildExplicitCueRecallSection(
     return "";
   }
 
-  const evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
-    role: string;
-    content: string;
-    score?: number;
-  }> = [];
+  const evidenceItems: ExplicitCueEvidenceItem[] = [];
   const seenTurns = new Set<string>();
 
   // #1505 codex P2: gather cue evidence across the ordered LCM read key set
   // (primary overlay → project/root fallbacks) into ONE shared accumulator
   // (`evidenceItems` / `seenTurns`), so a branch-scoped session's project/root
   // fallback cues are RECOVERED instead of being skipped by the old
-  // first-non-empty short-circuit. `seenTurns` dedupes across keys by
-  // `session_id`+`turn_index`; the budget is applied exactly once in the
-  // `buildEvidencePack` call below. `gatherAcrossReadSessions` isolates a
+  // first-non-empty short-circuit. `seenTurns` is the historical local name;
+  // its keys use archive-row identity when available and fall back to
+  // `session_id`+`turn_index` for legacy engines. The budget is applied exactly
+  // once in the `buildEvidencePack` call below. `gatherAcrossReadSessions` isolates a
   // per-key read failure (a corrupt/locked fallback index must not discard the
   // other keys' cues); single-key recall runs each collector directly, so a
   // failure propagates exactly as before.
@@ -510,13 +527,7 @@ async function collectTurnReferenceEvidence(options: {
   sessionId?: string;
   query: string;
   maxReferences: number;
-  evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
-    role: string;
-    content: string;
-  }>;
+  evidenceItems: ExplicitCueEvidenceItem[];
   seenTurns: Set<string>;
 }): Promise<void> {
   if (!options.sessionId) {
@@ -575,13 +586,7 @@ async function collectFocusedTranscriptCueEvidence(options: {
   engine: ExplicitCueRecallEngine;
   sessionId?: string;
   query: string;
-  evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
-    role: string;
-    content: string;
-  }>;
+  evidenceItems: ExplicitCueEvidenceItem[];
   seenTurns: Set<string>;
 }): Promise<void> {
   if (!options.sessionId || !options.engine.getStats) {
@@ -611,8 +616,8 @@ async function collectFocusedTranscriptCueEvidence(options: {
         continue;
       }
       appendEvidenceItem(options.evidenceItems, options.seenTurns, {
-        id: `${options.sessionId}:${message.turn_index}`,
-        sessionId: options.sessionId,
+        ...lcmEvidenceIdentity(message, options.sessionId),
+        sessionId: message.session_id ?? options.sessionId,
         turnIndex: message.turn_index,
         role: message.role,
         content: message.content,
@@ -772,13 +777,7 @@ async function collectContentLabelReferenceEvidence(options: {
   sessionId?: string;
   query: string;
   references: ExplicitTurnReference[];
-  evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
-    role: string;
-    content: string;
-  }>;
+  evidenceItems: ExplicitCueEvidenceItem[];
   seenTurns: Set<string>;
 }): Promise<Set<number>> {
   const resolved = new Set<number>();
@@ -818,7 +817,7 @@ async function collectContentLabelReferenceEvidence(options: {
       }
       if (expanded.length === 0) {
         appendEvidenceItem(options.evidenceItems, options.seenTurns, {
-          id: `${hit.session_id}:${hit.turn_index}`,
+          ...lcmEvidenceIdentity(hit, hit.session_id),
           sessionId: hit.session_id,
           turnIndex: hit.turn_index,
           role: hit.role,
@@ -845,6 +844,7 @@ async function searchReferenceContentLabels(
   sessionId?: string,
 ): Promise<
   Array<{
+    id?: number;
     turn_index: number;
     role: string;
     content: string;
@@ -855,6 +855,7 @@ async function searchReferenceContentLabels(
   const hits = new Map<
     string,
     {
+      id?: number;
       turn_index: number;
       role: string;
       content: string;
@@ -878,7 +879,8 @@ async function searchReferenceContentLabels(
         ) {
           continue;
         }
-        hits.set(`${result.session_id}:${result.turn_index}:${labelKind}`, {
+        hits.set(`${lcmEvidenceIdentity(result, result.session_id).id}:${labelKind}`, {
+          ...(typeof result.id === "number" ? { id: result.id } : {}),
           turn_index: result.turn_index,
           role: result.role,
           content: result.content,
@@ -1054,14 +1056,7 @@ async function collectLexicalCueEvidence(options: {
   includeBenchmarkAnchorCues?: boolean;
   includeContentLexicalCues?: boolean;
   includeStructuredPlanCues?: boolean;
-  evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
-    role: string;
-    content: string;
-    score?: number;
-  }>;
+  evidenceItems: ExplicitCueEvidenceItem[];
   seenTurns: Set<string>;
 }): Promise<void> {
   const cues = prioritizeLexicalCueSearchCues(
@@ -1096,7 +1091,7 @@ async function collectLexicalCueEvidence(options: {
       );
       if (expanded.length === 0) {
         appendEvidenceItem(options.evidenceItems, options.seenTurns, {
-          id: `${result.session_id}:${result.turn_index}`,
+          ...lcmEvidenceIdentity(result, result.session_id),
           sessionId: result.session_id,
           turnIndex: result.turn_index,
           role: result.role,
@@ -1107,7 +1102,7 @@ async function collectLexicalCueEvidence(options: {
       }
       if (exactHitFirst) {
         appendEvidenceItem(options.evidenceItems, options.seenTurns, {
-          id: `${result.session_id}:${result.turn_index}`,
+          ...lcmEvidenceIdentity(result, result.session_id),
           sessionId: result.session_id,
           turnIndex: result.turn_index,
           role: result.role,
@@ -1131,6 +1126,8 @@ interface LabeledTrajectoryStep {
   observation?: string;
   actionTurnIndex?: number;
   observationTurnIndex?: number;
+  actionArchiveRowId?: number;
+  observationArchiveRowId?: number;
 }
 
 interface TrajectoryBounds {
@@ -1187,7 +1184,12 @@ function hasTrajectoryAnalysisIntent(query: string): boolean {
 }
 
 function parseLabeledTrajectory(
-  messages: Array<{ turn_index: number; role: string; content: string }>,
+  messages: Array<{
+    id?: number;
+    turn_index: number;
+    role: string;
+    content: string;
+  }>,
 ): LabeledTrajectoryStep[] {
   const byStep = new Map<number, LabeledTrajectoryStep>();
 
@@ -1197,6 +1199,8 @@ function parseLabeledTrajectory(
       const step = getOrCreateTrajectoryStep(byStep, action.step);
       step.action = action.value;
       step.actionTurnIndex = message.turn_index;
+      const archiveRowId = lcmArchiveRowId(message);
+      if (archiveRowId !== undefined) step.actionArchiveRowId = archiveRowId;
       continue;
     }
 
@@ -1205,6 +1209,10 @@ function parseLabeledTrajectory(
       const step = getOrCreateTrajectoryStep(byStep, observation.step);
       step.observation = observation.value;
       step.observationTurnIndex = message.turn_index;
+      const archiveRowId = lcmArchiveRowId(message);
+      if (archiveRowId !== undefined) {
+        step.observationArchiveRowId = archiveRowId;
+      }
     }
   }
 
@@ -4538,21 +4546,21 @@ function normalizeTrajectoryQuery(value: string): string {
 }
 
 function appendExpandedEvidence(
-  evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
+  evidenceItems: ExplicitCueEvidenceItem[],
+  seenTurns: Set<string>,
+  sessionId: string,
+  expanded: Array<{
+    id?: number;
+    session_id?: string;
+    turn_index: number;
     role: string;
     content: string;
   }>,
-  seenTurns: Set<string>,
-  sessionId: string,
-  expanded: Array<{ turn_index: number; role: string; content: string }>,
 ): void {
   for (const message of expanded) {
     appendEvidenceItem(evidenceItems, seenTurns, {
-      id: `${sessionId}:${message.turn_index}`,
-      sessionId,
+      ...lcmEvidenceIdentity(message, sessionId),
+      sessionId: message.session_id ?? sessionId,
       turnIndex: message.turn_index,
       role: message.role,
       content: message.content,
@@ -4689,14 +4697,7 @@ async function collectNamedMeetingFactEvidence(options: {
   sessionId?: string;
   query: string;
   maxReferences: number;
-  evidenceItems: Array<{
-    id: string;
-    sessionId: string;
-    turnIndex: number;
-    role: string;
-    content: string;
-    score?: number;
-  }>;
+  evidenceItems: ExplicitCueEvidenceItem[];
   seenTurns: Set<string>;
 }): Promise<void> {
   const cues = collectMeetingFactCues(options.query)
@@ -4712,7 +4713,7 @@ async function collectNamedMeetingFactEvidence(options: {
     for (const result of results) {
       if (!isNamedMeetingFactEvidence(result.content, options.query)) continue;
       appendEvidenceItem(options.evidenceItems, options.seenTurns, {
-        id: `${result.session_id}:${result.turn_index}`,
+        ...lcmEvidenceIdentity(result, result.session_id),
         sessionId: result.session_id,
         turnIndex: result.turn_index,
         role: result.role,