@yhong91/vibetime 0.1.49 → 0.1.51

package/bin/vibetime.mjs

@@ -2047,7 +2047,7 @@ function claudeStyleFileMetrics(tool, input) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.49" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.51" : "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;
@@ -8094,27 +8094,98 @@ import path17 from "node:path";
 import { access } from "node:fs/promises";
 import os7 from "node:os";
 import path16 from "node:path";
+function takeQoderDbModelCall(calls, requestId, blockStart) {
+  if (requestId) {
+    const call = calls.byRequestId.get(requestId)?.shift();
+    if (call) {
+      const index = calls.ordered.indexOf(call);
+      if (index !== -1) {
+        calls.ordered.splice(index, 1);
+      }
+    }
+    return call;
+  }
+  if (!blockStart) {
+    return void 0;
+  }
+  return calls.ordered.shift();
+}
+function appDataRoot(appDirName, home = os7.homedir()) {
+  if (process.platform === "darwin") {
+    return path16.join(home, "Library", "Application Support", appDirName);
+  }
+  if (process.platform === "win32") {
+    return path16.join(process.env.APPDATA || path16.join(home, "AppData", "Roaming"), appDirName);
+  }
+  return path16.join(home, ".config", appDirName);
+}
 function qoderLocalDbCandidates(appDirName) {
   const candidates = [];
   const envPath = process.env.QODER_LOCAL_DB_PATH;
   if (envPath) {
     candidates.push(envPath);
   }
-  const home = os7.homedir();
-  let configRoot;
-  if (process.platform === "darwin") {
-    configRoot = path16.join(home, "Library", "Application Support", appDirName);
-  } else if (process.platform === "win32") {
-    configRoot = path16.join(process.env.APPDATA || path16.join(home, "AppData", "Roaming"), appDirName);
-  } else {
-    configRoot = path16.join(home, ".config", appDirName);
-  }
+  const configRoot = appDataRoot(appDirName);
   candidates.push(
     path16.join(configRoot, "SharedClientCache", "cache", "db", "local.db"),
     path16.join(configRoot, "SharedClientCache", "db", "local.db")
   );
   return candidates;
 }
+async function loadQoderIdeModelCatalog(appDirName, home) {
+  const map = {};
+  try {
+    const { DatabaseSync } = await import("node:sqlite");
+    const db = new DatabaseSync(
+      path16.join(appDataRoot(appDirName, home), "User", "globalStorage", "state.vscdb"),
+      { readOnly: true }
+    );
+    try {
+      const rows = db.prepare(
+        `select key, value from ItemTable where key like 'aicoding.modelConfigs.cache.%' or key = 'aicoding.customModels'`
+      ).all();
+      const customIds = [];
+      for (const row of rows) {
+        const key = stringField(row, "key");
+        const value = stringField(row, "value");
+        if (!key || !value) {
+          continue;
+        }
+        let entries;
+        try {
+          entries = JSON.parse(value);
+        } catch {
+          continue;
+        }
+        for (const entry of entries) {
+          const displayName = stringField(entry, "displayName");
+          if (key === "aicoding.customModels") {
+            const id = stringField(entry, "id");
+            if (id && displayName) {
+              map[`custom:${id}`] = displayName;
+              customIds.push(id);
+            }
+          } else {
+            const name = stringField(entry, "name");
+            if (name && displayName) {
+              map[name] = displayName;
+            }
+          }
+        }
+      }
+      if (customIds.length === 1) {
+        const displayName = map[`custom:${customIds[0]}`];
+        if (displayName) {
+          map.custom_model = displayName;
+        }
+      }
+    } finally {
+      db.close();
+    }
+  } catch {
+  }
+  return map;
+}
 async function loadQoderDbModelCalls(appDirName, sessionId, modelMap) {
   const calls = { byRequestId: /* @__PURE__ */ new Map(), ordered: [] };
   if (!sessionId) {
@@ -8266,7 +8337,7 @@ async function parseModelNamesFromDynamicTexts(dynamicTextsPath) {
     return {};
   }
 }
-async function loadQoderCnModelNames(configDir2) {
+async function loadQoderCnModelNames(configDir2, home) {
   const map = await parseModelNamesFromDynamicTexts(path17.join(configDir2, ".auth", "dynamic-texts.json"));
   const siblingConfigDir = configDir2.replace(/\.qoder-cn$/, ".qoder");
   if (siblingConfigDir !== configDir2) {
@@ -8277,6 +8348,14 @@ async function loadQoderCnModelNames(configDir2) {
       }
     }
   }
+  for (const appDirName of ["QoderCN", "Qoder"]) {
+    const ideMap = await loadQoderIdeModelCatalog(appDirName, home);
+    for (const [key, val] of Object.entries(ideMap)) {
+      if (!(key in map)) {
+        map[key] = val;
+      }
+    }
+  }
   return map;
 }
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
@@ -8310,7 +8389,8 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
               inputTokens: numberField(data, "input_tokens") || 0,
               outputTokens: numberField(data, "output_tokens") || 0,
               cacheCreationInputTokens: numberField(data, "cache_creation_input_tokens") || 0,
-              cacheReadInputTokens: numberField(data, "cache_read_input_tokens") || 0
+              cacheReadInputTokens: numberField(data, "cache_read_input_tokens") || 0,
+              stopReason: stringField(data, "stop_reason") || void 0
             });
           }
         }
