@vibe-cafe/vibe-usage 0.10.6 → 0.10.8

package/src/parsers/pi-session-jsonl.js

@@ -0,0 +1,148 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { basename, join, relative } from 'node:path';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const MAX_WARNINGS = 20;
+
+function warn(ctx, message) {
+  ctx.incomplete = true;
+  if (ctx.warnings.length < MAX_WARNINGS) ctx.warnings.push(message);
+}
+
+function findJsonlFiles(dir, includeFile, ctx) {
+  if (!existsSync(dir)) return [];
+  let children;
+  try {
+    children = readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    warn(ctx, `${ctx.source}: cannot read directory ${dir}: ${err.message}`);
+    return [];
+  }
+
+  const files = [];
+  for (const child of children) {
+    const filePath = join(dir, child.name);
+    if (child.isDirectory()) files.push(...findJsonlFiles(filePath, includeFile, ctx));
+    else if (child.name.endsWith('.jsonl') && includeFile(filePath)) files.push(filePath);
+  }
+  return files;
+}
+
+function tokenCount(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? number : 0;
+}
+
+export function projectFromCwd(cwd) {
+  if (typeof cwd !== 'string') return 'unknown';
+  const parts = cwd.replace(/\\/g, '/').split('/').filter(Boolean);
+  return parts.at(-1) || 'unknown';
+}
+
+export function projectFromFirstDir(filePath, sessionsDir) {
+  const first = relative(sessionsDir, filePath).split(/[\\/]/)[0];
+  if (!first) return 'unknown';
+  return first.split('-').filter(Boolean).at(-1) || 'unknown';
+}
+
+export async function parsePiSessionJsonl({
+  source,
+  sessionsDirs,
+  includeFile = () => true,
+  projectFromPath = projectFromFirstDir,
+}) {
+  const ctx = { source, warnings: [], incomplete: false };
+  const entriesById = new Map();
+  const anonymousEntries = [];
+  const eventsById = new Map();
+  const anonymousEvents = [];
+
+  for (const sessionsDir of sessionsDirs) {
+    for (const filePath of findJsonlFiles(sessionsDir, includeFile, ctx)) {
+      let content;
+      try {
+        content = readFileSync(filePath, 'utf8');
+      } catch (err) {
+        warn(ctx, `${source}: cannot read ${filePath}: ${err.message}`);
+        continue;
+      }
+
+      let sessionId = basename(filePath, '.jsonl');
+      let project = projectFromPath(filePath, sessionsDir) || 'unknown';
+
+      for (const line of content.split('\n')) {
+        if (!line.trim()) continue;
+        let obj;
+        try {
+          obj = JSON.parse(line);
+        } catch {
+          continue;
+        }
+
+        if (obj.type === 'session') {
+          if (obj.id) sessionId = String(obj.id);
+          if (obj.cwd) project = projectFromCwd(obj.cwd);
+          continue;
+        }
+        if (obj.type !== 'message' || !obj.message) continue;
+
+        const message = obj.message;
+        const timestamp = new Date(obj.timestamp || message.timestamp || 0);
+        if (Number.isNaN(timestamp.getTime())) continue;
+        const recordId = obj.id ? `${sessionId}:${obj.id}` : null;
+
+        if (message.role === 'user' || message.role === 'assistant' || message.role === 'toolResult') {
+          const event = {
+            sessionId,
+            source,
+            project,
+            timestamp,
+            role: message.role === 'user' ? 'user' : 'assistant',
+          };
+          if (recordId) eventsById.set(recordId, event);
+          else anonymousEvents.push(event);
+        }
+
+        if (message.role !== 'assistant' || !message.usage) continue;
+        const usage = message.usage;
+        const inputTokens = tokenCount(usage.input) + tokenCount(usage.cacheWrite);
+        const reasoningOutputTokens = tokenCount(usage.reasoningTokens);
+        // OMP/Pi usage.output includes reasoning; the shared bucket contract
+        // stores non-reasoning output and reasoning separately.
+        const outputTokens = Math.max(0, tokenCount(usage.output) - reasoningOutputTokens);
+        const cachedInputTokens = tokenCount(usage.cacheRead);
+        const score = inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens;
+        if (score === 0) continue;
+
+        const entry = {
+          source,
+          model: message.model || message.modelId || obj.model || obj.modelId || 'unknown',
+          project,
+          timestamp,
+          inputTokens,
+          outputTokens,
+          cachedInputTokens,
+          reasoningOutputTokens,
+        };
+        if (!recordId) {
+          anonymousEntries.push(entry);
+        } else {
+          const current = entriesById.get(recordId);
+          if (!current || score > current.score) entriesById.set(recordId, { score, entry });
+        }
+      }
+    }
+  }
+
+  const entries = [
+    ...anonymousEntries,
+    ...[...entriesById.values()].map(({ entry }) => entry),
+  ];
+  const events = [...anonymousEvents, ...eventsById.values()];
+  return {
+    buckets: aggregateToBuckets(entries),
+    sessions: extractSessions(events),
+    ...(ctx.incomplete ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
+  };
+}

package/src/parsers/workbuddy.js

@@ -0,0 +1,287 @@
+import { createReadStream, readdirSync, statSync } from 'node:fs';
+import { createInterface } from 'node:readline';
+import { basename, join, relative, sep } from 'node:path';
+import { findWorkbuddyDataDirs } from '../workbuddy-roots.js';
+import { aggregateToBuckets, extractSessions } from './index.js';
+
+const SOURCE = 'workbuddy';
+const MAX_WARNINGS = 20;
+
+function warn(ctx, message) {
+  ctx.skipped = true;
+  if (ctx.warnings.length < MAX_WARNINGS && !ctx.warnings.includes(message)) {
+    ctx.warnings.push(message);
+  }
+}
+
+function finite(value) {
+  const number = Number(value);
+  return Number.isFinite(number) && number >= 0 ? number : 0;
+}
+
+function dateFrom(value) {
+  if (value instanceof Date && !Number.isNaN(value.getTime())) return value;
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    const date = new Date(value < 1e12 ? value * 1000 : value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  if (typeof value === 'string' && value.trim()) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+  }
+  return null;
+}
+
+function projectFromFile(filePath, projectsDir) {
+  const first = relative(projectsDir, filePath).split(sep).filter(Boolean)[0];
+  return first ? basename(first) : 'unknown';
+}
+
+function projectFromRecord(record) {
+  const cwd = typeof record.cwd === 'string' ? record.cwd.trim() : '';
+  if (!cwd) return null;
+  return basename(cwd.replace(/[\\/]+$/, '')) || null;
+}
+
+function findJsonlFiles(dir, ctx) {
+  let children;
+  try {
+    children = readdirSync(dir, { withFileTypes: true })
+      .sort((a, b) => a.name.localeCompare(b.name));
+  } catch (error) {
+    if (error?.code === 'ENOENT') return [];
+    warn(ctx, 'workbuddy: cannot read a data directory');
+    return [];
+  }
+
+  const files = [];
+  for (const child of children) {
+    const filePath = join(dir, child.name);
+    if (child.isDirectory()) files.push(...findJsonlFiles(filePath, ctx));
+    else if (child.isFile() && child.name.endsWith('.jsonl')) files.push(filePath);
+  }
+  return files;
+}
+
+async function readJsonl(filePath, size, onRecord, ctx) {
+  if (size <= 0) return;
+  const stream = createReadStream(filePath, {
+    encoding: 'utf8',
+    start: 0,
+    end: size - 1,
+  });
+  let streamError = null;
+  stream.on('error', error => { streamError = error; });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+
+  try {
+    for await (const line of lines) {
+      if (!line.trim()) continue;
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (record && typeof record === 'object') onRecord(record);
+    }
+    if (streamError) throw streamError;
+  } catch {
+    warn(ctx, 'workbuddy: cannot read a session file');
+  } finally {
+    lines.close();
+    stream.destroy();
+  }
+}
+
+function recordId(record) {
+  if (typeof record.id !== 'string' && typeof record.id !== 'number') return null;
+  const id = String(record.id).trim();
+  return id || null;
+}
+
+function roleFor(record) {
+  const role = record.role ?? record.message?.role;
+  if (role === 'user') return 'user';
+  if (role === 'assistant' || role === 'assistant_message') return 'assistant';
+  return null;
+}
+
+function isCompletedAssistant(record) {
+  if (record.type !== 'message' || roleFor(record) !== 'assistant') return false;
+  const status = String(
+    record.status ?? record.message?.status ?? record.state ?? record.message?.state ?? ''
+  ).toLowerCase();
+  return status === 'completed' || status === 'complete' || status === 'success';
+}
+
+function modelFor(record) {
+  const providerData = record.providerData && typeof record.providerData === 'object'
+    ? record.providerData
+    : {};
+  for (const value of [
+    providerData.requestModelId,
+    record.requestModelName,
+    providerData.requestModelName,
+    providerData.model,
+  ]) {
+    if (typeof value === 'string' && value.trim()) return value.trim();
+  }
+  return 'unknown';
+}
+
+function firstDetailValue(details, ...keys) {
+  for (const detail of Array.isArray(details) ? details : [details]) {
+    if (!detail || typeof detail !== 'object') continue;
+    for (const key of keys) {
+      if (detail[key] != null) return finite(detail[key]);
+    }
+  }
+  return 0;
+}
+
+function usageFor(record) {
+  const providerData = record.providerData && typeof record.providerData === 'object'
+    ? record.providerData
+    : {};
+  const primary = providerData.usage && typeof providerData.usage === 'object'
+    ? providerData.usage
+    : record.message?.usage && typeof record.message.usage === 'object'
+      ? record.message.usage
+      : null;
+  const raw = providerData.rawUsage && typeof providerData.rawUsage === 'object'
+    ? providerData.rawUsage
+    : null;
+  if (!primary && !raw) return null;
+
+  const inputDetails = primary?.input_details
+    ?? primary?.inputDetails
+    ?? primary?.inputTokensDetails;
+  const outputDetails = primary?.output_details
+    ?? primary?.outputDetails
+    ?? primary?.outputTokensDetails;
+  const cachedInputTokens = firstDetailValue(inputDetails, 'cached_tokens', 'cachedTokens')
+    || finite(
+      primary?.cache_read_input_tokens
+      ?? primary?.cacheReadInputTokens
+      ?? raw?.prompt_cache_hit_tokens
+      ?? raw?.cache_read_input_tokens
+    );
+  const reasoningOutputTokens = firstDetailValue(outputDetails, 'reasoning_tokens', 'reasoningTokens')
+    || finite(
+      primary?.completion_thinking_tokens
+      ?? primary?.reasoning_tokens
+      ?? primary?.reasoningTokens
+      ?? raw?.completion_thinking_tokens
+    );
+  const inclusiveInput = finite(primary?.inputTokens ?? primary?.input_tokens ?? raw?.prompt_tokens);
+  const inclusiveOutput = finite(primary?.outputTokens ?? primary?.output_tokens ?? raw?.completion_tokens);
+  const cacheMiss = finite(raw?.prompt_cache_miss_tokens);
+
+  // WorkBuddy's aggregate input/output fields include cache reads/reasoning.
+  // Prefer the provider's exclusive cache-miss field when available.
+  const inputTokens = cacheMiss > 0
+    ? cacheMiss
+    : Math.max(0, inclusiveInput - cachedInputTokens);
+  const outputTokens = Math.max(0, inclusiveOutput - reasoningOutputTokens);
+  const score = inputTokens + outputTokens + cachedInputTokens + reasoningOutputTokens;
+  if (score === 0) return null;
+
+  return {
+    inputTokens,
+    outputTokens,
+    cachedInputTokens,
+    reasoningOutputTokens,
+    score,
+  };
+}
+
+function timestampFor(record) {
+  return dateFrom(
+    record.completedAt
+    ?? record.completed_at
+    ?? record.timestamp
+    ?? record.createdAt
+    ?? record.created_at
+    ?? record.message?.createdAt
+  );
+}
+
+export async function parse() {
+  const entriesById = new Map();
+  const eventsById = new Map();
+  const anonymousEvents = [];
+  const ctx = { skipped: false, warnings: [] };
+  const projectDirs = [...new Set(findWorkbuddyDataDirs().map(root => (
+    basename(root) === 'projects' ? root : join(root, 'projects')
+  )))];
+
+  for (const projectsDir of projectDirs) {
+    for (const filePath of findJsonlFiles(projectsDir, ctx)) {
+      let size;
+      try {
+        size = statSync(filePath).size;
+      } catch {
+        warn(ctx, 'workbuddy: cannot stat a session file');
+        continue;
+      }
+
+      const sessionId = basename(filePath, '.jsonl');
+      let project = projectFromFile(filePath, projectsDir);
+      const fileEntries = [];
+      const fileEvents = [];
+
+      await readJsonl(filePath, size, record => {
+        project = projectFromRecord(record) || project;
+        const timestamp = timestampFor(record);
+        const id = recordId(record);
+        const role = roleFor(record);
+
+        if (timestamp && (role === 'user' || isCompletedAssistant(record))) {
+          fileEvents.push({ id, sessionId, timestamp, role });
+        }
+
+        if (!id || !timestamp || !isCompletedAssistant(record)) return;
+        const usage = usageFor(record);
+        if (!usage) return;
+        fileEntries.push({
+          id,
+          score: usage.score,
+          entry: {
+            source: SOURCE,
+            model: modelFor(record),
+            timestamp,
+            inputTokens: usage.inputTokens,
+            outputTokens: usage.outputTokens,
+            cachedInputTokens: usage.cachedInputTokens,
+            reasoningOutputTokens: usage.reasoningOutputTokens,
+          },
+        });
+      }, ctx);
+
+      for (const candidate of fileEntries) {
+        candidate.entry.project = project;
+        const current = entriesById.get(candidate.id);
+        if (!current || candidate.score > current.score) entriesById.set(candidate.id, candidate);
+      }
+      for (const candidate of fileEvents) {
+        const event = {
+          sessionId: candidate.sessionId,
+          source: SOURCE,
+          project,
+          timestamp: candidate.timestamp,
+          role: candidate.role,
+        };
+        if (candidate.id) eventsById.set(candidate.id, event);
+        else anonymousEvents.push(event);
+      }
+    }
+  }
+
+  return {
+    buckets: aggregateToBuckets([...entriesById.values()].map(({ entry }) => entry)),
+    sessions: extractSessions([...eventsById.values(), ...anonymousEvents]),
+    ...(ctx.skipped ? { skipped: true } : {}),
+    ...(ctx.warnings.length > 0 ? { warnings: ctx.warnings } : {}),
+  };
+}

package/src/pi-roots.js

@@ -0,0 +1,89 @@
+import { existsSync, readdirSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+function expandHome(value) {
+  const trimmed = value.trim();
+  if (trimmed === '~') return homedir();
+  if (trimmed.startsWith('~/') || trimmed.startsWith('~\\')) {
+    return join(homedir(), trimmed.slice(2));
+  }
+  return trimmed;
+}
+
+function uniqueExistingDirs(paths) {
+  return [...new Set(paths.map(expandHome))].filter(existsSync);
+}
+
+function profileSessionDirs(profilesRoot, includesAgentDir) {
+  const dirs = [];
+  let profiles;
+  try {
+    profiles = readdirSync(profilesRoot, { withFileTypes: true });
+  } catch {
+    return dirs;
+  }
+  for (const profile of profiles) {
+    if (!profile.isDirectory()) continue;
+    dirs.push(join(
+      profilesRoot,
+      profile.name,
+      ...(includesAgentDir ? ['agent', 'sessions'] : ['sessions']),
+    ));
+  }
+  return dirs;
+}
+
+export function looksLikeOmpAgentDir(agentDir) {
+  const normalized = agentDir.replace(/\\/g, '/');
+  return normalized.includes('/.omp/')
+    || existsSync(join(agentDir, 'config.yml'))
+    || existsSync(join(agentDir, 'agent.db'));
+}
+
+export function getPiSessionDirs() {
+  const override = process.env.VIBE_USAGE_PI_SESSION_DIRS?.trim();
+  if (override) return uniqueExistingDirs(override.split(delimiter));
+
+  const agentDir = process.env.PI_CODING_AGENT_DIR?.trim();
+  if (agentDir) {
+    const expanded = expandHome(agentDir);
+    // OMP inherits PI_CODING_AGENT_DIR from Pi. Do not parse an identifiable
+    // OMP store again as source=pi-coding-agent.
+    return looksLikeOmpAgentDir(expanded) ? [] : uniqueExistingDirs([join(expanded, 'sessions')]);
+  }
+  return uniqueExistingDirs([join(homedir(), '.pi', 'agent', 'sessions')]);
+}
+
+export function getOmpSessionDirs() {
+  const override = process.env.VIBE_USAGE_OMP_SESSION_DIRS?.trim();
+  if (override) return uniqueExistingDirs(override.split(delimiter));
+
+  const dirs = [];
+  const configName = process.env.PI_CONFIG_DIR?.trim() || '.omp';
+  const configRoot = join(homedir(), configName);
+  dirs.push(join(configRoot, 'agent', 'sessions'));
+  dirs.push(...profileSessionDirs(join(configRoot, 'profiles'), true));
+
+  const agentOverride = process.env.PI_CODING_AGENT_DIR?.trim();
+  if (agentOverride) {
+    const expanded = expandHome(agentOverride);
+    if (looksLikeOmpAgentDir(expanded)) dirs.push(join(expanded, 'sessions'));
+  }
+
+  // OMP's XDG migration flattens the agent/ segment:
+  // ~/.omp/agent/sessions -> $XDG_DATA_HOME/omp/sessions.
+  if (process.platform === 'linux' || process.platform === 'darwin') {
+    const xdgDataHome = process.env.XDG_DATA_HOME?.trim();
+    if (xdgDataHome) {
+      const xdgRoot = join(expandHome(xdgDataHome), 'omp');
+      dirs.push(join(xdgRoot, 'sessions'));
+      dirs.push(...profileSessionDirs(join(xdgRoot, 'profiles'), false));
+    }
+  }
+
+  return uniqueExistingDirs(dirs);
+}
+
+export const findPiDataDirs = getPiSessionDirs;
+export const findOmpDataDirs = getOmpSessionDirs;

package/src/sync.js

@@ -6,7 +6,7 @@ import {
 } from './state.js';
 import { ingest, fetchSettings } from './api.js';
 import { createSyncClient, forBatch } from './client-meta.js';
-import { parsers } from './parsers/index.js';
+import { aggregateToBuckets, parsers } from './parsers/index.js';
 import { success, failure, arrow, link, dim } from './output.js';
 
 const BATCH_SIZE = 100;
@@ -31,6 +31,16 @@ export function resolveCodexExtraHome(configured, temporary) {
   return temporary ?? configured;
 }
 
+// Hiding project names can collapse multiple parser buckets onto one server
+// identity. Merge those buckets before hashing/uploading so no project's usage
+// wins by iteration order.
+export function reaggregateHiddenProjectBuckets(buckets) {
+  return aggregateToBuckets(buckets.map(bucket => ({
+    ...bucket,
+    timestamp: new Date(bucket.bucketStart),
+  })));
+}
+
 export async function runSync({
   throws = false,
   quiet = false,
@@ -70,7 +80,7 @@ export async function runSync({
     process.exit(1);
   }
 
-  const allBuckets = [];
+  let allBuckets = [];
   const allSessions = [];
   const parserResults = [];
   const parserProgress = [];
@@ -166,6 +176,7 @@ export async function runSync({
   if (!uploadProject) {
     for (const b of allBuckets) b.project = 'unknown';
     for (const s of allSessions) s.project = 'unknown';
+    allBuckets = reaggregateHiddenProjectBuckets(allBuckets);
   }
 
   // Incremental upload diff: parsers above emit a complete view of live local

package/src/tools.js

@@ -1,8 +1,29 @@
 import { existsSync, readdirSync, statSync } from 'node:fs';
-import { isAbsolute, join, resolve } from 'node:path';
+import { isAbsolute, join, posix, resolve, win32 } from 'node:path';
 import { homedir } from 'node:os';
 import { findClaudeCodeDataDirs } from './claude-roots.js';
 import { codexSessionDirs, resolveCodexHomes } from './codex-roots.js';
+import { findClineDataDirs } from './cline-roots.js';
+import { findCraftDataDirs } from './craft-roots.js';
+import { findOmpDataDirs, findPiDataDirs } from './pi-roots.js';
+import { findWorkbuddyDataDirs } from './workbuddy-roots.js';
+
+export function getAlmaDbPath(env = process.env, platform = process.platform, home = homedir()) {
+  const pathImpl = platform === 'win32' ? win32 : posix;
+  const override = env.VIBE_USAGE_ALMA_DB?.trim();
+  if (override) {
+    return platform === process.platform ? resolve(override) : pathImpl.resolve(override);
+  }
+  if (platform === 'darwin') {
+    return pathImpl.join(home, 'Library', 'Application Support', 'alma', 'chat_threads.db');
+  }
+  if (platform === 'win32') {
+    const appData = env.APPDATA?.trim() || pathImpl.join(home, 'AppData', 'Roaming');
+    return pathImpl.join(appData, 'alma', 'chat_threads.db');
+  }
+  const configHome = env.XDG_CONFIG_HOME?.trim() || pathImpl.join(home, '.config');
+  return pathImpl.join(configHome, 'alma', 'chat_threads.db');
+}
 
 function getCursorStateDbPath() {
   const rel = join('User', 'globalStorage', 'state.vscdb');
@@ -61,7 +82,6 @@ function findExtensionDirs(extensionId) {
   return dirs;
 }
 
-const findClineDataDirs = () => findExtensionDirs('saoudrizwan.claude-dev');
 const findRooCodeDataDirs = () => findExtensionDirs('rooveterinaryinc.roo-cline');
 
 /** Find all OpenClaw data roots: ~/.openclaw and ~/.openclaw-<profile> */
@@ -175,6 +195,12 @@ export function findDimAgentDataDirs() {
 }
 
 export const TOOLS = [
+  {
+    name: 'Alma',
+    id: 'alma',
+    dataDir: getAlmaDbPath(),
+    detectDataDirs: () => [getAlmaDbPath()].filter(existsSync),
+  },
   {
     name: 'Claude Code',
     id: 'claude-code',
@@ -198,6 +224,12 @@ export const TOOLS = [
     id: 'copilot-cli',
     dataDir: join(homedir(), '.copilot', 'session-state'),
   },
+  {
+    name: 'CraftAgent',
+    id: 'craft-agent',
+    dataDir: join(homedir(), '.craft-agent', 'workspaces'),
+    detectDataDirs: findCraftDataDirs,
+  },
   {
     name: 'Cursor',
     id: 'cursor',
@@ -225,10 +257,17 @@ export const TOOLS = [
     dataDir: join(homedir(), '.openclaw', 'agents'),
     detectDataDirs: findOpenclawDataDirs,
   },
+  {
+    name: 'Oh My Pi',
+    id: 'omp',
+    dataDir: join(homedir(), '.omp', 'agent', 'sessions'),
+    detectDataDirs: findOmpDataDirs,
+  },
   {
     name: 'pi',
     id: 'pi-coding-agent',
     dataDir: join(homedir(), '.pi', 'agent', 'sessions'),
+    detectDataDirs: findPiDataDirs,
   },
   {
     name: 'Qwen Code',
@@ -284,7 +323,7 @@ export const TOOLS = [
   {
     name: 'Cline',
     id: 'cline',
-    dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev'),
+    dataDir: join(homedir(), '.cline'),
     detectDataDirs: findClineDataDirs,
   },
   {
@@ -293,6 +332,12 @@ export const TOOLS = [
     dataDir: join(homedir(), 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'rooveterinaryinc.roo-cline'),
     detectDataDirs: findRooCodeDataDirs,
   },
+  {
+    name: 'WorkBuddy',
+    id: 'workbuddy',
+    dataDir: join(homedir(), '.workbuddy', 'projects'),
+    detectDataDirs: () => findWorkbuddyDataDirs().filter(existsSync),
+  },
   {
     name: 'ZCode',
     id: 'zcode',

package/src/workbuddy-roots.js

@@ -0,0 +1,19 @@
+import { delimiter, join } from 'node:path';
+import { homedir } from 'node:os';
+
+export function getDefaultWorkbuddyProjectsDir() {
+  return join(homedir(), '.workbuddy', 'projects');
+}
+
+// Fixture/relocation hook. Entries may name either the WorkBuddy home or its
+// projects/ directory; the parser normalizes both forms.
+export function findWorkbuddyDataDirs() {
+  const override = process.env.VIBE_USAGE_WORKBUDDY_DIRS?.trim();
+  if (!override) return [getDefaultWorkbuddyProjectsDir()];
+  return [...new Set(
+    override
+      .split(delimiter)
+      .map(entry => entry.trim())
+      .filter(Boolean)
+  )];
+}