tokentracker-cli 1.3.4 → 1.3.6

package/src/lib/rollout.js

@@ -12,6 +12,7 @@ const { physicalJsonlRecords } = require("./jsonl-lines");
 const { readSqliteJsonRows, readSqliteJsonRowsAsync } = require("./sqlite-reader");
 const wsl = require("./wsl-probe");
 const { resolveInstallPaths } = require("./install-resolver");
+const { expandHome } = require("./scan-roots");
 const {
   consumeUsageDelta,
   createUsageDeltaState,
@@ -1634,9 +1635,19 @@ async function resolveOpenclawSessionFiles(env = process.env, deps = {}) {
           out.push(full);
         }
       }
+      for (const dbPath of [
+        path.join(agentsDir, agent.name, "agent", "openclaw-agent.sqlite"),
+        path.join(agentsDir, agent.name, "openclaw-agent.sqlite"),
+      ]) {
+        if ((await fs.stat(dbPath).catch(() => null))?.isFile()) {
+          out.push(dbPath);
+          break; // alternate layouts of one agent database, not two sources
+        }
+      }
     }
   }
-  out.sort((a, b) => a.localeCompare(b));
+  // Import archives must seed dedup before the corresponding SQLite history.
+  out.sort((a, b) => Number(a.endsWith(".sqlite")) - Number(b.endsWith(".sqlite")) || a.localeCompare(b));
   return out;
 }
 