@@ -8333,20 +8413,15 @@ async function parseQoderCnSessionFile(filePath, options) {
   let cwd;
   let project = projectContext.project;
   let model;
-  const modelMap = await loadQoderCnModelNames(configDir2);
+  const home = path17.resolve(stringOption(options.home) || os8.homedir());
+  const modelMap = await loadQoderCnModelNames(configDir2, home);
   const isSubagentSession = filePath.includes("subagents");
   const segmentModelCalls = await loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap);
   let modelCallIndex = 0;
   let dbModelCalls;
   const nextDbModelCall = async (requestId, blockStart) => {
     dbModelCalls ??= await loadQoderDbModelCalls("QoderCN", sessionId, modelMap);
-    if (requestId) {
-      return dbModelCalls.byRequestId.get(requestId)?.shift();
-    }
-    if (!blockStart) {
-      return void 0;
-    }
-    return dbModelCalls.ordered.shift();
+    return takeQoderDbModelCall(dbModelCalls, requestId, blockStart);
   };
   const state = new SessionParserState(filePath, options, (event) => baseQoderCnEvent({ ...event, cwd, project, model }));
   state.sessionId = sessionId;
@@ -8458,6 +8533,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") {
@@ -8532,6 +8642,20 @@ async function parseQoderCnSessionFile(filePath, options) {
         modelCalls: 1
       };
       model = call.model || model;
