@yhong91/vibetime 0.1.50 → 0.1.52

package/bin/vibetime.mjs

@@ -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,7 @@ function claudeStyleFileMetrics(tool, input) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.50" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.52" : "0.1.1";
 var DEFAULT_API_URL = "http://121.196.224.82:3001";
 var DEFAULT_BACKFILL_BATCH_SIZE = 50;
 var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
@@ -6935,9 +6935,476 @@ function createGrokBuildAdapter() {
   };
 }
 
+// src/adapters/kimi-code.ts
+import { readFile as readFile9 } from "node:fs/promises";
+import path14 from "node:path";
+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 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 text = await readFile9(statePath, "utf8");
+    const raw = JSON.parse(text);
+    if (!isPlainObject(raw)) {
+      return {};
+    }
+    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;
+    }
+    const entryType = stringField(raw, "type");
+    const ts = timestampFrom(raw.time) || timestampFrom(raw.created_at) || timestampFrom(raw.timestamp);
+    if (!ts || !entryType) {
+      continue;
+    }
+    if (entryType === "metadata") {
+      state.ensureSessionStarted(ts, lineNumber, entryType);
+      continue;
+    }
+    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;
+    }
+    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,
+        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);
+        }
+      }
+      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;
+        }
+        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);
+        }
+        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
+          });
+        }
+        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 path14.join(kimiCodeHome(home, env), "vibetime-marker");
+    },
+    async isInstalled() {
+      return false;
+    },
+    installEntries(_home, _env) {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return [kimiCodeSessionsDir(home, env)];
+    },
+    parseSessionFile: parseKimiCodeSessionFile
+  };
+}
+
 // src/adapters/opencode.ts
 import os6 from "node:os";
-import path14 from "node:path";
+import path15 from "node:path";
 async function parseOpenCodeSessionFile(dbPath, options) {
   const { DatabaseSync } = await import("node:sqlite");
   if (!dbPath.endsWith(".db")) {
@@ -6994,7 +7461,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
       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 project = cwd ? path15.basename(cwd) : void 0;
       const sessionTs = msToIso(session.time_created);
       events.push(baseOpenCodeEvent({
         ts: sessionTs,
@@ -7102,7 +7569,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 +7840,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 +7941,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 +7954,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 +7966,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 +7984,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 +8042,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 +8074,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 +8507,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 +8528,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 +8541,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 +8553,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 +8579,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 +8594,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 +8604,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 +8746,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 +8756,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 +8789,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 +8805,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 +8827,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 +8835,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 +8869,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 +8880,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 +8915,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;
     }
@@ -8533,6 +9000,41 @@ async function parseQoderCnSessionFile(filePath, options) {
         }
         pendingTools.delete(pending.id);
       }
+      const attachedPrompt = extractQoderAttachedPrompt(qoderCnToolResultItems(message)[0]?.content);
+      if (attachedPrompt) {
+        const prompt = qoderCnTextStats(attachedPrompt);
+        state.closeTurn(ts, lineNumber, topType);
+        state.currentTurnId = stringField(raw, "uuid") || stringField(raw, "promptId") || `turn_${createStableHash([sessionId, lineNumber]).slice(0, 24)}`;
+        state.currentTurnStartedAt = ts;
+        state.currentTurnLastEventAt = ts;
+        push(baseQoderCnEvent({
+          ts,
+          type: "turn.started",
+          sessionId,
+          turnId: state.currentTurnId,
+          cwd,
+          project,
+          model,
+          confidence: "derived"
+        }), lineNumber, topType, "attached_prompt");
+        push(baseQoderCnEvent({
+          ts,
+          type: "prompt.submitted",
+          sessionId,
+          turnId: state.currentTurnId,
+          cwd,
+          project,
+          model,
+          confidence: "exact",
+          metrics: {
+            prompts: 1,
+            promptChars: prompt.chars
+          },
+          refs: stringRefs({
+            promptHash: prompt.hash
+          })
+        }), lineNumber, topType, "attached_prompt");
+      }
       continue;
     }
     if (topType === "user") {
@@ -8748,7 +9250,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,
@@ -8874,30 +9376,54 @@ function isNoisePrompt(text) {
   }
   return false;
 }
+function extractQoderAttachedPrompt(content) {
+  let text;
+  if (typeof content === "string") {
+    text = content;
+  } else if (Array.isArray(content)) {
+    text = content.filter((it) => isPlainObject(it) && it.type === "text").map((it) => stringField(it, "text")).join("\n");
+  } else {
+    return void 0;
+  }
+  if (!text.includes("aicoding-text-field") || !text.includes("text-field-content")) {
+    return void 0;
+  }
+  const fenceStart = text.indexOf("```");
+  if (fenceStart === -1) {
+    return void 0;
+  }
+  const afterFence = text.slice(fenceStart + 3);
+  const fenceEnd = afterFence.indexOf("```");
+  if (fenceEnd === -1) {
+    return void 0;
+  }
+  const inner = afterFence.slice(0, fenceEnd);
+  return inner.split("\n").map((line) => line.replace(/^\s*\d+->/, "")).join("\n").trim() || void 0;
+}
 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);
           }
         }
