vibeusage 0.3.1 → 0.3.2

package/src/lib/openclaw-session-plugin.js

@@ -3,6 +3,7 @@ const path = require("node:path");
 const fs = require("node:fs/promises");
 const fssync = require("node:fs");
 const cp = require("node:child_process");
+const { pathToFileURL } = require("node:url");
 
 const OPENCLAW_SESSION_PLUGIN_ID = "openclaw-session-sync";
 const OPENCLAW_SESSION_PLUGIN_DIRNAME = "openclaw-plugin";
@@ -103,7 +104,6 @@ async function ensureOpenclawSessionPluginFiles({
     buildSessionPluginIndex({
       trackerDir,
       packageName,
-      openclawHome: openclawHome || path.join(os.homedir(), ".openclaw"),
     }),
     "utf8",
   );
@@ -337,144 +337,58 @@ function buildSessionPluginMeta() {
   )}\n`;
 }
 
-function buildSessionPluginIndex({ trackerDir, packageName = "vibeusage", openclawHome }) {
-  const trackerBinPath = path.join(trackerDir, "app", "bin", "tracker.js");
-  const fallbackPkg = packageName || "vibeusage";
-  const safeOpenclawHome = openclawHome || path.join(os.homedir(), ".openclaw");
+function buildSessionPluginIndex({ trackerDir }) {
+  const ledgerModuleUrl = pathToFileURL(
+    path.join(trackerDir, "app", "src", "lib", "openclaw-usage-ledger.js"),
+  ).href;
 
   return (
-    `import fs from 'node:fs';\n` +
-    `import path from 'node:path';\n` +
-    `import cp from 'node:child_process';\n` +
+    `import { appendOpenclawUsageEvent } from ${JSON.stringify(ledgerModuleUrl)};\n` +
     `\n` +
     `const trackerDir = ${JSON.stringify(trackerDir)};\n` +
-    `const trackerBinPath = ${JSON.stringify(trackerBinPath)};\n` +
-    `const fallbackPkg = ${JSON.stringify(fallbackPkg)};\n` +
-    `const openclawHome = ${JSON.stringify(safeOpenclawHome)};\n` +
-    `const depsMarkerPath = path.join(trackerDir, 'app', 'node_modules', '@insforge', 'sdk', 'package.json');\n` +
-    `const triggerStatePath = path.join(trackerDir, 'openclaw.session-sync.trigger-state.json');\n` +
-    `const SESSION_TRIGGER_THROTTLE_MS = 15_000;\n` +
     `\n` +
     `export default function register(api) {\n` +
-    `  api.on('agent_end', async (_event, ctx) => {\n` +
+    `  api.on('llm_output', async (event, ctx) => {\n` +
     `    try {\n` +
-    `      const sessionKey = normalize(ctx && ctx.sessionKey);\n` +
-    `      if (!sessionKey) return;\n` +
-    `\n` +
-    `      const agentId = normalize(ctx && ctx.agentId) || parseAgentId(sessionKey);\n` +
-    `      if (!agentId) return;\n` +
-    `\n` +
-    `      const sessionInfo = resolveSessionInfo(agentId, sessionKey);\n` +
-    `      const sessionId = normalize(sessionInfo && sessionInfo.sessionId);\n` +
-    `      if (!sessionId) return;\n` +
-    `\n` +
-    `      if (!allowTrigger('agent_end', agentId, sessionId)) return;\n` +
-    `\n` +
-    `      spawnSync({\n` +
-    `        args: ['sync', '--auto', '--from-openclaw'],\n` +
-    `        env: buildSessionEnv({\n` +
-    `          agentId,\n` +
-    `          sessionId,\n` +
-    `          sessionKey,\n` +
-    `          sessionEntry: sessionInfo && sessionInfo.entry\n` +
-    `        })\n` +
-    `      });\n` +
-    `    } catch (_) {}\n` +
-    `  });\n` +
-    `\n` +
-    `  api.on('gateway_start', async () => {\n` +
-    `    try {\n` +
-    `      if (!allowTrigger('gateway_start', 'gateway', 'startup')) return;\n` +
-    `      spawnSync({ args: ['sync', '--auto'] });\n` +
-    `    } catch (_) {}\n` +
-    `  });\n` +
-    `\n` +
-    `  api.on('gateway_stop', async () => {\n` +
-    `    try {\n` +
-    `      if (!allowTrigger('gateway_stop', 'gateway', 'stop')) return;\n` +
-    `      spawnSync({ args: ['sync', '--auto'] });\n` +
+    `      const payload = buildPayload(event, ctx);\n` +
+    `      if (!payload) return;\n` +
+    `      await appendOpenclawUsageEvent({ trackerDir, payload });\n` +
     `    } catch (_) {}\n` +
     `  });\n` +
     `}\n` +
     `\n` +
-    `function spawnSync({ args, env = {} }) {\n` +
-    `  const hasLocalRuntime = fs.existsSync(trackerBinPath);\n` +
-    `  const hasLocalDeps = fs.existsSync(depsMarkerPath);\n` +
-    `  const argv = Array.isArray(args) && args.length > 0 ? args : ['sync', '--auto'];\n` +
-    `  const cmd = hasLocalRuntime && hasLocalDeps\n` +
-    `    ? [process.execPath, trackerBinPath, ...argv]\n` +
-    `    : ['npx', '--yes', fallbackPkg, ...argv];\n` +
-    `  const child = cp.spawn(cmd[0], cmd.slice(1), {\n` +
-    `    detached: true,\n` +
-    `    stdio: 'ignore',\n` +
-    `    env: { ...process.env, ...env }\n` +
-    `  });\n` +
-    `  child.unref();\n` +
-    `}\n` +
-    `\n` +
-    `function buildSessionEnv({ agentId, sessionId, sessionKey, sessionEntry }) {\n` +
-    `  const out = {\n` +
-    `    VIBEUSAGE_OPENCLAW_AGENT_ID: agentId,\n` +
-    `    VIBEUSAGE_OPENCLAW_PREV_SESSION_ID: sessionId,\n` +
-    `    VIBEUSAGE_OPENCLAW_HOME: openclawHome\n` +
-    `  };\n` +
-    `  const key = normalize(sessionKey);\n` +
-    `  if (key) out.VIBEUSAGE_OPENCLAW_SESSION_KEY = key;\n` +
-    `  const prevTotalTokens = toNonNegativeInt(sessionEntry && sessionEntry.totalTokens);\n` +
-    `  const prevInputTokens = toNonNegativeInt(sessionEntry && sessionEntry.inputTokens);\n` +
-    `  const prevOutputTokens = toNonNegativeInt(sessionEntry && sessionEntry.outputTokens);\n` +
-    `  const prevModel = normalize(sessionEntry && sessionEntry.model);\n` +
-    `  const prevUpdatedAt = toIso(sessionEntry && sessionEntry.updatedAt);\n` +
-    `  if (prevTotalTokens != null) out.VIBEUSAGE_OPENCLAW_PREV_TOTAL_TOKENS = String(prevTotalTokens);\n` +
-    `  if (prevInputTokens != null) out.VIBEUSAGE_OPENCLAW_PREV_INPUT_TOKENS = String(prevInputTokens);\n` +
-    `  if (prevOutputTokens != null) out.VIBEUSAGE_OPENCLAW_PREV_OUTPUT_TOKENS = String(prevOutputTokens);\n` +
-    `  if (prevModel) out.VIBEUSAGE_OPENCLAW_PREV_MODEL = prevModel;\n` +
-    `  if (prevUpdatedAt) out.VIBEUSAGE_OPENCLAW_PREV_UPDATED_AT = prevUpdatedAt;\n` +
-    `  return out;\n` +
-    `}\n` +
+    `function buildPayload(event, ctx) {\n` +
+    `  const usage = normalizeUsage(event);\n` +
+    `  if (!usage) return null;\n` +
     `\n` +
-    `function resolveSessionInfo(agentId, sessionKey) {\n` +
-    `  const key = normalize(sessionKey);\n` +
-    `  if (!key) return null;\n` +
-    `  const sessionsPath = path.join(openclawHome, 'agents', agentId, 'sessions', 'sessions.json');\n` +
-    `  try {\n` +
-    `    const raw = fs.readFileSync(sessionsPath, 'utf8');\n` +
-    `    const parsed = JSON.parse(raw);\n` +
-    `    if (!parsed || typeof parsed !== 'object') return null;\n` +
-    `    const entry = parsed[key];\n` +
-    `    if (!entry || typeof entry !== 'object') return null;\n` +
-    `    return {\n` +
-    `      sessionKey: key,\n` +
-    `      sessionId: normalize(entry.sessionId),\n` +
-    `      entry\n` +
-    `    };\n` +
-    `  } catch (_) {}\n` +
-    `  return null;\n` +
-    `}\n` +
+    `  const sessionKey = normalize(ctx && ctx.sessionKey);\n` +
+    `  if (!sessionKey) return null;\n` +
     `\n` +
-    `function parseAgentId(sessionKey) {\n` +
-    `  const s = normalize(sessionKey);\n` +
-    `  if (!s || !s.startsWith('agent:')) return null;\n` +
-    `  const parts = s.split(':');\n` +
-    `  return parts.length >= 2 ? normalize(parts[1]) : null;\n` +
+    `  return {\n` +
+    `    emittedAt: normalizeIso(event && (event.emittedAt || event.timestamp)) || new Date().toISOString(),\n` +
+    `    source: 'openclaw',\n` +
+    `    agentId: normalize(ctx && ctx.agentId),\n` +
+    `    sessionKey,\n` +
+    `    provider: normalize(event && event.provider) || normalize(ctx && ctx.provider),\n` +
+    `    model: normalize(event && event.model) || normalize(ctx && ctx.model),\n` +
+    `    channel: normalize(ctx && ctx.channel),\n` +
+    `    chatType: normalize(ctx && ctx.chatType),\n` +
+    `    trigger: normalize(ctx && ctx.trigger) || 'llm_output',\n` +
+    `    ...usage\n` +
+    `  };\n` +
     `}\n` +
     `\n` +
-    `function allowTrigger(kind, scope, target) {\n` +
-    `  const key = [kind, scope || 'na', target || 'na'].join(':');\n` +
-    `  const now = Date.now();\n` +
-    `  let state = {};\n` +
-    `  try {\n` +
-    `    state = JSON.parse(fs.readFileSync(triggerStatePath, 'utf8'));\n` +
-    `    if (!state || typeof state !== 'object') state = {};\n` +
-    `  } catch (_) {}\n` +
-    `  const last = Number(state[key] || 0);\n` +
-    `  if (Number.isFinite(last) && now - last < SESSION_TRIGGER_THROTTLE_MS) return false;\n` +
-    `  state[key] = now;\n` +
-    `  try {\n` +
-    `    fs.mkdirSync(path.dirname(triggerStatePath), { recursive: true });\n` +
-    `    fs.writeFileSync(triggerStatePath, JSON.stringify(state), 'utf8');\n` +
-    `  } catch (_) {}\n` +
-    `  return true;\n` +
+    `function normalizeUsage(event) {\n` +
+    `  const usage = event && typeof event.usage === 'object' ? event.usage : event || {};\n` +
+    `  const normalized = {\n` +
+    `    inputTokens: toNonNegativeInt(usage.inputTokens ?? usage.input_tokens ?? usage.input),\n` +
+    `    cachedInputTokens: toNonNegativeInt(usage.cachedInputTokens ?? usage.cached_input_tokens ?? usage.cacheRead ?? 0) + toNonNegativeInt(usage.cacheWrite ?? 0),\n` +
+    `    outputTokens: toNonNegativeInt(usage.outputTokens ?? usage.output_tokens ?? usage.output),\n` +
+    `    reasoningOutputTokens: toNonNegativeInt(usage.reasoningOutputTokens ?? usage.reasoning_output_tokens),\n` +
+    `    totalTokens: toNonNegativeInt(usage.totalTokens ?? usage.total_tokens)\n` +
+    `  };\n` +
+    `  const sum = normalized.inputTokens + normalized.cachedInputTokens + normalized.outputTokens + normalized.reasoningOutputTokens + normalized.totalTokens;\n` +
+    `  return sum > 0 ? normalized : null;\n` +
     `}\n` +
     `\n` +
     `function normalize(v) {\n` +
@@ -483,22 +397,18 @@ function buildSessionPluginIndex({ trackerDir, packageName = "vibeusage", opencl
     `  return s.length > 0 ? s : null;\n` +
     `}\n` +
     `\n` +
-    `function toNonNegativeInt(v) {\n` +
-    `  const n = Number(v);\n` +
-    `  if (!Number.isFinite(n) || n < 0) return null;\n` +
-    `  return Math.floor(n);\n` +
+    `function normalizeIso(v) {\n` +
+    `  const s = normalize(v);\n` +
+    `  if (!s) return null;\n` +
+    `  const ms = Date.parse(s);\n` +
+    `  if (!Number.isFinite(ms)) return null;\n` +
+    `  return new Date(ms).toISOString();\n` +
     `}\n` +
     `\n` +
-    `function toIso(v) {\n` +
-    `  if (typeof v === 'string') {\n` +
-    `    const s = normalize(v);\n` +
-    `    if (s && !Number.isNaN(Date.parse(s))) return s;\n` +
-    `  }\n` +
-    `  const n = Number(v);\n` +
-    `  if (!Number.isFinite(n) || n <= 0) return null;\n` +
-    `  const ms = n < 1e12 ? Math.floor(n * 1000) : Math.floor(n);\n` +
-    `  const d = new Date(ms);\n` +
-    `  return Number.isNaN(d.getTime()) ? null : d.toISOString();\n` +
+    `function toNonNegativeInt(v) {\n` +
+    `  const n = Number(v || 0);\n` +
+    `  if (!Number.isFinite(n) || n < 0) return 0;\n` +
+    `  return Math.floor(n);\n` +
     `}\n`
   );
 }

package/src/lib/openclaw-usage-ledger.js

@@ -0,0 +1,237 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs/promises");
+const path = require("node:path");
+
+const { ensureDir, readJson, writeJson } = require("./fs");
+
+const OPENCLAW_SOURCE = "openclaw";
+const ALLOWED_EVENT_FIELDS = [
+  "eventId",
+  "emittedAt",
+  "source",
+  "agentId",
+  "sessionRef",
+  "provider",
+  "model",
+  "channel",
+  "chatType",
+  "trigger",
+  "inputTokens",
+  "cachedInputTokens",
+  "outputTokens",
+  "reasoningOutputTokens",
+  "totalTokens",
+];
+
+function resolveOpenclawUsageLedgerPaths({ trackerDir } = {}) {
+  if (!trackerDir) throw new Error("trackerDir is required");
+  return {
+    ledgerPath: path.join(trackerDir, "openclaw-usage-ledger.jsonl"),
+    statePath: path.join(trackerDir, "openclaw-usage-ledger.state.json"),
+    saltPath: path.join(trackerDir, "openclaw-usage-ledger.salt"),
+  };
+}
+
+async function buildOpenclawUsageEvent({ trackerDir, payload } = {}) {
+  if (!payload || typeof payload !== "object") throw new Error("payload is required");
+
+  const source = normalizeString(payload.source) || OPENCLAW_SOURCE;
+  const emittedAt = normalizeIso(payload.emittedAt) || new Date().toISOString();
+  const agentId = normalizeString(payload.agentId);
+  const provider = normalizeString(payload.provider);
+  const model = normalizeString(payload.model);
+  const channel = normalizeString(payload.channel);
+  const chatType = normalizeString(payload.chatType);
+  const trigger = normalizeString(payload.trigger);
+  const sessionKey = normalizeString(payload.sessionKey);
+  const existingSessionRef = normalizeHex(payload.sessionRef);
+  const sessionRef = sessionKey
+    ? await hashOpenclawSessionRef({ trackerDir, sessionKey })
+    : existingSessionRef;
+
+  const usage = payload.usage && typeof payload.usage === "object" ? payload.usage : payload;
+  const event = {
+    eventId: normalizeString(payload.eventId),
+    emittedAt,
+    source,
+    agentId,
+    sessionRef,
+    provider,
+    model,
+    channel,
+    chatType,
+    trigger,
+    inputTokens: toNonNegativeInt(usage.inputTokens ?? usage.input_tokens),
+    cachedInputTokens: toNonNegativeInt(usage.cachedInputTokens ?? usage.cached_input_tokens),
+    outputTokens: toNonNegativeInt(usage.outputTokens ?? usage.output_tokens),
+    reasoningOutputTokens: toNonNegativeInt(
+      usage.reasoningOutputTokens ?? usage.reasoning_output_tokens,
+    ),
+    totalTokens: toNonNegativeInt(usage.totalTokens ?? usage.total_tokens),
+  };
+
+  if (!event.eventId) {
+    event.eventId = deriveOpenclawEventId(event);
+  }
+
+  return stripEmptyAllowedFields(event);
+}
+
+async function appendOpenclawUsageEvent({ trackerDir, event, payload } = {}) {
+  const nextEvent = event
+    ? await buildOpenclawUsageEvent({ trackerDir, payload: event })
+    : await buildOpenclawUsageEvent({ trackerDir, payload });
+  const { ledgerPath, statePath } = resolveOpenclawUsageLedgerPaths({ trackerDir });
+
+  await ensureDir(path.dirname(ledgerPath));
+
+  const state = (await readJson(statePath)) || { version: 1, seenEventIds: {}, updatedAt: null };
+  if (!state.seenEventIds || typeof state.seenEventIds !== "object") {
+    state.seenEventIds = {};
+  }
+
+  if (state.seenEventIds[nextEvent.eventId]) {
+    return { appended: false, duplicate: true, event: nextEvent };
+  }
+
+  await fs.appendFile(ledgerPath, `${JSON.stringify(nextEvent)}\n`, "utf8");
+  state.version = 1;
+  state.seenEventIds[nextEvent.eventId] = nextEvent.emittedAt || new Date().toISOString();
+  state.updatedAt = new Date().toISOString();
+  await writeJson(statePath, state);
+
+  return { appended: true, duplicate: false, event: nextEvent };
+}
+
+async function readOpenclawUsageLedger({ trackerDir, offset = 0 } = {}) {
+  const { ledgerPath } = resolveOpenclawUsageLedgerPaths({ trackerDir });
+  const buffer = await fs.readFile(ledgerPath).catch((err) => {
+    if (err && err.code === "ENOENT") return null;
+    throw err;
+  });
+
+  if (!buffer) {
+    return { events: [], endOffset: 0 };
+  }
+
+  const startOffset = Math.max(0, Number(offset || 0));
+  const endOffset = buffer.length;
+  if (startOffset >= endOffset) {
+    return { events: [], endOffset };
+  }
+
+  const raw = buffer.subarray(startOffset).toString("utf8");
+  const events = raw
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch (_err) {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .map(stripToAllowedEventFields);
+
+  return { events, endOffset };
+}
+
+async function hashOpenclawSessionRef({ trackerDir, sessionKey } = {}) {
+  const normalized = normalizeString(sessionKey);
+  if (!normalized) return null;
+
+  const salt = await ensureOpenclawLedgerSalt({ trackerDir });
+  return crypto.createHmac("sha256", salt).update(normalized).digest("hex");
+}
+
+async function ensureOpenclawLedgerSalt({ trackerDir } = {}) {
+  const { saltPath } = resolveOpenclawUsageLedgerPaths({ trackerDir });
+  await ensureDir(path.dirname(saltPath));
+
+  try {
+    const existing = (await fs.readFile(saltPath, "utf8")).trim();
+    if (existing) return existing;
+  } catch (err) {
+    if (err?.code !== "ENOENT") throw err;
+  }
+
+  const salt = crypto.randomBytes(32).toString("hex");
+  await fs.writeFile(saltPath, `${salt}\n`, { encoding: "utf8", mode: 0o600 });
+  return salt;
+}
+
+function deriveOpenclawEventId(event) {
+  const stable = JSON.stringify({
+    emittedAt: normalizeIso(event.emittedAt),
+    source: normalizeString(event.source) || OPENCLAW_SOURCE,
+    agentId: normalizeString(event.agentId),
+    sessionRef: normalizeHex(event.sessionRef),
+    provider: normalizeString(event.provider),
+    model: normalizeString(event.model),
+    channel: normalizeString(event.channel),
+    chatType: normalizeString(event.chatType),
+    trigger: normalizeString(event.trigger),
+    inputTokens: toNonNegativeInt(event.inputTokens),
+    cachedInputTokens: toNonNegativeInt(event.cachedInputTokens),
+    outputTokens: toNonNegativeInt(event.outputTokens),
+    reasoningOutputTokens: toNonNegativeInt(event.reasoningOutputTokens),
+    totalTokens: toNonNegativeInt(event.totalTokens),
+  });
+  return crypto.createHash("sha256").update(stable).digest("hex");
+}
+
+function stripEmptyAllowedFields(event) {
+  const out = {};
+  for (const field of ALLOWED_EVENT_FIELDS) {
+    const value = event[field];
+    if (value == null) continue;
+    out[field] = value;
+  }
+  return out;
+}
+
+function stripToAllowedEventFields(event) {
+  const out = {};
+  for (const field of ALLOWED_EVENT_FIELDS) {
+    if (!Object.prototype.hasOwnProperty.call(event, field)) continue;
+    out[field] = event[field];
+  }
+  return out;
+}
+
+function normalizeString(value) {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : null;
+}
+
+function normalizeIso(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) return null;
+  const time = Date.parse(normalized);
+  if (!Number.isFinite(time)) return null;
+  return new Date(time).toISOString();
+}
+
+function normalizeHex(value) {
+  const normalized = normalizeString(value);
+  if (!normalized) return null;
+  return /^[a-f0-9]{64}$/i.test(normalized) ? normalized.toLowerCase() : null;
+}
+
+function toNonNegativeInt(value) {
+  const numeric = Number(value || 0);
+  if (!Number.isFinite(numeric) || numeric < 0) return 0;
+  return Math.floor(numeric);
+}
+
+module.exports = {
+  ALLOWED_EVENT_FIELDS,
+  buildOpenclawUsageEvent,
+  appendOpenclawUsageEvent,
+  readOpenclawUsageLedger,
+  hashOpenclawSessionRef,
+  resolveOpenclawUsageLedgerPaths,
+};

package/src/lib/rollout.js

@@ -637,161 +637,6 @@ async function parseOpencodeIncremental({
   };
 }
 
-async function parseOpenclawIncremental({
-  sessionFiles,
-  cursors,
-  queuePath,
-  projectQueuePath,
-  onProgress,
-  source,
-}) {
-  await ensureDir(path.dirname(queuePath));
-  let filesProcessed = 0;
-  let eventsAggregated = 0;
-
-  const cb = typeof onProgress === "function" ? onProgress : null;
-  const files = Array.isArray(sessionFiles) ? sessionFiles : [];
-  const totalFiles = files.length;
-  const hourlyState = normalizeHourlyState(cursors?.hourly);
-  const projectEnabled = typeof projectQueuePath === "string" && projectQueuePath.length > 0;
-  const projectState = projectEnabled ? normalizeProjectState(cursors?.projectHourly) : null;
-  const projectTouchedBuckets = projectEnabled ? new Set() : null;
-  const touchedBuckets = new Set();
-  const defaultSource = normalizeSourceInput(source) || "openclaw";
-
-  if (!cursors.files || typeof cursors.files !== "object") {
-    cursors.files = {};
-  }
-
-  for (let idx = 0; idx < files.length; idx++) {
-    const entry = files[idx];
-    const filePath = typeof entry === "string" ? entry : entry?.path;
-    if (!filePath) continue;
-    const fileSource =
-      typeof entry === "string"
-        ? defaultSource
-        : normalizeSourceInput(entry?.source) || defaultSource;
-    const st = await fs.stat(filePath).catch(() => null);
-    if (!st || !st.isFile()) continue;
-
-    const key = filePath;
-    const prev = cursors.files[key] || null;
-    const inode = st.ino || 0;
-    const startOffset = prev && prev.inode === inode ? prev.offset || 0 : 0;
-
-    const result = await parseOpenclawSessionFile({
-      filePath,
-      startOffset,
-      hourlyState,
-      touchedBuckets,
-      source: fileSource,
-      projectState,
-      projectTouchedBuckets,
-    });
-
-    cursors.files[key] = {
-      inode,
-      offset: result.endOffset,
-      updatedAt: new Date().toISOString(),
-    };
-
-    filesProcessed += 1;
-    eventsAggregated += result.eventsAggregated;
-
-    if (cb) {
-      cb({
-        index: idx + 1,
-        total: totalFiles,
-        filePath,
-        filesProcessed,
-        eventsAggregated,
-        bucketsQueued: touchedBuckets.size,
-      });
-    }
-  }
-
-  const bucketsQueued = await enqueueTouchedBuckets({ queuePath, hourlyState, touchedBuckets });
-  const projectBucketsQueued = projectEnabled
-    ? await enqueueTouchedProjectBuckets({ projectQueuePath, projectState, projectTouchedBuckets })
-    : 0;
-  hourlyState.updatedAt = new Date().toISOString();
-  cursors.hourly = hourlyState;
-  if (projectState) {
-    projectState.updatedAt = new Date().toISOString();
-    cursors.projectHourly = projectState;
-  }
-
-  return { filesProcessed, eventsAggregated, bucketsQueued, projectBucketsQueued };
-}
-
-async function parseOpenclawSessionFile({
-  filePath,
-  startOffset,
-  hourlyState,
-  touchedBuckets,
-  source,
-  projectState,
-  projectTouchedBuckets,
-}) {
-  const st = await fs.stat(filePath);
-  const endOffset = st.size;
-  if (startOffset >= endOffset) return { endOffset, eventsAggregated: 0 };
-
-  const stream = fssync.createReadStream(filePath, { encoding: "utf8", start: startOffset });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-
-  let eventsAggregated = 0;
-  for await (const line of rl) {
-    if (!line) continue;
-    // Fast-path filter: OpenClaw assistant messages include message.usage.totalTokens.
-    if (!line.includes('"usage"') || !line.includes("totalTokens")) continue;
-
-    let obj;
-    try {
-      obj = JSON.parse(line);
-    } catch (_e) {
-      continue;
-    }
-
-    if (obj?.type !== "message") continue;
-    const msg = obj?.message;
-    if (!msg || typeof msg !== "object") continue;
-
-    const usage = msg.usage;
-    if (!usage || typeof usage !== "object") continue;
-
-    const tokenTimestamp = typeof obj?.timestamp === "string" ? obj.timestamp : null;
-    if (!tokenTimestamp) continue;
-
-    const model = normalizeModelInput(msg.model) || DEFAULT_MODEL;
-
-    const delta = {
-      input_tokens: Number(usage.input || 0),
-      cached_input_tokens: Number((usage.cacheRead || 0) + (usage.cacheWrite || 0)),
-      output_tokens: Number(usage.output || 0),
-      reasoning_output_tokens: 0,
-      total_tokens: Number(usage.totalTokens || 0),
-    };
-
-    if (isAllZeroUsage(delta)) continue;
-
-    const bucketStart = toUtcHalfHourStart(tokenTimestamp);
-    if (!bucketStart) continue;
-
-    const bucket = getHourlyBucket(hourlyState, source, model, bucketStart);
-    addTotals(bucket.totals, delta);
-    touchedBuckets.add(bucketKey(source, model, bucketStart));
-
-    // Project-level OpenClaw attribution is not supported yet (no stable cwd info).
-    // If OpenClaw later records cwd per event, we can mirror rollout's project logic.
-    eventsAggregated += 1;
-  }
-
-  rl.close();
-  stream.close?.();
-  return { endOffset, eventsAggregated };
-}
-
 async function parseRolloutFile({
   filePath,
   startOffset,
@@ -2453,5 +2298,10 @@ module.exports = {
   parseClaudeIncremental,
   parseGeminiIncremental,
   parseOpencodeIncremental,
-  parseOpenclawIncremental,
+  normalizeHourlyState,
+  getHourlyBucket,
+  addTotals,
+  bucketKey,
+  enqueueTouchedBuckets,
+  toUtcHalfHourStart,
 };