@yhong91/vibetime 0.1.25 → 0.1.26

package/bin/vibetime.mjs

@@ -159,9 +159,9 @@ var init_fs = __esm({
 
 // src/cli.ts
 import { spawn as spawn2, spawnSync } from "node:child_process";
-import { mkdir as mkdir5, open, rm, stat as stat12, writeFile as writeFile4 } from "node:fs/promises";
+import { mkdir as mkdir5, open, rm, stat as stat13, writeFile as writeFile4 } from "node:fs/promises";
 import os9 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -191,13 +191,15 @@ var TELEMETRY_EVENT_TYPES = [
   "model.usage",
   "permission.requested",
   "permission.resolved",
+  "permission.granted",
+  "permission.denied",
   "context.compacted",
   "test.completed",
   "git.changed",
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
-var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -1201,7 +1203,7 @@ function countTextLines(text) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.25" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.26" : "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;
@@ -4029,8 +4031,8 @@ async function codebuddyBackfillFiles(sourceRoot, home, env) {
           }
           const filePath = path9.join(traceDir, entry);
           try {
-            const stat13 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
-            files.push({ path: filePath, modifiedAt: stat13.mtime.toISOString() });
+            const stat14 = await import("node:fs/promises").then((fs) => fs.stat(filePath));
+            files.push({ path: filePath, modifiedAt: stat14.mtime.toISOString() });
           } catch {
           }
         }
@@ -5058,9 +5060,497 @@ function createCopilotAdapter() {
   };
 }
 
+// src/adapters/grok-build.ts
+import { readdir as readdir6, readFile as readFile8, stat as stat7 } from "node:fs/promises";
+import path13 from "node:path";
+init_fs();
+var SOURCE_ID = "grok-build";
+var AGENT_NAME = "grok-build";
+var HOOK_COMMAND = `vibetime hook --agent ${SOURCE_ID}`;
+function grokHome(home, env) {
+  const override = env?.GROK_HOME;
+  if (override && override.trim()) {
+    return path13.resolve(override);
+  }
+  return path13.join(home, ".grok");
+}
+function grokHooksPath(home, env) {
+  return path13.join(grokHome(home, env), "hooks", "vibetime.json");
+}
+function grokSessionsDir(home, env) {
+  return path13.join(grokHome(home, env), "sessions");
+}
+async function grokBackfillFiles(sourceRoot, home, env) {
+  const root = sourceRoot || grokSessionsDir(home, env);
+  const files = [];
+  async function walk(dir) {
+    let entries;
+    try {
+      entries = await readdir6(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryPath = path13.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryPath);
+        continue;
+      }
+      if (!entry.isFile() || entry.name !== "summary.json") {
+        continue;
+      }
+      try {
+        const info = await stat7(entryPath);
+        files.push({ path: entryPath, modifiedAt: info.mtime.toISOString() });
+      } catch {
+      }
+    }
+  }
+  await walk(root);
+  return files.sort((a, b) => a.path.localeCompare(b.path));
+}
+async function parseGrokSessionFile(filePath, options) {
+  const sessionDir = resolveSessionDir(filePath);
+  if (!sessionDir) {
+    return [];
+  }
+  const summaryPath = path13.join(sessionDir, "summary.json");
+  const eventsPath = path13.join(sessionDir, "events.jsonl");
+  const signalsPath = path13.join(sessionDir, "signals.json");
+  const updatesPath = path13.join(sessionDir, "updates.jsonl");
+  const summary = await readJsonIfExists(summaryPath);
+  if (!isPlainObject(summary)) {
+    return [];
+  }
+  const info = objectField(summary, "info");
+  const sessionId = stringField(info, "id") || path13.basename(sessionDir);
+  const cwd = stringField(info, "cwd");
+  const project = cwd ? path13.basename(cwd) : void 0;
+  const workspaceId = createWorkspaceId({ projectName: project, repoRoot: cwd });
+  const model = stringField(summary, "current_model_id");
+  const createdAt = timestampFrom(summary.created_at) || timestampFrom(summary.createdAt);
+  const updatedAt = timestampFrom(summary.updated_at) || timestampFrom(summary.last_active_at) || timestampFrom(summary.updatedAt) || createdAt;
+  if (!createdAt) {
+    return [];
+  }
+  const sourcePathHash = `sha256:${createStableHash(summaryPath)}`;
+  const toolInputs = await loadToolInputsFromUpdates(updatesPath);
+  const events = [];
+  const push = (event, lineNumber2, topType, payloadType) => {
+    const validated = validateCanonicalEvent(event);
+    if (!validated.valid) {
+      return;
+    }
+    events.push(withBackfillRefs(event, {
+      filePath: summaryPath,
+      sourcePathHash,
+      lineNumber: lineNumber2,
+      topType: topType || "session",
+      payloadType: payloadType || event.type,
+      options
+    }));
+  };
+  const base = (partial) => ({
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: SOURCE_ID,
+    agent: AGENT_NAME,
+    workspaceId,
+    project,
+    cwd,
+    model,
+    sessionId,
+    ...partial
+  });
+  push(base({
+    ts: createdAt,
+    type: "session.started",
+    confidence: "exact",
+    refs: stringRefs({ sourceId: `${sessionId}:started` })
+  }), 0, "summary", "session.started");
+  let currentTurnId;
+  let currentTurnStartedAt;
+  let lineNumber = 0;
+  const pendingTools = /* @__PURE__ */ new Map();
+  let eventsText = "";
+  try {
+    eventsText = await readFile8(eventsPath, "utf8");
+  } catch {
+  }
+  const lines = eventsText.split("\n").filter(Boolean);
+  for (const [index, line] of lines.entries()) {
+    lineNumber = index + 1;
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
+    }
+    const type = stringField(raw, "type");
+    const ts = timestampFrom(raw.ts) || timestampFrom(raw.timestamp);
+    if (!type || !ts) {
+      continue;
+    }
+    if (type === "turn_started") {
+      const turnNumber = numberField(raw, "turn_number");
+      currentTurnId = turnNumber !== void 0 ? `turn_${turnNumber}` : `turn_${createStableHash([sessionId, lineNumber]).slice(0, 24)}`;
+      currentTurnStartedAt = ts;
+      const turnModel = stringField(raw, "model_id") || model;
+      push(base({
+        ts,
+        type: "turn.started",
+        turnId: currentTurnId,
+        model: turnModel,
+        confidence: "exact",
+        refs: stringRefs({ sourceId: `${sessionId}:${currentTurnId}:started` })
+      }), lineNumber, type, "turn.started");
+      continue;
+    }
+    if (type === "turn_ended") {
+      const turnId = currentTurnId;
+      const outcome = stringField(raw, "outcome");
+      const success = outcome !== "error" && outcome !== "failed" && outcome !== "cancelled";
+      const durationMs = durationMsBetween(currentTurnStartedAt, ts);
+      push(base({
+        ts,
+        type: success ? "turn.completed" : "turn.failed",
+        turnId,
+        success,
+        confidence: "exact",
+        metrics: durationMs !== void 0 ? { durationMs } : void 0,
+        refs: stringRefs({
+          sourceId: `${sessionId}:${turnId || "turn"}:ended`,
+          outcome
+        })
+      }), lineNumber, type, "turn.ended");
+      currentTurnId = void 0;
+      currentTurnStartedAt = void 0;
+      continue;
+    }
+    if (type === "tool_started" || type === "mcp_tool_call_started") {
+      const toolName = type === "mcp_tool_call_started" ? mcpToolName(raw) : stringField(raw, "tool_name") || "unknown";
+      const toolId = stringField(raw, "call_id") || `${sessionId}:tool:${lineNumber}:${toolName}`;
+      pendingTools.set(toolId, {
+        id: toolId,
+        name: toolName,
+        startedAt: ts,
+        lineNumber,
+        turnId: currentTurnId
+      });
+      const knownInput = toolInputs.get(toolId);
+      const fileActivities = fileActivitiesFromTool(
+        toolName,
+        knownInput?.input || {},
+        ts,
+        cwd
+      );
+      push(base({
+        ts,
+        type: "tool.started",
+        turnId: currentTurnId,
+        tool: toolName,
+        operation: `${toolName} started`,
+        confidence: "exact",
+        fileActivities: fileActivities.length > 0 ? fileActivities : void 0,
+        refs: stringRefs({ sourceId: `${toolId}:started` })
+      }), lineNumber, type, "tool.started");
+      if (isShellTool(toolName)) {
+        const command = stringField(knownInput?.input || {}, "command");
+        if (command) {
+          push(base({
+            ts,
+            type: "command.started",
+            turnId: currentTurnId,
+            tool: toolName,
+            operation: "command started",
+            confidence: "derived",
+            refs: stringRefs({
+              sourceId: `${toolId}:command:started`,
+              commandHash: `sha256:${createStableHash(command)}`
+            })
+          }), lineNumber, type, "command.started");
+        }
+      }
+      continue;
+    }
+    if (type === "tool_completed" || type === "mcp_tool_call_completed") {
+      const toolName = type === "mcp_tool_call_completed" ? mcpToolName(raw) : stringField(raw, "tool_name") || "unknown";
+      const toolId = stringField(raw, "call_id") || findPendingToolId(pendingTools, toolName) || `${sessionId}:tool:${lineNumber}:${toolName}`;
+      const pending = pendingTools.get(toolId);
+      const durationMs = numberField(raw, "duration_ms") ?? durationMsBetween(pending?.startedAt, ts);
+      const outcome = stringField(raw, "outcome");
+      const success = raw.success !== false && outcome !== "error" && outcome !== "failed" && !raw.is_timeout;
+      push(base({
+        ts,
+        type: success ? "tool.completed" : "tool.failed",
+        turnId: pending?.turnId || currentTurnId,
+        tool: pending?.name || toolName,
+        operation: `${pending?.name || toolName} completed`,
+        success,
+        confidence: "exact",
+        metrics: {
+          toolCalls: 1,
+          toolDurationMs: durationMs,
+          durationMs
+        },
+        refs: stringRefs({ sourceId: `${toolId}:completed` })
+      }), lineNumber, type, "tool.completed");
+      if (isShellTool(pending?.name || toolName)) {
+        push(base({
+          ts,
+          type: success ? "command.completed" : "command.failed",
+          turnId: pending?.turnId || currentTurnId,
+          tool: pending?.name || toolName,
+          operation: "command completed",
+          success,
+          confidence: "derived",
+          metrics: {
+            commandCalls: 1,
+            commandDurationMs: durationMs,
+            durationMs
+          },
+          refs: stringRefs({ sourceId: `${toolId}:command:completed` })
+        }), lineNumber, type, "command.completed");
+      }
+      pendingTools.delete(toolId);
+      continue;
+    }
+    if (type === "permission_resolved") {
+      const toolName = stringField(raw, "tool_name");
+      const decision = stringField(raw, "decision") || stringField(raw, "outcome");
+      const allowed = decision !== "deny" && decision !== "denied" && decision !== "reject";
+      push(base({
+        ts,
+        type: allowed ? "permission.granted" : "permission.denied",
+        turnId: currentTurnId,
+        tool: toolName,
+        success: allowed,
+        confidence: "partial",
+        refs: stringRefs({
+          sourceId: `${sessionId}:permission:${lineNumber}`,
+          decision
+        })
+      }), lineNumber, type, "permission");
+    }
+  }
+  const signals = await readJsonIfExists(signalsPath);
+  if (isPlainObject(signals) && updatedAt) {
+    const metrics = metricsFromSignals(signals);
+    if (metrics) {
+      push(base({
+        ts: updatedAt,
+        type: "model.usage",
+        model: stringField(signals, "primaryModelId") || model,
+        confidence: "partial",
+        metrics,
+        refs: stringRefs({ sourceId: `${sessionId}:usage:signals` })
+      }), lineNumber + 1, "signals", "model.usage");
+    }
+  }
+  if (updatedAt) {
+    push(base({
+      ts: updatedAt,
+      type: "session.ended",
+      confidence: "derived",
+      refs: stringRefs({ sourceId: `${sessionId}:ended` })
+    }), lineNumber + 2, "summary", "session.ended");
+  }
+  return events;
+}
+function resolveSessionDir(filePath) {
+  const base = path13.basename(filePath);
+  if (base === "summary.json" || base === "events.jsonl" || base === "signals.json") {
+    return path13.dirname(filePath);
+  }
+  if (base.match(/^[0-9a-f]{8}-[0-9a-f-]{27,}$/i)) {
+    return filePath;
+  }
+  return void 0;
+}
+function mcpToolName(raw) {
+  const server = stringField(raw, "server_name");
+  const tool = stringField(raw, "tool_name");
+  if (server && tool) {
+    return `${server}__${tool}`;
+  }
+  return tool || server || "mcp_tool";
+}
+function findPendingToolId(pending, toolName) {
+  for (const [id, item] of pending) {
+    if (item.name === toolName) {
+      return id;
+    }
+  }
+  return void 0;
+}
+function isShellTool(name) {
+  if (!name) {
+    return false;
+  }
+  const lower = name.toLowerCase();
+  return lower === "run_terminal_command" || lower === "bash" || lower === "shell" || lower.endsWith("__run_terminal_command");
+}
+function fileActivitiesFromTool(toolName, input, ts, cwd) {
+  const lower = toolName.toLowerCase();
+  if (isShellTool(toolName)) {
+    const command = stringField(input, "command");
+    if (command) {
+      return fileActivitiesFromShellCommand(command, ts, cwd, cwd);
+    }
+    return [];
+  }
+  if (lower === "read_file" || lower.endsWith("__read_file")) {
+    const target = stringField(input, "target_file") || stringField(input, "path");
+    if (!target) {
+      return [];
+    }
+    return [{
+      ts,
+      path: displayPath(target, cwd),
+      operation: "read",
+      confidence: "exact"
+    }];
+  }
+  if (lower === "search_replace" || lower === "write" || lower.endsWith("__search_replace") || lower.endsWith("__write")) {
+    const target = stringField(input, "file_path") || stringField(input, "target_file") || stringField(input, "path");
+    if (!target) {
+      return [];
+    }
+    return [{
+      ts,
+      path: displayPath(target, cwd),
+      operation: "edit",
+      confidence: "exact"
+    }];
+  }
+  return [];
+}
+function displayPath(filePath, cwd) {
+  if (!cwd || !path13.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const relative = path13.relative(cwd, filePath);
+  return relative && !relative.startsWith("..") && !path13.isAbsolute(relative) ? relative : filePath;
+}
+async function loadToolInputsFromUpdates(updatesPath) {
+  const map = /* @__PURE__ */ new Map();
+  let text = "";
+  try {
+    text = await readFile8(updatesPath, "utf8");
+  } catch {
+    return map;
+  }
+  for (const line of text.split("\n")) {
+    if (!line.trim()) {
+      continue;
+    }
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
+    }
+    const params = objectField(raw, "params");
+    const update = objectField(params, "update");
+    const sessionUpdate = stringField(update, "sessionUpdate");
+    if (sessionUpdate !== "tool_call" && sessionUpdate !== "tool_call_update") {
+      continue;
+    }
+    const toolCallId = stringField(update, "toolCallId");
+    if (!toolCallId) {
+      continue;
+    }
+    const meta = objectField(update, "_meta");
+    const toolMeta = objectField(meta, "x.ai/tool");
+    const name = stringField(toolMeta, "name") || stringField(update, "title") || "unknown";
+    const rawInput = objectField(update, "rawInput");
+    const nestedInput = objectField(toolMeta, "input");
+    const input = Object.keys(rawInput).length > 0 ? rawInput : nestedInput;
+    if (!map.has(toolCallId) || Object.keys(input).length > 0) {
+      map.set(toolCallId, { name, input });
+    }
+  }
+  return map;
+}
+function metricsFromSignals(signals) {
+  const contextTokens = numberField(signals, "contextTokensUsed");
+  const toolCallCount = numberField(signals, "toolCallCount");
+  const turnCount = numberField(signals, "turnCount");
+  const durationSec = numberField(signals, "sessionDurationSeconds");
+  const linesAdded = numberField(signals, "agentLinesAdded");
+  const linesRemoved = numberField(signals, "agentLinesRemoved");
+  if (contextTokens === void 0 && toolCallCount === void 0 && turnCount === void 0 && durationSec === void 0) {
+    return void 0;
+  }
+  const metrics = {};
+  if (contextTokens !== void 0 && contextTokens > 0) {
+    metrics.tokensTotal = contextTokens;
+    metrics.tokensInput = contextTokens;
+  }
+  if (toolCallCount !== void 0) {
+    metrics.toolCalls = toolCallCount;
+  }
+  if (turnCount !== void 0) {
+    metrics.modelCalls = turnCount;
+  }
+  if (durationSec !== void 0) {
+    metrics.durationMs = Math.round(durationSec * 1e3);
+  }
+  if (linesAdded !== void 0) {
+    metrics.linesAdded = linesAdded;
+  }
+  if (linesRemoved !== void 0) {
+    metrics.linesRemoved = linesRemoved;
+  }
+  return metrics;
+}
+var grokHandler = (msg) => hookHandler(SOURCE_ID, msg);
+function hookConfig5() {
+  const anyTool = [{ matcher: ".*", hooks: [grokHandler("Reporting tool activity")] }];
+  return {
+    hooks: {
+      SessionStart: [{ hooks: [grokHandler("Reporting session start")] }],
+      SessionEnd: [{ hooks: [grokHandler("Reporting session end")] }],
+      UserPromptSubmit: [{ hooks: [grokHandler("Reporting prompt activity")] }],
+      PreToolUse: anyTool,
+      PostToolUse: anyTool,
+      PostToolUseFailure: anyTool,
+      PermissionDenied: anyTool,
+      SubagentStart: [{ hooks: [grokHandler("Reporting subagent start")] }],
+      SubagentStop: [{ hooks: [grokHandler("Reporting subagent completion")] }],
+      Stop: [{ hooks: [grokHandler("Reporting turn completion")] }],
+      StopFailure: [{ hooks: [grokHandler("Reporting turn failure")] }],
+      PostCompact: [{ hooks: [grokHandler("Reporting context compaction")] }]
+    }
+  };
+}
+function createGrokBuildAdapter() {
+  return {
+    id: SOURCE_ID,
+    label: "Grok Build",
+    agentName: AGENT_NAME,
+    kind: "agent",
+    detectPath(home, env) {
+      return grokHome(home, env);
+    },
+    installedPath(home, env) {
+      return grokHooksPath(home, env);
+    },
+    async isInstalled(home, env) {
+      return isHooksJsonInstalled(grokHooksPath(home, env), HOOK_COMMAND);
+    },
+    installEntries(home, env) {
+      return [{
+        kind: "hooks-json",
+        path: grokHooksPath(home, env),
+        content: hookConfig5()
+      }];
+    },
+    sourcePaths(home, env) {
+      return [grokSessionsDir(home, env)];
+    },
+    parseSessionFile: parseGrokSessionFile
+  };
+}
+
 // src/adapters/opencode.ts
 import os6 from "node:os";
