codetime-cli 0.2.0 → 0.3.1

package/bin/codetime.mjs

@@ -14,6 +14,7 @@ var fs_exports = {};
 __export(fs_exports, {
   GENERATED_MARKER: () => GENERATED_MARKER,
   countDirectoryEntries: () => countDirectoryEntries,
+  listFilesByExtensions: () => listFilesByExtensions,
   listJsonlFiles: () => listJsonlFiles,
   parseJsonFile: () => parseJsonFile,
   pathExists: () => pathExists,
@@ -22,7 +23,7 @@ __export(fs_exports, {
   writeGeneratedFile: () => writeGeneratedFile
 });
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
-import path3 from "node:path";
+import path from "node:path";
 async function pathExists(filePath) {
   try {
     await stat(filePath);
@@ -70,11 +71,14 @@ async function writeGeneratedFile(filePath, content, { dryRun, force, onWrite })
       `Refusing to overwrite non-codetime file: ${filePath}. Re-run with --force if this is intentional.`
     );
   }
-  await mkdir(path3.dirname(filePath), { recursive: true });
+  await mkdir(path.dirname(filePath), { recursive: true });
   await writeFile(filePath, content, "utf8");
   onWrite(`Installed ${filePath}`);
 }
 async function listJsonlFiles(rootPath) {
+  return listFilesByExtensions(rootPath, [".jsonl"]);
+}
+async function listFilesByExtensions(rootPath, extensions) {
   let info;
   try {
     info = await stat(rootPath);
@@ -85,18 +89,18 @@ async function listJsonlFiles(rootPath) {
     throw error;
   }
   if (info.isFile()) {
-    return rootPath.endsWith(".jsonl") ? [rootPath] : [];
+    return extensions.some((ext) => rootPath.endsWith(ext)) ? [rootPath] : [];
   }
   if (!info.isDirectory()) {
     return [];
   }
   const entries = await readdir(rootPath, { withFileTypes: true });
   const files = await Promise.all(entries.map(async (entry) => {
-    const entryPath = path3.join(rootPath, entry.name);
+    const entryPath = path.join(rootPath, entry.name);
     if (entry.isDirectory()) {
-      return listJsonlFiles(entryPath);
+      return listFilesByExtensions(entryPath, extensions);
     }
-    return entry.isFile() && entry.name.endsWith(".jsonl") ? [entryPath] : [];
+    return entry.isFile() && extensions.some((ext) => entry.name.endsWith(ext)) ? [entryPath] : [];
   }));
   return files.flat().sort();
 }
@@ -108,6 +112,9 @@ async function countDirectoryEntries(candidatePath) {
         const text = await readFile(candidatePath, "utf8");
         return text.split("\n").filter(Boolean).length;
       }
+      if (candidatePath.endsWith(".json")) {
+        return 1;
+      }
       if (candidatePath.endsWith(".db")) {
         try {
           const { DatabaseSync } = await import("node:sqlite");
@@ -126,7 +133,7 @@ async function countDirectoryEntries(candidatePath) {
       }
       return 1;
     }
-    const files = await listJsonlFiles(candidatePath);
+    const files = await listFilesByExtensions(candidatePath, [".jsonl", ".json"]);
     return files.length;
   } catch (error) {
     if (error.code === "ENOENT") {
@@ -145,9 +152,9 @@ var init_fs = __esm({
 
 // src/cli.ts
 import { spawn } from "node:child_process";
-import { mkdir as mkdir2, rm, stat as stat4, writeFile as writeFile2 } from "node:fs/promises";
+import { mkdir as mkdir3, rm, stat as stat5, writeFile as writeFile2 } from "node:fs/promises";
 import os3 from "node:os";
-import path11 from "node:path";
+import path12 from "node:path";
 import { fileURLToPath } from "node:url";
 
 // ../shared/src/index.ts
@@ -960,231 +967,17 @@ var CAC = class extends EventTarget {
 };
 var cac = (name = "") => new CAC(name);
 
-// src/adapters/claude-code.ts
+// src/adapters/amp.ts
 import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import os from "node:os";
-import path5 from "node:path";
-
-// src/lib/activity.ts
 import path2 from "node:path";
 
-// src/lib/shell.ts
-import path from "node:path";
-function fileActivitiesFromShellCommand(command, ts, rootCwd, initialCwd) {
-  const activities = [];
-  let currentCwd = initialCwd;
-  for (const segment of command.split(/\s*(?:&&|\|\||\||;)\s*/)) {
-    const words = shellWords(segment);
-    if (words.length === 0) {
-      continue;
-    }
-    const commandName = path.basename(words[0]);
-    if (commandName === "cd" && words[1]) {
-      currentCwd = resolvePath(words[1], currentCwd);
-      continue;
-    }
-    for (const item of shellReadTargets(words, currentCwd)) {
-      activities.push({
-        ts,
-        path: displayActivityPath(item.path, rootCwd, currentCwd),
-        operation: item.operation,
-        confidence: "derived"
-      });
-    }
-  }
-  return activities;
-}
-function shellReadTargets(words, cwd) {
-  const command = path.basename(words[0]).toLowerCase();
-  if (["cat", "less", "more", "nl"].includes(command)) {
-    return fileArgs(words.slice(1), /* @__PURE__ */ new Set()).map((item) => ({ path: item, operation: "read" }));
-  }
-  if (command === "sed") {
-    const args = commandArgs(words.slice(1), /* @__PURE__ */ new Set(["-e", "--expression", "-f", "--file"]));
-    return args.slice(1).filter(looksLikePathArg).map((item) => ({ path: item, operation: "read" }));
-  }
-  if (command === "head" || command === "tail") {
-    return fileArgs(words.slice(1), /* @__PURE__ */ new Set(["-n", "-c", "--lines", "--bytes"])).map((item) => ({ path: item, operation: "read" }));
-  }
-  if (["rg", "grep", "ag"].includes(command)) {
-    const hasPatternOption = words.includes("-e") || words.includes("--regexp") || words.includes("-f") || words.includes("--file");
-    const args = commandArgs(words.slice(1), /* @__PURE__ */ new Set(["-e", "--regexp", "-f", "--file", "-g", "--glob", "-t", "-T", "-A", "-B", "-C", "-m"]));
-    const pathArgs = hasPatternOption ? args : args.slice(1);
-    return pathArgs.filter(looksLikePathArg).map((item) => ({ path: item, operation: "search" }));
-  }
-  if (command === "find") {
-    const args = fileArgs(words.slice(1), /* @__PURE__ */ new Set());
-    return args.slice(0, 1).map((item) => ({ path: item, operation: "search" }));
-  }
-  if (command === "pwd" && cwd) {
-    return [{ path: cwd, operation: "search" }];
-  }
-  return [];
-}
-function fileArgs(args, optionsWithValues) {
-  return commandArgs(args, optionsWithValues).filter(looksLikePathArg);
-}
-function commandArgs(args, optionsWithValues) {
-  const result = [];
-  for (let index = 0; index < args.length; index += 1) {
-    const arg = args[index];
-    if (!arg || arg === "--") {
-      continue;
-    }
-    if (arg.startsWith("-")) {
-      if (optionsWithValues.has(arg)) {
-        index += 1;
-      }
-      continue;
-    }
-    result.push(arg);
-  }
-  return result;
-}
-function looksLikePathArg(value) {
-  if (!value || value.startsWith("$")) {
-    return false;
-  }
-  if ([">", ">>", "<", "2>", "2>>"].includes(value)) {
-    return false;
-  }
-  return path.isAbsolute(value) || value.includes("/") || value.includes(".");
-}
-function shellWords(command) {
-  const matches = command.match(/"([^"\\]|\\.)*"|'[^']*'|\S+/g) || [];
-  return matches.map((word) => {
-    if (word.startsWith('"') && word.endsWith('"') || word.startsWith("'") && word.endsWith("'")) {
-      return word.slice(1, -1);
-    }
-    return word;
-  });
-}
-function resolvePath(filePath, cwd) {
-  if (path.isAbsolute(filePath) || !cwd) {
-    return filePath;
-  }
-  return path.resolve(cwd, filePath);
-}
-function displayFilePath(filePath, cwd) {
-  if (!cwd || !path.isAbsolute(filePath)) {
-    return filePath;
-  }
-  const relative = path.relative(cwd, filePath);
-  return relative && !relative.startsWith("..") && !path.isAbsolute(relative) ? relative : filePath;
-}
-function displayActivityPath(filePath, rootCwd, currentCwd) {
-  if (path.isAbsolute(filePath)) {
-    return displayFilePath(filePath, rootCwd);
-  }
-  if (currentCwd && path.isAbsolute(currentCwd)) {
-    return displayFilePath(path.resolve(currentCwd, filePath), rootCwd);
-  }
-  return filePath;
-}
-
-// src/lib/activity.ts
-function operationForTool(tool) {
-  const normalized = (tool || "").toLowerCase();
-  if (["read", "notebookread", "view_image"].includes(normalized)) {
-    return "read";
-  }
-  if (["grep", "glob", "ls", "search", "rg"].includes(normalized)) {
-    return "search";
-  }
-  if (["write"].includes(normalized)) {
-    return "write";
-  }
-  if (["edit", "multiedit", "notebookedit", "apply_patch", "applypatch"].includes(normalized)) {
-    return "edit";
-  }
-  return "read";
-}
-function toolFileActivityType(tool) {
-  const readTools = ["read", "glob", "grep", "webfetch", "websearch"];
-  if (readTools.includes(tool.toLowerCase())) {
-    return "file.read";
-  }
-  return "file.changed";
-}
-function selectFileOperation(current, next) {
-  if (!current) {
-    return next;
-  }
-  if (isWriteOperation(current) && !isWriteOperation(next)) {
-    return current;
-  }
-  return next;
-}
-function isWriteOperation(operation) {
-  return operation === "create" || operation === "write" || operation === "edit" || operation === "delete";
-}
-function eventTypeFromFileActivities(files) {
-  if (files.some((file) => isWriteOperation(file.operation))) {
-    return "file.changed";
-  }
-  if (files.some((file) => file.operation === "search")) {
-    return "file.searched";
-  }
-  return "file.read";
-}
-function mergeFileActivity(current, next) {
-  return {
-    ts: next.ts,
-    path: next.path,
-    operation: selectFileOperation(current?.operation, next.operation),
-    bytesRead: sumOptional(current?.bytesRead, next.bytesRead),
-    bytesWritten: sumOptional(current?.bytesWritten, next.bytesWritten),
-    charsRead: sumOptional(current?.charsRead, next.charsRead),
-    charsWritten: sumOptional(current?.charsWritten, next.charsWritten),
-    linesRead: sumOptional(current?.linesRead, next.linesRead),
-    linesAdded: (current?.linesAdded || 0) + (next.linesAdded || 0),
-    linesRemoved: (current?.linesRemoved || 0) + (next.linesRemoved || 0)
-  };
-}
-function sumOptional(left, right) {
-  const sum = (left || 0) + (right || 0);
-  return sum || void 0;
-}
-function summarizeFileActivities(files) {
-  const linesAdded = files.reduce((total, file) => total + (file.linesAdded || 0), 0);
-  const linesRemoved = files.reduce((total, file) => total + (file.linesRemoved || 0), 0);
-  return {
-    linesAdded: linesAdded || void 0,
-    linesRemoved: linesRemoved || void 0
-  };
-}
-function addPathActivity(changes, filePath, operation, ts) {
-  if (!filePath) {
-    return;
-  }
-  const current = changes.get(filePath);
-  changes.set(filePath, mergeFileActivity(current, { ts, path: filePath, operation }));
-}
-function addResolvedPathActivity(changes, filePath, operation, ts, rootCwd, currentCwd, metrics = {}) {
-  if (!filePath) {
-    return;
-  }
-  const resolvedPath = path2.isAbsolute(filePath) ? displayFilePath(filePath, rootCwd) : currentCwd && path2.isAbsolute(currentCwd) ? displayFilePath(path2.resolve(currentCwd, filePath), rootCwd) : filePath;
-  changes.set(
-    resolvedPath,
-    mergeFileActivity(changes.get(resolvedPath), { ts, path: resolvedPath, operation, ...metrics })
-  );
-}
-function displayBackfillPath(filePath) {
-  if (!path2.isAbsolute(filePath)) {
-    return filePath;
-  }
-  return path2.basename(filePath);
-}
-function countTextLines(text) {
-  if (!text) {
-    return void 0;
-  }
-  return text.split(/\r\n|\r|\n/).length;
-}
-
-// src/lib/adapter-helpers.ts
-import path4 from "node:path";
+// src/lib/constants.ts
+var PACKAGE_VERSION = true ? "0.3.1" : "0.1.1";
+var DEFAULT_API_URL = "https://codetime.dev";
+var DEFAULT_BACKFILL_BATCH_SIZE = 50;
+var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
+var ROLLUP_BUCKET_MS = 15 * 60 * 1e3;
+var DEFAULT_HOOK_SYNC_MIN_INTERVAL_SECONDS = 60;
 
 // src/lib/fields.ts
 function stringField(object, key) {
@@ -1243,75 +1036,30 @@ function numberOption(value) {
   return Number.isFinite(parsed) ? parsed : void 0;
 }
 
-// src/lib/adapter-helpers.ts
-var TURN_IDLE_MS = 6e4;
-function isTurnIdle(lastEventAt) {
-  if (!lastEventAt) {
-    return false;
-  }
-  const lastMs = Date.parse(lastEventAt);
-  if (!Number.isFinite(lastMs)) {
-    return false;
+// src/lib/jsonl.ts
+function parseJsonLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    return isPlainObject(parsed) ? parsed : void 0;
+  } catch {
+    return void 0;
   }
-  return Date.now() - lastMs > TURN_IDLE_MS;
 }
-function sessionIdFromFilePath(filePath, prefix) {
-  const match = path4.basename(filePath).match(/([0-9a-f]{8}-[0-9a-f-]{27,})/);
-  return match?.[1] || `${prefix}_${createStableHash(filePath).slice(0, 24)}`;
+function timestampFrom(value) {
+  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
+    return value;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    return void 0;
+  }
+  const millis = value > 1e10 ? value : value * 1e3;
+  return new Date(millis).toISOString();
 }
-function hookHandler(agentId, statusMessage) {
-  return {
-    type: "command",
-    command: `codetime hook --agent ${agentId}`,
-    timeout: 10,
-    statusMessage
-  };
-}
-async function isHooksJsonInstalled(filePath, command) {
-  try {
-    const { readTextIfExists: readTextIfExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-    const text = await readTextIfExists2(filePath);
-    if (!text) {
-      return false;
-    }
-    const config = JSON.parse(text);
-    if (!isPlainObject(config) || !isPlainObject(config.hooks)) {
-      return false;
-    }
-    return Object.values(config.hooks).some(
-      (groups) => Array.isArray(groups) && groups.some(
-        (group) => isPlainObject(group) && Array.isArray(group.hooks) && group.hooks.some((hook) => hook.command === command)
-      )
-    );
-  } catch {
-    return false;
-  }
-}
-
-// src/lib/jsonl.ts
-function parseJsonLine(line) {
-  try {
-    const parsed = JSON.parse(line);
-    return isPlainObject(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function timestampFrom(value) {
-  if (typeof value === "string" && !Number.isNaN(Date.parse(value))) {
-    return value;
-  }
-  if (typeof value !== "number" || !Number.isFinite(value)) {
-    return void 0;
-  }
-  const millis = value > 1e10 ? value : value * 1e3;
-  return new Date(millis).toISOString();
-}
-function durationObjectToMs(duration) {
-  const secs = duration.secs || 0;
-  const nanos = duration.nanos || 0;
-  const durationMs = secs * 1e3 + Math.round(nanos / 1e6);
-  return durationMs || void 0;
+function durationObjectToMs(duration) {
+  const secs = duration.secs || 0;
+  const nanos = duration.nanos || 0;
+  const durationMs = secs * 1e3 + Math.round(nanos / 1e6);
+  return durationMs || void 0;
 }
 function durationMsBetween(startedAt, endedAt) {
   if (!startedAt || !endedAt) {
@@ -1328,14 +1076,6 @@ function msToIso(ms) {
   return new Date(ms).toISOString();
 }
 
-// src/lib/constants.ts
-var PACKAGE_VERSION = true ? "0.2.0" : "0.1.1";
-var DEFAULT_API_URL = "https://codetime.dev";
-var DEFAULT_BACKFILL_BATCH_SIZE = 50;
-var DEFAULT_BACKFILL_BATCH_BYTES = 800 * 1024;
-var ROLLUP_BUCKET_MS = 15 * 60 * 1e3;
-var DEFAULT_HOOK_SYNC_MIN_INTERVAL_SECONDS = 60;
-
 // src/lib/backfill.ts
 function withBackfillRefs(event, context) {
   const importKey = createImportKey([
@@ -1380,6 +1120,9 @@ function matchesBackfillFilters(event, options) {
   return true;
 }
 
+// src/adapters/amp.ts
+init_fs();
+
 // src/lib/session-state.ts
 var SessionParserState = class {
   events = [];
@@ -1464,14 +1207,447 @@ var SessionParserState = class {
       sessionId: event.sessionId ?? sessionId
     };
   }
-};
+};
+
+// src/adapters/amp.ts
+async function parseAmpSessionFile(filePath, options) {
+  const text = await readFile2(filePath, "utf8");
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return [];
+  }
+  if (!isPlainObject(raw)) {
+    return [];
+  }
+  const threadId = stringField(raw, "id") || path2.basename(filePath, ".json");
+  const sessionId = `amp_${threadId}`;
+  const messages = Array.isArray(raw.messages) ? raw.messages.filter(isPlainObject) : [];
+  const ledger = objectField(raw, "usageLedger");
+  const rawEvents = Array.isArray(ledger.events) ? ledger.events.filter(isPlainObject) : [];
+  if (rawEvents.length === 0) {
+    return [];
+  }
+  const events = [...rawEvents].sort((a, b) => {
+    const ta = timestampFrom(stringField(a, "timestamp")) || "";
+    const tb = timestampFrom(stringField(b, "timestamp")) || "";
+    return ta.localeCompare(tb);
+  });
+  const state = new SessionParserState(filePath, options, (event) => baseAmpEvent(event));
+  state.sessionId = sessionId;
+  const firstTs = timestampFrom(stringField(events[0], "timestamp")) || (/* @__PURE__ */ new Date()).toISOString();
+  state.ensureSessionStarted(firstTs, 0);
+  let lastTs = firstTs;
+  for (const [index, ev] of events.entries()) {
+    const ts = timestampFrom(stringField(ev, "timestamp")) || lastTs;
+    lastTs = ts;
+    const model = stringField(ev, "model") || void 0;
+    const tokens = objectField(ev, "tokens");
+    const input = numberField(tokens, "input") || 0;
+    const output = numberField(tokens, "output") || 0;
+    const toMessageId = numberField(ev, "toMessageId");
+    const cache = cacheTokensFor(messages, toMessageId);
+    const cacheRead = cache.cacheReadInputTokens;
+    const cacheWrite = cache.cacheCreationInputTokens;
+    const totalTokens = input + output + cacheRead + cacheWrite;
+    if (totalTokens <= 0) {
+      continue;
+    }
+    const credits = numberField(ev, "credits");
+    const operationType = stringField(ev, "operationType");
+    const fromMessageId = numberField(ev, "fromMessageId");
+    const metrics = {
+      tokensInput: input + cacheRead + cacheWrite || void 0,
+      tokensOutput: output || void 0,
+      tokensCachedInput: cacheRead + cacheWrite || void 0,
+      tokensCacheReadInput: cacheRead || void 0,
+      tokensCacheCreationInput: cacheWrite || void 0,
+      tokensTotal: totalTokens,
+      modelCalls: 1
+    };
+    state.push(
+      baseAmpEvent({
+        ts,
+        type: "model.usage",
+        sessionId,
+        model,
+        confidence: "exact",
+        metrics,
+        refs: stringRefs({
+          threadId,
+          operationType,
+          fromMessageId: fromMessageId === void 0 ? void 0 : String(fromMessageId),
+          toMessageId: toMessageId === void 0 ? void 0 : String(toMessageId),
+          // Credits are Amp's proprietary billing unit; preserved here so the
+          // backend can correlate token counts with what the user is charged.
+          credits: typeof credits === "number" && Number.isFinite(credits) ? String(credits) : void 0
+        })
+      }),
+      index + 1,
+      "ledger",
+      "model.usage"
+    );
+  }
+  state.push(
+    baseAmpEvent({
+      ts: lastTs,
+      type: "session.ended",
+      sessionId,
+      confidence: "derived"
+    }),
+    events.length,
+    "ledger",
+    "session"
+  );
+  return state.events.filter((event) => matchesBackfillFilters(event, options));
+}
+function baseAmpEvent(event) {
+  return {
+    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
+    source: "amp",
+    agent: "amp",
+    // Amp threads carry no cwd/project metadata; pin all events to a stable
+    // synthetic workspace so downstream rollups keep them grouped together.
+    workspaceId: createWorkspaceId({ projectName: "amp" }),
+    ...event
+  };
+}
+function cacheTokensFor(messages, toMessageId) {
+  if (toMessageId === void 0) {
+    return { cacheReadInputTokens: 0, cacheCreationInputTokens: 0 };
+  }
+  const match = messages.find(
+    (message) => stringField(message, "role") === "assistant" && numberField(message, "messageId") === toMessageId
+  );
+  if (!match) {
+    return { cacheReadInputTokens: 0, cacheCreationInputTokens: 0 };
+  }
+  const usage = objectField(match, "usage");
+  return {
+    cacheReadInputTokens: numberField(usage, "cacheReadInputTokens") || 0,
+    cacheCreationInputTokens: numberField(usage, "cacheCreationInputTokens") || 0
+  };
+}
+function ampDataDir(home, env) {
+  const override = env?.AMP_DATA_DIR;
+  if (override && override.trim()) {
+    return path2.resolve(override);
+  }
+  return path2.join(home, ".local", "share", "amp");
+}
+function ampThreadsDir(home, env) {
+  return path2.join(ampDataDir(home, env), "threads");
+}
+async function ampBackfillFiles(sourceRoot, home, env) {
+  const root = sourceRoot ? path2.resolve(sourceRoot) : ampThreadsDir(home, env);
+  const files = await listFilesByExtensions(root, [".json"]);
+  return Promise.all(files.map(async (filePath) => {
+    const info = await stat2(filePath);
+    return { path: filePath, modifiedAt: info.mtime.toISOString() };
+  }));
+}
+function createAmpAdapter() {
+  return {
+    id: "amp",
+    label: "Amp",
+    agentName: "amp",
+    kind: "agent",
+    detectPath(home, env) {
+      return ampDataDir(home, env);
+    },
+    // Amp has no plugin/hook surface, so there is nothing for codetime to
+    // "install". Report installed = true whenever the threads dir is on disk
+    // so `detect` accurately shows "already covered via backfill".
+    installedPath(home, env) {
+      return ampThreadsDir(home, env);
+    },
+    async isInstalled(home, env) {
+      try {
+        return await pathExists(ampThreadsDir(home, env));
+      } catch {
+        return false;
+      }
+    },
+    installEntries() {
+      return [];
+    },
+    sourcePaths(home, env) {
+      return [ampThreadsDir(home, env)];
+    },
+    parseSessionFile: parseAmpSessionFile
+  };
+}
+
+// src/adapters/claude-code.ts
+import { readFile as readFile3, stat as stat3 } from "node:fs/promises";
+import os from "node:os";
+import path6 from "node:path";
+
+// src/lib/activity.ts
+import path4 from "node:path";
+
+// src/lib/shell.ts
+import path3 from "node:path";
+function fileActivitiesFromShellCommand(command, ts, rootCwd, initialCwd) {
+  const activities = [];
+  let currentCwd = initialCwd;
+  for (const segment of command.split(/\s*(?:&&|\|\||\||;)\s*/)) {
+    const words = shellWords(segment);
+    if (words.length === 0) {
+      continue;
+    }
+    const commandName = path3.basename(words[0]);
+    if (commandName === "cd" && words[1]) {
+      currentCwd = resolvePath(words[1], currentCwd);
+      continue;
+    }
+    for (const item of shellReadTargets(words, currentCwd)) {
+      activities.push({
+        ts,
+        path: displayActivityPath(item.path, rootCwd, currentCwd),
+        operation: item.operation,
+        confidence: "derived"
+      });
+    }
+  }
+  return activities;
+}
+function shellReadTargets(words, cwd) {
+  const command = path3.basename(words[0]).toLowerCase();
+  if (["cat", "less", "more", "nl"].includes(command)) {
+    return fileArgs(words.slice(1), /* @__PURE__ */ new Set()).map((item) => ({ path: item, operation: "read" }));
+  }
+  if (command === "sed") {
+    const args = commandArgs(words.slice(1), /* @__PURE__ */ new Set(["-e", "--expression", "-f", "--file"]));
+    return args.slice(1).filter(looksLikePathArg).map((item) => ({ path: item, operation: "read" }));
+  }
+  if (command === "head" || command === "tail") {
+    return fileArgs(words.slice(1), /* @__PURE__ */ new Set(["-n", "-c", "--lines", "--bytes"])).map((item) => ({ path: item, operation: "read" }));
+  }
+  if (["rg", "grep", "ag"].includes(command)) {
+    const hasPatternOption = words.includes("-e") || words.includes("--regexp") || words.includes("-f") || words.includes("--file");
+    const args = commandArgs(words.slice(1), /* @__PURE__ */ new Set(["-e", "--regexp", "-f", "--file", "-g", "--glob", "-t", "-T", "-A", "-B", "-C", "-m"]));
+    const pathArgs = hasPatternOption ? args : args.slice(1);
+    return pathArgs.filter(looksLikePathArg).map((item) => ({ path: item, operation: "search" }));
+  }
+  if (command === "find") {
+    const args = fileArgs(words.slice(1), /* @__PURE__ */ new Set());
+    return args.slice(0, 1).map((item) => ({ path: item, operation: "search" }));
+  }
+  if (command === "pwd" && cwd) {
+    return [{ path: cwd, operation: "search" }];
+  }
+  return [];
+}
+function fileArgs(args, optionsWithValues) {
+  return commandArgs(args, optionsWithValues).filter(looksLikePathArg);
+}
+function commandArgs(args, optionsWithValues) {
+  const result = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg || arg === "--") {
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      if (optionsWithValues.has(arg)) {
+        index += 1;
+      }
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}
+function looksLikePathArg(value) {
+  if (!value || value.startsWith("$")) {
+    return false;
+  }
+  if ([">", ">>", "<", "2>", "2>>"].includes(value)) {
+    return false;
+  }
+  return path3.isAbsolute(value) || value.includes("/") || value.includes(".");
+}
+function shellWords(command) {
+  const matches = command.match(/"([^"\\]|\\.)*"|'[^']*'|\S+/g) || [];
+  return matches.map((word) => {
+    if (word.startsWith('"') && word.endsWith('"') || word.startsWith("'") && word.endsWith("'")) {
+      return word.slice(1, -1);
+    }
+    return word;
+  });
+}
+function resolvePath(filePath, cwd) {
+  if (path3.isAbsolute(filePath) || !cwd) {
+    return filePath;
+  }
+  return path3.resolve(cwd, filePath);
+}
+function displayFilePath(filePath, cwd) {
+  if (!cwd || !path3.isAbsolute(filePath)) {
+    return filePath;
+  }
+  const relative = path3.relative(cwd, filePath);
+  return relative && !relative.startsWith("..") && !path3.isAbsolute(relative) ? relative : filePath;
+}
+function displayActivityPath(filePath, rootCwd, currentCwd) {
+  if (path3.isAbsolute(filePath)) {
+    return displayFilePath(filePath, rootCwd);
+  }
+  if (currentCwd && path3.isAbsolute(currentCwd)) {
+    return displayFilePath(path3.resolve(currentCwd, filePath), rootCwd);
+  }
+  return filePath;
+}
+
+// src/lib/activity.ts
+function operationForTool(tool) {
+  const normalized = (tool || "").toLowerCase();
+  if (["read", "notebookread", "view_image"].includes(normalized)) {
+    return "read";
+  }
+  if (["grep", "glob", "ls", "search", "rg"].includes(normalized)) {
+    return "search";
+  }
+  if (["write"].includes(normalized)) {
+    return "write";
+  }
+  if (["edit", "multiedit", "notebookedit", "apply_patch", "applypatch"].includes(normalized)) {
+    return "edit";
+  }
+  return "read";
+}
+function toolFileActivityType(tool) {
+  const readTools = ["read", "glob", "grep", "webfetch", "websearch"];
+  if (readTools.includes(tool.toLowerCase())) {
+    return "file.read";
+  }
+  return "file.changed";
+}
+function selectFileOperation(current, next) {
+  if (!current) {
+    return next;
+  }
+  if (isWriteOperation(current) && !isWriteOperation(next)) {
+    return current;
+  }
+  return next;
+}
+function isWriteOperation(operation) {
+  return operation === "create" || operation === "write" || operation === "edit" || operation === "delete";
+}
+function eventTypeFromFileActivities(files) {
+  if (files.some((file) => isWriteOperation(file.operation))) {
+    return "file.changed";
+  }
+  if (files.some((file) => file.operation === "search")) {
+    return "file.searched";
+  }
+  return "file.read";
+}
+function mergeFileActivity(current, next) {
+  return {
+    ts: next.ts,
+    path: next.path,
+    operation: selectFileOperation(current?.operation, next.operation),
+    bytesRead: sumOptional(current?.bytesRead, next.bytesRead),
+    bytesWritten: sumOptional(current?.bytesWritten, next.bytesWritten),
+    charsRead: sumOptional(current?.charsRead, next.charsRead),
+    charsWritten: sumOptional(current?.charsWritten, next.charsWritten),
+    linesRead: sumOptional(current?.linesRead, next.linesRead),
+    linesAdded: (current?.linesAdded || 0) + (next.linesAdded || 0),
+    linesRemoved: (current?.linesRemoved || 0) + (next.linesRemoved || 0)
+  };
+}
+function sumOptional(left, right) {
+  const sum = (left || 0) + (right || 0);
+  return sum || void 0;
+}
+function summarizeFileActivities(files) {
+  const linesAdded = files.reduce((total, file) => total + (file.linesAdded || 0), 0);
+  const linesRemoved = files.reduce((total, file) => total + (file.linesRemoved || 0), 0);
+  return {
+    linesAdded: linesAdded || void 0,
+    linesRemoved: linesRemoved || void 0
+  };
+}
+function addResolvedPathActivity(changes, filePath, operation, ts, rootCwd, currentCwd, metrics = {}) {
+  if (!filePath) {
+    return;
+  }
+  const resolvedPath = path4.isAbsolute(filePath) ? displayFilePath(filePath, rootCwd) : currentCwd && path4.isAbsolute(currentCwd) ? displayFilePath(path4.resolve(currentCwd, filePath), rootCwd) : filePath;
+  changes.set(
+    resolvedPath,
+    mergeFileActivity(changes.get(resolvedPath), { ts, path: resolvedPath, operation, ...metrics })
+  );
+}
+function displayBackfillPath(filePath) {
+  if (!path4.isAbsolute(filePath)) {
+    return filePath;
+  }
+  return path4.basename(filePath);
+}
+function countTextLines(text) {
+  if (!text) {
+    return void 0;
+  }
+  return text.split(/\r\n|\r|\n/).length;
+}
+
+// src/lib/adapter-helpers.ts
+import path5 from "node:path";
+var TURN_IDLE_MS = 6e4;
+function isTurnIdle(lastEventAt) {
+  if (!lastEventAt) {
+    return false;
+  }
+  const lastMs = Date.parse(lastEventAt);
+  if (!Number.isFinite(lastMs)) {
+    return false;
+  }
+  return Date.now() - lastMs > TURN_IDLE_MS;
+}
+function sessionIdFromFilePath(filePath, prefix) {
+  const match = path5.basename(filePath).match(/([0-9a-f]{8}-[0-9a-f-]{27,})/);
+  return match?.[1] || `${prefix}_${createStableHash(filePath).slice(0, 24)}`;
+}
+function hookHandler(agentId, statusMessage) {
+  return {
+    type: "command",
+    command: `codetime hook --agent ${agentId}`,
+    timeout: 10,
+    statusMessage
+  };
+}
+async function isHooksJsonInstalled(filePath, command) {
+  try {
+    const { readTextIfExists: readTextIfExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
+    const text = await readTextIfExists2(filePath);
+    if (!text) {
+      return false;
+    }
+    const config = JSON.parse(text);
+    if (!isPlainObject(config) || !isPlainObject(config.hooks)) {
+      return false;
+    }
+    return Object.values(config.hooks).some(
+      (groups) => Array.isArray(groups) && groups.some(
+        (group) => isPlainObject(group) && Array.isArray(group.hooks) && group.hooks.some((hook) => hook.command === command)
+      )
+    );
+  } catch {
+    return false;
+  }
+}
 
 // src/adapters/claude-code.ts
 async function parseClaudeCodeSessionFile(filePath, options) {
-  const text = await readFile2(filePath, "utf8");
+  const text = await readFile3(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const projectContext = await claudeProjectContextFromLines(filePath, lines, options);
   const pendingTools = /* @__PURE__ */ new Map();
+  const seenUsageKeys = /* @__PURE__ */ new Set();
   let sessionId = sessionIdFromFilePath(filePath, "claude");
   let cwd;
   let project = projectContext.project;
@@ -1497,7 +1673,7 @@ async function parseClaudeCodeSessionFile(filePath, options) {
     sessionId = stringField(raw, "sessionId") || sessionId;
     state.sessionId = sessionId;
     cwd = stringField(raw, "cwd") || cwd;
-    project = projectContext.project || (cwd ? path5.basename(cwd) : project || claudeProjectFromFilePath(filePath, options));
+    project = projectContext.project || (cwd ? path6.basename(cwd) : project || claudeProjectFromFilePath(filePath, options));
     if (!ts) {
       continue;
     }
@@ -1623,8 +1799,19 @@ async function parseClaudeCodeSessionFile(filePath, options) {
       continue;
     }
     model = stringField(message, "model") || model;
+    const messageId = stringField(message, "id");
+    const requestId = stringField(raw, "requestId");
+    const usageKey = messageId ? `${messageId}:${requestId}` : null;
+    if (usageKey != null && seenUsageKeys.has(usageKey)) {
+      continue;
+    }
+    if (usageKey != null) {
+      seenUsageKeys.add(usageKey);
+    }
     const usage = claudeUsageFromMessage(message);
     if (usage) {
+      const speed = stringField(objectField(message, "usage"), "speed");
+      const usageModel = speed === "fast" && model ? `${model}-fast` : model;
       push(baseClaudeEvent({
         ts,
         type: "model.usage",
@@ -1632,7 +1819,7 @@ async function parseClaudeCodeSessionFile(filePath, options) {
         turnId: state.currentTurnId,
         cwd,
         project,
-        model,
+        model: usageModel,
         confidence: "partial",
         metrics: usage
       }), lineNumber, topType, "usage");
@@ -1855,17 +2042,17 @@ function claudeTextStats(value) {
   };
 }
 async function claudeProjectContextFromLines(filePath, lines, options) {
-  const projectDir = path5.basename(path5.dirname(filePath));
+  const projectDir = path6.basename(path6.dirname(filePath));
   const cwds = [];
   for (const line of lines) {
     const raw = parseJsonLine(line);
     const cwd = raw ? stringField(raw, "cwd") : void 0;
-    if (cwd && path5.isAbsolute(cwd)) {
+    if (cwd && path6.isAbsolute(cwd)) {
       cwds.push(cwd);
     }
   }
   const root = await gitRootFromCwds(cwds) || claudeProjectRootFromCwds(projectDir, cwds);
-  const project = root ? path5.basename(root) : claudeProjectFromFilePath(filePath, options);
+  const project = root ? path6.basename(root) : claudeProjectFromFilePath(filePath, options);
   return {
     project,
     workspaceId: createWorkspaceId({ projectName: project, repoRoot: root })
@@ -1874,15 +2061,15 @@ async function claudeProjectContextFromLines(filePath, lines, options) {
 async function gitRootFromCwds(cwds) {
   const seen = /* @__PURE__ */ new Set();
   for (const cwd of cwds) {
-    let current = path5.resolve(cwd);
+    let current = path6.resolve(cwd);
     while (!seen.has(current)) {
       seen.add(current);
       try {
-        await stat2(path5.join(current, ".git"));
+        await stat3(path6.join(current, ".git"));
         return current;
       } catch {
       }
-      const parent = path5.dirname(current);
+      const parent = path6.dirname(current);
       if (parent === current) {
         break;
       }
@@ -1893,12 +2080,12 @@ async function gitRootFromCwds(cwds) {
 }
 function claudeProjectRootFromCwds(projectDir, cwds) {
   for (const cwd of cwds) {
-    let current = path5.resolve(cwd);
+    let current = path6.resolve(cwd);
     while (true) {
       if (encodeClaudeProjectPath(current) === projectDir) {
         return current;
       }
-      const parent = path5.dirname(current);
+      const parent = path6.dirname(current);
       if (parent === current) {
         break;
       }
@@ -1908,11 +2095,11 @@ function claudeProjectRootFromCwds(projectDir, cwds) {
   return void 0;
 }
 function encodeClaudeProjectPath(value) {
-  return path5.resolve(value).split(path5.sep).join("-");
+  return path6.resolve(value).split(path6.sep).join("-");
 }
 function claudeProjectFromFilePath(filePath, options) {
-  const projectDir = path5.basename(path5.dirname(filePath));
-  const home = options ? path5.resolve(stringOption(options.home) || os.homedir()) : os.homedir();
+  const projectDir = path6.basename(path6.dirname(filePath));
+  const home = options ? path6.resolve(stringOption(options.home) || os.homedir()) : os.homedir();
   const homePrefix = `${encodeClaudeProjectPath(home)}-`;
   if (projectDir.startsWith(homePrefix)) {
     return projectDir.slice(homePrefix.length) || void 0;
@@ -1940,36 +2127,44 @@ function hookConfig() {
     }
   };
 }
+function claudeConfigDir(home, env) {
+  const override = env?.CLAUDE_CONFIG_DIR;
+  if (override && override.trim()) {
+    return path6.resolve(override);
+  }
+  return path6.join(home, ".claude");
+}
 function createClaudeCodeAdapter() {
-  const CLAUDE_PATH = ".claude";
   return {
     id: "claude-code",
     label: "Claude Code",
     agentName: "claude",
     kind: "agent",
-    detectPath(home) {
-      return path5.join(home, CLAUDE_PATH);
+    detectPath(home, env) {
+      return claudeConfigDir(home, env);
     },
-    installedPath(home) {
-      return path5.join(home, CLAUDE_PATH, "settings.json");
+    installedPath(home, env) {
+      return path6.join(claudeConfigDir(home, env), "settings.json");
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path5.join(home, CLAUDE_PATH, "settings.json"),
+        path6.join(claudeConfigDir(home, env), "settings.json"),
         "codetime hook --agent claude"
       );
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path5.join(home, CLAUDE_PATH, "settings.json"),
+        path: path6.join(claudeConfigDir(home, env), "settings.json"),
         content: hookConfig()
       }];
     },
-    sourcePaths(home) {
+    sourcePaths(home, env) {
+      const base = claudeConfigDir(home, env);
       return [
-        path5.join(home, ".claude", "projects"),
-        path5.join(home, ".claude.json")
+        path6.join(base, "projects"),
+        path6.join(base, ".claude.json"),
+        path6.join(home, ".claude.json")
       ];
     },
     parseSessionFile: parseClaudeCodeSessionFile
@@ -1977,43 +2172,10 @@ function createClaudeCodeAdapter() {
 }
 
 // src/adapters/codex.ts
-import { readFile as readFile3 } from "node:fs/promises";
-import path6 from "node:path";
+import { readFile as readFile4 } from "node:fs/promises";
+import path7 from "node:path";
 
 // src/lib/diff.ts
-function parseApplyPatch(patch, ts) {
-  const changes = [];
-  let current;
-  for (const line of patch.split("\n")) {
-    const fileMatch = line.match(/^\*\*\* (Add|Update|Delete) File: (.+)$/);
-    if (fileMatch) {
-      current = {
-        ts,
-        path: fileMatch[2].trim(),
-        operation: fileMatch[1] === "Add" ? "create" : fileMatch[1] === "Delete" ? "delete" : "edit",
-        linesAdded: 0,
-        linesRemoved: 0
-      };
-      changes.push(current);
-      continue;
-    }
-    if (!current) {
-      continue;
-    }
-    if (line.startsWith("+") && !line.startsWith("+++")) {
-      current.linesAdded = (current.linesAdded || 0) + 1;
-    } else if (line.startsWith("-") && !line.startsWith("---")) {
-      current.linesRemoved = (current.linesRemoved || 0) + 1;
-    }
-  }
-  return changes;
-}
-function patchFromCommand(command) {
-  if (!command || !command.includes("*** Begin Patch")) {
-    return void 0;
-  }
-  return command.slice(command.indexOf("*** Begin Patch"));
-}
 function diffStats(diff) {
   let linesAdded = 0;
   let linesRemoved = 0;
@@ -2058,9 +2220,10 @@ function fileActivitiesFromPatchChanges(changes, ts, cwd, displayFilePath3) {
 
 // src/adapters/codex.ts
 async function parseCodexSessionFile(filePath, options) {
-  const text = await readFile3(filePath, "utf8");
+  const text = await readFile4(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   const sourcePathHash = `sha256:${createStableHash(filePath)}`;
+  const serviceTier = await resolveCodexServiceTier(filePath);
   const events = [];
   let sessionId = sessionIdFromFilePath(filePath, "codex");
   let cwd;
@@ -2089,7 +2252,7 @@ async function parseCodexSessionFile(filePath, options) {
       sessionMetaLocked = true;
       sessionId = stringField(payload, "id") || sessionId;
       cwd = stringField(payload, "cwd") || cwd;
-      project = cwd ? path6.basename(cwd) : project;
+      project = cwd ? path7.basename(cwd) : project;
       model = stringField(payload, "model_provider") || model;
       events.push(withBackfillRefs({
         schemaVersion: AGENT_TIME_SCHEMA_VERSION,
@@ -2109,7 +2272,7 @@ async function parseCodexSessionFile(filePath, options) {
     if (topType === "turn_context") {
       currentTurnId = stringField(payload, "turn_id") || currentTurnId;
       cwd = stringField(payload, "cwd") || cwd;
-      project = cwd ? path6.basename(cwd) : project;
+      project = cwd ? path7.basename(cwd) : project;
       model = stringField(payload, "model") || model;
       continue;
     }
@@ -2190,7 +2353,10 @@ async function parseCodexSessionFile(filePath, options) {
             turnId: currentTurnId,
             cwd,
             project,
-            model,
+            // Only the model.usage event carries the -fast suffix; tool and
+            // turn events keep the bare model so other queries (e.g. "what
+            // model was the user on") don't show tier-specific names.
+            model: rewriteCodexModelForTier(model, serviceTier),
             confidence: "partial",
             metrics: usage
           }), { filePath, sourcePathHash, lineNumber, topType, payloadType, options }));
@@ -2379,6 +2545,50 @@ async function parseCodexSessionFile(filePath, options) {
   }
   return events.filter((event) => validateCanonicalEvent(event).valid);
 }
+var codexServiceTierCache = /* @__PURE__ */ new Map();
+async function resolveCodexServiceTier(sessionFilePath) {
+  const home = inferCodexHomeFromSessionPath(sessionFilePath);
+  if (!home) {
+    return void 0;
+  }
+  if (!codexServiceTierCache.has(home)) {
+    codexServiceTierCache.set(home, await readCodexServiceTier(home));
+  }
+  return codexServiceTierCache.get(home) ?? void 0;
+}
+function inferCodexHomeFromSessionPath(sessionFilePath) {
+  if (path7.basename(sessionFilePath) === "history.jsonl") {
+    return path7.dirname(sessionFilePath);
+  }
+  let dir = path7.dirname(sessionFilePath);
+  for (let depth = 0; depth < 10; depth += 1) {
+    const parent = path7.dirname(dir);
+    if (parent === dir) {
+      return void 0;
+    }
+    if (path7.basename(dir) === "sessions") {
+      return parent;
+    }
+    dir = parent;
+  }
+  return void 0;
+}
+async function readCodexServiceTier(codexHomePath) {
+  try {
+    const text = await readFile4(path7.join(codexHomePath, "config.toml"), "utf8");
+    const match = text.match(/(?:^|\n)\s*service_tier\s*=\s*["']?([a-z_]+)["']?/i);
+    return match ? match[1].toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+function rewriteCodexModelForTier(model, serviceTier) {
+  if (!model) {
+    return model;
+  }
+  const isFastTier = serviceTier === "fast" || serviceTier === "priority";
+  return isFastTier ? `${model}-fast` : model;
+}
 function baseCodexEvent(event) {
   return {
     schemaVersion: AGENT_TIME_SCHEMA_VERSION,
@@ -2453,11 +2663,11 @@ function functionCallArguments(payload) {
   }
 }
 function displayFilePath2(filePath, cwd) {
-  if (!cwd || !path6.isAbsolute(filePath)) {
+  if (!cwd || !path7.isAbsolute(filePath)) {
     return filePath;
   }
-  const relative = path6.relative(cwd, filePath);
-  return relative && !relative.startsWith("..") && !path6.isAbsolute(relative) ? relative : filePath;
+  const relative = path7.relative(cwd, filePath);
+  return relative && !relative.startsWith("..") && !path7.isAbsolute(relative) ? relative : filePath;
 }
 var codexHandler = (msg) => hookHandler("codex", msg);
 function hookConfig2() {
@@ -2473,36 +2683,43 @@ function hookConfig2() {
     }
   };
 }
+function codexHome(home, env) {
+  const override = env?.CODEX_HOME;
+  if (override && override.trim()) {
+    return path7.resolve(override);
+  }
+  return path7.join(home, ".codex");
+}
 function createCodexAdapter() {
-  const CODE_PATH = ".codex";
   return {
     id: "codex",
     label: "Codex",
     agentName: "codex",
     kind: "agent",
-    detectPath(home) {
-      return path6.join(home, CODE_PATH);
+    detectPath(home, env) {
+      return codexHome(home, env);
     },
-    installedPath(home) {
-      return path6.join(home, CODE_PATH, "hooks.json");
+    installedPath(home, env) {
+      return path7.join(codexHome(home, env), "hooks.json");
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       return isHooksJsonInstalled(
-        path6.join(home, CODE_PATH, "hooks.json"),
+        path7.join(codexHome(home, env), "hooks.json"),
         "codetime hook --agent codex"
       );
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "hooks-json",
-        path: path6.join(home, CODE_PATH, "hooks.json"),
+        path: path7.join(codexHome(home, env), "hooks.json"),
         content: hookConfig2()
       }];
     },
-    sourcePaths(home) {
+    sourcePaths(home, env) {
+      const base = codexHome(home, env);
       return [
-        path6.join(home, ".codex", "sessions"),
-        path6.join(home, ".codex", "history.jsonl")
+        path7.join(base, "sessions"),
+        path7.join(base, "history.jsonl")
       ];
     },
     parseSessionFile: parseCodexSessionFile
@@ -2511,7 +2728,7 @@ function createCodexAdapter() {
 
 // src/adapters/opencode.ts
 import os2 from "node:os";
-import path7 from "node:path";
+import path8 from "node:path";
 async function parseOpenCodeSessionFile(dbPath, options) {
   const { DatabaseSync } = await import("node:sqlite");
   if (!dbPath.endsWith(".db")) {
@@ -2520,13 +2737,29 @@ async function parseOpenCodeSessionFile(dbPath, options) {
   const db = new DatabaseSync(dbPath, { readOnly: true });
   const events = [];
   try {
+    const sessionCols = new Set(
+      db.prepare("PRAGMA table_info(session)").all().map((row) => row.name)
+    );
+    const hasDirectory = sessionCols.has("directory");
+    const hasPath = sessionCols.has("path");
+    const hasArchived = sessionCols.has("time_archived");
+    const selectCols = ["id", "title", "time_created"];
+    if (hasDirectory) {
+      selectCols.push("directory");
+    }
+    if (hasPath) {
+      selectCols.push("path");
+    }
+    if (hasArchived) {
+      selectCols.push("time_archived");
+    }
     const sessions = db.prepare(
-      "SELECT id, directory, path, title, time_created, time_archived FROM session WHERE time_created IS NOT NULL ORDER BY time_created"
+      `SELECT ${selectCols.join(", ")} FROM session WHERE time_created IS NOT NULL ORDER BY time_created`
     ).all();
     for (const session of sessions) {
       const sessionId = session.id;
       const cwd = session.directory || session.path || void 0;
-      const project = cwd ? path7.basename(cwd) : void 0;
+      const project = cwd ? path8.basename(cwd) : void 0;
       const sessionTs = msToIso(session.time_created);
       events.push(baseOpenCodeEvent({
         ts: sessionTs,
@@ -2616,7 +2849,7 @@ async function parseOpenCodeSessionFile(dbPath, options) {
           const assistantAgent = stringField(info, "agent") || "opencode";
           const pathObj = objectField(info, "path");
           const assistantCwd = stringField(pathObj, "cwd") || cwd;
-          const assistantProject = assistantCwd ? path7.basename(assistantCwd) : project;
+          const assistantProject = assistantCwd ? path8.basename(assistantCwd) : project;
           const completedTs = numberField(objectField(info, "time"), "completed");
           const createdTs = timeCreated;
           const tokens = opencodeUsageFromInfo(info);
@@ -2855,24 +3088,36 @@ function opencodeUsageFromInfo(info) {
     tokensTotal: total
   };
 }
-async function opencodeBackfillFiles(sourceRoot) {
-  const { stat: stat5 } = await import("node:fs/promises");
+function opencodeConfigDir(home, env) {
+  const override = env?.OPENCODE_CONFIG_DIR;
+  if (override && override.trim()) {
+    return path8.resolve(override);
+  }
+  const xdgConfig = env?.XDG_CONFIG_HOME;
+  if (xdgConfig && xdgConfig.trim()) {
+    return path8.join(path8.resolve(xdgConfig), "opencode");
+  }
+  return path8.join(home, ".config", "opencode");
+}
+function opencodeDataCandidates(home, env) {
+  const xdgData = env?.XDG_DATA_HOME;
+  const primary = xdgData && xdgData.trim() ? path8.join(path8.resolve(xdgData), "opencode", "opencode.db") : path8.join(home, ".local", "share", "opencode", "opencode.db");
+  return [primary, path8.join(home, ".opencode", "opencode.db")];
+}
+async function opencodeBackfillFiles(sourceRoot, home = os2.homedir(), env) {
+  const { stat: stat6 } = await import("node:fs/promises");
   if (sourceRoot) {
     if (!sourceRoot.endsWith(".db")) {
       return [];
     }
-    const info = await stat5(sourceRoot).catch(() => null);
+    const info = await stat6(sourceRoot).catch(() => null);
     if (!info) {
       return [];
     }
     return [{ path: sourceRoot, modifiedAt: info.mtime.toISOString() }];
   }
-  const candidates = [
-    path7.join(os2.homedir(), ".local", "share", "opencode", "opencode.db"),
-    path7.join(os2.homedir(), ".opencode", "opencode.db")
-  ];
-  for (const candidatePath of candidates) {
-    const info = await stat5(candidatePath).catch(() => null);
+  for (const candidatePath of opencodeDataCandidates(home, env)) {
+    const info = await stat6(candidatePath).catch(() => null);
     if (info) {
       return [{ path: candidatePath, modifiedAt: info.mtime.toISOString() }];
     }
@@ -2925,49 +3170,45 @@ export const AgentTime = async ({ $, directory }) => {
 `;
 }
 function createOpenCodeAdapter() {
-  const OPENCODE_CONFIG = ".config/opencode";
   const PLUGIN_PATH = "plugins/codetime.mjs";
   return {
     id: "opencode",
     label: "OpenCode",
     agentName: "opencode",
     kind: "agent",
-    detectPath(home) {
-      return path7.join(home, OPENCODE_CONFIG);
+    detectPath(home, env) {
+      return opencodeConfigDir(home, env);
     },
-    installedPath(home) {
-      return path7.join(home, OPENCODE_CONFIG, PLUGIN_PATH);
+    installedPath(home, env) {
+      return path8.join(opencodeConfigDir(home, env), PLUGIN_PATH);
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path7.join(home, OPENCODE_CONFIG, PLUGIN_PATH)) || await pathExists2(path7.join(".opencode", PLUGIN_PATH));
+        return await pathExists2(path8.join(opencodeConfigDir(home, env), PLUGIN_PATH)) || await pathExists2(path8.join(".opencode", PLUGIN_PATH));
       } catch {
         return false;
       }
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "file",
-        path: path7.join(home, OPENCODE_CONFIG, PLUGIN_PATH),
+        path: path8.join(opencodeConfigDir(home, env), PLUGIN_PATH),
         content: opencodePluginContent()
       }];
     },
-    sourcePaths(home) {
-      return [
-        path7.join(home, ".local", "share", "opencode", "opencode.db"),
-        path7.join(home, ".opencode", "opencode.db")
-      ];
+    sourcePaths(home, env) {
+      return opencodeDataCandidates(home, env);
     },
     parseSessionFile: parseOpenCodeSessionFile
   };
 }
 
 // src/adapters/pi.ts
-import { readFile as readFile4 } from "node:fs/promises";
-import path8 from "node:path";
+import { readFile as readFile5 } from "node:fs/promises";
+import path9 from "node:path";
 async function parsePiSessionFile(filePath, options) {
-  const text = await readFile4(filePath, "utf8");
+  const text = await readFile5(filePath, "utf8");
   const lines = text.split("\n").filter(Boolean);
   let sessionId;
   let cwd;
@@ -2996,7 +3237,7 @@ async function parsePiSessionFile(filePath, options) {
       sessionId = stringField(raw, "id") || state.sessionId;
       state.sessionId = sessionId || state.sessionId;
       cwd = stringField(raw, "cwd") || cwd;
-      project = cwd ? path8.basename(cwd) : project;
+      project = cwd ? path9.basename(cwd) : project;
       continue;
     }
     if (entryType === "model_change") {
@@ -3391,36 +3632,49 @@ export default function (pi: ExtensionAPI) {
 }
 `;
 }
+function piAgentDir(home, env) {
+  const override = env?.PI_CODING_AGENT_DIR;
+  if (override && override.trim()) {
+    return path9.resolve(override);
+  }
+  return path9.join(home, ".pi", "agent");
+}
+function piSessionDir(home, env) {
+  const override = env?.PI_CODING_AGENT_SESSION_DIR;
+  if (override && override.trim()) {
+    return path9.resolve(override);
+  }
+  return path9.join(piAgentDir(home, env), "sessions");
+}
 function createPiAdapter() {
-  const PI_EXTENSIONS_DIR = ".pi/agent/extensions";
   return {
     id: "pi",
     label: "Pi",
     agentName: "pi",
     kind: "agent",
-    detectPath(home) {
-      return path8.join(home, ".pi", "agent");
+    detectPath(home, env) {
+      return piAgentDir(home, env);
     },
-    installedPath(home) {
-      return path8.join(home, PI_EXTENSIONS_DIR, "codetime.ts");
+    installedPath(home, env) {
+      return path9.join(piAgentDir(home, env), "extensions", "codetime.ts");
     },
-    async isInstalled(home) {
+    async isInstalled(home, env) {
       try {
         const { pathExists: pathExists2 } = await Promise.resolve().then(() => (init_fs(), fs_exports));
-        return await pathExists2(path8.join(home, PI_EXTENSIONS_DIR, "codetime.ts"));
+        return await pathExists2(path9.join(piAgentDir(home, env), "extensions", "codetime.ts"));
       } catch {
         return false;
       }
     },
-    installEntries(home) {
+    installEntries(home, env) {
       return [{
         kind: "file",
-        path: path8.join(home, PI_EXTENSIONS_DIR, "codetime.ts"),
+        path: path9.join(piAgentDir(home, env), "extensions", "codetime.ts"),
         content: piExtensionContent()
       }];
     },
-    sourcePaths(home) {
-      return [path8.join(home, ".pi", "agent", "sessions")];
+    sourcePaths(home, env) {
+      return [piSessionDir(home, env)];
     },
     parseSessionFile: parsePiSessionFile
   };
@@ -3699,457 +3953,78 @@ function buildSessionRollup(rollupKey, events) {
       fileRollup.linesAdded += fileLinesAdded;
       fileRollup.linesRemoved += fileLinesRemoved;
       if ((file.ts || event.ts) > fileRollup.lastTouchedAt) {
-        fileRollup.lastTouchedAt = file.ts || event.ts;
-      }
-      fileRollups.set(pathHash, fileRollup);
-    }
-    timeBuckets.set(bucketTs, bucket);
-  }
-  const baseRollup = {
-    rollupKey,
-    payloadHash: "",
-    source: first.source,
-    project,
-    sessionId,
-    agent,
-    startedAt,
-    lastEventAt,
-    eventCount: ordered.length,
-    promptCount,
-    turnCount,
-    toolCallCount,
-    commandCallCount,
-    inputTokens,
-    cachedInputTokens,
-    cacheCreationInputTokens,
-    cacheReadInputTokens,
-    outputTokens,
-    reasoningOutputTokens,
-    totalTokens,
-    linesAdded,
-    linesRemoved,
-    durationMs: Math.max(0, Date.parse(lastEventAt) - Date.parse(startedAt)),
-    timeBuckets: [...timeBuckets.values()].sort((a, b) => a.ts.localeCompare(b.ts)),
-    modelRollups: [...modelRollups.values()].sort((a, b) => b.callCount - a.callCount || a.model.localeCompare(b.model)),
-    toolRollups: [...toolRollups.values()].sort((a, b) => b.callCount - a.callCount || a.tool.localeCompare(b.tool)),
-    fileRollups: [...fileRollups.values()].sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.displayPath.localeCompare(b.displayPath)),
-    turnRollups: [...turnRollups.values()].map((rollup) => ({
-      ...rollup,
-      durationMs: Math.max(0, Date.parse(rollup.lastEventAt) - Date.parse(rollup.startedAt))
-    })).sort((a, b) => a.startedAt.localeCompare(b.startedAt))
-  };
-  return {
-    ...baseRollup,
-    payloadHash: createPayloadHash(baseRollup)
-  };
-}
-function floorRollupBucket(ts) {
-  const ms = Date.parse(ts);
-  if (!Number.isFinite(ms)) {
-    return ts;
-  }
-  return new Date(Math.floor(ms / ROLLUP_BUCKET_MS) * ROLLUP_BUCKET_MS).toISOString();
-}
-function totalTokensFromEvent(event) {
-  const explicit = event.metrics?.tokensTotal;
-  if (typeof explicit === "number" && explicit > 0) {
-    return explicit;
-  }
-  return Math.max(0, event.metrics?.tokensInput || 0) + Math.max(0, event.metrics?.tokensOutput || 0) + Math.max(0, event.metrics?.tokensReasoningOutput || 0);
-}
-function lineStatsFromEvent(event) {
-  const files = event.fileActivities || [];
-  const fileLinesAdded = files.reduce((total, f) => total + (f.linesAdded || 0), 0);
-  const fileLinesRemoved = files.reduce((total, f) => total + (f.linesRemoved || 0), 0);
-  return {
-    linesAdded: Math.max(fileLinesAdded, event.metrics?.linesAdded || 0),
-    linesRemoved: Math.max(fileLinesRemoved, event.metrics?.linesRemoved || 0)
-  };
-}
-function eventDurationMs(event) {
-  return Math.max(
-    0,
-    event.metrics?.durationMs || event.metrics?.commandDurationMs || event.metrics?.toolDurationMs || event.metrics?.modelDurationMs || 0
-  );
-}
-
-// src/hooks/dispatch.ts
-import { open, readFile as readFile5, stat as stat3 } from "node:fs/promises";
-import path9 from "node:path";
-var TRANSCRIPT_TAIL_BYTES = 512 * 1024;
-function hookEventsFromPayload(agent, payload, options, enrichment = {}, adapters) {
-  const eventName = stringField(payload, "hook_event_name") || "agent.operation";
-  const tool = stringField(payload, "tool_name");
-  const cwd = stringField(payload, "cwd");
-  const model = stringField(payload, "model") || enrichment.model;
-  const project = stringOption(options.project) || (cwd ? path9.basename(cwd) : void 0);
-  const source = toAgentSource(agent);
-  const ts = (/* @__PURE__ */ new Date()).toISOString();
-  const toolUseId = stringField(payload, "tool_use_id") || stringField(payload, "toolUseId");
-  const turnId = stringField(payload, "turn_id") || stringField(payload, "turnId");
-  const sessionId = stringField(payload, "session_id") || stringField(payload, "sessionId");
-  const prompt = stringField(payload, "prompt");
-  const fileActivities = extractFileActivities(payload, tool, ts);
-  const lineMetrics = summarizeFileActivities(fileActivities);
-  const durationMs = numberField(payload, "duration_ms") || durationObjectToMs(objectField(payload, "duration"));
-  const command = stringField(objectField(payload, "tool_input"), "command");
-  const commandHash = tool === "Bash" && command ? createStableHash(command) : void 0;
-  const codexUsage = adapters?.tokenUsageFromPayload?.(payload);
-  const baseEvent = (type, extra = {}) => ({
-    schemaVersion: AGENT_TIME_SCHEMA_VERSION,
-    ts,
-    source,
-    agent,
-    type,
-    project,
-    cwd,
-    workspaceId: createWorkspaceId({ projectName: project, repoRoot: cwd }),
-    sessionId,
-    turnId,
-    tool,
-    model,
-    ...extra
-  });
-  const usageEvent = (metrics, extra = {}) => {
-    const total = (metrics.tokensInput || 0) + (metrics.tokensOutput || 0) + (metrics.tokensReasoningOutput || 0);
-    if (total <= 0) {
-      return void 0;
-    }
-    const finalMetrics = {
-      ...metrics,
-      tokensTotal: metrics.tokensTotal || total
-    };
-    const eventBase = baseEvent("model.usage", {
-      operation: "model usage",
-      confidence: extra.confidence ?? "partial",
-      metrics: finalMetrics,
-      refs: stringRefs({
-        sourceId: extra.messageId,
-        messageId: extra.messageId
-      })
-    });
-    const cost = estimateEventCostUsd(eventBase);
-    if (cost > 0) {
-      eventBase.metrics = { ...finalMetrics, costUsd: cost };
-    }
-    return eventBase;
-  };
-  switch (eventName) {
-    case "SessionStart": {
-      return [baseEvent("session.started", { operation: stringField(payload, "source") || "session start" })];
-    }
-    case "SessionEnd": {
-      return [baseEvent("session.ended", { operation: stringField(payload, "reason") || "session end" })];
-    }
-    case "UserPromptSubmit": {
-      return [
-        baseEvent("prompt.submitted", {
-          operation: "prompt submitted",
-          metrics: { prompts: 1, promptChars: prompt?.length },
-          refs: stringRefs({
-            promptHash: prompt ? `sha256:${createStableHash(prompt)}` : void 0
-          })
-        })
-      ];
-    }
-    case "PreToolUse": {
-      return [
-        baseEvent("tool.started", {
-          operation: tool ? `${tool} started` : eventName,
-          metrics: { toolCalls: 1 },
-          refs: stringRefs({ sourceId: toolUseId, commandHash })
-        })
-      ];
-    }
-    case "PermissionRequest": {
-      return [
-        baseEvent("permission.requested", {
-          operation: tool ? `${tool} permission requested` : "permission requested",
-          refs: stringRefs({ sourceId: toolUseId, commandHash })
-        })
-      ];
-    }
-    case "PermissionDenied": {
-      return [
-        baseEvent("permission.resolved", {
-          operation: tool ? `${tool} permission denied` : "permission denied",
-          success: false,
-          refs: stringRefs({ sourceId: toolUseId, commandHash })
-        })
-      ];
-    }
-    case "PostToolUse": {
-      const events = buildHookToolResultEvents({
-        baseEvent,
-        tool,
-        toolUseId,
-        commandHash,
-        durationMs,
-        success: true,
-        fileActivities,
-        lineMetrics
-      });
-      if (codexUsage) {
-        const usage = usageEvent({
-          ...codexUsage,
-          modelCalls: 1,
-          modelDurationMs: durationMs
-        }, { confidence: "exact" });
-        if (usage) {
-          events.push(usage);
-        }
-      }
-      return events;
-    }
-    case "PostToolUseFailure": {
-      return buildHookToolResultEvents({
-        baseEvent,
-        tool,
-        toolUseId,
-        commandHash,
-        durationMs,
-        success: false,
-        fileActivities,
-        lineMetrics,
-        error: stringField(payload, "error")
-      });
-    }
-    case "SubagentStart": {
-      return [
-        baseEvent("subagent.started", {
-          operation: "subagent started",
-          agentInstanceId: stringField(payload, "agent_id") || stringField(payload, "agentId")
-        })
-      ];
-    }
-    case "SubagentStop": {
-      return [
-        baseEvent("subagent.ended", {
-          operation: "subagent completed",
-          agentInstanceId: stringField(payload, "agent_id") || stringField(payload, "agentId"),
-          success: !payload.error
-        })
-      ];
-    }
-    case "Stop": {
-      const turnUsage = enrichment.turnUsage || codexUsage;
-      const turnMetrics = { durationMs };
-      if (turnUsage) {
-        Object.assign(turnMetrics, turnUsage);
-        if (!turnMetrics.modelCalls && enrichment.turnUsage?.modelCalls) {
-          turnMetrics.modelCalls = enrichment.turnUsage.modelCalls;
-        }
-      }
-      const events = [
-        baseEvent("turn.completed", { operation: "turn completed", metrics: turnMetrics })
-      ];
-      if (turnUsage) {
-        const usage = usageEvent(
-          { ...turnUsage, modelCalls: turnMetrics.modelCalls, modelDurationMs: durationMs },
-          { messageId: enrichment.lastUsageMessageId, confidence: enrichment.turnUsage ? "derived" : "exact" }
-        );
-        if (usage) {
-          events.push(usage);
-        }
-      }
-      return events;
-    }
-    case "StopFailure": {
-      return [baseEvent("turn.failed", { operation: "turn failed" })];
-    }
-    case "PostCompact": {
-      return [baseEvent("context.compacted", { operation: "context compacted" })];
-    }
-    default: {
-      return [];
-    }
-  }
-}
-async function enrichFromTranscript(payload, claudeUsageFromMessage2) {
-  const transcriptPath = stringField(payload, "transcript_path");
-  if (!transcriptPath) {
-    return {};
-  }
-  let text;
-  try {
-    const stats = await stat3(transcriptPath);
-    if (stats.size <= TRANSCRIPT_TAIL_BYTES) {
-      text = await readFile5(transcriptPath, "utf8");
-    } else {
-      const handle = await open(transcriptPath, "r");
-      try {
-        const buffer = Buffer.alloc(TRANSCRIPT_TAIL_BYTES);
-        await handle.read(buffer, 0, TRANSCRIPT_TAIL_BYTES, stats.size - TRANSCRIPT_TAIL_BYTES);
-        text = buffer.toString("utf8");
-        const newlineIndex = text.indexOf("\n");
-        if (newlineIndex !== -1) {
-          text = text.slice(newlineIndex + 1);
-        }
-      } finally {
-        await handle.close();
-      }
-    }
-  } catch (error) {
-    if (process.env.CODETIME_DEBUG || process.env.AGENT_TIME_DEBUG) {
-      process.stderr.write(`[codetime] enrichFromTranscript: failed to read transcript ${transcriptPath}: ${error.message}
-`);
-    }
-    return {};
-  }
-  const lines = text.split("\n");
-  let model;
-  let lastUsage;
-  let lastUsageMessageId;
-  const turnUsage = {};
-  let turnCalls = 0;
-  for (let index = lines.length - 1; index >= 0; index -= 1) {
-    const raw = lines[index];
-    if (!raw) {
-      continue;
-    }
-    let entry;
-    try {
-      entry = JSON.parse(raw);
-    } catch {
-      continue;
-    }
-    if (!isPlainObject(entry)) {
-      continue;
-    }
-    const topType = stringField(entry, "type");
-    const message = objectField(entry, "message");
-    if (topType === "user") {
-      if (Object.keys(message).length > 0 && isClaudeToolResultMessage2(message)) {
-        continue;
-      }
-      break;
-    }
-    if (topType !== "assistant") {
-      continue;
-    }
-    if (!model) {
-      model = stringField(message, "model");
-    }
-    if (!claudeUsageFromMessage2) {
-      continue;
-    }
-    const usage = claudeUsageFromMessage2(message);
-    if (!usage) {
-      continue;
-    }
-    if (!lastUsage) {
-      lastUsage = usage;
-      lastUsageMessageId = stringField(message, "id");
-    }
-    for (const [key, value] of Object.entries(usage)) {
-      if (typeof value === "number") {
-        turnUsage[key] = (turnUsage[key] || 0) + value;
+        fileRollup.lastTouchedAt = file.ts || event.ts;
       }
+      fileRollups.set(pathHash, fileRollup);
     }
-    turnCalls += 1;
+    timeBuckets.set(bucketTs, bucket);
   }
+  const baseRollup = {
+    rollupKey,
+    payloadHash: "",
+    source: first.source,
+    project,
+    sessionId,
+    agent,
+    startedAt,
+    lastEventAt,
+    eventCount: ordered.length,
+    promptCount,
+    turnCount,
+    toolCallCount,
+    commandCallCount,
+    inputTokens,
+    cachedInputTokens,
+    cacheCreationInputTokens,
+    cacheReadInputTokens,
+    outputTokens,
+    reasoningOutputTokens,
+    totalTokens,
+    linesAdded,
+    linesRemoved,
+    durationMs: Math.max(0, Date.parse(lastEventAt) - Date.parse(startedAt)),
+    timeBuckets: [...timeBuckets.values()].sort((a, b) => a.ts.localeCompare(b.ts)),
+    modelRollups: [...modelRollups.values()].sort((a, b) => b.callCount - a.callCount || a.model.localeCompare(b.model)),
+    toolRollups: [...toolRollups.values()].sort((a, b) => b.callCount - a.callCount || a.tool.localeCompare(b.tool)),
+    fileRollups: [...fileRollups.values()].sort((a, b) => b.writes - a.writes || b.reads - a.reads || a.displayPath.localeCompare(b.displayPath)),
+    turnRollups: [...turnRollups.values()].map((rollup) => ({
+      ...rollup,
+      durationMs: Math.max(0, Date.parse(rollup.lastEventAt) - Date.parse(rollup.startedAt))
+    })).sort((a, b) => a.startedAt.localeCompare(b.startedAt))
+  };
   return {
-    model,
-    lastUsage,
-    lastUsageMessageId,
-    turnUsage: turnCalls > 0 ? { ...turnUsage, modelCalls: turnCalls } : void 0
+    ...baseRollup,
+    payloadHash: createPayloadHash(baseRollup)
   };
 }
-function isClaudeToolResultMessage2(message) {
-  return Array.isArray(message.content) ? message.content.some(
-    (item) => isPlainObject(item) && item.type === "tool_result"
-  ) : false;
-}
-function extractFileActivities(payload, tool, ts) {
-  const changes = /* @__PURE__ */ new Map();
-  const toolInput = objectField(payload, "tool_input");
-  const toolResponse = objectField(payload, "tool_response");
-  const operation = operationForTool2(tool);
-  addPathActivity(changes, stringField(toolInput, "file_path") || stringField(toolInput, "path"), operation, ts);
-  addPathActivity(changes, stringField(toolResponse, "filePath") || stringField(toolResponse, "file_path"), operation, ts);
-  for (const file of arrayField3(toolInput, "files")) {
-    if (typeof file === "string") {
-      addPathActivity(changes, file, operation, ts);
-    }
-  }
-  const patch = stringField(toolInput, "patch") || patchFromCommand(stringField(toolInput, "command"));
-  if (patch) {
-    for (const change of parseApplyPatch(patch, ts)) {
-      const current = changes.get(change.path);
-      changes.set(change.path, mergeFileActivity(current, change));
-    }
-  }
-  return [...changes.values()];
-}
-function operationForTool2(tool) {
-  const normalized = (tool || "").toLowerCase();
-  if (["read", "notebookread", "view_image"].includes(normalized)) {
-    return "read";
-  }
-  if (["grep", "glob", "ls", "search", "rg"].includes(normalized)) {
-    return "search";
-  }
-  if (["write"].includes(normalized)) {
-    return "write";
-  }
-  if (["edit", "multiedit", "notebookedit", "apply_patch", "applypatch"].includes(normalized)) {
-    return "edit";
+function floorRollupBucket(ts) {
+  const ms = Date.parse(ts);
+  if (!Number.isFinite(ms)) {
+    return ts;
   }
-  return "read";
+  return new Date(Math.floor(ms / ROLLUP_BUCKET_MS) * ROLLUP_BUCKET_MS).toISOString();
 }
-function arrayField3(object, key) {
-  if (!isPlainObject(object) || !Array.isArray(object[key])) {
-    return [];
+function totalTokensFromEvent(event) {
+  const explicit = event.metrics?.tokensTotal;
+  if (typeof explicit === "number" && explicit > 0) {
+    return explicit;
   }
-  return object[key];
+  return Math.max(0, event.metrics?.tokensInput || 0) + Math.max(0, event.metrics?.tokensOutput || 0) + Math.max(0, event.metrics?.tokensReasoningOutput || 0);
 }
-function buildHookToolResultEvents(input) {
-  const refs = stringRefs({
-    sourceId: input.toolUseId,
-    commandHash: input.commandHash
-  });
-  const events = [
-    input.baseEvent(input.success ? "tool.completed" : "tool.failed", {
-      operation: input.tool ? `${input.tool} completed` : "tool completed",
-      success: input.success,
-      metrics: {
-        toolDurationMs: input.durationMs,
-        durationMs: input.durationMs
-      },
-      refs
-    })
-  ];
-  if (input.tool === "Bash") {
-    events.push(input.baseEvent(input.success ? "command.completed" : "command.failed", {
-      operation: "command completed",
-      success: input.success,
-      metrics: {
-        commandCalls: 1,
-        commandDurationMs: input.durationMs,
-        durationMs: input.durationMs
-      },
-      refs
-    }));
-  }
-  if (input.fileActivities.length > 0) {
-    events.push(input.baseEvent(eventTypeFromFileActivities(input.fileActivities), {
-      operation: input.tool ? `${input.tool} file activity` : "file activity",
-      success: input.success,
-      fileActivities: input.fileActivities,
-      metrics: input.lineMetrics,
-      refs
-    }));
-  }
-  return events;
+function lineStatsFromEvent(event) {
+  const files = event.fileActivities || [];
+  const fileLinesAdded = files.reduce((total, f) => total + (f.linesAdded || 0), 0);
+  const fileLinesRemoved = files.reduce((total, f) => total + (f.linesRemoved || 0), 0);
+  return {
+    linesAdded: Math.max(fileLinesAdded, event.metrics?.linesAdded || 0),
+    linesRemoved: Math.max(fileLinesRemoved, event.metrics?.linesRemoved || 0)
+  };
 }
-function toAgentSource(agent) {
-  if (agent === "claude") {
-    return "claude-code";
-  }
-  if (agent === "codex" || agent === "cursor" || agent === "opencode") {
-    return agent;
-  }
-  return agent || "unknown";
+function eventDurationMs(event) {
+  return Math.max(
+    0,
+    event.metrics?.durationMs || event.metrics?.commandDurationMs || event.metrics?.toolDurationMs || event.metrics?.modelDurationMs || 0
+  );
 }
 
 // src/install/manager.ts
@@ -4165,7 +4040,7 @@ async function installEntry(entry, options) {
   });
 }
 async function mergeHooksJson(filePath, content, { dryRun, force, onWrite }) {
-  const { mkdir: mkdir3, writeFile: writeFile3 } = await import("node:fs/promises");
+  const { mkdir: mkdir4, writeFile: writeFile3 } = await import("node:fs/promises");
   const pathMod = await import("node:path");
   if (dryRun) {
     onWrite(`Would merge ${filePath}`);
@@ -4186,7 +4061,7 @@ async function mergeHooksJson(filePath, content, { dryRun, force, onWrite }) {
     onWrite(`Already installed ${filePath}`);
     return;
   }
-  await mkdir3(pathMod.dirname(filePath), { recursive: true });
+  await mkdir4(pathMod.dirname(filePath), { recursive: true });
   await writeFile3(filePath, nextText, "utf8");
   onWrite(`Installed ${filePath}`);
 }
@@ -4281,6 +4156,63 @@ function defaultMachineName() {
 // src/cli.ts
 init_fs();
 
+// src/lib/logger.ts
+import { appendFile, mkdir as mkdir2, rename, stat as stat4 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import path11 from "node:path";
+var MAX_BYTES = 1 * 1024 * 1024;
+function logDir(home = homedir2()) {
+  return path11.join(home, ".codetime", "logs");
+}
+function logPath(home = homedir2(), name = "cli.log") {
+  return path11.join(logDir(home), name);
+}
+function serializeError(error) {
+  if (error instanceof Error) {
+    return { message: error.message, stack: error.stack, name: error.name };
+  }
+  return { value: String(error) };
+}
+async function rotateIfNeeded(file) {
+  try {
+    const info = await stat4(file);
+    if (info.size > MAX_BYTES) {
+      await rename(file, `${file}.1`).catch(() => {
+      });
+    }
+  } catch {
+  }
+}
+async function writeLog(entry, home = homedir2(), fileName = "cli.log") {
+  try {
+    const dir = logDir(home);
+    await mkdir2(dir, { recursive: true });
+    const file = logPath(home, fileName);
+    await rotateIfNeeded(file);
+    const record = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level: entry.level || (entry.error ? "error" : "info"),
+      scope: entry.scope,
+      pid: process.pid
+    };
+    if (entry.message) {
+      record.message = entry.message;
+    }
+    if (entry.meta) {
+      Object.assign(record, entry.meta);
+    }
+    if (entry.error !== void 0) {
+      record.error = serializeError(entry.error);
+    }
+    await appendFile(file, `${JSON.stringify(record)}
+`);
+  } catch {
+  }
+}
+async function logError(scope, error, meta = {}, home = homedir2()) {
+  await writeLog({ scope, error, meta, level: "error" }, home);
+}
+
 // src/lib/progress.ts
 var BAR_WIDTH = 24;
 var ProgressBar = class {
@@ -4408,8 +4340,8 @@ function buildHeaders(token, machine) {
     ...machine?.platform ? { "x-machine-platform": machine.platform } : {}
   };
 }
-function joinUrl(base, path12) {
-  return new URL(path12, base.endsWith("/") ? base : `${base}/`).toString();
+function joinUrl(base, path13) {
+  return new URL(path13, base.endsWith("/") ? base : `${base}/`).toString();
 }
 async function postRollupBatch(remote, rollups, options = {}) {
   const response = await remote.fetchImpl(joinUrl(remote.baseUrl, "/v3/agent/ingest"), {
@@ -4473,6 +4405,9 @@ async function deleteMachine(remote, id) {
   return { deletedSessions: Number(body.deletedSessions) || 0 };
 }
 
+// src/lib/types.ts
+var BACKFILL_STATE_SCHEMA_VERSION = 3;
+
 // src/cli.ts
 function createRegistry() {
   const registry = new AdapterRegistry();
@@ -4480,6 +4415,7 @@ function createRegistry() {
   registry.register(createClaudeCodeAdapter());
   registry.register(createPiAdapter());
   registry.register(createOpenCodeAdapter());
+  registry.register(createAmpAdapter());
   return registry;
 }
 var defaultContext = {
@@ -4519,6 +4455,7 @@ ${helpText()}`);
   } catch (error) {
     write(ctx.stderr, `${error.message}
 `);
+    await logError("cli", error, { argv });
     return 1;
   }
 }
@@ -4569,18 +4506,19 @@ function normalizeOptions(options) {
 }
 async function detectCommand(options, ctx, registry) {
   const home = resolveHome(options, ctx);
+  const env = ctx.env;
   const adapters = registry.all();
   const targets = await Promise.all(adapters.map(async (adapter) => {
-    const detected = await pathExists(adapter.detectPath(home));
-    const installed = await adapter.isInstalled(home);
+    const detected = await pathExists(adapter.detectPath(home, env));
+    const installed = await adapter.isInstalled(home, env);
     return {
       id: adapter.id,
       label: adapter.label,
       kind: adapter.kind,
       detected,
       installed,
-      detectPath: adapter.detectPath(home),
-      installedPath: adapter.installedPath(home)
+      detectPath: adapter.detectPath(home, env),
+      installedPath: adapter.installedPath(home, env)
     };
   }));
   if (options.json) {
@@ -4597,6 +4535,7 @@ async function detectCommand(options, ctx, registry) {
 }
 async function installCommand(options, ctx, registry) {
   const home = resolveHome(options, ctx);
+  const env = ctx.env;
   const dryRun = Boolean(options["dry-run"]);
   const force = Boolean(options.force);
   const allAdapters = registry.all();
@@ -4607,17 +4546,17 @@ async function installCommand(options, ctx, registry) {
   }
   const detected = [];
   for (const adapter of allAdapters) {
-    if (await pathExists(adapter.detectPath(home))) {
+    if (await pathExists(adapter.detectPath(home, env))) {
       detected.push(adapter.id);
     }
   }
   const selectedIds = requested.length > 0 ? requested : options.all ? allAdapters.map((a) => a.id) : detected;
   if (selectedIds.length === 0) {
-    write(ctx.stderr, "No supported local targets were detected. Use --target codex,claude,opencode,pi or --all to create them.\n");
+    write(ctx.stderr, "No supported local targets were detected. Use --target codex,claude,opencode,pi,amp or --all to create them.\n");
     return 1;
   }
   for (const adapter of allAdapters.filter((a) => selectedIds.includes(a.id))) {
-    for (const entry of adapter.installEntries(home)) {
+    for (const entry of adapter.installEntries(home, env)) {
       await installEntry(entry, {
         dryRun,
         force,
@@ -4629,21 +4568,30 @@ async function installCommand(options, ctx, registry) {
   return 0;
 }
 async function hookCommand(options, ctx) {
-  const agent = requiredOption(options, "agent");
-  const payload = await readHookPayload(ctx.stdin);
-  const enrichment = await enrichFromTranscript(payload, claudeUsageFromMessage);
-  const events = hookEventsFromPayload(agent, payload, options, enrichment, { tokenUsageFromPayload });
-  assertValidEvents(events);
-  if (options["dry-run"]) {
-    write(ctx.stdout, `${JSON.stringify(events.length === 1 ? events[0] : events, null, 2)}
+  const home = resolveHome(options, ctx);
+  try {
+    const agent = requiredOption(options, "agent");
+    const payload = await readHookPayload(ctx.stdin);
+    if (options["dry-run"]) {
+      write(ctx.stdout, `${JSON.stringify({
+        agent,
+        received: payload,
+        wouldTrigger: "backfill"
+      }, null, 2)}
+`);
+      return 0;
+    }
+    return await syncLocalTriggerCommand({
+      ...options,
+      agent,
+      "min-interval": stringOption(options["min-interval"]) || String(DEFAULT_HOOK_SYNC_MIN_INTERVAL_SECONDS)
+    }, ctx);
+  } catch (error) {
+    await logError("hook", error, { agent: stringOption(options.agent) }, home);
+    debug(ctx, `[codetime] hook failed: ${error.message}
 `);
     return 0;
   }
-  return syncLocalTriggerCommand({
-    ...options,
-    agent,
-    "min-interval": stringOption(options["min-interval"]) || String(DEFAULT_HOOK_SYNC_MIN_INTERVAL_SECONDS)
-  }, ctx);
 }
 async function syncLocalTriggerCommand(options, ctx, _registry) {
   const home = resolveHome(options, ctx);
@@ -4704,6 +4652,9 @@ async function syncLocalRunnerCommand(options, ctx, _registry) {
       source: "all"
     }, ctx);
     return exitCode;
+  } catch (error) {
+    await logError("sync-local-runner", error, { home }, home);
+    throw error;
   } finally {
     const nextState = await readSyncLocalTriggerState(statePath);
     nextState.lastStartedAt = state.lastStartedAt;
@@ -4746,13 +4697,14 @@ async function backfillCommand(options, ctx, registry) {
 }
 async function createBackfillPlanFromOptions(options, ctx, action, registry) {
   const home = resolveHome(options, ctx);
+  const env = ctx.env;
   const source = normalizeBackfillSource(stringOption(options.source) || "all");
-  const sourceDefs = source === "all" ? registry.all().map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home) })) : (() => {
+  const sourceDefs = source === "all" ? registry.all().map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home, env) })) : (() => {
     const adapter = registry.get(source);
     if (!adapter) {
       return [];
     }
-    return [{ id: adapter.id, label: adapter.label, paths: adapter.sourcePaths(home) }];
+    return [{ id: adapter.id, label: adapter.label, paths: adapter.sourcePaths(home, env) }];
   })();
   if (sourceDefs.length === 0) {
     throw new Error(`Unknown backfill source: ${source}`);
@@ -4761,7 +4713,7 @@ async function createBackfillPlanFromOptions(options, ctx, action, registry) {
   const candidates = candidateList.flat();
   let events = [];
   if (action !== "discover") {
-    const eventList = await createBackfillEventsFromDefs(sourceDefs, options, registry);
+    const eventList = await createBackfillEventsFromDefs(sourceDefs, options, registry, ctx);
     events = eventList.flat();
   }
   const plannedEvents = events.map((event) => ({
@@ -4811,21 +4763,36 @@ async function createBackfillPlanFromOptions(options, ctx, action, registry) {
     privacy: "metadata only; prompt text, command text, source code, and diffs are not imported"
   };
 }
-async function createBackfillEventsFromDefs(sourceDefs, options, registry, overrideFiles) {
+async function createBackfillEventsFromDefs(sourceDefs, options, registry, ctx, overrideFiles) {
   const events = [];
+  const home = resolveHome(options, ctx);
   for (const item of sourceDefs) {
     const parser = registry.getParser(item.id);
     if (!parser) {
       continue;
     }
-    const sourceFiles = await listBackfillSourceFiles(item, options);
-    const files = overrideFiles ?? sourceFiles.map((f) => f.path);
+    let files;
+    try {
+      const sourceFiles = await listBackfillSourceFiles(item, options, ctx);
+      files = overrideFiles ?? sourceFiles.map((f) => f.path);
+    } catch (error) {
+      await logError("backfill.listFiles", error, { source: item.id, phase: "plan" }, home);
+      debug(ctx, `[codetime] skip ${item.id} in plan: list files failed: ${error.message}
+`);
+      continue;
+    }
     for (const filePath of files) {
-      const parsed = await parser(filePath, options);
-      for (const event of parsed) {
-        if (matchesBackfillFilters(event, options)) {
-          events.push(event);
+      try {
+        const parsed = await parser(filePath, options);
+        for (const event of parsed) {
+          if (matchesBackfillFilters(event, options)) {
+            events.push(event);
+          }
         }
+      } catch (error) {
+        await logError("backfill.parse", error, { source: item.id, file: filePath, phase: "plan" }, home);
+        debug(ctx, `[codetime] skip ${item.id} file ${filePath} in plan: ${error.message}
+`);
       }
     }
   }
@@ -4846,15 +4813,18 @@ async function createBackfillCandidates(source, options) {
     };
   }));
 }
-async function listBackfillSourceFiles(source, options) {
+async function listBackfillSourceFiles(source, options, ctx) {
   if (source.id === "opencode") {
-    return opencodeBackfillFiles(stringOption(options["source-root"]));
+    return opencodeBackfillFiles(stringOption(options["source-root"]), resolveHome(options, ctx), ctx.env);
+  }
+  if (source.id === "amp") {
+    return ampBackfillFiles(stringOption(options["source-root"]), resolveHome(options, ctx), ctx.env);
   }
   const roots = stringOption(options["source-root"]) ? [requiredOption(options, "source-root")] : source.paths;
   const fileLists = await Promise.all(roots.map((r) => listJsonlFiles(r)));
   const files = fileLists.flat().sort().slice(0, numberOption(options.limit) || void 0);
   return Promise.all(files.map(async (filePath) => {
-    const info = await stat4(filePath);
+    const info = await stat5(filePath);
     return { path: filePath, modifiedAt: info.mtime.toISOString() };
   }));
 }
@@ -4936,119 +4906,142 @@ async function importBackfillPlan(plan, options, ctx, registry) {
     write(ctx.stderr, "Only Codex, Claude Code, OpenCode, and Pi backfill import are implemented.\n");
     return 1;
   }
-  const allAdapters = registry.all();
-  const sourceDefs = allAdapters.filter((a) => supportedSources.has(a.id) && (source === "all" || a.id === source)).map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home) }));
+  const sourceDefs = registry.all().filter((a) => supportedSources.has(a.id) && (source === "all" || a.id === source)).map((a) => ({ id: a.id, label: a.label, paths: a.sourcePaths(home, ctx.env) }));
   if (options.force) {
-    try {
-      await rm(backfillIncrementalStatePath(home), { force: true });
-    } catch {
-    }
-    for (const item of sourceDefs) {
-      try {
-        const deleted = await deleteSessionRollupsBySourceAPI(item.id, options, ctx);
-        if (!options.json) {
-          write(ctx.stdout, `purged ${item.id}: ${deleted} old rollups
-`);
-        }
-      } catch (error) {
-        debug(ctx, `Failed to purge ${item.id} rollups: ${error.message}
-`);
-      }
-    }
+    await purgeForcedSources(sourceDefs, home, options, ctx);
   }
-  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home) : void 0;
-  const selectedFilesBySource = /* @__PURE__ */ new Map();
-  const canonicalEvents = [];
+  const incrementalState = shouldUseIncrementalBackfill(options) ? await readBackfillIncrementalState(home, ctx) : void 0;
   if (!options.json) {
     write(ctx.stdout, `importRun ${plan.importRun.importRunId}
 `);
     write(ctx.stdout, `sources ${sourceDefs.map((s) => s.id).join(", ") || "none"}
 `);
   }
+  const { canonicalEvents, selectedFilesBySource } = await collectCanonicalEvents(
+    sourceDefs,
+    registry,
+    incrementalState,
+    options,
+    ctx
+  );
+  const rollups = buildSessionRollups(canonicalEvents);
+  const counts = await uploadSessionRollups(rollups, canonicalEvents.length, options, ctx);
+  const result = {
+    importRunId: plan.importRun.importRunId,
+    source,
+    planned: rollups.length,
+    sourceEvents: canonicalEvents.length,
+    ...counts
+  };
+  if (options.json) {
+    write(ctx.stdout, `${JSON.stringify(result, null, 2)}
+`);
+  }
+  if (counts.failed === 0 && counts.conflicts === 0 && incrementalState) {
+    await updateBackfillIncrementalState(home, incrementalState, selectedFilesBySource);
+  }
+  return counts.failed > 0 || counts.conflicts > 0 && !options["skip-conflicts"] ? 1 : 0;
+}
+async function purgeForcedSources(sourceDefs, home, options, ctx) {
+  try {
+    await rm(backfillIncrementalStatePath(home), { force: true });
+  } catch (error) {
+    debug(ctx, `Failed to clear backfill watermark: ${error.message}
+`);
+  }
+  for (const item of sourceDefs) {
+    try {
+      const deleted = await deleteSessionRollupsBySourceAPI(item.id, options, ctx);
+      if (!options.json) {
+        write(ctx.stdout, `purged ${item.id}: ${deleted} old rollups
+`);
+      }
+    } catch (error) {
+      debug(ctx, `Failed to purge ${item.id} rollups: ${error.message}
+`);
+    }
+  }
+}
+async function collectCanonicalEvents(sourceDefs, registry, incrementalState, options, ctx) {
+  const selectedFilesBySource = /* @__PURE__ */ new Map();
+  const canonicalEvents = [];
+  const home = resolveHome(options, ctx);
   for (const item of sourceDefs) {
     const parser = registry.getParser(item.id);
     if (!parser) {
       continue;
     }
-    const sourceFiles = await listBackfillSourceFiles(item, options);
-    const selectedFiles = selectBackfillFilesForImport(sourceFiles, incrementalState?.sources[item.id]?.watermarkTs);
+    let selectedFiles;
+    try {
+      const sourceFiles = await listBackfillSourceFiles(item, options, ctx);
+      selectedFiles = selectBackfillFilesForImport(sourceFiles, incrementalState?.sources[item.id]?.watermarkTs);
+    } catch (error) {
+      await logError("backfill.listFiles", error, { source: item.id }, home);
+      debug(ctx, `[codetime] skip ${item.id}: list files failed: ${error.message}
+`);
+      continue;
+    }
     selectedFilesBySource.set(item.id, selectedFiles);
     const filePaths = selectedFiles.map((f) => f.path);
     const sourceEvents = [];
-    if (options.json) {
-      for (const filePath of filePaths) {
-        const parsed = await parser(filePath, options);
-        for (const event of parsed) {
-          if (matchesBackfillFilters(event, options)) {
-            sourceEvents.push(event);
-          }
-        }
-      }
-    } else {
-      const bar = new ProgressBar(ctx.stdout, `${item.id.padEnd(12)}`);
-      bar.init(filePaths.length, `0 events`);
-      for (let fi = 0; fi < filePaths.length; fi += 1) {
+    let sourceFailed = false;
+    const bar = options.json ? void 0 : new ProgressBar(ctx.stdout, `${item.id.padEnd(12)}`);
+    bar?.init(filePaths.length, `0 events`);
+    for (let fi = 0; fi < filePaths.length; fi += 1) {
+      try {
         const parsed = await parser(filePaths[fi], options);
         for (const event of parsed) {
           if (matchesBackfillFilters(event, options)) {
             sourceEvents.push(event);
           }
         }
-        bar.tick(`${fi + 1}/${filePaths.length} files, ${sourceEvents.length} events`);
+      } catch (error) {
+        sourceFailed = true;
+        await logError("backfill.parse", error, { source: item.id, file: filePaths[fi] }, home);
+        debug(ctx, `[codetime] skip ${item.id} file ${filePaths[fi]}: ${error.message}
+`);
       }
-      bar.finalize(`${sourceEvents.length} events`);
+      bar?.tick(`${fi + 1}/${filePaths.length} files, ${sourceEvents.length} events`);
+    }
+    bar?.finalize(`${sourceEvents.length} events${sourceFailed ? " (partial \u2014 see logs)" : ""}`);
+    if (sourceFailed) {
+      selectedFilesBySource.delete(item.id);
     }
     for (const event of sourceEvents) canonicalEvents.push(event);
   }
+  return { canonicalEvents, selectedFilesBySource };
+}
+async function uploadSessionRollups(rollups, eventCount, options, ctx) {
   const counts = { inserted: 0, skipped: 0, conflicts: 0, failed: 0 };
-  const rollups = buildSessionRollups(canonicalEvents);
   const batchSize = Math.max(1, Math.floor(numberOption(options["batch-size"]) || DEFAULT_BACKFILL_BATCH_SIZE));
   const batchBytes = Math.max(64 * 1024, Math.floor(numberOption(options["batch-bytes"]) || DEFAULT_BACKFILL_BATCH_BYTES));
   const batches = packRollupBatches(rollups, batchSize, batchBytes);
   const totalBatches = batches.length;
   let uploadBar;
   if (!options.json) {
-    write(ctx.stdout, `rollup ${rollups.length} from ${canonicalEvents.length} events
+    write(ctx.stdout, `rollup ${rollups.length} from ${eventCount} events
 `);
     uploadBar = new ProgressBar(ctx.stdout, `upload`.padEnd(12));
     uploadBar.init(totalBatches, `0/${totalBatches} batches, 0 inserted`);
   }
-  for (let i = 0; i < batches.length; i += 1) {
-    const batch = batches[i];
+  for (const [i, batch_] of batches.entries()) {
+    const batch = batch_;
     const batchNumber = i + 1;
     try {
-      const result2 = await sendSessionRollupBatch(batch, options, ctx);
-      counts.inserted += result2.inserted;
-      counts.skipped += result2.skipped;
-      counts.conflicts += result2.conflicts;
-      counts.failed += result2.failed;
+      const result = await sendSessionRollupBatch(batch, options, ctx);
+      counts.inserted += result.inserted;
+      counts.skipped += result.skipped;
+      counts.conflicts += result.conflicts;
+      counts.failed += result.failed;
     } catch (error) {
       debug(ctx, `backfill rollup batch ${batchNumber}/${totalBatches} (${batch.length} rollups) failed: ${error.message}
 `);
       counts.failed += batch.length;
     }
-    if (uploadBar) {
-      uploadBar.update(batchNumber, `${batchNumber}/${totalBatches} batches, inserted ${counts.inserted}`);
-    }
-  }
-  if (uploadBar) {
-    uploadBar.finalize(`inserted ${counts.inserted} \xB7 skipped ${counts.skipped}${counts.conflicts ? ` \xB7 conflicts ${counts.conflicts}` : ""}${counts.failed ? ` \xB7 failed ${counts.failed}` : ""}`);
-  }
-  const result = {
-    importRunId: plan.importRun.importRunId,
-    source,
-    planned: rollups.length,
-    sourceEvents: canonicalEvents.length,
-    ...counts
-  };
-  if (options.json) {
-    write(ctx.stdout, `${JSON.stringify(result, null, 2)}
-`);
-  }
-  if (counts.failed === 0 && counts.conflicts === 0 && incrementalState) {
-    await updateBackfillIncrementalState(home, incrementalState, selectedFilesBySource);
+    uploadBar?.update(batchNumber, `${batchNumber}/${totalBatches} batches, inserted ${counts.inserted}`);
   }
-  return counts.failed > 0 || counts.conflicts > 0 && !options["skip-conflicts"] ? 1 : 0;
+  uploadBar?.finalize(`inserted ${counts.inserted} \xB7 skipped ${counts.skipped}${counts.conflicts ? ` \xB7 conflicts ${counts.conflicts}` : ""}${counts.failed ? ` \xB7 failed ${counts.failed}` : ""}`);
+  return counts;
 }
 function backfillVerifyCommand(options, ctx) {
   const importRunId = stringOption(options["import-run"]);
@@ -5072,12 +5065,7 @@ ${result.message}
   return 0;
 }
 async function sendSessionRollupBatch(rollups, options, ctx) {
-  const remote = resolveRemote({
-    apiUrl: stringOption(options["api-url"]),
-    token: stringOption(options.token),
-    env: ctx.env,
-    fetch: ctx.fetch
-  });
+  const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote) {
     throw new Error("No fetch available for HTTP upload");
   }
@@ -5096,12 +5084,7 @@ async function sendSessionRollupBatch(rollups, options, ctx) {
   return result;
 }
 async function deleteSessionRollupsBySourceAPI(source, options, ctx) {
-  const remote = resolveRemote({
-    apiUrl: stringOption(options["api-url"]),
-    token: stringOption(options.token),
-    env: ctx.env,
-    fetch: ctx.fetch
-  });
+  const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote) {
     throw new Error("No fetch available for HTTP delete");
   }
@@ -5130,7 +5113,9 @@ function packRollupBatches(rollups, maxCount, maxBytes) {
     current.push(rollup);
     currentBytes += size;
   }
-  if (current.length > 0) batches.push(current);
+  if (current.length > 0) {
+    batches.push(current);
+  }
   return batches;
 }
 function selectBackfillFilesForImport(files, watermarkTs) {
@@ -5147,27 +5132,42 @@ function selectBackfillFilesForImport(files, watermarkTs) {
   });
 }
 function backfillIncrementalStatePath(home) {
-  return path11.join(home, ".codetime", "backfill-state.json");
+  return path12.join(home, ".codetime", "backfill-state.json");
 }
 function syncLocalTriggerStatePath(home) {
-  return path11.join(home, ".codetime", "sync-local-trigger.json");
+  return path12.join(home, ".codetime", "sync-local-trigger.json");
 }
 function syncLocalTriggerLockPath(home) {
-  return path11.join(home, ".codetime", "sync-local-trigger.lock");
+  return path12.join(home, ".codetime", "sync-local-trigger.lock");
 }
-async function readBackfillIncrementalState(home) {
-  const state = await readJsonIfExists(backfillIncrementalStatePath(home));
+async function readBackfillIncrementalState(home, ctx) {
+  const statePath = backfillIncrementalStatePath(home);
+  const state = await readJsonIfExists(statePath);
+  if (state === null) {
+    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+  }
   if (!isPlainObject(state) || !isPlainObject(state.sources)) {
-    return { version: 1, sources: {} };
+    if (ctx) {
+      debug(ctx, `backfill-state malformed at ${statePath}; ignoring watermarks
+`);
+    }
+    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
+  }
+  if (state.version !== BACKFILL_STATE_SCHEMA_VERSION) {
+    if (ctx) {
+      debug(ctx, `backfill-state version ${String(state.version)} at ${statePath} differs from current v${BACKFILL_STATE_SCHEMA_VERSION}; dropping watermarks so the next sync re-imports under the new parser
+`);
+    }
+    return { version: BACKFILL_STATE_SCHEMA_VERSION, sources: {} };
   }
   const sources = {};
-  for (const source of ["codex", "claude-code", "opencode", "pi"]) {
+  for (const source of ["codex", "claude-code", "opencode", "pi", "amp"]) {
     const item = state.sources[source];
     if (isPlainObject(item) && typeof item.watermarkTs === "string" && !Number.isNaN(Date.parse(item.watermarkTs))) {
       sources[source] = { watermarkTs: item.watermarkTs };
     }
   }
-  return { version: 1, sources };
+  return { version: BACKFILL_STATE_SCHEMA_VERSION, sources };
 }
 async function updateBackfillIncrementalState(home, state, selectedFilesBySource) {
   for (const [source, files] of selectedFilesBySource.entries()) {
@@ -5178,7 +5178,7 @@ async function updateBackfillIncrementalState(home, state, selectedFilesBySource
     state.sources[source] = { watermarkTs: latest };
   }
   const statePath = backfillIncrementalStatePath(home);
-  await mkdir2(path11.dirname(statePath), { recursive: true });
+  await mkdir3(path12.dirname(statePath), { recursive: true });
   await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -5206,7 +5206,7 @@ async function readSyncLocalTriggerState(statePath) {
   return nextState;
 }
 async function writeSyncLocalTriggerState(statePath, state) {
-  await mkdir2(path11.dirname(statePath), { recursive: true });
+  await mkdir3(path12.dirname(statePath), { recursive: true });
   await writeFile2(statePath, `${JSON.stringify(state, null, 2)}
 `, "utf8");
 }
@@ -5221,7 +5221,7 @@ async function readSyncLocalLock(lockPath) {
   return { pid: lock.pid, startedAt: lock.startedAt };
 }
 async function writeSyncLocalLock(lockPath, lock) {
-  await mkdir2(path11.dirname(lockPath), { recursive: true });
+  await mkdir3(path12.dirname(lockPath), { recursive: true });
   await writeFile2(lockPath, `${JSON.stringify(lock, null, 2)}
 `, "utf8");
 }
@@ -5281,10 +5281,10 @@ function syncLocalRunnerEntryArgs(cliPath) {
   if (cliPath.endsWith(".ts")) {
     return ["--import", "tsx", cliPath];
   }
-  return [path11.resolve(path11.dirname(cliPath), "../bin/codetime.mjs")];
+  return [path12.resolve(path12.dirname(cliPath), "../bin/codetime.mjs")];
 }
 function resolveHome(options, ctx) {
-  return path11.resolve(stringOption(options.home) || ctx.env.HOME || os3.homedir());
+  return path12.resolve(stringOption(options.home) || ctx.env.HOME || os3.homedir());
 }
 function requestedTargets(options) {
   const value = options.target || options.targets;
@@ -5303,15 +5303,6 @@ function requiredOption(options, name) {
   }
   return value;
 }
-function assertValidEvent(event) {
-  const validation = validateCanonicalEvent(event);
-  if (!validation.valid) {
-    throw new Error(`Invalid event: ${validation.errors.join("; ")}`);
-  }
-}
-function assertValidEvents(events) {
-  for (const event of events) assertValidEvent(event);
-}
 async function readHookPayload(stdin) {
   const text = await readAll(stdin);
   if (!text.trim()) {
@@ -5339,6 +5330,15 @@ function debug(ctx, message) {
     write(ctx.stderr, message);
   }
 }
+function resolveRemoteFromOptions(options, ctx) {
+  return resolveRemote({
+    apiUrl: stringOption(options["api-url"]),
+    token: stringOption(options.token),
+    env: ctx.env,
+    fetch: ctx.fetch,
+    homeOverride: stringOption(options.home)
+  });
+}
 function maskToken(token) {
   if (token.length <= 8) {
     return "***";
@@ -5399,12 +5399,7 @@ Usage: codetime token [set <token>|show|clear] [--remote <url>]
   return 1;
 }
 async function machineCommand(action, options, ctx) {
-  const remote = resolveRemote({
-    apiUrl: stringOption(options["api-url"]),
-    token: stringOption(options.token),
-    env: ctx.env,
-    fetch: ctx.fetch
-  });
+  const remote = resolveRemoteFromOptions(options, ctx);
   if (!remote || !remote.token) {
     write(ctx.stderr, "machine command requires login (run `codetime login`).\n");
     return 1;
@@ -5485,14 +5480,11 @@ Global options:
   --token <token>   Bearer token for this invocation (overrides config).
 
 Token precedence (highest first):
-  --token flag  >  CODETIME_AGENT_TOKEN env  >  AGENT_TIME_API_TOKEN env
-  (legacy alias)  >  saved config (~/.codetime/config.json).
+  --token flag  >  CODETIME_TOKEN env  >  saved config (~/.codetime/config.json).
 
 Environment:
   CODETIME_API_URL        Defaults to ${DEFAULT_API_URL}
-  CODETIME_AGENT_TOKEN    Bearer token for the API
-  AGENT_TIME_API_URL      Legacy alias for CODETIME_API_URL
-  AGENT_TIME_API_TOKEN    Legacy alias for CODETIME_AGENT_TOKEN
+  CODETIME_TOKEN          Bearer token for the API
 `;
 }
 export {