@@ -1699,6 +1710,67 @@ async function parseOpenclawIncremental({
     const previousOffset = Number(prev?.offset || 0);
     let accepted = null;
     let openedRegularFile = false;
+    if (filePath.endsWith(".sqlite")) {
+      const sessionFilter = typeof entry?.sessionId === "string"
+        ? ` AND e.session_id = '${entry.sessionId.replace(/'/g, "''")}'` : "";
+      const rows = await readSqliteJsonRowsAsync(filePath, `
+        SELECT e.session_id, json_object(
+          'type', json_extract(e.event_json, '$.type'),
+          'id', json_extract(e.event_json, '$.id'),
+          'timestamp', json_extract(e.event_json, '$.timestamp'),
+          'message', json_object(
+            'role', json_extract(e.event_json, '$.message.role'),
+            'model', json_extract(e.event_json, '$.message.model'),
+            'provider', json_extract(e.event_json, '$.message.provider'),
+            'api', json_extract(e.event_json, '$.message.api'),
+            'timestamp', json_extract(e.event_json, '$.message.timestamp'),
+            'responseId', json_extract(e.event_json, '$.message.responseId'),
+            'usage', json_extract(e.event_json, '$.message.usage')
+          )) AS event
+        FROM transcript_events e JOIN session_windows w ON w.session_id = e.session_id
+        WHERE json_valid(e.event_json) AND COALESCE(w.reason, '') != 'compaction'
+          AND json_extract(e.event_json, '$.message.role') = 'assistant'
+          AND json_extract(e.event_json, '$.message.usage') IS NOT NULL
+          ${sessionFilter}
+        ORDER BY e.session_id, e.seq
+      `, { readOnly: true, throwOnReadFailure: true, label: "OpenClaw" });
+      const sessions = new Map();
+      for (const row of rows) {
+        if (!sessions.has(row.session_id)) sessions.set(row.session_id, []);
+        sessions.get(row.session_id).push(row.event);
+      }
+      for (const [sessionId, lines] of sessions) {
+        const sessionCursorKey = `${key}#${sessionId}`;
+        const prior = { ...(stagedFiles[sessionCursorKey]?.usageEvents || {}) };
+        const dbDir = path.dirname(filePath);
+        const agentDir = path.basename(dbDir) === "agent" && path.basename(path.dirname(path.dirname(dbDir))) === "agents"
+          ? path.dirname(dbDir) : dbDir;
+        const agentPrefix = openclawCursorKey(`${agentDir}${path.sep}`);
+        // SQLite imports retain transcript identities. Carry forward counts
+        // from this session's legacy transcript, including reset archives.
+        for (const [legacyPath, cursor] of Object.entries(stagedFiles)) {
+          const basename = path.basename(legacyPath);
+          if (cursor.provider !== "openclaw" || !openclawCursorKey(legacyPath).startsWith(agentPrefix)) continue;
+          if (!basename.startsWith(`${sessionId}.jsonl`) &&
+              !(basename.startsWith(`${sessionId}-topic-`) && basename.includes(".jsonl"))) continue;
+          for (const [identity, count] of Object.entries(cursor.usageEvents || {})) {
+            prior[identity] = Math.max(prior[identity] || 0, count);
+          }
+        }
+        const result = await parseOpenclawSessionFile({
+          lines, previousUsageEvents: prior, appendOnly: false,
+          hourlyState, touchedBuckets, source: fileSource,
+        });
+        stagedFiles[sessionCursorKey] = {
+          provider: "openclaw", usageEvents: result.usageEvents,
+          hasRealUsage: Object.keys(result.usageEvents).length > 0,
+          updatedAt: new Date().toISOString(),
+        };
+        eventsAggregated += result.eventsAggregated;
+      }
+      filesProcessed += 1;
+      continue;
+    }
     for (let attempt = 0; attempt < 3; attempt += 1) {
       const fileHandle = await fs.open(filePath, "r").catch(() => null);
       if (!fileHandle) break;
@@ -1913,6 +1985,7 @@ function mergeOpenclawAttemptBuckets(
 }
 
 async function parseOpenclawSessionFile({
+  lines,
   filePath,
   fileHandle,
   startOffset,
@@ -1928,7 +2001,8 @@ async function parseOpenclawSessionFile({
   projectState,
   projectTouchedBuckets,
 }) {
-  const st = fileHandle ? await fileHandle.stat() : await fs.stat(filePath);
+  const st = lines ? { size: lines.length } : fileHandle ? await fileHandle.stat() : await fs.stat(filePath);
+  startOffset = startOffset || 0;
   const endOffset =
     Number.isFinite(endOffsetLimit) && endOffsetLimit >= 0
       ? Math.min(st.size, endOffsetLimit)
@@ -1963,14 +2037,14 @@ async function parseOpenclawSessionFile({
     };
   }
 
-  const stream = fssync.createReadStream(filePath, {
+  const stream = lines ? null : fssync.createReadStream(filePath, {
     fd: fileHandle?.fd,
     autoClose: !fileHandle,
     encoding: "utf8",
     start: startOffset,
     end: endOffset - 1,
   });
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+  const rl = lines || readline.createInterface({ input: stream, crlfDelay: Infinity });
 
   let eventsAggregated = 0;
   const scanCounts = appendOnly ? { ...priorCounts } : {};
@@ -2069,8 +2143,8 @@ async function parseOpenclawSessionFile({
     if (!collectOnly) eventsAggregated += 1;
   }
 
-  rl.close();
-  if (!fileHandle) stream.close?.();
+  if (!lines) rl.close();
+  if (!fileHandle) stream?.close?.();
   return {
     endOffset,
     eventsAggregated,
@@ -5053,16 +5127,21 @@ function buildV2Sql(sessionTable, watermark = null) {
 // sessionTable (which session table exists, session_v2 preferred over session
 // via DESC). Returns null when the probe itself fails — callers treat that as
 // v1-only, matching the pre-existing silent-degradation contract.
-function detectOpencodeMessageLayout(dbPath, sqliteOptions = {}) {
+function detectOpencodeMessageLayout(dbPath, sqliteOptions = {}, { propagateReadFailure = false } = {}) {
   let rows;
   try {
     rows = readSqliteJsonRows(
       dbPath,
       `SELECT (SELECT 1 FROM session_message LIMIT 1) AS hasRows,
               (SELECT name FROM sqlite_master WHERE name IN ('session','session_v2') ORDER BY name DESC LIMIT 1) AS sessionTable`,
-      { label: "OpenCode", timeout: 10_000, maxBuffer: 1024 * 1024, ...sqliteOptions },
+      { label: "OpenCode", timeout: 10_000, maxBuffer: 1024 * 1024, ...sqliteOptions, throwOnReadFailure: true },
     );
-  } catch (_e) {
+  } catch (error) {
+    // A missing session_message table is the normal v1-only miss; with
+    // propagateReadFailure a real read failure must reach the caller — the
+    // session scanner would otherwise skip the v2 generation silently and
+    // cache a zero-token inventory over a readable-in-principle database.
+    if (propagateReadFailure && !isMissingSqliteTableError(error)) throw error;
     return null;
   }
   if (!Array.isArray(rows) || rows.length === 0) return null;
@@ -5082,7 +5161,17 @@ function opencodeMessageProvider(data) {
   return data?.providerID || data?.model?.providerID || "";
 }
 
-function readOpencodeDbMessagesIncremental(dbPath, previousCursor = null, sqliteOptions = {}) {
+// readSqliteJsonRows wraps its two backend errors into the thrown Error, so a
+// "table genuinely absent" miss and a "database unreadable" failure look the
+// same to a caller that only catches. Both backends spell a missing table
+// "no such table" — use that to keep the normal miss on the tolerant path
+// while real read failures can propagate.
+function isMissingSqliteTableError(error) {
+  const messages = [error?.message, error?.cliError?.message, error?.nodeSqliteError?.message];
+  return messages.some((m) => typeof m === "string" && m.includes("no such table"));
+}
+
+function readOpencodeDbMessagesIncremental(dbPath, previousCursor = null, sqliteOptions = {}, { propagateReadFailure = false } = {}) {
   if (!dbPath || !fssync.existsSync(dbPath)) return { messages: [], cursor: null };
 
   const identity = opencodeDbIdentity(dbPath);
@@ -5149,7 +5238,11 @@ function readOpencodeDbMessagesIncremental(dbPath, previousCursor = null, sqlite
         throwOnReadFailure: true,
       });
       return Array.isArray(rows) ? rows : [];
-    } catch (_e) {
+    } catch (error) {
+      // A missing table is the normal "other generation's layout" miss; an
+      // unreadable database is not — with propagateReadFailure the session
+      // scan aborts instead of caching a zero-token inventory over it.
+      if (propagateReadFailure && !isMissingSqliteTableError(error)) throw error;
       return null; // query-level failure (e.g. wrong generation's table)
     }
   };
@@ -5227,7 +5320,7 @@ function readOpencodeDbMessagesIncremental(dbPath, previousCursor = null, sqlite
     // baseline every database carries or degrades to), v2 runs only when the
     // probe confirms session_message has rows — this avoids firing a JOIN
     // against a non-existent session table on type-A databases.
-    const probe = detectOpencodeMessageLayout(effectiveDbPath, sqliteOptions);
+    const probe = detectOpencodeMessageLayout(effectiveDbPath, sqliteOptions, { propagateReadFailure });
     const out = [];
     const nextCursor = {
       version: OPENCODE_DB_CURSOR_VERSION,
@@ -5267,8 +5360,8 @@ function readOpencodeDbMessagesIncremental(dbPath, previousCursor = null, sqlite
   }
 }
 
-function readOpencodeDbMessages(dbPath, sqliteOptions = {}) {
-  return readOpencodeDbMessagesIncremental(dbPath, null, sqliteOptions).messages;
+function readOpencodeDbMessages(dbPath, sqliteOptions = {}, { propagateReadFailure = false } = {}) {
+  return readOpencodeDbMessagesIncremental(dbPath, null, sqliteOptions, { propagateReadFailure }).messages;
 }
 
 // mimocode mirrors the user's Claude Code + claude-mem history into its own
@@ -5384,7 +5477,7 @@ const ZCODE_NATIVE_USAGE_COLUMNS = new Set([
   "cache_read_input_tokens",
 ]);
 
-function detectZcodeNativeUsageLayout(dbPath, sqliteOptions = {}) {
+function detectZcodeNativeUsageLayout(dbPath, sqliteOptions = {}, { propagateReadFailure = false } = {}) {
   if (!dbPath || !fssync.existsSync(dbPath)) return null;
   let rows;
   try {
@@ -5401,7 +5494,11 @@ function detectZcodeNativeUsageLayout(dbPath, sqliteOptions = {}) {
         throwOnReadFailure: true,
       },
     );
-  } catch (_error) {
+  } catch (error) {
+    // propagateReadFailure: an unreadable db is a failure, not "no native
+    // layout" — the session scanner must skip the file, not fall back to an
+    // empty legacy read and cache zero tokens.
+    if (propagateReadFailure) throw error;
     return null;
   }
   const modelUsageColumns = new Set(
@@ -5471,7 +5568,13 @@ function buildZcodeNativeUsageSql({ hasSessionDirectory }) {
     ORDER BY mu.started_at ASC, mu.id ASC`;
 }
 
-function readZcodeNativeUsageMessages(dbPath, sqliteOptions = {}) {
+// `propagateReadFailure` (off by default): when the native usage layout is
+// present but its row query fails, throw instead of returning null. The usage
+// queue treats that fallthrough as "no native table, use legacy" — correct for
+// its own resilience — but the session scanner must not cache a zero-token
+// inventory over a failed read (the browser then hides the sessions entirely
+// instead of reporting the db as skipped).
+function readZcodeNativeUsageMessages(dbPath, sqliteOptions = {}, { propagateReadFailure = false } = {}) {
   let snapshot = null;
   let effectiveDbPath = dbPath;
   if (isUncPath(dbPath)) {
@@ -5486,7 +5589,7 @@ function readZcodeNativeUsageMessages(dbPath, sqliteOptions = {}) {
 
   let rows;
   try {
-    const layout = detectZcodeNativeUsageLayout(effectiveDbPath, sqliteOptions);
+    const layout = detectZcodeNativeUsageLayout(effectiveDbPath, sqliteOptions, { propagateReadFailure });
     if (!layout) return null;
     rows = readSqliteJsonRows(effectiveDbPath, buildZcodeNativeUsageSql(layout), {
       label: "ZCode",
@@ -5495,7 +5598,8 @@ function readZcodeNativeUsageMessages(dbPath, sqliteOptions = {}) {
       ...sqliteOptions,
       throwOnReadFailure: true,
     });
-  } catch (_error) {
+  } catch (error) {
+    if (propagateReadFailure) throw error;
     return null;
   } finally {
     if (snapshot) snapshot.cleanup();
@@ -5547,10 +5651,10 @@ function readZcodeNativeUsageMessages(dbPath, sqliteOptions = {}) {
 // table is authoritative from its first completed row onward, but it is not a
 // historical backfill. Keep legacy rows before that boundary so merely adding
 // the new table cannot make older usage disappear from TokenTracker.
-function readZcodeDbMessages(dbPath, sqliteOptions = {}) {
+function readZcodeDbMessages(dbPath, sqliteOptions = {}, { propagateReadFailure = false } = {}) {
   if (!dbPath || !fssync.existsSync(dbPath)) return [];
-  const nativeMessages = readZcodeNativeUsageMessages(dbPath, sqliteOptions);
-  const legacyMessages = readOpencodeDbMessages(dbPath, sqliteOptions)
+  const nativeMessages = readZcodeNativeUsageMessages(dbPath, sqliteOptions, { propagateReadFailure });
+  const legacyMessages = readOpencodeDbMessages(dbPath, sqliteOptions, { propagateReadFailure })
     .filter((message) => isZcodeNativeMessage(message.data))
     .map(normalizeZcodeLegacyMessage);
   if (nativeMessages === null) return legacyMessages;
@@ -10451,23 +10555,43 @@ async function parseCodebuddyIncremental({
 //      is accepted by workbuddySqliteUsageSnapshot.
 // ─────────────────────────────────────────────────────────────────────────────
 
-function resolveWorkbuddyHome(env = process.env) {
-  const home = env.HOME || require("node:os").homedir();
-  if (env.WORKBUDDY_HOME) return env.WORKBUDDY_HOME;
+// WorkBuddy ships two regional builds that keep their data in sibling homes:
+//   ~/.workbuddy     — Tencent CN build (models: hy*/glm*/deepseek-*/auto)
+//   ~/.workbuddy-ai  — international build (models: gpt-5.6-*, gpt-6-*)
+// Both write byte-identical JSONL, so every reader below is shared and only
+// the home directory (and the bucket source key) differs. `variant` is also
+// the source key written into hourly buckets, so the two builds stay
+// separable in the dashboard and never share dedup state.
+const WORKBUDDY_VARIANTS = {
+  workbuddy: { dir: ".workbuddy", envVar: "WORKBUDDY_HOME" },
+  "workbuddy-ai": { dir: ".workbuddy-ai", envVar: "WORKBUDDY_AI_HOME" },
+};
+
+function resolveWorkbuddyVariant(variant) {
+  return Object.prototype.hasOwnProperty.call(WORKBUDDY_VARIANTS, variant)
+    ? variant
+    : "workbuddy";
+}
+
+function resolveWorkbuddyHome(env = process.env, variant = "workbuddy") {
+  const spec = WORKBUDDY_VARIANTS[resolveWorkbuddyVariant(variant)];
+  const home = env.HOME || env.USERPROFILE || require("node:os").homedir();
+  const configured = expandHome(env[spec.envVar], home);
+  if (configured) return configured;
   if (process.platform === "win32") {
     return pickWin32ProviderPath({
       env,
-      nativeValue: path.join(home, ".workbuddy"),
-      wslProviderDir: ".workbuddy",
+      nativeValue: path.join(home, spec.dir),
+      wslProviderDir: spec.dir,
     });
   }
-  return path.join(home, ".workbuddy");
+  return path.join(home, spec.dir);
 }
 
-function resolveWorkbuddyDefaultModel(env = process.env) {
+function resolveWorkbuddyDefaultModel(env = process.env, variant = "workbuddy") {
   const fallback = "auto";
   try {
-    const workbuddyHome = resolveWorkbuddyHome(env);
+    const workbuddyHome = resolveWorkbuddyHome(env, variant);
     if (!workbuddyHome) return fallback;
     const settingsPath = path.join(workbuddyHome, "settings.json");
     const raw = fssync.readFileSync(settingsPath, "utf8");
@@ -10487,8 +10611,8 @@ function resolveWorkbuddyDefaultModel(env = process.env) {
 // ~/.workbuddy/traces/<pid>/trace_*.json. Those summaries are useful only when
 // the detailed JSONL for a session is absent, so they are returned as typed
 // entries and parsed after JSONL (JSONL remains authoritative when both exist).
-function resolveWorkbuddyProjectFiles(env = process.env) {
-  const workbuddyHome = resolveWorkbuddyHome(env);
+function resolveWorkbuddyProjectFiles(env = process.env, variant = "workbuddy") {
+  const workbuddyHome = resolveWorkbuddyHome(env, variant);
   if (!workbuddyHome) return [];
   const projectsDir = path.join(workbuddyHome, "projects");
   const files = [];
@@ -10597,10 +10721,15 @@ async function parseWorkbuddyIncremental({
   onProgress,
   env,
   defaultModel,
+  source = "workbuddy",
 } = {}) {
   await ensureDir(path.dirname(queuePath));
+  // `source` doubles as the variant selector and the bucket source key, so the
+  // CN install (~/.workbuddy) and the international install (~/.workbuddy-ai)
+  // get independent cursor namespaces and never share dedup state.
+  const variant = resolveWorkbuddyVariant(source);
   const workbuddyState =
-    cursors.workbuddy && typeof cursors.workbuddy === "object" ? cursors.workbuddy : {};
+    cursors[variant] && typeof cursors[variant] === "object" ? cursors[variant] : {};
   const seenIds = new Set(
     Array.isArray(workbuddyState.seenIds) ? workbuddyState.seenIds : [],
   );
@@ -10626,20 +10755,20 @@ async function parseWorkbuddyIncremental({
 
   const allFiles = Array.isArray(projectFiles)
     ? projectFiles
-    : resolveWorkbuddyProjectFiles(env || process.env);
+    : resolveWorkbuddyProjectFiles(env || process.env, variant);
   const jsonlFiles = allFiles.filter((entry) => typeof entry === "string");
   const traceFiles = allFiles.filter(
     (entry) => entry && typeof entry === "object" && typeof entry.path === "string" && entry.kind === "trace",
   );
   const files = [...jsonlFiles, ...traceFiles];
-  const fallbackModel = defaultModel || resolveWorkbuddyDefaultModel(env || process.env);
+  const fallbackModel = defaultModel || resolveWorkbuddyDefaultModel(env || process.env, variant);
 
-  const workbuddyHome = resolveWorkbuddyHome(env || process.env);
+  const workbuddyHome = resolveWorkbuddyHome(env || process.env, variant);
   const dbPath = workbuddyHome ? path.join(workbuddyHome, "workbuddy.db") : null;
   const dbExists = Boolean(dbPath && fssync.existsSync(dbPath));
 
   if (files.length === 0 && !dbExists) {
-    cursors.workbuddy = {
+    cursors[variant] = {
       ...workbuddyState,
       seenIds: Array.from(seenIds),
       seenTraceIds: Array.from(seenTraceIds),
@@ -10786,9 +10915,9 @@ async function parseWorkbuddyIncremental({
         conversation_count: 1,
       };
 
-      const bucket = getHourlyBucket(hourlyState, "workbuddy", model, bucketStart);
+      const bucket = getHourlyBucket(hourlyState, variant, model, bucketStart);
       addTotals(bucket.totals, delta);
-      touchedBuckets.add(bucketKey("workbuddy", model, bucketStart));
+      touchedBuckets.add(bucketKey(variant, model, bucketStart));
       seenIds.add(messageId);
       // Keep legacy entry-id keys alongside the response id so upgrading a
       // cursor cannot replay a row that an older build already counted.
@@ -10897,9 +11026,9 @@ async function parseWorkbuddyIncremental({
       total_tokens: inputTokens + totalCached + totalOutput,
       conversation_count: 1,
     };
-    const bucket = getHourlyBucket(hourlyState, "workbuddy", model, bucketStart);
+    const bucket = getHourlyBucket(hourlyState, variant, model, bucketStart);
     addTotals(bucket.totals, delta);
-    touchedBuckets.add(bucketKey("workbuddy", model, bucketStart));
+    touchedBuckets.add(bucketKey(variant, model, bucketStart));
     seenTraceIds.add(traceId);
     tracedSessionIds.add(sessionId);
     recordsProcessed++;
@@ -11032,9 +11161,9 @@ async function parseWorkbuddyIncremental({
           conversation_count: Object.keys(previousTokens).every((key) => toNonNegativeInt(previousTokens[key]) === 0) || isReset ? 1 : 0,
         };
 
-        const bucket = getHourlyBucket(hourlyState, "workbuddy", model, bucketStart);
+        const bucket = getHourlyBucket(hourlyState, variant, model, bucketStart);
         addTotals(bucket.totals, delta);
-        touchedBuckets.add(bucketKey("workbuddy", model, bucketStart));
+        touchedBuckets.add(bucketKey(variant, model, bucketStart));
         sqliteSessions[sessionId] = {
           used: usedNow,
           updatedAt: updatedAtRaw,
@@ -11085,7 +11214,7 @@ async function parseWorkbuddyIncremental({
   const updatedAt = new Date().toISOString();
   hourlyState.updatedAt = updatedAt;
   cursors.hourly = hourlyState;
-  cursors.workbuddy = {
+  cursors[variant] = {
     ...workbuddyState,
     seenIds: cappedSeen,
     seenTraceIds: cappedSeenTraceIds,
@@ -15972,6 +16101,27 @@ function resolvePiSessionFiles(env = process.env) {
   } catch {
     // ignore — return what we have
   }
+  // Multica launches pi headless with a dedicated flat session dir:
+  //   ~/.multica/pi-sessions/<session-id>.jsonl
+  // Scan it too so orchestrated runs are counted alongside TUI sessions.
+  try {
+    const seen = new Set(files);
+    const multicaSessionsDir = path.join(
+      env.HOME || require("node:os").homedir(),
+      ".multica",
+      "pi-sessions",
+    );
+    for (const entry of fssync.readdirSync(multicaSessionsDir, { withFileTypes: true })) {
+      if (!entry.isFile() || !entry.name.endsWith(".jsonl")) continue;
+      const full = path.join(multicaSessionsDir, entry.name);
+      if (!seen.has(full)) {
+        seen.add(full);
+        files.push(full);
+      }
+    }
+  } catch {
+    // ignore — no Multica install
+  }
   files.sort((a, b) => a.localeCompare(b));
   return files;
 }
@@ -24439,6 +24589,8 @@ module.exports = {
   readOpencodeDbMessagesIncremental,
   readMimoDbMessages,
   readZcodeDbMessages,
+  coerceEpochMs,
+  normalizeOpencodeModelFields,
   hasZcodeNativeUsageSchema,
   resolveQoderDbPath,
   resolveQoderDbPaths,
@@ -24473,6 +24625,7 @@ module.exports = {
   parseGeminiIncremental,
   parseOpencodeIncremental,
   parseOpencodeDbIncremental,
+  deriveOpencodeMessageFingerprint,
   parseQoderDbIncremental,
   openclawCursorKey,
   parseOpenclawIncremental,
@@ -24514,6 +24667,8 @@ module.exports = {
   resolveWorkbuddyProjectFiles,
   resolveWorkbuddyDefaultModel,
   parseWorkbuddyIncremental,
+  WORKBUDDY_VARIANTS,
+  resolveWorkbuddyVariant,
   resolveKiroCliSessionFiles,
   resolveKiroCliDbPath,
   parseKiroCliIncremental,