agentel 0.2.5 → 0.2.8

package/src/config.js

@@ -45,6 +45,7 @@ function defaultConfig(env = process.env) {
     },
     imports: {
       defaultSinceDays: 30,
+      updateSince: "",
       sources: IMPORT_SOURCE_ORDER,
       autoDiscoverSources: true
     },
@@ -246,6 +247,7 @@ function parseConfigValue(value) {
 function normalizeConfigKeyValue(key, value) {
   if (key === "imports.sources") return normalizeImportSources(value);
   if (key === "imports.defaultSinceDays") return normalizeNonNegativeInteger(value, 30);
+  if (key === "imports.updateSince") return normalizeImportSinceValue(value);
   if (key === "sync.intervalMinutes" || key === "index.intervalMinutes" || key === "index.batteryIntervalMinutes") {
     return normalizeSyncInterval(value);
   }
@@ -253,6 +255,15 @@ function normalizeConfigKeyValue(key, value) {
   return value;
 }
 
+function normalizeImportSinceValue(value) {
+  const text = String(value || "").trim().toLowerCase();
+  if (!text) return "";
+  if (text === "all") return "all";
+  const match = text.match(/^(\d+)([dhm])$/);
+  if (!match) return text;
+  return `${Math.max(1, Math.round(Number(match[1])))}${match[2]}`;
+}
+
 function normalizeImportSources(value) {
   const raw = Array.isArray(value)
     ? value

package/src/doctor.js

@@ -59,6 +59,7 @@ function sourceCoverage(discovery, cfg) {
   const rows = [
     coverageRow("codex-cli", "Codex CLI", discovery.codexCli, configured),
     coverageRow("codex-desktop", "Codex Desktop", discovery.codexDesktop, configured),
+    coverageRow("codex-sdk", "Codex SDK jobs", discovery.codexSdk, configured),
     coverageRow("claude", "Claude Code CLI", discovery.claude, configured),
     coverageRow("claude-code-desktop", "Claude Code Desktop", discovery.claudeCodeDesktop, configured),
     coverageRow("claude-workspace", "Claude Workspace", discovery.claudeWorkspace, configured),
@@ -194,6 +195,7 @@ function parserUpdateCommand(sourceType) {
   const source = {
     "codex-cli-history": "codex-cli",
     "codex-desktop-history": "codex-desktop",
+    "codex-sdk-history": "codex-sdk",
     "cli-history": "claude",
     "claude-sdk-history": "claude-sdk",
     "claude-code-desktop-metadata": "claude-code-desktop",

package/src/importers/claude.js

@@ -17,6 +17,9 @@ function extractClaudeMessagesFromEvent(event, provider, context = {}) {
   const role = normalizeRole(message.role || event.role || type);
   const timestamp = eventTimestamp(event);
 
+  const remoteMessages = remoteControlLifecycleMessages(event, provider, context, type, timestamp);
+  if (remoteMessages.length) return remoteMessages;
+
   if (type === "summary" || event.summary) {
     const content = firstString(event.summary, message.summary);
     return content ? [supplementaryMessage(provider, "Claude summary", content, timestamp, "summary")] : [];
@@ -34,9 +37,12 @@ function assistantMessages(event, message, provider, context, timestamp, content
   const text = visibleText(content);
   const thinking = thinkingText(content);
   const toolCalls = toolUseParts(content).map((part) => normalizeToolCall(part, provider)).filter(Boolean);
+  rememberToolCalls(context, toolCalls);
+  const eventMetadata = claudeEventMetadata(event);
   const metadata = {
     provider,
     eventType: firstString(event.type, event.kind),
+    ...eventMetadata,
     model: firstString(message.model, event.model, context.model) || undefined,
     requestId: firstString(event.requestId, event.request_id, message.id) || undefined,
     status: firstString(message.stop_reason, event.stop_reason, event.status) || undefined,
@@ -51,7 +57,8 @@ function assistantMessages(event, message, provider, context, timestamp, content
 
 function userMessages(event, message, provider, context, timestamp, content) {
   const text = visibleText(content);
-  const toolResults = toolResultParts(content).map((part) => normalizeToolResult(part, provider, event.toolUseResult)).filter(Boolean);
+  const eventMetadata = claudeEventMetadata(event);
+  const toolResults = toolResultParts(content).map((part) => normalizeToolResult(part, provider, event, context)).filter(Boolean);
   const result = [];
   if (text) {
     result.push({
@@ -61,6 +68,7 @@ function userMessages(event, message, provider, context, timestamp, content) {
       metadata: {
         provider,
         eventType: firstString(event.type, event.kind),
+        ...eventMetadata,
         model: firstString(message.model, event.model, context.model) || undefined
       }
     });
@@ -74,6 +82,7 @@ function userMessages(event, message, provider, context, timestamp, content) {
       metadata: {
         provider,
         eventType: "claude-tool-result",
+        ...eventMetadata,
         toolResult
       }
     });
@@ -81,6 +90,49 @@ function userMessages(event, message, provider, context, timestamp, content) {
   return result;
 }
 
+function claudeEventMetadata(event) {
+  return compactMetadata({
+    uuid: firstString(event.uuid),
+    parentUuid: firstString(event.parentUuid, event.parent_uuid),
+    logicalParentUuid: firstString(event.logicalParentUuid, event.logical_parent_uuid),
+    leafUuid: firstString(event.leafUuid, event.leaf_uuid),
+    promptId: firstString(event.promptId, event.prompt_id),
+    sourceToolAssistantUUID: firstString(event.sourceToolAssistantUUID, event.source_tool_assistant_uuid),
+    sourceToolUseID: firstString(event.sourceToolUseID, event.source_tool_use_id),
+    parentToolUseID: firstString(event.parentToolUseID, event.parent_tool_use_id),
+    toolUseID: firstString(event.toolUseID, event.tool_use_id),
+    isSidechain: typeof event.isSidechain === "boolean" ? event.isSidechain : undefined,
+    isVisibleInTranscriptOnly: typeof event.isVisibleInTranscriptOnly === "boolean" ? event.isVisibleInTranscriptOnly : undefined,
+    isCompactSummary: typeof event.isCompactSummary === "boolean" ? event.isCompactSummary : undefined,
+    userType: firstString(event.userType, event.user_type),
+    entrypoint: firstString(event.entrypoint),
+    claudeCodeVersion: firstString(event.version),
+    gitBranch: firstString(event.gitBranch, event.git_branch),
+    permissionMode: firstString(event.permissionMode, event.permission_mode),
+    agentId: firstString(event.agentId, event.agent_id),
+    slug: firstString(event.slug),
+    attributionSkill: firstString(event.attributionSkill, event.attribution_skill),
+    origin: firstString(event.origin),
+    mcpMeta: event.mcpMeta && typeof event.mcpMeta === "object" ? event.mcpMeta : undefined,
+    compactMetadata: event.compactMetadata && typeof event.compactMetadata === "object" ? event.compactMetadata : undefined,
+    apiError: claudeApiErrorMetadata(event) || undefined
+  }) || {};
+}
+
+function claudeApiErrorMetadata(event) {
+  if (!event || typeof event !== "object") return null;
+  if (event.isApiErrorMessage !== true && !event.error && event.apiErrorStatus == null) return null;
+  return compactMetadata({
+    isApiErrorMessage: event.isApiErrorMessage === true ? true : undefined,
+    status: numberValue(event.apiErrorStatus, event.api_error_status) ?? undefined,
+    type: firstString(event.error) || undefined,
+    retryAttempt: numberValue(event.retryAttempt, event.retry_attempt) ?? undefined,
+    maxRetries: numberValue(event.maxRetries, event.max_retries) ?? undefined,
+    retryInMs: numberValue(event.retryInMs, event.retry_in_ms) ?? undefined,
+    cause: firstString(event.cause?.message, event.cause) || undefined
+  });
+}
+
 function supplementaryMessage(provider, title, content, timestamp, summaryKind, model = "") {
   return {
     role: "assistant",
@@ -96,6 +148,209 @@ function supplementaryMessage(provider, title, content, timestamp, summaryKind,
   };
 }
 
+function remoteControlLifecycleMessages(event, provider, context, type, timestamp) {
+  if (!isClaudeRemoteControlSession(context)) return [];
+  if (type === "user" || type === "assistant" || type === "summary") return [];
+  if (type === "queue-operation") return [remoteQueueMessage(event, provider, timestamp)];
+  if (type === "attachment") return [remoteAttachmentMessage(event, provider, timestamp)].filter(Boolean);
+  if (type === "progress") return [remoteProgressMessage(event, provider, timestamp)];
+  if (type === "system") return [remoteSystemMessage(event, provider, timestamp)];
+  if (type === "permission-mode") return [remotePermissionModeMessage(event, provider, timestamp)].filter(Boolean);
+  if (type === "file-history-snapshot") return [remoteFileHistorySnapshotMessage(event, provider, timestamp)];
+  return [];
+}
+
+function isClaudeRemoteControlSession(context) {
+  return context?.claudeJsonl?.remoteControl === true;
+}
+
+function remoteQueueMessage(event, provider, timestamp) {
+  const operation = firstString(event.operation, "operation").toLowerCase();
+  const content = firstString(event.content);
+  const label = operation ? operation.replace(/_/g, " ") : "operation";
+  const suffix = content ? `: ${previewText(content, 240)}` : "";
+  return remoteContextMessage(provider, event, timestamp, "remote_control_queue", `Remote Control queue ${label}${suffix}`, {
+    queueOperation: operation || undefined,
+    queueContent: content || undefined
+  });
+}
+
+function remoteAttachmentMessage(event, provider, timestamp) {
+  const attachment = event.attachment && typeof event.attachment === "object" ? event.attachment : {};
+  const metadata = normalizeRemoteAttachment(attachment);
+  if (!metadata) return null;
+  return remoteContextMessage(provider, event, timestamp, remoteAttachmentContextKind(metadata.type), remoteAttachmentText(metadata), {
+    attachment: metadata
+  });
+}
+
+function remoteProgressMessage(event, provider, timestamp) {
+  const data = event.data && typeof event.data === "object" ? event.data : {};
+  const hookName = firstString(data.hookName, data.hook_name);
+  const hookEvent = firstString(data.hookEvent, data.hook_event);
+  const progressType = firstString(data.type);
+  const label = firstString(hookName, hookEvent, progressType, "progress");
+  return remoteContextMessage(provider, event, timestamp, "remote_control_progress", `Remote Control progress: ${label}`, {
+    progress: compactMetadata({
+      type: progressType || undefined,
+      hookEvent: hookEvent || undefined,
+      hookName: hookName || undefined,
+      command: firstString(data.command) || undefined,
+      parentToolUseID: firstString(event.parentToolUseID, event.parent_tool_use_id) || undefined,
+      toolUseID: firstString(event.toolUseID, event.tool_use_id) || undefined
+    })
+  });
+}
+
+function remoteSystemMessage(event, provider, timestamp) {
+  const subtype = firstString(event.subtype, event.kind, "system");
+  const hookCount = numberValue(event.hookCount, event.hook_count);
+  const hookErrors = Array.isArray(event.hookErrors) ? event.hookErrors : [];
+  const body = subtype === "stop_hook_summary"
+    ? `Remote Control stop hook summary: ${hookCount ?? 0} ${plural("hook", hookCount ?? 0)}${hookErrors.length ? `, ${hookErrors.length} ${plural("error", hookErrors.length)}` : ""}`
+    : `Remote Control system event: ${subtype}`;
+  return remoteContextMessage(provider, event, timestamp, "remote_control_system", body, {
+    system: compactMetadata({
+      subtype,
+      hookCount: hookCount ?? undefined,
+      hookInfos: Array.isArray(event.hookInfos) ? event.hookInfos.map((hook) => compactMetadata({ command: firstString(hook?.command) || undefined })).filter(Boolean) : undefined,
+      hookErrors: hookErrors.length ? hookErrors : undefined,
+      preventedContinuation: typeof event.preventedContinuation === "boolean" ? event.preventedContinuation : undefined,
+      stopReason: firstString(event.stopReason, event.stop_reason) || undefined,
+      hasOutput: typeof event.hasOutput === "boolean" ? event.hasOutput : undefined,
+      level: firstString(event.level) || undefined
+    })
+  });
+}
+
+function remotePermissionModeMessage(event, provider, timestamp) {
+  if (!timestamp) return null;
+  const permissionMode = firstString(event.permissionMode, event.permission_mode, "unknown");
+  return remoteContextMessage(provider, event, timestamp, "remote_control_permission", `Remote Control permission mode: ${permissionMode}`, {
+    permissionMode
+  });
+}
+
+function remoteFileHistorySnapshotMessage(event, provider, timestamp) {
+  const snapshot = event.snapshot && typeof event.snapshot === "object" ? event.snapshot : {};
+  const snapshotTimestamp = timestamp || eventTimestamp(snapshot);
+  const backups = snapshot.trackedFileBackups && typeof snapshot.trackedFileBackups === "object" ? snapshot.trackedFileBackups : {};
+  const paths = Object.keys(backups).sort();
+  const action = event.isSnapshotUpdate ? "updated" : "recorded";
+  const target = paths.length ? `: ${namesPreview(paths)}` : "";
+  return remoteContextMessage(provider, event, snapshotTimestamp, "remote_control_file_history", `Remote Control file history snapshot ${action}${target}`, {
+    fileHistorySnapshot: compactMetadata({
+      messageId: firstString(event.messageId, event.message_id, snapshot.messageId, snapshot.message_id) || undefined,
+      isSnapshotUpdate: typeof event.isSnapshotUpdate === "boolean" ? event.isSnapshotUpdate : undefined,
+      timestamp: snapshotTimestamp || undefined,
+      backupFileCount: paths.length || undefined,
+      paths: paths.length ? paths : undefined
+    })
+  });
+}
+
+function remoteContextMessage(provider, event, timestamp, contextKind, content, extraMetadata = {}) {
+  return {
+    role: "system",
+    content,
+    timestamp,
+    metadata: compactMetadata({
+      provider,
+      eventType: firstString(event.type, event.kind),
+      ...claudeEventMetadata(event),
+      providerGenerated: true,
+      contextKind,
+      contextSource: "claude-remote-control",
+      ...extraMetadata
+    })
+  };
+}
+
+function normalizeRemoteAttachment(attachment) {
+  const type = firstString(attachment.type);
+  if (!type) return null;
+  const content = attachment.content && typeof attachment.content === "object" ? attachment.content : {};
+  const text = firstString(content.content, attachment.content);
+  return compactMetadata({
+    type,
+    addedNames: asStringArray(attachment.addedNames),
+    removedNames: asStringArray(attachment.removedNames),
+    path: firstString(attachment.path, content.path) || undefined,
+    displayPath: firstString(attachment.displayPath, attachment.display_path) || undefined,
+    prompt: previewText(firstString(attachment.prompt), 500) || undefined,
+    commandMode: firstString(attachment.commandMode, attachment.command_mode) || undefined,
+    allowedTools: asStringArray(attachment.allowedTools),
+    newDate: firstString(attachment.newDate, attachment.new_date) || undefined,
+    itemCount: numberValue(attachment.itemCount, attachment.item_count) ?? undefined,
+    maxTurns: numberValue(attachment.maxTurns, attachment.max_turns) ?? undefined,
+    turnCount: numberValue(attachment.turnCount, attachment.turn_count) ?? undefined,
+    contentType: firstString(content.type) || undefined,
+    contentPath: firstString(content.path) || undefined,
+    contentDiffersFromDisk: typeof content.contentDiffersFromDisk === "boolean" ? content.contentDiffersFromDisk : undefined,
+    contentPreview: text ? previewText(text, 240) : undefined
+  });
+}
+
+function remoteAttachmentContextKind(type) {
+  return `remote_control_${String(type || "attachment").replace(/[^a-z0-9]+/gi, "_").replace(/^_+|_+$/g, "").toLowerCase() || "attachment"}`;
+}
+
+function remoteAttachmentText(metadata) {
+  const type = metadata.type;
+  if (type === "deferred_tools_delta") {
+    const names = [...(metadata.addedNames || []), ...(metadata.removedNames || [])];
+    return names.length ? `Remote Control tools updated: ${namesPreview(names)}` : "Remote Control tools updated";
+  }
+  if (type === "mcp_instructions_delta") {
+    return metadata.addedNames?.length ? `Remote Control MCP instructions updated: ${namesPreview(metadata.addedNames)}` : "Remote Control MCP instructions updated";
+  }
+  if (type === "skill_listing") {
+    return metadata.addedNames?.length ? `Remote Control skills available: ${namesPreview(metadata.addedNames)}` : "Remote Control skills updated";
+  }
+  if (type === "nested_memory") {
+    return `Remote Control memory loaded: ${firstString(metadata.displayPath, metadata.path, metadata.contentPath, "memory")}`;
+  }
+  if (type === "queued_command") {
+    return metadata.prompt ? `Remote Control queued command: ${metadata.prompt}` : "Remote Control queued command";
+  }
+  if (type === "command_permissions") {
+    return metadata.allowedTools?.length ? `Remote Control command permissions: ${namesPreview(metadata.allowedTools)}` : "Remote Control command permissions updated";
+  }
+  if (type === "edited_text_file") {
+    return `Remote Control edited text file: ${firstString(metadata.displayPath, metadata.path, metadata.contentPath, "file")}`;
+  }
+  if (type === "date_change") {
+    return metadata.newDate ? `Remote Control date changed: ${metadata.newDate}` : "Remote Control date changed";
+  }
+  if (type === "max_turns_reached") {
+    return `Remote Control max turns reached: ${metadata.turnCount ?? 0}/${metadata.maxTurns ?? 0}`;
+  }
+  if (type === "compact_file_reference") {
+    return `Remote Control compact file reference: ${firstString(metadata.displayPath, metadata.path, "file")}`;
+  }
+  if (type === "task_reminder" || type === "todo_reminder") {
+    return `Remote Control ${type.replace(/_/g, " ")}: ${metadata.itemCount ?? 0} ${plural("item", metadata.itemCount ?? 0)}`;
+  }
+  return `Remote Control attachment: ${type.replace(/_/g, " ")}`;
+}
+
+function namesPreview(names, limit = 8) {
+  const values = asStringArray(names);
+  const visible = values.slice(0, limit).join(", ");
+  const remaining = values.length - limit;
+  return remaining > 0 ? `${visible}, +${remaining} more` : visible;
+}
+
+function previewText(value, max = 240) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  if (!text) return "";
+  return text.length > max ? `${text.slice(0, max - 3).trimEnd()}...` : text;
+}
+
+function plural(word, count) {
+  return count === 1 ? word : `${word}s`;
+}
+
 function toolUseParts(content) {
   return arrayContent(content).filter((part) => {
     const type = String(part?.type || part?.kind || "").toLowerCase();
@@ -137,6 +392,14 @@ function thinkingText(content) {
     .trim();
 }
 
+function rememberToolCalls(context, toolCalls) {
+  if (!context || !toolCalls.length) return;
+  if (!context.claudeToolNamesById) context.claudeToolNamesById = new Map();
+  for (const call of toolCalls) {
+    if (call.id && call.name) context.claudeToolNamesById.set(call.id, call.name);
+  }
+}
+
 function normalizeToolCall(part, provider) {
   const rawName = firstString(part.name, part.tool_name, part.toolName, part.function?.name, "tool");
   const rawArgs = parseArgs(part.input ?? part.arguments ?? part.args ?? part.function?.arguments);
@@ -170,14 +433,16 @@ function normalizeToolCall(part, provider) {
   };
 }
 
-function normalizeToolResult(part, provider, eventToolUseResult) {
-  const output = extractToolResultOutput(part, eventToolUseResult);
+function normalizeToolResult(part, provider, event, context = {}) {
+  const output = extractToolResultOutput(part, event?.toolUseResult);
   if (!output) return null;
-  const name = firstString(part.name, part.tool_name, part.toolName, part.tool_use_id, "Tool output");
+  const id = firstString(part.tool_use_id, part.id, part.call_id, part.callId);
+  const name = firstString(part.name, part.tool_name, part.toolName, id ? context.claudeToolNamesById?.get(id) : "", "Tool output");
   const category = toolCategory(name, part.type);
-  return {
+  return compactMetadata({
     provider,
-    id: firstString(part.tool_use_id, part.id, part.call_id, part.callId) || undefined,
+    id: id || undefined,
+    name,
     kind: displayName(name),
     title: part.is_error ? "Tool error" : "Tool result",
     rawCategory: firstString(part.type, part.kind) || undefined,
@@ -187,8 +452,10 @@ function normalizeToolResult(part, provider, eventToolUseResult) {
     output,
     lineCount: output.split("\n").length,
     collapsed: output.split("\n").length > 18,
-    status: part.is_error ? "error" : "completed"
-  };
+    status: part.is_error ? "error" : "completed",
+    sourceToolUseID: firstString(event?.sourceToolUseID, event?.source_tool_use_id) || undefined,
+    structuredContent: event?.mcpMeta?.structuredContent && typeof event.mcpMeta.structuredContent === "object" ? event.mcpMeta.structuredContent : undefined
+  });
 }
 
 function extractToolResultOutput(part, eventToolUseResult) {
@@ -204,13 +471,27 @@ function claudeUsage(usage) {
   const cacheCreation = numberValue(usage.cache_creation_input_tokens, usage.cacheCreationInputTokens);
   const cacheRead = numberValue(usage.cache_read_input_tokens, usage.cacheReadInputTokens);
   if ([input, output, cacheCreation, cacheRead].every((value) => value == null)) return null;
-  return {
+  const serverToolUse = compactMetadata({
+    webSearchRequests: numberValue(usage.server_tool_use?.web_search_requests, usage.serverToolUse?.webSearchRequests),
+    webFetchRequests: numberValue(usage.server_tool_use?.web_fetch_requests, usage.serverToolUse?.webFetchRequests)
+  });
+  const cacheCreationDetails = compactMetadata({
+    ephemeral1hInputTokens: numberValue(usage.cache_creation?.ephemeral_1h_input_tokens, usage.cacheCreation?.ephemeral1hInputTokens),
+    ephemeral5mInputTokens: numberValue(usage.cache_creation?.ephemeral_5m_input_tokens, usage.cacheCreation?.ephemeral5mInputTokens)
+  });
+  return compactMetadata({
     inputTokens: input ?? undefined,
     outputTokens: output ?? undefined,
     cacheCreationInputTokens: cacheCreation ?? undefined,
     cacheReadInputTokens: cacheRead ?? undefined,
-    totalTokens: [input, output, cacheCreation, cacheRead].reduce((sum, value) => sum + (value || 0), 0)
-  };
+    totalTokens: [input, output, cacheCreation, cacheRead].reduce((sum, value) => sum + (value || 0), 0),
+    serviceTier: firstString(usage.service_tier, usage.serviceTier) || undefined,
+    speed: firstString(usage.speed) || undefined,
+    inferenceGeo: firstString(usage.inference_geo, usage.inferenceGeo) || undefined,
+    serverToolUse: serverToolUse || undefined,
+    cacheCreation: cacheCreationDetails || undefined,
+    iterationCount: Array.isArray(usage.iterations) ? usage.iterations.length : undefined
+  });
 }
 
 function extractText(value, depth = 0) {
@@ -328,6 +609,11 @@ function numberValue(...values) {
   return null;
 }
 
+function asStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.trim()).map((item) => item.trim());
+}
+
 function firstString(...values) {
   for (const value of values) {
     if (typeof value === "string" && value.trim()) return value.trim();
@@ -339,6 +625,18 @@ function firstLine(value) {
   return String(value || "").split(/\r?\n/).find((line) => line.trim())?.trim() || "";
 }
 
+function compactMetadata(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return value || null;
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (item === undefined || item === null || item === "") continue;
+    if (Array.isArray(item) && !item.length) continue;
+    if (item && typeof item === "object" && !Array.isArray(item) && !Object.keys(item).length) continue;
+    result[key] = item;
+  }
+  return Object.keys(result).length ? result : null;
+}
+
 function isClaudeProvider(provider) {
   return provider === "claude_code" || provider === "claude_sdk" || provider === "claude_desktop";
 }

package/src/importers/gemini.js

@@ -607,6 +607,7 @@ function geminiUsage(value) {
     totalTokens,
     thoughtsTokens,
     cacheReadTokens,
+    cacheReadTokensIncludedInInput: cacheReadTokens ? true : undefined,
     toolUsePromptTokens
   });
   return Object.keys(normalized).length ? normalized : null;
@@ -880,7 +881,7 @@ function geminiSessionSummaryUsage(summary) {
     cacheInputTokens += numberValue(model.cacheReadTokens) || 0;
   }
   if (!inputTokens && !outputTokens && !cacheInputTokens) return null;
-  return { inputTokens, outputTokens, cacheInputTokens, totalTokens: inputTokens + outputTokens };
+  return { inputTokens, outputTokens, cacheInputTokens, cacheInputTokensIncludedInInput: cacheInputTokens ? true : undefined, totalTokens: inputTokens + outputTokens };
 }
 
 function mergeGeminiSessionSummaries(summaries) {

package/src/importers/providers.js

@@ -23,6 +23,21 @@ const PROVIDER_ADAPTERS = [
     run: ({ helpers, since, options, env }) =>
       helpers.importCodexProvider("codex", since, { ...options, codexSource: "vscode" }, env)
   },
+  {
+    source: "codex-sdk",
+    provider: "codex",
+    sourceType: "codex-sdk-history",
+    label: "Codex SDK jobs",
+    run: ({ helpers, since, options, env }) =>
+      helpers.importCodexProvider("codex", since, { ...options, codexSource: "exec" }, env)
+  },
+  {
+    source: "chatgpt",
+    provider: "chatgpt",
+    label: "ChatGPT",
+    manual: true,
+    run: ({ helpers }) => helpers.manualImportInstructionResult("chatgpt")
+  },
   {
     source: "claude",
     provider: "claude_code",
@@ -59,6 +74,13 @@ const PROVIDER_ADAPTERS = [
     run: ({ helpers, since, options, env }) =>
       helpers.importClaudeDesktopProvider("claude_desktop", since, { ...options, claudeDesktopKind: "claude-workspace-desktop" }, env)
   },
+  {
+    source: "claude-web",
+    provider: "claude_web",
+    label: "Claude.ai",
+    manual: true,
+    run: ({ helpers }) => helpers.manualImportInstructionResult("claude-web")
+  },
   {
     source: "cursor",
     provider: "cursor",