+      if (!usage.tokensTotal && !usage.tokensCachedInput) {
+        const dbCall = await nextDbModelCall(requestId, isBlockStart);
+        if (dbCall && (dbCall.inputTokens || dbCall.outputTokens || dbCall.cachedTokens)) {
+          usage = {
+            tokensInput: dbCall.inputTokens || void 0,
+            tokensCachedInput: dbCall.cachedTokens || void 0,
+            tokensCacheReadInput: dbCall.cachedTokens || void 0,
+            tokensOutput: dbCall.outputTokens || void 0,
+            tokensTotal: dbCall.inputTokens + dbCall.outputTokens || void 0,
+            modelCalls: 1
+          };
+          model = dbCall.model || model;
+        }
+      }
     } else if (shouldEmitUsage) {
       const dbCall = await nextDbModelCall(requestId, isBlockStart);
       if (dbCall) {
@@ -8785,6 +8909,30 @@ 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}`);
@@ -8982,6 +9130,7 @@ 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 os9 from "node:os";
 import path18 from "node:path";
@@ -9044,7 +9193,7 @@ async function parseModelNamesFromDynamicTexts2(dynamicTextsPath) {
     return {};
   }
 }
-async function loadQoderModelNames(configDir2) {
+async function loadQoderModelNames(configDir2, home) {
   const map = await parseModelNamesFromDynamicTexts2(path18.join(configDir2, ".auth", "dynamic-texts.json"));
   const siblingConfigDir = configDir2.replace(/\.qoder$/, ".qoder-cn");
   if (siblingConfigDir !== configDir2) {
@@ -9055,8 +9204,38 @@ async function loadQoderModelNames(configDir2) {
       }
     }
   }
+  if (isQwenworkConfigRoot(configDir2)) {
+    for (const dir of [path18.join(home, ".qoder"), path18.join(home, ".qoder-cn")]) {
+      if (path18.resolve(dir) === path18.resolve(configDir2)) {
+        continue;
+      }
+      const fallbackMap = await parseModelNamesFromDynamicTexts2(path18.join(dir, ".auth", "dynamic-texts.json"));
+      for (const [key, val] of Object.entries(fallbackMap)) {
+        if (!(key in map)) {
+          map[key] = val;
+        }
+      }
+    }
+  }
+  for (const appDirName of ["Qoder", "QoderCN"]) {
+    const ideMap = await loadQoderIdeModelCatalog(appDirName, home);
+    for (const [key, val] of Object.entries(ideMap)) {
+      if (!(key in map)) {
+        map[key] = val;
+      }
+    }
+  }
   return map;
 }
+function isQwenworkConfigRoot(configDir2) {
+  const name = path18.basename(path18.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);
+}
+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");
@@ -9088,7 +9267,8 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
               inputTokens: numberField(data, "input_tokens") || 0,
               outputTokens: numberField(data, "output_tokens") || 0,
               cacheCreationInputTokens: numberField(data, "cache_creation_input_tokens") || 0,
-              cacheReadInputTokens: numberField(data, "cache_read_input_tokens") || 0
+              cacheReadInputTokens: numberField(data, "cache_read_input_tokens") || 0,
+              stopReason: stringField(data, "stop_reason") || void 0
             });
           }
         }
@@ -9111,20 +9291,16 @@ async function parseQoderSessionFile(filePath, options) {
   let cwd;
   let project = projectContext.project;
   let model;
-  const modelMap = await loadQoderModelNames(configDir2);
+  const home = path18.resolve(stringOption(options.home) || os9.homedir());
+  const modelMap = await loadQoderModelNames(configDir2, home);
+  const qwenworkRoot = isQwenworkConfigRoot(configDir2);
   const isSubagentSession = filePath.includes("subagents");
   const segmentModelCalls = await loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap);
   let modelCallIndex = 0;
   let dbModelCalls;
   const nextDbModelCall = async (requestId, blockStart) => {
     dbModelCalls ??= await loadQoderDbModelCalls("Qoder", sessionId, modelMap);
-    if (requestId) {
-      return dbModelCalls.byRequestId.get(requestId)?.shift();
-    }
-    if (!blockStart) {
-      return void 0;
-    }
-    return dbModelCalls.ordered.shift();
+    return takeQoderDbModelCall(dbModelCalls, requestId, blockStart);
   };
   const state = new SessionParserState(filePath, options, (event) => baseQoderEvent({ ...event, cwd, project, model }));
   state.sessionId = sessionId;
@@ -9236,6 +9412,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") {
@@ -9292,39 +9503,28 @@ async function parseQoderSessionFile(filePath, options) {
       seenUsageKeys.add(usageKey);
     }
     let usage;
+    let keepZeroTokenUsage = false;
     if (shouldEmitUsage && modelCallIndex < segmentModelCalls.length) {
       const call = segmentModelCalls[modelCallIndex++];
-      const inputTokens = call.inputTokens;
-      const cacheCreationInputTokens = call.cacheCreationInputTokens;
-      const cacheReadInputTokens = call.cacheReadInputTokens;
-      const outputTokens = call.outputTokens;
-      const cachedInputTokens = cacheCreationInputTokens + cacheReadInputTokens;
-      const totalInputTokens = inputTokens;
-      usage = {
-        tokensInput: totalInputTokens || void 0,
-        tokensCachedInput: cachedInputTokens || void 0,
-        tokensCacheCreationInput: cacheCreationInputTokens || void 0,
-        tokensCacheReadInput: cacheReadInputTokens || void 0,
-        tokensOutput: outputTokens || void 0,
-        tokensTotal: totalInputTokens + outputTokens || void 0,
-        modelCalls: 1
-      };
+      usage = qoderSegmentUsage(call);
       model = call.model || model;
+      if (!usage.tokensTotal && !usage.tokensCachedInput) {
+        const dbCall = await nextDbModelCall(requestId, isBlockStart);
+        if (dbCall && (dbCall.inputTokens || dbCall.outputTokens || dbCall.cachedTokens)) {
+          usage = qoderDbUsage(dbCall);
+          model = dbCall.model || model;
+        } else if (qwenworkRoot && (!call.stopReason || !FAILED_SEGMENT_STOP_REASONS.has(call.stopReason))) {
+          keepZeroTokenUsage = true;
+        }
+      }
     } else if (shouldEmitUsage) {
       const dbCall = await nextDbModelCall(requestId, isBlockStart);
       if (dbCall) {
-        usage = {
-          tokensInput: dbCall.inputTokens || void 0,
-          tokensCachedInput: dbCall.cachedTokens || void 0,
-          tokensCacheReadInput: dbCall.cachedTokens || void 0,
-          tokensOutput: dbCall.outputTokens || void 0,
-          tokensTotal: dbCall.inputTokens + dbCall.outputTokens || void 0,
-          modelCalls: 1
-        };
+        usage = qoderDbUsage(dbCall);
         model = dbCall.model || model;
       }
     }
-    if (usage && (usage.tokensTotal || usage.tokensCachedInput)) {
+    if (usage && (usage.tokensTotal || usage.tokensCachedInput || keepZeroTokenUsage)) {
       const speed = stringField(objectField(message, "usage"), "speed");
       const usageModel = speed === "fast" && model ? `${model}-fast` : model;
       push(baseQoderEvent({
@@ -9451,6 +9651,28 @@ async function parseQoderSessionFile(filePath, options) {
   }
   return validEvents;
 }
+function qoderSegmentUsage(call) {
+  const cachedInputTokens = call.cacheCreationInputTokens + call.cacheReadInputTokens;
+  return {
+    tokensInput: call.inputTokens || void 0,
+    tokensCachedInput: cachedInputTokens || void 0,
+    tokensCacheCreationInput: call.cacheCreationInputTokens || void 0,
+    tokensCacheReadInput: call.cacheReadInputTokens || void 0,
+    tokensOutput: call.outputTokens || void 0,
+    tokensTotal: call.inputTokens + call.outputTokens || void 0,
+    modelCalls: 1
+  };
+}
+function qoderDbUsage(dbCall) {
+  return {
+    tokensInput: dbCall.inputTokens || void 0,
+    tokensCachedInput: dbCall.cachedTokens || void 0,
+    tokensCacheReadInput: dbCall.cachedTokens || void 0,
+    tokensOutput: dbCall.outputTokens || void 0,
+    tokensTotal: dbCall.inputTokens + dbCall.outputTokens || void 0,
+    modelCalls: 1
+  };
+}
 function baseQoderEvent(event) {
   return {
     schemaVersion: AGENT_TIME_SCHEMA_VERSION,
@@ -9534,12 +9756,20 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
   const isSubagent = filePath.includes(`${path18.sep}subagents${path18.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)) {
       cwds.push(cwd);
     }