-import path13 from "node:path";
+import path14 from "node:path";
 async function parseOpenCodeSessionFile(dbPath, options) {
   const { DatabaseSync } = await import("node:sqlite");
   if (!dbPath.endsWith(".db")) {
@@ -5091,7 +5581,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 ? path13.basename(cwd) : void 0;
+      const project = cwd ? path14.basename(cwd) : void 0;
       const sessionTs = msToIso(session.time_created);
       events.push(baseOpenCodeEvent({
         ts: sessionTs,
@@ -5199,7 +5689,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const provider = currentProvider;
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path13.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path14.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -5447,33 +5937,33 @@ function opencodeUsageFromInfo(info) {
 function opencodeConfigDir(home, env) {
   const override = env?.OPENCODE_CONFIG_DIR;
   if (override && override.trim()) {
-    return path13.resolve(override);
+    return path14.resolve(override);
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path13.join(path13.resolve(xdgConfig), "opencode");
+    return path14.join(path14.resolve(xdgConfig), "opencode");
   }
-  return path13.join(home, ".config", "opencode");
+  return path14.join(home, ".config", "opencode");
 }
 function opencodeDataCandidates(home, env) {
   const xdgData = env?.XDG_DATA_HOME;
-  const primary = xdgData && xdgData.trim() ? path13.join(path13.resolve(xdgData), "opencode", "opencode.db") : path13.join(home, ".local", "share", "opencode", "opencode.db");
-  return [primary, path13.join(home, ".opencode", "opencode.db")];
+  const primary = xdgData && xdgData.trim() ? path14.join(path14.resolve(xdgData), "opencode", "opencode.db") : path14.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path14.join(home, ".opencode", "opencode.db")];
 }
 async function opencodeBackfillFiles(sourceRoot, home = os6.homedir(), env) {
-  const { stat: stat13 } = await import("node:fs/promises");
+  const { stat: stat14 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat13(sourceRoot).catch(() => null);
+    const info = await stat14(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
   for (const candidatePath of opencodeDataCandidates(home, env)) {
-    const info = await stat13(candidatePath).catch(() => null);
+    const info = await stat14(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -5548,12 +6038,12 @@ function createOpenCodeAdapter() {
       return opencodeConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path13.join(opencodeConfigDir(home, env), PLUGIN_PATH);
+      return path14.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(path13.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path13.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path14.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path14.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
@@ -5561,7 +6051,7 @@ function createOpenCodeAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path13.join(opencodeConfigDir(home, env), PLUGIN_PATH),
+        path: path14.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
@@ -5573,10 +6063,10 @@ function createOpenCodeAdapter() {
 }
 
 // src/adapters/pi.ts
-import { readFile as readFile8 } from "node:fs/promises";
-import path14 from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import path15 from "node:path";
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile8(filePath, "utf8");
+  const text = await readFile9(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -5607,7 +6097,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path14.basename(cwd) : project;
+      project = cwd ? path15.basename(cwd) : project;
       continue;
     }
     if (entryType === "model_change") {
@@ -6016,16 +6506,16 @@ export default function (pi: ExtensionAPI) {
 function piAgentDir(home, env) {
   const override = env?.PI_CODING_AGENT_DIR;
   if (override && override.trim()) {
-    return path14.resolve(override);
+    return path15.resolve(override);
   }
-  return path14.join(home, ".pi", "agent");
+  return path15.join(home, ".pi", "agent");
 }
 function piSessionDir(home, env) {
   const override = env?.PI_CODING_AGENT_SESSION_DIR;
   if (override && override.trim()) {
-    return path14.resolve(override);
+    return path15.resolve(override);
   }
-  return path14.join(piAgentDir(home, env), "sessions");
+  return path15.join(piAgentDir(home, env), "sessions");
 }
 function createPiAdapter() {
   return {
@@ -6037,12 +6527,12 @@ function createPiAdapter() {
       return piAgentDir(home, env);
     },
     installedPath(home, env) {
-      return path14.join(piAgentDir(home, env), "extensions", "vibetime.ts");
+      return path15.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(path14.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
+        return await pathExists2(path15.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
       } catch {
         return false;
       }
@@ -6050,7 +6540,7 @@ function createPiAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path14.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
+        path: path15.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
         content: piExtensionContent()
       }];
     },
@@ -6062,11 +6552,11 @@ function createPiAdapter() {
 }
 
 // src/adapters/qoder-cn.ts
-import { readdir as readdir6, readFile as readFile9, stat as stat7 } from "node:fs/promises";
+import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
 import os7 from "node:os";
-import path15 from "node:path";
+import path16 from "node:path";
 function parseQoderCnPaths(filePath) {
-  const parts = filePath.split(path15.sep);
+  const parts = filePath.split(path16.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -6075,20 +6565,20 @@ function parseQoderCnPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path15.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path15.basename(filename, ".jsonl");
+    sessionId = path16.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path15.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
   }
   return { configDir: configDir2, projectName, sessionId };
 }
 async function loadQoderCnModelNames(configDir2) {
   try {
-    const dynamicTextsPath = path15.join(configDir2, ".auth", "dynamic-texts.json");
-    const content = await readFile9(dynamicTextsPath, "utf8");
+    const dynamicTextsPath = path16.join(configDir2, ".auth", "dynamic-texts.json");
+    const content = await readFile10(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -6105,15 +6595,15 @@ async function loadQoderCnModelNames(configDir2) {
 }
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderCnPaths(filePath);
-  const segmentsPath = path15.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path16.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir6(segmentsPath);
+    const files = await readdir7(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile9(path15.join(segmentsPath, file), "utf8");
+      const content = await readFile10(path16.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -6146,7 +6636,7 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderCnSessionFile(filePath, options) {
-  const text = await readFile9(filePath, "utf8");
+  const text = await readFile10(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const { configDir: configDir2 } = parseQoderCnPaths(filePath);
   const projectContext = await qoderCnProjectContextFromLines(filePath, lines, options, configDir2);
@@ -6181,7 +6671,7 @@ async function parseQoderCnSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path15.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path16.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -6610,28 +7100,28 @@ function isNoisePrompt(text) {
 }
 async function qoderCnProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderCnPaths(filePath);
-  const isSubagent = filePath.includes(`${path15.sep}subagents${path15.sep}`);
+  const isSubagent = filePath.includes(`${path16.sep}subagents${path16.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path15.isAbsolute(cwd)) {
+    if (cwd && path16.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path15.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path16.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path15.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path16.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile9(parentSessionPath, "utf8");
+        const parentText = await readFile10(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 && path15.isAbsolute(cwd)) {
+          if (cwd && path16.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
         }
@@ -6643,7 +7133,7 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
     }
   }
   const root = await gitRootFromCwds2(cwds) || qoderCnProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path15.basename(cwds[0]) : root ? path15.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path16.basename(cwds[0]) : root ? path16.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -6652,15 +7142,15 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
 async function gitRootFromCwds2(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path15.resolve(cwd);
+    let current = path16.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat7(path15.join(current, ".git"));
+        await stat8(path16.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path15.dirname(current);
+      const parent = path16.dirname(current);
       if (parent === current) {
         break;
       }
@@ -6671,12 +7161,12 @@ async function gitRootFromCwds2(cwds) {
 }
 function qoderCnProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path15.resolve(cwd);
+    let current = path16.resolve(cwd);
     while (true) {
       if (encodeQoderCnProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path15.dirname(current);
+      const parent = path16.dirname(current);
       if (parent === current) {
         break;
       }
@@ -6686,14 +7176,14 @@ function qoderCnProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderCnProjectPath(value) {
-  return path15.resolve(value).split(path15.sep).join("-").replace(/_/g, "-");
+  return path16.resolve(value).split(path16.sep).join("-").replace(/_/g, "-");
 }
 async function qoderCnProjectFromFilePath(filePath, options) {
-  const projectDir = path15.basename(path15.dirname(filePath));
-  const home = options ? path15.resolve(stringOption(options.home) || os7.homedir()) : os7.homedir();
+  const projectDir = path16.basename(path16.dirname(filePath));
+  const home = options ? path16.resolve(stringOption(options.home) || os7.homedir()) : os7.homedir();
   const resolved = await resolveQoderCnProjectPath(projectDir, home);
   if (resolved) {
-    return path15.basename(resolved);
+    return path16.basename(resolved);
   }
   const homePrefix = `${encodeQoderCnProjectPath(home)}-`;
   if (projectDir.startsWith(homePrefix)) {
@@ -6713,12 +7203,12 @@ async function resolveQoderCnProjectPath(projectDir, home) {
   while (projectDir.startsWith(`${currentEncoded}-`)) {
     let matchedChild;
     try {
-      const entries = await readdir6(current, { withFileTypes: true });
+      const entries = await readdir7(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path15.join(current, entry.name);
+        const candidate = path16.join(current, entry.name);
         const encoded = encodeQoderCnProjectPath(candidate);
         if (encoded === projectDir) {
           return candidate;
@@ -6740,7 +7230,7 @@ async function resolveQoderCnProjectPath(projectDir, home) {
   return void 0;
 }
 var qoderCnHandler = (msg) => hookHandler("qoder-cn", msg);
-function hookConfig5() {
+function hookConfig6() {
   const anyTool = [{ matcher: ".*", hooks: [qoderCnHandler("Reporting tool activity")] }];
   return {
     hooks: {
@@ -6763,9 +7253,9 @@ function hookConfig5() {
 function qoderCnConfigDir(home, env) {
   const override = env?.QODER_CN_CONFIG_DIR;
   if (override && override.trim()) {
-    return path15.resolve(override);
+    return path16.resolve(override);
   }
-  return path15.join(home, ".qoder-cn");
+  return path16.join(home, ".qoder-cn");
 }
 function createQoderCnAdapter() {
   return {
@@ -6777,27 +7267,27 @@ function createQoderCnAdapter() {
       return qoderCnConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path15.join(qoderCnConfigDir(home, env), "settings.json");
+      return path16.join(qoderCnConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path15.join(qoderCnConfigDir(home, env), "settings.json"),
+        path16.join(qoderCnConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder-cn"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path15.join(qoderCnConfigDir(home, env), "settings.json"),
-        content: hookConfig5()
+        path: path16.join(qoderCnConfigDir(home, env), "settings.json"),
+        content: hookConfig6()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderCnConfigDir(home, env);
       return [
-        path15.join(base, "projects"),
-        path15.join(base, ".qoder.json"),
-        path15.join(home, ".qoder.json")
+        path16.join(base, "projects"),
+        path16.join(base, ".qoder.json"),
+        path16.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderCnSessionFile
@@ -6805,11 +7295,11 @@ function createQoderCnAdapter() {
 }
 
 // src/adapters/qoder.ts
-import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
+import { readdir as readdir8, readFile as readFile11, stat as stat9 } from "node:fs/promises";
 import os8 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 function parseQoderPaths(filePath) {
-  const parts = filePath.split(path16.sep);
+  const parts = filePath.split(path17.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -6818,20 +7308,20 @@ function parseQoderPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path17.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path16.basename(filename, ".jsonl");
+    sessionId = path17.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path16.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path17.sep);
   }
   return { configDir: configDir2, projectName, sessionId };
 }
 async function loadQoderModelNames(configDir2) {
   try {
-    const dynamicTextsPath = path16.join(configDir2, ".auth", "dynamic-texts.json");
-    const content = await readFile10(dynamicTextsPath, "utf8");
+    const dynamicTextsPath = path17.join(configDir2, ".auth", "dynamic-texts.json");
+    const content = await readFile11(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -6848,15 +7338,15 @@ async function loadQoderModelNames(configDir2) {
 }
 async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderPaths(filePath);
-  const segmentsPath = path16.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path17.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
-    const files = await readdir7(segmentsPath);
+    const files = await readdir8(segmentsPath);
     for (const file of files) {
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile10(path16.join(segmentsPath, file), "utf8");
+      const content = await readFile11(path17.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -6889,7 +7379,7 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderSessionFile(filePath, options) {
-  const text = await readFile10(filePath, "utf8");
+  const text = await readFile11(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const { configDir: configDir2 } = parseQoderPaths(filePath);
   const projectContext = await qoderProjectContextFromLines(filePath, lines, options, configDir2);
@@ -6924,7 +7414,7 @@ async function parseQoderSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path16.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path17.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -7319,28 +7809,28 @@ function qoderExtractText(value) {
 }
 async function qoderProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderPaths(filePath);
-  const isSubagent = filePath.includes(`${path16.sep}subagents${path16.sep}`);
+  const isSubagent = filePath.includes(`${path17.sep}subagents${path17.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path16.isAbsolute(cwd)) {
+    if (cwd && path17.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path16.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path17.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path16.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path17.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile10(parentSessionPath, "utf8");
+        const parentText = await readFile11(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 && path16.isAbsolute(cwd)) {
+          if (cwd && path17.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
         }
@@ -7352,7 +7842,7 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
     }
   }
   const root = await gitRootFromCwds3(cwds) || qoderProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path16.basename(cwds[0]) : root ? path16.basename(root) : await qoderProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path17.basename(cwds[0]) : root ? path17.basename(root) : await qoderProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -7361,15 +7851,15 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
 async function gitRootFromCwds3(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path16.resolve(cwd);
+    let current = path17.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat8(path16.join(current, ".git"));
+        await stat9(path17.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path16.dirname(current);
+      const parent = path17.dirname(current);
       if (parent === current) {
         break;
       }
@@ -7380,12 +7870,12 @@ async function gitRootFromCwds3(cwds) {
 }
 function qoderProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path16.resolve(cwd);
+    let current = path17.resolve(cwd);
     while (true) {
       if (encodeQoderProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path16.dirname(current);
+      const parent = path17.dirname(current);
       if (parent === current) {
         break;
       }
@@ -7395,10 +7885,10 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderProjectPath(value) {
-  return path16.resolve(value).split(path16.sep).join("-").replace(/_/g, "-");
+  return path17.resolve(value).split(path17.sep).join("-").replace(/_/g, "-");
 }
 function rawQoderProjectPath(value) {
-  return path16.resolve(value).split(path16.sep).join("-");
+  return path17.resolve(value).split(path17.sep).join("-");
 }
 function qoderEncodedVariants(value) {
   const raw = rawQoderProjectPath(value);
@@ -7414,11 +7904,11 @@ function qoderEncodedProjectSuffix(projectDir, home) {
   return void 0;
 }
 async function qoderProjectFromFilePath(filePath, options) {
-  const projectDir = path16.basename(path16.dirname(filePath));
-  const home = options ? path16.resolve(stringOption(options.home) || os8.homedir()) : os8.homedir();
+  const projectDir = path17.basename(path17.dirname(filePath));
+  const home = options ? path17.resolve(stringOption(options.home) || os8.homedir()) : os8.homedir();
   const resolved = await resolveQoderProjectPath(projectDir, home);
   if (resolved) {
-    return path16.basename(resolved);
+    return path17.basename(resolved);
   }
   const suffix = qoderEncodedProjectSuffix(projectDir, home);
   if (suffix) {
@@ -7439,12 +7929,12 @@ async function resolveQoderProjectPath(projectDir, home) {
   while (currentEncodedVariants.some((prefix) => projectDir.startsWith(`${prefix}-`))) {
     let matchedChild;
     try {
-      const entries = await readdir7(current, { withFileTypes: true });
+      const entries = await readdir8(current, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path16.join(current, entry.name);
+        const candidate = path17.join(current, entry.name);
         const candidateVariants = qoderEncodedVariants(candidate);
         if (candidateVariants.includes(projectDir)) {
           return candidate;
@@ -7466,7 +7956,7 @@ async function resolveQoderProjectPath(projectDir, home) {
   return void 0;
 }
 var qoderHandler = (msg) => hookHandler("qoder", msg);
-function hookConfig6() {
+function hookConfig7() {
   const anyTool = [{ matcher: ".*", hooks: [qoderHandler("Reporting tool activity")] }];
   return {
     hooks: {
@@ -7489,9 +7979,9 @@ function hookConfig6() {
 function qoderConfigDir(home, env) {
   const override = env?.QODER_CONFIG_DIR;
   if (override && override.trim()) {
-    return path16.resolve(override);
+    return path17.resolve(override);
   }
-  return path16.join(home, ".qoder");
+  return path17.join(home, ".qoder");
 }
 function createQoderAdapter() {
   return {
@@ -7503,27 +7993,27 @@ function createQoderAdapter() {
       return qoderConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path16.join(qoderConfigDir(home, env), "settings.json");
+      return path17.join(qoderConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path16.join(qoderConfigDir(home, env), "settings.json"),
+        path17.join(qoderConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path16.join(qoderConfigDir(home, env), "settings.json"),
-        content: hookConfig6()
+        path: path17.join(qoderConfigDir(home, env), "settings.json"),
+        content: hookConfig7()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderConfigDir(home, env);
       return [
-        path16.join(base, "projects"),
-        path16.join(base, ".qoder.json"),
-        path16.join(home, ".qoder.json")
+        path17.join(base, "projects"),
+        path17.join(base, ".qoder.json"),
+        path17.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderSessionFile
@@ -7558,21 +8048,21 @@ function normalizeId(id) {
 }
 
 // src/adapters/workbuddy.ts
-import { readFile as readFile11, readdir as readdir8, stat as stat9 } from "node:fs/promises";
-import path17 from "node:path";
+import { readFile as readFile12, readdir as readdir9, stat as stat10 } from "node:fs/promises";
+import path18 from "node:path";
 init_fs();
 function workbuddyProjectsDir(home, env) {
   const override = env?.WORKBUDDY_PROJECTS_DIR || env?.WORKBUDDY_HOME;
   if (override && override.trim()) {
-    return path17.resolve(override, override.endsWith("projects") ? "" : "projects");
+    return path18.resolve(override, override.endsWith("projects") ? "" : "projects");
   }
-  return path17.join(home, ".workbuddy", "projects");
+  return path18.join(home, ".workbuddy", "projects");
 }
 function projectFromCwd(cwd, fallback) {
   if (!cwd) {
     return fallback;
   }
-  return path17.basename(cwd) || fallback;
+  return path18.basename(cwd) || fallback;
 }
 function sourceHash(filePath) {
   return `sha256:${createStableHash(filePath)}`;
@@ -7654,7 +8144,7 @@ function contentLength(value) {
   return 0;
 }
 async function readWorkbuddyLines(filePath) {
-  const text = await readFile11(filePath, "utf8");
+  const text = await readFile12(filePath, "utf8");
   return text.split(/\r?\n/).map((line, index) => {
     if (!line.trim()) {
       return void 0;
@@ -7674,8 +8164,8 @@ async function parseWorkbuddySessionFile(filePath, options) {
   }
   const events = [];
   const first = lines[0].record;
-  const sessionId = stringField(first, "sessionId") || path17.basename(filePath, ".jsonl");
-  const fallbackProject = path17.basename(path17.dirname(filePath));
+  const sessionId = stringField(first, "sessionId") || path18.basename(filePath, ".jsonl");
+  const fallbackProject = path18.basename(path18.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 });
@@ -7844,17 +8334,17 @@ async function workbuddyBackfillFiles(sourceRoot, home, env) {
   const base = sourceRoot || workbuddyProjectsDir(home, env);
   const files = [];
   try {
-    const projects = await readdir8(base, { withFileTypes: true });
+    const projects = await readdir9(base, { withFileTypes: true });
     for (const project of projects) {
       if (!project.isDirectory()) {
         continue;
       }
-      const projectDir = path17.join(base, project.name);
-      const entries = await readdir8(projectDir, { withFileTypes: true });
+      const projectDir = path18.join(base, project.name);
+      const entries = await readdir9(projectDir, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith(".jsonl")) {
-          const filePath = path17.join(projectDir, entry.name);
-          const info = await stat9(filePath);
+          const filePath = path18.join(projectDir, entry.name);
+          const info = await stat10(filePath);
           files.push({ path: filePath, modifiedAt: info.mtime.toISOString() });
         }
       }
@@ -7891,26 +8381,26 @@ function createWorkbuddyAdapter() {
 
 // src/adapters/zcode.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile12, stat as stat10 } from "node:fs/promises";
-import path18 from "node:path";
+import { readFile as readFile13, stat as stat11 } from "node:fs/promises";
+import path19 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 path18.resolve(override, override.endsWith("cli") ? "" : "cli");
+    return path19.resolve(override, override.endsWith("cli") ? "" : "cli");
   }
-  return path18.join(home, ".zcode", "cli");
+  return path19.join(home, ".zcode", "cli");
 }
 function zcodeDbPath(home, env) {
-  return path18.join(zcodeCliDir(home, env), "db", "db.sqlite");
+  return path19.join(zcodeCliDir(home, env), "db", "db.sqlite");
 }
 var providerNameCache = null;
 async function loadProviderNames(configPath2) {
   let fileMtime = 0;
   try {
-    const info = await stat10(configPath2);
+    const info = await stat11(configPath2);
     fileMtime = info.mtimeMs;
   } catch {
     return /* @__PURE__ */ new Map();
@@ -7920,7 +8410,7 @@ async function loadProviderNames(configPath2) {
   }
   const map = /* @__PURE__ */ new Map();
   try {
-    const raw = await readFile12(configPath2, "utf-8");
+    const raw = await readFile13(configPath2, "utf-8");
     const config = JSON.parse(raw);
     const providers = config?.provider;
     if (isPlainObject(providers)) {
@@ -7938,7 +8428,7 @@ function sourceHash2(filePath) {
   return `sha256:${createStableHash(filePath)}`;
 }
 function projectFromDirectory(directory) {
-  return directory ? path18.basename(directory) || "zcode" : "zcode";
+  return directory ? path19.basename(directory) || "zcode" : "zcode";
 }
 function isoFromMs(value) {
   return timestampFrom(typeof value === "number" ? value : Number(value));
@@ -8094,16 +8584,16 @@ async function parseZCodeDb(filePath, options) {
   if (rows.length === 0) {
     return [];
   }
-  let candidate = path18.resolve(filePath);
+  let candidate = path19.resolve(filePath);
   let configPath2 = "";
   for (let i = 0; i < 12; i++) {
-    const probe = path18.join(candidate, ".zcode", "v2", "config.json");
+    const probe = path19.join(candidate, ".zcode", "v2", "config.json");
     try {
-      await stat10(probe);
+      await stat11(probe);
       configPath2 = probe;
       break;
     } catch {
-      const parent = path18.dirname(candidate);
+      const parent = path19.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -8319,9 +8809,9 @@ async function parseZCodeDb(filePath, options) {
 }
 async function zcodeBackfillFiles(sourceRoot, home, env) {
   const candidate = sourceRoot || zcodeDbPath(home, env);
-  const filePath = candidate.endsWith(".sqlite") ? candidate : path18.join(candidate, "db", "db.sqlite");
+  const filePath = candidate.endsWith(".sqlite") ? candidate : path19.join(candidate, "db", "db.sqlite");
   try {
-    const info = await stat10(filePath);
+    const info = await stat11(filePath);
     return [{ path: filePath, modifiedAt: info.mtime.toISOString() }];
   } catch {
     return [];
@@ -8583,11 +9073,11 @@ function buildSessionRollup(rollupKey, events) {
       bucket.activityCount += 1;
     }
     for (const file of event.fileActivities || []) {
-      const displayPath = displayBackfillPath(file.path);
-      const pathHash = `sha256:${createStableHash(displayPath)}`;
+      const displayPath2 = displayBackfillPath(file.path);
+      const pathHash = `sha256:${createStableHash(displayPath2)}`;
       const fileRollup = fileRollups.get(pathHash) || {
         pathHash,
-        displayPath,
+        displayPath: displayPath2,
         reads: 0,
         writes: 0,
         linesAdded: 0,
@@ -8796,15 +9286,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 path19 from "node:path";
+import path20 from "node:path";
 function configDir(home = homedir()) {
-  return path19.join(home, ".vibetime");
+  return path20.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path19.join(configDir(home), "config.json");
+  return path20.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path19.join(configDir(home), "machine-id");
+  return path20.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -8851,15 +9341,15 @@ function defaultMachineName() {
 init_fs();
 
 // src/lib/logger.ts
-import { appendFile, mkdir as mkdir4, rename, stat as stat11 } from "node:fs/promises";
+import { appendFile, mkdir as mkdir4, rename, stat as stat12 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path20 from "node:path";
+import path21 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path20.join(home, ".vibetime", "logs");
+  return path21.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path20.join(logDir(home), name);
+  return path21.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -8869,7 +9359,7 @@ function serializeError(error) {
 }
 async function rotateIfNeeded(file) {
   try {
-    const info = await stat11(file);
+    const info = await stat12(file);
     if (info.size > MAX_BYTES) {
       await rename(file, `${file}.1`).catch(() => {
       });
@@ -9034,8 +9524,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path22) {
-  return new URL(path22, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path23) {
+  return new URL(path23, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -9117,6 +9607,7 @@ function createRegistry() {
   registry.register(createQoderCnAdapter());
   registry.register(createWorkbuddyAdapter());
   registry.register(createZCodeAdapter());
+  registry.register(createGrokBuildAdapter());
   return registry;
 }
 var defaultContext = {
@@ -9629,11 +10120,14 @@ async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "copilot") {
     return copilotBackfillFiles(stringOption(options["source-root"]), resolveHome3(options, ctx), ctx.env);
   }
+  if (source.id === "grok-build") {
+    return grokBackfillFiles(stringOption(options["source-root"]), resolveHome3(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 stat12(filePath);
+    const info = await stat13(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -9946,13 +10440,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path21.join(home, ".vibetime", "backfill-state.json");
+  return path22.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path21.join(home, ".vibetime", "sync-local-trigger.json");
+  return path22.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path21.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path22.join(home, ".vibetime", "sync-local-trigger.lock");
 }
 function backfillRemoteKey(baseUrl) {
   try {
@@ -10014,7 +10508,7 @@ async function readBackfillIncrementalStateFile(home, ctx) {
 }
 async function writeBackfillIncrementalStateFile(home, file) {
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir5(path21.dirname(statePath), { recursive: true });
+  await mkdir5(path22.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }
@@ -10063,7 +10557,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir5(path21.dirname(statePath), { recursive: true });
+  await mkdir5(path22.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -10078,12 +10572,12 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir5(path21.dirname(lockPath), { recursive: true });
+  await mkdir5(path22.dirname(lockPath), { recursive: true });
   await writeFile4(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
 async function acquireSyncLocalLock(lockPath, lock) {
-  await mkdir5(path21.dirname(lockPath), { recursive: true });
+  await mkdir5(path22.dirname(lockPath), { recursive: true });
   try {
     const handle = await open(lockPath, "wx");
     try {
@@ -10163,10 +10657,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path21.resolve(path21.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path22.resolve(path22.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome3(options, ctx) {
-  return path21.resolve(stringOption(options.home) || ctx.env.HOME || os9.homedir());
+  return path22.resolve(stringOption(options.home) || ctx.env.HOME || os9.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;