@yhong91/vibetime 0.1.51 → 0.1.53

package/bin/vibetime.mjs

@@ -18,7 +18,7 @@ var __export = (target, all) => {
 // src/lib/fs.ts
 var fs_exports = {};
 __export(fs_exports, {
-  GENERATED_MARKER: () => GENERATED_MARKER,
+  GENERATED_MARKER: () => GENERATED_MARKER2,
   countDirectoryEntries: () => countDirectoryEntries,
   listFilesByExtensions: () => listFilesByExtensions,
   listJsonlFiles: () => listJsonlFiles,
@@ -72,7 +72,7 @@ async function writeGeneratedFile(filePath, content, { dryRun, force, onWrite })
     onWrite(`Already installed ${filePath}`);
     return;
   }
-  if (existing !== null && !existing.includes(GENERATED_MARKER) && !existing.includes(LEGACY_GENERATED_MARKER) && !force) {
+  if (existing !== null && !existing.includes(GENERATED_MARKER2) && !existing.includes(LEGACY_GENERATED_MARKER) && !force) {
     throw new Error(
       `Refusing to overwrite non-vibetime file: ${filePath}. Re-run with --force if this is intentional.`
     );
@@ -148,11 +148,11 @@ async function countDirectoryEntries(candidatePath) {
     throw error;
   }
 }
-var GENERATED_MARKER, LEGACY_GENERATED_MARKER;
+var GENERATED_MARKER2, LEGACY_GENERATED_MARKER;
 var init_fs = __esm({
   "src/lib/fs.ts"() {
     "use strict";
-    GENERATED_MARKER = "Generated by vibetime.";
+    GENERATED_MARKER2 = "Generated by vibetime.";
     LEGACY_GENERATED_MARKER = "Generated by codetime.";
   }
 });
@@ -886,7 +886,7 @@ var init_esm = __esm({
 import { spawn as spawn2, spawnSync } from "node:child_process";
 import { mkdir as mkdir5, open, rm, stat as stat13, writeFile as writeFile4 } from "node:fs/promises";
 import os11 from "node:os";
-import path24 from "node:path";
+import path25 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -924,7 +924,7 @@ var TELEMETRY_EVENT_TYPES = [
   "agent.operation"
 ];
 var FILE_ACTIVITY_OPERATIONS = ["read", "search", "create", "write", "edit", "delete"];
-var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build", "zed"];
+var BACKFILL_SOURCE_IDS = ["codex", "claude-code", "claude-cowork", "copilot", "opencode", "pi", "agy", "codebuddy", "qoder", "qoder-cn", "workbuddy", "zcode", "grok-build", "zed", "kimi-code"];
 function createWorkspaceId(input) {
   const basis = input.repoUrl || input.repoRoot || input.projectName || "unknown";
   return `workspace_${fnv1a(basis)}`;
@@ -2047,7 +2047,8 @@ function claudeStyleFileMetrics(tool, input) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.51" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.53" : "0.1.1";
+var GENERATED_MARKER = "Generated by vibetime.";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -6935,120 +6936,761 @@ function createGrokBuildAdapter() {
   };
 }
 
-// src/adapters/opencode.ts
-import os6 from "node:os";
+// src/adapters/kimi-code.ts
+import { readFile as readFile9 } from "node:fs/promises";
 import path14 from "node:path";
-async function parseOpenCodeSessionFile(dbPath, options) {
-  const { DatabaseSync } = await import("node:sqlite");
-  if (!dbPath.endsWith(".db")) {
-    return [];
+
+// src/lib/toml-hooks.ts
+init_fs();
+async function hasTomlHookCommand(filePath, command) {
+  const text = await readTextIfExists(filePath);
+  if (!text) {
+    return false;
   }
-  const db = new DatabaseSync(dbPath, { readOnly: true });
-  const events = [];
+  return parseTomlHookRules(text).some((rule) => rule.command === command);
+}
+function parseTomlHookRules(text) {
+  const rules = [];
+  const chunks = text.split(/^\[\[hooks\]\][ \t]*\r?\n?/m);
+  for (const chunk of chunks.slice(1)) {
+    const body = chunk.split(/^\[[^\]]+\]/m)[0] ?? "";
+    const event = tomlStringField(body, "event");
+    const command = tomlStringField(body, "command");
+    if (!event || !command) {
+      continue;
+    }
+    const matcher = tomlStringField(body, "matcher");
+    const timeout = tomlNumberField(body, "timeout");
+    const rule = { event, command };
+    if (matcher !== void 0) {
+      rule.matcher = matcher;
+    }
+    if (timeout !== void 0) {
+      rule.timeout = timeout;
+    }
+    rules.push(rule);
+  }
+  return rules;
+}
+function mergeTomlHookRules(existingText, desired) {
+  const existingKeys = new Set(parseTomlHookRules(existingText).map(ruleKey));
+  const toAppend = desired.filter((rule) => !existingKeys.has(ruleKey(rule)));
+  if (toAppend.length === 0) {
+    return existingText;
+  }
+  let base = existingText;
+  if (base.length > 0 && !base.endsWith("\n")) {
+    base += "\n";
+  }
+  if (base.length > 0 && !base.endsWith("\n\n") && base.trim().length > 0) {
+    base += "\n";
+  }
+  const blocks = toAppend.map(serializeTomlHookRule).join("\n\n");
+  return `${base}${blocks}
+`;
+}
+function removeTomlHookRulesByCommand(existingText, commands) {
+  const commandSet = new Set(commands.filter(Boolean));
+  if (commandSet.size === 0 || !existingText) {
+    return existingText;
+  }
+  const parts = [];
+  let cursor = 0;
+  const headerRe = /^\[\[hooks\]\][ \t]*\r?\n?/gm;
+  let match = headerRe.exec(existingText);
+  let removed = 0;
+  while (match) {
+    const headerStart = match.index;
+    const bodyStart = headerRe.lastIndex;
+    const rest = existingText.slice(bodyStart);
+    const nextHeader = rest.search(/^\[[^\]]+\]/m);
+    const bodyEnd = nextHeader === -1 ? existingText.length : bodyStart + nextHeader;
+    const body = existingText.slice(bodyStart, bodyEnd);
+    const command = tomlStringField(body, "command");
+    parts.push(existingText.slice(cursor, headerStart));
+    if (command && commandSet.has(command)) {
+      removed += 1;
+    } else {
+      parts.push(existingText.slice(headerStart, bodyEnd));
+    }
+    cursor = bodyEnd;
+    match = headerRe.exec(existingText);
+  }
+  if (removed === 0) {
+    return existingText;
+  }
+  parts.push(existingText.slice(cursor));
+  let next = parts.join("");
+  next = next.replace(/\n{3,}/g, "\n\n");
+  if (next.length > 0 && !next.endsWith("\n")) {
+    next += "\n";
+  }
+  return next;
+}
+function looksLikeToml(text) {
+  const sample = text.trim();
+  if (!sample) {
+    return true;
+  }
+  if (sample.startsWith("{")) {
+    return false;
+  }
+  if (/^\s*\[\s*\{/.test(sample)) {
+    return false;
+  }
+  return true;
+}
+function ruleKey(rule) {
+  return `${rule.event}\0${rule.command}`;
+}
+function serializeTomlHookRule(rule) {
+  const lines = [
+    "[[hooks]]",
+    `event = "${escapeTomlString(rule.event)}"`
+  ];
+  if (rule.matcher !== void 0 && rule.matcher !== "") {
+    lines.push(`matcher = "${escapeTomlString(rule.matcher)}"`);
+  }
+  lines.push(`command = "${escapeTomlString(rule.command)}"`);
+  if (rule.timeout !== void 0) {
+    lines.push(`timeout = ${Math.floor(rule.timeout)}`);
+  }
+  return lines.join("\n");
+}
+function escapeTomlString(value) {
+  return value.replaceAll("\\", "\\\\").replaceAll('"', '\\"').replaceAll("\n", "\\n").replaceAll("	", "\\t");
+}
+function tomlStringField(body, key) {
+  const re = new RegExp(
+    `^\\s*${key}\\s*=\\s*(?:"((?:\\\\.|[^"\\\\])*)"|'([^']*)')\\s*$`,
+    "m"
+  );
+  const match = body.match(re);
+  if (!match) {
+    return void 0;
+  }
+  if (match[1] !== void 0) {
+    return match[1].replaceAll("\\n", "\n").replaceAll("\\t", "	").replaceAll('\\"', '"').replaceAll("\\\\", "\\");
+  }
+  return match[2];
+}
+function tomlNumberField(body, key) {
+  const re = new RegExp(`^\\s*${key}\\s*=\\s*(-?\\d+)\\s*$`, "m");
+  const match = body.match(re);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  const n = Number.parseInt(match[1], 10);
+  return Number.isFinite(n) ? n : void 0;
+}
+
+// src/adapters/kimi-code.ts
+var HOOK_COMMAND2 = "vibetime hook --agent kimi-code";
+var HOOK_TIMEOUT_SECONDS = 10;
+function kimiCodeHome(home, env) {
+  const override = env?.KIMI_CODE_HOME || env?.KIMI_HOME;
+  if (override && override.trim()) {
+    return path14.resolve(override);
+  }
+  return path14.join(home, ".kimi-code");
+}
+function kimiCodeSessionsDir(home, env) {
+  return path14.join(kimiCodeHome(home, env), "sessions");
+}
+function kimiCodeConfigPath(home, env) {
+  return path14.join(kimiCodeHome(home, env), "config.toml");
+}
+function kimiHookRules() {
+  const events = [
+    "SessionStart",
+    "SessionEnd",
+    "UserPromptSubmit",
+    "TurnStarted",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "Stop",
+    "StopFailure",
+    "PermissionResult",
+    "SubagentStop"
+  ];
+  return events.map((event) => ({
+    event,
+    command: HOOK_COMMAND2,
+    timeout: HOOK_TIMEOUT_SECONDS
+  }));
+}
+function baseKimiEvent(event) {
+  return {
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: "kimi-code",
+    agent: "kimi-code",
+    workspaceId: createWorkspaceId({ projectName: event.project, repoRoot: event.cwd }),
+    ...event
+  };
+}
+function extractTextParts(input) {
+  if (typeof input === "string") {
+    return input;
+  }
+  if (!Array.isArray(input)) {
+    return "";
+  }
+  return input.filter((item) => isPlainObject(item) && item.type === "text").map((item) => stringField(item, "text") || "").join("");
+}
+function kimiUsageFromRecord(usage) {
+  const inputOther = numberField(usage, "inputOther") || 0;
+  const output = numberField(usage, "output") || 0;
+  const cacheRead = numberField(usage, "inputCacheRead") || 0;
+  const cacheWrite = numberField(usage, "inputCacheCreation") || 0;
+  const inputTokens = numberField(usage, "input_tokens") || numberField(usage, "input") || 0;
+  const outputTokens = numberField(usage, "output_tokens") || 0;
+  const nonCached = inputOther || inputTokens;
+  const out = output || outputTokens;
+  const total = nonCached + out + cacheRead + cacheWrite;
+  if (total <= 0) {
+    return void 0;
+  }
+  return {
+    tokensInput: nonCached + cacheRead + cacheWrite || void 0,
+    tokensOutput: out || void 0,
+    tokensCacheReadInput: cacheRead || void 0,
+    tokensCacheCreationInput: cacheWrite || void 0,
+    tokensCachedInput: cacheRead + cacheWrite || void 0,
+    tokensTotal: total,
+    modelCalls: 1
+  };
+}
+function normalizeTurnId(raw) {
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    return `turn_${raw}`;
+  }
+  if (typeof raw === "string" && raw.trim()) {
+    return raw.startsWith("turn_") ? raw : `turn_${raw}`;
+  }
+  return void 0;
+}
+function sessionIdFromWirePath(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const match = normalized.match(/\/(session_[^/]+)\/agents\/[^/]+\/wire\.jsonl$/);
+  return match?.[1];
+}
+async function readSessionState(filePath) {
+  const sessionDir = path14.dirname(path14.dirname(path14.dirname(filePath)));
+  const statePath = path14.join(sessionDir, "state.json");
   try {
-    const sessionCols = new Set(
-      db.prepare("PRAGMA table_info(session)").all().map((row) => row.name)
-    );
-    const hasDirectory = sessionCols.has("directory");
-    const hasPath = sessionCols.has("path");
-    const hasArchived = sessionCols.has("time_archived");
-    const hasParentId = sessionCols.has("parent_id");
-    const selectCols = ["id", "title", "time_created"];
-    if (hasDirectory) {
-      selectCols.push("directory");
+    const text = await readFile9(statePath, "utf8");
+    const raw = JSON.parse(text);
+    if (!isPlainObject(raw)) {
+      return {};
     }
-    if (hasPath) {
-      selectCols.push("path");
+    return {
+      sessionId: stringField(raw, "id"),
+      cwd: stringField(raw, "cwd"),
+      title: stringField(raw, "title")
+    };
+  } catch {
+    return {};
+  }
+}
+async function parseKimiCodeSessionFile(filePath, options) {
+  if (path14.basename(filePath) !== "wire.jsonl") {
+    return [];
+  }
+  const text = await readFile9(filePath, "utf8");
+  const lines = text.split("\n").filter(Boolean);
+  const stateMeta = await readSessionState(filePath);
+  let sessionId = stateMeta.sessionId || sessionIdFromWirePath(filePath);
+  let cwd = stateMeta.cwd;
+  let project = cwd ? path14.basename(cwd) : void 0;
+  let model;
+  let provider;
+  let reasoningEffort;
+  const pendingToolCalls = /* @__PURE__ */ new Map();
+  const pendingPermissions = /* @__PURE__ */ new Map();
+  let sawUsageRecord = false;
+  const state = new SessionParserState(filePath, options, (event) => baseKimiEvent({ ...event, cwd, project, model, provider }));
+  if (sessionId) {
+    state.sessionId = sessionId;
+  }
+  const push = (event, ln, topType) => {
+    state.push(
+      {
+        ...event,
+        sessionId: event.sessionId || sessionId,
+        workspaceId: event.workspaceId || createWorkspaceId({ projectName: project, repoRoot: cwd })
+      },
+      ln,
+      topType || event.type,
+      event.type
+    );
+  };
+  for (const [index, line] of lines.entries()) {
+    const lineNumber = index + 1;
+    const raw = parseJsonLine(line);
+    if (!raw) {
+      continue;
     }
-    if (hasArchived) {
-      selectCols.push("time_archived");
+    const entryType = stringField(raw, "type");
+    const ts = timestampFrom(raw.time) || timestampFrom(raw.created_at) || timestampFrom(raw.timestamp);
+    if (!ts || !entryType) {
+      continue;
     }
-    if (hasParentId) {
-      selectCols.push("parent_id");
+    if (entryType === "metadata") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      continue;
     }
-    const sessions = db.prepare(
-      `SELECT ${selectCols.join(", ")} FROM session WHERE time_created IS NOT NULL ORDER BY time_created`
-    ).all();
-    const rootIdByRawId = /* @__PURE__ */ new Map();
-    if (hasParentId) {
-      const byId = new Map(sessions.map((s) => [s.id, s]));
-      for (const session of sessions) {
-        let current = session.id;
-        const visited = /* @__PURE__ */ new Set();
-        while (true) {
-          if (visited.has(current)) {
-            break;
-          }
-          visited.add(current);
-          const node = byId.get(current);
-          const parentId = node?.parent_id || void 0;
-          if (!parentId || !byId.has(parentId)) {
-            break;
-          }
-          current = parentId;
-        }
-        rootIdByRawId.set(session.id, current);
+    if (entryType === "profile.bind") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      model = stringField(raw, "modelAlias") || stringField(raw, "model") || model;
+      reasoningEffort = stringField(raw, "thinkingEffort") || reasoningEffort;
+      const disclosure = objectField(raw, "environmentDisclosure");
+      const disclosedCwd = stringField(disclosure, "cwd");
+      if (disclosedCwd) {
+        cwd = disclosedCwd;
+        project = path14.basename(disclosedCwd);
       }
+      continue;
     }
-    for (const session of sessions) {
-      const rawSessionId = session.id;
-      const sessionId = rootIdByRawId.get(rawSessionId) || rawSessionId;
-      const cwd = session.directory || session.path || void 0;
-      const project = cwd ? path14.basename(cwd) : void 0;
-      const sessionTs = msToIso(session.time_created);
-      events.push(baseOpenCodeEvent({
-        ts: sessionTs,
-        type: "session.started",
+    if (entryType === "turn.prompt") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      if (isTurnIdle(state.currentTurnLastEventAt) || state.currentTurnId) {
+        state.closeTurn(ts, lineNumber, entryType);
+      }
+      const nextOrdinal = state.currentTurnId ? Number.parseInt(state.currentTurnId.replace(/^turn_/, ""), 10) : Number.NaN;
+      const turnOrdinal = Number.isFinite(nextOrdinal) ? nextOrdinal + 1 : 0;
+      const turnId = `turn_${turnOrdinal}`;
+      state.startTurn(turnId, ts);
+      push(baseKimiEvent({
+        ts,
+        type: "turn.started",
         sessionId,
+        turnId,
         cwd,
         project,
-        operation: "session start"
-      }));
-      const messages = db.prepare(
-        "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created"
-      ).all(rawSessionId);
-      let currentTurnId;
-      let currentProvider;
-      let turnTs;
-      let reasoningEffort;
-      const modelSwitchedEvents = db.prepare(
-        "SELECT data FROM event WHERE aggregate_id = ? AND type = 'session.next.model.switched.1' ORDER BY seq"
-      ).all(rawSessionId);
-      for (const evt of modelSwitchedEvents) {
-        try {
-          const evtData = JSON.parse(evt.data);
-          const variant = isPlainObject(evtData) ? stringField(evtData.model || evtData, "variant") : void 0;
-          if (variant && variant !== "default") {
-            reasoningEffort = variant;
-          }
-        } catch {
+        model,
+        provider,
+        confidence: "exact"
+      }), lineNumber, entryType);
+      const promptText = extractTextParts(raw.input);
+      push(baseKimiEvent({
+        ts,
+        type: "prompt.submitted",
+        sessionId,
+        turnId,
+        cwd,
+        project,
+        model,
+        provider,
+        confidence: "exact",
+        metrics: {
+          prompts: 1,
+          promptChars: promptText.length || void 0
+        },
+        refs: stringRefs({
+          promptHash: promptText ? `sha256:${createStableHash(promptText)}` : void 0
+        })
+      }), lineNumber, entryType);
+      continue;
+    }
+    if (entryType === "llm.request") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      model = stringField(raw, "modelAlias") || stringField(raw, "model") || model;
+      provider = stringField(raw, "provider") || provider;
+      reasoningEffort = stringField(raw, "thinkingEffort") || reasoningEffort;
+      const turnStep = stringField(raw, "turnStep");
+      if (turnStep && !state.currentTurnId) {
+        const turnPart = turnStep.split(".")[0];
+        const turnId = normalizeTurnId(turnPart);
+        if (turnId) {
+          state.startTurn(turnId, ts);
         }
       }
-      for (const msg of messages) {
-        let info;
-        try {
-          info = JSON.parse(msg.data);
-        } catch {
-          continue;
+      continue;
+    }
+    if (entryType === "usage.record") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      sawUsageRecord = true;
+      model = stringField(raw, "model") || model;
+      const usage = objectField(raw, "usage");
+      const metrics = kimiUsageFromRecord(usage);
+      if (metrics) {
+        if (reasoningEffort) {
+          metrics.reasoningEffort = reasoningEffort;
         }
-        if (!isPlainObject(info)) {
-          continue;
+        push(baseKimiEvent({
+          ts,
+          type: "model.usage",
+          sessionId,
+          turnId: state.currentTurnId,
+          cwd,
+          project,
+          model,
+          provider,
+          confidence: "exact",
+          metrics
+        }), lineNumber, entryType);
+      }
+      continue;
+    }
+    if (entryType === "context.append_loop_event") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      const loopEvent = objectField(raw, "event");
+      const loopType = stringField(loopEvent, "type");
+      const turnId = normalizeTurnId(loopEvent.turnId) || state.currentTurnId;
+      if (turnId && turnId !== state.currentTurnId) {
+        if (state.currentTurnId) {
+          state.closeTurn(ts, lineNumber, entryType);
         }
-        const role = stringField(info, "role");
-        const timeObj = objectField(info, "time");
-        const timeCreated = numberField(timeObj, "created");
-        if (!role || !timeCreated) {
-          continue;
+        state.startTurn(turnId, ts);
+      }
+      if (loopType === "tool.call") {
+        const toolCallId = stringField(loopEvent, "toolCallId") || stringField(loopEvent, "uuid");
+        const toolName = stringField(loopEvent, "name") || "tool";
+        const toolInput = isPlainObject(loopEvent.args) ? loopEvent.args : {};
+        if (toolCallId) {
+          pendingToolCalls.set(toolCallId, {
+            toolName,
+            startedAt: ts,
+            turnId: turnId || state.currentTurnId,
+            input: toolInput
+          });
         }
-        if (role === "user") {
-          currentTurnId = `turn_${createStableHash([sessionId, msg.id]).slice(0, 24)}`;
-          turnTs = msToIso(timeCreated);
-          const userAgent = stringField(info, "agent") || "opencode";
-          const modelObj = objectField(info, "model");
-          const model = modelObj ? stringField(modelObj, "modelID") : void 0;
-          currentProvider = modelObj ? stringField(modelObj, "providerID") : void 0;
-          events.push(baseOpenCodeEvent({
-            ts: turnTs,
+        push(baseKimiEvent({
+          ts,
+          type: "tool.started",
+          operation: `${toolName} started`,
+          sessionId,
+          turnId: turnId || state.currentTurnId,
+          cwd,
+          project,
+          model,
+          provider,
+          tool: toolName,
+          confidence: "exact",
+          metrics: { toolCalls: 1 },
+          refs: stringRefs({
+            sourceId: toolCallId,
+            commandHash: toolName.toLowerCase() === "bash" && stringField(toolInput, "command") ? createStableHash(stringField(toolInput, "command")) : void 0
+          })
+        }), lineNumber, entryType);
+        const fileActivities = claudeStyleToolFileActivities(
+          toolName,
+          toolInput,
+          ts,
+          cwd
+        );
+        if (fileActivities.length > 0) {
+          push(baseKimiEvent({
+            ts,
+            type: eventTypeFromFileActivities(fileActivities),
+            operation: `${toolName} file activity`,
+            sessionId,
+            turnId: turnId || state.currentTurnId,
+            cwd,
+            project,
+            model,
+            provider,
+            tool: toolName,
+            confidence: "derived",
+            fileActivities,
+            metrics: summarizeFileActivities(fileActivities),
+            refs: stringRefs({ sourceId: toolCallId })
+          }), lineNumber, entryType);
+        }
+        continue;
+      }
+      if (loopType === "tool.result") {
+        const toolCallId = stringField(loopEvent, "toolCallId");
+        const pending = toolCallId ? pendingToolCalls.get(toolCallId) : void 0;
+        if (toolCallId) {
+          pendingToolCalls.delete(toolCallId);
+        }
+        const result = objectField(loopEvent, "result");
+        const isError = Boolean(result.isError);
+        const toolName = pending?.toolName || "tool";
+        const durationMs = pending ? durationMsBetween(pending.startedAt, ts) : void 0;
+        push(baseKimiEvent({
+          ts,
+          type: isError ? "tool.failed" : "tool.completed",
+          operation: isError ? `${toolName} failed` : `${toolName} completed`,
+          sessionId,
+          turnId: pending?.turnId || turnId || state.currentTurnId,
+          cwd,
+          project,
+          model,
+          provider,
+          tool: toolName,
+          success: !isError,
+          confidence: "exact",
+          metrics: {
+            toolDurationMs: durationMs,
+            durationMs
+          },
+          refs: stringRefs({ sourceId: toolCallId })
+        }), lineNumber, entryType);
+        if (toolName.toLowerCase() === "bash") {
+          push(baseKimiEvent({
+            ts,
+            type: isError ? "command.failed" : "command.completed",
+            operation: "command completed",
+            sessionId,
+            turnId: pending?.turnId || turnId || state.currentTurnId,
+            cwd,
+            project,
+            model,
+            provider,
+            tool: "Bash",
+            success: !isError,
+            confidence: "derived",
+            metrics: {
+              commandCalls: 1,
+              commandDurationMs: durationMs,
+              durationMs
+            },
+            refs: stringRefs({
+              sourceId: toolCallId,
+              commandHash: pending?.input.command ? `sha256:${createStableHash(String(pending.input.command))}` : void 0
+            })
+          }), lineNumber, entryType);
+        }
+        continue;
+      }
+      if (loopType === "step.end") {
+        if (!sawUsageRecord) {
+          const streamMs = numberField(loopEvent, "llmStreamDurationMs") || numberField(loopEvent, "llmServerDecodeMs");
+          const usage = objectField(loopEvent, "usage");
+          const metrics = kimiUsageFromRecord(usage);
+          if (metrics) {
+            if (streamMs) {
+              metrics.modelDurationMs = streamMs;
+            }
+            if (reasoningEffort) {
+              metrics.reasoningEffort = reasoningEffort;
+            }
+            push(baseKimiEvent({
+              ts,
+              type: "model.usage",
+              sessionId,
+              turnId: turnId || state.currentTurnId,
+              cwd,
+              project,
+              model,
+              provider,
+              confidence: "exact",
+              metrics
+            }), lineNumber, entryType);
+          }
+        }
+        continue;
+      }
+      continue;
+    }
+    if (entryType === "interaction.request") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      const requestId = stringField(raw, "id") || stringField(raw, "toolCallId");
+      const request2 = objectField(raw, "request");
+      const toolName = stringField(request2, "toolName") || stringField(raw, "toolName");
+      const turnId = normalizeTurnId(request2.turnId) || state.currentTurnId;
+      if (requestId) {
+        pendingPermissions.set(requestId, { toolName, startedAt: ts, turnId });
+      }
+      push(baseKimiEvent({
+        ts,
+        type: "permission.requested",
+        operation: toolName ? `${toolName} permission` : "permission requested",
+        sessionId,
+        turnId,
+        cwd,
+        project,
+        model,
+        provider,
+        tool: toolName,
+        confidence: "exact",
+        refs: stringRefs({ sourceId: requestId })
+      }), lineNumber, entryType);
+      continue;
+    }
+    if (entryType === "interaction.resolved") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      const requestId = stringField(raw, "id");
+      const pending = requestId ? pendingPermissions.get(requestId) : void 0;
+      if (requestId) {
+        pendingPermissions.delete(requestId);
+      }
+      const response = objectField(raw, "response");
+      const decision = stringField(response, "decision") || stringField(raw, "decision");
+      const granted = decision === "approved" || decision === "allow" || decision === "granted";
+      const denied = decision === "denied" || decision === "reject" || decision === "rejected";
+      push(baseKimiEvent({
+        ts,
+        type: granted ? "permission.granted" : denied ? "permission.denied" : "permission.resolved",
+        operation: decision ? `permission ${decision}` : "permission resolved",
+        sessionId,
+        turnId: pending?.turnId || state.currentTurnId,
+        cwd,
+        project,
+        model,
+        provider,
+        tool: pending?.toolName,
+        success: granted ? true : denied ? false : void 0,
+        confidence: "exact",
+        metrics: {
+          durationMs: pending ? durationMsBetween(pending.startedAt, ts) : void 0,
+          approvalWaitMs: pending ? durationMsBetween(pending.startedAt, ts) : void 0
+        },
+        refs: stringRefs({ sourceId: requestId })
+      }), lineNumber, entryType);
+      continue;
+    }
+  }
+  if (isTurnIdle(state.currentTurnLastEventAt)) {
+    state.closeTurn(state.currentTurnLastEventAt, lines.length);
+  }
+  return state.events.filter((event) => matchesBackfillFilters(event, options));
+}
+function createKimiCodeAdapter() {
+  return {
+    id: "kimi-code",
+    label: "Kimi Code",
+    agentName: "kimi-code",
+    kind: "agent",
+    detectPath(home, env) {
+      return kimiCodeHome(home, env);
+    },
+    installedPath(home, env) {
+      return kimiCodeConfigPath(home, env);
+    },
+    async isInstalled(home, env) {
+      return hasTomlHookCommand(kimiCodeConfigPath(home, env), HOOK_COMMAND2);
+    },
+    installEntries(home, env) {
+      return [{
+        kind: "hooks-toml",
+        path: kimiCodeConfigPath(home, env),
+        content: { hooks: kimiHookRules() }
+      }];
+    },
+    sourcePaths(home, env) {
+      return [kimiCodeSessionsDir(home, env)];
+    },
+    parseSessionFile: parseKimiCodeSessionFile
+  };
+}
+
+// src/adapters/opencode.ts
+import os6 from "node:os";
+import path15 from "node:path";
+async function parseOpenCodeSessionFile(dbPath, options) {
+  const { DatabaseSync } = await import("node:sqlite");
+  if (!dbPath.endsWith(".db")) {
+    return [];
+  }
+  const db = new DatabaseSync(dbPath, { readOnly: true });
+  const events = [];
+  try {
+    const sessionCols = new Set(
+      db.prepare("PRAGMA table_info(session)").all().map((row) => row.name)
+    );
+    const hasDirectory = sessionCols.has("directory");
+    const hasPath = sessionCols.has("path");
+    const hasArchived = sessionCols.has("time_archived");
+    const hasParentId = sessionCols.has("parent_id");
+    const selectCols = ["id", "title", "time_created"];
+    if (hasDirectory) {
+      selectCols.push("directory");
+    }
+    if (hasPath) {
+      selectCols.push("path");
+    }
+    if (hasArchived) {
+      selectCols.push("time_archived");
+    }
+    if (hasParentId) {
+      selectCols.push("parent_id");
+    }
+    const sessions = db.prepare(
+      `SELECT ${selectCols.join(", ")} FROM session WHERE time_created IS NOT NULL ORDER BY time_created`
+    ).all();
+    const rootIdByRawId = /* @__PURE__ */ new Map();
+    if (hasParentId) {
+      const byId = new Map(sessions.map((s) => [s.id, s]));
+      for (const session of sessions) {
+        let current = session.id;
+        const visited = /* @__PURE__ */ new Set();
+        while (true) {
+          if (visited.has(current)) {
+            break;
+          }
+          visited.add(current);
+          const node = byId.get(current);
+          const parentId = node?.parent_id || void 0;
+          if (!parentId || !byId.has(parentId)) {
+            break;
+          }
+          current = parentId;
+        }
+        rootIdByRawId.set(session.id, current);
+      }
+    }
+    for (const session of sessions) {
+      const rawSessionId = session.id;
+      const sessionId = rootIdByRawId.get(rawSessionId) || rawSessionId;
+      const cwd = session.directory || session.path || void 0;
+      const project = cwd ? path15.basename(cwd) : void 0;
+      const sessionTs = msToIso(session.time_created);
+      events.push(baseOpenCodeEvent({
+        ts: sessionTs,
+        type: "session.started",
+        sessionId,
+        cwd,
+        project,
+        operation: "session start"
+      }));
+      const messages = db.prepare(
+        "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created"
+      ).all(rawSessionId);
+      let currentTurnId;
+      let currentProvider;
+      let turnTs;
+      let reasoningEffort;
+      const modelSwitchedEvents = db.prepare(
+        "SELECT data FROM event WHERE aggregate_id = ? AND type = 'session.next.model.switched.1' ORDER BY seq"
+      ).all(rawSessionId);
+      for (const evt of modelSwitchedEvents) {
+        try {
+          const evtData = JSON.parse(evt.data);
+          const variant = isPlainObject(evtData) ? stringField(evtData.model || evtData, "variant") : void 0;
+          if (variant && variant !== "default") {
+            reasoningEffort = variant;
+          }
+        } catch {
+        }
+      }
+      for (const msg of messages) {
+        let info;
+        try {
+          info = JSON.parse(msg.data);
+        } catch {
+          continue;
+        }
+        if (!isPlainObject(info)) {
+          continue;
+        }
+        const role = stringField(info, "role");
+        const timeObj = objectField(info, "time");
+        const timeCreated = numberField(timeObj, "created");
+        if (!role || !timeCreated) {
+          continue;
+        }
+        if (role === "user") {
+          currentTurnId = `turn_${createStableHash([sessionId, msg.id]).slice(0, 24)}`;
+          turnTs = msToIso(timeCreated);
+          const userAgent = stringField(info, "agent") || "opencode";
+          const modelObj = objectField(info, "model");
+          const model = modelObj ? stringField(modelObj, "modelID") : void 0;
+          currentProvider = modelObj ? stringField(modelObj, "providerID") : void 0;
+          events.push(baseOpenCodeEvent({
+            ts: turnTs,
             type: "turn.started",
             sessionId,
             turnId: currentTurnId,
@@ -7102,7 +7744,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const provider = currentProvider;
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path14.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path15.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -7373,18 +8015,18 @@ function opencodeUsageFromInfo(info) {
 function opencodeConfigDir(home, env) {
   const override = env?.OPENCODE_CONFIG_DIR;
   if (override && override.trim()) {
-    return path14.resolve(override);
+    return path15.resolve(override);
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path14.join(path14.resolve(xdgConfig), "opencode");
+    return path15.join(path15.resolve(xdgConfig), "opencode");
   }
-  return path14.join(home, ".config", "opencode");
+  return path15.join(home, ".config", "opencode");
 }
 function opencodeDataCandidates(home, env) {
   const xdgData = env?.XDG_DATA_HOME;
-  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")];
+  const primary = xdgData && xdgData.trim() ? path15.join(path15.resolve(xdgData), "opencode", "opencode.db") : path15.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path15.join(home, ".opencode", "opencode.db")];
 }
 async function opencodeBackfillFiles(sourceRoot, home = os6.homedir(), env) {
   const { stat: stat14 } = await import("node:fs/promises");
@@ -7474,12 +8116,12 @@ function createOpenCodeAdapter() {
       return opencodeConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path14.join(opencodeConfigDir(home, env), PLUGIN_PATH);
+      return path15.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(path14.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path14.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path15.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path15.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
@@ -7487,7 +8129,7 @@ function createOpenCodeAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path14.join(opencodeConfigDir(home, env), PLUGIN_PATH),
+        path: path15.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
@@ -7499,12 +8141,12 @@ function createOpenCodeAdapter() {
 }
 
 // src/adapters/pi.ts
-import { readFile as readFile9 } from "node:fs/promises";
-import path15 from "node:path";
+import { readFile as readFile10 } from "node:fs/promises";
+import path16 from "node:path";
 function parsePiSubagentLink(filePath, headerParentSession) {
   if (headerParentSession) {
-    const parentFile = path15.isAbsolute(headerParentSession) ? headerParentSession : void 0;
-    const parentSessionId2 = parentFile ? path15.basename(parentFile, ".jsonl") : headerParentSession;
+    const parentFile = path16.isAbsolute(headerParentSession) ? headerParentSession : void 0;
+    const parentSessionId2 = parentFile ? path16.basename(parentFile, ".jsonl") : headerParentSession;
     return { parentSessionId: parentSessionId2, parentSessionFile: parentFile, explicit: true };
   }
   const normalized = filePath.replaceAll("\\", "/");
@@ -7517,20 +8159,20 @@ function parsePiSubagentLink(filePath, headerParentSession) {
     return void 0;
   }
   const parentSessionId = parentBasename.endsWith(".jsonl") ? parentBasename.slice(0, -".jsonl".length) : parentBasename;
-  const parentDir = path15.dirname(path15.dirname(path15.dirname(filePath)));
-  const parentSessionFile = path15.join(path15.dirname(parentDir), `${parentBasename}.jsonl`);
+  const parentDir = path16.dirname(path16.dirname(path16.dirname(filePath)));
+  const parentSessionFile = path16.join(path16.dirname(parentDir), `${parentBasename}.jsonl`);
   return { parentSessionId, parentSessionFile, explicit: false };
 }
 async function resolveParentContext(link, options) {
   if (link.parentSessionFile) {
     try {
-      const text = await readFile9(link.parentSessionFile, "utf8");
+      const text = await readFile10(link.parentSessionFile, "utf8");
       const firstLine = text.split("\n").find((line) => line.trim().length > 0);
       const raw = firstLine ? parseJsonLine(firstLine) : void 0;
       if (raw) {
         const id = stringField(raw, "id");
         const cwd = stringField(raw, "cwd");
-        const project = cwd ? path15.basename(cwd) : void 0;
+        const project = cwd ? path16.basename(cwd) : void 0;
         if (id || cwd || project) {
           return { sessionId: id, cwd, project };
         }
@@ -7575,7 +8217,7 @@ function rebuildEventIdentity2(event) {
   };
 }
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile9(filePath, "utf8");
+  const text = await readFile10(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -7607,7 +8249,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path15.basename(cwd) : project;
+      project = cwd ? path16.basename(cwd) : project;
       headerParentSession = stringField(raw, "parentSession") || headerParentSession;
       continue;
     }
@@ -8040,16 +8682,16 @@ export default function (pi: ExtensionAPI) {
 function piAgentDir(home, env) {
   const override = env?.PI_CODING_AGENT_DIR;
   if (override && override.trim()) {
-    return path15.resolve(override);
+    return path16.resolve(override);
   }
-  return path15.join(home, ".pi", "agent");
+  return path16.join(home, ".pi", "agent");
 }
 function piSessionDir(home, env) {
   const override = env?.PI_CODING_AGENT_SESSION_DIR;
   if (override && override.trim()) {
-    return path15.resolve(override);
+    return path16.resolve(override);
   }
-  return path15.join(piAgentDir(home, env), "sessions");
+  return path16.join(piAgentDir(home, env), "sessions");
 }
 function createPiAdapter() {
   return {
@@ -8061,12 +8703,12 @@ function createPiAdapter() {
       return piAgentDir(home, env);
     },
     installedPath(home, env) {
-      return path15.join(piAgentDir(home, env), "extensions", "vibetime.ts");
+      return path16.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(path15.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
+        return await pathExists2(path16.join(piAgentDir(home, env), "extensions", "vibetime.ts"));
       } catch {
         return false;
       }
@@ -8074,7 +8716,7 @@ function createPiAdapter() {
     installEntries(home, env) {
       return [{
         kind: "file",
-        path: path15.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
+        path: path16.join(piAgentDir(home, env), "extensions", "vibetime.ts"),
         content: piExtensionContent()
       }];
     },
@@ -8086,14 +8728,14 @@ function createPiAdapter() {
 }
 
 // src/adapters/qoder-cn.ts
-import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
+import { readdir as readdir7, readFile as readFile11, stat as stat8 } from "node:fs/promises";
 import os8 from "node:os";
-import path17 from "node:path";
+import path18 from "node:path";
 
 // src/adapters/qoder-local-db.ts
 import { access } from "node:fs/promises";
 import os7 from "node:os";
-import path16 from "node:path";
+import path17 from "node:path";
 function takeQoderDbModelCall(calls, requestId, blockStart) {
   if (requestId) {
     const call = calls.byRequestId.get(requestId)?.shift();
@@ -8112,12 +8754,12 @@ function takeQoderDbModelCall(calls, requestId, blockStart) {
 }
 function appDataRoot(appDirName, home = os7.homedir()) {
   if (process.platform === "darwin") {
-    return path16.join(home, "Library", "Application Support", appDirName);
+    return path17.join(home, "Library", "Application Support", appDirName);
   }
   if (process.platform === "win32") {
-    return path16.join(process.env.APPDATA || path16.join(home, "AppData", "Roaming"), appDirName);
+    return path17.join(process.env.APPDATA || path17.join(home, "AppData", "Roaming"), appDirName);
   }
-  return path16.join(home, ".config", appDirName);
+  return path17.join(home, ".config", appDirName);
 }
 function qoderLocalDbCandidates(appDirName) {
   const candidates = [];
@@ -8127,8 +8769,8 @@ function qoderLocalDbCandidates(appDirName) {
   }
   const configRoot = appDataRoot(appDirName);
   candidates.push(
-    path16.join(configRoot, "SharedClientCache", "cache", "db", "local.db"),
-    path16.join(configRoot, "SharedClientCache", "db", "local.db")
+    path17.join(configRoot, "SharedClientCache", "cache", "db", "local.db"),
+    path17.join(configRoot, "SharedClientCache", "db", "local.db")
   );
   return candidates;
 }
@@ -8137,7 +8779,7 @@ async function loadQoderIdeModelCatalog(appDirName, home) {
   try {
     const { DatabaseSync } = await import("node:sqlite");
     const db = new DatabaseSync(
-      path16.join(appDataRoot(appDirName, home), "User", "globalStorage", "state.vscdb"),
+      path17.join(appDataRoot(appDirName, home), "User", "globalStorage", "state.vscdb"),
       { readOnly: true }
     );
     try {
@@ -8279,7 +8921,7 @@ function resolveSessionPreferredModel(db, sessionId, modelMap) {
 
 // src/adapters/qoder-cn.ts
 function parseQoderCnPaths(filePath) {
-  const parts = filePath.split(path17.sep);
+  const parts = filePath.split(path18.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -8289,17 +8931,17 @@ function parseQoderCnPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path17.sep);
-    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path17.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path18.sep);
+    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path18.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path17.basename(filename, ".jsonl");
+    sessionId = path18.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     if (projectName === "transcript") {
       projectName = parts.at(-3) || "";
     }
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path17.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path18.sep);
   }
   return { configDir: configDir2, projectName, sessionId, mainTranscriptPath };
 }
@@ -8322,7 +8964,7 @@ function rebuildEventIdentity3(event) {
 }
 async function parseModelNamesFromDynamicTexts(dynamicTextsPath) {
   try {
-    const content = await readFile10(dynamicTextsPath, "utf8");
+    const content = await readFile11(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -8338,10 +8980,10 @@ async function parseModelNamesFromDynamicTexts(dynamicTextsPath) {
   }
 }
 async function loadQoderCnModelNames(configDir2, home) {
-  const map = await parseModelNamesFromDynamicTexts(path17.join(configDir2, ".auth", "dynamic-texts.json"));
+  const map = await parseModelNamesFromDynamicTexts(path18.join(configDir2, ".auth", "dynamic-texts.json"));
   const siblingConfigDir = configDir2.replace(/\.qoder-cn$/, ".qoder");
   if (siblingConfigDir !== configDir2) {
-    const siblingMap = await parseModelNamesFromDynamicTexts(path17.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
+    const siblingMap = await parseModelNamesFromDynamicTexts(path18.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
     for (const [key, val] of Object.entries(siblingMap)) {
       if (!(key in map)) {
         map[key] = val;
@@ -8360,7 +9002,7 @@ async function loadQoderCnModelNames(configDir2, home) {
 }
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderCnPaths(filePath);
-  const segmentsPath = path17.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path18.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
     const files = await readdir7(segmentsPath);
@@ -8368,7 +9010,7 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile10(path17.join(segmentsPath, file), "utf8");
+      const content = await readFile11(path18.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -8402,7 +9044,7 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderCnSessionFile(filePath, options) {
-  const text = await readFile10(filePath, "utf8");
+  const text = await readFile11(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const parsedPaths = parseQoderCnPaths(filePath);
   const { configDir: configDir2 } = parsedPaths;
@@ -8413,7 +9055,7 @@ async function parseQoderCnSessionFile(filePath, options) {
   let cwd;
   let project = projectContext.project;
   let model;
-  const home = path17.resolve(stringOption(options.home) || os8.homedir());
+  const home = path18.resolve(stringOption(options.home) || os8.homedir());
   const modelMap = await loadQoderCnModelNames(configDir2, home);
   const isSubagentSession = filePath.includes("subagents");
   const segmentModelCalls = await loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap);
@@ -8448,7 +9090,7 @@ async function parseQoderCnSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path17.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path18.basename(cwd) : project || await qoderCnProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -8783,7 +9425,7 @@ async function parseQoderCnSessionFile(filePath, options) {
   }
   dbModelCalls ??= await loadQoderDbModelCalls("QoderCN", parsedPaths.sessionId, modelMap);
   if (dbModelCalls.rootSessionId) {
-    const parentPath = path17.join(path17.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
+    const parentPath = path18.join(path18.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
     const parentSourcePathHash = `sha256:${createStableHash(parentPath)}`;
     return validEvents.map((event) => rebuildEventIdentity3({
       ...event,
@@ -8935,28 +9577,28 @@ function extractQoderAttachedPrompt(content) {
 }
 async function qoderCnProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderCnPaths(filePath);
-  const isSubagent = filePath.includes(`${path17.sep}subagents${path17.sep}`);
+  const isSubagent = filePath.includes(`${path18.sep}subagents${path18.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 && path17.isAbsolute(cwd)) {
+    if (cwd && path18.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path17.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path18.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path17.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path18.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 && path17.isAbsolute(cwd)) {
+          if (cwd && path18.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
         }
@@ -8968,7 +9610,7 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
     }
   }
   const root = await gitRootFromCwds2(cwds) || qoderCnProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path17.basename(cwds[0]) : root ? path17.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path18.basename(cwds[0]) : root ? path18.basename(root) : await qoderCnProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -8977,15 +9619,15 @@ async function qoderCnProjectContextFromLines(filePath, lines, options, configDi
 async function gitRootFromCwds2(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path17.resolve(cwd);
+    let current = path18.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat8(path17.join(current, ".git"));
+        await stat8(path18.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path17.dirname(current);
+      const parent = path18.dirname(current);
       if (parent === current) {
         break;
       }
@@ -8996,12 +9638,12 @@ async function gitRootFromCwds2(cwds) {
 }
 function qoderCnProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path17.resolve(cwd);
+    let current = path18.resolve(cwd);
     while (true) {
       if (encodeQoderCnProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path17.dirname(current);
+      const parent = path18.dirname(current);
       if (parent === current) {
         break;
       }
@@ -9011,14 +9653,14 @@ function qoderCnProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeQoderCnProjectPath(value) {
-  return path17.resolve(value).split(path17.sep).join("-").replaceAll("_", "-");
+  return path18.resolve(value).split(path18.sep).join("-").replaceAll("_", "-");
 }
 async function qoderCnProjectFromFilePath(filePath, options) {
-  const projectDir = path17.basename(path17.dirname(filePath));
-  const home = options ? path17.resolve(stringOption(options.home) || os8.homedir()) : os8.homedir();
+  const projectDir = path18.basename(path18.dirname(filePath));
+  const home = options ? path18.resolve(stringOption(options.home) || os8.homedir()) : os8.homedir();
   const resolved = await resolveQoderCnProjectPath(projectDir, home);
   if (resolved) {
-    return path17.basename(resolved);
+    return path18.basename(resolved);
   }
   const homePrefix = `${encodeQoderCnProjectPath(home)}-`;
   if (projectDir.startsWith(homePrefix)) {
@@ -9043,7 +9685,7 @@ async function resolveQoderCnProjectPath(projectDir, home) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path17.join(current, entry.name);
+        const candidate = path18.join(current, entry.name);
         const encoded = encodeQoderCnProjectPath(candidate);
         if (encoded === projectDir) {
           return candidate;
@@ -9088,9 +9730,9 @@ function hookConfig6() {
 function qoderCnConfigDir(home, env) {
   const override = env?.QODER_CN_CONFIG_DIR;
   if (override && override.trim()) {
-    return path17.resolve(override);
+    return path18.resolve(override);
   }
-  return path17.join(home, ".qoder-cn");
+  return path18.join(home, ".qoder-cn");
 }
 function createQoderCnAdapter() {
   return {
@@ -9102,27 +9744,27 @@ function createQoderCnAdapter() {
       return qoderCnConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path17.join(qoderCnConfigDir(home, env), "settings.json");
+      return path18.join(qoderCnConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path17.join(qoderCnConfigDir(home, env), "settings.json"),
+        path18.join(qoderCnConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder-cn"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path17.join(qoderCnConfigDir(home, env), "settings.json"),
+        path: path18.join(qoderCnConfigDir(home, env), "settings.json"),
         content: hookConfig6()
       }];
     },
     sourcePaths(home, env) {
       const base = qoderCnConfigDir(home, env);
       return [
-        path17.join(base, "projects"),
-        path17.join(base, ".qoder.json"),
-        path17.join(home, ".qoder.json")
+        path18.join(base, "projects"),
+        path18.join(base, ".qoder.json"),
+        path18.join(home, ".qoder.json")
       ];
     },
     parseSessionFile: parseQoderCnSessionFile
@@ -9131,11 +9773,11 @@ function createQoderCnAdapter() {
 
 // src/adapters/qoder.ts
 import { existsSync } from "node:fs";
-import { readdir as readdir8, readFile as readFile11, stat as stat9 } from "node:fs/promises";
+import { readdir as readdir8, readFile as readFile12, stat as stat9 } from "node:fs/promises";
 import os9 from "node:os";
-import path18 from "node:path";
+import path19 from "node:path";
 function parseQoderPaths(filePath) {
-  const parts = filePath.split(path18.sep);
+  const parts = filePath.split(path19.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
   let sessionId = "";
   let projectName = "";
@@ -9145,17 +9787,17 @@ function parseQoderPaths(filePath) {
     sessionId = parts[subagentsIdx - 1];
     projectName = parts[subagentsIdx - 2];
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path18.sep);
-    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path18.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path19.sep);
+    mainTranscriptPath = [...parts.slice(0, subagentsIdx - 1), `${sessionId}.jsonl`].join(path19.sep);
   } else {
     const filename = parts.at(-1) || "";
-    sessionId = path18.basename(filename, ".jsonl");
+    sessionId = path19.basename(filename, ".jsonl");
     projectName = parts.at(-2) || "";
     if (projectName === "transcript") {
       projectName = parts.at(-3) || "";
     }
     const projectsIdx = parts.lastIndexOf("projects");
-    configDir2 = parts.slice(0, projectsIdx).join(path18.sep);
+    configDir2 = parts.slice(0, projectsIdx).join(path19.sep);
   }
   return { configDir: configDir2, projectName, sessionId, mainTranscriptPath };
 }
@@ -9178,7 +9820,7 @@ function rebuildEventIdentity4(event) {
 }
 async function parseModelNamesFromDynamicTexts2(dynamicTextsPath) {
   try {
-    const content = await readFile11(dynamicTextsPath, "utf8");
+    const content = await readFile12(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
     const map = {};
@@ -9194,10 +9836,10 @@ async function parseModelNamesFromDynamicTexts2(dynamicTextsPath) {
   }
 }
 async function loadQoderModelNames(configDir2, home) {
-  const map = await parseModelNamesFromDynamicTexts2(path18.join(configDir2, ".auth", "dynamic-texts.json"));
+  const map = await parseModelNamesFromDynamicTexts2(path19.join(configDir2, ".auth", "dynamic-texts.json"));
   const siblingConfigDir = configDir2.replace(/\.qoder$/, ".qoder-cn");
   if (siblingConfigDir !== configDir2) {
-    const siblingMap = await parseModelNamesFromDynamicTexts2(path18.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
+    const siblingMap = await parseModelNamesFromDynamicTexts2(path19.join(siblingConfigDir, ".auth", "dynamic-texts.json"));
     for (const [key, val] of Object.entries(siblingMap)) {
       if (!(key in map)) {
         map[key] = val;
@@ -9205,11 +9847,11 @@ async function loadQoderModelNames(configDir2, home) {
     }
   }
   if (isQwenworkConfigRoot(configDir2)) {
-    for (const dir of [path18.join(home, ".qoder"), path18.join(home, ".qoder-cn")]) {
-      if (path18.resolve(dir) === path18.resolve(configDir2)) {
+    for (const dir of [path19.join(home, ".qoder"), path19.join(home, ".qoder-cn")]) {
+      if (path19.resolve(dir) === path19.resolve(configDir2)) {
         continue;
       }
-      const fallbackMap = await parseModelNamesFromDynamicTexts2(path18.join(dir, ".auth", "dynamic-texts.json"));
+      const fallbackMap = await parseModelNamesFromDynamicTexts2(path19.join(dir, ".auth", "dynamic-texts.json"));
       for (const [key, val] of Object.entries(fallbackMap)) {
         if (!(key in map)) {
           map[key] = val;
@@ -9228,17 +9870,17 @@ async function loadQoderModelNames(configDir2, home) {
   return map;
 }
 function isQwenworkConfigRoot(configDir2) {
-  const name = path18.basename(path18.resolve(configDir2));
+  const name = path19.basename(path19.resolve(configDir2));
   if (name === ".qwenworkcn" || name === ".qwenwork") {
     return true;
   }
   const override = process.env.QWENWORK_CONFIG_DIR;
-  return Boolean(override && override.trim() && path18.basename(path18.resolve(override)) === name);
+  return Boolean(override && override.trim() && path19.basename(path19.resolve(override)) === name);
 }
 var FAILED_SEGMENT_STOP_REASONS = /* @__PURE__ */ new Set(["cancelled", "canceled", "error", "failed", "refusal"]);
 async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderPaths(filePath);
-  const segmentsPath = path18.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
+  const segmentsPath = path19.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
   const modelCalls = [];
   try {
     const files = await readdir8(segmentsPath);
@@ -9246,7 +9888,7 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
       if (!file.endsWith(".jsonl")) {
         continue;
       }
-      const content = await readFile11(path18.join(segmentsPath, file), "utf8");
+      const content = await readFile12(path19.join(segmentsPath, file), "utf8");
       let currentTurnIsSubagent = false;
       for (const line of content.split("\n").filter(Boolean)) {
         const raw = parseJsonLine(line);
@@ -9280,7 +9922,7 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
   return modelCalls.filter((call) => call.isSubagent === isSubagentSession);
 }
 async function parseQoderSessionFile(filePath, options) {
-  const text = await readFile11(filePath, "utf8");
+  const text = await readFile12(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const parsedPaths = parseQoderPaths(filePath);
   const { configDir: configDir2 } = parsedPaths;
@@ -9291,7 +9933,7 @@ async function parseQoderSessionFile(filePath, options) {
   let cwd;
   let project = projectContext.project;
   let model;
-  const home = path18.resolve(stringOption(options.home) || os9.homedir());
+  const home = path19.resolve(stringOption(options.home) || os9.homedir());
   const modelMap = await loadQoderModelNames(configDir2, home);
   const qwenworkRoot = isQwenworkConfigRoot(configDir2);
   const isSubagentSession = filePath.includes("subagents");
@@ -9327,7 +9969,7 @@ async function parseQoderSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path18.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path19.basename(cwd) : project || await qoderProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -9637,7 +10279,7 @@ async function parseQoderSessionFile(filePath, options) {
   }
   dbModelCalls ??= await loadQoderDbModelCalls("Qoder", parsedPaths.sessionId, modelMap);
   if (dbModelCalls.rootSessionId) {
-    const parentPath = path18.join(path18.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
+    const parentPath = path19.join(path19.dirname(filePath), `${dbModelCalls.rootSessionId}.jsonl`);
     const parentSourcePathHash = `sha256:${createStableHash(parentPath)}`;
     return validEvents.map((event) => rebuildEventIdentity4({
       ...event,
@@ -9753,41 +10395,41 @@ function qoderExtractText(value) {
 }
 async function qoderProjectContextFromLines(filePath, lines, options, configDir2) {
   const { projectName: projectDir, sessionId } = parseQoderPaths(filePath);
-  const isSubagent = filePath.includes(`${path18.sep}subagents${path18.sep}`);
+  const isSubagent = filePath.includes(`${path19.sep}subagents${path19.sep}`);
   const inherited = isSubagent ? await readPersistedSessionContextFromOptions(options, sessionId) : void 0;
   let cwds = [];
   const workspaceDirs = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path18.isAbsolute(cwd)) {
+    if (cwd && path19.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
     if (raw && stringField(raw, "type") === "workspace-directories") {
       for (const dir of arrayField5(raw, "directories")) {
-        if (typeof dir === "string" && path18.isAbsolute(dir)) {
+        if (typeof dir === "string" && path19.isAbsolute(dir)) {
           workspaceDirs.push(dir);
         }
       }
     }
   }
   if (isSubagent) {
-    if (inherited?.cwd && path18.isAbsolute(inherited.cwd)) {
+    if (inherited?.cwd && path19.isAbsolute(inherited.cwd)) {
       cwds = [inherited.cwd];
     } else {
-      const parentSessionPath = path18.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
+      const parentSessionPath = path19.join(configDir2, "projects", projectDir, `${sessionId}.jsonl`);
       try {
-        const parentText = await readFile11(parentSessionPath, "utf8");
+        const parentText = await readFile12(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 && path18.isAbsolute(cwd)) {
+          if (cwd && path19.isAbsolute(cwd)) {
             parentCwds.push(cwd);
           }
           if (workspaceDirs.length === 0 && raw && stringField(raw, "type") === "workspace-directories") {
             for (const dir of arrayField5(raw, "directories")) {
-              if (typeof dir === "string" && path18.isAbsolute(dir)) {
+              if (typeof dir === "string" && path19.isAbsolute(dir)) {
                 workspaceDirs.push(dir);
               }
             }
@@ -9807,29 +10449,29 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
     }
   }
   const root = await gitRootFromCwds3(cwds) || qoderProjectRootFromCwds(projectDir, cwds);
-  const project = inherited?.project || (cwds.length > 0 ? path18.basename(cwds[0]) : root ? path18.basename(root) : await qoderProjectFromFilePath(filePath, options));
+  const project = inherited?.project || (cwds.length > 0 ? path19.basename(cwds[0]) : root ? path19.basename(root) : await qoderProjectFromFilePath(filePath, options));
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
   };
 }
 function pathInsideDir(candidate, dir) {
-  const resolvedDir = path18.resolve(dir);
-  const resolved = path18.resolve(candidate);
-  return resolved === resolvedDir || resolved.startsWith(`${resolvedDir}${path18.sep}`);
+  const resolvedDir = path19.resolve(dir);
+  const resolved = path19.resolve(candidate);
+  return resolved === resolvedDir || resolved.startsWith(`${resolvedDir}${path19.sep}`);
 }
 async function gitRootFromCwds3(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path18.resolve(cwd);
+    let current = path19.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat9(path18.join(current, ".git"));
+        await stat9(path19.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path18.dirname(current);
+      const parent = path19.dirname(current);
       if (parent === current) {
         break;
       }
@@ -9840,12 +10482,12 @@ async function gitRootFromCwds3(cwds) {
 }
 function qoderProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path18.resolve(cwd);
+    let current = path19.resolve(cwd);
     while (true) {
       if (qoderEncodedVariants(current).includes(projectDir)) {
         return current;
       }
-      const parent = path18.dirname(current);
+      const parent = path19.dirname(current);
       if (parent === current) {
         break;
       }
@@ -9855,7 +10497,7 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function rawQoderProjectPath(value) {
-  return path18.resolve(value).split(path18.sep).join("-");
+  return path19.resolve(value).split(path19.sep).join("-");
 }
 function qoderEncodedVariants(value) {
   const raw = rawQoderProjectPath(value);
@@ -9876,11 +10518,11 @@ function qoderEncodedProjectSuffix(projectDir, home) {
   return void 0;
 }
 async function qoderProjectFromFilePath(filePath, options) {
-  const projectDir = path18.basename(path18.dirname(filePath));
-  const home = options ? path18.resolve(stringOption(options.home) || os9.homedir()) : os9.homedir();
+  const projectDir = path19.basename(path19.dirname(filePath));
+  const home = options ? path19.resolve(stringOption(options.home) || os9.homedir()) : os9.homedir();
   const resolved = await resolveQoderProjectPath(projectDir, home);
   if (resolved) {
-    return path18.basename(resolved);
+    return path19.basename(resolved);
   }
   const suffix = qoderEncodedProjectSuffix(projectDir, home);
   if (suffix) {
@@ -9906,7 +10548,7 @@ async function resolveQoderProjectPath(projectDir, home) {
         if (!entry.isDirectory()) {
           continue;
         }
-        const candidate = path18.join(current, entry.name);
+        const candidate = path19.join(current, entry.name);
         const candidateVariants = qoderEncodedVariants(candidate);
         if (candidateVariants.includes(projectDir)) {
           return candidate;
@@ -9951,19 +10593,19 @@ function hookConfig7() {
 function qoderConfigDir(home, env) {
   const override = env?.QODER_CONFIG_DIR;
   if (override && override.trim()) {
-    return path18.resolve(override);
+    return path19.resolve(override);
   }
-  return path18.join(home, ".qoder");
+  return path19.join(home, ".qoder");
 }
 function qwenworkConfigDir(home, env) {
   const override = env?.QWENWORK_CONFIG_DIR;
   if (override && override.trim()) {
-    return path18.resolve(override);
+    return path19.resolve(override);
   }
-  return path18.join(home, ".qwenworkcn");
+  return path19.join(home, ".qwenworkcn");
 }
 function qoderConfigDirs(home, env) {
-  return [...new Set([qoderConfigDir(home, env), qwenworkConfigDir(home, env)].map((dir) => path18.resolve(dir)))];
+  return [...new Set([qoderConfigDir(home, env), qwenworkConfigDir(home, env)].map((dir) => path19.resolve(dir)))];
 }
 function createQoderAdapter() {
   return {
@@ -9975,11 +10617,11 @@ function createQoderAdapter() {
       return qoderConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path18.join(qoderConfigDir(home, env), "settings.json");
+      return path19.join(qoderConfigDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path18.join(qoderConfigDir(home, env), "settings.json"),
+        path19.join(qoderConfigDir(home, env), "settings.json"),
         "vibetime hook --agent qoder"
       );
     },
@@ -9988,16 +10630,16 @@ function createQoderAdapter() {
       const targets = [primary, ...variants.filter((dir) => existsSync(dir))];
       return targets.map((base) => ({
         kind: "hooks-json",
-        path: path18.join(base, "settings.json"),
+        path: path19.join(base, "settings.json"),
         content: hookConfig7()
       }));
     },
     sourcePaths(home, env) {
-      const paths = qoderConfigDirs(home, env).map((base2) => path18.join(base2, "projects"));
+      const paths = qoderConfigDirs(home, env).map((base2) => path19.join(base2, "projects"));
       const base = qoderConfigDir(home, env);
       paths.push(
-        path18.join(base, ".qoder.json"),
-        path18.join(home, ".qoder.json")
+        path19.join(base, ".qoder.json"),
+        path19.join(home, ".qoder.json")
       );
       return paths;
     },
@@ -10033,27 +10675,27 @@ function normalizeId(id) {
 }
 
 // src/adapters/workbuddy.ts
-import { readdir as readdir9, readFile as readFile12, stat as stat10 } from "node:fs/promises";
-import path19 from "node:path";
+import { readdir as readdir9, readFile as readFile13, stat as stat10 } from "node:fs/promises";
+import path20 from "node:path";
 function workbuddyProjectsDir(home, env) {
   const override = env?.WORKBUDDY_PROJECTS_DIR || env?.WORKBUDDY_HOME;
   if (override && override.trim()) {
-    return path19.resolve(override, override.endsWith("projects") ? "" : "projects");
+    return path20.resolve(override, override.endsWith("projects") ? "" : "projects");
   }
-  return path19.join(home, ".workbuddy", "projects");
+  return path20.join(home, ".workbuddy", "projects");
 }
 function workbuddyBaseDir(home, env) {
   const override = env?.WORKBUDDY_HOME;
   if (override && override.trim()) {
-    return path19.resolve(override);
+    return path20.resolve(override);
   }
-  return path19.join(home, ".workbuddy");
+  return path20.join(home, ".workbuddy");
 }
 function projectFromCwd(cwd, fallback) {
   if (!cwd) {
     return fallback;
   }
-  return path19.basename(cwd) || fallback;
+  return path20.basename(cwd) || fallback;
 }
 function sourceHash(filePath) {
   return `sha256:${createStableHash(filePath)}`;
@@ -10171,7 +10813,7 @@ function toolCallFailed(record) {
   return status === "failed" || status === "incomplete" || record.is_error === true || providerData.error != null || providerData.isError === true;
 }
 async function readWorkbuddyLines(filePath) {
-  const text = await readFile12(filePath, "utf8");
+  const text = await readFile13(filePath, "utf8");
   return text.split(/\r?\n/).map((line, index) => {
     if (!line.trim()) {
       return void 0;
@@ -10191,8 +10833,8 @@ async function parseWorkbuddySessionFile(filePath, options) {
   }
   const events = [];
   const first = lines[0].record;
-  const sessionId = stringField(first, "sessionId") || path19.basename(filePath, ".jsonl");
-  const fallbackProject = path19.basename(path19.dirname(filePath));
+  const sessionId = stringField(first, "sessionId") || path20.basename(filePath, ".jsonl");
+  const fallbackProject = path20.basename(path20.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 });
@@ -10481,11 +11123,11 @@ async function workbuddyBackfillFiles(sourceRoot, home, env) {
       if (!project.isDirectory()) {
         continue;
       }
-      const projectDir = path19.join(base, project.name);
+      const projectDir = path20.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 = path19.join(projectDir, entry.name);
+          const filePath = path20.join(projectDir, entry.name);
           const info = await stat10(filePath);
           files.push({ path: filePath, modifiedAt: info.mtime.toISOString() });
         }
@@ -10523,18 +11165,18 @@ function createWorkbuddyAdapter() {
       return workbuddyProjectsDir(home, env);
     },
     installedPath(home, env) {
-      return path19.join(workbuddyBaseDir(home, env), "settings.json");
+      return path20.join(workbuddyBaseDir(home, env), "settings.json");
     },
     async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path19.join(workbuddyBaseDir(home, env), "settings.json"),
+        path20.join(workbuddyBaseDir(home, env), "settings.json"),
         "vibetime hook --agent workbuddy"
       );
     },
     installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path19.join(workbuddyBaseDir(home, env), "settings.json"),
+        path: path20.join(workbuddyBaseDir(home, env), "settings.json"),
         content: hookConfig8()
       }];
     },
@@ -10547,20 +11189,20 @@ function createWorkbuddyAdapter() {
 
 // src/adapters/zcode.ts
 import { execFile } from "node:child_process";
-import { readFile as readFile13, stat as stat11 } from "node:fs/promises";
-import path20 from "node:path";
+import { readFile as readFile14, stat as stat11 } from "node:fs/promises";
+import path21 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 path20.resolve(override, override.endsWith("cli") ? "" : "cli");
+    return path21.resolve(override, override.endsWith("cli") ? "" : "cli");
   }
-  return path20.join(home, ".zcode", "cli");
+  return path21.join(home, ".zcode", "cli");
 }
 function zcodeDbPath(home, env) {
-  return path20.join(zcodeCliDir(home, env), "db", "db.sqlite");
+  return path21.join(zcodeCliDir(home, env), "db", "db.sqlite");
 }
 var providerNameCache = null;
 async function loadProviderNames(configPath2) {
@@ -10576,7 +11218,7 @@ async function loadProviderNames(configPath2) {
   }
   const map = /* @__PURE__ */ new Map();
   try {
-    const raw = await readFile13(configPath2, "utf-8");
+    const raw = await readFile14(configPath2, "utf-8");
     const config = JSON.parse(raw);
     const providers = config?.provider;
     if (isPlainObject(providers)) {
@@ -10594,7 +11236,7 @@ function sourceHash2(filePath) {
   return `sha256:${createStableHash(filePath)}`;
 }
 function projectFromDirectory(directory) {
-  return directory ? path20.basename(directory) || "zcode" : "zcode";
+  return directory ? path21.basename(directory) || "zcode" : "zcode";
 }
 function isoFromMs(value) {
   return timestampFrom(typeof value === "number" ? value : Number(value));
@@ -10777,16 +11419,16 @@ async function parseZCodeDb(filePath, options) {
   if (rows.length === 0) {
     return [];
   }
-  let candidate = path20.resolve(filePath);
+  let candidate = path21.resolve(filePath);
   let configPath2 = "";
   for (let i = 0; i < 12; i++) {
-    const probe = path20.join(candidate, ".zcode", "v2", "config.json");
+    const probe = path21.join(candidate, ".zcode", "v2", "config.json");
     try {
       await stat11(probe);
       configPath2 = probe;
       break;
     } catch {
-      const parent = path20.dirname(candidate);
+      const parent = path21.dirname(candidate);
       if (parent === candidate) break;
       candidate = parent;
     }
@@ -11002,7 +11644,7 @@ async function parseZCodeDb(filePath, options) {
 }
 async function zcodeBackfillFiles(sourceRoot, home, env) {
   const candidate = sourceRoot || zcodeDbPath(home, env);
-  const filePath = candidate.endsWith(".sqlite") ? candidate : path20.join(candidate, "db", "db.sqlite");
+  const filePath = candidate.endsWith(".sqlite") ? candidate : path21.join(candidate, "db", "db.sqlite");
   try {
     const info = await stat11(filePath);
     return [{ path: filePath, modifiedAt: info.mtime.toISOString() }];
@@ -11037,49 +11679,49 @@ function createZCodeAdapter() {
 
 // src/adapters/zed.ts
 import os10 from "node:os";
-import path21 from "node:path";
+import path22 from "node:path";
 function zedThreadsCandidates(home, env) {
   const candidates = [];
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    candidates.push(path21.join(home, "Library", "Application Support", "Zed", "threads", "threads.db"));
+    candidates.push(path22.join(home, "Library", "Application Support", "Zed", "threads", "threads.db"));
   } else if (platform2 === "win32") {
     const appdata = env?.APPDATA;
     if (appdata && appdata.trim()) {
-      candidates.push(path21.join(path21.resolve(appdata), "Zed", "threads", "threads.db"));
+      candidates.push(path22.join(path22.resolve(appdata), "Zed", "threads", "threads.db"));
     }
-    candidates.push(path21.join(home, "AppData", "Roaming", "Zed", "threads", "threads.db"));
+    candidates.push(path22.join(home, "AppData", "Roaming", "Zed", "threads", "threads.db"));
   } else {
     const xdgData = env?.XDG_DATA_HOME;
     if (xdgData && xdgData.trim()) {
-      candidates.push(path21.join(path21.resolve(xdgData), "zed", "threads", "threads.db"));
+      candidates.push(path22.join(path22.resolve(xdgData), "zed", "threads", "threads.db"));
     }
-    candidates.push(path21.join(home, ".local", "share", "zed", "threads", "threads.db"));
+    candidates.push(path22.join(home, ".local", "share", "zed", "threads", "threads.db"));
     const xdgConfig = env?.XDG_CONFIG_HOME;
     if (xdgConfig && xdgConfig.trim()) {
-      candidates.push(path21.join(path21.resolve(xdgConfig), "zed", "threads", "threads.db"));
+      candidates.push(path22.join(path22.resolve(xdgConfig), "zed", "threads", "threads.db"));
     }
-    candidates.push(path21.join(home, ".config", "zed", "threads", "threads.db"));
+    candidates.push(path22.join(home, ".config", "zed", "threads", "threads.db"));
   }
   return candidates;
 }
 function zedConfigDir(home, env) {
   const platform2 = process.platform;
   if (platform2 === "darwin") {
-    return path21.join(home, "Library", "Application Support", "Zed");
+    return path22.join(home, "Library", "Application Support", "Zed");
   }
   if (platform2 === "win32") {
     const appdata = env?.APPDATA;
     if (appdata && appdata.trim()) {
-      return path21.join(path21.resolve(appdata), "Zed");
+      return path22.join(path22.resolve(appdata), "Zed");
     }
-    return path21.join(home, "AppData", "Roaming", "Zed");
+    return path22.join(home, "AppData", "Roaming", "Zed");
   }
   const xdgConfig = env?.XDG_CONFIG_HOME;
   if (xdgConfig && xdgConfig.trim()) {
-    return path21.join(path21.resolve(xdgConfig), "zed");
+    return path22.join(path22.resolve(xdgConfig), "zed");
   }
-  return path21.join(home, ".config", "zed");
+  return path22.join(home, ".config", "zed");
 }
 function baseZedEvent(event) {
   return {
@@ -11143,7 +11785,7 @@ async function parseZedSessionFile(dbPath, options) {
       const folderRaw = row.folder_paths || "";
       const folder = folderRaw.split(/[\n,]/).map((s) => s.trim()).find(Boolean);
       const cwd = folder || void 0;
-      const project = cwd ? path21.basename(cwd) : row.summary ? row.summary.slice(0, 40) : void 0;
+      const project = cwd ? path22.basename(cwd) : row.summary ? row.summary.slice(0, 40) : void 0;
       let json;
       try {
         const bytes = row.data_type === "zstd" ? decompress2(new Uint8Array(row.data)) : new Uint8Array(row.data);
@@ -11418,7 +12060,7 @@ function createZedAdapter() {
       return zedConfigDir(home, env);
     },
     installedPath(home, env) {
-      return path21.join(zedConfigDir(home, env), "vibetime-marker");
+      return path22.join(zedConfigDir(home, env), "vibetime-marker");
     },
     async isInstalled() {
       return false;
@@ -11793,11 +12435,26 @@ async function installEntry(entry, options) {
     await mergeHooksJson(entry.path, entry.content, options);
     return;
   }
+  if (entry.kind === "hooks-toml" && typeof entry.content === "object") {
+    await mergeHooksToml(entry.path, entry.content, options);
+    return;
+  }
   await writeGeneratedFile(entry.path, String(entry.content), {
     ...options,
     onWrite: options.onWrite
   });
 }
+async function uninstallEntry(entry, options) {
+  if (entry.kind === "hooks-toml" && typeof entry.content === "object") {
+    await uninstallHooksToml(entry.path, entry.content, options);
+    return;
+  }
+  if (entry.kind === "hooks-json" && typeof entry.content === "object") {
+    await uninstallHooksJson(entry.path, entry.content, options);
+    return;
+  }
+  await uninstallGeneratedFile(entry.path, options);
+}
 async function mergeHooksJson(filePath, content, { dryRun, force, onWrite }) {
   const { mkdir: mkdir6, writeFile: writeFile5 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
@@ -11894,20 +12551,232 @@ function hookCommandFromGroup(group) {
   const hook = group.hooks[0];
   return isPlainObject(hook) && typeof hook.command === "string" ? hook.command : void 0;
 }
+async function mergeHooksToml(filePath, content, { dryRun, force, onWrite }) {
+  const { mkdir: mkdir6, writeFile: writeFile5 } = await import("node:fs/promises");
+  const pathMod = await import("node:path");
+  if (dryRun) {
+    onWrite(`Would merge ${filePath}`);
+    return;
+  }
+  const existingText = await readTextIfExists(filePath);
+  if (existingText !== null && existingText.trim() !== "" && !looksLikeToml(existingText) && !force) {
+    throw new Error(
+      `Refusing to update non-TOML file: ${filePath}. Re-run with --force if this is intentional.`
+    );
+  }
+  const desired = Array.isArray(content.hooks) ? content.hooks : [];
+  const nextText = mergeTomlHookRules(existingText ?? "", desired);
+  if (existingText === nextText || existingText === null && nextText === "") {
+    onWrite(`Already installed ${filePath}`);
+    return;
+  }
+  if (existingText !== null) {
+    const existingKeys = new Set(
+      parseTomlHookRules(existingText).map((rule) => `${rule.event}\0${rule.command}`)
+    );
+    const allPresent = desired.every((rule) => existingKeys.has(`${rule.event}\0${rule.command}`));
+    if (allPresent && desired.length > 0) {
+      onWrite(`Already installed ${filePath}`);
+      return;
+    }
+  }
+  await mkdir6(pathMod.dirname(filePath), { recursive: true });
+  await writeFile5(filePath, nextText, "utf8");
+  onWrite(`Installed ${filePath}`);
+}
+async function uninstallHooksToml(filePath, content, { dryRun, onWrite }) {
+  const existingText = await readTextIfExists(filePath);
+  if (existingText === null) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  const commands = Array.from(new Set(
+    (Array.isArray(content.hooks) ? content.hooks : []).map((rule) => rule.command).filter((cmd) => typeof cmd === "string" && cmd.length > 0)
+  ));
+  if (commands.length === 0) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  const nextText = removeTomlHookRulesByCommand(existingText, commands);
+  if (nextText === existingText) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  if (dryRun) {
+    onWrite(`Would uninstall ${filePath}`);
+    return;
+  }
+  const { writeFile: writeFile5 } = await import("node:fs/promises");
+  await writeFile5(filePath, nextText, "utf8");
+  onWrite(`Uninstalled ${filePath}`);
+}
+function collectHookCommandsFromJsonContent(content) {
+  const commands = /* @__PURE__ */ new Set();
+  const walkGroups = (groups) => {
+    if (!Array.isArray(groups)) {
+      return;
+    }
+    for (const group of groups) {
+      if (!isPlainObject(group) || !Array.isArray(group.hooks)) {
+        continue;
+      }
+      for (const hook of group.hooks) {
+        if (isPlainObject(hook) && typeof hook.command === "string" && hook.command) {
+          commands.add(hook.command);
+        }
+      }
+    }
+  };
+  if (isPlainObject(content.hooks)) {
+    for (const groups of Object.values(content.hooks)) {
+      walkGroups(groups);
+    }
+  }
+  for (const [key, value] of Object.entries(content)) {
+    if (key === "hooks" || key === "enable_json_hooks" || !isPlainObject(value)) {
+      continue;
+    }
+    for (const groups of Object.values(value)) {
+      walkGroups(groups);
+    }
+  }
+  return [...commands];
+}
+function stripHookCommandsFromGroups(groups, commands) {
+  if (!Array.isArray(groups)) {
+    return groups;
+  }
+  return groups.map((group) => {
+    if (!isPlainObject(group) || !Array.isArray(group.hooks)) {
+      return group;
+    }
+    const nextHooks = group.hooks.filter(
+      (hook) => !(isPlainObject(hook) && typeof hook.command === "string" && commands.has(hook.command))
+    );
+    if (nextHooks.length === 0) {
+      return null;
+    }
+    return { ...group, hooks: nextHooks };
+  }).filter(Boolean);
+}
+async function uninstallHooksJson(filePath, content, { dryRun, onWrite }) {
+  const existingText = await readTextIfExists(filePath);
+  if (existingText === null) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  let existing;
+  try {
+    existing = JSON.parse(existingText);
+  } catch {
+    onWrite(`Skipped non-JSON file ${filePath}`);
+    return;
+  }
+  if (!isPlainObject(existing)) {
+    onWrite(`Skipped non-object JSON file ${filePath}`);
+    return;
+  }
+  const commands = new Set(collectHookCommandsFromJsonContent(content));
+  if (commands.size === 0) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  const next = structuredClone(existing);
+  let changed = false;
+  if (isPlainObject(next.hooks)) {
+    for (const [event, groups] of Object.entries(next.hooks)) {
+      const stripped = stripHookCommandsFromGroups(groups, commands);
+      if (JSON.stringify(stripped) !== JSON.stringify(groups)) {
+        changed = true;
+        if (Array.isArray(stripped) && stripped.length === 0) {
+          delete next.hooks[event];
+        } else {
+          next.hooks[event] = stripped;
+        }
+      }
+    }
+    if (isPlainObject(next.hooks) && Object.keys(next.hooks).length === 0) {
+      delete next.hooks;
+      changed = true;
+    }
+  }
+  for (const [key, value] of Object.entries(next)) {
+    if (key === "hooks" || key === "enable_json_hooks" || !isPlainObject(value)) {
+      continue;
+    }
+    if (!Object.prototype.hasOwnProperty.call(content, key)) {
+      continue;
+    }
+    for (const [event, groups] of Object.entries(value)) {
+      const stripped = stripHookCommandsFromGroups(groups, commands);
+      if (JSON.stringify(stripped) !== JSON.stringify(groups)) {
+        changed = true;
+        if (Array.isArray(stripped) && stripped.length === 0) {
+          delete value[event];
+        } else {
+          value[event] = stripped;
+        }
+      }
+    }
+    if (Object.keys(value).length === 0) {
+      delete next[key];
+      changed = true;
+    }
+  }
+  if (Object.prototype.hasOwnProperty.call(content, "enable_json_hooks") && next.enable_json_hooks === true) {
+    const stillHasNamedHooks = Object.entries(next).some(
+      ([key, value]) => key !== "hooks" && key !== "enable_json_hooks" && isPlainObject(value) && Object.values(value).some((groups) => Array.isArray(groups) && groups.length > 0)
+    );
+    if (!stillHasNamedHooks) {
+      delete next.enable_json_hooks;
+      changed = true;
+    }
+  }
+  if (!changed) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  if (dryRun) {
+    onWrite(`Would uninstall ${filePath}`);
+    return;
+  }
+  const { writeFile: writeFile5 } = await import("node:fs/promises");
+  await writeFile5(filePath, `${JSON.stringify(next, null, 2)}
+`, "utf8");
+  onWrite(`Uninstalled ${filePath}`);
+}
+async function uninstallGeneratedFile(filePath, { dryRun, onWrite }) {
+  const existingText = await readTextIfExists(filePath);
+  if (existingText === null) {
+    onWrite(`Already uninstalled ${filePath}`);
+    return;
+  }
+  if (!existingText.includes(GENERATED_MARKER) && !existingText.includes("Generated by codetime.")) {
+    onWrite(`Skipped non-vibetime file ${filePath}`);
+    return;
+  }
+  if (dryRun) {
+    onWrite(`Would uninstall ${filePath}`);
+    return;
+  }
+  const { unlink } = await import("node:fs/promises");
+  await unlink(filePath);
+  onWrite(`Uninstalled ${filePath}`);
+}
 
 // src/lib/config.ts
 import { randomUUID } from "node:crypto";
 import { existsSync as existsSync2, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
-import path22 from "node:path";
+import path23 from "node:path";
 function configDir(home = homedir()) {
-  return path22.join(home, ".vibetime");
+  return path23.join(home, ".vibetime");
 }
 function configPath(home = homedir()) {
-  return path22.join(configDir(home), "config.json");
+  return path23.join(configDir(home), "config.json");
 }
 function machineIdPath(home = homedir()) {
-  return path22.join(configDir(home), "machine-id");
+  return path23.join(configDir(home), "machine-id");
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
@@ -11956,13 +12825,13 @@ init_fs();
 // src/lib/logger.ts
 import { appendFile, mkdir as mkdir4, rename, stat as stat12 } from "node:fs/promises";
 import { homedir as homedir2 } from "node:os";
-import path23 from "node:path";
+import path24 from "node:path";
 var MAX_BYTES = 1 * 1024 * 1024;
 function logDir(home = homedir2()) {
-  return path23.join(home, ".vibetime", "logs");
+  return path24.join(home, ".vibetime", "logs");
 }
 function logPath(home = homedir2(), name = "cli.log") {
-  return path23.join(logDir(home), name);
+  return path24.join(logDir(home), name);
 }
 function serializeError(error) {
   if (error instanceof Error) {
@@ -12137,8 +13006,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path25) {
-  return new URL(path25, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path26) {
+  return new URL(path26, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -12228,6 +13097,7 @@ function createRegistry() {
   registry.register(createZCodeAdapter());
   registry.register(createGrokBuildAdapter());
   registry.register(createZedAdapter());
+  registry.register(createKimiCodeAdapter());
   return registry;
 }
 var defaultContext = {
@@ -12285,6 +13155,7 @@ function createCli(ctx, registry) {
   });
   cli.command("detect", "Show supported local targets and install status").action((options) => detectCommand(normalizeOptions(options), ctx, registry).then(() => 0));
   cli.command("install", "Install integration files into detected or requested targets").option("--target <targets>", "Target integrations, comma-separated").option("--targets <targets>", "Target integrations, comma-separated").option("--all", "Install all supported integrations").option("--force", "Overwrite existing non-generated files when needed").action((options) => installCommand(normalizeOptions(options), ctx, registry));
+  cli.command("uninstall", "Remove vibetime integration hooks/files from targets").option("--target <targets>", "Target integrations, comma-separated").option("--targets <targets>", "Target integrations, comma-separated").option("--all", "Uninstall all supported integrations").action((options) => uninstallCommand(normalizeOptions(options), ctx, registry));
   cli.command("upgrade", "Check for updates and upgrade to the latest version").option("--check", "Only check for updates, do not install").action((options) => upgradeCommand(normalizeOptions(options), ctx, registry));
   cli.command("hook", "Read agent hook JSON from stdin and report a throttled event").option("--agent <name>", "Agent name").option("--project <name>", "Project name").option("--min-interval <seconds>", "Minimum seconds between similar hook reports").action((options) => hookCommand(normalizeOptions(options), ctx));
   cli.command("sync-local-trigger", "Trigger one background local sync with throttle and locking").option("--min-interval <seconds>", "Minimum seconds between sync triggers").action((options) => syncLocalTriggerCommand(normalizeOptions(options), ctx, registry));
@@ -12381,6 +13252,44 @@ async function installCommand(options, ctx, registry) {
   }
   return 0;
 }
+async function uninstallCommand(options, ctx, registry) {
+  const home = resolveHome3(options, ctx);
+  const env = ctx.env;
+  const dryRun = Boolean(options["dry-run"]);
+  const allAdapters = registry.all();
+  const requested = requestedTargets(options);
+  const unknown = requested.filter((id) => !allAdapters.some((a) => a.id === id));
+  if (unknown.length > 0) {
+    throw new Error(`Unknown target(s): ${unknown.join(", ")}`);
+  }
+  const installed = [];
+  for (const adapter of allAdapters) {
+    if (await adapter.isInstalled(home, env)) {
+      installed.push(adapter.id);
+    }
+  }
+  const selectedIds = requested.length > 0 ? requested : options.all ? allAdapters.map((a) => a.id) : installed;
+  if (selectedIds.length === 0) {
+    write(ctx.stderr, "No installed vibetime integrations were found. Use --target <id> or --all.\n");
+    return 1;
+  }
+  for (const adapter of allAdapters.filter((a) => selectedIds.includes(a.id))) {
+    const entries = adapter.installEntries(home, env);
+    if (entries.length === 0) {
+      write(ctx.stdout, `Nothing to uninstall for ${adapter.id}
+`);
+      continue;
+    }
+    for (const entry of entries) {
+      await uninstallEntry(entry, {
+        dryRun,
+        onWrite: (msg) => write(ctx.stdout, `${msg}
+`)
+      });
+    }
+  }
+  return 0;
+}
 var NPM_PACKAGE = "@yhong91/vibetime";
 async function fetchLatestVersion() {
   try {
@@ -13123,13 +14032,13 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   return picked;
 }
 function backfillIncrementalStatePath(home) {
-  return path24.join(home, ".vibetime", "backfill-state.json");
+  return path25.join(home, ".vibetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path24.join(home, ".vibetime", "sync-local-trigger.json");
+  return path25.join(home, ".vibetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path24.join(home, ".vibetime", "sync-local-trigger.lock");
+  return path25.join(home, ".vibetime", "sync-local-trigger.lock");
 }
 function backfillRemoteKey(baseUrl) {
   try {
@@ -13191,7 +14100,7 @@ async function readBackfillIncrementalStateFile(home, ctx) {
 }
 async function writeBackfillIncrementalStateFile(home, file) {
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir5(path24.dirname(statePath), { recursive: true });
+  await mkdir5(path25.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(file, null, 2)}
 `, "utf8");
 }
@@ -13240,7 +14149,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir5(path24.dirname(statePath), { recursive: true });
+  await mkdir5(path25.dirname(statePath), { recursive: true });
   await writeFile4(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -13255,12 +14164,12 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir5(path24.dirname(lockPath), { recursive: true });
+  await mkdir5(path25.dirname(lockPath), { recursive: true });
   await writeFile4(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
 async function acquireSyncLocalLock(lockPath, lock) {
-  await mkdir5(path24.dirname(lockPath), { recursive: true });
+  await mkdir5(path25.dirname(lockPath), { recursive: true });
   try {
     const handle = await open(lockPath, "wx");
     try {
@@ -13340,10 +14249,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path24.resolve(path24.dirname(cliPath), "../bin/vibetime.mjs")];
+  return [path25.resolve(path25.dirname(cliPath), "../bin/vibetime.mjs")];
 }
 function resolveHome3(options, ctx) {
-  return path24.resolve(stringOption(options.home) || ctx.env.HOME || os11.homedir());
+  return path25.resolve(stringOption(options.home) || ctx.env.HOME || os11.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;
@@ -13514,6 +14423,7 @@ function helpText() {
 Usage:
   vibetime detect [--json] [--home <path>]
   vibetime install [--target codex,claude,opencode,pi] [--all] [--dry-run] [--force] [--home <path>]
+  vibetime uninstall [--target codex,claude,opencode,pi] [--all] [--dry-run] [--home <path>]
   vibetime upgrade [--check]
   vibetime hook --agent <name>
   vibetime backfill discover|plan|import|verify --source codex|claude-code|opencode|pi|all --dry-run [--json] [--batch-size <count>] [--force [--purge-all]]
@@ -13528,6 +14438,7 @@ Setup:
 Commands:
   detect    Show supported local targets and install status.
   install   Install integration files into detected or requested targets.
+  uninstall Remove vibetime hooks/files from detected or requested targets.
   upgrade   Check for updates and upgrade to the latest version.
   hook      Read agent hook JSON from stdin and report a throttled event.
   backfill  Discover local history and create metadata-only import plans.