+    if (raw && stringField(raw, "type") === "workspace-directories") {
+      for (const dir of arrayField5(raw, "directories")) {
+        if (typeof dir === "string" && path18.isAbsolute(dir)) {
+          workspaceDirs.push(dir);
+        }
+      }
+    }
   }
   if (isSubagent) {
     if (inherited?.cwd && path18.isAbsolute(inherited.cwd)) {
@@ -9555,6 +9785,13 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
           if (cwd && path18.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)) {
+                workspaceDirs.push(dir);
+              }
+            }
+          }
         }
         if (parentCwds.length > 0) {
           cwds = parentCwds;
@@ -9563,6 +9800,12 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
       }
     }
   }
+  if (cwds.length > 0 && cwds.every((cwd) => pathInsideDir(cwd, configDir2))) {
+    const external = workspaceDirs.filter((dir) => !pathInsideDir(dir, configDir2));
+    if (external.length > 0) {
+      cwds = external;
+    }
+  }
   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));
   return {
@@ -9570,6 +9813,11 @@ async function qoderProjectContextFromLines(filePath, lines, options, configDir2
     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}`);
+}
 async function gitRootFromCwds3(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
@@ -9594,7 +9842,7 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
     let current = path18.resolve(cwd);
     while (true) {
-      if (encodeQoderProjectPath(current) === projectDir) {
+      if (qoderEncodedVariants(current).includes(projectDir)) {
         return current;
       }
       const parent = path18.dirname(current);
@@ -9606,21 +9854,23 @@ function qoderProjectRootFromCwds(projectDir, cwds) {
   }
   return void 0;
 }
-function encodeQoderProjectPath(value) {
-  return path18.resolve(value).split(path18.sep).join("-").replaceAll("_", "-");
-}
 function rawQoderProjectPath(value) {
   return path18.resolve(value).split(path18.sep).join("-");
 }
 function qoderEncodedVariants(value) {
   const raw = rawQoderProjectPath(value);
-  const normalized = raw.replaceAll("_", "-");
-  return raw === normalized ? [raw] : [raw, normalized];
+  const variants = /* @__PURE__ */ new Set([
+    raw,
+    raw.replaceAll("_", "-"),
+    raw.replaceAll(".", "-"),
+    raw.replaceAll("_", "-").replaceAll(".", "-")
+  ]);
+  return [...variants];
 }
 function qoderEncodedProjectSuffix(projectDir, home) {
   for (const prefix of qoderEncodedVariants(home).map((value) => `${value}-`)) {
     if (projectDir.startsWith(prefix)) {
-      return projectDir.slice(prefix.length) || void 0;
+      return projectDir.slice(prefix.length).replace(/^-+/, "") || void 0;
     }
   }
   return void 0;
@@ -9705,6 +9955,16 @@ function qoderConfigDir(home, env) {
   }
   return path18.join(home, ".qoder");
 }
+function qwenworkConfigDir(home, env) {
+  const override = env?.QWENWORK_CONFIG_DIR;
+  if (override && override.trim()) {
+    return path18.resolve(override);
+  }
+  return path18.join(home, ".qwenworkcn");
+}
+function qoderConfigDirs(home, env) {
+  return [...new Set([qoderConfigDir(home, env), qwenworkConfigDir(home, env)].map((dir) => path18.resolve(dir)))];
+}
 function createQoderAdapter() {
   return {
     id: "qoder",
@@ -9724,19 +9984,22 @@ function createQoderAdapter() {
       );
     },
     installEntries(home, env) {
-      return [{
+      const [primary, ...variants] = qoderConfigDirs(home, env);
+      const targets = [primary, ...variants.filter((dir) => existsSync(dir))];
+      return targets.map((base) => ({
         kind: "hooks-json",
-        path: path18.join(qoderConfigDir(home, env), "settings.json"),
+        path: path18.join(base, "settings.json"),
         content: hookConfig7()
-      }];
+      }));
     },
     sourcePaths(home, env) {
+      const paths = qoderConfigDirs(home, env).map((base2) => path18.join(base2, "projects"));
       const base = qoderConfigDir(home, env);
-      return [
-        path18.join(base, "projects"),
+      paths.push(
         path18.join(base, ".qoder.json"),
         path18.join(home, ".qoder.json")
-      ];
+      );
+      return paths;
     },
     parseSessionFile: parseQoderSessionFile
   };
@@ -11171,13 +11434,7 @@ function createZedAdapter() {
 }
 
 // src/lib/pricing.ts
-function estimateEventCostUsd(event) {
-  if (event.type !== "model.usage") {
-    return 0;
-  }
-  if (typeof event.metrics?.costUsd === "number" && event.metrics.costUsd > 0) {
-    return event.metrics.costUsd;
-  }
+function estimateEventCostUsd(_event) {
   return 0;
 }
 
@@ -11640,7 +11897,7 @@ function hookCommandFromGroup(group) {
 
 // src/lib/config.ts
 import { randomUUID } from "node:crypto";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync as existsSync2, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir, hostname } from "node:os";
 import path22 from "node:path";
 function configDir(home = homedir()) {
@@ -11654,7 +11911,7 @@ function machineIdPath(home = homedir()) {
 }
 function readConfig(home = homedir()) {
   const file = configPath(home);
-  if (!existsSync(file)) {
+  if (!existsSync2(file)) {
     return {};
   }
   try {
@@ -11666,7 +11923,7 @@ function readConfig(home = homedir()) {
 }
 function writeConfig(config, home = homedir()) {
   const dir = configDir(home);
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   writeFileSync(configPath(home), `${JSON.stringify(config, null, 2)}
@@ -11674,7 +11931,7 @@ function writeConfig(config, home = homedir()) {
 }
 function ensureLocalMachineId(home = homedir()) {
   const file = machineIdPath(home);
-  if (existsSync(file)) {
+  if (existsSync2(file)) {
     const value = readFileSync(file, "utf8").trim();
     if (value.length > 0) {
       return value;
@@ -11682,7 +11939,7 @@ function ensureLocalMachineId(home = homedir()) {
   }
   const id = randomUUID();
   const dir = configDir(home);
-  if (!existsSync(dir)) {
+  if (!existsSync2(dir)) {
     mkdirSync(dir, { recursive: true });
   }
   writeFileSync(file, `${id}

package/package.json

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