@yhong91/vibetime 0.1.2 → 0.1.4

package/bin/vibetime.mjs

@@ -159,9 +159,9 @@ var init_fs = __esm({
 
 // src/cli.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir4, rename as rename2, rm, stat as stat8, writeFile as writeFile3 } from "node:fs/promises";
+import { mkdir as mkdir4, rename as rename2, rm, stat as stat10, writeFile as writeFile3 } from "node:fs/promises";
 import os7 from "node:os";
-import path16 from "node:path";
+import path18 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -197,7 +197,7 @@ var TELEMETRY_EVENT_TYPES = [
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
-var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -349,9 +349,9 @@ function removeVolatileHashFields(value) {
       continue;
     }
     if (key === "refs" && isRecord(item)) {
-      const refs = { ...item };
-      delete refs.payloadHash;
-      result[key] = removeVolatileHashFields(refs);
+      const refs2 = { ...item };
+      delete refs2.payloadHash;
+      result[key] = removeVolatileHashFields(refs2);
       continue;
     }
     result[key] = removeVolatileHashFields(item);
@@ -1195,7 +1195,7 @@ function countTextLines(text) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.2" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.4" : "0.1.1";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -1224,13 +1224,13 @@ function isPlainObject(value) {
   return value !== null && typeof value === "object" && !Array.isArray(value);
 }
 function stringRefs(value) {
-  const refs = {};
+  const refs2 = {};
   for (const [key, item] of Object.entries(value || {})) {
     if (typeof item === "string" && item.length > 0) {
-      refs[key] = item;
+      refs2[key] = item;
     }
   }
-  return refs;
+  return refs2;
 }
 function stringOption(value) {
   if (Array.isArray(value)) {
@@ -1308,7 +1308,7 @@ function withBackfillRefs(event, context) {
     event.type,
     event.refs?.sourceId
   ]);
-  const refs = {
+  const refs2 = {
     ...stringRefs(event.refs),
     importKey,
     sourcePathHash: context.sourcePathHash,
@@ -1318,12 +1318,12 @@ function withBackfillRefs(event, context) {
     parserVersion: PACKAGE_VERSION
   };
   if (context.options.includeSourcePath) {
-    refs.transcriptPath = context.filePath;
+    refs2.transcriptPath = context.filePath;
   }
   return {
     ...event,
     id: createStableEventId(importKey),
-    refs
+    refs: refs2
   };
 }
 function matchesBackfillFilters(event, options) {
@@ -2956,9 +2956,9 @@ async function parseClaudeCoworkSessionFile(filePath, options) {
     const sessionId = prefixCoworkId(event.sessionId);
     const turnId = prefixCoworkId(event.turnId);
     const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
-    const refs = { ...event.refs };
+    const refs2 = { ...event.refs };
     if (metadata.title) {
-      refs.coworkTitleHash = `sha256:${createStableHash(metadata.title)}`;
+      refs2.coworkTitleHash = `sha256:${createStableHash(metadata.title)}`;
     }
     const mapped = {
       ...event,
@@ -2970,7 +2970,7 @@ async function parseClaudeCoworkSessionFile(filePath, options) {
       project,
       sessionId,
       turnId,
-      refs
+      refs: refs2
     };
     return rebuildEventIdentity(mapped);
   });
@@ -3507,8 +3507,8 @@ async function codebuddyBackfillFiles(sourceRoot, home, env) {
           }
           const filePath = path8.join(traceDir, entry);
           try {
-            const stat9 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
-            files.push({ path: filePath, modifiedAt: stat9.mtime.toISOString() });
+            const stat11 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
+            files.push({ path: filePath, modifiedAt: stat11.mtime.toISOString() });
           } catch {
           }
         }
@@ -4513,19 +4513,19 @@ function opencodeDataCandidates(home, env) {
   return [primary, path10.join(home, ".opencode", "opencode.db")];
 }
 async function opencodeBackfillFiles(sourceRoot, home = os4.homedir(), env) {
-  const { stat: stat9 } = await import("node:fs/promises");
+  const { stat: stat11 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat9(sourceRoot).catch(() => null);
+    const info = await stat11(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
   for (const candidatePath of opencodeDataCandidates(home, env)) {
-    const info = await stat9(candidatePath).catch(() => null);
+    const info = await stat11(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -6580,6 +6580,758 @@ function normalizeId(id) {
   return id;
 }
 
+// src/adapters/workbuddy.ts
+import { readFile as readFile10, readdir as readdir7, stat as stat7 } from "node:fs/promises";
+import path14 from "node:path";
+init_fs();
+function workbuddyProjectsDir(home, env) {
+  const override = env?.WORKBUDDY_PROJECTS_DIR || env?.WORKBUDDY_HOME;
+  if (override && override.trim()) {
+    return path14.resolve(override, override.endsWith("projects") ? "" : "projects");
+  }
+  return path14.join(home, ".workbuddy", "projects");
+}
+function projectFromCwd(cwd, fallback) {
+  if (!cwd) {
+    return fallback;
+  }
+  return path14.basename(cwd) || fallback;
+}
+function sourceHash(filePath) {
+  return `sha256:${createStableHash(filePath)}`;
+}
+function makeEvent(event, line, filePath, options) {
+  const withRefs = withBackfillRefs(event, {
+    filePath,
+    sourcePathHash: sourceHash(filePath),
+    lineNumber: line.lineNumber,
+    topType: stringField(line.record, "type"),
+    payloadType: stringField(line.record, "role") || stringField(line.record, "name"),
+    options
+  });
+  return validateCanonicalEvent(withRefs).valid ? withRefs : void 0;
+}
+function workbuddyUsageMetrics(record) {
+  const providerData = objectField(record, "providerData");
+  const usage = objectField(providerData, "usage");
+  const rawUsage = objectField(providerData, "rawUsage");
+  if (Object.keys(usage).length === 0 && Object.keys(rawUsage).length === 0) {
+    return void 0;
+  }
+  const input = numberField(usage, "inputTokens") ?? numberField(rawUsage, "prompt_tokens") ?? 0;
+  const output = numberField(usage, "outputTokens") ?? numberField(rawUsage, "completion_tokens") ?? 0;
+  const total = numberField(usage, "totalTokens") ?? numberField(rawUsage, "total_tokens") ?? 0;
+  const cacheRead = workbuddyCachedTokens(usage, rawUsage);
+  const cacheCreate = numberField(rawUsage, "cache_creation_input_tokens") ?? numberField(rawUsage, "prompt_cache_write_tokens") ?? 0;
+  const reasoning = workbuddyReasoningTokens(usage, rawUsage);
+  if (!input && !output && !total && !cacheRead && !cacheCreate && !reasoning) {
+    return void 0;
+  }
+  return {
+    tokensInput: input,
+    tokensOutput: output,
+    tokensCachedInput: cacheRead + cacheCreate,
+    tokensCacheCreationInput: cacheCreate,
+    tokensCacheReadInput: cacheRead,
+    tokensReasoningOutput: reasoning,
+    tokensTotal: total || input + output,
+    modelCalls: 1
+  };
+}
+function workbuddyCachedTokens(usage, rawUsage) {
+  const rawCache = numberField(rawUsage, "cache_read_input_tokens") ?? numberField(rawUsage, "prompt_cache_hit_tokens") ?? numberField(rawUsage, "cached_tokens");
+  if (rawCache !== void 0) {
+    return rawCache;
+  }
+  const details = usage.inputTokensDetails;
+  if (Array.isArray(details) && isPlainObject(details[0])) {
+    return numberField(details[0], "cached_tokens") || 0;
+  }
+  const rawDetails = objectField(rawUsage, "prompt_tokens_details");
+  return numberField(rawDetails, "cached_tokens") || 0;
+}
+function workbuddyReasoningTokens(usage, rawUsage) {
+  const completionDetails = objectField(rawUsage, "completion_tokens_details");
+  const raw = numberField(completionDetails, "reasoning_tokens") ?? numberField(rawUsage, "completion_thinking_tokens");
+  if (raw !== void 0) {
+    return raw;
+  }
+  const details = usage.outputTokensDetails;
+  if (Array.isArray(details) && isPlainObject(details[0])) {
+    return numberField(details[0], "reasoning_tokens") || 0;
+  }
+  return 0;
+}
+function contentLength(value) {
+  if (typeof value === "string") {
+    return value.length;
+  }
+  if (Array.isArray(value)) {
+    return value.reduce((total, item) => {
+      if (!isPlainObject(item)) {
+        return total;
+      }
+      return total + (stringField(item, "text") || stringField(item, "input_text") || stringField(item, "output_text") || "").length;
+    }, 0);
+  }
+  return 0;
+}
+async function readWorkbuddyLines(filePath) {
+  const text = await readFile10(filePath, "utf8");
+  return text.split(/\r?\n/).map((line, index) => {
+    if (!line.trim()) {
+      return void 0;
+    }
+    try {
+      const record = JSON.parse(line);
+      return isPlainObject(record) ? { lineNumber: index + 1, record } : void 0;
+    } catch {
+      return void 0;
+    }
+  }).filter((line) => Boolean(line));
+}
+async function parseWorkbuddySessionFile(filePath, options) {
+  const lines = await readWorkbuddyLines(filePath);
+  if (lines.length === 0) {
+    return [];
+  }
+  const events = [];
+  const first = lines[0].record;
+  const sessionId = stringField(first, "sessionId") || path14.basename(filePath, ".jsonl");
+  const fallbackProject = path14.basename(path14.dirname(filePath));
+  const cwd = lines.map((line) => stringField(line.record, "cwd")).find(Boolean);
+  const project = projectFromCwd(cwd, fallbackProject);
+  const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
+  const sessionPrefix = `workbuddy:${sessionId}`;
+  const toolStarts = /* @__PURE__ */ new Map();
+  let currentTurnId = `${sessionPrefix}:turn:0`;
+  let turnIndex = 0;
+  const firstTs = lines.map((line) => timestampFrom(numberField(line.record, "timestamp"))).find(Boolean);
+  if (firstTs) {
+    const event = makeEvent({
+      schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+      ts: firstTs,
+      type: "session.started",
+      source: "workbuddy",
+      workspaceId,
+      project,
+      cwd,
+      sessionId: sessionPrefix,
+      agent: "workbuddy",
+      confidence: "derived",
+      refs: { sourceId: `${sessionPrefix}:session` }
+    }, lines[0], filePath, options);
+    if (event) events.push(event);
+  }
+  for (const line of lines) {
+    const record = line.record;
+    const ts = timestampFrom(numberField(record, "timestamp"));
+    if (!ts) {
+      continue;
+    }
+    const type = stringField(record, "type");
+    const sourceId = stringField(record, "id") || `${line.lineNumber}`;
+    if (type === "message" && stringField(record, "role") === "user") {
+      turnIndex += 1;
+      currentTurnId = `${sessionPrefix}:turn:${turnIndex}`;
+      const promptChars = contentLength(record.content);
+      for (const event of [
+        makeEvent({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts,
+          type: "turn.started",
+          source: "workbuddy",
+          workspaceId,
+          project,
+          cwd,
+          sessionId: sessionPrefix,
+          turnId: currentTurnId,
+          agent: "workbuddy",
+          confidence: "derived",
+          refs: { sourceId: `${sourceId}:turn` }
+        }, line, filePath, options),
+        makeEvent({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts,
+          type: "prompt.submitted",
+          source: "workbuddy",
+          workspaceId,
+          project,
+          cwd,
+          sessionId: sessionPrefix,
+          turnId: currentTurnId,
+          agent: "workbuddy",
+          metrics: { promptChars, prompts: 1 },
+          confidence: "partial",
+          refs: { sourceId: `${sourceId}:prompt` }
+        }, line, filePath, options)
+      ]) {
+        if (event) events.push(event);
+      }
+      continue;
+    }
+    if (type === "function_call") {
+      const tool = stringField(record, "name");
+      const callId = stringField(record, "callId");
+      if (tool && callId) {
+        toolStarts.set(`${sessionId}:${callId}`, { line, ts, tool, callId });
+        const started = makeEvent({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts,
+          type: "tool.started",
+          source: "workbuddy",
+          workspaceId,
+          project,
+          cwd,
+          sessionId: sessionPrefix,
+          turnId: currentTurnId,
+          spanId: `${sessionPrefix}:tool:${callId}`,
+          agent: "workbuddy",
+          tool,
+          confidence: "exact",
+          refs: { sourceId: `${callId}:start` }
+        }, line, filePath, options);
+        if (started) events.push(started);
+      }
+      const metrics = workbuddyUsageMetrics(record);
+      const model = stringField(objectField(record, "providerData"), "model");
+      if (metrics || model) {
+        const usage = makeEvent({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts,
+          type: "model.usage",
+          source: "workbuddy",
+          workspaceId,
+          project,
+          cwd,
+          sessionId: sessionPrefix,
+          turnId: currentTurnId,
+          agent: "workbuddy",
+          model,
+          metrics,
+          confidence: metrics ? "partial" : "derived",
+          refs: { sourceId: `${sourceId}:usage:${callId || line.lineNumber}` }
+        }, line, filePath, options);
+        if (usage) events.push(usage);
+      }
+      continue;
+    }
+    if (type === "function_call_result") {
+      const tool = stringField(record, "name") || "tool";
+      const callId = stringField(record, "callId") || `${line.lineNumber}`;
+      const start = toolStarts.get(`${sessionId}:${callId}`);
+      const durationMs = start?.ts ? Math.max(0, Date.parse(ts) - Date.parse(start.ts)) : void 0;
+      const status = stringField(record, "status");
+      const completed = makeEvent({
+        schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+        ts,
+        type: status === "failed" ? "tool.failed" : "tool.completed",
+        source: "workbuddy",
+        workspaceId,
+        project,
+        cwd,
+        sessionId: sessionPrefix,
+        turnId: currentTurnId,
+        spanId: `${sessionPrefix}:tool:${callId}`,
+        agent: "workbuddy",
+        tool,
+        success: status !== "failed",
+        metrics: { toolDurationMs: durationMs, durationMs },
+        confidence: start ? "derived" : "partial",
+        refs: { sourceId: `${callId}:result` }
+      }, line, filePath, options);
+      if (completed) events.push(completed);
+    }
+  }
+  const lastLine = lines.at(-1);
+  const lastTs = lastLine ? timestampFrom(numberField(lastLine.record, "timestamp")) : void 0;
+  if (lastLine && lastTs) {
+    const event = makeEvent({
+      schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+      ts: lastTs,
+      type: "session.ended",
+      source: "workbuddy",
+      workspaceId,
+      project,
+      cwd,
+      sessionId: sessionPrefix,
+      agent: "workbuddy",
+      confidence: "derived",
+      refs: { sourceId: `${sessionPrefix}:ended` }
+    }, lastLine, filePath, options);
+    if (event) events.push(event);
+  }
+  return events;
+}
+async function workbuddyBackfillFiles(sourceRoot, home, env) {
+  const base = sourceRoot || workbuddyProjectsDir(home, env);
+  const files = [];
+  try {
+    const projects = await readdir7(base, { withFileTypes: true });
+    for (const project of projects) {
+      if (!project.isDirectory()) {
+        continue;
+      }
+      const projectDir = path14.join(base, project.name);
+      const entries = await readdir7(projectDir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+          const filePath = path14.join(projectDir, entry.name);
+          const info = await stat7(filePath);
+          files.push({ path: filePath, modifiedAt: info.mtime.toISOString() });
+        }
+      }
+    }
+  } catch {
+    return [];
+  }
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+function createWorkbuddyAdapter() {
+  return {
+    id: "workbuddy",
+    label: "WorkBuddy",
+    agentName: "workbuddy",
+    kind: "agent",
+    detectPath(home, env) {
+      return workbuddyProjectsDir(home, env);
+    },
+    installedPath(home, env) {
+      return workbuddyProjectsDir(home, env);
+    },
+    async isInstalled(home, env) {
+      return pathExists(workbuddyProjectsDir(home, env));
+    },
+    installEntries() {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return [workbuddyProjectsDir(home, env)];
+    },
+    parseSessionFile: parseWorkbuddySessionFile
+  };
+}
+
+// src/adapters/zcode.ts
+import { execFile } from "node:child_process";
+import { stat as stat8 } from "node:fs/promises";
+import path15 from "node:path";
+import { promisify as promisify2 } from "node:util";
+init_fs();
+var execFileAsync = promisify2(execFile);
+function zcodeCliDir(home, env) {
+  const override = env?.ZCODE_CLI_DIR || env?.ZCODE_HOME;
+  if (override && override.trim()) {
+    return path15.resolve(override, override.endsWith("cli") ? "" : "cli");
+  }
+  return path15.join(home, ".zcode", "cli");
+}
+function zcodeDbPath(home, env) {
+  return path15.join(zcodeCliDir(home, env), "db", "db.sqlite");
+}
+function sourceHash2(filePath) {
+  return `sha256:${createStableHash(filePath)}`;
+}
+function projectFromDirectory(directory) {
+  return directory ? path15.basename(directory) || "zcode" : "zcode";
+}
+function isoFromMs(value) {
+  return timestampFrom(typeof value === "number" ? value : Number(value));
+}
+function makeEvent2(event, row, rowNumber, filePath, options) {
+  const withRefs = withBackfillRefs(event, {
+    filePath,
+    sourcePathHash: sourceHash2(filePath),
+    lineNumber: rowNumber,
+    topType: row.kind,
+    payloadType: stringField(row, "status") || stringField(row, "query_source") || stringField(row, "tool_name"),
+    options
+  });
+  return validateCanonicalEvent(withRefs).valid ? withRefs : void 0;
+}
+function refs(values) {
+  const out = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== void 0 && value !== "") {
+      out[key] = String(value);
+    }
+  }
+  return out;
+}
+async function sqliteJsonRows(dbPath, sql) {
+  try {
+    const { stdout } = await execFileAsync("sqlite3", ["-readonly", dbPath, sql], {
+      maxBuffer: 32 * 1024 * 1024
+    });
+    return stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+      try {
+        const parsed = JSON.parse(line);
+        return isPlainObject(parsed) ? parsed : void 0;
+      } catch {
+        return void 0;
+      }
+    }).filter((row) => Boolean(row));
+  } catch {
+    return [];
+  }
+}
+async function readZCodeRows(dbPath) {
+  const queries = [
+    `select json_object(
+      'kind','session',
+      'id',id,
+      'parent_id',parent_id,
+      'directory',directory,
+      'title',title,
+      'task_type',task_type,
+      'time_created',time_created,
+      'time_updated',time_updated
+    ) from session order by time_created, id;`,
+    `select json_object(
+      'kind','turn',
+      'session_id',session_id,
+      'turn_id',turn_id,
+      'status',status,
+      'started_at',started_at,
+      'completed_at',completed_at,
+      'duration_ms',duration_ms,
+      'model_request_count',model_request_count,
+      'tool_call_count',tool_call_count,
+      'input_tokens',input_tokens,
+      'output_tokens',output_tokens,
+      'reasoning_tokens',reasoning_tokens,
+      'cache_creation_input_tokens',cache_creation_input_tokens,
+      'cache_read_input_tokens',cache_read_input_tokens,
+      'computed_total_tokens',computed_total_tokens
+    ) from turn_usage order by started_at, session_id, turn_id;`,
+    `select json_object(
+      'kind','model',
+      'id',id,
+      'session_id',session_id,
+      'turn_id',turn_id,
+      'query_source',query_source,
+      'provider_id',provider_id,
+      'model_id',model_id,
+      'agent',agent,
+      'mode',mode,
+      'status',status,
+      'started_at',started_at,
+      'completed_at',completed_at,
+      'duration_ms',duration_ms,
+      'input_tokens',input_tokens,
+      'output_tokens',output_tokens,
+      'reasoning_tokens',reasoning_tokens,
+      'cache_creation_input_tokens',cache_creation_input_tokens,
+      'cache_read_input_tokens',cache_read_input_tokens,
+      'computed_total_tokens',computed_total_tokens,
+      'tool_call_count',tool_call_count
+    ) from model_usage order by started_at, id;`,
+    `select json_object(
+      'kind','tool',
+      'id',id,
+      'session_id',session_id,
+      'turn_id',turn_id,
+      'tool_call_id',tool_call_id,
+      'tool_name',tool_name,
+      'side_effect_scope',side_effect_scope,
+      'read_only',read_only,
+      'destructive',destructive,
+      'approval_status',approval_status,
+      'status',status,
+      'started_at',started_at,
+      'completed_at',completed_at,
+      'duration_ms',duration_ms,
+      'output_bytes',output_bytes,
+      'exit_code',exit_code
+    ) from tool_usage order by started_at, id;`
+  ];
+  const results = await Promise.all(queries.map((query) => sqliteJsonRows(dbPath, query)));
+  return results.flat();
+}
+function modelMetrics(row) {
+  const input = numberField(row, "input_tokens") || 0;
+  const output = numberField(row, "output_tokens") || 0;
+  const reasoning = numberField(row, "reasoning_tokens") || 0;
+  const cacheCreation = numberField(row, "cache_creation_input_tokens") || 0;
+  const cacheRead = numberField(row, "cache_read_input_tokens") || 0;
+  const total = numberField(row, "computed_total_tokens") || input + output + reasoning;
+  const durationMs = numberField(row, "duration_ms");
+  return {
+    tokensInput: input,
+    tokensOutput: output,
+    tokensReasoningOutput: reasoning,
+    tokensCachedInput: cacheCreation + cacheRead,
+    tokensCacheCreationInput: cacheCreation,
+    tokensCacheReadInput: cacheRead,
+    tokensTotal: total,
+    modelDurationMs: durationMs,
+    durationMs,
+    modelCalls: 1,
+    toolCalls: numberField(row, "tool_call_count")
+  };
+}
+function sessionContext(row, sessions) {
+  const sessionId = stringField(row, "session_id") || stringField(row, "id") || "unknown";
+  const session = sessions.get(sessionId);
+  const cwd = stringField(session, "directory");
+  const project = projectFromDirectory(cwd);
+  return {
+    rawSessionId: sessionId,
+    sessionId: `zcode:${sessionId}`,
+    cwd,
+    project,
+    workspaceId: createWorkspaceId({ projectName: project, repoRoot: cwd }),
+    parentSessionId: stringField(session, "parent_id") ? `zcode:${stringField(session, "parent_id")}` : void 0
+  };
+}
+async function parseZCodeDb(filePath, options) {
+  const rows = await readZCodeRows(filePath);
+  if (rows.length === 0) {
+    return [];
+  }
+  const sessions = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.kind === "session") {
+      const id = stringField(row, "id");
+      if (id) {
+        sessions.set(id, row);
+      }
+    }
+  }
+  const events = [];
+  rows.forEach((row, index) => {
+    const rowNumber = index + 1;
+    if (row.kind === "session") {
+      const id = stringField(row, "id");
+      const ts = isoFromMs(numberField(row, "time_created"));
+      if (!id || !ts) {
+        return;
+      }
+      const ctx = sessionContext(row, sessions);
+      const event = makeEvent2({
+        schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+        ts,
+        type: "session.started",
+        source: "zcode",
+        workspaceId: ctx.workspaceId,
+        project: ctx.project,
+        cwd: ctx.cwd,
+        sessionId: ctx.sessionId,
+        parentAgentInstanceId: ctx.parentSessionId,
+        agent: "zcode",
+        confidence: "exact",
+        refs: refs({
+          sourceId: `${id}:session`,
+          zcodeTaskType: stringField(row, "task_type"),
+          zcodeTitleHash: stringField(row, "title") ? `sha256:${createStableHash(stringField(row, "title"))}` : void 0
+        })
+      }, row, rowNumber, filePath, options);
+      if (event) events.push(event);
+      const completedTs = isoFromMs(numberField(row, "time_updated"));
+      if (completedTs && completedTs !== ts) {
+        const completed = makeEvent2({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts: completedTs,
+          type: "session.ended",
+          source: "zcode",
+          workspaceId: ctx.workspaceId,
+          project: ctx.project,
+          cwd: ctx.cwd,
+          sessionId: ctx.sessionId,
+          parentAgentInstanceId: ctx.parentSessionId,
+          agent: "zcode",
+          confidence: "exact",
+          refs: { sourceId: `${id}:session:ended` }
+        }, row, rowNumber, filePath, options);
+        if (completed) events.push(completed);
+      }
+      return;
+    }
+    if (row.kind === "turn") {
+      const rawTurnId = stringField(row, "turn_id");
+      const ts = isoFromMs(numberField(row, "started_at"));
+      if (!rawTurnId || !ts) {
+        return;
+      }
+      const ctx = sessionContext(row, sessions);
+      const turnId = `zcode:${rawTurnId}`;
+      const started = makeEvent2({
+        schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+        ts,
+        type: "turn.started",
+        source: "zcode",
+        workspaceId: ctx.workspaceId,
+        project: ctx.project,
+        cwd: ctx.cwd,
+        sessionId: ctx.sessionId,
+        turnId,
+        agent: "zcode",
+        confidence: "exact",
+        refs: { sourceId: `${rawTurnId}:start` }
+      }, row, rowNumber, filePath, options);
+      if (started) events.push(started);
+      const completedTs = isoFromMs(numberField(row, "completed_at"));
+      if (completedTs) {
+        const status = stringField(row, "status");
+        const completed = makeEvent2({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts: completedTs,
+          type: "turn.completed",
+          source: "zcode",
+          workspaceId: ctx.workspaceId,
+          project: ctx.project,
+          cwd: ctx.cwd,
+          sessionId: ctx.sessionId,
+          turnId,
+          agent: "zcode",
+          success: status === "completed",
+          metrics: {
+            durationMs: numberField(row, "duration_ms"),
+            turns: 1,
+            modelCalls: numberField(row, "model_request_count"),
+            toolCalls: numberField(row, "tool_call_count")
+          },
+          confidence: "exact",
+          refs: refs({ sourceId: `${rawTurnId}:completed`, zcodeStatus: status })
+        }, row, rowNumber, filePath, options);
+        if (completed) events.push(completed);
+      }
+      return;
+    }
+    if (row.kind === "model") {
+      const ts = isoFromMs(numberField(row, "completed_at")) || isoFromMs(numberField(row, "started_at"));
+      if (!ts) {
+        return;
+      }
+      const ctx = sessionContext(row, sessions);
+      const modelId = stringField(row, "model_id");
+      const usage = makeEvent2({
+        schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+        ts,
+        type: "model.usage",
+        source: "zcode",
+        workspaceId: ctx.workspaceId,
+        project: ctx.project,
+        cwd: ctx.cwd,
+        sessionId: ctx.sessionId,
+        turnId: stringField(row, "turn_id") ? `zcode:${stringField(row, "turn_id")}` : void 0,
+        agent: stringField(row, "agent") || "zcode",
+        provider: stringField(row, "provider_id"),
+        model: modelId,
+        success: stringField(row, "status") === "completed",
+        metrics: modelMetrics(row),
+        confidence: "exact",
+        refs: refs({
+          sourceId: stringField(row, "id") || `${ctx.rawSessionId}:model:${rowNumber}`,
+          zcodeQuerySource: stringField(row, "query_source"),
+          zcodeMode: stringField(row, "mode"),
+          zcodeStatus: stringField(row, "status")
+        })
+      }, row, rowNumber, filePath, options);
+      if (usage) events.push(usage);
+      return;
+    }
+    if (row.kind === "tool") {
+      const startedTs = isoFromMs(numberField(row, "started_at"));
+      const completedTs = isoFromMs(numberField(row, "completed_at")) || startedTs;
+      const tool = stringField(row, "tool_name") || "tool";
+      const toolCallId = stringField(row, "tool_call_id") || stringField(row, "id") || `${rowNumber}`;
+      if (!startedTs) {
+        return;
+      }
+      const ctx = sessionContext(row, sessions);
+      const turnId = stringField(row, "turn_id") ? `zcode:${stringField(row, "turn_id")}` : void 0;
+      const spanId = `${ctx.sessionId}:tool:${toolCallId}`;
+      const started = makeEvent2({
+        schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+        ts: startedTs,
+        type: "tool.started",
+        source: "zcode",
+        workspaceId: ctx.workspaceId,
+        project: ctx.project,
+        cwd: ctx.cwd,
+        sessionId: ctx.sessionId,
+        turnId,
+        spanId,
+        agent: "zcode",
+        tool,
+        confidence: "exact",
+        refs: refs({
+          sourceId: `${toolCallId}:start`,
+          zcodeSideEffectScope: stringField(row, "side_effect_scope"),
+          zcodeApprovalStatus: stringField(row, "approval_status")
+        })
+      }, row, rowNumber, filePath, options);
+      if (started) events.push(started);
+      if (completedTs) {
+        const status = stringField(row, "status");
+        const completed = makeEvent2({
+          schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+          ts: completedTs,
+          type: status === "completed" ? "tool.completed" : "tool.failed",
+          source: "zcode",
+          workspaceId: ctx.workspaceId,
+          project: ctx.project,
+          cwd: ctx.cwd,
+          sessionId: ctx.sessionId,
+          turnId,
+          spanId,
+          agent: "zcode",
+          tool,
+          success: status === "completed",
+          metrics: {
+            toolDurationMs: numberField(row, "duration_ms"),
+            durationMs: numberField(row, "duration_ms"),
+            bytesRead: numberField(row, "output_bytes")
+          },
+          confidence: "exact",
+          refs: refs({
+            sourceId: `${toolCallId}:completed`,
+            zcodeStatus: status,
+            zcodeExitCode: numberField(row, "exit_code")
+          })
+        }, row, rowNumber, filePath, options);
+        if (completed) events.push(completed);
+      }
+    }
+  });
+  return events.sort((a, b) => a.ts.localeCompare(b.ts) || (a.id || "").localeCompare(b.id || ""));
+}
+async function zcodeBackfillFiles(sourceRoot, home, env) {
+  const candidate = sourceRoot || zcodeDbPath(home, env);
+  const filePath = candidate.endsWith(".sqlite") ? candidate : path15.join(candidate, "db", "db.sqlite");
+  try {
+    const info = await stat8(filePath);
+    return [{ path: filePath, modifiedAt: info.mtime.toISOString() }];
+  } catch {
+    return [];
+  }
+}
+function createZCodeAdapter() {
+  return {
+    id: "zcode",
+    label: "ZCode",
+    agentName: "zcode",
+    kind: "agent",
+    detectPath(home, env) {
+      return zcodeCliDir(home, env);
+    },
+    installedPath(home, env) {
+      return zcodeDbPath(home, env);
+    },
+    async isInstalled(home, env) {
+      return pathExists(zcodeDbPath(home, env));
+    },
+    installEntries() {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return [zcodeDbPath(home, env)];
+    },
+    parseSessionFile: parseZCodeDb
+  };
+}
+
 // src/lib/pricing.ts
 function estimateEventCostUsd(event) {
   if (event.type !== "model.usage") {
@@ -7016,15 +7768,15 @@ function hookCommandFromGroup(group) {
 import { randomUUID } from "node:crypto";
 import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import path14 from "node:path";
+import path16 from "node:path";
 function configDir(home = homedir()) {
-  return path14.join(home, ".vibetime");
+  return path16.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path14.join(configDir(home), "config.json");
+  return path16.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path14.join(configDir(home), "machine-id");
+  return path16.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -7071,15 +7823,15 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir3, rename, stat as stat7 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir3, rename, stat as stat9 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path15 from "node:path";
+import path17 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path15.join(home, ".vibetime", "logs");
+  return path17.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path15.join(logDir(home), name);
+  return path17.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -7089,7 +7841,7 @@ function serializeError(error) {
 }
 async function rotateIfNeeded(file) {
   try {
-    const info = await stat7(file);
+    const info = await stat9(file);
     if (info.size > MAX_BYTES) {
       await rename(file, `${file}.1`).catch(() => {
       });
@@ -7254,8 +8006,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path17) {
-  return new URL(path17, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path19) {
+  return new URL(path19, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -7320,7 +8072,7 @@ async function deleteMachine(remote, id) {
 }
 
 // src/lib/types.ts
-var BACKFILL_STATE_SCHEMA_VERSION = 4;
+var BACKFILL_STATE_SCHEMA_VERSION = 5;
 
 // src/cli.ts
 function createRegistry() {
@@ -7334,6 +8086,8 @@ function createRegistry() {
   registry.register(createCodebuddyAdapter());
   registry.register(createQoderAdapter());
   registry.register(createQoderCnAdapter());
+  registry.register(createWorkbuddyAdapter());
+  registry.register(createZCodeAdapter());
   return registry;
 }
 var defaultContext = {
@@ -7745,11 +8499,17 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "codebuddy") {
     return codebuddyBackfillFiles(stringOption(options["source-root"]), resolveHome2(options, ctx), ctx.env);
   }
+  if (source.id === "workbuddy") {
+    return workbuddyBackfillFiles(stringOption(options["source-root"]), resolveHome2(options, ctx), ctx.env);
+  }
+  if (source.id === "zcode") {
+    return zcodeBackfillFiles(stringOption(options["source-root"]), resolveHome2(options, ctx), ctx.env);
+  }
   const roots = stringOption(options["source-root"]) ? [requiredOption(options, "source-root")] : source.paths;
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
   const files = fileLists.flat().sort().slice(0, numberOption(options.limit) || void 0);
   return Promise.all(files.map(async (filePath) => {
-    const info = await stat8(filePath);
+    const info = await stat10(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -7833,10 +8593,12 @@ async function importBackfillPlan(plan, options, ctx, registry) {
     return 1;
   }
   const sourceDefs = registry.all().filter((a) => supportedSources.has(a.id) && (source === "all" || a.id === source)).map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home, ctx.env) }));
+  const remote = resolveRemoteFromOptions(options, ctx);
+  const remoteKey = backfillRemoteKey(remote?.baseUrl ?? DEFAULT_API_URL);
   if (options.force) {
-    await purgeForcedSources(sourceDefs, home, options, ctx);
+    await purgeForcedSources(sourceDefs, home, remoteKey, options, ctx);
   }
-  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home, ctx) : void 0;
+  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home, remoteKey, ctx) : void 0;
   if (!options.json) {
     write(ctx.stdout, `importRun ${plan.importRun.importRunId}
 `);
@@ -7864,13 +8626,15 @@ async function importBackfillPlan(plan, options, ctx, registry) {
 `);
   }
   if (counts.failed === 0 && counts.conflicts === 0 && incrementalState) {
-    await updateBackfillIncrementalState(home, incrementalState, selectedFilesBySource);
+    await updateBackfillIncrementalState(home, remoteKey, incrementalState, selectedFilesBySource);
   }
   return counts.failed > 0 || counts.conflicts > 0 && !options["skip-conflicts"] ? 1 : 0;
 }
-async function purgeForcedSources(sourceDefs, home, options, ctx) {
+async function purgeForcedSources(sourceDefs, home, remoteKey, options, ctx) {
   try {
-    await rm(backfillIncrementalStatePath(home), { force: true });
+    const file = await readBackfillIncrementalStateFile(home);
+    delete file.remotes[remoteKey];
+    await writeBackfillIncrementalStateFile(home, file);
   } catch (error) {
     debug(ctx, `Failed to clear backfill watermark: ${error.message}
 `);
@@ -8058,44 +8822,83 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path16.join(home, ".vibetime", "backfill-state.json");
+  return path18.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path16.join(home, ".vibetime", "sync-local-trigger.json");
+  return path18.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path16.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path18.join(home, ".vibetime", "sync-local-trigger.lock");
+}
+function backfillRemoteKey(baseUrl) {
+  try {
+    const url = new URL(baseUrl);
+    return `${url.protocol}//${url.host}${url.pathname.replace(/\/+$/, "")}`;
+  } catch {
+    return baseUrl.replace(/\/+$/, "");
+  }
+}
+function sanitizeBackfillSources(raw) {
+  const sources = {};
+  if (!isPlainObject(raw)) {
+    return sources;
+  }
+  for (const source of BACKFILL_SOURCE_IDS) {
+    const item = raw[source];
+    if (isPlainObject(item) && typeof item.watermarkTs === "string" && !Number.isNaN(Date.parse(item.watermarkTs))) {
+      sources[source] = { watermarkTs: item.watermarkTs };
+    }
+  }
+  return sources;
 }
-async function readBackfillIncrementalState(home, ctx) {
+async function readBackfillIncrementalStateFile(home, ctx) {
+  const empty = { version: BACKFILL_STATE_SCHEMA_VERSION, remotes: {} };
   const statePath = backfillIncrementalStatePath(home);
   const state = await readJsonIfExists(statePath);
   if (state === null) {
-    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+    return empty;
   }
-  if (!isPlainObject(state) || !isPlainObject(state.sources)) {
+  if (!isPlainObject(state)) {
     if (ctx) {
       debug(ctx, `backfill-state malformed at ${statePath}; ignoring watermarks
 `);
     }
-    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+    return empty;
   }
   if (state.version !== BACKFILL_STATE_SCHEMA_VERSION) {
     if (ctx) {
       debug(ctx, `backfill-state version ${String(state.version)} at ${statePath} differs from current v${BACKFILL_STATE_SCHEMA_VERSION}; dropping watermarks so the next sync re-imports under the new parser
 `);
     }
-    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+    return empty;
   }
-  const sources = {};
-  for (const source of BACKFILL_SOURCE_IDS) {
-    const item = state.sources[source];
-    if (isPlainObject(item) && typeof item.watermarkTs === "string" && !Number.isNaN(Date.parse(item.watermarkTs))) {
-      sources[source] = { watermarkTs: item.watermarkTs };
+  if (!isPlainObject(state.remotes)) {
+    if (ctx) {
+      debug(ctx, `backfill-state malformed at ${statePath}; ignoring watermarks
+`);
     }
+    return empty;
   }
-  return { version: BACKFILL_STATE_SCHEMA_VERSION, sources };
+  const remotes = {};
+  for (const [remoteKey, entry] of Object.entries(state.remotes)) {
+    if (!isPlainObject(entry)) {
+      continue;
+    }
+    remotes[remoteKey] = { sources: sanitizeBackfillSources(entry.sources) };
+  }
+  return { version: BACKFILL_STATE_SCHEMA_VERSION, remotes };
+}
+async function writeBackfillIncrementalStateFile(home, file) {
+  const statePath = backfillIncrementalStatePath(home);
+  await mkdir4(path18.dirname(statePath), { recursive: true });
+  await writeFile3(statePath, `${JSON.stringify(file, null, 2)}
+`, "utf8");
+}
+async function readBackfillIncrementalState(home, remoteKey, ctx) {
+  const file = await readBackfillIncrementalStateFile(home, ctx);
+  return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: file.remotes[remoteKey]?.sources ?? {} };
 }
-async function updateBackfillIncrementalState(home, state, selectedFilesBySource) {
+async function updateBackfillIncrementalState(home, remoteKey, state, selectedFilesBySource) {
   for (const [source, files] of selectedFilesBySource.entries()) {
     const latest = maxTimestamp(files.map((f) => f.modifiedAt));
     if (!latest) {
@@ -8103,10 +8906,9 @@ async function updateBackfillIncrementalState(home, state, selectedFilesBySource
     }
     state.sources[source] = { watermarkTs: latest };
   }
-  const statePath = backfillIncrementalStatePath(home);
-  await mkdir4(path16.dirname(statePath), { recursive: true });
-  await writeFile3(statePath, `${JSON.stringify(state, null, 2)}
-`, "utf8");
+  const file = await readBackfillIncrementalStateFile(home);
+  file.remotes[remoteKey] = { sources: state.sources };
+  await writeBackfillIncrementalStateFile(home, file);
 }
 async function readSyncLocalTriggerState(statePath) {
   let state;
@@ -8137,7 +8939,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir4(path16.dirname(statePath), { recursive: true });
+  await mkdir4(path18.dirname(statePath), { recursive: true });
   const tmpPath = `${statePath}.tmp`;
   await writeFile3(tmpPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
@@ -8154,7 +8956,7 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir4(path16.dirname(lockPath), { recursive: true });
+  await mkdir4(path18.dirname(lockPath), { recursive: true });
   await writeFile3(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
@@ -8214,10 +9016,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path16.resolve(path16.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path18.resolve(path18.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome2(options, ctx) {
-  return path16.resolve(stringOption(options.home) || ctx.env.HOME || os7.homedir());
+  return path18.resolve(stringOption(options.home) || ctx.env.HOME || os7.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@yhong91/vibetime",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "vibetime CLI — install AI-agent hooks (Claude Code, Codex, OpenCode, Pi) and report activity to vibetime.",
   "license": "MIT",
   "publishConfig": {