@yhong91/vibetime 0.1.1 → 0.1.3

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 stat7, writeFile as writeFile3 } from "node:fs/promises";
-import os6 from "node:os";
-import path15 from "node:path";
+import { mkdir as mkdir4, rename as rename2, rm, stat as stat10, writeFile as writeFile3 } from "node:fs/promises";
+import os7 from "node:os";
+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", "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.1" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.3" : "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) {
@@ -2776,11 +2776,256 @@ function createClaudeCodeAdapter() {
   };
 }
 
-// src/adapters/codebuddy.ts
-import { readFile as readFile4, readdir as readdir3 } from "node:fs/promises";
+// src/adapters/claude-cowork.ts
+import { readdir as readdir3, readFile as readFile4, stat as stat4 } from "node:fs/promises";
+import os3 from "node:os";
 import path7 from "node:path";
+init_fs();
+var COWORK_PREFIX = "cowork:";
+function coworkDataDirs(home, env) {
+  const override = env?.COWORK_DIR || env?.CLAUDE_COWORK_DIR;
+  if (override && override.trim()) {
+    return override.split(",").map((item) => item.trim()).filter(Boolean).map((item) => path7.resolve(item));
+  }
+  return [
+    path7.join(home, "Library", "Application Support", "Claude", "local-agent-mode-sessions"),
+    path7.join(home, ".config", "Claude", "local-agent-mode-sessions"),
+    path7.join(home, "AppData", "Local", "Packages", "Claude_pzs8sxrjxfjjc", "LocalCache", "Roaming", "Claude", "local-agent-mode-sessions"),
+    path7.join(home, "AppData", "Roaming", "Claude", "local-agent-mode-sessions")
+  ];
+}
+function isCoworkMetaFileName(name) {
+  return /^local_[\w-]+\.json$/.test(name);
+}
+async function readCoworkMeta(filePath) {
+  try {
+    const raw = JSON.parse(await readFile4(filePath, "utf8"));
+    return raw && typeof raw === "object" ? raw : {};
+  } catch {
+    return {};
+  }
+}
+async function isRegularFile(filePath) {
+  try {
+    return (await stat4(filePath)).isFile();
+  } catch {
+    return false;
+  }
+}
+async function resolveCoworkTranscript(sessionDir, cliSessionId) {
+  if (!sessionDir || !cliSessionId) {
+    return void 0;
+  }
+  const projectsDir = path7.join(sessionDir, ".claude", "projects");
+  let entries;
+  try {
+    entries = await readdir3(projectsDir, { withFileTypes: true });
+  } catch {
+    return void 0;
+  }
+  const target = `${cliSessionId}.jsonl`;
+  for (const entry of entries) {
+    if (!entry.isDirectory() && !entry.isSymbolicLink()) {
+      continue;
+    }
+    const candidate = path7.join(projectsDir, entry.name, target);
+    if (await isRegularFile(candidate)) {
+      return candidate;
+    }
+  }
+  return void 0;
+}
+async function coworkSubagentTranscripts(mainTranscript, cliSessionId) {
+  const root = path7.join(path7.dirname(mainTranscript), cliSessionId, "subagents");
+  const out = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+      const entryPath = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryPath);
+        return;
+      }
+      if (entry.isFile() && /^agent-.+\.jsonl$/.test(entry.name)) {
+        out.push(entryPath);
+      }
+    }));
+  }
+  await walk(root);
+  return out.sort();
+}
+async function discoverCoworkTranscripts(root) {
+  const transcripts = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir3(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    await Promise.all(entries.map(async (entry) => {
+      const entryPath = path7.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        if (entry.name.startsWith("local_") || entry.name === "skills-plugin" || entry.name === "node_modules" || entry.name === ".git") {
+          return;
+        }
+        await walk(entryPath);
+        return;
+      }
+      if (!entry.isFile() || !isCoworkMetaFileName(entry.name)) {
+        return;
+      }
+      const metadata = await readCoworkMeta(entryPath);
+      if (!metadata.cliSessionId) {
+        return;
+      }
+      const sessionDir = entryPath.slice(0, -".json".length);
+      const mainTranscript = await resolveCoworkTranscript(sessionDir, metadata.cliSessionId);
+      if (!mainTranscript) {
+        return;
+      }
+      transcripts.push({ transcriptPath: mainTranscript, metadataPath: entryPath, metadata });
+      for (const subagentPath of await coworkSubagentTranscripts(mainTranscript, metadata.cliSessionId)) {
+        transcripts.push({ transcriptPath: subagentPath, metadataPath: entryPath, metadata });
+      }
+    }));
+  }
+  await walk(root);
+  return transcripts.sort((a, b) => a.transcriptPath.localeCompare(b.transcriptPath));
+}
+function coworkMetaPathForTranscript(transcriptPath) {
+  const marker = `${path7.sep}.claude${path7.sep}projects${path7.sep}`;
+  const index = transcriptPath.indexOf(marker);
+  if (index < 0) {
+    return void 0;
+  }
+  return `${transcriptPath.slice(0, index)}.json`;
+}
+function selectedFolder(meta) {
+  return meta.userSelectedFolders?.find((item) => typeof item === "string" && item.trim());
+}
+function projectFromMeta(meta) {
+  const folder = selectedFolder(meta);
+  if (!folder) {
+    return { project: "cowork" };
+  }
+  const resolved = path7.resolve(folder);
+  return {
+    project: path7.basename(resolved).replace(/-/g, "_") || "cowork",
+    cwd: resolved
+  };
+}
+function prefixCoworkId(value) {
+  if (!value) {
+    return void 0;
+  }
+  return value.startsWith(COWORK_PREFIX) ? value : `${COWORK_PREFIX}${value}`;
+}
+function rebuildEventIdentity(event) {
+  const importKey = createImportKey([
+    event.source,
+    event.refs?.sourcePathHash,
+    event.refs?.sourceLine,
+    event.type,
+    event.refs?.sourceId
+  ]);
+  return {
+    ...event,
+    id: createStableEventId(importKey),
+    refs: {
+      ...event.refs,
+      importKey
+    }
+  };
+}
+async function parseClaudeCoworkSessionFile(filePath, options) {
+  const metaPath = coworkMetaPathForTranscript(filePath);
+  const metadata = metaPath ? await readCoworkMeta(metaPath) : {};
+  const { project, cwd } = projectFromMeta(metadata);
+  const parser = createClaudeCodeAdapter().parseSessionFile;
+  if (!parser) {
+    return [];
+  }
+  const events = await parser(filePath, options);
+  return events.map((event) => {
+    const sessionId = prefixCoworkId(event.sessionId);
+    const turnId = prefixCoworkId(event.turnId);
+    const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
+    const refs2 = { ...event.refs };
+    if (metadata.title) {
+      refs2.coworkTitleHash = `sha256:${createStableHash(metadata.title)}`;
+    }
+    const mapped = {
+      ...event,
+      schemaVersion: event.schemaVersion || AGENT_TIME_SCHEMA_VERSION,
+      source: "claude-cowork",
+      agent: "claude-cowork",
+      workspaceId,
+      cwd: cwd || event.cwd,
+      project,
+      sessionId,
+      turnId,
+      refs: refs2
+    };
+    return rebuildEventIdentity(mapped);
+  });
+}
+async function claudeCoworkBackfillFiles(sourceRoot, home, env) {
+  const roots = sourceRoot ? [path7.resolve(sourceRoot)] : coworkDataDirs(home, env);
+  const discovered = (await Promise.all(roots.map(discoverCoworkTranscripts))).flat();
+  return Promise.all(discovered.map(async ({ transcriptPath, metadataPath }) => {
+    const transcriptInfo = await stat4(transcriptPath);
+    let modifiedAt = transcriptInfo.mtime;
+    try {
+      const metaInfo = await stat4(metadataPath);
+      if (metaInfo.mtime > modifiedAt) {
+        modifiedAt = metaInfo.mtime;
+      }
+    } catch {
+    }
+    return { path: transcriptPath, modifiedAt: modifiedAt.toISOString() };
+  }));
+}
+function createClaudeCoworkAdapter() {
+  return {
+    id: "claude-cowork",
+    label: "Claude Cowork",
+    agentName: "claude-cowork",
+    kind: "agent",
+    detectPath(home, env) {
+      return coworkDataDirs(home, env)[0] || path7.join(os3.homedir(), "Library", "Application Support", "Claude", "local-agent-mode-sessions");
+    },
+    installedPath(home, env) {
+      return this.detectPath(home, env);
+    },
+    async isInstalled() {
+      return false;
+    },
+    installEntries() {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return coworkDataDirs(home, env);
+    },
+    async parseSessionFile(filePath, options) {
+      if (!await pathExists(filePath)) {
+        return [];
+      }
+      return parseClaudeCoworkSessionFile(filePath, options);
+    }
+  };
+}
+
+// src/adapters/codebuddy.ts
+import { readFile as readFile5, readdir as readdir4 } from "node:fs/promises";
+import path8 from "node:path";
 async function parseCodebuddyTraceFile(filePath, options) {
-  const text = await readFile4(filePath, "utf8");
+  const text = await readFile5(filePath, "utf8");
   const sourcePathHash = `sha256:${createStableHash(filePath)}`;
   const events = [];
   let traceFile;
@@ -2804,7 +3049,7 @@ async function parseCodebuddyTraceFile(filePath, options) {
   if (!cwd && trace.startedAt) {
     cwd = await cwdFromHistoryFile(trace.startedAt, options);
   }
-  const project = cwd ? path7.basename(cwd) : void 0;
+  const project = cwd ? path8.basename(cwd) : void 0;
   const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
   const model = trace.modelInfo?.models?.[0];
   const baseEvent = (event) => ({
@@ -3090,15 +3335,15 @@ function modelUsageFromTrace(trace, generationIndex, totalGenerations) {
   return { modelCalls: 1 };
 }
 function sessionIdFromTracePath(filePath) {
-  const match = path7.basename(filePath).match(/trace_([0-9a-f]{32})/);
+  const match = path8.basename(filePath).match(/trace_([0-9a-f]{32})/);
   return match?.[1] ? `codebuddy_${match[1]}` : `codebuddy_${createStableHash(filePath).slice(0, 24)}`;
 }
 function resolveHome(options) {
-  return options.home ? path7.resolve(String(options.home)) : process.env.HOME || __require("node:os").homedir();
+  return options.home ? path8.resolve(String(options.home)) : process.env.HOME || __require("node:os").homedir();
 }
 async function readCwdFromSession(sessionPath, matchSessionId) {
   try {
-    const text = await readFile4(sessionPath, "utf8");
+    const text = await readFile5(sessionPath, "utf8");
     const session = JSON.parse(text);
     if (!isPlainObject(session)) {
       return void 0;
@@ -3115,22 +3360,22 @@ async function readCwdFromSession(sessionPath, matchSessionId) {
 }
 async function cwdFromSessionFile(pid, traceSessionId, options) {
   const home = resolveHome(options);
-  const sessionsDir = path7.join(home, ".codebuddy", "sessions");
+  const sessionsDir = path8.join(home, ".codebuddy", "sessions");
   if (pid) {
-    const cwd = await readCwdFromSession(path7.join(sessionsDir, `${pid}.json`));
+    const cwd = await readCwdFromSession(path8.join(sessionsDir, `${pid}.json`));
     if (cwd) {
       return cwd;
     }
   }
   if (traceSessionId) {
     try {
-      const files = await readdir3(sessionsDir);
+      const files = await readdir4(sessionsDir);
       for (const f of files) {
         if (!f.endsWith(".json")) {
           continue;
         }
         const cwd = await readCwdFromSession(
-          path7.join(sessionsDir, f),
+          path8.join(sessionsDir, f),
           traceSessionId
         );
         if (cwd) {
@@ -3144,13 +3389,13 @@ async function cwdFromSessionFile(pid, traceSessionId, options) {
 }
 async function cwdFromHistoryFile(traceStartedAt, options) {
   const home = resolveHome(options);
-  const historyPath = path7.join(home, ".codebuddy", "history.jsonl");
+  const historyPath = path8.join(home, ".codebuddy", "history.jsonl");
   const traceMs = Date.parse(traceStartedAt);
   if (Number.isNaN(traceMs)) {
     return void 0;
   }
   try {
-    const text = await readFile4(historyPath, "utf8");
+    const text = await readFile5(historyPath, "utf8");
     let bestCwd;
     let bestDistance = Infinity;
     for (const line of text.split("\n")) {
@@ -3206,9 +3451,9 @@ function hookConfig3() {
 function codebuddyConfigDir(home, env) {
   const override = env?.CODEBUDDY_CONFIG_DIR;
   if (override && override.trim()) {
-    return path7.resolve(override);
+    return path8.resolve(override);
   }
-  return path7.join(home, ".codebuddy");
+  return path8.join(home, ".codebuddy");
 }
 function createCodebuddyAdapter() {
   return {
@@ -3220,50 +3465,50 @@ function createCodebuddyAdapter() {
       return codebuddyConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path7.join(codebuddyConfigDir(home, env), "settings.json");
+      return path8.join(codebuddyConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path7.join(codebuddyConfigDir(home, env), "settings.json"),
+        path8.join(codebuddyConfigDir(home, env), "settings.json"),
         "vibetime hook --agent codebuddy"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path7.join(codebuddyConfigDir(home, env), "settings.json"),
+        path: path8.join(codebuddyConfigDir(home, env), "settings.json"),
         content: hookConfig3()
       }];
     },
     sourcePaths(home, env) {
       const base = codebuddyConfigDir(home, env);
       return [
-        path7.join(base, "traces")
+        path8.join(base, "traces")
       ];
     },
     parseSessionFile: parseCodebuddyTraceFile
   };
 }
 async function codebuddyBackfillFiles(sourceRoot, home, env) {
-  const base = sourceRoot || path7.join(codebuddyConfigDir(home, env), "traces");
+  const base = sourceRoot || path8.join(codebuddyConfigDir(home, env), "traces");
   const files = [];
   try {
-    const pidDirs = await readdir3(base, { withFileTypes: true });
+    const pidDirs = await readdir4(base, { withFileTypes: true });
     for (const pidDir of pidDirs) {
       if (!pidDir.isDirectory()) {
         continue;
       }
-      const traceDir = path7.join(base, pidDir.name);
+      const traceDir = path8.join(base, pidDir.name);
       try {
-        const entries = await readdir3(traceDir);
+        const entries = await readdir4(traceDir);
         for (const entry of entries) {
           if (!entry.endsWith(".json") || !entry.startsWith("trace_")) {
             continue;
           }
-          const filePath = path7.join(traceDir, entry);
+          const filePath = path8.join(traceDir, entry);
           try {
-            const stat8 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
-            files.push({ path: filePath, modifiedAt: stat8.mtime.toISOString() });
+            const stat11 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
+            files.push({ path: filePath, modifiedAt: stat11.mtime.toISOString() });
           } catch {
           }
         }
@@ -3276,8 +3521,8 @@ async function codebuddyBackfillFiles(sourceRoot, home, env) {
 }
 
 // src/adapters/codex.ts
-import { readFile as readFile5 } from "node:fs/promises";
-import path8 from "node:path";
+import { readFile as readFile6 } from "node:fs/promises";
+import path9 from "node:path";
 
 // src/lib/diff.ts
 function diffStats(diff) {
@@ -3324,7 +3569,7 @@ function fileActivitiesFromPatchChanges(changes, ts, cwd, displayFilePath3) {
 
 // src/adapters/codex.ts
 async function parseCodexSessionFile(filePath, options) {
-  const text = await readFile5(filePath, "utf8");
+  const text = await readFile6(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const sourcePathHash = `sha256:${createStableHash(filePath)}`;
   const events = [];
@@ -3357,7 +3602,7 @@ async function parseCodexSessionFile(filePath, options) {
       sessionMetaLocked = true;
       sessionId = stringField(payload, "id") || sessionId;
       cwd = stringField(payload, "cwd") || cwd;
-      project = cwd ? path8.basename(cwd) : project;
+      project = cwd ? path9.basename(cwd) : project;
       model = stringField(payload, "model_provider") || model;
       events.push(withBackfillRefs({
         schemaVersion: AGENT_TIME_SCHEMA_VERSION,
@@ -3378,7 +3623,7 @@ async function parseCodexSessionFile(filePath, options) {
     if (topType === "turn_context") {
       currentTurnId = stringField(payload, "turn_id") || currentTurnId;
       cwd = stringField(payload, "cwd") || cwd;
-      project = cwd ? path8.basename(cwd) : project;
+      project = cwd ? path9.basename(cwd) : project;
       model = stringField(payload, "model") || model;
       const tier = stringField(payload, "service_tier");
       if (tier) {
@@ -3820,11 +4065,11 @@ function functionCallArguments(payload) {
   }
 }
 function displayFilePath2(filePath, cwd) {
-  if (!cwd || !path8.isAbsolute(filePath)) {
+  if (!cwd || !path9.isAbsolute(filePath)) {
     return filePath;
   }
-  const relative = path8.relative(cwd, filePath);
-  return relative && !relative.startsWith("..") && !path8.isAbsolute(relative) ? relative : filePath;
+  const relative = path9.relative(cwd, filePath);
+  return relative && !relative.startsWith("..") && !path9.isAbsolute(relative) ? relative : filePath;
 }
 var codexHandler = (msg) => hookHandler("codex", msg);
 function hookConfig4() {
@@ -3843,9 +4088,9 @@ function hookConfig4() {
 function codexHome(home, env) {
   const override = env?.CODEX_HOME;
   if (override && override.trim()) {
-    return path8.resolve(override);
+    return path9.resolve(override);
   }
-  return path8.join(home, ".codex");
+  return path9.join(home, ".codex");
 }
 function createCodexAdapter() {
   return {
@@ -3857,26 +4102,26 @@ function createCodexAdapter() {
       return codexHome(home, env);
     },
     installedPath(home, env) {
-      return path8.join(codexHome(home, env), "hooks.json");
+      return path9.join(codexHome(home, env), "hooks.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path8.join(codexHome(home, env), "hooks.json"),
+        path9.join(codexHome(home, env), "hooks.json"),
         "vibetime hook --agent codex"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path8.join(codexHome(home, env), "hooks.json"),
+        path: path9.join(codexHome(home, env), "hooks.json"),
         content: hookConfig4()
       }];
     },
     sourcePaths(home, env) {
       const base = codexHome(home, env);
       return [
-        path8.join(base, "sessions"),
-        path8.join(base, "history.jsonl")
+        path9.join(base, "sessions"),
+        path9.join(base, "history.jsonl")
       ];
     },
     parseSessionFile: parseCodexSessionFile
@@ -3884,8 +4129,8 @@ function createCodexAdapter() {
 }
 
 // src/adapters/opencode.ts
-import os3 from "node:os";
-import path9 from "node:path";
+import os4 from "node:os";
+import path10 from "node:path";
 async function parseOpenCodeSessionFile(dbPath, options) {
   const { DatabaseSync } = await import("node:sqlite");
   if (!dbPath.endsWith(".db")) {
@@ -3916,7 +4161,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
     for (const session of sessions) {
       const sessionId = session.id;
       const cwd = session.directory || session.path || void 0;
-      const project = cwd ? path9.basename(cwd) : void 0;
+      const project = cwd ? path10.basename(cwd) : void 0;
       const sessionTs = msToIso(session.time_created);
       events.push(baseOpenCodeEvent({
         ts: sessionTs,
@@ -4010,7 +4255,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const provider = currentProvider;
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path9.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path10.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -4254,33 +4499,33 @@ function opencodeUsageFromInfo(info) {
 function opencodeConfigDir(home, env) {
   const override = env?.OPENCODE_CONFIG_DIR;
   if (override && override.trim()) {
-    return path9.resolve(override);
+    return path10.resolve(override);
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path9.join(path9.resolve(xdgConfig), "opencode");
+    return path10.join(path10.resolve(xdgConfig), "opencode");
   }
-  return path9.join(home, ".config", "opencode");
+  return path10.join(home, ".config", "opencode");
 }
 function opencodeDataCandidates(home, env) {
   const xdgData = env?.XDG_DATA_HOME;
-  const primary = xdgData && xdgData.trim() ? path9.join(path9.resolve(xdgData), "opencode", "opencode.db") : path9.join(home, ".local", "share", "opencode", "opencode.db");
-  return [primary, path9.join(home, ".opencode", "opencode.db")];
+  const primary = xdgData && xdgData.trim() ? path10.join(path10.resolve(xdgData), "opencode", "opencode.db") : path10.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path10.join(home, ".opencode", "opencode.db")];
 }
-async function opencodeBackfillFiles(sourceRoot, home = os3.homedir(), env) {
-  const { stat: stat8 } = await import("node:fs/promises");
+async function opencodeBackfillFiles(sourceRoot, home = os4.homedir(), env) {
+  const { stat: stat11 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat8(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 stat8(candidatePath).catch(() => null);
+    const info = await stat11(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -4345,12 +4590,12 @@ function createOpenCodeAdapter() {
       return opencodeConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path9.join(opencodeConfigDir(home, env), PLUGIN_PATH);
+      return path10.join(opencodeConfigDir(home, env), PLUGIN_PATH);
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path9.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path9.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path10.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path10.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
@@ -4358,7 +4603,7 @@ function createOpenCodeAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path9.join(opencodeConfigDir(home, env), PLUGIN_PATH),
+        path: path10.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
@@ -4370,10 +4615,10 @@ function createOpenCodeAdapter() {
 }
 
 // src/adapters/pi.ts
-import { readFile as readFile6 } from "node:fs/promises";
-import path10 from "node:path";
+import { readFile as readFile7 } from "node:fs/promises";
+import path11 from "node:path";
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile6(filePath, "utf8");
+  const text = await readFile7(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -4403,7 +4648,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path10.basename(cwd) : project;
+      project = cwd ? path11.basename(cwd) : project;
       continue;
     }
     if (entryType === "model_change") {
@@ -4804,16 +5049,16 @@ export default function (pi: ExtensionAPI) {
 function piAgentDir(home, env) {
   const override = env?.PI_CODING_AGENT_DIR;
   if (override && override.trim()) {
-    return path10.resolve(override);
+    return path11.resolve(override);
   }
-  return path10.join(home, ".pi", "agent");
+  return path11.join(home, ".pi", "agent");
 }
 function piSessionDir(home, env) {
   const override = env?.PI_CODING_AGENT_SESSION_DIR;
   if (override && override.trim()) {
-    return path10.resolve(override);
+    return path11.resolve(override);
   }
-  return path10.join(piAgentDir(home, env), "sessions");
+  return path11.join(piAgentDir(home, env), "sessions");
 }
 function createPiAdapter() {
   return {
@@ -4825,12 +5070,12 @@ function createPiAdapter() {
       return piAgentDir(home, env);
     },
     installedPath(home, env) {
-      return path10.join(piAgentDir(home, env), "extensions", "vibetime.ts");
+      return path11.join(piAgentDir(home, env), "extensions", "vibetime.ts");
     },
     async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path10.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
+        return await pathExists2(path11.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
       } catch {
         return false;
       }
@@ -4838,7 +5083,7 @@ function createPiAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path10.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
+        path: path11.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
         content: piExtensionContent()
       }];
     },
@@ -4850,11 +5095,11 @@ function createPiAdapter() {
 }
 
 // src/adapters/qoder-cn.ts
-import { readdir as readdir4, readFile as readFile7, stat as stat4 } from "node:fs/promises";
-import os4 from "node:os";
-import path11 from "node:path";
+import { readdir as readdir5, readFile as readFile8, stat as stat5 } from "node:fs/promises";
+import os5 from "node:os";
+import path12 from "node:path";
 function parseQoderCnPaths(filePath) {
-  const parts = filePath.split(path11.sep);
+  const parts = filePath.split(path12.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -4863,20 +5108,20 @@ function parseQoderCnPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path11.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path12.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path11.basename(filename, ".jsonl");
+    sessionId = path12.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path11.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path12.sep);
   }
   return { configDir: configDir2, projectName, sessionId };
 }
 async function loadQoderCnModelNames(configDir2) {
   try {
-    const dynamicTextsPath = path11.join(configDir2, ".auth", "dynamic-texts.json");
-    const content = await readFile7(dynamicTextsPath, "utf8");
+    const dynamicTextsPath = path12.join(configDir2, ".auth", "dynamic-texts.json");
+    const content = await readFile8(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -4893,15 +5138,15 @@ async function loadQoderCnModelNames(configDir2) {
 }
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderCnPaths(filePath);
-  const segmentsPath = path11.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path12.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir4(segmentsPath);
+    const files = await readdir5(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile7(path11.join(segmentsPath, file), "utf8");
+      const content = await readFile8(path12.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -4934,7 +5179,7 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderCnSessionFile(filePath, options) {
-  const text = await readFile7(filePath, "utf8");
+  const text = await readFile8(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const { configDir: configDir2 } = parseQoderCnPaths(filePath);
   const projectContext = await qoderCnProjectContextFromLines(filePath, lines, options, configDir2);
@@ -4969,7 +5214,7 @@ async function parseQoderCnSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path11.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path12.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -5398,24 +5643,24 @@ function isNoisePrompt(text) {
 }
 async function qoderCnProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderCnPaths(filePath);
-  const isSubagent = filePath.includes(`${path11.sep}subagents${path11.sep}`);
+  const isSubagent = filePath.includes(`${path12.sep}subagents${path12.sep}`);
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path11.isAbsolute(cwd)) {
+    if (cwd && path12.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    const parentSessionPath = path11.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+    const parentSessionPath = path12.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
     try {
-      const parentText = await readFile7(parentSessionPath, "utf8");
+      const parentText = await readFile8(parentSessionPath, "utf8");
       const parentCwds = [];
       for (const line of parentText.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
         const cwd = raw ? stringField(raw, "cwd") : void 0;
-        if (cwd && path11.isAbsolute(cwd)) {
+        if (cwd && path12.isAbsolute(cwd)) {
           parentCwds.push(cwd);
         }
       }
@@ -5426,7 +5671,7 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
     }
   }
   const root = await gitRootFromCwds2(cwds) || qoderCnProjectRootFromCwds(projectDir, cwds);
-  const project = cwds.length > 0 ? path11.basename(cwds[0]) : root ? path11.basename(root) : await qoderCnProjectFromFilePath(filePath, options);
+  const project = cwds.length > 0 ? path12.basename(cwds[0]) : root ? path12.basename(root) : await qoderCnProjectFromFilePath(filePath, options);
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -5435,15 +5680,15 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
 async function gitRootFromCwds2(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path11.resolve(cwd);
+    let current = path12.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat4(path11.join(current, ".git"));
+        await stat5(path12.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path11.dirname(current);
+      const parent = path12.dirname(current);
       if (parent === current) {
         break;
       }
@@ -5454,12 +5699,12 @@ async function gitRootFromCwds2(cwds) {
 }
 function qoderCnProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path11.resolve(cwd);
+    let current = path12.resolve(cwd);
     while (true) {
       if (encodeQoderCnProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path11.dirname(current);
+      const parent = path12.dirname(current);
       if (parent === current) {
         break;
       }
@@ -5469,14 +5714,14 @@ function qoderCnProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderCnProjectPath(value) {
-  return path11.resolve(value).split(path11.sep).join("-").replace(/_/g, "-");
+  return path12.resolve(value).split(path12.sep).join("-").replace(/_/g, "-");
 }
 async function qoderCnProjectFromFilePath(filePath, options) {
-  const projectDir = path11.basename(path11.dirname(filePath));
-  const home = options ? path11.resolve(stringOption(options.home) || os4.homedir()) : os4.homedir();
+  const projectDir = path12.basename(path12.dirname(filePath));
+  const home = options ? path12.resolve(stringOption(options.home) || os5.homedir()) : os5.homedir();
   const resolved = await resolveQoderCnProjectPath(projectDir, home);
   if (resolved) {
-    return path11.basename(resolved);
+    return path12.basename(resolved);
   }
   const homePrefix = `${encodeQoderCnProjectPath(home)}-`;
   if (projectDir.startsWith(homePrefix)) {
@@ -5496,12 +5741,12 @@ async function resolveQoderCnProjectPath(projectDir, home) {
   while (projectDir.startsWith(`${currentEncoded}-`)) {
     let matchedChild;
     try {
-      const entries = await readdir4(current, { withFileTypes: true });
+      const entries = await readdir5(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path11.join(current, entry.name);
+        const candidate = path12.join(current, entry.name);
         const encoded = encodeQoderCnProjectPath(candidate);
         if (encoded === projectDir) {
           return candidate;
@@ -5546,9 +5791,9 @@ function hookConfig5() {
 function qoderCnConfigDir(home, env) {
   const override = env?.QODER_CN_CONFIG_DIR;
   if (override && override.trim()) {
-    return path11.resolve(override);
+    return path12.resolve(override);
   }
-  return path11.join(home, ".qoder-cn");
+  return path12.join(home, ".qoder-cn");
 }
 function createQoderCnAdapter() {
   return {
@@ -5560,27 +5805,27 @@ function createQoderCnAdapter() {
       return qoderCnConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path11.join(qoderCnConfigDir(home, env), "settings.json");
+      return path12.join(qoderCnConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path11.join(qoderCnConfigDir(home, env), "settings.json"),
+        path12.join(qoderCnConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder-cn"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path11.join(qoderCnConfigDir(home, env), "settings.json"),
+        path: path12.join(qoderCnConfigDir(home, env), "settings.json"),
         content: hookConfig5()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderCnConfigDir(home, env);
       return [
-        path11.join(base, "projects"),
-        path11.join(base, ".qoder.json"),
-        path11.join(home, ".qoder.json")
+        path12.join(base, "projects"),
+        path12.join(base, ".qoder.json"),
+        path12.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderCnSessionFile
@@ -5588,11 +5833,11 @@ function createQoderCnAdapter() {
 }
 
 // src/adapters/qoder.ts
-import { readdir as readdir5, readFile as readFile8, stat as stat5 } from "node:fs/promises";
-import os5 from "node:os";
-import path12 from "node:path";
+import { readdir as readdir6, readFile as readFile9, stat as stat6 } from "node:fs/promises";
+import os6 from "node:os";
+import path13 from "node:path";
 function parseQoderPaths(filePath) {
-  const parts = filePath.split(path12.sep);
+  const parts = filePath.split(path13.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -5601,20 +5846,20 @@ function parseQoderPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path12.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path13.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path12.basename(filename, ".jsonl");
+    sessionId = path13.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path12.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path13.sep);
   }
   return { configDir: configDir2, projectName, sessionId };
 }
 async function loadQoderModelNames(configDir2) {
   try {
-    const dynamicTextsPath = path12.join(configDir2, ".auth", "dynamic-texts.json");
-    const content = await readFile8(dynamicTextsPath, "utf8");
+    const dynamicTextsPath = path13.join(configDir2, ".auth", "dynamic-texts.json");
+    const content = await readFile9(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -5631,15 +5876,15 @@ async function loadQoderModelNames(configDir2) {
 }
 async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderPaths(filePath);
-  const segmentsPath = path12.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path13.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir5(segmentsPath);
+    const files = await readdir6(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile8(path12.join(segmentsPath, file), "utf8");
+      const content = await readFile9(path13.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -5672,7 +5917,7 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderSessionFile(filePath, options) {
-  const text = await readFile8(filePath, "utf8");
+  const text = await readFile9(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const { configDir: configDir2 } = parseQoderPaths(filePath);
   const projectContext = await qoderProjectContextFromLines(filePath, lines, options, configDir2);
@@ -5707,7 +5952,7 @@ async function parseQoderSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path12.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path13.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -6102,24 +6347,24 @@ function qoderExtractText(value) {
 }
 async function qoderProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderPaths(filePath);
-  const isSubagent = filePath.includes(`${path12.sep}subagents${path12.sep}`);
+  const isSubagent = filePath.includes(`${path13.sep}subagents${path13.sep}`);
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path12.isAbsolute(cwd)) {
+    if (cwd && path13.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    const parentSessionPath = path12.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+    const parentSessionPath = path13.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
     try {
-      const parentText = await readFile8(parentSessionPath, "utf8");
+      const parentText = await readFile9(parentSessionPath, "utf8");
       const parentCwds = [];
       for (const line of parentText.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
         const cwd = raw ? stringField(raw, "cwd") : void 0;
-        if (cwd && path12.isAbsolute(cwd)) {
+        if (cwd && path13.isAbsolute(cwd)) {
           parentCwds.push(cwd);
         }
       }
@@ -6130,7 +6375,7 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
     }
   }
   const root = await gitRootFromCwds3(cwds) || qoderProjectRootFromCwds(projectDir, cwds);
-  const project = cwds.length > 0 ? path12.basename(cwds[0]) : root ? path12.basename(root) : await qoderProjectFromFilePath(filePath, options);
+  const project = cwds.length > 0 ? path13.basename(cwds[0]) : root ? path13.basename(root) : await qoderProjectFromFilePath(filePath, options);
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -6139,15 +6384,15 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
 async function gitRootFromCwds3(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path12.resolve(cwd);
+    let current = path13.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat5(path12.join(current, ".git"));
+        await stat6(path13.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path12.dirname(current);
+      const parent = path13.dirname(current);
       if (parent === current) {
         break;
       }
@@ -6158,12 +6403,12 @@ async function gitRootFromCwds3(cwds) {
 }
 function qoderProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path12.resolve(cwd);
+    let current = path13.resolve(cwd);
     while (true) {
       if (encodeQoderProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path12.dirname(current);
+      const parent = path13.dirname(current);
       if (parent === current) {
         break;
       }
@@ -6173,10 +6418,10 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderProjectPath(value) {
-  return path12.resolve(value).split(path12.sep).join("-").replace(/_/g, "-");
+  return path13.resolve(value).split(path13.sep).join("-").replace(/_/g, "-");
 }
 function rawQoderProjectPath(value) {
-  return path12.resolve(value).split(path12.sep).join("-");
+  return path13.resolve(value).split(path13.sep).join("-");
 }
 function qoderEncodedVariants(value) {
   const raw = rawQoderProjectPath(value);
@@ -6192,11 +6437,11 @@ function qoderEncodedProjectSuffix(projectDir, home) {
   return void 0;
 }
 async function qoderProjectFromFilePath(filePath, options) {
-  const projectDir = path12.basename(path12.dirname(filePath));
-  const home = options ? path12.resolve(stringOption(options.home) || os5.homedir()) : os5.homedir();
+  const projectDir = path13.basename(path13.dirname(filePath));
+  const home = options ? path13.resolve(stringOption(options.home) || os6.homedir()) : os6.homedir();
   const resolved = await resolveQoderProjectPath(projectDir, home);
   if (resolved) {
-    return path12.basename(resolved);
+    return path13.basename(resolved);
   }
   const suffix = qoderEncodedProjectSuffix(projectDir, home);
   if (suffix) {
@@ -6217,12 +6462,12 @@ async function resolveQoderProjectPath(projectDir, home) {
   while (currentEncodedVariants.some((prefix) => projectDir.startsWith(`${prefix}-`))) {
     let matchedChild;
     try {
-      const entries = await readdir5(current, { withFileTypes: true });
+      const entries = await readdir6(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path12.join(current, entry.name);
+        const candidate = path13.join(current, entry.name);
         const candidateVariants = qoderEncodedVariants(candidate);
         if (candidateVariants.includes(projectDir)) {
           return candidate;
@@ -6267,9 +6512,9 @@ function hookConfig6() {
 function qoderConfigDir(home, env) {
   const override = env?.QODER_CONFIG_DIR;
   if (override && override.trim()) {
-    return path12.resolve(override);
+    return path13.resolve(override);
   }
-  return path12.join(home, ".qoder");
+  return path13.join(home, ".qoder");
 }
 function createQoderAdapter() {
   return {
@@ -6281,27 +6526,27 @@ function createQoderAdapter() {
       return qoderConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path12.join(qoderConfigDir(home, env), "settings.json");
+      return path13.join(qoderConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path12.join(qoderConfigDir(home, env), "settings.json"),
+        path13.join(qoderConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path12.join(qoderConfigDir(home, env), "settings.json"),
+        path: path13.join(qoderConfigDir(home, env), "settings.json"),
         content: hookConfig6()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderConfigDir(home, env);
       return [
-        path12.join(base, "projects"),
-        path12.join(base, ".qoder.json"),
-        path12.join(home, ".qoder.json")
+        path13.join(base, "projects"),
+        path13.join(base, ".qoder.json"),
+        path13.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderSessionFile
@@ -6335,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") {
@@ -6771,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 path13 from "node:path";
+import path16 from "node:path";
 function configDir(home = homedir()) {
-  return path13.join(home, ".vibetime");
+  return path16.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path13.join(configDir(home), "config.json");
+  return path16.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path13.join(configDir(home), "machine-id");
+  return path16.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -6826,15 +7823,15 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir3, rename, stat as stat6 } 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 path14 from "node:path";
+import path17 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path14.join(home, ".vibetime", "logs");
+  return path17.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path14.join(logDir(home), name);
+  return path17.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -6844,7 +7841,7 @@ function serializeError(error) {
 }
 async function rotateIfNeeded(file) {
   try {
-    const info = await stat6(file);
+    const info = await stat9(file);
     if (info.size > MAX_BYTES) {
       await rename(file, `${file}.1`).catch(() => {
       });
@@ -7009,8 +8006,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path16) {
-  return new URL(path16, 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"), {
@@ -7082,12 +8079,15 @@ function createRegistry() {
   const registry = new AdapterRegistry();
   registry.register(createCodexAdapter());
   registry.register(createClaudeCodeAdapter());
+  registry.register(createClaudeCoworkAdapter());
   registry.register(createPiAdapter());
   registry.register(createOpenCodeAdapter());
   registry.register(createAgyAdapter());
   registry.register(createCodebuddyAdapter());
   registry.register(createQoderAdapter());
   registry.register(createQoderCnAdapter());
+  registry.register(createWorkbuddyAdapter());
+  registry.register(createZCodeAdapter());
   return registry;
 }
 var defaultContext = {
@@ -7493,14 +8493,23 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "agy") {
     return agyBackfillFiles(stringOption(options["source-root"]), resolveHome2(options, ctx), ctx.env);
   }
+  if (source.id === "claude-cowork") {
+    return claudeCoworkBackfillFiles(stringOption(options["source-root"]), resolveHome2(options, ctx), ctx.env);
+  }
   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 stat7(filePath);
+    const info = await stat10(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -7809,13 +8818,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path15.join(home, ".vibetime", "backfill-state.json");
+  return path18.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path15.join(home, ".vibetime", "sync-local-trigger.json");
+  return path18.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path15.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path18.join(home, ".vibetime", "sync-local-trigger.lock");
 }
 async function readBackfillIncrementalState(home, ctx) {
   const statePath = backfillIncrementalStatePath(home);
@@ -7855,7 +8864,7 @@ async function updateBackfillIncrementalState(home, state, selectedFilesBySource
     state.sources[source] = { watermarkTs: latest };
   }
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir4(path15.dirname(statePath), { recursive: true });
+  await mkdir4(path18.dirname(statePath), { recursive: true });
   await writeFile3(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -7888,7 +8897,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir4(path15.dirname(statePath), { recursive: true });
+  await mkdir4(path18.dirname(statePath), { recursive: true });
   const tmpPath = `${statePath}.tmp`;
   await writeFile3(tmpPath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
@@ -7905,7 +8914,7 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir4(path15.dirname(lockPath), { recursive: true });
+  await mkdir4(path18.dirname(lockPath), { recursive: true });
   await writeFile3(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
@@ -7965,10 +8974,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path15.resolve(path15.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path18.resolve(path18.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome2(options, ctx) {
-  return path15.resolve(stringOption(options.home) || ctx.env.HOME || os6.homedir());
+  return path18.resolve(stringOption(options.home) || ctx.env.HOME || os7.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;