@@ -8909,7 +9435,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 })
@@ -8918,15 +9444,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;
       }
@@ -8937,12 +9463,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;
       }
@@ -8952,14 +9478,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)) {
@@ -8984,7 +9510,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;
@@ -9029,9 +9555,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 {
@@ -9043,27 +9569,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
@@ -9072,11 +9598,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 = "";
@@ -9086,17 +9612,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 };
 }
@@ -9119,7 +9645,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 = {};
@@ -9135,10 +9661,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;
@@ -9146,11 +9672,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;
@@ -9169,17 +9695,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);
@@ -9187,7 +9713,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);
@@ -9221,7 +9747,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;
@@ -9232,7 +9758,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");
@@ -9268,7 +9794,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;
     }
@@ -9353,6 +9879,41 @@ async function parseQoderSessionFile(filePath, options) {
         }
         pendingTools.delete(pending.id);
       }
+      const attachedPrompt = extractQoderAttachedPrompt(qoderToolResultItems(message)[0]?.content);
+      if (attachedPrompt) {
+        const prompt = qoderTextStats(attachedPrompt);
+        state.closeTurn(ts, lineNumber, topType);
+        state.currentTurnId = stringField(raw, "uuid") || stringField(raw, "promptId") || `turn_${createStableHash([sessionId, lineNumber]).slice(0, 24)}`;
+        state.currentTurnStartedAt = ts;
+        state.currentTurnLastEventAt = ts;
+        push(baseQoderEvent({
+          ts,
+          type: "turn.started",
+          sessionId,
+          turnId: state.currentTurnId,
+          cwd,
+          project,
+          model,
+          confidence: "derived"
+        }), lineNumber, topType, "attached_prompt");
+        push(baseQoderEvent({
+          ts,
+          type: "prompt.submitted",
+          sessionId,
+          turnId: state.currentTurnId,
+          cwd,
+          project,
+          model,
+          confidence: "exact",
+          metrics: {
+            prompts: 1,
+            promptChars: prompt.chars
+          },
+          refs: stringRefs({
+            promptHash: prompt.hash
+          })
+        }), lineNumber, topType, "attached_prompt");
+      }
       continue;
     }
     if (topType === "user") {
@@ -9543,7 +10104,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,
@@ -9659,41 +10220,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);
               }
             }
@@ -9713,29 +10274,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;
       }
@@ -9746,12 +10307,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;
       }
@@ -9761,7 +10322,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);
@@ -9782,11 +10343,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) {
@@ -9812,7 +10373,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;
@@ -9857,19 +10418,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 {
@@ -9881,11 +10442,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"
       );
     },
@@ -9894,16 +10455,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;
     },
@@ -9939,27 +10500,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)}`;
@@ -10077,7 +10638,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;
@@ -10097,8 +10658,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 });
@@ -10387,11 +10948,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() });
         }
@@ -10429,18 +10990,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()
       }];
     },
@@ -10453,20 +11014,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) {
@@ -10482,7 +11043,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)) {
@@ -10500,7 +11061,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));
@@ -10683,16 +11244,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;
     }
@@ -10908,7 +11469,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() }];
@@ -10943,49 +11504,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 {
@@ -11049,7 +11610,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);
@@ -11324,7 +11885,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;
@@ -11805,15 +12366,15 @@ function hookCommandFromGroup(group) {
 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);
@@ -11862,13 +12423,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) {
@@ -12043,8 +12604,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"), {
@@ -12134,6 +12695,7 @@ function createRegistry() {
   registry.register(createZCodeAdapter());
   registry.register(createGrokBuildAdapter());
   registry.register(createZedAdapter());
+  registry.register(createKimiCodeAdapter());
   return registry;
 }
 var defaultContext = {
@@ -13029,13 +13591,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 {
@@ -13097,7 +13659,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");
 }
@@ -13146,7 +13708,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");
 }
@@ -13161,12 +13723,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 {
@@ -13246,10 +13808,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;