@elizaos/plugin-trajectory-logger 2.0.0-alpha.6 → 2.0.0-alpha.8

package/dist/node/index.node.js

@@ -10,7 +10,7 @@ var __export = (target, all) => {
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 
-// ../../../../node_modules/drizzle-orm/entity.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/entity.js
 function is(value, type) {
   if (!value || typeof value !== "object") {
     return false;
@@ -38,7 +38,7 @@ var init_entity = __esm(() => {
   hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
 });
 
-// ../../../../node_modules/drizzle-orm/column.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/column.js
 var Column;
 var init_column = __esm(() => {
   init_entity();
@@ -92,7 +92,7 @@ var init_column = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/column-builder.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/column-builder.js
 var ColumnBuilder;
 var init_column_builder = __esm(() => {
   init_entity();
@@ -152,19 +152,19 @@ var init_column_builder = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/table.utils.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/table.utils.js
 var TableName;
 var init_table_utils = __esm(() => {
   TableName = Symbol.for("drizzle:Name");
 });
 
-// ../../../../node_modules/drizzle-orm/tracing-utils.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/tracing-utils.js
 function iife(fn, ...args) {
   return fn(...args);
 }
 var init_tracing_utils = () => {};
 
-// ../../../../node_modules/drizzle-orm/pg-core/unique-constraint.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/pg-core/unique-constraint.js
 function uniqueKeyName(table, columns) {
   return `${table[TableName]}_${columns.join("_")}_unique`;
 }
@@ -172,7 +172,7 @@ var init_unique_constraint = __esm(() => {
   init_table_utils();
 });
 
-// ../../../../node_modules/drizzle-orm/pg-core/columns/common.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/pg-core/columns/common.js
 var PgColumn, ExtraConfigColumn;
 var init_common = __esm(() => {
   init_column();
@@ -226,7 +226,7 @@ var init_common = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/pg-core/columns/enum.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/pg-core/columns/enum.js
 function isPgEnum(obj) {
   return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
 }
@@ -261,7 +261,7 @@ var init_enum = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/subquery.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/subquery.js
 var Subquery, WithSubquery;
 var init_subquery = __esm(() => {
   init_entity();
@@ -283,11 +283,11 @@ var init_subquery = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/version.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/version.js
 var version = "0.45.1";
 var init_version = () => {};
 
-// ../../../../node_modules/drizzle-orm/tracing.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/tracing.js
 var otel, rawTracer, tracer;
 var init_tracing = __esm(() => {
   init_tracing_utils();
@@ -317,13 +317,13 @@ var init_tracing = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/view-common.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/view-common.js
 var ViewBaseConfig;
 var init_view_common = __esm(() => {
   ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
 });
 
-// ../../../../node_modules/drizzle-orm/table.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/table.js
 function isTable(table) {
   return typeof table === "object" && table !== null && IsDrizzleTable in table;
 }
@@ -374,7 +374,7 @@ var init_table = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/sql/sql.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/sql.js
 function isSQLWrapper(value) {
   return value !== null && value !== undefined && typeof value.getSQL === "function";
 }
@@ -776,7 +776,7 @@ var init_sql = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/alias.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/alias.js
 function aliasedTable(table, tableAlias) {
   return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
 }
@@ -877,7 +877,7 @@ var init_alias = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/errors.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/errors.js
 var DrizzleError, DrizzleQueryError, TransactionRollbackError;
 var init_errors = __esm(() => {
   init_entity();
@@ -909,7 +909,7 @@ params: ${params}`);
   };
 });
 
-// ../../../../node_modules/drizzle-orm/logger.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/logger.js
 var ConsoleLogWriter, DefaultLogger, NoopLogger;
 var init_logger = __esm(() => {
   init_entity();
@@ -943,7 +943,7 @@ var init_logger = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/query-promise.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/query-promise.js
 var QueryPromise;
 var init_query_promise = __esm(() => {
   init_entity();
@@ -968,7 +968,7 @@ var init_query_promise = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/utils.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/utils.js
 function mapResultRow(columns, row, joinsNotNullableMap) {
   const nullifyMap = {};
   const result = columns.reduce((result2, { path, field }, columnIndex) => {
@@ -1134,7 +1134,7 @@ var init_utils = __esm(() => {
   textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
 });
 
-// ../../../../node_modules/drizzle-orm/pg-core/table.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/pg-core/table.js
 var InlineForeignKeys, EnableRLS, PgTable;
 var init_table2 = __esm(() => {
   init_entity();
@@ -1154,7 +1154,7 @@ var init_table2 = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/pg-core/primary-keys.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/pg-core/primary-keys.js
 var PrimaryKeyBuilder, PrimaryKey;
 var init_primary_keys = __esm(() => {
   init_entity();
@@ -1186,7 +1186,7 @@ var init_primary_keys = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/sql/expressions/conditions.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/expressions/conditions.js
 function bindIfParam(value, column) {
   if (isDriverValueEncoder(column) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
     return new Param(value, column);
@@ -1322,7 +1322,7 @@ var init_conditions = __esm(() => {
   init_sql();
 });
 
-// ../../../../node_modules/drizzle-orm/sql/expressions/select.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/expressions/select.js
 function asc(column) {
   return sql`${column} asc`;
 }
@@ -1333,13 +1333,13 @@ var init_select = __esm(() => {
   init_sql();
 });
 
-// ../../../../node_modules/drizzle-orm/sql/expressions/index.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/expressions/index.js
 var init_expressions = __esm(() => {
   init_conditions();
   init_select();
 });
 
-// ../../../../node_modules/drizzle-orm/relations.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/relations.js
 function getOperators() {
   return {
     and,
@@ -1571,7 +1571,7 @@ var init_relations = __esm(() => {
   };
 });
 
-// ../../../../node_modules/drizzle-orm/sql/functions/aggregate.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/functions/aggregate.js
 function count(expression) {
   return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
 }
@@ -1602,7 +1602,7 @@ var init_aggregate = __esm(() => {
   init_sql();
 });
 
-// ../../../../node_modules/drizzle-orm/sql/functions/vector.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/functions/vector.js
 function toSql(value) {
   return JSON.stringify(value);
 }
@@ -1646,20 +1646,20 @@ var init_vector = __esm(() => {
   init_sql();
 });
 
-// ../../../../node_modules/drizzle-orm/sql/functions/index.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/functions/index.js
 var init_functions = __esm(() => {
   init_aggregate();
   init_vector();
 });
 
-// ../../../../node_modules/drizzle-orm/sql/index.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/sql/index.js
 var init_sql2 = __esm(() => {
   init_expressions();
   init_functions();
   init_sql();
 });
 
-// ../../../../node_modules/drizzle-orm/index.js
+// ../../../node_modules/.bun/drizzle-orm@0.45.1/node_modules/drizzle-orm/index.js
 var exports_drizzle_orm = {};
 __export(exports_drizzle_orm, {
   textDecoder: () => textDecoder,
@@ -1845,7 +1845,7 @@ function sqlLiteral(v) {
   if (typeof v === "boolean")
     return v ? "TRUE" : "FALSE";
   if (typeof v === "object")
-    return `'${JSON.stringify(v).replace(/'/g, "''")}'::jsonb`;
+    return `'${JSON.stringify(v).replace(/'/g, "''")}'`;
   return `'${String(v).replace(/'/g, "''")}'`;
 }
 
@@ -1854,9 +1854,9 @@ class TrajectoryLoggerService extends Service {
   capabilityDescription = "Captures and persists LLM calls, provider accesses, and full trajectories for debugging, analysis, and RL training";
   enabled = true;
   initialized = false;
-  activeTrajectories = new Map;
   activeStepIds = new Map;
   stepToTrajectory = new Map;
+  writeQueues = new Map;
   static async start(runtime) {
     const service = new TrajectoryLoggerService(runtime);
     await service.initialize();
@@ -1897,9 +1897,92 @@ class TrajectoryLoggerService extends Service {
       return;
     }
     await this.ensureTablesExist();
+    await this.backfillTrajectoriesMissingLlmCalls();
     this.initialized = true;
     logger2.info("[trajectory-logger] Trajectory logger service initialized");
   }
+  async getTableColumnNames(tableName) {
+    const names = new Set;
+    try {
+      const result = await this.executeRawSql(`
+        SELECT column_name
+        FROM information_schema.columns
+        WHERE table_name = ${sqlLiteral(tableName)}
+          AND table_schema NOT IN ('pg_catalog', 'information_schema')
+      `);
+      for (const row of result.rows) {
+        const name2 = asString(pickCell(row, "column_name"));
+        if (name2)
+          names.add(name2);
+      }
+      if (names.size > 0)
+        return names;
+    } catch {}
+    const safeTableName = tableName.replace(/[^a-zA-Z0-9_]/g, "");
+    if (!safeTableName)
+      return names;
+    try {
+      const pragma = await this.executeRawSql(`PRAGMA table_info(${safeTableName})`);
+      for (const row of pragma.rows) {
+        const name2 = asString(pickCell(row, "name"));
+        if (name2)
+          names.add(name2);
+      }
+    } catch {}
+    return names;
+  }
+  async ensureTrajectoryColumnsExist() {
+    const columns = await this.getTableColumnNames("trajectories");
+    const requiredColumns = [
+      ["scenario_id", "TEXT"],
+      ["episode_id", "TEXT"],
+      ["batch_id", "TEXT"],
+      ["group_index", "INTEGER"],
+      ["steps_json", "JSONB NOT NULL DEFAULT '[]'"],
+      ["reward_components_json", "JSONB NOT NULL DEFAULT '{}'"],
+      ["metrics_json", "JSONB NOT NULL DEFAULT '{}'"],
+      ["metadata_json", "JSONB NOT NULL DEFAULT '{}'"],
+      ["is_training_data", "BOOLEAN NOT NULL DEFAULT FALSE"],
+      ["is_evaluation", "BOOLEAN NOT NULL DEFAULT FALSE"],
+      ["used_in_training", "BOOLEAN NOT NULL DEFAULT FALSE"],
+      ["judged_at", "TIMESTAMPTZ"]
+    ];
+    for (const [columnName, definition] of requiredColumns) {
+      if (columns.has(columnName))
+        continue;
+      try {
+        await this.executeRawSql(`
+          ALTER TABLE trajectories
+          ADD COLUMN IF NOT EXISTS ${columnName} ${definition}
+        `);
+      } catch (errWithIfExists) {
+        try {
+          await this.executeRawSql(`
+            ALTER TABLE trajectories
+            ADD COLUMN ${columnName} ${definition}
+          `);
+        } catch (errPlain) {
+          const combinedMessage = `${errWithIfExists instanceof Error ? errWithIfExists.message : String(errWithIfExists)} | ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`.toLowerCase();
+          if (combinedMessage.includes("already exists") || combinedMessage.includes("duplicate column") || combinedMessage.includes("duplicate_column")) {
+            continue;
+          }
+          logger2.warn(`[trajectory-logger] Failed to add trajectories.${columnName} (non-fatal): ${errPlain instanceof Error ? errPlain.message : String(errPlain)}`);
+        }
+      }
+    }
+    for (const statement of [
+      `ALTER TABLE trajectories
+       ALTER COLUMN start_time TYPE BIGINT USING start_time::BIGINT`,
+      `ALTER TABLE trajectories
+       ALTER COLUMN end_time TYPE BIGINT USING end_time::BIGINT`,
+      `ALTER TABLE trajectories
+       ALTER COLUMN duration_ms TYPE BIGINT USING duration_ms::BIGINT`
+    ]) {
+      try {
+        await this.executeRawSql(statement);
+      } catch {}
+    }
+  }
   async ensureTablesExist() {
     await this.executeRawSql(`
       CREATE TABLE IF NOT EXISTS trajectories (
@@ -1930,89 +2013,459 @@ class TrajectoryLoggerService extends Service {
         ai_judge_reward REAL,
         ai_judge_reasoning TEXT,
         judged_at TIMESTAMPTZ,
-        created_at TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-        updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.ensureTrajectoryColumnsExist();
+    try {
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_agent_id ON trajectories(agent_id)`);
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_source ON trajectories(source)`);
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_status ON trajectories(status)`);
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_created_at ON trajectories(created_at)`);
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_scenario_id ON trajectories(scenario_id)`);
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_batch_id ON trajectories(batch_id)`);
+      await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_is_training ON trajectories(is_training_data)`);
+    } catch (e) {
+      logger2.warn(`[trajectory-logger] Failed to create indexes (non-fatal): ${e instanceof Error ? e.message : String(e)}`);
+    }
+    await this.executeRawSql(`
+      CREATE TABLE IF NOT EXISTS trajectory_step_index (
+        step_id TEXT PRIMARY KEY,
+        trajectory_id TEXT NOT NULL REFERENCES trajectories(id) ON DELETE CASCADE,
+        step_number INTEGER NOT NULL DEFAULT 0,
+        is_active BOOLEAN NOT NULL DEFAULT FALSE,
+        created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+        updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+      )
+    `);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectory_step_index_trajectory_id ON trajectory_step_index(trajectory_id)`);
+    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectory_step_index_is_active ON trajectory_step_index(is_active)`);
+  }
+  normalizeTrajectoryStatus(value) {
+    switch (value) {
+      case "active":
+      case "completed":
+      case "error":
+      case "timeout":
+      case "terminated":
+        return value;
+      default:
+        return "completed";
+    }
+  }
+  async backfillTrajectoriesMissingLlmCalls() {
+    const maxRows = 2000;
+    let fixed = 0;
+    try {
+      const rows = await this.executeRawSql(`
+        SELECT id, status
+        FROM trajectories
+        WHERE COALESCE(llm_call_count, 0) = 0
+          AND status <> 'active'
+        ORDER BY created_at ASC
+        LIMIT ${maxRows}
+      `);
+      for (const row of rows.rows) {
+        const trajectoryId = asString(pickCell(row, "id"));
+        if (!trajectoryId)
+          continue;
+        const status = this.normalizeTrajectoryStatus(asString(pickCell(row, "status")));
+        await this.withTrajectoryWriteLock(trajectoryId, async () => {
+          const trajectory = await this.getTrajectoryById(trajectoryId);
+          if (!trajectory)
+            return;
+          const inserted = this.ensureAtLeastOneLlmCall(trajectory, "backfill");
+          if (!inserted)
+            return;
+          await this.persistTrajectory(trajectoryId, trajectory, status);
+          fixed += 1;
+        });
+      }
+      if (fixed > 0) {
+        logger2.info(`[trajectory-logger] Backfilled ${fixed} completed trajectories with synthetic LLM calls`);
+      }
+      if (rows.rows.length >= maxRows) {
+        logger2.warn(`[trajectory-logger] Backfill hit safety cap (${maxRows}); remaining older trajectories will be fixed lazily when touched`);
+      }
+    } catch (err) {
+      logger2.warn(`[trajectory-logger] Failed to backfill trajectories missing LLM calls (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  normalizePurpose(value) {
+    switch (value) {
+      case "action":
+      case "reasoning":
+      case "evaluation":
+      case "response":
+      case "other":
+        return value;
+      default:
+        return "other";
+    }
+  }
+  defaultEnvironmentState(timestamp = Date.now()) {
+    return {
+      timestamp,
+      agentBalance: 0,
+      agentPoints: 0,
+      agentPnL: 0,
+      openPositions: 0
+    };
+  }
+  createPendingAction(stepTimestamp) {
+    return {
+      attemptId: "",
+      timestamp: stepTimestamp,
+      actionType: "pending",
+      actionName: "pending",
+      parameters: {},
+      success: false
+    };
+  }
+  createStep(stepId, stepNumber, envState) {
+    const timestamp = envState.timestamp || Date.now();
+    return {
+      stepId,
+      stepNumber,
+      timestamp,
+      environmentState: envState,
+      observation: {},
+      llmCalls: [],
+      providerAccesses: [],
+      action: this.createPendingAction(timestamp),
+      reward: 0,
+      done: false
+    };
+  }
+  ensureAtLeastOneLlmCall(trajectory, source) {
+    if (this.computeTotals(trajectory.steps).llmCallCount > 0) {
+      return false;
+    }
+    const timestamp = Date.now();
+    let step = trajectory.steps[trajectory.steps.length - 1];
+    if (!step) {
+      step = this.createStep(uuidv4(), 0, this.defaultEnvironmentState(timestamp));
+      step.done = true;
+      trajectory.steps.push(step);
+    }
+    if (!Array.isArray(step.llmCalls)) {
+      step.llmCalls = [];
+    }
+    const syntheticCall = {
+      callId: uuidv4(),
+      timestamp,
+      model: "milady/synthetic-trajectory-fallback",
+      systemPrompt: "[synthetic] inserted by trajectory logger because no LLM calls were captured",
+      userPrompt: "[synthetic] this trajectory completed without recorded model activity",
+      response: "[synthetic] placeholder call inserted to enforce minimum llm_call_count=1",
+      temperature: 0,
+      maxTokens: 0,
+      promptTokens: 0,
+      completionTokens: 0,
+      latencyMs: 0,
+      purpose: "other",
+      actionType: "TRAJECTORY_FALLBACK"
+    };
+    step.llmCalls.push(syntheticCall);
+    if (!step.metadata)
+      step.metadata = {};
+    step.metadata.syntheticLlmCall = true;
+    step.metadata.syntheticLlmCallSource = source;
+    trajectory.metadata.syntheticLlmCall = true;
+    trajectory.metadata.syntheticLlmCallSource = source;
+    const existingFallbackCount = trajectory.metrics.syntheticLlmFallbackCount;
+    trajectory.metrics.syntheticLlmFallbackCount = typeof existingFallbackCount === "number" && Number.isFinite(existingFallbackCount) ? existingFallbackCount + 1 : 1;
+    return true;
+  }
+  computeTotals(steps) {
+    let llmCallCount = 0;
+    let providerAccessCount = 0;
+    let totalPromptTokens = 0;
+    let totalCompletionTokens = 0;
+    for (const step of steps) {
+      const llmCalls = Array.isArray(step.llmCalls) ? step.llmCalls : [];
+      const providerAccesses = Array.isArray(step.providerAccesses) ? step.providerAccesses : [];
+      llmCallCount += llmCalls.length;
+      providerAccessCount += providerAccesses.length;
+      for (const call of llmCalls) {
+        totalPromptTokens += call.promptTokens ?? 0;
+        totalCompletionTokens += call.completionTokens ?? 0;
+      }
+    }
+    return {
+      stepCount: steps.length,
+      llmCallCount,
+      providerAccessCount,
+      totalPromptTokens,
+      totalCompletionTokens
+    };
+  }
+  async withTrajectoryWriteLock(trajectoryId, task) {
+    const previous = this.writeQueues.get(trajectoryId) ?? Promise.resolve();
+    const next = previous.catch(() => {}).then(task);
+    this.writeQueues.set(trajectoryId, next);
+    try {
+      await next;
+    } finally {
+      if (this.writeQueues.get(trajectoryId) === next) {
+        this.writeQueues.delete(trajectoryId);
+      }
+    }
+  }
+  async getTrajectoryById(trajectoryId) {
+    const result = await this.executeRawSql(`SELECT * FROM trajectories WHERE id = ${sqlLiteral(trajectoryId)} LIMIT 1`);
+    if (result.rows.length === 0)
+      return null;
+    return this.rowToTrajectory(result.rows[0]);
+  }
+  async getStepIndex(stepId) {
+    const result = await this.executeRawSql(`SELECT trajectory_id, step_number, is_active FROM trajectory_step_index WHERE step_id = ${sqlLiteral(stepId)} LIMIT 1`);
+    const row = result.rows[0];
+    if (!row)
+      return null;
+    const trajectoryId = asString(pickCell(row, "trajectory_id"));
+    if (!trajectoryId)
+      return null;
+    const stepNumber = asNumber(pickCell(row, "step_number")) ?? 0;
+    const isActiveText = asString(pickCell(row, "is_active"));
+    const isActive = isActiveText === "true" || isActiveText === "t" || pickCell(row, "is_active") === true;
+    return { trajectoryId, stepNumber, isActive };
+  }
+  async setStepIndex(stepId, trajectoryId, stepNumber, isActive) {
+    await this.executeRawSql(`
+      INSERT INTO trajectory_step_index (
+        step_id, trajectory_id, step_number, is_active, updated_at
+      ) VALUES (
+        ${sqlLiteral(stepId)},
+        ${sqlLiteral(trajectoryId)},
+        ${stepNumber},
+        ${isActive ? "TRUE" : "FALSE"},
+        CURRENT_TIMESTAMP
       )
+      ON CONFLICT (step_id) DO UPDATE SET
+        trajectory_id = EXCLUDED.trajectory_id,
+        step_number = EXCLUDED.step_number,
+        is_active = EXCLUDED.is_active,
+        updated_at = CURRENT_TIMESTAMP
     `);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_agent_id ON trajectories(agent_id)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_source ON trajectories(source)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_status ON trajectories(status)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_created_at ON trajectories(created_at)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_scenario_id ON trajectories(scenario_id)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_batch_id ON trajectories(batch_id)`);
-    await this.executeRawSql(`CREATE INDEX IF NOT EXISTS idx_trajectories_is_training ON trajectories(is_training_data)`);
+  }
+  async markAllStepsInactive(trajectoryId) {
+    await this.executeRawSql(`
+      UPDATE trajectory_step_index
+      SET is_active = FALSE, updated_at = CURRENT_TIMESTAMP
+      WHERE trajectory_id = ${sqlLiteral(trajectoryId)}
+    `);
+  }
+  async resolveTrajectoryId(stepIdOrTrajectoryId) {
+    const cached = this.stepToTrajectory.get(stepIdOrTrajectoryId);
+    if (cached)
+      return cached;
+    const byStep = await this.getStepIndex(stepIdOrTrajectoryId);
+    if (byStep?.trajectoryId) {
+      this.stepToTrajectory.set(stepIdOrTrajectoryId, byStep.trajectoryId);
+      return byStep.trajectoryId;
+    }
+    const byId = await this.executeRawSql(`SELECT id FROM trajectories WHERE id = ${sqlLiteral(stepIdOrTrajectoryId)} LIMIT 1`);
+    const row = byId.rows[0];
+    const id = row ? asString(pickCell(row, "id")) : null;
+    return id;
+  }
+  async getCurrentStepIdFromDb(trajectoryId) {
+    const result = await this.executeRawSql(`
+      SELECT step_id
+      FROM trajectory_step_index
+      WHERE trajectory_id = ${sqlLiteral(trajectoryId)} AND is_active = TRUE
+      ORDER BY step_number DESC, updated_at DESC
+      LIMIT 1
+    `);
+    const row = result.rows[0];
+    return row ? asString(pickCell(row, "step_id")) : null;
+  }
+  async persistTrajectory(trajectoryId, trajectory, status = "active") {
+    if (status !== "active") {
+      this.ensureAtLeastOneLlmCall(trajectory, "finalize");
+    }
+    const totals = this.computeTotals(trajectory.steps);
+    const isFinalStatus = status !== "active";
+    const persistedEndTime = isFinalStatus ? trajectory.endTime : null;
+    const persistedDuration = isFinalStatus ? trajectory.durationMs : null;
+    const updatedAtIso = new Date().toISOString();
+    try {
+      await this.executeRawSql(`
+        UPDATE trajectories SET
+          status = ${sqlLiteral(status)},
+          end_time = ${sqlLiteral(persistedEndTime)},
+          duration_ms = ${sqlLiteral(persistedDuration)},
+          step_count = ${totals.stepCount},
+          llm_call_count = ${totals.llmCallCount},
+          provider_access_count = ${totals.providerAccessCount},
+          total_prompt_tokens = ${totals.totalPromptTokens},
+          total_completion_tokens = ${totals.totalCompletionTokens},
+          total_reward = ${trajectory.totalReward},
+          steps_json = ${sqlLiteral(trajectory.steps)},
+          reward_components_json = ${sqlLiteral(trajectory.rewardComponents)},
+          metrics_json = ${sqlLiteral(trajectory.metrics)},
+          metadata_json = ${sqlLiteral(trajectory.metadata)},
+          updated_at = ${sqlLiteral(updatedAtIso)}
+        WHERE id = ${sqlLiteral(trajectoryId)}
+      `);
+    } catch (modernErr) {
+      await this.executeRawSql(`
+        UPDATE trajectories SET
+          status = ${sqlLiteral(status)},
+          end_time = ${sqlLiteral(persistedEndTime)},
+          duration_ms = ${sqlLiteral(persistedDuration)},
+          step_count = ${totals.stepCount},
+          llm_call_count = ${totals.llmCallCount},
+          provider_access_count = ${totals.providerAccessCount},
+          total_prompt_tokens = ${totals.totalPromptTokens},
+          total_completion_tokens = ${totals.totalCompletionTokens},
+          total_reward = ${trajectory.totalReward},
+          steps_json = ${sqlLiteral(trajectory.steps)},
+          metadata = ${sqlLiteral(trajectory.metadata)},
+          updated_at = ${sqlLiteral(updatedAtIso)}
+        WHERE id = ${sqlLiteral(trajectoryId)}
+      `).catch((legacyErr) => {
+        logger2.warn({ err: legacyErr, trajectoryId }, `[trajectory-logger] Failed to persist trajectory update after compatibility fallback: ${modernErr instanceof Error ? modernErr.message : String(modernErr)}`);
+        throw legacyErr;
+      });
+    }
+  }
+  async ensureStepExists(trajectory, stepId) {
+    let step = trajectory.steps.find((entry) => entry.stepId === stepId);
+    if (step) {
+      if (!Array.isArray(step.llmCalls))
+        step.llmCalls = [];
+      if (!Array.isArray(step.providerAccesses))
+        step.providerAccesses = [];
+      return step;
+    }
+    const index = await this.getStepIndex(stepId);
+    const stepNumber = index?.stepNumber ?? trajectory.steps.length;
+    step = this.createStep(stepId, stepNumber, this.defaultEnvironmentState());
+    trajectory.steps.push(step);
+    trajectory.steps.sort((a, b) => a.stepNumber - b.stepNumber);
+    return step;
   }
   logLlmCall(params) {
     if (!this.enabled)
       return;
-    const trajectoryId = this.stepToTrajectory.get(params.stepId);
-    if (!trajectoryId) {
-      logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No active trajectory for LLM call");
-      return;
-    }
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory)
-      return;
-    const currentStepId = this.activeStepIds.get(trajectoryId);
-    const step = trajectory.steps.find((s) => s.stepId === currentStepId);
-    if (step) {
-      const llmCall = {
-        callId: uuidv4(),
-        timestamp: Date.now(),
-        model: params.model,
-        systemPrompt: params.systemPrompt,
-        userPrompt: params.userPrompt,
-        response: params.response,
-        temperature: params.temperature,
-        maxTokens: params.maxTokens,
-        purpose: params.purpose,
-        actionType: params.actionType,
-        promptTokens: params.promptTokens,
-        completionTokens: params.completionTokens,
-        latencyMs: params.latencyMs
-      };
-      step.llmCalls.push(llmCall);
-    }
-    this.updateTrajectoryCountsInMemory(trajectoryId, {
-      llmCallCount: 1,
-      promptTokens: params.promptTokens ?? 0,
-      completionTokens: params.completionTokens ?? 0
+    (async () => {
+      const trajectoryId = await this.resolveTrajectoryId(params.stepId);
+      if (!trajectoryId) {
+        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for LLM call");
+        return;
+      }
+      await this.withTrajectoryWriteLock(trajectoryId, async () => {
+        const trajectory = await this.getTrajectoryById(trajectoryId);
+        if (!trajectory)
+          return;
+        const step = await this.ensureStepExists(trajectory, params.stepId);
+        const llmCall = {
+          callId: uuidv4(),
+          timestamp: Date.now(),
+          model: params.model,
+          modelVersion: params.modelVersion,
+          systemPrompt: params.systemPrompt,
+          userPrompt: params.userPrompt,
+          response: params.response,
+          reasoning: params.reasoning,
+          temperature: params.temperature,
+          maxTokens: params.maxTokens,
+          purpose: this.normalizePurpose(params.purpose),
+          actionType: params.actionType,
+          promptTokens: params.promptTokens,
+          completionTokens: params.completionTokens,
+          latencyMs: params.latencyMs
+        };
+        step.llmCalls.push(llmCall);
+        await this.persistTrajectory(trajectoryId, trajectory, "active");
+      });
+    })().catch((err) => {
+      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist LLM call");
     });
   }
-  logProviderAccess(params) {
+  logLLMCall(stepId, details) {
+    this.logLlmCall({
+      stepId,
+      model: details.model,
+      modelVersion: details.modelVersion,
+      systemPrompt: details.systemPrompt,
+      userPrompt: details.userPrompt,
+      response: details.response,
+      reasoning: details.reasoning,
+      temperature: details.temperature,
+      maxTokens: details.maxTokens,
+      purpose: details.purpose,
+      actionType: details.actionType ?? "",
+      latencyMs: details.latencyMs ?? 0,
+      promptTokens: details.promptTokens,
+      completionTokens: details.completionTokens
+    });
+  }
+  logProviderAccess(arg1, arg2) {
     if (!this.enabled)
       return;
-    const trajectoryId = this.stepToTrajectory.get(params.stepId);
-    if (!trajectoryId) {
-      logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No active trajectory for provider access");
-      return;
-    }
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory)
+    const params = typeof arg1 === "string" ? {
+      stepId: arg1,
+      providerName: arg2?.providerName ?? "unknown",
+      data: arg2?.data ?? {},
+      purpose: arg2?.purpose ?? "other",
+      query: arg2?.query
+    } : arg1;
+    (async () => {
+      const trajectoryId = await this.resolveTrajectoryId(params.stepId);
+      if (!trajectoryId) {
+        logger2.debug({ stepId: params.stepId }, "[trajectory-logger] No trajectory mapping for provider access");
+        return;
+      }
+      await this.withTrajectoryWriteLock(trajectoryId, async () => {
+        const trajectory = await this.getTrajectoryById(trajectoryId);
+        if (!trajectory)
+          return;
+        const step = await this.ensureStepExists(trajectory, params.stepId);
+        const access = {
+          providerId: uuidv4(),
+          providerName: params.providerName,
+          timestamp: Date.now(),
+          data: params.data,
+          query: params.query,
+          purpose: params.purpose
+        };
+        step.providerAccesses.push(access);
+        await this.persistTrajectory(trajectoryId, trajectory, "active");
+      });
+    })().catch((err) => {
+      logger2.warn({ err, stepId: params.stepId }, "[trajectory-logger] Failed to persist provider access");
+    });
+  }
+  logProviderAccessByTrajectoryId(trajectoryId, access) {
+    const stepId = this.getCurrentStepId(trajectoryId);
+    if (!stepId) {
+      logger2.debug({ trajectoryId }, "[trajectory-logger] No active step for provider access by trajectory");
       return;
-    const currentStepId = this.activeStepIds.get(trajectoryId);
-    const step = trajectory.steps.find((s) => s.stepId === currentStepId);
-    if (step) {
-      const access = {
-        providerId: uuidv4(),
-        providerName: params.providerName,
-        timestamp: Date.now(),
-        data: params.data,
-        query: params.query,
-        purpose: params.purpose
-      };
-      step.providerAccesses.push(access);
     }
+    this.logProviderAccess(stepId, access);
   }
-  updateTrajectoryCountsInMemory(trajectoryId, counts) {}
-  async startTrajectory(stepId, options) {
+  async startTrajectory(stepIdOrAgentId, options = {}) {
     if (!this.enabled)
-      return stepId;
+      return uuidv4();
+    const legacyStepId = typeof options.agentId === "string" && options.agentId.length > 0 ? stepIdOrAgentId : null;
+    const agentId = (typeof options.agentId === "string" && options.agentId.length > 0 ? options.agentId : stepIdOrAgentId) ?? stepIdOrAgentId;
     const trajectoryId = uuidv4();
     const now = Date.now();
+    const timestampIso = new Date(now).toISOString();
+    const metadata = {
+      ...options.metadata ?? {}
+    };
+    if (options.roomId)
+      metadata.roomId = options.roomId;
+    if (options.entityId)
+      metadata.entityId = options.entityId;
     const trajectory = {
       trajectoryId,
-      agentId: options.agentId,
+      agentId,
       startTime: now,
       endTime: now,
       durationMs: 0,
@@ -2029,28 +2482,19 @@ class TrajectoryLoggerService extends Service {
       },
       metadata: {
         source: options.source ?? "chat",
-        roomId: options.roomId,
-        entityId: options.entityId,
-        ...options.metadata ?? {}
+        ...metadata
       }
     };
-    this.activeTrajectories.set(trajectoryId, trajectory);
-    this.stepToTrajectory.set(stepId, trajectoryId);
-    this.startStep(trajectoryId, {
-      timestamp: now,
-      agentBalance: 0,
-      agentPoints: 0,
-      agentPnL: 0,
-      openPositions: 0
-    });
+    let persistedStart = false;
     try {
       await this.executeRawSql(`
         INSERT INTO trajectories (
           id, agent_id, source, status, start_time, scenario_id, episode_id,
-          batch_id, group_index, metadata_json
+          batch_id, group_index, metadata_json, steps_json, reward_components_json, metrics_json,
+          created_at, updated_at
         ) VALUES (
           ${sqlLiteral(trajectoryId)},
-          ${sqlLiteral(options.agentId)},
+          ${sqlLiteral(agentId)},
           ${sqlLiteral(options.source ?? "chat")},
           'active',
           ${now},
@@ -2058,124 +2502,139 @@ class TrajectoryLoggerService extends Service {
           ${sqlLiteral(options.episodeId ?? null)},
           ${sqlLiteral(options.batchId ?? null)},
           ${options.groupIndex ?? "NULL"},
-          ${sqlLiteral(trajectory.metadata)}
+          ${sqlLiteral(trajectory.metadata)},
+          ${sqlLiteral([])},
+          ${sqlLiteral(trajectory.rewardComponents)},
+          ${sqlLiteral(trajectory.metrics)},
+          ${sqlLiteral(timestampIso)},
+          ${sqlLiteral(timestampIso)}
         )
       `);
+      persistedStart = true;
     } catch (err) {
-      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
+      try {
+        await this.executeRawSql(`
+          INSERT INTO trajectories (
+            id, agent_id, source, status, start_time, steps_json, metadata, created_at, updated_at
+          ) VALUES (
+            ${sqlLiteral(trajectoryId)},
+            ${sqlLiteral(agentId)},
+            ${sqlLiteral(options.source ?? "chat")},
+            'active',
+            ${now},
+            ${sqlLiteral([])},
+            ${sqlLiteral(trajectory.metadata)},
+            ${sqlLiteral(timestampIso)},
+            ${sqlLiteral(timestampIso)}
+          )
+        `);
+        persistedStart = true;
+      } catch (legacyErr) {
+        logger2.warn({ err: legacyErr, trajectoryId }, "[trajectory-logger] Failed to persist trajectory start");
+      }
+    }
+    if (persistedStart && legacyStepId) {
+      this.stepToTrajectory.set(legacyStepId, trajectoryId);
+      try {
+        await this.setStepIndex(legacyStepId, trajectoryId, -1, false);
+      } catch (indexErr) {
+        logger2.warn({ err: indexErr, trajectoryId, stepId: legacyStepId }, "[trajectory-logger] Failed to persist step index for trajectory start");
+      }
     }
     return trajectoryId;
   }
   startStep(trajectoryId, envState) {
+    if (!this.enabled)
+      return uuidv4();
     const stepId = uuidv4();
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      logger2.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
-      return stepId;
-    }
-    const step = {
-      stepId,
-      stepNumber: trajectory.steps.length,
-      timestamp: envState.timestamp || Date.now(),
-      environmentState: envState,
-      observation: {},
-      llmCalls: [],
-      providerAccesses: [],
-      action: {
-        attemptId: "",
-        timestamp: 0,
-        actionType: "pending",
-        actionName: "pending",
-        parameters: {},
-        success: false
-      },
-      reward: 0,
-      done: false
-    };
-    trajectory.steps.push(step);
     this.activeStepIds.set(trajectoryId, stepId);
+    this.stepToTrajectory.set(stepId, trajectoryId);
+    this.withTrajectoryWriteLock(trajectoryId, async () => {
+      const trajectory = await this.getTrajectoryById(trajectoryId);
+      if (!trajectory) {
+        logger2.warn({ trajectoryId }, "[trajectory-logger] Trajectory not found for startStep");
+        return;
+      }
+      const step = this.createStep(stepId, trajectory.steps.length, envState);
+      trajectory.steps.push(step);
+      await this.markAllStepsInactive(trajectoryId);
+      await this.setStepIndex(stepId, trajectoryId, step.stepNumber, true);
+      await this.persistTrajectory(trajectoryId, trajectory, "active");
+    }).catch((err) => {
+      logger2.warn({ err, trajectoryId, stepId }, "[trajectory-logger] Failed to persist startStep");
+    });
     return stepId;
   }
-  completeStep(trajectoryId, action, rewardInfo) {
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory)
+  completeStep(trajectoryId, actionOrStepId, actionOrReward, maybeReward) {
+    if (!this.enabled)
       return;
-    const stepId = this.activeStepIds.get(trajectoryId);
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step)
+    const explicitStepId = typeof actionOrStepId === "string" ? actionOrStepId : null;
+    const action = typeof actionOrStepId === "string" ? actionOrReward : actionOrStepId;
+    const rewardInfo = typeof actionOrStepId === "string" ? maybeReward : actionOrReward;
+    if (!action)
       return;
-    step.action = {
-      attemptId: uuidv4(),
-      timestamp: Date.now(),
-      ...action
-    };
-    if (rewardInfo?.reward !== undefined) {
-      step.reward = rewardInfo.reward;
-      trajectory.totalReward += rewardInfo.reward;
-    }
-    if (rewardInfo?.components) {
-      trajectory.rewardComponents = {
-        ...trajectory.rewardComponents,
-        ...rewardInfo.components
+    this.withTrajectoryWriteLock(trajectoryId, async () => {
+      const trajectory = await this.getTrajectoryById(trajectoryId);
+      if (!trajectory)
+        return;
+      const stepId = explicitStepId ?? this.activeStepIds.get(trajectoryId) ?? await this.getCurrentStepIdFromDb(trajectoryId);
+      if (!stepId)
+        return;
+      const step = await this.ensureStepExists(trajectory, stepId);
+      step.action = {
+        attemptId: uuidv4(),
+        timestamp: Date.now(),
+        ...action
       };
-    }
-    this.activeStepIds.delete(trajectoryId);
+      step.done = true;
+      if (rewardInfo?.reward !== undefined) {
+        step.reward = rewardInfo.reward;
+        trajectory.totalReward += rewardInfo.reward;
+      }
+      if (rewardInfo?.components) {
+        trajectory.rewardComponents = {
+          ...trajectory.rewardComponents,
+          ...rewardInfo.components
+        };
+      }
+      await this.setStepIndex(stepId, trajectoryId, step.stepNumber, false);
+      this.activeStepIds.delete(trajectoryId);
+      await this.persistTrajectory(trajectoryId, trajectory, "active");
+    }).catch((err) => {
+      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to complete step");
+    });
   }
-  async endTrajectory(stepIdOrTrajectoryId, status = "completed") {
+  async endTrajectory(stepIdOrTrajectoryId, status = "completed", finalMetrics) {
     if (!this.enabled)
       return;
-    let trajectoryId = this.stepToTrajectory.get(stepIdOrTrajectoryId);
+    const trajectoryId = await this.resolveTrajectoryId(stepIdOrTrajectoryId);
     if (!trajectoryId) {
-      trajectoryId = stepIdOrTrajectoryId;
-    }
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No active trajectory to end");
+      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
       return;
     }
-    const now = Date.now();
-    trajectory.endTime = now;
-    trajectory.durationMs = now - trajectory.startTime;
-    trajectory.metrics.finalStatus = status;
-    trajectory.metrics.episodeLength = trajectory.steps.length;
-    let totalLlmCalls = 0;
-    let totalProviderAccesses = 0;
-    let totalPromptTokens = 0;
-    let totalCompletionTokens = 0;
-    for (const step of trajectory.steps) {
-      totalLlmCalls += step.llmCalls.length;
-      totalProviderAccesses += step.providerAccesses.length;
-      for (const call of step.llmCalls) {
-        totalPromptTokens += call.promptTokens ?? 0;
-        totalCompletionTokens += call.completionTokens ?? 0;
+    await this.withTrajectoryWriteLock(trajectoryId, async () => {
+      const trajectory = await this.getTrajectoryById(trajectoryId);
+      if (!trajectory) {
+        logger2.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
+        return;
       }
-    }
-    try {
-      await this.executeRawSql(`
-        UPDATE trajectories SET
-          status = ${sqlLiteral(status)},
-          end_time = ${now},
-          duration_ms = ${trajectory.durationMs},
-          step_count = ${trajectory.steps.length},
-          llm_call_count = ${totalLlmCalls},
-          provider_access_count = ${totalProviderAccesses},
-          total_prompt_tokens = ${totalPromptTokens},
-          total_completion_tokens = ${totalCompletionTokens},
-          total_reward = ${trajectory.totalReward},
-          steps_json = ${sqlLiteral(trajectory.steps)},
-          reward_components_json = ${sqlLiteral(trajectory.rewardComponents)},
-          metrics_json = ${sqlLiteral(trajectory.metrics)},
-          metadata_json = ${sqlLiteral(trajectory.metadata)},
-          updated_at = NOW()
-        WHERE id = ${sqlLiteral(trajectoryId)}
-      `);
-    } catch (err) {
-      logger2.warn({ err, trajectoryId }, "[trajectory-logger] Failed to persist trajectory end");
-    }
-    this.activeTrajectories.delete(trajectoryId);
-    this.activeStepIds.delete(trajectoryId);
-    for (const [stepId, trajId] of this.stepToTrajectory.entries()) {
-      if (trajId === trajectoryId) {
+      const now = Date.now();
+      trajectory.endTime = now;
+      trajectory.durationMs = now - trajectory.startTime;
+      trajectory.metrics.finalStatus = status;
+      trajectory.metrics.episodeLength = trajectory.steps.length;
+      if (finalMetrics) {
+        trajectory.metrics = {
+          ...trajectory.metrics,
+          ...finalMetrics
+        };
+      }
+      await this.markAllStepsInactive(trajectoryId);
+      this.activeStepIds.delete(trajectoryId);
+      await this.persistTrajectory(trajectoryId, trajectory, status);
+    });
+    for (const [stepId, mappedTrajectoryId] of this.stepToTrajectory.entries()) {
+      if (mappedTrajectoryId === trajectoryId) {
         this.stepToTrajectory.delete(stepId);
       }
     }
@@ -2231,23 +2690,28 @@ class TrajectoryLoggerService extends Service {
       ORDER BY created_at DESC
       LIMIT ${limit} OFFSET ${offset}
     `);
-    const trajectories = rowsResult.rows.map((row) => ({
-      id: asString(pickCell(row, "id")) ?? "",
-      agentId: asString(pickCell(row, "agent_id")) ?? "",
-      source: asString(pickCell(row, "source")) ?? "chat",
-      status: asString(pickCell(row, "status")) ?? "completed",
-      startTime: asNumber(pickCell(row, "start_time")) ?? 0,
-      endTime: asNumber(pickCell(row, "end_time")),
-      durationMs: asNumber(pickCell(row, "duration_ms")),
-      stepCount: asNumber(pickCell(row, "step_count")) ?? 0,
-      llmCallCount: asNumber(pickCell(row, "llm_call_count")) ?? 0,
-      totalPromptTokens: asNumber(pickCell(row, "total_prompt_tokens")) ?? 0,
-      totalCompletionTokens: asNumber(pickCell(row, "total_completion_tokens")) ?? 0,
-      totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
-      scenarioId: asString(pickCell(row, "scenario_id")),
-      batchId: asString(pickCell(row, "batch_id")),
-      createdAt: asIsoString(pickCell(row, "created_at"))
-    }));
+    const trajectories = rowsResult.rows.map((row) => {
+      const status = asString(pickCell(row, "status")) ?? "completed";
+      const rawLlmCallCount = asNumber(pickCell(row, "llm_call_count")) ?? 0;
+      const llmCallCount = status === "active" ? rawLlmCallCount : Math.max(1, rawLlmCallCount);
+      return {
+        id: asString(pickCell(row, "id")) ?? "",
+        agentId: asString(pickCell(row, "agent_id")) ?? "",
+        source: asString(pickCell(row, "source")) ?? "chat",
+        status,
+        startTime: asNumber(pickCell(row, "start_time")) ?? 0,
+        endTime: asNumber(pickCell(row, "end_time")),
+        durationMs: asNumber(pickCell(row, "duration_ms")),
+        stepCount: asNumber(pickCell(row, "step_count")) ?? 0,
+        llmCallCount,
+        totalPromptTokens: asNumber(pickCell(row, "total_prompt_tokens")) ?? 0,
+        totalCompletionTokens: asNumber(pickCell(row, "total_completion_tokens")) ?? 0,
+        totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
+        scenarioId: asString(pickCell(row, "scenario_id")),
+        batchId: asString(pickCell(row, "batch_id")),
+        createdAt: asIsoString(pickCell(row, "created_at"))
+      };
+    });
     return { trajectories, total, offset, limit };
   }
   async getTrajectoryDetail(trajectoryId) {
@@ -2259,7 +2723,17 @@ class TrajectoryLoggerService extends Service {
     if (result.rows.length === 0)
       return null;
     const row = result.rows[0];
-    return this.rowToTrajectory(row);
+    const trajectory = this.rowToTrajectory(row);
+    const status = this.normalizeTrajectoryStatus(asString(pickCell(row, "status")));
+    if (status !== "active") {
+      const inserted = this.ensureAtLeastOneLlmCall(trajectory, "backfill");
+      if (inserted) {
+        await this.withTrajectoryWriteLock(trajectoryId, async () => {
+          await this.persistTrajectory(trajectoryId, trajectory, status);
+        });
+      }
+    }
+    return trajectory;
   }
   async getStats() {
     const runtime = this.runtime;
@@ -2455,18 +2929,18 @@ class TrajectoryLoggerService extends Service {
       episodeId: asString(pickCell(row, "episode_id")) ?? undefined,
       batchId: asString(pickCell(row, "batch_id")) ?? undefined,
       groupIndex: asNumber(pickCell(row, "group_index")) ?? undefined,
-      steps: parseJson(pickCell(row, "steps_json"), []),
+      steps: parseJson(pickCell(row, "steps_json", "steps"), []),
       totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
-      rewardComponents: parseJson(pickCell(row, "reward_components_json"), { environmentReward: 0 }),
-      metrics: parseJson(pickCell(row, "metrics_json"), {
+      rewardComponents: parseJson(pickCell(row, "reward_components_json", "reward_components"), { environmentReward: 0 }),
+      metrics: parseJson(pickCell(row, "metrics_json", "metrics"), {
         episodeLength: 0,
         finalStatus: "completed"
       }),
-      metadata: parseJson(pickCell(row, "metadata_json"), {})
+      metadata: parseJson(pickCell(row, "metadata_json", "metadata"), {})
     };
   }
   getActiveTrajectory(trajectoryId) {
-    return this.activeTrajectories.get(trajectoryId) || null;
+    return null;
   }
   getCurrentStepId(trajectoryId) {
     return this.activeStepIds.get(trajectoryId) || null;
@@ -2935,8 +3409,8 @@ async function buildGameStateFromDB(_trajectoryId) {
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
 import { logger as logger4 } from "@elizaos/core";
-function startAutonomousTick(trajectoryLogger, context) {
-  const trajectoryId = trajectoryLogger.startTrajectory(context.agentId, {
+async function startAutonomousTick(trajectoryLogger, context) {
+  const trajectoryId = await trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
     episodeId: context.episodeId,
     batchId: context.batchId,
@@ -3134,4 +3608,4 @@ export {
   RewardService
 };
 
-//# debugId=61D715423871574264756E2164756E21
+//# debugId=16B8470362B4AC2364756E2164756E21