@yhong91/vibetime 0.1.39 → 0.1.41

package/bin/vibetime.mjs

@@ -1928,7 +1928,7 @@ function countTextLines(text) {
 }
 
 // src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.1.39" : "0.1.1";
+var PACKAGE_VERSION = true ? "0.1.41" : "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;
@@ -3308,7 +3308,11 @@ async function isHooksJsonInstalled(filePath, command) {
 }
 
 // src/adapters/claude-code.ts
+init_fs();
 async function parseClaudeCodeSessionFile(filePath, options) {
+  if (path7.basename(filePath) === "usage.jsonl" && path7.basename(path7.dirname(filePath)) === ".viberouter") {
+    return parseClaudeRouterUsageFile(filePath, options);
+  }
   const text = await readFile3(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const projectContext = await claudeProjectContextFromLines(filePath, lines, options);
@@ -3575,6 +3579,86 @@ async function parseClaudeCodeSessionFile(filePath, options) {
   }
   return state.events.filter((event) => validateCanonicalEvent(event).valid);
 }
+async function parseClaudeRouterUsageFile(filePath, options) {
+  const rows = (await readFile3(filePath, "utf8")).split("\n").map(parseJsonLine).filter((row) => Boolean(
+    row && row.surface === "claude" && (numberField(row, "timestamp") ?? 0) > 0 && Object.keys(objectField(row, "usage")).length > 0
+  ));
+  if (rows.length === 0) {
+    return [];
+  }
+  const timestamps = rows.map((row) => numberField(row, "timestamp") ?? 0);
+  const firstTs = Math.min(...timestamps) - 6e4;
+  const lastTs = Math.max(...timestamps) + 6e4;
+  const home = path7.resolve(stringOption(options.home) || path7.dirname(path7.dirname(filePath)));
+  const transcriptCounts = /* @__PURE__ */ new Map();
+  for (const transcript of await listJsonlFiles(path7.join(claudeConfigDir(home, process.env), "projects"))) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of (await readFile3(transcript, "utf8")).split("\n")) {
+      const raw = parseJsonLine(line);
+      const ts = raw ? Date.parse(timestampFrom(raw.timestamp) || "") : Number.NaN;
+      if (!raw || stringField(raw, "type") !== "assistant" || ts < firstTs || ts > lastTs) {
+        continue;
+      }
+      const message = objectField(raw, "message");
+      const messageId = stringField(message, "id");
+      const usageKey = messageId ? `${messageId}:${stringField(raw, "requestId")}` : null;
+      if (usageKey && seen.has(usageKey)) {
+        continue;
+      }
+      if (usageKey) {
+        seen.add(usageKey);
+      }
+      const usage = claudeUsageFromMessage(message);
+      if (!usage) {
+        continue;
+      }
+      const key = `${usage.tokensInput || 0}:${usage.tokensOutput || 0}`;
+      transcriptCounts.set(key, (transcriptCounts.get(key) || 0) + 1);
+    }
+  }
+  const sourcePathHash = `sha256:${createStableHash(filePath)}`;
+  const events = [];
+  for (const row of rows) {
+    const usage = objectField(row, "usage");
+    const input = numberField(usage, "inputTokens") || 0;
+    const output = numberField(usage, "outputTokens") || 0;
+    const key = `${input}:${output}`;
+    const matched = transcriptCounts.get(key) || 0;
+    if (matched > 0) {
+      transcriptCounts.set(key, matched - 1);
+      continue;
+    }
+    const timestamp = numberField(row, "timestamp") ?? 0;
+    const requestId = stringField(row, "requestId") || createStableHash(row).slice(0, 24);
+    const cacheCreation = numberField(usage, "cacheCreationInputTokens") || 0;
+    const cacheRead = numberField(usage, "cacheReadInputTokens") || 0;
+    const cached = numberField(usage, "cachedInputTokens") || cacheCreation + cacheRead;
+    const event = baseClaudeEvent({
+      ts: new Date(timestamp).toISOString(),
+      type: "model.usage",
+      sessionId: `viberouter:${new Date(timestamp).toISOString().slice(0, 10)}`,
+      project: "unknown",
+      model: stringField(row, "resolvedModel") || stringField(row, "requestedModel") || stringField(row, "model"),
+      provider: stringField(row, "provider"),
+      confidence: "exact",
+      metrics: {
+        tokensInput: input || void 0,
+        tokensCachedInput: cached || void 0,
+        tokensCacheCreationInput: cacheCreation || void 0,
+        tokensCacheReadInput: cacheRead || void 0,
+        tokensOutput: output || void 0,
+        tokensReasoningOutput: numberField(usage, "reasoningOutputTokens") || void 0,
+        tokensTotal: numberField(usage, "totalTokens") || input + output || void 0,
+        modelCalls: 1
+      },
+      refs: stringRefs({ sourceId: requestId, sourcePathHash, importKey: `claude-code:viberouter:${requestId}` })
+    });
+    if (validateCanonicalEvent(event).valid) {
+      events.push(event);
+    }
+  }
+  return events;
+}
 function baseClaudeEvent(event) {
   return {
     schemaVersion: AGENT_TIME_SCHEMA_VERSION,
@@ -3911,6 +3995,7 @@ function createClaudeCodeAdapter() {
       const base = claudeConfigDir(home, env);
       return [
         path7.join(base, "projects"),
+        path7.join(home, ".viberouter", "usage.jsonl"),
         path7.join(base, ".claude.json"),
         path7.join(home, ".claude.json")
       ];
@@ -4565,48 +4650,71 @@ function normalizeModelCandidate(value) {
   }
   return trimmed;
 }
-function extractUsageFromGenerationSpan(span) {
-  const parsed = parseEmbeddedJson(span.toolOutput);
-  if (!Array.isArray(parsed) || parsed.length === 0) {
-    return void 0;
-  }
-  const first = parsed[0];
-  if (!isPlainObject(first)) {
-    return void 0;
-  }
-  const usage = objectField(first, "usage");
-  if (!isPlainObject(usage)) {
+function finitePositive(value) {
+  if (typeof value !== "number" && typeof value !== "string") {
     return void 0;
   }
+  const parsed = Number(value);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : void 0;
+}
+function extractUsageFromGenerationSpan(span) {
+  const parsed = parseEmbeddedJson(span.toolOutput);
+  const first = Array.isArray(parsed) ? parsed[0] : void 0;
+  const usage = isPlainObject(first) ? objectField(first, "usage") : {};
   const inputTokens = numberField(usage, "prompt_tokens");
   const outputTokens = numberField(usage, "completion_tokens");
   const totalTokens = numberField(usage, "total_tokens");
   const details = objectField(usage, "prompt_tokens_details");
   const cachedTokens = isPlainObject(details) ? numberField(details, "cached_tokens") : void 0;
+  const otelAttributes = span.attributes || {};
+  const otelInputTokens = finitePositive(otelAttributes["gen_ai.usage.input_tokens"]);
+  const otelOutputTokens = finitePositive(otelAttributes["gen_ai.usage.output_tokens"]);
+  const otelCacheReadTokens = finitePositive(otelAttributes["gen_ai.usage.cache_read_input_tokens"]);
+  const otelCacheCreationTokens = finitePositive(otelAttributes["gen_ai.usage.cache_creation_input_tokens"]);
+  const otelReasoningTokens = finitePositive(otelAttributes["gen_ai.usage.reasoning_output_tokens"]);
+  const tokensInput = otelInputTokens ?? inputTokens;
+  const tokensOutput = otelOutputTokens ?? outputTokens;
+  const tokensCacheReadInput = otelCacheReadTokens ?? cachedTokens;
+  const tokensCachedInput = (tokensCacheReadInput ?? 0) + (otelCacheCreationTokens ?? 0);
+  const tokensTotal = totalTokens || (tokensInput ?? 0) + (tokensOutput ?? 0);
+  if (!tokensInput && !tokensOutput && !tokensCachedInput && !otelReasoningTokens && !tokensTotal) {
+    return void 0;
+  }
   return {
-    tokensInput: inputTokens || void 0,
-    tokensCachedInput: cachedTokens || void 0,
-    tokensCacheReadInput: cachedTokens || void 0,
-    tokensOutput: outputTokens || void 0,
-    tokensTotal: totalTokens || void 0,
+    tokensInput: tokensInput || void 0,
+    tokensOutput: tokensOutput || void 0,
+    tokensCachedInput: tokensCachedInput || void 0,
+    tokensCacheReadInput: tokensCacheReadInput || void 0,
+    tokensCacheCreationInput: otelCacheCreationTokens,
+    tokensReasoningOutput: otelReasoningTokens,
+    tokensTotal: tokensTotal || void 0,
     modelCalls: 1
   };
 }
 function modelUsageFromTrace(trace, generationIndex, totalGenerations) {
   const info = trace.modelInfo;
-  if (!info || !info.totalInputTokens && !info.totalOutputTokens && !trace.totalTokens) {
+  const otelAttributes = trace.attributes || {};
+  const otelInputTokens = finitePositive(otelAttributes["gen_ai.usage.input_tokens"]);
+  const otelOutputTokens = finitePositive(otelAttributes["gen_ai.usage.output_tokens"]);
+  const otelCacheReadTokens = finitePositive(otelAttributes["gen_ai.usage.cache_read_input_tokens"]);
+  const otelCacheCreationTokens = finitePositive(otelAttributes["gen_ai.usage.cache_creation_input_tokens"]);
+  const otelReasoningTokens = finitePositive(otelAttributes["gen_ai.usage.reasoning_output_tokens"]);
+  if (!info && !trace.totalTokens && !otelInputTokens && !otelOutputTokens && !otelCacheReadTokens && !otelCacheCreationTokens && !otelReasoningTokens) {
     return void 0;
   }
+  const inputTokens = otelInputTokens ?? (info?.totalInputTokens || 0);
+  const outputTokens = otelOutputTokens ?? (info?.totalOutputTokens || 0);
+  const cacheReadTokens = otelCacheReadTokens ?? info?.totalCachedTokens;
+  const cachedTokens = (cacheReadTokens ?? 0) + (otelCacheCreationTokens ?? 0);
+  const totalTokens = trace.totalTokens || inputTokens + outputTokens;
   if (generationIndex === 1) {
-    const inputTokens = info.totalInputTokens || 0;
-    const outputTokens = info.totalOutputTokens || 0;
-    const cachedTokens = info.totalCachedTokens || 0;
-    const totalTokens = trace.totalTokens || inputTokens + outputTokens;
     return {
       tokensInput: inputTokens || void 0,
       tokensCachedInput: cachedTokens || void 0,
-      tokensCacheReadInput: cachedTokens || void 0,
+      tokensCacheReadInput: cacheReadTokens,
+      tokensCacheCreationInput: otelCacheCreationTokens || void 0,
       tokensOutput: outputTokens || void 0,
+      tokensReasoningOutput: otelReasoningTokens || void 0,
       tokensTotal: totalTokens || void 0,
       modelCalls: totalGenerations || 1
     };
@@ -7468,6 +7576,11 @@ function createPiAdapter() {
   };
 }
 
+// src/adapters/qoder-cn.ts
+import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
+import os8 from "node:os";
+import path17 from "node:path";
+
 // src/adapters/qoder-local-db.ts
 import { access } from "node:fs/promises";
 import os7 from "node:os";
@@ -7514,6 +7627,7 @@ async function loadQoderDbModelCalls(appDirName, sessionId, modelMap) {
     }
     const db = new DatabaseSync(dbPath, { readOnly: true });
     try {
+      calls.rootSessionId = resolveRootSessionId(db, sessionId);
       const preferredModel = resolveSessionPreferredModel(db, sessionId, modelMap);
       const rows = db.prepare(
         `select request_id, token_info, model_info from chat_message where session_id = ? and role = 'assistant' and token_info != '' order by gmt_create asc`
@@ -7547,6 +7661,18 @@ async function loadQoderDbModelCalls(appDirName, sessionId, modelMap) {
   }
   return calls;
 }
+function resolveRootSessionId(db, sessionId) {
+  let current = sessionId;
+  for (let depth = 0; depth < 5; depth += 1) {
+    const row = db.prepare("select parent_session_id from chat_session where session_id = ?").get(current);
+    const parent = row ? stringField(row, "parent_session_id") : void 0;
+    if (!parent) {
+      return current === sessionId ? void 0 : current;
+    }
+    current = parent;
+  }
+  return current === sessionId ? void 0 : current;
+}
 function resolveSessionPreferredModel(db, sessionId, modelMap) {
   let current = sessionId;
   for (let depth = 0; depth < 5 && current; depth++) {
@@ -7572,9 +7698,6 @@ function resolveSessionPreferredModel(db, sessionId, modelMap) {
 }
 
 // src/adapters/qoder-cn.ts
-import { readdir as readdir7, readFile as readFile10, stat as stat8 } from "node:fs/promises";
-import os8 from "node:os";
-import path17 from "node:path";
 function parseQoderCnPaths(filePath) {
   const parts = filePath.split(path17.sep);
   const subagentsIdx = parts.lastIndexOf("subagents");
@@ -7617,9 +7740,8 @@ function rebuildEventIdentity2(event) {
     }
   };
 }
-async function loadQoderCnModelNames(configDir2) {
+async function parseModelNamesFromDynamicTexts(dynamicTextsPath) {
   try {
-    const dynamicTextsPath = path17.join(configDir2, ".auth", "dynamic-texts.json");
     const content = await readFile10(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
@@ -7635,6 +7757,19 @@ async function loadQoderCnModelNames(configDir2) {
     return {};
   }
 }
+async function loadQoderCnModelNames(configDir2) {
+  const map = await parseModelNamesFromDynamicTexts(path17.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"));
+    for (const [key, val] of Object.entries(siblingMap)) {
+      if (!(key in map)) {
+        map[key] = val;
+      }
+    }
+  }
+  return map;
+}
 async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderCnPaths(filePath);
   const segmentsPath = path17.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
@@ -7680,7 +7815,8 @@ async function loadQoderCnSegmentModelCalls(filePath, isSubagentSession, modelMa
 async function parseQoderCnSessionFile(filePath, options) {
   const text = await readFile10(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
-  const { configDir: configDir2 } = parseQoderCnPaths(filePath);
+  const parsedPaths = parseQoderCnPaths(filePath);
+  const { configDir: configDir2 } = parsedPaths;
   const projectContext = await qoderCnProjectContextFromLines(filePath, lines, options, configDir2);
   const pendingTools = /* @__PURE__ */ new Map();
   const seenUsageKeys = /* @__PURE__ */ new Set();
@@ -8008,6 +8144,16 @@ 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 parentSourcePathHash = `sha256:${createStableHash(parentPath)}`;
+    return validEvents.map((event) => rebuildEventIdentity2({
+      ...event,
+      sessionId: dbModelCalls.rootSessionId,
+      refs: { ...event.refs, sourcePathHash: parentSourcePathHash }
+    }));
+  }
   return validEvents;
 }
 function baseQoderCnEvent(event) {
@@ -8420,9 +8566,8 @@ function rebuildEventIdentity3(event) {
     }
   };
 }
-async function loadQoderModelNames(configDir2) {
+async function parseModelNamesFromDynamicTexts2(dynamicTextsPath) {
   try {
-    const dynamicTextsPath = path18.join(configDir2, ".auth", "dynamic-texts.json");
     const content = await readFile11(dynamicTextsPath, "utf8");
     const json = JSON.parse(content);
     const texts = json.texts || {};
@@ -8438,6 +8583,19 @@ async function loadQoderModelNames(configDir2) {
     return {};
   }
 }
+async function loadQoderModelNames(configDir2) {
+  const map = await parseModelNamesFromDynamicTexts2(path18.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"));
+    for (const [key, val] of Object.entries(siblingMap)) {
+      if (!(key in map)) {
+        map[key] = val;
+      }
+    }
+  }
+  return map;
+}
 async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap) {
   const { configDir: configDir2, projectName, sessionId } = parseQoderPaths(filePath);
   const segmentsPath = path18.join(configDir2, "logs", "sessions", projectName, sessionId, "segments");
@@ -8483,7 +8641,8 @@ async function loadQoderSegmentModelCalls(filePath, isSubagentSession, modelMap)
 async function parseQoderSessionFile(filePath, options) {
   const text = await readFile11(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
-  const { configDir: configDir2 } = parseQoderPaths(filePath);
+  const parsedPaths = parseQoderPaths(filePath);
+  const { configDir: configDir2 } = parsedPaths;
   const projectContext = await qoderProjectContextFromLines(filePath, lines, options, configDir2);
   const pendingTools = /* @__PURE__ */ new Map();
   const seenUsageKeys = /* @__PURE__ */ new Set();
@@ -8811,6 +8970,16 @@ 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 parentSourcePathHash = `sha256:${createStableHash(parentPath)}`;
+    return validEvents.map((event) => rebuildEventIdentity3({
+      ...event,
+      sessionId: dbModelCalls.rootSessionId,
+      refs: { ...event.refs, sourcePathHash: parentSourcePathHash }
+    }));
+  }
   return validEvents;
 }
 function baseQoderEvent(event) {
@@ -9846,7 +10015,7 @@ function modelMetrics(row) {
     toolCalls: numberField(row, "tool_call_count")
   };
 }
-function resolveRootSessionId(sessionId, sessions) {
+function resolveRootSessionId2(sessionId, sessions) {
   let current = sessionId;
   const visited = /* @__PURE__ */ new Set();
   while (true) {
@@ -9868,7 +10037,7 @@ function sessionContext(row, sessions) {
   const session = sessions.get(sessionId);
   const cwd = stringField(session, "directory");
   const project = projectFromDirectory(cwd);
-  const rootSessionId = resolveRootSessionId(sessionId, sessions);
+  const rootSessionId = resolveRootSessionId2(sessionId, sessions);
   return {
     rawSessionId: sessionId,
     sessionId: `zcode:${rootSessionId}`,
@@ -11242,9 +11411,10 @@ async function postRollupBatch(remote, rollups, options = {}) {
     failed: 0
   };
 }
-async function deleteRollupsBySource(remote, source, machine) {
+async function deleteRollupsBySource(remote, source, machine, options = {}) {
+  const query = `source=${encodeURIComponent(source)}${options.preserveTokens ? "&preserveTokens=1" : ""}`;
   const response = await remote.fetchImpl(
-    joinUrl(remote.baseUrl, `/v3/agent/sessions?source=${encodeURIComponent(source)}`),
+    joinUrl(remote.baseUrl, `/v3/agent/sessions?${query}`),
     { method: "DELETE", headers: buildHeaders(remote.token, machine) }
   );
   if (!response.ok) {
@@ -11367,7 +11537,7 @@ function createCli(ctx, registry) {
   cli.command("hook", "Read agent hook JSON from stdin and report a throttled event").option("--agent <name>", "Agent name").option("--project <name>", "Project name").option("--min-interval <seconds>", "Minimum seconds between similar hook reports").action((options) => hookCommand(normalizeOptions(options), ctx));
   cli.command("sync-local-trigger", "Trigger one background local sync with throttle and locking").option("--min-interval <seconds>", "Minimum seconds between sync triggers").action((options) => syncLocalTriggerCommand(normalizeOptions(options), ctx, registry));
   cli.command("sync-local-runner", "Internal background local sync runner").option("--lock-file <path>", "Lock file for the active sync").option("--state-file <path>", "State file for trigger metadata").action((options) => syncLocalRunnerCommand(normalizeOptions(options), ctx, registry));
-  cli.command("backfill [action]", "Inspect local history import candidates").option("--source <source>", "Backfill source").option("--since <time>", "Only include history after this time").option("--until <time>", "Only include history before this time").option("--project <name>", "Project filter").option("--source-root <path>", "Override source history root").option("--include-source-path", "Include local source paths in output").option("--import-run <id>", "Import run id for verify/resume workflows").option("--limit <count>", "Maximum session files to parse").option("--batch-size <count>", "Max rollups per request (also bounded by --batch-bytes)").option("--batch-bytes <bytes>", "Soft byte cap for the JSON body of a single ingest POST").option("--replace", "Replace conflicting records during import (default)").option("--skip-conflicts", "Skip conflicting records instead of replacing them").option("--force", "Force full re-import: clear watermark and re-process all files").action((action, options) => backfillCommand({ ...normalizeOptions(options), action }, ctx, registry));
+  cli.command("backfill [action]", "Inspect local history import candidates").option("--source <source>", "Backfill source").option("--since <time>", "Only include history after this time").option("--until <time>", "Only include history before this time").option("--project <name>", "Project filter").option("--source-root <path>", "Override source history root").option("--include-source-path", "Include local source paths in output").option("--import-run <id>", "Import run id for verify/resume workflows").option("--limit <count>", "Maximum session files to parse").option("--batch-size <count>", "Max rollups per request (also bounded by --batch-bytes)").option("--batch-bytes <bytes>", "Soft byte cap for the JSON body of a single ingest POST").option("--replace", "Replace conflicting records during import (default)").option("--skip-conflicts", "Skip conflicting records instead of replacing them").option("--force", "Force full re-import: clear watermark and re-process all files (keeps server rollups that already have tokens)").option("--purge-all", "With --force: also delete token-bearing server rollups before re-importing (DANGEROUS \u2014 tokens whose local sources were rotated away are lost forever)").action((action, options) => backfillCommand({ ...normalizeOptions(options), action }, ctx, registry));
   cli.command("token [action] [value]", "Set, show, or clear the persisted API token").option("--remote <url>", "Override API base URL when setting a token").action((action, value, options) => tokenCommand(action, value, normalizeOptions(options), ctx));
   cli.command("machine [action]", "List or rename machines (requires login)").option("--name <name>", "New display name (used by `machine rename`)").option("--id <id>", "Machine id (defaults to current machine)").action((action, options) => machineCommand(action, normalizeOptions(options), ctx));
   return cli;
@@ -11386,7 +11556,8 @@ function normalizeOptions(options) {
     importRun: "import-run",
     batchSize: "batch-size",
     batchBytes: "batch-bytes",
-    skipConflicts: "skip-conflicts"
+    skipConflicts: "skip-conflicts",
+    purgeAll: "purge-all"
   };
   for (const [camel, dashed] of Object.entries(aliases)) {
     if (normalized[camel] !== void 0 && normalized[dashed] === void 0) {
@@ -11958,11 +12129,13 @@ async function purgeForcedSources(sourceDefs, home, remoteKey, options, ctx) {
     debug(ctx, `Failed to clear backfill watermark: ${error.message}
 `);
   }
+  const preserveTokens = !options["purge-all"];
   for (const item of sourceDefs) {
     try {
-      const deleted = await deleteSessionRollupsBySourceAPI(item.id, options, ctx);
+      const deleted = await deleteSessionRollupsBySourceAPI(item.id, options, ctx, preserveTokens);
       if (!options.json) {
-        write(ctx.stdout, `purged ${item.id}: ${deleted} old rollups
+        const suffix = preserveTokens ? " (token-bearing rollups kept)" : "";
+        write(ctx.stdout, `purged ${item.id}: ${deleted} old rollups${suffix}
 `);
       }
     } catch (error) {
@@ -12092,7 +12265,7 @@ async function sendSessionRollupBatch(rollups, options, ctx) {
   });
   return result;
 }
-async function deleteSessionRollupsBySourceAPI(source, options, ctx) {
+async function deleteSessionRollupsBySourceAPI(source, options, ctx, preserveTokens) {
   const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote) {
     throw new Error("No fetch available for HTTP delete");
@@ -12102,7 +12275,7 @@ async function deleteSessionRollupsBySourceAPI(source, options, ctx) {
     id: ensureLocalMachineId(home),
     hostname: defaultMachineName(),
     platform: process.platform
-  });
+  }, { preserveTokens });
 }
 function shouldUseIncrementalBackfill(options) {
   return !stringOption(options.since) && !stringOption(options.until) && !stringOption(options["source-root"]) && numberOption(options.limit) === void 0;
@@ -12561,7 +12734,7 @@ Usage:
   vibetime install [--target codex,claude,opencode,pi] [--all] [--dry-run] [--force] [--home <path>]
   vibetime upgrade [--check]
   vibetime hook --agent <name>
-  vibetime backfill discover|plan|import|verify --source codex|claude-code|opencode|pi|all --dry-run [--json] [--batch-size <count>]
+  vibetime backfill discover|plan|import|verify --source codex|claude-code|opencode|pi|all --dry-run [--json] [--batch-size <count>] [--force [--purge-all]]
   vibetime token set <token>
   vibetime token show
   vibetime token clear

package/package.json

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