grix-connector 4.0.2 → 4.2.0

package/openclaw-plugin/audit-recorder-worker.js

@@ -773,9 +773,9 @@ async function collectClaudeTranscript(boundary, includeSubagents) {
   }
   const subagentRoot = typeof boundary.subagentRoot === "string" ? boundary.subagentRoot : void 0;
   if (!includeSubagents || !subagentRoot) return evidence;
-  let paths;
+  let paths2;
   try {
-    paths = await findSubagentFiles(subagentRoot);
+    paths2 = await findSubagentFiles(subagentRoot);
   } catch (error) {
     evidence.anomalies.push({
       code: "claude_subagent_root_unreadable",
@@ -789,7 +789,7 @@ async function collectClaudeTranscript(boundary, includeSubagents) {
     return evidence;
   }
   const offsets = isRecord(boundary.subagentOffsets) ? boundary.subagentOffsets : {};
-  for (const path of paths) {
+  for (const path of paths2) {
     const fileBoundary = subagentBoundary(offsets[path] ?? offsets[basename(path)]);
     const result = await readJsonlRange(
       path,
@@ -1291,7 +1291,7 @@ function groupMessages(job, evidence, anomalies) {
       });
       continue;
     }
-    const timestamp5 = asTimestamp(line.record.timestamp, job.startedAt);
+    const timestamp6 = asTimestamp(line.record.timestamp, job.startedAt);
     let group = groups.get(messageId);
     if (!group) {
       group = {
@@ -1301,14 +1301,14 @@ function groupMessages(job, evidence, anomalies) {
         sourcePath: line.sourcePath,
         isSubagent: line.isSubagent,
         promptId: targetPromptId,
-        startedAt: timestamp5,
-        endedAt: timestamp5,
+        startedAt: timestamp6,
+        endedAt: timestamp6,
         samples: [],
         blocks: []
       };
       groups.set(messageId, group);
     } else {
-      group.endedAt = timestamp5;
+      group.endedAt = timestamp6;
       if (typeof line.record.requestId === "string") {
         group.requestId = line.record.requestId;
       }
@@ -2299,9 +2299,9 @@ function stableHash(value) {
   return (hash >>> 0).toString(16).padStart(8, "0");
 }
 function observedAt(value) {
-  const timestamp5 = stringValue2(value);
-  if (!timestamp5 || Number.isNaN(Date.parse(timestamp5))) return void 0;
-  return timestamp5;
+  const timestamp6 = stringValue2(value);
+  if (!timestamp6 || Number.isNaN(Date.parse(timestamp6))) return void 0;
+  return timestamp6;
 }
 function captureOptions2(job) {
   return job.options?.enabled === true ? job.options.capture : DEFAULT_CAPTURE2;
@@ -2816,7 +2816,7 @@ function toSpan(job, candidate, modelId) {
   if (candidate.snapshotKey) {
     nativeIds2.usageSnapshotId = stableHash(candidate.snapshotKey);
   }
-  const timestamp5 = candidate.observedAt ?? job.startedAt;
+  const timestamp6 = candidate.observedAt ?? job.startedAt;
   return {
     spanId: `codex-llm-${stableHash(`${job.traceId}|${nativeRequestId}`)}`,
     traceId: job.traceId,
@@ -2827,8 +2827,8 @@ function toSpan(job, candidate, modelId) {
     name: "codex response",
     sequence: candidate.sequence,
     status: "completed",
-    startedAt: timestamp5,
-    endedAt: timestamp5,
+    startedAt: timestamp6,
+    endedAt: timestamp6,
     ...modelId ? { modelId } : {},
     inputRefs: [],
     outputRefs: [],
@@ -4378,9 +4378,9 @@ function eventTime(value) {
   }
   return void 0;
 }
-function withinTurn(timestamp5, job) {
-  if (!timestamp5) return false;
-  const at = Date.parse(timestamp5);
+function withinTurn(timestamp6, job) {
+  if (!timestamp6) return false;
+  const at = Date.parse(timestamp6);
   return at >= Date.parse(job.startedAt) - 5e3 && at <= Date.parse(job.endedAt) + 3e4;
 }
 function contentText2(value) {
@@ -5023,8 +5023,8 @@ function lineEvent(line) {
   return line.record.type === "context.append_loop_event" && isRecord7(line.record.event) ? line.record.event : void 0;
 }
 function withinTurn2(value, job) {
-  const timestamp5 = Date.parse(isoTime(value, ""));
-  return Number.isFinite(timestamp5) && timestamp5 >= Date.parse(job.startedAt) - 5e3 && timestamp5 <= Date.parse(job.endedAt) + 3e4;
+  const timestamp6 = Date.parse(isoTime(value, ""));
+  return Number.isFinite(timestamp6) && timestamp6 >= Date.parse(job.startedAt) - 5e3 && timestamp6 <= Date.parse(job.endedAt) + 3e4;
 }
 async function readJsonl2(sourcePath) {
   const raw = await readFile4(sourcePath, "utf8");
@@ -8059,7 +8059,7 @@ var DeepSeekHarnessAuditAdapter = class {
       const mapped = mapDshSessionEvent(event);
       const eventSessionId = String(event.sessionId ?? "");
       const isChild = !!eventSessionId && !!rootSessionId && eventSessionId !== rootSessionId;
-      const timestamp5 = iso(record4.at, job.startedAt);
+      const timestamp6 = iso(record4.at, job.startedAt);
       if (mapped.kind === "thinking") {
         if (capture.thinking && mapped.text) {
           addContent10(contents, { role: "thinking", format: "text", value: mapped.text, captureLevel: "runtime_exact" });
@@ -8134,9 +8134,9 @@ var DeepSeekHarnessAuditAdapter = class {
           continue;
         }
         tool.span.status = mapped.isError ? "failed" : "completed";
-        tool.span.endedAt = timestamp5;
+        tool.span.endedAt = timestamp6;
         const startMs = Date.parse(tool.span.startedAt);
-        const endMs = Date.parse(timestamp5);
+        const endMs = Date.parse(timestamp6);
         if (Number.isFinite(startMs) && Number.isFinite(endMs)) {
           tool.span.durationMs = Math.max(0, endMs - startMs);
         }
@@ -8234,7 +8234,7 @@ function turnSpan(job, spanId) {
   };
 }
 function simpleSpan(job, parentSpanId, sequence, kind, name, at, nativeIds2) {
-  const timestamp5 = iso(at, job.startedAt);
+  const timestamp6 = iso(at, job.startedAt);
   return {
     spanId: `deepseek-harness:${job.turnId}:${sequence}`,
     traceId: job.traceId,
@@ -8245,8 +8245,8 @@ function simpleSpan(job, parentSpanId, sequence, kind, name, at, nativeIds2) {
     name,
     sequence,
     status: "completed",
-    startedAt: timestamp5,
-    endedAt: timestamp5,
+    startedAt: timestamp6,
+    endedAt: timestamp6,
     inputRefs: [],
     outputRefs: [],
     provider: { provider: "deepseek-harness", nativeEventType: name, nativeIds: nativeIds2 },
@@ -8306,6 +8306,387 @@ function usageSpan(job, parentSpanId, sequence, at, raw, requestId2, modelId, pr
 
 // src/audit/adapters/agy/agy-audit-adapter.ts
 import { readFile as readFile5 } from "node:fs/promises";
+
+// src/audit/adapters/agy/agy-gen-metadata.ts
+import { homedir as homedir4 } from "node:os";
+import { join as join6 } from "node:path";
+
+// src/core/util/sqlite-reader.ts
+import { createRequire } from "node:module";
+
+// src/core/log/logger.ts
+import { createWriteStream, mkdirSync, existsSync, readdirSync, statSync, unlinkSync } from "node:fs";
+import { join as join5 } from "node:path";
+
+// src/core/config/paths.ts
+import { join as join4 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+var GRIX_HOME_ENV = "GRIX_CONNECTOR_HOME";
+var DEFAULT_GRIX_HOME = join4(homedir3(), ".grix");
+function resolveRuntimePaths(runtimeDir) {
+  const rootDir = runtimeDir ? runtimeDir : process.env[GRIX_HOME_ENV] ? process.env[GRIX_HOME_ENV] : DEFAULT_GRIX_HOME;
+  return {
+    rootDir,
+    configDir: join4(rootDir, "config"),
+    logDir: join4(rootDir, "log"),
+    dataDir: join4(rootDir, "data"),
+    serviceDir: join4(rootDir, "service"),
+    skillsDir: join4(rootDir, "skills"),
+    stateFile: join4(rootDir, "service.json"),
+    pidFile: join4(rootDir, "grix-connector.pid"),
+    daemonLockFile: join4(rootDir, "daemon.lock.json"),
+    daemonStatusFile: join4(rootDir, "daemon-status.json"),
+    stdoutLogFile: join4(rootDir, "service", "daemon.out.log"),
+    stderrLogFile: join4(rootDir, "service", "daemon.err.log"),
+    contextsDir: join4(rootDir, "data", "session-contexts"),
+    hookSignalsPath: join4(rootDir, "data", "hook-signals.json"),
+    hookSignalsLogPath: join4(rootDir, "log", "hook-signals.log"),
+    elicitationRequestsDir: join4(rootDir, "data", "elicitation-requests"),
+    eventStatesDir: join4(rootDir, "data", "event-states"),
+    questionRequestsDir: join4(rootDir, "data", "question-requests"),
+    permissionRequestsDir: join4(rootDir, "data", "permission-requests"),
+    agentGlobalConfigsFile: join4(rootDir, "data", "agent-global-configs.json")
+  };
+}
+
+// src/core/log/logger.ts
+var paths = resolveRuntimePaths();
+var GRIX_PATHS = {
+  base: paths.rootDir,
+  config: paths.configDir,
+  log: paths.logDir,
+  data: paths.dataDir,
+  skills: paths.skillsDir
+};
+var LEVEL_PRIORITY = {
+  trace: 0,
+  debug: 1,
+  info: 2,
+  warn: 3,
+  error: 4
+};
+function parseLevel(raw, fallback) {
+  if (!raw) return fallback;
+  const lower = raw.trim().toLowerCase();
+  return lower in LEVEL_PRIORITY ? lower : fallback;
+}
+function parseTagOverrides(env) {
+  const map = /* @__PURE__ */ new Map();
+  if (!env) return map;
+  for (const pair of env.split(",")) {
+    const eq = pair.indexOf("=");
+    if (eq < 0) continue;
+    const tag = pair.slice(0, eq).trim();
+    const level = parseLevel(pair.slice(eq + 1), "info");
+    if (tag) map.set(tag, level);
+  }
+  return map;
+}
+var globalLevel = parseLevel(process.env.GRIX_CONNECTOR_LOG_LEVEL, "info");
+var tagOverrides = parseTagOverrides(process.env.GRIX_CONNECTOR_LOG_TAG_LEVELS);
+function effectiveLevel(tag) {
+  return tagOverrides.get(tag) ?? globalLevel;
+}
+function shouldLog(tag, level) {
+  return LEVEL_PRIORITY[level] >= LEVEL_PRIORITY[effectiveLevel(tag)];
+}
+var logStream = null;
+var currentLogDate = "";
+var LOG_RETENTION_DAYS_ENV = "GRIX_CONNECTOR_LOG_RETENTION_DAYS";
+var DEFAULT_LOG_RETENTION_DAYS = 14;
+function resolveRetentionDays() {
+  const raw = process.env[LOG_RETENTION_DAYS_ENV];
+  const n2 = raw ? Number.parseInt(raw, 10) : Number.NaN;
+  return Number.isFinite(n2) && n2 > 0 ? n2 : DEFAULT_LOG_RETENTION_DAYS;
+}
+function currentDate() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function cleanupOldLogs() {
+  const cutoff = Date.now() - resolveRetentionDays() * 24 * 60 * 60 * 1e3;
+  let entries;
+  try {
+    entries = readdirSync(GRIX_PATHS.log);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (!name.startsWith("grix-connector-") || !name.includes(".log")) continue;
+    const full = join5(GRIX_PATHS.log, name);
+    try {
+      if (statSync(full).mtimeMs < cutoff) unlinkSync(full);
+    } catch {
+    }
+  }
+}
+function openLogStream(date) {
+  try {
+    logStream?.end();
+  } catch {
+  }
+  const logFile = join5(GRIX_PATHS.log, `grix-connector-${date}.log`);
+  logStream = createWriteStream(logFile, { flags: "a" });
+  currentLogDate = date;
+  cleanupOldLogs();
+}
+function timestamp4() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
+}
+var consoleEnabled = true;
+function emitConsole(level, line) {
+  if (!consoleEnabled) return;
+  if (level === "warn") console.warn(line);
+  else if (level === "error") console.error(line);
+  else console.log(line);
+}
+function safeWrite(line) {
+  try {
+    const date = currentDate();
+    if (date !== currentLogDate) openLogStream(date);
+    logStream?.write(line);
+  } catch {
+  }
+}
+function formatLine(level, tag, msg, args) {
+  const levelStr = level === "info" ? "" : `${level.toUpperCase()} `;
+  return `${timestamp4()} [${tag}] ${levelStr}${msg}${args.length ? " " + args.map(String).join(" ") : ""}`;
+}
+var log = {
+  trace(tag, msg, ...args) {
+    if (!shouldLog(tag, "trace")) return;
+    const line = formatLine("trace", tag, msg, args);
+    emitConsole("trace", line);
+    safeWrite(line + "\n");
+  },
+  debug(tag, msg, ...args) {
+    if (!shouldLog(tag, "debug")) return;
+    const line = formatLine("debug", tag, msg, args);
+    emitConsole("debug", line);
+    safeWrite(line + "\n");
+  },
+  info(tag, msg, ...args) {
+    if (!shouldLog(tag, "info")) return;
+    const line = formatLine("info", tag, msg, args);
+    emitConsole("info", line);
+    safeWrite(line + "\n");
+  },
+  warn(tag, msg, ...args) {
+    if (!shouldLog(tag, "warn")) return;
+    const line = formatLine("warn", tag, msg, args);
+    emitConsole("warn", line);
+    safeWrite(line + "\n");
+  },
+  error(tag, msg, ...args) {
+    if (!shouldLog(tag, "error")) return;
+    const line = formatLine("error", tag, msg, args);
+    emitConsole("error", line);
+    safeWrite(line + "\n");
+  }
+};
+
+// src/core/log/rotation.ts
+var DEFAULT_LOG_MAX_BYTES = 10 * 1024 * 1024;
+
+// src/core/log/packet-log.ts
+var DEFAULT_MAX_BYTES = 128 * 1024 * 1024;
+
+// src/core/util/sqlite-reader.ts
+var cachedCtor;
+function loadDatabaseSync() {
+  if (cachedCtor !== void 0) return cachedCtor;
+  try {
+    const require2 = createRequire(import.meta.url);
+    cachedCtor = require2("node:sqlite").DatabaseSync;
+  } catch {
+    cachedCtor = null;
+    log.warn(
+      "sqlite-reader",
+      `node:sqlite unavailable on Node ${process.version}; sessions stored in sqlite (cursor/opencode) will not be listed`
+    );
+  }
+  return cachedCtor;
+}
+function openReadOnlyDatabase(dbPath) {
+  const DatabaseSync = loadDatabaseSync();
+  if (!DatabaseSync) return null;
+  try {
+    const db = new DatabaseSync(dbPath, { readOnly: true });
+    return {
+      all(sql, ...params) {
+        return db.prepare(sql).all(...params);
+      },
+      close() {
+        try {
+          db.close();
+        } catch {
+        }
+      }
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/audit/adapters/agy/agy-gen-metadata.ts
+function resolveAgyAntigravityHome() {
+  return process.env.GRIX_AGY_ANTIGRAVITY_HOME ?? join6(homedir4(), ".gemini", "antigravity-cli");
+}
+function extractAgyResponseIds(logExcerpt) {
+  const ids = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const line of logExcerpt.split(/\r?\n/)) {
+    if (!line.includes("streamGenerateContent")) continue;
+    const match = /ResponseID: (\S+)/.exec(line);
+    if (!match) continue;
+    const id = match[1];
+    if (!seen.has(id)) {
+      seen.add(id);
+      ids.push(id);
+    }
+  }
+  return ids;
+}
+function readVarint(buf, pos) {
+  let value = 0n;
+  let shift = 0n;
+  let cursor = pos;
+  for (; ; ) {
+    if (cursor >= buf.length || shift > 63n) throw new Error("bad varint");
+    const byte = buf[cursor];
+    value |= BigInt(byte & 127) << shift;
+    cursor += 1;
+    if ((byte & 128) === 0) return { value, next: cursor };
+    shift += 7n;
+  }
+}
+function parseProtoFields(buf) {
+  const fields = [];
+  let pos = 0;
+  while (pos < buf.length) {
+    const tag = readVarint(buf, pos);
+    pos = tag.next;
+    const field2 = Number(tag.value >> 3n);
+    const wire = Number(tag.value & 0x7n);
+    if (field2 <= 0) throw new Error("bad field number");
+    if (wire === 0) {
+      const v = readVarint(buf, pos);
+      pos = v.next;
+      fields.push({ field: field2, wire, varint: v.value });
+    } else if (wire === 2) {
+      const len = readVarint(buf, pos);
+      pos = len.next;
+      const end = pos + Number(len.value);
+      if (end > buf.length) throw new Error("bad length");
+      fields.push({ field: field2, wire, bytes: buf.subarray(pos, end) });
+      pos = end;
+    } else if (wire === 5) {
+      pos += 4;
+      if (pos > buf.length) throw new Error("bad fixed32");
+    } else if (wire === 1) {
+      pos += 8;
+      if (pos > buf.length) throw new Error("bad fixed64");
+    } else {
+      throw new Error(`unsupported wire type ${wire}`);
+    }
+  }
+  return fields;
+}
+function firstMessage(fields, fieldNumber) {
+  const field2 = fields.find((item) => item.field === fieldNumber && item.wire === 2);
+  if (!field2?.bytes) return void 0;
+  try {
+    return parseProtoFields(field2.bytes);
+  } catch {
+    return void 0;
+  }
+}
+function firstVarint(fields, fieldNumber) {
+  const field2 = fields.find((item) => item.field === fieldNumber && item.wire === 0);
+  if (field2?.varint === void 0) return void 0;
+  if (field2.varint < 0n || field2.varint > 0xffffffffn) return void 0;
+  return Number(field2.varint);
+}
+var RESPONSE_ID_PATTERN = /^[\x21-\x7e]{8,64}$/;
+function tryDecodeUtf8(bytes) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return void 0;
+  }
+}
+function firstString(fields, fieldNumber, pattern) {
+  const field2 = fields.find((item) => item.field === fieldNumber && item.wire === 2);
+  if (!field2?.bytes) return void 0;
+  const value = tryDecodeUtf8(field2.bytes);
+  if (value === void 0) return void 0;
+  if (pattern && !pattern.test(value)) return void 0;
+  return value;
+}
+function decodeAgyGenMetadata(data) {
+  try {
+    const top = parseProtoFields(data);
+    const record4 = firstMessage(top, 1);
+    if (!record4) return void 0;
+    const usage = firstMessage(record4, 4);
+    if (!usage) return void 0;
+    const responseId = firstString(usage, 11, RESPONSE_ID_PATTERN);
+    if (!responseId) return void 0;
+    return {
+      responseId,
+      inputTokens: firstVarint(usage, 2),
+      outputTokens: firstVarint(usage, 3),
+      model: firstString(record4, 19)
+    };
+  } catch {
+    return void 0;
+  }
+}
+var SAFE_CONVERSATION_ID = /^[a-zA-Z0-9._-]+$/;
+function readAgyTurnUsage(conversationId, responseIds) {
+  if (!SAFE_CONVERSATION_ID.test(conversationId) || responseIds.length === 0) {
+    return null;
+  }
+  const dbPath = join6(
+    resolveAgyAntigravityHome(),
+    "conversations",
+    `${conversationId}.db`
+  );
+  const db = openReadOnlyDatabase(dbPath);
+  if (!db) return null;
+  try {
+    const wanted = new Set(responseIds);
+    const rows = db.all(
+      "SELECT idx, data FROM gen_metadata"
+    );
+    const byResponseId = /* @__PURE__ */ new Map();
+    let model;
+    for (const row of rows) {
+      if (!(row.data instanceof Uint8Array)) continue;
+      const decoded = decodeAgyGenMetadata(row.data);
+      if (!decoded || !wanted.has(decoded.responseId)) continue;
+      const existing = byResponseId.get(decoded.responseId);
+      if (existing && existing.idx >= row.idx) continue;
+      byResponseId.set(decoded.responseId, {
+        idx: row.idx,
+        responseId: decoded.responseId,
+        inputTokens: decoded.inputTokens ?? null,
+        outputTokens: decoded.outputTokens ?? null
+      });
+      model ??= decoded.model;
+    }
+    if (byResponseId.size === 0) return null;
+    const records = Array.from(byResponseId.values()).sort(
+      (left, right) => left.idx - right.idx
+    );
+    return { records, ...model ? { model } : {} };
+  } catch {
+    return null;
+  } finally {
+    db.close();
+  }
+}
+
+// src/audit/adapters/agy/agy-audit-adapter.ts
 var DEFAULT_CAPTURE11 = Object.freeze({
   inputOutput: true,
   tools: true,
@@ -8339,7 +8720,7 @@ function append5(target, reference) {
     target.push(reference);
   }
 }
-function timestamp4(value, fallback) {
+function timestamp5(value, fallback) {
   return typeof value === "string" && Number.isFinite(Date.parse(value)) ? value : fallback;
 }
 function makeSpan8(input) {
@@ -8392,6 +8773,51 @@ function parseToolInvocation(value) {
     ...typeof value.completedAt === "string" ? { completedAt: value.completedAt } : {}
   };
 }
+function agyUsage(evidence) {
+  const records = evidence.usageRecords;
+  if (!records || records.length === 0) return void 0;
+  let input = 0;
+  let output = 0;
+  for (const record4 of records) {
+    input += record4.inputTokens ?? 0;
+    output += record4.outputTokens ?? 0;
+  }
+  const hasNullTokenRecord = records.some(
+    (record4) => record4.inputTokens === null && record4.outputTokens === null
+  );
+  const complete = evidence.usageExpectedCount !== void 0 && records.length === evidence.usageExpectedCount && !hasNullTokenRecord;
+  return {
+    input: {
+      total: input,
+      uncached: null,
+      cacheRead: null,
+      cacheWrite: null,
+      other: null
+    },
+    output: {
+      total: output,
+      reasoning: null,
+      visible: null
+    },
+    totalProcessed: input + output,
+    requestCount: records.length,
+    accuracy: "provider_reported",
+    completeness: complete ? "complete" : "partial",
+    provider: "agy",
+    providerUsageRaw: records,
+    normalization: {
+      adapter: "agy-gen-metadata",
+      version: 1,
+      formula: "sum of per-generation input_tokens/output_tokens from the agy conversation sqlite gen_metadata table, matched to this turn by streamGenerateContent ResponseID"
+    }
+  };
+}
+function agyUsageGapDetail(evidence) {
+  if (evidence.usageExpectedCount === void 0) {
+    return "agy gen_metadata extraction skipped: conversation id or streamGenerateContent log excerpt unavailable";
+  }
+  return `agy gen_metadata extraction found no matching rows for ${evidence.usageExpectedCount} ResponseID(s)`;
+}
 var AgyAuditAdapter = class {
   provider = "agy";
   async collect(job) {
@@ -8465,6 +8891,16 @@ var AgyAuditAdapter = class {
         });
       }
     }
+    const conversationId = stringValue10(job.boundary.providerSessionId);
+    const responseIds = evidence.logExcerpt ? extractAgyResponseIds(evidence.logExcerpt) : [];
+    if (conversationId && responseIds.length > 0) {
+      evidence.usageExpectedCount = responseIds.length;
+      const usage = readAgyTurnUsage(conversationId, responseIds);
+      if (usage) {
+        evidence.usageRecords = usage.records;
+        if (usage.model) evidence.usageModel = usage.model;
+      }
+    }
     return evidence;
   }
   async normalize(job, rawEvidence) {
@@ -8558,8 +8994,8 @@ var AgyAuditAdapter = class {
           name: invocation.action,
           sequence: sequence++,
           status: invocation.error ? "failed" : invocation.completedAt ? "completed" : "running",
-          startedAt: timestamp4(invocation.observedAt, job.startedAt),
-          endedAt: timestamp4(invocation.completedAt, job.endedAt),
+          startedAt: timestamp5(invocation.observedAt, job.startedAt),
+          endedAt: timestamp5(invocation.completedAt, job.endedAt),
           nativeEventType: "grix_tool_invoke",
           nativeIds: { toolSequence: String(invocation.sequence) },
           rawAttributes: { toolInvocation: invocation }
@@ -8584,11 +9020,17 @@ var AgyAuditAdapter = class {
         spans.push(tool);
       }
     }
-    collection.gaps.push({
-      category: "provider_usage",
-      reason: "provider_usage_missing",
-      detail: "agy print mode does not report token usage"
-    });
+    const usage = agyUsage(collection);
+    if (usage) {
+      request.usage = usage;
+      if (collection.usageModel) request.modelId = collection.usageModel;
+    } else {
+      collection.gaps.push({
+        category: "provider_usage",
+        reason: "provider_usage_missing",
+        detail: agyUsageGapDetail(collection)
+      });
+    }
     return {
       spans,
       contents,
@@ -8609,7 +9051,7 @@ var AgyAuditAdapter = class {
     const inputComplete = !evidence.capture.inputOutput || job.input !== void 0 || evidence.collection.prompt !== void 0;
     const outputComplete = !evidence.capture.inputOutput || job.finalOutput !== void 0 || requests.some((request) => request.outputRefs.length > 0);
     const toolCallsComplete = !evidence.capture.tools || tools.every((tool) => tool.status !== "running");
-    const usageComplete = false;
+    const usageComplete = requests.length > 0 && requests.every((request) => request.usage?.completeness === "complete");
     const gaps = [...evidence.collection.gaps];
     if (evidence.capture.rawProviderBody) {
       gaps.push({
@@ -8634,7 +9076,7 @@ var AgyAuditAdapter = class {
 
 // src/audit/adapters/openclaw/openclaw-audit-adapter.ts
 import { readFile as readFile6, readdir as readdir4, stat as stat7 } from "node:fs/promises";
-import { basename as basename6, dirname as dirname2, join as join4 } from "node:path";
+import { basename as basename6, dirname as dirname2, join as join7 } from "node:path";
 function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -8661,7 +9103,7 @@ async function resolveResetTranscriptPath(transcriptPath, expectedIdentity) {
     const prefix = `${basename6(transcriptPath)}.reset`;
     const candidates = (await readdir4(directory)).filter((entry) => entry.startsWith(prefix)).sort().reverse();
     for (const entry of candidates) {
-      const candidate = join4(directory, entry);
+      const candidate = join7(directory, entry);
       if (await fileIdentity(candidate) === expectedIdentity) return candidate;
     }
   } catch {
@@ -8676,7 +9118,7 @@ async function resolveCurrentTranscriptPath(boundary) {
     const parsed = JSON.parse(await readFile6(storePath, "utf8"));
     if (!isRecord15(parsed) || !isRecord15(parsed[sessionKey])) return void 0;
     const session = parsed[sessionKey];
-    return typeof session.sessionFile === "string" ? session.sessionFile : typeof session.sessionId === "string" ? join4(dirname2(storePath), `${session.sessionId}.jsonl`) : void 0;
+    return typeof session.sessionFile === "string" ? session.sessionFile : typeof session.sessionId === "string" ? join7(dirname2(storePath), `${session.sessionId}.jsonl`) : void 0;
   } catch {
     return void 0;
   }
@@ -8784,7 +9226,7 @@ import {
   rm,
   writeFile
 } from "node:fs/promises";
-import { basename as basename7, dirname as dirname3, join as join5, relative, resolve as resolve3, sep as sep3 } from "node:path";
+import { basename as basename7, dirname as dirname3, join as join8, relative, resolve as resolve3, sep as sep3 } from "node:path";
 var SHA256_PATTERN = /^[a-f0-9]{64}$/;
 var NO_CAPTURE = Object.freeze({
   inputOutput: false,
@@ -8877,7 +9319,7 @@ var FileAuditReplayStore = class {
     const replaySha256 = sha256(replayBytes);
     const auditKey = idKey(replay.auditId);
     const turnKey = idKey(replay.turnId);
-    const replayPath = join5(
+    const replayPath = join8(
       this.rootDir,
       "replays",
       auditKey,
@@ -8943,7 +9385,7 @@ var FileAuditReplayStore = class {
     return this.readReplay(manifest);
   }
   async findByAuditId(auditId) {
-    const directory = join5(
+    const directory = join8(
       this.rootDir,
       "manifests",
       "by-audit",
@@ -8952,7 +9394,7 @@ var FileAuditReplayStore = class {
     const names = await readDirectory(directory);
     const replays = [];
     for (const name of names.filter((item) => item.endsWith(".json")).sort()) {
-      const manifest = await this.readManifest(join5(directory, name));
+      const manifest = await this.readManifest(join8(directory, name));
       if (!manifest || manifest.auditId !== auditId || manifestExpired(manifest)) {
         continue;
       }
@@ -8961,7 +9403,7 @@ var FileAuditReplayStore = class {
     return sortReplays(replays);
   }
   async findByTurnId(turnId) {
-    const directory = join5(
+    const directory = join8(
       this.rootDir,
       "indexes",
       "by-turn",
@@ -8970,7 +9412,7 @@ var FileAuditReplayStore = class {
     const names = await readDirectory(directory);
     const replays = [];
     for (const name of names.filter((item) => item.endsWith(".json")).sort()) {
-      const entry = await this.readIndex(join5(directory, name));
+      const entry = await this.readIndex(join8(directory, name));
       if (!entry || entry.turnId !== turnId) continue;
       const manifestPath = this.resolveStoredPath(entry.manifestPath);
       const manifest = await this.readManifest(manifestPath);
@@ -9083,13 +9525,13 @@ var FileAuditReplayStore = class {
     await mkdir(this.rootDir, { recursive: true, mode: 448 });
   }
   async currentManifests() {
-    const root = join5(this.rootDir, "manifests", "by-audit");
+    const root = join8(this.rootDir, "manifests", "by-audit");
     const manifests = [];
     for (const auditKey of await readDirectory(root)) {
-      const directory = join5(root, auditKey);
+      const directory = join8(root, auditKey);
       for (const name of await readDirectory(directory)) {
         if (!name.endsWith(".json")) continue;
-        const path = join5(directory, name);
+        const path = join8(directory, name);
         const manifest = await this.readManifest(path);
         if (manifest) manifests.push({ path, manifest });
       }
@@ -9097,7 +9539,7 @@ var FileAuditReplayStore = class {
     return manifests;
   }
   async revisionManifests(manifest) {
-    const directory = join5(
+    const directory = join8(
       this.rootDir,
       "manifests",
       "revisions",
@@ -9107,7 +9549,7 @@ var FileAuditReplayStore = class {
     const revisions = [];
     for (const name of await readDirectory(directory)) {
       if (!name.endsWith(".json")) continue;
-      const revision = await this.readManifest(join5(directory, name));
+      const revision = await this.readManifest(join8(directory, name));
       if (revision) revisions.push(revision);
     }
     return revisions;
@@ -9119,14 +9561,14 @@ var FileAuditReplayStore = class {
       rm(this.manifestPath(manifest.auditId, manifest.turnId), {
         force: true
       }),
-      rm(join5(
+      rm(join8(
         this.rootDir,
         "manifests",
         "revisions",
         auditKey,
         turnKey
       ), { recursive: true, force: true }),
-      rm(join5(this.rootDir, "replays", auditKey, turnKey), {
+      rm(join8(this.rootDir, "replays", auditKey, turnKey), {
         recursive: true,
         force: true
       }),
@@ -9180,7 +9622,7 @@ var FileAuditReplayStore = class {
   async atomicWrite(path, body) {
     const directory = dirname3(path);
     await mkdir(directory, { recursive: true, mode: 448 });
-    const temporary = join5(
+    const temporary = join8(
       directory,
       `.${basename7(path)}.${process.pid}.${randomUUID()}.tmp`
     );
@@ -9192,7 +9634,7 @@ var FileAuditReplayStore = class {
     }
   }
   manifestPath(auditId, turnId) {
-    return join5(
+    return join8(
       this.rootDir,
       "manifests",
       "by-audit",
@@ -9201,7 +9643,7 @@ var FileAuditReplayStore = class {
     );
   }
   revisionManifestPath(auditId, turnId, revision) {
-    return join5(
+    return join8(
       this.rootDir,
       "manifests",
       "revisions",
@@ -9211,7 +9653,7 @@ var FileAuditReplayStore = class {
     );
   }
   turnIndexPath(turnId, auditId) {
-    return join5(
+    return join8(
       this.rootDir,
       "indexes",
       "by-turn",
@@ -9220,7 +9662,7 @@ var FileAuditReplayStore = class {
     );
   }
   blobPath(contentId) {
-    return join5(
+    return join8(
       this.rootDir,
       "blobs",
       "sha256",