@elizaos/plugin-trajectory-logger 2.0.0-alpha.13 → 2.0.0-alpha.20

package/dist/node/index.node.js

@@ -1,193 +1,3068 @@
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// ../../../../node_modules/drizzle-orm/entity.js
+function is(value, type) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  if (value instanceof type) {
+    return true;
+  }
+  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
+    throw new Error(`Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`);
+  }
+  let cls = Object.getPrototypeOf(value).constructor;
+  if (cls) {
+    while (cls) {
+      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
+        return true;
+      }
+      cls = Object.getPrototypeOf(cls);
+    }
+  }
+  return false;
+}
+var entityKind, hasOwnEntityKind;
+var init_entity = __esm(() => {
+  entityKind = Symbol.for("drizzle:entityKind");
+  hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
+});
+
+// ../../../../node_modules/drizzle-orm/column.js
+var Column;
+var init_column = __esm(() => {
+  init_entity();
+  Column = class Column {
+    constructor(table, config) {
+      this.table = table;
+      this.config = config;
+      this.name = config.name;
+      this.keyAsName = config.keyAsName;
+      this.notNull = config.notNull;
+      this.default = config.default;
+      this.defaultFn = config.defaultFn;
+      this.onUpdateFn = config.onUpdateFn;
+      this.hasDefault = config.hasDefault;
+      this.primary = config.primaryKey;
+      this.isUnique = config.isUnique;
+      this.uniqueName = config.uniqueName;
+      this.uniqueType = config.uniqueType;
+      this.dataType = config.dataType;
+      this.columnType = config.columnType;
+      this.generated = config.generated;
+      this.generatedIdentity = config.generatedIdentity;
+    }
+    static [entityKind] = "Column";
+    name;
+    keyAsName;
+    primary;
+    notNull;
+    default;
+    defaultFn;
+    onUpdateFn;
+    hasDefault;
+    isUnique;
+    uniqueName;
+    uniqueType;
+    dataType;
+    columnType;
+    enumValues = undefined;
+    generated = undefined;
+    generatedIdentity = undefined;
+    config;
+    mapFromDriverValue(value) {
+      return value;
+    }
+    mapToDriverValue(value) {
+      return value;
+    }
+    shouldDisableInsert() {
+      return this.config.generated !== undefined && this.config.generated.type !== "byDefault";
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/column-builder.js
+var ColumnBuilder;
+var init_column_builder = __esm(() => {
+  init_entity();
+  ColumnBuilder = class ColumnBuilder {
+    static [entityKind] = "ColumnBuilder";
+    config;
+    constructor(name, dataType, columnType) {
+      this.config = {
+        name,
+        keyAsName: name === "",
+        notNull: false,
+        default: undefined,
+        hasDefault: false,
+        primaryKey: false,
+        isUnique: false,
+        uniqueName: undefined,
+        uniqueType: undefined,
+        dataType,
+        columnType,
+        generated: undefined
+      };
+    }
+    $type() {
+      return this;
+    }
+    notNull() {
+      this.config.notNull = true;
+      return this;
+    }
+    default(value) {
+      this.config.default = value;
+      this.config.hasDefault = true;
+      return this;
+    }
+    $defaultFn(fn) {
+      this.config.defaultFn = fn;
+      this.config.hasDefault = true;
+      return this;
+    }
+    $default = this.$defaultFn;
+    $onUpdateFn(fn) {
+      this.config.onUpdateFn = fn;
+      this.config.hasDefault = true;
+      return this;
+    }
+    $onUpdate = this.$onUpdateFn;
+    primaryKey() {
+      this.config.primaryKey = true;
+      this.config.notNull = true;
+      return this;
+    }
+    setName(name) {
+      if (this.config.name !== "")
+        return;
+      this.config.name = name;
+    }
+  };
+});
+
+// ../../../../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
+function iife(fn, ...args) {
+  return fn(...args);
+}
+var init_tracing_utils = () => {};
+
+// ../../../../node_modules/drizzle-orm/pg-core/unique-constraint.js
+function uniqueKeyName(table, columns) {
+  return `${table[TableName]}_${columns.join("_")}_unique`;
+}
+var init_unique_constraint = __esm(() => {
+  init_table_utils();
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/columns/common.js
+var PgColumn, ExtraConfigColumn;
+var init_common = __esm(() => {
+  init_column();
+  init_entity();
+  init_unique_constraint();
+  PgColumn = class PgColumn extends Column {
+    constructor(table, config) {
+      if (!config.uniqueName) {
+        config.uniqueName = uniqueKeyName(table, [config.name]);
+      }
+      super(table, config);
+      this.table = table;
+    }
+    static [entityKind] = "PgColumn";
+  };
+  ExtraConfigColumn = class ExtraConfigColumn extends PgColumn {
+    static [entityKind] = "ExtraConfigColumn";
+    getSQLType() {
+      return this.getSQLType();
+    }
+    indexConfig = {
+      order: this.config.order ?? "asc",
+      nulls: this.config.nulls ?? "last",
+      opClass: this.config.opClass
+    };
+    defaultConfig = {
+      order: "asc",
+      nulls: "last",
+      opClass: undefined
+    };
+    asc() {
+      this.indexConfig.order = "asc";
+      return this;
+    }
+    desc() {
+      this.indexConfig.order = "desc";
+      return this;
+    }
+    nullsFirst() {
+      this.indexConfig.nulls = "first";
+      return this;
+    }
+    nullsLast() {
+      this.indexConfig.nulls = "last";
+      return this;
+    }
+    op(opClass) {
+      this.indexConfig.opClass = opClass;
+      return this;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/columns/enum.js
+function isPgEnum(obj) {
+  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
+}
+var PgEnumObjectColumn, isPgEnumSym, PgEnumColumn;
+var init_enum = __esm(() => {
+  init_entity();
+  init_common();
+  PgEnumObjectColumn = class PgEnumObjectColumn extends PgColumn {
+    static [entityKind] = "PgEnumObjectColumn";
+    enum;
+    enumValues = this.config.enum.enumValues;
+    constructor(table, config) {
+      super(table, config);
+      this.enum = config.enum;
+    }
+    getSQLType() {
+      return this.enum.enumName;
+    }
+  };
+  isPgEnumSym = Symbol.for("drizzle:isPgEnum");
+  PgEnumColumn = class PgEnumColumn extends PgColumn {
+    static [entityKind] = "PgEnumColumn";
+    enum = this.config.enum;
+    enumValues = this.config.enum.enumValues;
+    constructor(table, config) {
+      super(table, config);
+      this.enum = config.enum;
+    }
+    getSQLType() {
+      return this.enum.enumName;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/subquery.js
+var Subquery, WithSubquery;
+var init_subquery = __esm(() => {
+  init_entity();
+  Subquery = class Subquery {
+    static [entityKind] = "Subquery";
+    constructor(sql, fields, alias, isWith = false, usedTables = []) {
+      this._ = {
+        brand: "Subquery",
+        sql,
+        selectedFields: fields,
+        alias,
+        isWith,
+        usedTables
+      };
+    }
+  };
+  WithSubquery = class WithSubquery extends Subquery {
+    static [entityKind] = "WithSubquery";
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/version.js
+var version = "0.45.1";
+var init_version = () => {};
+
+// ../../../../node_modules/drizzle-orm/tracing.js
+var otel, rawTracer, tracer;
+var init_tracing = __esm(() => {
+  init_tracing_utils();
+  init_version();
+  tracer = {
+    startActiveSpan(name, fn) {
+      if (!otel) {
+        return fn();
+      }
+      if (!rawTracer) {
+        rawTracer = otel.trace.getTracer("drizzle-orm", version);
+      }
+      return iife((otel2, rawTracer2) => rawTracer2.startActiveSpan(name, (span) => {
+        try {
+          return fn(span);
+        } catch (e) {
+          span.setStatus({
+            code: otel2.SpanStatusCode.ERROR,
+            message: e instanceof Error ? e.message : "Unknown error"
+          });
+          throw e;
+        } finally {
+          span.end();
+        }
+      }), otel, rawTracer);
+    }
+  };
+});
+
+// ../../../../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
+function isTable(table) {
+  return typeof table === "object" && table !== null && IsDrizzleTable in table;
+}
+function getTableName(table) {
+  return table[TableName];
+}
+function getTableUniqueName(table) {
+  return `${table[Schema] ?? "public"}.${table[TableName]}`;
+}
+var Schema, Columns, ExtraConfigColumns, OriginalName, BaseName, IsAlias, ExtraConfigBuilder, IsDrizzleTable, Table;
+var init_table = __esm(() => {
+  init_entity();
+  init_table_utils();
+  Schema = Symbol.for("drizzle:Schema");
+  Columns = Symbol.for("drizzle:Columns");
+  ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
+  OriginalName = Symbol.for("drizzle:OriginalName");
+  BaseName = Symbol.for("drizzle:BaseName");
+  IsAlias = Symbol.for("drizzle:IsAlias");
+  ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
+  IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
+  Table = class Table {
+    static [entityKind] = "Table";
+    static Symbol = {
+      Name: TableName,
+      Schema,
+      OriginalName,
+      Columns,
+      ExtraConfigColumns,
+      BaseName,
+      IsAlias,
+      ExtraConfigBuilder
+    };
+    [TableName];
+    [OriginalName];
+    [Schema];
+    [Columns];
+    [ExtraConfigColumns];
+    [BaseName];
+    [IsAlias] = false;
+    [IsDrizzleTable] = true;
+    [ExtraConfigBuilder] = undefined;
+    constructor(name, schema, baseName) {
+      this[TableName] = this[OriginalName] = name;
+      this[Schema] = schema;
+      this[BaseName] = baseName;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/sql/sql.js
+function isSQLWrapper(value) {
+  return value !== null && value !== undefined && typeof value.getSQL === "function";
+}
+function mergeQueries(queries) {
+  const result = { sql: "", params: [] };
+  for (const query of queries) {
+    result.sql += query.sql;
+    result.params.push(...query.params);
+    if (query.typings?.length) {
+      if (!result.typings) {
+        result.typings = [];
+      }
+      result.typings.push(...query.typings);
+    }
+  }
+  return result;
+}
+function name(value) {
+  return new Name(value);
+}
+function isDriverValueEncoder(value) {
+  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
+}
+function param(value, encoder) {
+  return new Param(value, encoder);
+}
+function sql(strings, ...params) {
+  const queryChunks = [];
+  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
+    queryChunks.push(new StringChunk(strings[0]));
+  }
+  for (const [paramIndex, param2] of params.entries()) {
+    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
+  }
+  return new SQL(queryChunks);
+}
+function placeholder(name2) {
+  return new Placeholder(name2);
+}
+function fillPlaceholders(params, values) {
+  return params.map((p) => {
+    if (is(p, Placeholder)) {
+      if (!(p.name in values)) {
+        throw new Error(`No value for placeholder "${p.name}" was provided`);
+      }
+      return values[p.name];
+    }
+    if (is(p, Param) && is(p.value, Placeholder)) {
+      if (!(p.value.name in values)) {
+        throw new Error(`No value for placeholder "${p.value.name}" was provided`);
+      }
+      return p.encoder.mapToDriverValue(values[p.value.name]);
+    }
+    return p;
+  });
+}
+function isView(view) {
+  return typeof view === "object" && view !== null && IsDrizzleView in view;
+}
+function getViewName(view) {
+  return view[ViewBaseConfig].name;
+}
+var FakePrimitiveParam, StringChunk, SQL, Name, noopDecoder, noopEncoder, noopMapper, Param, Placeholder, IsDrizzleView, View;
+var init_sql = __esm(() => {
+  init_entity();
+  init_enum();
+  init_subquery();
+  init_tracing();
+  init_view_common();
+  init_column();
+  init_table();
+  FakePrimitiveParam = class FakePrimitiveParam {
+    static [entityKind] = "FakePrimitiveParam";
+  };
+  StringChunk = class StringChunk {
+    static [entityKind] = "StringChunk";
+    value;
+    constructor(value) {
+      this.value = Array.isArray(value) ? value : [value];
+    }
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  SQL = class SQL {
+    constructor(queryChunks) {
+      this.queryChunks = queryChunks;
+      for (const chunk of queryChunks) {
+        if (is(chunk, Table)) {
+          const schemaName = chunk[Table.Symbol.Schema];
+          this.usedTables.push(schemaName === undefined ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]);
+        }
+      }
+    }
+    static [entityKind] = "SQL";
+    decoder = noopDecoder;
+    shouldInlineParams = false;
+    usedTables = [];
+    append(query) {
+      this.queryChunks.push(...query.queryChunks);
+      return this;
+    }
+    toQuery(config) {
+      return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
+        const query = this.buildQueryFromSourceParams(this.queryChunks, config);
+        span?.setAttributes({
+          "drizzle.query.text": query.sql,
+          "drizzle.query.params": JSON.stringify(query.params)
+        });
+        return query;
+      });
+    }
+    buildQueryFromSourceParams(chunks, _config) {
+      const config = Object.assign({}, _config, {
+        inlineParams: _config.inlineParams || this.shouldInlineParams,
+        paramStartIndex: _config.paramStartIndex || { value: 0 }
+      });
+      const {
+        casing,
+        escapeName,
+        escapeParam,
+        prepareTyping,
+        inlineParams,
+        paramStartIndex
+      } = config;
+      return mergeQueries(chunks.map((chunk) => {
+        if (is(chunk, StringChunk)) {
+          return { sql: chunk.value.join(""), params: [] };
+        }
+        if (is(chunk, Name)) {
+          return { sql: escapeName(chunk.value), params: [] };
+        }
+        if (chunk === undefined) {
+          return { sql: "", params: [] };
+        }
+        if (Array.isArray(chunk)) {
+          const result = [new StringChunk("(")];
+          for (const [i, p] of chunk.entries()) {
+            result.push(p);
+            if (i < chunk.length - 1) {
+              result.push(new StringChunk(", "));
+            }
+          }
+          result.push(new StringChunk(")"));
+          return this.buildQueryFromSourceParams(result, config);
+        }
+        if (is(chunk, SQL)) {
+          return this.buildQueryFromSourceParams(chunk.queryChunks, {
+            ...config,
+            inlineParams: inlineParams || chunk.shouldInlineParams
+          });
+        }
+        if (is(chunk, Table)) {
+          const schemaName = chunk[Table.Symbol.Schema];
+          const tableName = chunk[Table.Symbol.Name];
+          return {
+            sql: schemaName === undefined || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
+            params: []
+          };
+        }
+        if (is(chunk, Column)) {
+          const columnName = casing.getColumnCasing(chunk);
+          if (_config.invokeSource === "indexes") {
+            return { sql: escapeName(columnName), params: [] };
+          }
+          const schemaName = chunk.table[Table.Symbol.Schema];
+          return {
+            sql: chunk.table[IsAlias] || schemaName === undefined ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
+            params: []
+          };
+        }
+        if (is(chunk, View)) {
+          const schemaName = chunk[ViewBaseConfig].schema;
+          const viewName = chunk[ViewBaseConfig].name;
+          return {
+            sql: schemaName === undefined || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
+            params: []
+          };
+        }
+        if (is(chunk, Param)) {
+          if (is(chunk.value, Placeholder)) {
+            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+          }
+          const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
+          if (is(mappedValue, SQL)) {
+            return this.buildQueryFromSourceParams([mappedValue], config);
+          }
+          if (inlineParams) {
+            return { sql: this.mapInlineParam(mappedValue, config), params: [] };
+          }
+          let typings = ["none"];
+          if (prepareTyping) {
+            typings = [prepareTyping(chunk.encoder)];
+          }
+          return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
+        }
+        if (is(chunk, Placeholder)) {
+          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+        }
+        if (is(chunk, SQL.Aliased) && chunk.fieldAlias !== undefined) {
+          return { sql: escapeName(chunk.fieldAlias), params: [] };
+        }
+        if (is(chunk, Subquery)) {
+          if (chunk._.isWith) {
+            return { sql: escapeName(chunk._.alias), params: [] };
+          }
+          return this.buildQueryFromSourceParams([
+            new StringChunk("("),
+            chunk._.sql,
+            new StringChunk(") "),
+            new Name(chunk._.alias)
+          ], config);
+        }
+        if (isPgEnum(chunk)) {
+          if (chunk.schema) {
+            return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
+          }
+          return { sql: escapeName(chunk.enumName), params: [] };
+        }
+        if (isSQLWrapper(chunk)) {
+          if (chunk.shouldOmitSQLParens?.()) {
+            return this.buildQueryFromSourceParams([chunk.getSQL()], config);
+          }
+          return this.buildQueryFromSourceParams([
+            new StringChunk("("),
+            chunk.getSQL(),
+            new StringChunk(")")
+          ], config);
+        }
+        if (inlineParams) {
+          return { sql: this.mapInlineParam(chunk, config), params: [] };
+        }
+        return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
+      }));
+    }
+    mapInlineParam(chunk, { escapeString }) {
+      if (chunk === null) {
+        return "null";
+      }
+      if (typeof chunk === "number" || typeof chunk === "boolean") {
+        return chunk.toString();
+      }
+      if (typeof chunk === "string") {
+        return escapeString(chunk);
+      }
+      if (typeof chunk === "object") {
+        const mappedValueAsString = chunk.toString();
+        if (mappedValueAsString === "[object Object]") {
+          return escapeString(JSON.stringify(chunk));
+        }
+        return escapeString(mappedValueAsString);
+      }
+      throw new Error("Unexpected param value: " + chunk);
+    }
+    getSQL() {
+      return this;
+    }
+    as(alias) {
+      if (alias === undefined) {
+        return this;
+      }
+      return new SQL.Aliased(this, alias);
+    }
+    mapWith(decoder) {
+      this.decoder = typeof decoder === "function" ? { mapFromDriverValue: decoder } : decoder;
+      return this;
+    }
+    inlineParams() {
+      this.shouldInlineParams = true;
+      return this;
+    }
+    if(condition) {
+      return condition ? this : undefined;
+    }
+  };
+  Name = class Name {
+    constructor(value) {
+      this.value = value;
+    }
+    static [entityKind] = "Name";
+    brand;
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  noopDecoder = {
+    mapFromDriverValue: (value) => value
+  };
+  noopEncoder = {
+    mapToDriverValue: (value) => value
+  };
+  noopMapper = {
+    ...noopDecoder,
+    ...noopEncoder
+  };
+  Param = class Param {
+    constructor(value, encoder = noopEncoder) {
+      this.value = value;
+      this.encoder = encoder;
+    }
+    static [entityKind] = "Param";
+    brand;
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  ((sql2) => {
+    function empty() {
+      return new SQL([]);
+    }
+    sql2.empty = empty;
+    function fromList(list) {
+      return new SQL(list);
+    }
+    sql2.fromList = fromList;
+    function raw(str) {
+      return new SQL([new StringChunk(str)]);
+    }
+    sql2.raw = raw;
+    function join(chunks, separator) {
+      const result = [];
+      for (const [i, chunk] of chunks.entries()) {
+        if (i > 0 && separator !== undefined) {
+          result.push(separator);
+        }
+        result.push(chunk);
+      }
+      return new SQL(result);
+    }
+    sql2.join = join;
+    function identifier(value) {
+      return new Name(value);
+    }
+    sql2.identifier = identifier;
+    function placeholder2(name2) {
+      return new Placeholder(name2);
+    }
+    sql2.placeholder = placeholder2;
+    function param2(value, encoder) {
+      return new Param(value, encoder);
+    }
+    sql2.param = param2;
+  })(sql || (sql = {}));
+  ((SQL2) => {
+
+    class Aliased {
+      constructor(sql2, fieldAlias) {
+        this.sql = sql2;
+        this.fieldAlias = fieldAlias;
+      }
+      static [entityKind] = "SQL.Aliased";
+      isSelectionField = false;
+      getSQL() {
+        return this.sql;
+      }
+      clone() {
+        return new Aliased(this.sql, this.fieldAlias);
+      }
+    }
+    SQL2.Aliased = Aliased;
+  })(SQL || (SQL = {}));
+  Placeholder = class Placeholder {
+    constructor(name2) {
+      this.name = name2;
+    }
+    static [entityKind] = "Placeholder";
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
+  View = class View {
+    static [entityKind] = "View";
+    [ViewBaseConfig];
+    [IsDrizzleView] = true;
+    constructor({ name: name2, schema, selectedFields, query }) {
+      this[ViewBaseConfig] = {
+        name: name2,
+        originalName: name2,
+        schema,
+        selectedFields,
+        query,
+        isExisting: !query,
+        isAlias: false
+      };
+    }
+    getSQL() {
+      return new SQL([this]);
+    }
+  };
+  Column.prototype.getSQL = function() {
+    return new SQL([this]);
+  };
+  Table.prototype.getSQL = function() {
+    return new SQL([this]);
+  };
+  Subquery.prototype.getSQL = function() {
+    return new SQL([this]);
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/alias.js
+function aliasedTable(table, tableAlias) {
+  return new Proxy(table, new TableAliasProxyHandler(tableAlias, false));
+}
+function aliasedRelation(relation, tableAlias) {
+  return new Proxy(relation, new RelationTableAliasProxyHandler(tableAlias));
+}
+function aliasedTableColumn(column, tableAlias) {
+  return new Proxy(column, new ColumnAliasProxyHandler(new Proxy(column.table, new TableAliasProxyHandler(tableAlias, false))));
+}
+function mapColumnsInAliasedSQLToAlias(query, alias) {
+  return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias), query.fieldAlias);
+}
+function mapColumnsInSQLToAlias(query, alias) {
+  return sql.join(query.queryChunks.map((c) => {
+    if (is(c, Column)) {
+      return aliasedTableColumn(c, alias);
+    }
+    if (is(c, SQL)) {
+      return mapColumnsInSQLToAlias(c, alias);
+    }
+    if (is(c, SQL.Aliased)) {
+      return mapColumnsInAliasedSQLToAlias(c, alias);
+    }
+    return c;
+  }));
+}
+var ColumnAliasProxyHandler, TableAliasProxyHandler, RelationTableAliasProxyHandler;
+var init_alias = __esm(() => {
+  init_column();
+  init_entity();
+  init_sql();
+  init_table();
+  init_view_common();
+  ColumnAliasProxyHandler = class ColumnAliasProxyHandler {
+    constructor(table) {
+      this.table = table;
+    }
+    static [entityKind] = "ColumnAliasProxyHandler";
+    get(columnObj, prop) {
+      if (prop === "table") {
+        return this.table;
+      }
+      return columnObj[prop];
+    }
+  };
+  TableAliasProxyHandler = class TableAliasProxyHandler {
+    constructor(alias, replaceOriginalName) {
+      this.alias = alias;
+      this.replaceOriginalName = replaceOriginalName;
+    }
+    static [entityKind] = "TableAliasProxyHandler";
+    get(target, prop) {
+      if (prop === Table.Symbol.IsAlias) {
+        return true;
+      }
+      if (prop === Table.Symbol.Name) {
+        return this.alias;
+      }
+      if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {
+        return this.alias;
+      }
+      if (prop === ViewBaseConfig) {
+        return {
+          ...target[ViewBaseConfig],
+          name: this.alias,
+          isAlias: true
+        };
+      }
+      if (prop === Table.Symbol.Columns) {
+        const columns = target[Table.Symbol.Columns];
+        if (!columns) {
+          return columns;
+        }
+        const proxiedColumns = {};
+        Object.keys(columns).map((key) => {
+          proxiedColumns[key] = new Proxy(columns[key], new ColumnAliasProxyHandler(new Proxy(target, this)));
+        });
+        return proxiedColumns;
+      }
+      const value = target[prop];
+      if (is(value, Column)) {
+        return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
+      }
+      return value;
+    }
+  };
+  RelationTableAliasProxyHandler = class RelationTableAliasProxyHandler {
+    constructor(alias) {
+      this.alias = alias;
+    }
+    static [entityKind] = "RelationTableAliasProxyHandler";
+    get(target, prop) {
+      if (prop === "sourceTable") {
+        return aliasedTable(target.sourceTable, this.alias);
+      }
+      return target[prop];
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/errors.js
+var DrizzleError, DrizzleQueryError, TransactionRollbackError;
+var init_errors = __esm(() => {
+  init_entity();
+  DrizzleError = class DrizzleError extends Error {
+    static [entityKind] = "DrizzleError";
+    constructor({ message, cause }) {
+      super(message);
+      this.name = "DrizzleError";
+      this.cause = cause;
+    }
+  };
+  DrizzleQueryError = class DrizzleQueryError extends Error {
+    constructor(query, params, cause) {
+      super(`Failed query: ${query}
+params: ${params}`);
+      this.query = query;
+      this.params = params;
+      this.cause = cause;
+      Error.captureStackTrace(this, DrizzleQueryError);
+      if (cause)
+        this.cause = cause;
+    }
+  };
+  TransactionRollbackError = class TransactionRollbackError extends DrizzleError {
+    static [entityKind] = "TransactionRollbackError";
+    constructor() {
+      super({ message: "Rollback" });
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/logger.js
+var ConsoleLogWriter, DefaultLogger, NoopLogger;
+var init_logger = __esm(() => {
+  init_entity();
+  ConsoleLogWriter = class ConsoleLogWriter {
+    static [entityKind] = "ConsoleLogWriter";
+    write(message) {
+      console.log(message);
+    }
+  };
+  DefaultLogger = class DefaultLogger {
+    static [entityKind] = "DefaultLogger";
+    writer;
+    constructor(config) {
+      this.writer = config?.writer ?? new ConsoleLogWriter;
+    }
+    logQuery(query, params) {
+      const stringifiedParams = params.map((p) => {
+        try {
+          return JSON.stringify(p);
+        } catch {
+          return String(p);
+        }
+      });
+      const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
+      this.writer.write(`Query: ${query}${paramsStr}`);
+    }
+  };
+  NoopLogger = class NoopLogger {
+    static [entityKind] = "NoopLogger";
+    logQuery() {}
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/query-promise.js
+var QueryPromise;
+var init_query_promise = __esm(() => {
+  init_entity();
+  QueryPromise = class QueryPromise {
+    static [entityKind] = "QueryPromise";
+    [Symbol.toStringTag] = "QueryPromise";
+    catch(onRejected) {
+      return this.then(undefined, onRejected);
+    }
+    finally(onFinally) {
+      return this.then((value) => {
+        onFinally?.();
+        return value;
+      }, (reason) => {
+        onFinally?.();
+        throw reason;
+      });
+    }
+    then(onFulfilled, onRejected) {
+      return this.execute().then(onFulfilled, onRejected);
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/utils.js
+function mapResultRow(columns, row, joinsNotNullableMap) {
+  const nullifyMap = {};
+  const result = columns.reduce((result2, { path, field }, columnIndex) => {
+    let decoder;
+    if (is(field, Column)) {
+      decoder = field;
+    } else if (is(field, SQL)) {
+      decoder = field.decoder;
+    } else if (is(field, Subquery)) {
+      decoder = field._.sql.decoder;
+    } else {
+      decoder = field.sql.decoder;
+    }
+    let node = result2;
+    for (const [pathChunkIndex, pathChunk] of path.entries()) {
+      if (pathChunkIndex < path.length - 1) {
+        if (!(pathChunk in node)) {
+          node[pathChunk] = {};
+        }
+        node = node[pathChunk];
+      } else {
+        const rawValue = row[columnIndex];
+        const value = node[pathChunk] = rawValue === null ? null : decoder.mapFromDriverValue(rawValue);
+        if (joinsNotNullableMap && is(field, Column) && path.length === 2) {
+          const objectName = path[0];
+          if (!(objectName in nullifyMap)) {
+            nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
+          } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
+            nullifyMap[objectName] = false;
+          }
+        }
+      }
+    }
+    return result2;
+  }, {});
+  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
+    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
+      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
+        result[objectName] = null;
+      }
+    }
+  }
+  return result;
+}
+function orderSelectedFields(fields, pathPrefix) {
+  return Object.entries(fields).reduce((result, [name2, field]) => {
+    if (typeof name2 !== "string") {
+      return result;
+    }
+    const newPath = pathPrefix ? [...pathPrefix, name2] : [name2];
+    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased) || is(field, Subquery)) {
+      result.push({ path: newPath, field });
+    } else if (is(field, Table)) {
+      result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
+    } else {
+      result.push(...orderSelectedFields(field, newPath));
+    }
+    return result;
+  }, []);
+}
+function haveSameKeys(left, right) {
+  const leftKeys = Object.keys(left);
+  const rightKeys = Object.keys(right);
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (const [index, key] of leftKeys.entries()) {
+    if (key !== rightKeys[index]) {
+      return false;
+    }
+  }
+  return true;
+}
+function mapUpdateSet(table, values) {
+  const entries = Object.entries(values).filter(([, value]) => value !== undefined).map(([key, value]) => {
+    if (is(value, SQL) || is(value, Column)) {
+      return [key, value];
+    } else {
+      return [key, new Param(value, table[Table.Symbol.Columns][key])];
+    }
+  });
+  if (entries.length === 0) {
+    throw new Error("No values to set");
+  }
+  return Object.fromEntries(entries);
+}
+function applyMixins(baseClass, extendedClasses) {
+  for (const extendedClass of extendedClasses) {
+    for (const name2 of Object.getOwnPropertyNames(extendedClass.prototype)) {
+      if (name2 === "constructor")
+        continue;
+      Object.defineProperty(baseClass.prototype, name2, Object.getOwnPropertyDescriptor(extendedClass.prototype, name2) || /* @__PURE__ */ Object.create(null));
+    }
+  }
+}
+function getTableColumns(table) {
+  return table[Table.Symbol.Columns];
+}
+function getViewSelectedFields(view) {
+  return view[ViewBaseConfig].selectedFields;
+}
+function getTableLikeName(table) {
+  return is(table, Subquery) ? table._.alias : is(table, View) ? table[ViewBaseConfig].name : is(table, SQL) ? undefined : table[Table.Symbol.IsAlias] ? table[Table.Symbol.Name] : table[Table.Symbol.BaseName];
+}
+function getColumnNameAndConfig(a, b) {
+  return {
+    name: typeof a === "string" && a.length > 0 ? a : "",
+    config: typeof a === "object" ? a : b
+  };
+}
+function isConfig(data) {
+  if (typeof data !== "object" || data === null)
+    return false;
+  if (data.constructor.name !== "Object")
+    return false;
+  if ("logger" in data) {
+    const type = typeof data["logger"];
+    if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("schema" in data) {
+    const type = typeof data["schema"];
+    if (type !== "object" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("casing" in data) {
+    const type = typeof data["casing"];
+    if (type !== "string" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("mode" in data) {
+    if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== undefined)
+      return false;
+    return true;
+  }
+  if ("connection" in data) {
+    const type = typeof data["connection"];
+    if (type !== "string" && type !== "object" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if ("client" in data) {
+    const type = typeof data["client"];
+    if (type !== "object" && type !== "function" && type !== "undefined")
+      return false;
+    return true;
+  }
+  if (Object.keys(data).length === 0)
+    return true;
+  return false;
+}
+var textDecoder;
+var init_utils = __esm(() => {
+  init_column();
+  init_entity();
+  init_sql();
+  init_subquery();
+  init_table();
+  init_view_common();
+  textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder;
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/table.js
+var InlineForeignKeys, EnableRLS, PgTable;
+var init_table2 = __esm(() => {
+  init_entity();
+  init_table();
+  InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
+  EnableRLS = Symbol.for("drizzle:EnableRLS");
+  PgTable = class PgTable extends Table {
+    static [entityKind] = "PgTable";
+    static Symbol = Object.assign({}, Table.Symbol, {
+      InlineForeignKeys,
+      EnableRLS
+    });
+    [InlineForeignKeys] = [];
+    [EnableRLS] = false;
+    [Table.Symbol.ExtraConfigBuilder] = undefined;
+    [Table.Symbol.ExtraConfigColumns] = {};
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/pg-core/primary-keys.js
+var PrimaryKeyBuilder, PrimaryKey;
+var init_primary_keys = __esm(() => {
+  init_entity();
+  init_table2();
+  PrimaryKeyBuilder = class PrimaryKeyBuilder {
+    static [entityKind] = "PgPrimaryKeyBuilder";
+    columns;
+    name;
+    constructor(columns, name2) {
+      this.columns = columns;
+      this.name = name2;
+    }
+    build(table) {
+      return new PrimaryKey(table, this.columns, this.name);
+    }
+  };
+  PrimaryKey = class PrimaryKey {
+    constructor(table, columns, name2) {
+      this.table = table;
+      this.columns = columns;
+      this.name = name2;
+    }
+    static [entityKind] = "PgPrimaryKey";
+    columns;
+    name;
+    getName() {
+      return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column) => column.name).join("_")}_pk`;
+    }
+  };
+});
+
+// ../../../../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);
+  }
+  return value;
+}
+function and(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== undefined);
+  if (conditions.length === 0) {
+    return;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" and ")),
+    new StringChunk(")")
+  ]);
+}
+function or(...unfilteredConditions) {
+  const conditions = unfilteredConditions.filter((c) => c !== undefined);
+  if (conditions.length === 0) {
+    return;
+  }
+  if (conditions.length === 1) {
+    return new SQL(conditions);
+  }
+  return new SQL([
+    new StringChunk("("),
+    sql.join(conditions, new StringChunk(" or ")),
+    new StringChunk(")")
+  ]);
+}
+function not(condition) {
+  return sql`not ${condition}`;
+}
+function inArray(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      return sql`false`;
+    }
+    return sql`${column} in ${values.map((v) => bindIfParam(v, column))}`;
+  }
+  return sql`${column} in ${bindIfParam(values, column)}`;
+}
+function notInArray(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      return sql`true`;
+    }
+    return sql`${column} not in ${values.map((v) => bindIfParam(v, column))}`;
+  }
+  return sql`${column} not in ${bindIfParam(values, column)}`;
+}
+function isNull(value) {
+  return sql`${value} is null`;
+}
+function isNotNull(value) {
+  return sql`${value} is not null`;
+}
+function exists(subquery) {
+  return sql`exists ${subquery}`;
+}
+function notExists(subquery) {
+  return sql`not exists ${subquery}`;
+}
+function between(column, min, max) {
+  return sql`${column} between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function notBetween(column, min, max) {
+  return sql`${column} not between ${bindIfParam(min, column)} and ${bindIfParam(max, column)}`;
+}
+function like(column, value) {
+  return sql`${column} like ${value}`;
+}
+function notLike(column, value) {
+  return sql`${column} not like ${value}`;
+}
+function ilike(column, value) {
+  return sql`${column} ilike ${value}`;
+}
+function notIlike(column, value) {
+  return sql`${column} not ilike ${value}`;
+}
+function arrayContains(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayContains requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} @> ${array}`;
+  }
+  return sql`${column} @> ${bindIfParam(values, column)}`;
+}
+function arrayContained(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayContained requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} <@ ${array}`;
+  }
+  return sql`${column} <@ ${bindIfParam(values, column)}`;
+}
+function arrayOverlaps(column, values) {
+  if (Array.isArray(values)) {
+    if (values.length === 0) {
+      throw new Error("arrayOverlaps requires at least one value");
+    }
+    const array = sql`${bindIfParam(values, column)}`;
+    return sql`${column} && ${array}`;
+  }
+  return sql`${column} && ${bindIfParam(values, column)}`;
+}
+var eq = (left, right) => {
+  return sql`${left} = ${bindIfParam(right, left)}`;
+}, ne = (left, right) => {
+  return sql`${left} <> ${bindIfParam(right, left)}`;
+}, gt = (left, right) => {
+  return sql`${left} > ${bindIfParam(right, left)}`;
+}, gte = (left, right) => {
+  return sql`${left} >= ${bindIfParam(right, left)}`;
+}, lt = (left, right) => {
+  return sql`${left} < ${bindIfParam(right, left)}`;
+}, lte = (left, right) => {
+  return sql`${left} <= ${bindIfParam(right, left)}`;
+};
+var init_conditions = __esm(() => {
+  init_column();
+  init_entity();
+  init_table();
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/expressions/select.js
+function asc(column) {
+  return sql`${column} asc`;
+}
+function desc(column) {
+  return sql`${column} desc`;
+}
+var init_select = __esm(() => {
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/expressions/index.js
+var init_expressions = __esm(() => {
+  init_conditions();
+  init_select();
+});
+
+// ../../../../node_modules/drizzle-orm/relations.js
+function getOperators() {
+  return {
+    and,
+    between,
+    eq,
+    exists,
+    gt,
+    gte,
+    ilike,
+    inArray,
+    isNull,
+    isNotNull,
+    like,
+    lt,
+    lte,
+    ne,
+    not,
+    notBetween,
+    notExists,
+    notLike,
+    notIlike,
+    notInArray,
+    or,
+    sql
+  };
+}
+function getOrderByOperators() {
+  return {
+    sql,
+    asc,
+    desc
+  };
+}
+function extractTablesRelationalConfig(schema, configHelpers) {
+  if (Object.keys(schema).length === 1 && "default" in schema && !is(schema["default"], Table)) {
+    schema = schema["default"];
+  }
+  const tableNamesMap = {};
+  const relationsBuffer = {};
+  const tablesConfig = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (is(value, Table)) {
+      const dbName = getTableUniqueName(value);
+      const bufferedRelations = relationsBuffer[dbName];
+      tableNamesMap[dbName] = key;
+      tablesConfig[key] = {
+        tsName: key,
+        dbName: value[Table.Symbol.Name],
+        schema: value[Table.Symbol.Schema],
+        columns: value[Table.Symbol.Columns],
+        relations: bufferedRelations?.relations ?? {},
+        primaryKey: bufferedRelations?.primaryKey ?? []
+      };
+      for (const column of Object.values(value[Table.Symbol.Columns])) {
+        if (column.primary) {
+          tablesConfig[key].primaryKey.push(column);
+        }
+      }
+      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
+      if (extraConfig) {
+        for (const configEntry of Object.values(extraConfig)) {
+          if (is(configEntry, PrimaryKeyBuilder)) {
+            tablesConfig[key].primaryKey.push(...configEntry.columns);
+          }
+        }
+      }
+    } else if (is(value, Relations)) {
+      const dbName = getTableUniqueName(value.table);
+      const tableName = tableNamesMap[dbName];
+      const relations2 = value.config(configHelpers(value.table));
+      let primaryKey;
+      for (const [relationName, relation] of Object.entries(relations2)) {
+        if (tableName) {
+          const tableConfig = tablesConfig[tableName];
+          tableConfig.relations[relationName] = relation;
+          if (primaryKey) {
+            tableConfig.primaryKey.push(...primaryKey);
+          }
+        } else {
+          if (!(dbName in relationsBuffer)) {
+            relationsBuffer[dbName] = {
+              relations: {},
+              primaryKey
+            };
+          }
+          relationsBuffer[dbName].relations[relationName] = relation;
+        }
+      }
+    }
+  }
+  return { tables: tablesConfig, tableNamesMap };
+}
+function relations(table, relations2) {
+  return new Relations(table, (helpers) => Object.fromEntries(Object.entries(relations2(helpers)).map(([key, value]) => [
+    key,
+    value.withFieldName(key)
+  ])));
+}
+function createOne(sourceTable) {
+  return function one(table, config) {
+    return new One(sourceTable, table, config, config?.fields.reduce((res, f) => res && f.notNull, true) ?? false);
+  };
+}
+function createMany(sourceTable) {
+  return function many(referencedTable, config) {
+    return new Many(sourceTable, referencedTable, config);
+  };
+}
+function normalizeRelation(schema, tableNamesMap, relation) {
+  if (is(relation, One) && relation.config) {
+    return {
+      fields: relation.config.fields,
+      references: relation.config.references
+    };
+  }
+  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
+  if (!referencedTableTsName) {
+    throw new Error(`Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`);
+  }
+  const referencedTableConfig = schema[referencedTableTsName];
+  if (!referencedTableConfig) {
+    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
+  }
+  const sourceTable = relation.sourceTable;
+  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
+  if (!sourceTableTsName) {
+    throw new Error(`Table "${sourceTable[Table.Symbol.Name]}" not found in schema`);
+  }
+  const reverseRelations = [];
+  for (const referencedTableRelation of Object.values(referencedTableConfig.relations)) {
+    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
+      reverseRelations.push(referencedTableRelation);
+    }
+  }
+  if (reverseRelations.length > 1) {
+    throw relation.relationName ? new Error(`There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`) : new Error(`There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`);
+  }
+  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
+    return {
+      fields: reverseRelations[0].config.references,
+      references: reverseRelations[0].config.fields
+    };
+  }
+  throw new Error(`There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`);
+}
+function createTableRelationsHelpers(sourceTable) {
+  return {
+    one: createOne(sourceTable),
+    many: createMany(sourceTable)
+  };
+}
+function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
+  const result = {};
+  for (const [
+    selectionItemIndex,
+    selectionItem
+  ] of buildQueryResultSelection.entries()) {
+    if (selectionItem.isJson) {
+      const relation = tableConfig.relations[selectionItem.tsKey];
+      const rawSubRows = row[selectionItemIndex];
+      const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
+      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRows, selectionItem.selection, mapColumnValue) : subRows.map((subRow) => mapRelationalRow(tablesConfig, tablesConfig[selectionItem.relationTableTsKey], subRow, selectionItem.selection, mapColumnValue));
+    } else {
+      const value = mapColumnValue(row[selectionItemIndex]);
+      const field = selectionItem.field;
+      let decoder;
+      if (is(field, Column)) {
+        decoder = field;
+      } else if (is(field, SQL)) {
+        decoder = field.decoder;
+      } else {
+        decoder = field.sql.decoder;
+      }
+      result[selectionItem.tsKey] = value === null ? null : decoder.mapFromDriverValue(value);
+    }
+  }
+  return result;
+}
+var Relation, Relations, One, Many;
+var init_relations = __esm(() => {
+  init_table();
+  init_column();
+  init_entity();
+  init_primary_keys();
+  init_expressions();
+  init_sql();
+  Relation = class Relation {
+    constructor(sourceTable, referencedTable, relationName) {
+      this.sourceTable = sourceTable;
+      this.referencedTable = referencedTable;
+      this.relationName = relationName;
+      this.referencedTableName = referencedTable[Table.Symbol.Name];
+    }
+    static [entityKind] = "Relation";
+    referencedTableName;
+    fieldName;
+  };
+  Relations = class Relations {
+    constructor(table, config) {
+      this.table = table;
+      this.config = config;
+    }
+    static [entityKind] = "Relations";
+  };
+  One = class One extends Relation {
+    constructor(sourceTable, referencedTable, config, isNullable) {
+      super(sourceTable, referencedTable, config?.relationName);
+      this.config = config;
+      this.isNullable = isNullable;
+    }
+    static [entityKind] = "One";
+    withFieldName(fieldName) {
+      const relation = new One(this.sourceTable, this.referencedTable, this.config, this.isNullable);
+      relation.fieldName = fieldName;
+      return relation;
+    }
+  };
+  Many = class Many extends Relation {
+    constructor(sourceTable, referencedTable, config) {
+      super(sourceTable, referencedTable, config?.relationName);
+      this.config = config;
+    }
+    static [entityKind] = "Many";
+    withFieldName(fieldName) {
+      const relation = new Many(this.sourceTable, this.referencedTable, this.config);
+      relation.fieldName = fieldName;
+      return relation;
+    }
+  };
+});
+
+// ../../../../node_modules/drizzle-orm/sql/functions/aggregate.js
+function count(expression) {
+  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
+}
+function countDistinct(expression) {
+  return sql`count(distinct ${expression})`.mapWith(Number);
+}
+function avg(expression) {
+  return sql`avg(${expression})`.mapWith(String);
+}
+function avgDistinct(expression) {
+  return sql`avg(distinct ${expression})`.mapWith(String);
+}
+function sum(expression) {
+  return sql`sum(${expression})`.mapWith(String);
+}
+function sumDistinct(expression) {
+  return sql`sum(distinct ${expression})`.mapWith(String);
+}
+function max(expression) {
+  return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+function min(expression) {
+  return sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String);
+}
+var init_aggregate = __esm(() => {
+  init_column();
+  init_entity();
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/functions/vector.js
+function toSql(value) {
+  return JSON.stringify(value);
+}
+function l2Distance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <-> ${toSql(value)}`;
+  }
+  return sql`${column} <-> ${value}`;
+}
+function l1Distance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <+> ${toSql(value)}`;
+  }
+  return sql`${column} <+> ${value}`;
+}
+function innerProduct(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <#> ${toSql(value)}`;
+  }
+  return sql`${column} <#> ${value}`;
+}
+function cosineDistance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <=> ${toSql(value)}`;
+  }
+  return sql`${column} <=> ${value}`;
+}
+function hammingDistance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <~> ${toSql(value)}`;
+  }
+  return sql`${column} <~> ${value}`;
+}
+function jaccardDistance(column, value) {
+  if (Array.isArray(value)) {
+    return sql`${column} <%> ${toSql(value)}`;
+  }
+  return sql`${column} <%> ${value}`;
+}
+var init_vector = __esm(() => {
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/functions/index.js
+var init_functions = __esm(() => {
+  init_aggregate();
+  init_vector();
+});
+
+// ../../../../node_modules/drizzle-orm/sql/index.js
+var init_sql2 = __esm(() => {
+  init_expressions();
+  init_functions();
+  init_sql();
+});
+
+// ../../../../node_modules/drizzle-orm/index.js
+var exports_drizzle_orm = {};
+__export(exports_drizzle_orm, {
+  textDecoder: () => textDecoder,
+  sumDistinct: () => sumDistinct,
+  sum: () => sum,
+  sql: () => sql,
+  relations: () => relations,
+  placeholder: () => placeholder,
+  param: () => param,
+  orderSelectedFields: () => orderSelectedFields,
+  or: () => or,
+  notLike: () => notLike,
+  notInArray: () => notInArray,
+  notIlike: () => notIlike,
+  notExists: () => notExists,
+  notBetween: () => notBetween,
+  not: () => not,
+  normalizeRelation: () => normalizeRelation,
+  noopMapper: () => noopMapper,
+  noopEncoder: () => noopEncoder,
+  noopDecoder: () => noopDecoder,
+  ne: () => ne,
+  name: () => name,
+  min: () => min,
+  max: () => max,
+  mapUpdateSet: () => mapUpdateSet,
+  mapResultRow: () => mapResultRow,
+  mapRelationalRow: () => mapRelationalRow,
+  mapColumnsInSQLToAlias: () => mapColumnsInSQLToAlias,
+  mapColumnsInAliasedSQLToAlias: () => mapColumnsInAliasedSQLToAlias,
+  lte: () => lte,
+  lt: () => lt,
+  like: () => like,
+  l2Distance: () => l2Distance,
+  l1Distance: () => l1Distance,
+  jaccardDistance: () => jaccardDistance,
+  isView: () => isView,
+  isTable: () => isTable,
+  isSQLWrapper: () => isSQLWrapper,
+  isNull: () => isNull,
+  isNotNull: () => isNotNull,
+  isDriverValueEncoder: () => isDriverValueEncoder,
+  isConfig: () => isConfig,
+  is: () => is,
+  innerProduct: () => innerProduct,
+  inArray: () => inArray,
+  ilike: () => ilike,
+  haveSameKeys: () => haveSameKeys,
+  hasOwnEntityKind: () => hasOwnEntityKind,
+  hammingDistance: () => hammingDistance,
+  gte: () => gte,
+  gt: () => gt,
+  getViewSelectedFields: () => getViewSelectedFields,
+  getViewName: () => getViewName,
+  getTableUniqueName: () => getTableUniqueName,
+  getTableName: () => getTableName,
+  getTableLikeName: () => getTableLikeName,
+  getTableColumns: () => getTableColumns,
+  getOrderByOperators: () => getOrderByOperators,
+  getOperators: () => getOperators,
+  getColumnNameAndConfig: () => getColumnNameAndConfig,
+  fillPlaceholders: () => fillPlaceholders,
+  extractTablesRelationalConfig: () => extractTablesRelationalConfig,
+  exists: () => exists,
+  eq: () => eq,
+  entityKind: () => entityKind,
+  desc: () => desc,
+  createTableRelationsHelpers: () => createTableRelationsHelpers,
+  createOne: () => createOne,
+  createMany: () => createMany,
+  countDistinct: () => countDistinct,
+  count: () => count,
+  cosineDistance: () => cosineDistance,
+  bindIfParam: () => bindIfParam,
+  between: () => between,
+  avgDistinct: () => avgDistinct,
+  avg: () => avg,
+  asc: () => asc,
+  arrayOverlaps: () => arrayOverlaps,
+  arrayContains: () => arrayContains,
+  arrayContained: () => arrayContained,
+  applyMixins: () => applyMixins,
+  and: () => and,
+  aliasedTableColumn: () => aliasedTableColumn,
+  aliasedTable: () => aliasedTable,
+  aliasedRelation: () => aliasedRelation,
+  WithSubquery: () => WithSubquery,
+  ViewBaseConfig: () => ViewBaseConfig,
+  View: () => View,
+  TransactionRollbackError: () => TransactionRollbackError,
+  TableAliasProxyHandler: () => TableAliasProxyHandler,
+  Table: () => Table,
+  Subquery: () => Subquery,
+  StringChunk: () => StringChunk,
+  Schema: () => Schema,
+  SQL: () => SQL,
+  Relations: () => Relations,
+  RelationTableAliasProxyHandler: () => RelationTableAliasProxyHandler,
+  Relation: () => Relation,
+  QueryPromise: () => QueryPromise,
+  Placeholder: () => Placeholder,
+  Param: () => Param,
+  OriginalName: () => OriginalName,
+  One: () => One,
+  NoopLogger: () => NoopLogger,
+  Name: () => Name,
+  Many: () => Many,
+  IsAlias: () => IsAlias,
+  FakePrimitiveParam: () => FakePrimitiveParam,
+  ExtraConfigColumns: () => ExtraConfigColumns,
+  ExtraConfigBuilder: () => ExtraConfigBuilder,
+  DrizzleQueryError: () => DrizzleQueryError,
+  DrizzleError: () => DrizzleError,
+  DefaultLogger: () => DefaultLogger,
+  ConsoleLogWriter: () => ConsoleLogWriter,
+  Columns: () => Columns,
+  ColumnBuilder: () => ColumnBuilder,
+  ColumnAliasProxyHandler: () => ColumnAliasProxyHandler,
+  Column: () => Column,
+  BaseName: () => BaseName
+});
+var init_drizzle_orm = __esm(() => {
+  init_alias();
+  init_column_builder();
+  init_column();
+  init_entity();
+  init_errors();
+  init_logger();
+  init_query_promise();
+  init_relations();
+  init_sql2();
+  init_subquery();
+  init_table();
+  init_utils();
+  init_view_common();
+});
+
 // index.ts
-import { createUniqueUuid } from "@elizaos/core";
+import {
+  createUniqueUuid
+} from "@elizaos/core";
+import crypto from "node:crypto";
 
 // TrajectoryLoggerService.ts
-import { asUUID, logger } from "@elizaos/core";
+import { logger as logger2, Service } from "@elizaos/core";
 import { v4 as uuidv4 } from "uuid";
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value))
+    return value;
+  if (typeof value === "string") {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  return null;
+}
+function asString(value) {
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (value instanceof Date)
+    return value.toISOString();
+  return null;
+}
+function asIsoString(value) {
+  if (value instanceof Date)
+    return value.toISOString();
+  const asText = asString(value);
+  if (!asText)
+    return new Date(0).toISOString();
+  const parsed = new Date(asText);
+  if (Number.isNaN(parsed.getTime()))
+    return new Date(0).toISOString();
+  return parsed.toISOString();
+}
+function pickCell(row, ...keys) {
+  for (const key of keys) {
+    if (Object.hasOwn(row, key)) {
+      return row[key];
+    }
+  }
+  return;
+}
+function sqlLiteral(v) {
+  if (v === null || v === undefined)
+    return "NULL";
+  if (typeof v === "number")
+    return String(v);
+  if (typeof v === "boolean")
+    return v ? "TRUE" : "FALSE";
+  if (typeof v === "object")
+    return `'${JSON.stringify(v).replace(/'/g, "''")}'`;
+  return `'${String(v).replace(/'/g, "''")}'`;
+}
 
-class TrajectoryLoggerService {
-  activeTrajectories = new Map;
+class TrajectoryLoggerService extends Service {
+  static serviceType = "trajectory_logger";
+  get serviceType() {
+    return TrajectoryLoggerService.serviceType;
+  }
+  capabilityDescription = "Captures and persists LLM calls, provider accesses, and full trajectories for debugging, analysis, and RL training";
+  enabled = true;
+  initialized = false;
   activeStepIds = new Map;
-  startTrajectory(agentId, options = {}) {
+  stepToTrajectory = new Map;
+  writeQueues = new Map;
+  static async start(runtime) {
+    const service = new this(runtime);
+    await service.initialize();
+    return service;
+  }
+  async stop() {
+    this.enabled = false;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  async getSqlHelper() {
+    const drizzle = await Promise.resolve().then(() => (init_drizzle_orm(), exports_drizzle_orm));
+    return drizzle.sql;
+  }
+  async executeRawSql(sqlText) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      throw new Error("Database adapter not available");
+    }
+    const sqlHelper = await this.getSqlHelper();
+    const db = runtime.adapter.db;
+    const query = sqlHelper.raw(sqlText);
+    const result = await db.execute(query);
+    const rows = Array.isArray(result.rows) ? result.rows : [];
+    const columns = result.fields && Array.isArray(result.fields) ? result.fields.map((field) => field.name) : rows.length > 0 ? Object.keys(rows[0]) : [];
+    return { rows, columns };
+  }
+  async initialize() {
+    if (this.initialized)
+      return;
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      logger2.warn("[trajectory-logger] No runtime adapter available, skipping initialization");
+      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 (
+        id TEXT PRIMARY KEY,
+        agent_id TEXT NOT NULL,
+        source TEXT NOT NULL DEFAULT 'chat',
+        status TEXT NOT NULL DEFAULT 'active',
+        start_time BIGINT NOT NULL,
+        end_time BIGINT,
+        duration_ms BIGINT,
+        step_count INTEGER NOT NULL DEFAULT 0,
+        llm_call_count INTEGER NOT NULL DEFAULT 0,
+        provider_access_count INTEGER NOT NULL DEFAULT 0,
+        total_prompt_tokens INTEGER NOT NULL DEFAULT 0,
+        total_completion_tokens INTEGER NOT NULL DEFAULT 0,
+        total_reward REAL NOT NULL DEFAULT 0,
+        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,
+        ai_judge_reward REAL,
+        ai_judge_reasoning TEXT,
+        judged_at TIMESTAMPTZ,
+        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
+    `);
+  }
+  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;
+    (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");
+    });
+  }
+  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 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;
+    }
+    this.logProviderAccess(stepId, access);
+  }
+  async startTrajectory(stepIdOrAgentId, options = {}) {
+    if (!this.enabled)
+      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: asUUID(trajectoryId),
-      agentId: asUUID(agentId),
+      trajectoryId,
+      agentId,
       startTime: now,
       endTime: now,
       durationMs: 0,
-      episodeId: options.episodeId,
       scenarioId: options.scenarioId,
+      episodeId: options.episodeId,
       batchId: options.batchId,
       groupIndex: options.groupIndex,
       steps: [],
       totalReward: 0,
-      rewardComponents: {
-        environmentReward: 0
-      },
+      rewardComponents: { environmentReward: 0 },
       metrics: {
         episodeLength: 0,
         finalStatus: "completed"
       },
-      metadata: options.metadata || {}
+      metadata: {
+        source: options.source ?? "chat",
+        ...metadata
+      }
     };
-    this.activeTrajectories.set(trajectoryId, trajectory);
+    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, steps_json, reward_components_json, metrics_json,
+          created_at, updated_at
+        ) VALUES (
+          ${sqlLiteral(trajectoryId)},
+          ${sqlLiteral(agentId)},
+          ${sqlLiteral(options.source ?? "chat")},
+          'active',
+          ${now},
+          ${sqlLiteral(options.scenarioId ?? null)},
+          ${sqlLiteral(options.episodeId ?? null)},
+          ${sqlLiteral(options.batchId ?? null)},
+          ${options.groupIndex ?? "NULL"},
+          ${sqlLiteral(trajectory.metadata)},
+          ${sqlLiteral([])},
+          ${sqlLiteral(trajectory.rewardComponents)},
+          ${sqlLiteral(trajectory.metrics)},
+          ${sqlLiteral(timestampIso)},
+          ${sqlLiteral(timestampIso)}
+        )
+      `);
+      persistedStart = true;
+    } catch (err) {
+      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) {
-      throw new Error(`Trajectory ${trajectoryId} not found`);
-    }
-    const step = {
-      stepId: asUUID(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;
   }
-  logLLMCall(stepId, llmCall) {
-    const trajectory = this.findTrajectoryByStepId(stepId);
-    if (!trajectory) {
-      logger.warn({ stepId }, "Trajectory not found for LLM call");
+  completeStep(trajectoryId, actionOrStepId, actionOrReward, maybeReward) {
+    if (!this.enabled)
       return;
-    }
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step) {
-      logger.warn({ stepId }, "Step not found for LLM call");
+    const explicitStepId = typeof actionOrStepId === "string" ? actionOrStepId : null;
+    const action = typeof actionOrStepId === "string" ? actionOrReward : actionOrStepId;
+    const rewardInfo = typeof actionOrStepId === "string" ? maybeReward : actionOrReward;
+    if (!action)
       return;
-    }
-    const fullLLMCall = {
-      callId: uuidv4(),
-      timestamp: Date.now(),
-      ...llmCall
-    };
-    step.llmCalls.push(fullLLMCall);
+    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
+      };
+      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");
+    });
   }
-  logProviderAccess(stepId, access) {
-    const trajectory = this.findTrajectoryByStepId(stepId);
-    if (!trajectory) {
-      logger.warn({ stepId }, "Trajectory not found for provider access");
+  async endTrajectory(stepIdOrTrajectoryId, status = "completed", finalMetrics) {
+    if (!this.enabled)
       return;
-    }
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step) {
-      logger.warn({ stepId }, "Step not found for provider access");
+    const trajectoryId = await this.resolveTrajectoryId(stepIdOrTrajectoryId);
+    if (!trajectoryId) {
+      logger2.debug({ stepIdOrTrajectoryId }, "[trajectory-logger] No trajectory to end");
       return;
     }
-    const fullAccess = {
-      providerId: uuidv4(),
-      timestamp: Date.now(),
-      ...access
-    };
-    step.providerAccesses.push(fullAccess);
-  }
-  logLLMCallByTrajectoryId(trajectoryId, llmCall) {
-    const stepId = this.activeStepIds.get(trajectoryId);
-    if (!stepId) {
-      logger.warn({ trajectoryId }, "No active step for trajectory");
-      return;
+    await this.withTrajectoryWriteLock(trajectoryId, async () => {
+      const trajectory = await this.getTrajectoryById(trajectoryId);
+      if (!trajectory) {
+        logger2.debug({ trajectoryId }, "[trajectory-logger] Trajectory not found while ending");
+        return;
+      }
+      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);
+      }
     }
-    this.logLLMCall(stepId, llmCall);
   }
-  logProviderAccessByTrajectoryId(trajectoryId, access) {
-    const stepId = this.activeStepIds.get(trajectoryId);
-    if (!stepId) {
-      logger.warn({ trajectoryId }, "No active step for trajectory");
-      return;
+  async listTrajectories(options = {}) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      return { trajectories: [], total: 0, offset: 0, limit: 50 };
     }
-    this.logProviderAccess(stepId, access);
+    const offset = Math.max(0, options.offset ?? 0);
+    const limit = Math.min(500, Math.max(1, options.limit ?? 50));
+    const whereClauses = [];
+    if (options.status) {
+      whereClauses.push(`status = ${sqlLiteral(options.status)}`);
+    }
+    if (options.source) {
+      whereClauses.push(`source = ${sqlLiteral(options.source)}`);
+    }
+    if (options.scenarioId) {
+      whereClauses.push(`scenario_id = ${sqlLiteral(options.scenarioId)}`);
+    }
+    if (options.batchId) {
+      whereClauses.push(`batch_id = ${sqlLiteral(options.batchId)}`);
+    }
+    if (options.isTrainingData !== undefined) {
+      whereClauses.push(`is_training_data = ${options.isTrainingData}`);
+    }
+    if (options.startDate) {
+      whereClauses.push(`created_at >= ${sqlLiteral(options.startDate)}::timestamptz`);
+    }
+    if (options.endDate) {
+      whereClauses.push(`created_at <= ${sqlLiteral(options.endDate)}::timestamptz`);
+    }
+    if (options.search) {
+      const escaped = options.search.replace(/'/g, "''").replace(/%/g, "\\%");
+      whereClauses.push(`(
+        id ILIKE '%${escaped}%' OR
+        agent_id ILIKE '%${escaped}%' OR
+        source ILIKE '%${escaped}%' OR
+        scenario_id ILIKE '%${escaped}%'
+      )`);
+    }
+    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const countResult = await this.executeRawSql(`SELECT count(*)::int AS total FROM trajectories ${whereClause}`);
+    const total = asNumber(pickCell(countResult.rows[0] ?? {}, "total")) ?? 0;
+    const rowsResult = await this.executeRawSql(`
+      SELECT
+        id, agent_id, source, status, start_time, end_time, duration_ms,
+        step_count, llm_call_count, total_prompt_tokens, total_completion_tokens,
+        total_reward, scenario_id, batch_id, created_at
+      FROM trajectories
+      ${whereClause}
+      ORDER BY created_at DESC
+      LIMIT ${limit} OFFSET ${offset}
+    `);
+    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 };
   }
-  getCurrentStepId(trajectoryId) {
-    return this.activeStepIds.get(trajectoryId) || null;
+  async getTrajectoryDetail(trajectoryId) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter)
+      return null;
+    const safeId = trajectoryId.replace(/'/g, "''");
+    const result = await this.executeRawSql(`SELECT * FROM trajectories WHERE id = '${safeId}' LIMIT 1`);
+    if (result.rows.length === 0)
+      return null;
+    const row = result.rows[0];
+    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;
   }
-  completeStep(trajectoryId, stepId, action, rewardInfo) {
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      logger.warn({ trajectoryId }, "Trajectory not found for completeStep");
-      return;
+  async getStats() {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      return {
+        totalTrajectories: 0,
+        totalSteps: 0,
+        totalLlmCalls: 0,
+        totalPromptTokens: 0,
+        totalCompletionTokens: 0,
+        averageDurationMs: 0,
+        averageReward: 0,
+        bySource: {},
+        byStatus: {},
+        byScenario: {}
+      };
     }
-    const step = trajectory.steps.find((s) => s.stepId === stepId);
-    if (!step) {
-      logger.warn({ trajectoryId, stepId }, "Step not found for completeStep");
-      return;
+    const statsResult = await this.executeRawSql(`
+      SELECT
+        count(*)::int AS total_trajectories,
+        COALESCE(sum(step_count), 0)::int AS total_steps,
+        COALESCE(sum(llm_call_count), 0)::int AS total_llm_calls,
+        COALESCE(sum(total_prompt_tokens), 0)::int AS total_prompt_tokens,
+        COALESCE(sum(total_completion_tokens), 0)::int AS total_completion_tokens,
+        COALESCE(avg(duration_ms), 0)::int AS avg_duration_ms,
+        COALESCE(avg(total_reward), 0)::real AS avg_reward
+      FROM trajectories
+    `);
+    const sourceResult = await this.executeRawSql(`
+      SELECT source, count(*)::int AS cnt
+      FROM trajectories
+      GROUP BY source
+    `);
+    const statusResult = await this.executeRawSql(`
+      SELECT status, count(*)::int AS cnt
+      FROM trajectories
+      GROUP BY status
+    `);
+    const scenarioResult = await this.executeRawSql(`
+      SELECT scenario_id, count(*)::int AS cnt
+      FROM trajectories
+      WHERE scenario_id IS NOT NULL
+      GROUP BY scenario_id
+    `);
+    const stats = statsResult.rows[0] ?? {};
+    const bySource = {};
+    const byStatus = {};
+    const byScenario = {};
+    for (const row of sourceResult.rows) {
+      const source = asString(pickCell(row, "source"));
+      const cnt = asNumber(pickCell(row, "cnt"));
+      if (source && cnt !== null)
+        bySource[source] = cnt;
     }
-    step.action = {
-      attemptId: uuidv4(),
-      timestamp: Date.now(),
-      ...action
+    for (const row of statusResult.rows) {
+      const status = asString(pickCell(row, "status"));
+      const cnt = asNumber(pickCell(row, "cnt"));
+      if (status && cnt !== null)
+        byStatus[status] = cnt;
+    }
+    for (const row of scenarioResult.rows) {
+      const scenario = asString(pickCell(row, "scenario_id"));
+      const cnt = asNumber(pickCell(row, "cnt"));
+      if (scenario && cnt !== null)
+        byScenario[scenario] = cnt;
+    }
+    return {
+      totalTrajectories: asNumber(pickCell(stats, "total_trajectories")) ?? 0,
+      totalSteps: asNumber(pickCell(stats, "total_steps")) ?? 0,
+      totalLlmCalls: asNumber(pickCell(stats, "total_llm_calls")) ?? 0,
+      totalPromptTokens: asNumber(pickCell(stats, "total_prompt_tokens")) ?? 0,
+      totalCompletionTokens: asNumber(pickCell(stats, "total_completion_tokens")) ?? 0,
+      averageDurationMs: asNumber(pickCell(stats, "avg_duration_ms")) ?? 0,
+      averageReward: asNumber(pickCell(stats, "avg_reward")) ?? 0,
+      bySource,
+      byStatus,
+      byScenario
     };
-    if (rewardInfo?.reward !== undefined) {
-      step.reward = rewardInfo.reward;
-      trajectory.totalReward += rewardInfo.reward;
-    }
-    if (rewardInfo?.components) {
-      trajectory.rewardComponents = {
-        ...trajectory.rewardComponents,
-        ...rewardInfo.components
-      };
+  }
+  async deleteTrajectories(trajectoryIds) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter)
+      return 0;
+    if (trajectoryIds.length === 0)
+      return 0;
+    const ids = trajectoryIds.map(sqlLiteral).join(", ");
+    const result = await this.executeRawSql(`DELETE FROM trajectories WHERE id IN (${ids}) RETURNING id`);
+    return result.rows.length;
+  }
+  async clearAllTrajectories() {
+    const runtime = this.runtime;
+    if (!runtime?.adapter)
+      return 0;
+    const countResult = await this.executeRawSql(`SELECT count(*)::int AS cnt FROM trajectories`);
+    const count2 = asNumber(pickCell(countResult.rows[0] ?? {}, "cnt")) ?? 0;
+    await this.executeRawSql(`DELETE FROM trajectories`);
+    return count2;
+  }
+  sanitizeZipFolderName(value) {
+    const sanitized = value.trim().replace(/[^a-zA-Z0-9._-]+/g, "_").replace(/^_+|_+$/g, "");
+    return sanitized || "trajectory";
+  }
+  redactTrajectoryPrompts(trajectory) {
+    return {
+      ...trajectory,
+      steps: trajectory.steps.map((step) => ({
+        ...step,
+        llmCalls: step.llmCalls.map((call) => ({
+          ...call,
+          systemPrompt: "[redacted]",
+          userPrompt: "[redacted]",
+          response: "[redacted]"
+        }))
+      }))
+    };
+  }
+  buildZipSummary(trajectory) {
+    const finalStatus = trajectory.metrics?.finalStatus ?? "completed";
+    const normalizedEndTime = typeof trajectory.endTime === "number" && trajectory.endTime > 0 ? trajectory.endTime : null;
+    const status = finalStatus === "timeout" || finalStatus === "terminated" || finalStatus === "error" ? "error" : finalStatus === "completed" ? "completed" : normalizedEndTime ? "completed" : "active";
+    let llmCallCount = 0;
+    let providerAccessCount = 0;
+    let totalPromptTokens = 0;
+    let totalCompletionTokens = 0;
+    for (const step of trajectory.steps) {
+      providerAccessCount += step.providerAccesses.length;
+      llmCallCount += step.llmCalls.length;
+      for (const call of step.llmCalls) {
+        totalPromptTokens += call.promptTokens ?? 0;
+        totalCompletionTokens += call.completionTokens ?? 0;
+      }
     }
-    this.activeStepIds.delete(trajectoryId);
+    const metadata = trajectory.metadata ?? {};
+    const asNullableString = (value) => typeof value === "string" ? value : null;
+    const source = typeof metadata.source === "string" ? metadata.source : "chat";
+    const normalizedDurationMs = status === "active" ? null : typeof trajectory.durationMs === "number" ? trajectory.durationMs : null;
+    const updatedAtMs = normalizedEndTime ?? (trajectory.startTime || Date.now());
+    return {
+      id: trajectory.trajectoryId,
+      agentId: trajectory.agentId,
+      roomId: asNullableString(metadata.roomId),
+      entityId: asNullableString(metadata.entityId),
+      conversationId: asNullableString(metadata.conversationId),
+      source,
+      status,
+      startTime: trajectory.startTime,
+      endTime: normalizedEndTime,
+      durationMs: normalizedDurationMs,
+      llmCallCount,
+      providerAccessCount,
+      totalPromptTokens,
+      totalCompletionTokens,
+      metadata,
+      createdAt: new Date(trajectory.startTime).toISOString(),
+      updatedAt: new Date(updatedAtMs).toISOString()
+    };
   }
-  completeCurrentStep(trajectoryId, action, rewardInfo) {
-    const stepId = this.activeStepIds.get(trajectoryId);
-    if (!stepId) {
-      logger.warn({ trajectoryId }, "No active step for trajectory");
-      return;
+  async exportTrajectoriesZip(options = {}) {
+    let targetIds = Array.isArray(options.trajectoryIds) ? options.trajectoryIds.filter((id) => typeof id === "string" && id.trim().length > 0) : [];
+    if (targetIds.length === 0) {
+      const list = await this.listTrajectories({
+        limit: 500,
+        startDate: options.startDate,
+        endDate: options.endDate,
+        scenarioId: options.scenarioId,
+        batchId: options.batchId
+      });
+      targetIds = list.trajectories.map((trajectory) => trajectory.id);
+    }
+    const entries = [];
+    const manifestRows = [];
+    for (const trajectoryId of targetIds) {
+      const detail = await this.getTrajectoryDetail(trajectoryId);
+      if (!detail)
+        continue;
+      const exportTrajectory = options.includePrompts === false ? this.redactTrajectoryPrompts(detail) : detail;
+      const summary = this.buildZipSummary(exportTrajectory);
+      const folderName = this.sanitizeZipFolderName(trajectoryId);
+      entries.push({
+        name: `${folderName}/trajectory.json`,
+        data: JSON.stringify(exportTrajectory, null, 2)
+      });
+      entries.push({
+        name: `${folderName}/summary.json`,
+        data: JSON.stringify(summary, null, 2)
+      });
+      manifestRows.push({
+        trajectoryId,
+        folder: folderName,
+        createdAt: summary.createdAt
+      });
     }
-    this.completeStep(trajectoryId, stepId, action, rewardInfo);
+    entries.unshift({
+      name: "manifest.json",
+      data: JSON.stringify({
+        exportedAt: new Date().toISOString(),
+        trajectories: manifestRows
+      }, null, 2)
+    });
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return {
+      filename: `trajectories-${timestamp}.zip`,
+      entries
+    };
   }
-  async endTrajectory(trajectoryId, status, finalMetrics) {
-    const trajectory = this.activeTrajectories.get(trajectoryId);
-    if (!trajectory) {
-      logger.warn({ trajectoryId }, "Trajectory not found for endTrajectory");
-      return;
+  async exportTrajectories(options) {
+    const runtime = this.runtime;
+    if (!runtime?.adapter) {
+      throw new Error("Database not available");
+    }
+    const whereClauses = [];
+    if (options.trajectoryIds && options.trajectoryIds.length > 0) {
+      const ids = options.trajectoryIds.map(sqlLiteral).join(", ");
+      whereClauses.push(`id IN (${ids})`);
+    }
+    if (options.startDate) {
+      whereClauses.push(`created_at >= ${sqlLiteral(options.startDate)}::timestamptz`);
+    }
+    if (options.endDate) {
+      whereClauses.push(`created_at <= ${sqlLiteral(options.endDate)}::timestamptz`);
     }
-    trajectory.endTime = Date.now();
-    trajectory.durationMs = trajectory.endTime - trajectory.startTime;
-    trajectory.metrics.finalStatus = status;
-    trajectory.metrics.episodeLength = trajectory.steps.length;
-    if (finalMetrics) {
-      trajectory.metrics = {
-        ...trajectory.metrics,
-        ...finalMetrics
+    if (options.scenarioId) {
+      whereClauses.push(`scenario_id = ${sqlLiteral(options.scenarioId)}`);
+    }
+    if (options.batchId) {
+      whereClauses.push(`batch_id = ${sqlLiteral(options.batchId)}`);
+    }
+    const whereClause = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+    const result = await this.executeRawSql(`SELECT * FROM trajectories ${whereClause} ORDER BY created_at DESC`);
+    const trajectories = result.rows.map((row) => this.rowToTrajectory(row));
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    if (options.format === "csv") {
+      const lines = [
+        "id,agent_id,source,status,start_time,end_time,duration_ms,step_count,llm_call_count,total_reward,scenario_id"
+      ];
+      for (const t of trajectories) {
+        lines.push([
+          t.trajectoryId,
+          t.agentId,
+          t.metadata.source ?? "chat",
+          t.metrics.finalStatus,
+          t.startTime,
+          t.endTime,
+          t.durationMs,
+          t.steps.length,
+          t.steps.reduce((sum2, s) => sum2 + s.llmCalls.length, 0),
+          t.totalReward,
+          t.scenarioId ?? ""
+        ].join(","));
+      }
+      return {
+        data: lines.join(`
+`),
+        filename: `trajectories-${timestamp}.csv`,
+        mimeType: "text/csv"
       };
     }
-    this.activeStepIds.delete(trajectoryId);
-  }
-  getActiveTrajectory(trajectoryId) {
-    return this.activeTrajectories.get(trajectoryId) || null;
+    let exportData = trajectories;
+    if (!options.includePrompts) {
+      exportData = trajectories.map((trajectory) => this.redactTrajectoryPrompts(trajectory));
+    }
+    return {
+      data: JSON.stringify(exportData, null, 2),
+      filename: `trajectories-${timestamp}.json`,
+      mimeType: "application/json"
+    };
   }
-  findTrajectoryByStepId(stepId) {
-    for (const trajectory of this.activeTrajectories.values()) {
-      if (trajectory.steps.some((s) => s.stepId === stepId)) {
-        return trajectory;
+  rowToTrajectory(row) {
+    const parseJson = (cell, fallback) => {
+      if (typeof cell === "string") {
+        try {
+          return JSON.parse(cell);
+        } catch {
+          return fallback;
+        }
       }
-    }
+      if (typeof cell === "object" && cell !== null && !Array.isArray(cell)) {
+        return cell;
+      }
+      return fallback;
+    };
+    return {
+      trajectoryId: asString(pickCell(row, "id")) ?? "",
+      agentId: asString(pickCell(row, "agent_id")) ?? "",
+      startTime: asNumber(pickCell(row, "start_time")) ?? 0,
+      endTime: asNumber(pickCell(row, "end_time")) ?? 0,
+      durationMs: asNumber(pickCell(row, "duration_ms")) ?? 0,
+      scenarioId: asString(pickCell(row, "scenario_id")) ?? undefined,
+      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"), []),
+      totalReward: asNumber(pickCell(row, "total_reward")) ?? 0,
+      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"), {})
+    };
+  }
+  getActiveTrajectory(trajectoryId) {
     return null;
   }
+  getCurrentStepId(trajectoryId) {
+    return this.activeStepIds.get(trajectoryId) || null;
+  }
+  getProviderAccessLogs() {
+    return [];
+  }
+  getLlmCallLogs() {
+    return [];
+  }
 }
-
 // action-interceptor.ts
-import { logger as logger2 } from "@elizaos/core";
+import { logger as logger3 } from "@elizaos/core";
 var trajectoryContexts = new WeakMap;
 function setTrajectoryContext(runtime, trajectoryId, trajectoryLogger) {
   trajectoryContexts.set(runtime, { trajectoryId, logger: trajectoryLogger });
@@ -211,7 +3086,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger2.warn({ action: action.name, trajectoryId }, "No active step for action execution");
+        logger3.warn({ action: action.name, trajectoryId }, "No active step for action execution");
         const result = await originalHandler(runtime, message, state, options, callback);
         return result ?? undefined;
       }
@@ -231,7 +3106,7 @@ function wrapActionWithLogging(action, _trajectoryLogger) {
       };
       const errorHandler = (err) => {
         const error = err instanceof Error ? err.message : typeof err === "string" ? err : err.message || String(err);
-        logger2.error({ action: action.name, trajectoryId, error }, "Action execution failed");
+        logger3.error({ action: action.name, trajectoryId, error }, "Action execution failed");
         const stateSnapshot = state ? JSON.parse(JSON.stringify(state)) : null;
         loggerService.completeStep(trajectoryId, stepId, {
           actionType: action.name,
@@ -274,7 +3149,7 @@ function wrapPluginActions(plugin, trajectoryLogger) {
 function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger2.warn({ trajectoryId }, "No active step for LLM call from action");
+    logger3.warn({ trajectoryId }, "No active step for LLM call from action");
     return;
   }
   trajectoryLogger.logLLMCall(stepId, {
@@ -295,7 +3170,7 @@ function logLLMCallFromAction(actionContext, trajectoryLogger, trajectoryId) {
 function logProviderFromAction(actionContext, trajectoryLogger, trajectoryId) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger2.warn({ trajectoryId }, "No active step for provider access from action");
+    logger3.warn({ trajectoryId }, "No active step for provider access from action");
     return;
   }
   trajectoryLogger.logProviderAccess(stepId, {
@@ -317,7 +3192,7 @@ function wrapProviderWithLogging(provider, _trajectoryLogger) {
       const { trajectoryId, logger: loggerService } = context;
       const stepId = loggerService.getCurrentStepId(trajectoryId);
       if (!stepId) {
-        logger2.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
+        logger3.warn({ provider: provider.name, trajectoryId }, "No active step for provider access");
         return originalGet?.(runtime, message, state) || { text: "" };
       }
       const result = await originalGet?.(runtime, message, state) || { text: "" };
@@ -519,14 +3394,14 @@ function toARTJSONL(trajectory) {
   return JSON.stringify(toARTTrajectory(trajectory));
 }
 function validateARTCompatibility(trajectory) {
-  const errors = [];
+  const errors2 = [];
   const warnings = [];
   if (trajectory.steps.length === 0) {
-    errors.push("Trajectory has no steps");
+    errors2.push("Trajectory has no steps");
   }
   for (const [idx, step] of trajectory.steps.entries()) {
     if (step.llmCalls.length === 0) {
-      errors.push(`Step ${idx} has no LLM calls - can't extract messages`);
+      errors2.push(`Step ${idx} has no LLM calls - can't extract messages`);
     }
     for (const llmCall of step.llmCalls) {
       if (!llmCall.userPrompt || llmCall.userPrompt.length < 10) {
@@ -538,15 +3413,15 @@ function validateARTCompatibility(trajectory) {
     }
   }
   if (trajectory.totalReward === undefined || Number.isNaN(trajectory.totalReward)) {
-    errors.push("Trajectory has no valid reward");
+    errors2.push("Trajectory has no valid reward");
   }
   const artTraj = toARTTrajectory(trajectory);
   if (artTraj.messages.length < 2) {
     warnings.push("Trajectory converts to very few messages (< 2)");
   }
   return {
-    valid: errors.length === 0,
-    errors,
+    valid: errors2.length === 0,
+    errors: errors2,
     warnings
   };
 }
@@ -642,9 +3517,9 @@ async function buildGameStateFromDB(_trajectoryId) {
 }
 async function recomputeTrajectoryRewards(_trajectoryIds) {}
 // integration.ts
-import { logger as logger3 } from "@elizaos/core";
-function startAutonomousTick(trajectoryLogger, context) {
-  const trajectoryId = trajectoryLogger.startTrajectory(context.agentId, {
+import { logger as logger4 } from "@elizaos/core";
+async function startAutonomousTick(trajectoryLogger, context) {
+  const trajectoryId = await trajectoryLogger.startTrajectory(context.agentId, {
     scenarioId: context.scenarioId,
     episodeId: context.episodeId,
     batchId: context.batchId,
@@ -658,17 +3533,17 @@ function startAutonomousTick(trajectoryLogger, context) {
     openPositions: 0
   };
   trajectoryLogger.startStep(trajectoryId, envState);
-  logger3.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
+  logger4.info({ trajectoryId, agentId: context.agentId }, "Started autonomous tick trajectory");
   return trajectoryId;
 }
 async function endAutonomousTick(trajectoryLogger, trajectoryId, status = "completed", finalMetrics) {
   await trajectoryLogger.endTrajectory(trajectoryId, status, finalMetrics);
-  logger3.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
+  logger4.info({ trajectoryId, status }, "Ended autonomous tick trajectory");
 }
 async function loggedLLMCall(trajectoryLogger, trajectoryId, options, llmCallFn) {
   const stepId = trajectoryLogger.getCurrentStepId(trajectoryId);
   if (!stepId) {
-    logger3.warn({ trajectoryId }, "No active step for LLM call");
+    logger4.warn({ trajectoryId }, "No active step for LLM call");
     const result2 = await llmCallFn();
     return result2.text;
   }
@@ -773,13 +3648,13 @@ class RewardService {
     return (score + 1) / 2;
   }
   normalizeScoresForGroup(scores) {
-    const min = Math.min(...scores);
-    const max = Math.max(...scores);
-    const range = max - min;
+    const min2 = Math.min(...scores);
+    const max2 = Math.max(...scores);
+    const range = max2 - min2;
     if (range === 0) {
       return scores.map(() => 0.5);
     }
-    return scores.map((s) => (s - min) / range);
+    return scores.map((s) => (s - min2) / range);
   }
 }
 function createRewardService(options = {}) {
@@ -809,16 +3684,18 @@ var trajectoryLoggerPlugin = {
         if (!message || !runtime)
           return;
         if (!message.metadata) {
-          message.metadata = { type: "message" };
+          message.metadata = {
+            type: "message"
+          };
         }
         const meta = message.metadata;
-        const logger4 = runtime.getService("trajectory_logger");
-        if (!logger4)
+        const logger5 = runtime.getService("trajectory_logger");
+        if (!logger5)
           return;
         let trajectoryStepId = crypto.randomUUID();
         meta.trajectoryStepId = trajectoryStepId;
         try {
-          const trajectoryId = await logger4.startTrajectory(runtime.agentId, {
+          const trajectoryId = await logger5.startTrajectory(runtime.agentId, {
             source: source ?? meta.source ?? "chat",
             metadata: {
               roomId: message.roomId,
@@ -830,7 +3707,7 @@ var trajectoryLoggerPlugin = {
           });
           const normalizedTrajectoryId = typeof trajectoryId === "string" && trajectoryId.trim().length > 0 ? trajectoryId : null;
           if (normalizedTrajectoryId) {
-            const runtimeStepId = logger4.startStep(normalizedTrajectoryId, {
+            const runtimeStepId = logger5.startStep(normalizedTrajectoryId, {
               timestamp: Date.now(),
               agentBalance: 0,
               agentPoints: 0,
@@ -841,13 +3718,17 @@ var trajectoryLoggerPlugin = {
             trajectoryStepId = normalizedStepId;
             meta.trajectoryStepId = trajectoryStepId;
             pendingTrajectoryEndTargetByStepId.set(trajectoryStepId, normalizedTrajectoryId);
-          }
+          } else {}
           if (message.id) {
             const replyId = createUniqueUuid(runtime, message.id);
             pendingTrajectoryStepByReplyId.set(replyId, trajectoryStepId);
           }
         } catch (err) {
-          runtime.logger?.warn({ err, src: "plugin-trajectory-logger", roomId: message.roomId }, "Failed to start trajectory logging");
+          runtime.logger?.warn({
+            err,
+            src: "plugin-trajectory-logger",
+            roomId: message.roomId
+          }, "Failed to start trajectory logging");
         }
       }
     ],
@@ -864,14 +3745,18 @@ var trajectoryLoggerPlugin = {
         }
         if (!trajectoryStepId)
           return;
-        const logger4 = runtime.getService("trajectory_logger");
-        if (!logger4)
+        const logger5 = runtime.getService("trajectory_logger");
+        if (!logger5)
           return;
         try {
           const endTarget = pendingTrajectoryEndTargetByStepId.get(trajectoryStepId) ?? trajectoryStepId;
-          await logger4.endTrajectory(endTarget, "completed");
+          await logger5.endTrajectory(endTarget, "completed");
         } catch (err) {
-          runtime.logger?.warn({ err, src: "plugin-trajectory-logger", trajectoryStepId }, "Failed to end trajectory logging");
+          runtime.logger?.warn({
+            err,
+            src: "plugin-trajectory-logger",
+            trajectoryStepId
+          }, "Failed to end trajectory logging");
         }
         if (inReplyTo) {
           pendingTrajectoryStepByReplyId.delete(inReplyTo);
@@ -922,4 +3807,4 @@ export {
   RewardService
 };
 
-//# debugId=F0E0006C38150F8464756E2164756E21
+//# debugId=621E07B14B9A695B64756E2164756E21