@fml-inc/fml 0.0.30 → 0.1.1

package/dist/doctor-YV6KQEGW.js

@@ -1,2019 +0,0 @@
-import {
-  closeDb,
-  config,
-  getDb,
-  loadUnifiedConfig,
-  readWatermark,
-  watermarkKey
-} from "./chunk-NLFKYSN7.js";
-import "./chunk-UALBZA5X.js";
-import "./chunk-2CRFCFE4.js";
-import "./chunk-PZ5AY32C.js";
-
-// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-QVK6VGCV.js
-import fs2 from "fs";
-import os from "os";
-import path from "path";
-import fs from "fs";
-import fs3 from "fs";
-import os2 from "os";
-import path2 from "path";
-import fs4 from "fs";
-import os3 from "os";
-import path3 from "path";
-var targets = /* @__PURE__ */ new Map();
-function registerTarget(adapter) {
-  if (targets.has(adapter.id)) {
-    throw new Error(`Target "${adapter.id}" is already registered`);
-  }
-  targets.set(adapter.id, adapter);
-}
-function allTargets() {
-  return [...targets.values()];
-}
-function defaultToolCategory(_toolName) {
-  return "";
-}
-function readNewLines(filePath, fromByteOffset) {
-  let fd;
-  try {
-    fd = fs.openSync(filePath, "r");
-  } catch {
-    return { lines: [], newByteOffset: fromByteOffset };
-  }
-  try {
-    const size = fs.fstatSync(fd).size;
-    if (size <= fromByteOffset) {
-      return { lines: [], newByteOffset: fromByteOffset };
-    }
-    const bytesToRead = size - fromByteOffset;
-    const buf = Buffer.alloc(bytesToRead);
-    fs.readSync(fd, buf, 0, bytesToRead, fromByteOffset);
-    const text = buf.toString("utf-8");
-    const lastNewline = text.lastIndexOf("\n");
-    if (lastNewline === -1) {
-      return { lines: [], newByteOffset: fromByteOffset };
-    }
-    const complete = text.slice(0, lastNewline);
-    const lines = complete.split("\n").filter((l) => l.length > 0);
-    const bytesConsumed = Buffer.byteLength(
-      text.slice(0, lastNewline + 1),
-      "utf-8"
-    );
-    return {
-      lines,
-      newByteOffset: fromByteOffset + bytesConsumed
-    };
-  } finally {
-    fs.closeSync(fd);
-  }
-}
-var CLAUDE_TOOL_CATEGORIES = {
-  Read: "Read",
-  read_file: "Read",
-  ReadNotebook: "Read",
-  Edit: "Edit",
-  StrReplace: "Edit",
-  MultiEdit: "Edit",
-  Write: "Write",
-  create_file: "Write",
-  NotebookEdit: "Write",
-  Bash: "Bash",
-  Grep: "Grep",
-  Glob: "Glob",
-  list_dir: "Glob",
-  Task: "Task",
-  Agent: "Task",
-  TaskCreate: "Task",
-  TaskUpdate: "Task",
-  Skill: "Tool",
-  WebSearch: "Web",
-  WebFetch: "Web",
-  ToolSearch: "Web"
-};
-function claudeToolCategory(toolName) {
-  const mapped = CLAUDE_TOOL_CATEGORIES[toolName];
-  if (mapped) return mapped;
-  if (toolName.startsWith("mcp__")) return "MCP";
-  if (toolName.toLowerCase().includes("subagent")) return "Task";
-  return defaultToolCategory(toolName);
-}
-var SYSTEM_MESSAGE_PREFIXES = [
-  "This session is being continued",
-  "[Request interrupted",
-  "<task-notification>",
-  "<local-command-",
-  "Stop hook feedback:"
-];
-function isSystemMessage(content) {
-  const trimmed = content.trimStart();
-  return SYSTEM_MESSAGE_PREFIXES.some((p) => trimmed.startsWith(p));
-}
-var CMD_NAME_RE = /<command-name>([^<]+)<\/command-name>/;
-var CMD_ARGS_RE = /<command-args>([^<]*)<\/command-args>/;
-var CMD_MSG_RE = /<command-message>([^<]+)<\/command-message>/;
-var CMD_STRIP_RE = /<\/?(?:command-name|command-message|command-args)>[^<]*<\/(?:command-name|command-message|command-args)>|<\/?(?:command-name|command-message|command-args)>/g;
-function extractCommandText(content) {
-  const trimmed = content.replace(/^\uFEFF/, "").trimStart();
-  if (!trimmed.startsWith("<command-message>") && !trimmed.startsWith("<command-name>")) {
-    return [content, false];
-  }
-  const stripped = trimmed.replace(CMD_STRIP_RE, "");
-  if (stripped.trim() !== "") {
-    return [content, false];
-  }
-  const nameMatch = CMD_NAME_RE.exec(content);
-  if (!nameMatch) {
-    const msgMatch = CMD_MSG_RE.exec(content);
-    if (msgMatch) return [`/${msgMatch[1]}`, true];
-    return [content, false];
-  }
-  let name = nameMatch[1];
-  if (!name.startsWith("/")) name = `/${name}`;
-  const argsMatch = CMD_ARGS_RE.exec(content);
-  const args = argsMatch?.[1]?.trim();
-  return [args ? `${name} ${args}` : name, true];
-}
-function extractToolResultTextLength(content) {
-  if (typeof content === "string") return content.length;
-  if (Array.isArray(content)) {
-    let len = 0;
-    for (const b of content) {
-      if (typeof b === "object" && b !== null && b.type === "text") {
-        const text = b.text;
-        if (typeof text === "string") len += text.length;
-      }
-    }
-    return len;
-  }
-  return 0;
-}
-var FORK_THRESHOLD = 3;
-function hasDAGFork(entries) {
-  for (let i = 1; i < entries.length; i++) {
-    if (entries[i].parentUuid !== entries[i - 1].uuid) return true;
-  }
-  return false;
-}
-function detectForks(entries, sessionId) {
-  const children = /* @__PURE__ */ new Map();
-  const roots = [];
-  const uuidSet = /* @__PURE__ */ new Set();
-  for (let i = 0; i < entries.length; i++) {
-    const e = entries[i];
-    uuidSet.add(e.uuid);
-    if (!e.parentUuid) {
-      roots.push(i);
-    } else {
-      const kids = children.get(e.parentUuid) ?? [];
-      kids.push(i);
-      children.set(e.parentUuid, kids);
-    }
-  }
-  if (roots.length !== 1) {
-    return { mainDagIndices: entries.map((_, i) => i), forkBranches: [] };
-  }
-  for (const e of entries) {
-    if (e.parentUuid && !uuidSet.has(e.parentUuid)) {
-      return { mainDagIndices: entries.map((_, i) => i), forkBranches: [] };
-    }
-  }
-  const forkBranches = [];
-  function countUserTurns(startIdx) {
-    const stack = [startIdx];
-    let count = 0;
-    while (stack.length > 0) {
-      const idx = stack.pop();
-      if (entries[idx].type === "user") count++;
-      for (const k of children.get(entries[idx].uuid) ?? []) stack.push(k);
-    }
-    return count;
-  }
-  function walkBranch(startIdx, ownerId) {
-    const pathIndices = [];
-    let current = startIdx;
-    while (current !== null) {
-      pathIndices.push(current);
-      const kids = children.get(entries[current].uuid) ?? [];
-      if (kids.length === 0) {
-        current = null;
-      } else if (kids.length === 1) {
-        current = kids[0];
-      } else {
-        const firstChildTurns = countUserTurns(kids[0]);
-        if (firstChildTurns <= FORK_THRESHOLD) {
-          current = kids[kids.length - 1];
-        } else {
-          for (let k = 1; k < kids.length; k++) {
-            const branchIndices = walkBranch(kids[k], ownerId);
-            forkBranches.push({
-              parentId: ownerId,
-              dagIndices: branchIndices
-            });
-          }
-          current = kids[0];
-        }
-      }
-    }
-    return pathIndices;
-  }
-  const mainDagIndices = walkBranch(roots[0], sessionId);
-  return { mainDagIndices, forkBranches };
-}
-var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-var CLAUDE_DIR = path.join(os.homedir(), ".claude");
-var claude = {
-  id: "claude",
-  config: {
-    dir: CLAUDE_DIR,
-    configPath: path.join(CLAUDE_DIR, "settings.json"),
-    configFormat: "json"
-  },
-  hooks: {
-    // Claude Code uses plugin marketplace, not direct hook registration.
-    // Marketplace setup is handled separately in the install command;
-    // this method handles the settings.json portion only.
-    events: [],
-    applyInstallConfig(existing, _opts) {
-      const settings = { ...existing };
-      settings.extraKnownMarketplaces = settings.extraKnownMarketplaces ?? {};
-      settings.extraKnownMarketplaces["local-plugins"] = {
-        source: { source: "directory", path: config.marketplaceDir }
-      };
-      settings.enabledPlugins = settings.enabledPlugins ?? {};
-      settings.enabledPlugins["panopticon@local-plugins"] = true;
-      const hooks = settings.hooks;
-      if (hooks) {
-        for (const event of Object.keys(hooks)) {
-          const entries = hooks[event];
-          if (!Array.isArray(entries)) continue;
-          hooks[event] = entries.filter(
-            (h) => !(typeof h === "object" && h !== null && JSON.stringify(h).includes("hook-handler"))
-          );
-          if (hooks[event].length === 0) delete hooks[event];
-        }
-        if (Object.keys(hooks).length === 0) delete settings.hooks;
-      }
-      return settings;
-    },
-    removeInstallConfig(existing) {
-      const settings = { ...existing };
-      const marketplaces = settings.extraKnownMarketplaces;
-      if (marketplaces) {
-        delete marketplaces["local-plugins"];
-        if (Object.keys(marketplaces).length === 0)
-          delete settings.extraKnownMarketplaces;
-      }
-      const plugins = settings.enabledPlugins;
-      if (plugins) {
-        delete plugins["panopticon@local-plugins"];
-        delete plugins["fml@local-plugins"];
-        if (Object.keys(plugins).length === 0) delete settings.enabledPlugins;
-      }
-      return settings;
-    }
-  },
-  shellEnv: {
-    envVars(port, proxy) {
-      const vars = [
-        ["CLAUDE_CODE_ENABLE_TELEMETRY", "1"]
-      ];
-      if (proxy) {
-        vars.push([
-          "ANTHROPIC_BASE_URL",
-          `http://localhost:${port}/proxy/anthropic`
-        ]);
-      }
-      return vars;
-    }
-  },
-  events: {
-    // Claude Code already sends canonical event names
-    eventMap: {},
-    formatPermissionResponse({ allow, reason }) {
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PreToolUse",
-          permissionDecision: allow ? "allow" : "deny",
-          permissionDecisionReason: reason
-        }
-      };
-    }
-  },
-  detect: {
-    displayName: "Claude Code",
-    isInstalled: () => fs2.existsSync(CLAUDE_DIR),
-    isConfigured() {
-      try {
-        const settings = JSON.parse(
-          fs2.readFileSync(path.join(CLAUDE_DIR, "settings.json"), "utf-8")
-        );
-        const plugins = settings.enabledPlugins ?? {};
-        return !!plugins["panopticon@local-plugins"] || !!plugins["fml@local-plugins"];
-      } catch {
-        return false;
-      }
-    }
-  },
-  proxy: {
-    upstreamHost: "api.anthropic.com",
-    accumulatorType: "anthropic"
-  },
-  otel: {
-    metrics: {
-      metricNames: ["claude_code.token.usage"],
-      aggregation: "SUM",
-      tokenTypeAttrs: ["$.type"],
-      modelAttrs: ["$.model"]
-    }
-  },
-  ident: {
-    modelPatterns: [/^claude-/]
-  },
-  scanner: {
-    normalizeToolCategory: claudeToolCategory,
-    discover() {
-      const projectsDir = path.join(CLAUDE_DIR, "projects");
-      const files = [];
-      const safeReaddir = (d) => {
-        try {
-          return fs2.readdirSync(d);
-        } catch {
-          return [];
-        }
-      };
-      const safeIsDir = (d) => {
-        try {
-          return fs2.statSync(d).isDirectory();
-        } catch {
-          return false;
-        }
-      };
-      try {
-        for (const slug of fs2.readdirSync(projectsDir)) {
-          const slugDir = path.join(projectsDir, slug);
-          if (!safeIsDir(slugDir)) continue;
-          for (const entry of fs2.readdirSync(slugDir)) {
-            const entryPath = path.join(slugDir, entry);
-            if (entry.endsWith(".jsonl")) {
-              files.push({ filePath: entryPath });
-            }
-            if (safeIsDir(entryPath)) {
-              const subagentsDir = path.join(entryPath, "subagents");
-              for (const sub of safeReaddir(subagentsDir)) {
-                if (sub.endsWith(".jsonl")) {
-                  files.push({
-                    filePath: path.join(subagentsDir, sub)
-                  });
-                }
-              }
-            }
-          }
-        }
-      } catch {
-      }
-      return files;
-    },
-    parseFile(filePath, fromByteOffset) {
-      const { lines, newByteOffset } = readNewLines(filePath, fromByteOffset);
-      if (lines.length === 0) return null;
-      const fileUuid = path.basename(filePath, ".jsonl");
-      const isSubagentPath = filePath.includes("/subagents/");
-      let meta;
-      const turns = [];
-      const events = [];
-      const messages = [];
-      let turnIndex = 0;
-      let ordinal = 0;
-      let firstPrompt;
-      const subagentMap = /* @__PURE__ */ new Map();
-      const orphanedToolResults = /* @__PURE__ */ new Map();
-      const dagEntries = [];
-      const msgLineIdx = [];
-      const turnLineIdx = [];
-      for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
-        const line = lines[lineIdx];
-        let obj;
-        try {
-          obj = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        const type = obj.type;
-        const sessionId = obj.sessionId;
-        const agentId = obj.agentId;
-        const tsMs = obj.timestamp ? new Date(obj.timestamp).getTime() : Date.now();
-        const uuid = obj.uuid;
-        const parentUuid = obj.parentUuid;
-        if (uuid && (type === "user" || type === "assistant")) {
-          dagEntries.push({
-            uuid,
-            parentUuid: parentUuid ?? "",
-            type,
-            lineIndex: lineIdx,
-            timestampMs: tsMs
-          });
-        }
-        if (!meta && sessionId) {
-          const common = {
-            cliVersion: obj.version,
-            cwd: obj.cwd,
-            startedAtMs: tsMs
-          };
-          if (agentId) {
-            meta = {
-              sessionId: `agent-${agentId}`,
-              parentSessionId: sessionId,
-              relationshipType: "subagent",
-              ...common
-            };
-          } else if (!isSubagentPath && UUID_RE.test(fileUuid) && sessionId !== fileUuid) {
-            meta = {
-              sessionId: fileUuid,
-              parentSessionId: sessionId,
-              relationshipType: "continuation",
-              ...common
-            };
-          } else {
-            meta = { sessionId, ...common };
-          }
-        }
-        const sid = meta?.sessionId ?? sessionId ?? "";
-        if (type === "user") {
-          const msg = obj.message;
-          const content = msg?.content;
-          let preview;
-          const textParts = [];
-          const toolResults = /* @__PURE__ */ new Map();
-          if (typeof content === "string") {
-            preview = content.slice(0, 200);
-            textParts.push(content);
-          } else if (Array.isArray(content)) {
-            for (const block of content) {
-              if (typeof block !== "object" || block === null) continue;
-              const b = block;
-              if (b.type === "text" && typeof b.text === "string") {
-                textParts.push(b.text);
-              } else if (b.type === "tool_result") {
-                const textLen = extractToolResultTextLength(b.content);
-                const raw = typeof b.content === "string" ? b.content : JSON.stringify(b.content ?? "");
-                toolResults.set(b.tool_use_id, {
-                  contentLength: textLen,
-                  contentRaw: raw,
-                  timestampMs: tsMs
-                });
-              }
-            }
-            if (textParts.length > 0) {
-              preview = textParts[0].slice(0, 200);
-            }
-          }
-          if (!firstPrompt && preview) firstPrompt = preview;
-          let fullContent = textParts.join("\n");
-          const isMeta = obj.isMeta === true;
-          const isCompact = obj.isCompactSummary === true;
-          if (isMeta || isCompact) {
-          } else if (fullContent.length === 0 && toolResults.size > 0) {
-            for (const [id, result] of toolResults) {
-              orphanedToolResults.set(id, result);
-            }
-          } else if (fullContent.length > 0) {
-            const [converted, wasCommand] = extractCommandText(fullContent);
-            if (wasCommand) {
-              fullContent = converted;
-            }
-            const isSystem = isSystemMessage(fullContent);
-            messages.push({
-              sessionId: sid,
-              ordinal: ordinal++,
-              role: "user",
-              content: fullContent,
-              timestampMs: tsMs,
-              hasThinking: false,
-              hasToolUse: false,
-              isSystem,
-              contentLength: fullContent.length,
-              hasContextTokens: false,
-              hasOutputTokens: false,
-              uuid,
-              parentUuid: parentUuid ?? void 0,
-              toolCalls: [],
-              toolResults
-            });
-            msgLineIdx.push(lineIdx);
-          }
-          turns.push({
-            sessionId: sid,
-            turnIndex: turnIndex++,
-            timestampMs: tsMs,
-            role: "user",
-            contentPreview: preview,
-            inputTokens: 0,
-            outputTokens: 0,
-            cacheReadTokens: 0,
-            cacheCreationTokens: 0,
-            reasoningTokens: 0
-          });
-          turnLineIdx.push(lineIdx);
-        }
-        if (type === "assistant") {
-          const msg = obj.message;
-          const usage = msg?.usage;
-          const model = msg?.model;
-          if (meta && model && !meta.model) meta.model = model;
-          const textParts = [];
-          let hasThinking = false;
-          let hasToolUse = false;
-          const toolCalls = [];
-          const content = msg?.content;
-          if (Array.isArray(content)) {
-            for (const block of content) {
-              if (typeof block !== "object" || block === null) continue;
-              const b = block;
-              if (b.type === "text" && typeof b.text === "string") {
-                textParts.push(b.text);
-              }
-              if (b.type === "thinking") {
-                hasThinking = true;
-                if (typeof b.thinking === "string") {
-                  textParts.push(`[Thinking]
-${b.thinking}
-[/Thinking]`);
-                }
-                events.push({
-                  sessionId: sid,
-                  eventType: "thinking",
-                  timestampMs: tsMs,
-                  content: typeof b.thinking === "string" ? b.thinking.slice(0, 2e3) : void 0,
-                  metadata: {
-                    has_signature: !!b.signature
-                  }
-                });
-              }
-              if (b.type === "tool_use") {
-                hasToolUse = true;
-                const toolName = b.name ?? "";
-                const input = b.input;
-                const inputJson = input ? JSON.stringify(input) : void 0;
-                let skillName;
-                if (toolName === "Skill" && input) {
-                  skillName = input.skill ?? input.name;
-                }
-                toolCalls.push({
-                  toolUseId: b.id ?? "",
-                  toolName,
-                  category: claudeToolCategory(toolName),
-                  inputJson,
-                  skillName,
-                  timestampMs: tsMs
-                });
-                events.push({
-                  sessionId: sid,
-                  eventType: "tool_call",
-                  timestampMs: tsMs,
-                  toolName,
-                  toolInput: inputJson?.slice(0, 1e4),
-                  metadata: { tool_use_id: b.id }
-                });
-              }
-            }
-          }
-          const fullContent = textParts.join("\n");
-          const inputTokens = usage?.input_tokens ?? 0;
-          const outTokens = usage?.output_tokens ?? 0;
-          const cacheRead = usage?.cache_read_input_tokens ?? 0;
-          const cacheCreation = usage?.cache_creation_input_tokens ?? 0;
-          const ctxTokens = inputTokens + cacheRead + cacheCreation;
-          const hasCtx = inputTokens > 0 || cacheRead > 0 || cacheCreation > 0;
-          messages.push({
-            sessionId: sid,
-            ordinal: ordinal++,
-            role: "assistant",
-            content: fullContent,
-            timestampMs: tsMs,
-            hasThinking,
-            hasToolUse,
-            isSystem: false,
-            contentLength: fullContent.length,
-            model,
-            tokenUsage: usage ? JSON.stringify(usage) : void 0,
-            contextTokens: hasCtx ? ctxTokens : void 0,
-            outputTokens: outTokens > 0 ? outTokens : void 0,
-            hasContextTokens: hasCtx,
-            hasOutputTokens: outTokens > 0,
-            uuid,
-            parentUuid: parentUuid ?? void 0,
-            toolCalls,
-            toolResults: /* @__PURE__ */ new Map()
-          });
-          msgLineIdx.push(lineIdx);
-          turns.push({
-            sessionId: sid,
-            turnIndex: turnIndex++,
-            timestampMs: tsMs,
-            model,
-            role: "assistant",
-            inputTokens,
-            outputTokens: outTokens,
-            cacheReadTokens: cacheRead,
-            cacheCreationTokens: cacheCreation,
-            reasoningTokens: 0
-          });
-          turnLineIdx.push(lineIdx);
-        }
-        if (type === "user") {
-          const msg = obj.message;
-          const content = msg?.content;
-          if (Array.isArray(content)) {
-            for (const block of content) {
-              if (typeof block !== "object" || block === null) continue;
-              const b = block;
-              if (b.type === "tool_result") {
-                const resultContent = b.content;
-                events.push({
-                  sessionId: sid,
-                  eventType: "tool_result",
-                  timestampMs: tsMs,
-                  toolOutput: typeof resultContent === "string" ? resultContent.slice(0, 500) : void 0,
-                  metadata: {
-                    tool_use_id: b.tool_use_id,
-                    is_error: b.is_error
-                  }
-                });
-              }
-              if (b.type === "image") {
-                const src = b.source;
-                events.push({
-                  sessionId: sid,
-                  eventType: "image",
-                  timestampMs: tsMs,
-                  metadata: {
-                    media_type: src?.media_type,
-                    source_type: src?.type
-                  }
-                });
-              }
-            }
-          }
-        }
-        if (type === "system") {
-          const data = obj.data;
-          const level = obj.level;
-          const subtype = obj.subtype;
-          if (data?.type === "api_error" || level === "error") {
-            events.push({
-              sessionId: sid,
-              eventType: "error",
-              timestampMs: tsMs,
-              content: typeof data?.message === "string" ? data.message : void 0,
-              metadata: {
-                level,
-                retryAttempt: data?.retryAttempt,
-                maxRetries: data?.maxRetries,
-                retryInMs: data?.retryInMs
-              }
-            });
-          } else if (subtype === "stop_hook_summary" || level === "suggestion") {
-            events.push({
-              sessionId: sid,
-              eventType: subtype ?? "system",
-              timestampMs: tsMs,
-              metadata: {
-                subtype,
-                level,
-                hookCount: obj.hookCount,
-                hookInfos: obj.hookInfos,
-                stopReason: obj.stopReason,
-                preventedContinuation: obj.preventedContinuation
-              }
-            });
-          }
-        }
-        if (type === "file-history-snapshot") {
-          const data = obj.data;
-          const messageId = obj.messageId;
-          events.push({
-            sessionId: sid,
-            eventType: "file_snapshot",
-            timestampMs: tsMs,
-            metadata: { messageId, ...data ?? {} }
-          });
-        }
-        if (type === "progress") {
-          const data = obj.data;
-          const hookEvent = data?.hookEvent;
-          const progressType = data?.type;
-          if (hookEvent || data?.durationMs) {
-            events.push({
-              sessionId: sid,
-              eventType: hookEvent ? `progress:${hookEvent}` : "progress",
-              timestampMs: tsMs,
-              toolName: data?.hookName ?? data?.toolName,
-              metadata: {
-                hookEvent,
-                durationMs: data?.durationMs
-              }
-            });
-          } else if (progressType === "agent_progress") {
-            const tuid = data?.parentToolUseID ?? obj.parentToolUseID;
-            const agentId2 = data?.agentId ?? obj.agentId;
-            if (tuid && agentId2) {
-              subagentMap.set(tuid, `agent-${agentId2}`);
-            }
-            events.push({
-              sessionId: sid,
-              eventType: "agent_progress",
-              timestampMs: tsMs,
-              metadata: {
-                parentToolUseID: tuid,
-                toolUseID: obj.toolUseID
-              }
-            });
-          }
-        }
-        if (type === "queue-operation") {
-          const operation = obj.operation;
-          if (operation === "enqueue" && typeof obj.content === "string") {
-            try {
-              const qc = JSON.parse(obj.content);
-              const tuid = qc.tool_use_id;
-              const taskId = qc.task_id;
-              if (tuid && taskId) {
-                subagentMap.set(tuid, `agent-${taskId}`);
-              }
-            } catch {
-              const tuidMatch = obj.content.match(
-                /<tool-use-id>([^<]+)<\/tool-use-id>/
-              );
-              const taskMatch = obj.content.match(
-                /<task-id>([^<]+)<\/task-id>/
-              );
-              if (tuidMatch?.[1] && taskMatch?.[1]) {
-                subagentMap.set(tuidMatch[1], `agent-${taskMatch[1]}`);
-              }
-            }
-          }
-          events.push({
-            sessionId: sid,
-            eventType: `queue:${operation ?? "unknown"}`,
-            timestampMs: tsMs,
-            content: typeof obj.content === "string" ? obj.content.slice(0, 500) : void 0
-          });
-        }
-        if (type === "last-prompt") {
-          events.push({
-            sessionId: sid,
-            eventType: "last_prompt",
-            timestampMs: tsMs,
-            content: typeof obj.lastPrompt === "string" ? obj.lastPrompt.slice(0, 500) : void 0
-          });
-        }
-      }
-      if (meta && firstPrompt && !meta.firstPrompt)
-        meta.firstPrompt = firstPrompt;
-      if (subagentMap.size > 0) {
-        for (const msg of messages) {
-          for (const tc of msg.toolCalls) {
-            const agentSid = subagentMap.get(tc.toolUseId);
-            if (agentSid && (tc.category === "Task" || tc.toolName === "Agent"))
-              tc.subagentSessionId = agentSid;
-          }
-        }
-      }
-      if (fromByteOffset > 0 && dagEntries.length > 1 && hasDAGFork(dagEntries)) {
-        return {
-          meta,
-          turns: [],
-          events: [],
-          messages: [],
-          newByteOffset: fromByteOffset,
-          // don't advance watermark
-          needsFullReparse: true
-        };
-      }
-      if (fromByteOffset === 0 && meta && dagEntries.length > 1 && hasDAGFork(dagEntries)) {
-        const { mainDagIndices, forkBranches } = detectForks(
-          dagEntries,
-          meta.sessionId
-        );
-        if (forkBranches.length > 0) {
-          const mainLineSet = new Set(
-            mainDagIndices.map((i) => dagEntries[i].lineIndex)
-          );
-          const mainMessages = messages.filter(
-            (_, i) => mainLineSet.has(msgLineIdx[i])
-          );
-          const mainTurns = turns.filter(
-            (_, i) => mainLineSet.has(turnLineIdx[i])
-          );
-          for (let i = 0; i < mainMessages.length; i++) {
-            mainMessages[i] = { ...mainMessages[i], ordinal: i };
-          }
-          for (let i = 0; i < mainTurns.length; i++) {
-            mainTurns[i] = { ...mainTurns[i], turnIndex: i };
-          }
-          const forks = [];
-          for (const branch of forkBranches) {
-            const branchLineSet = new Set(
-              branch.dagIndices.map((i) => dagEntries[i].lineIndex)
-            );
-            const forkUuid = dagEntries[branch.dagIndices[0]].uuid;
-            const forkSessionId = `${meta.sessionId}-${forkUuid}`;
-            const forkStartMs = dagEntries[branch.dagIndices[0]].timestampMs;
-            const forkMessages = messages.filter((_, i) => branchLineSet.has(msgLineIdx[i])).map((m, i) => ({
-              ...m,
-              sessionId: forkSessionId,
-              ordinal: i
-            }));
-            const forkTurns = turns.filter((_, i) => branchLineSet.has(turnLineIdx[i])).map((t, i) => ({
-              ...t,
-              sessionId: forkSessionId,
-              turnIndex: i
-            }));
-            forks.push({
-              meta: {
-                sessionId: forkSessionId,
-                parentSessionId: branch.parentId,
-                relationshipType: "fork",
-                model: meta.model,
-                cwd: meta.cwd,
-                cliVersion: meta.cliVersion,
-                startedAtMs: forkStartMs
-              },
-              turns: forkTurns,
-              events: [],
-              // events stay in main result
-              messages: forkMessages,
-              newByteOffset
-            });
-          }
-          return {
-            meta,
-            turns: mainTurns,
-            events,
-            // all events stay in main
-            messages: mainMessages,
-            newByteOffset,
-            forks,
-            orphanedToolResults: orphanedToolResults.size > 0 ? orphanedToolResults : void 0
-          };
-        }
-      }
-      return {
-        meta,
-        turns,
-        events,
-        messages,
-        newByteOffset,
-        orphanedToolResults: orphanedToolResults.size > 0 ? orphanedToolResults : void 0
-      };
-    }
-  }
-};
-registerTarget(claude);
-var GEMINI_TOOL_CATEGORIES = {
-  read_file: "Read",
-  read_many_files: "Read",
-  write_file: "Write",
-  edit_file: "Edit",
-  run_shell_command: "Bash",
-  shell: "Bash",
-  glob: "Glob",
-  list_directory: "Glob",
-  grep: "Grep",
-  search_files: "Grep",
-  web_search: "Web"
-};
-function geminiToolCategory(toolName) {
-  return GEMINI_TOOL_CATEGORIES[toolName] ?? defaultToolCategory(toolName);
-}
-var GEMINI_DIR = path2.join(os2.homedir(), ".gemini");
-var gemini = {
-  id: "gemini",
-  config: {
-    dir: GEMINI_DIR,
-    configPath: path2.join(GEMINI_DIR, "settings.json"),
-    configFormat: "json"
-  },
-  hooks: {
-    // Gemini's native event names
-    events: ["SessionStart", "BeforeModel", "BeforeTool", "AfterTool"],
-    applyInstallConfig(existing, opts) {
-      const settings = { ...existing };
-      const hookBin = path2.join(opts.pluginRoot, "bin", "hook-handler");
-      const mcpBin = path2.join(opts.pluginRoot, "bin", "mcp-server");
-      const hooks = structuredClone(
-        settings.hooks ?? {}
-      );
-      for (const event of this.events) {
-        hooks[event] = hooks[event] || [];
-        hooks[event] = hooks[event].map((group) => ({
-          ...group,
-          hooks: (group.hooks || []).filter(
-            (h) => !h.command?.includes("panopticon") && !h.path?.includes("panopticon")
-          )
-        })).filter((group) => group.hooks.length > 0);
-        hooks[event].push({
-          hooks: [
-            {
-              type: "command",
-              command: `node ${hookBin} gemini ${opts.port}${opts.proxy ? " --proxy" : ""}`
-            }
-          ]
-        });
-      }
-      settings.hooks = hooks;
-      settings.mcpServers = settings.mcpServers || {};
-      settings.mcpServers.panopticon = {
-        command: "node",
-        args: [mcpBin]
-      };
-      settings.telemetry = settings.telemetry || {};
-      Object.assign(settings.telemetry, {
-        enabled: true,
-        target: "local",
-        otlpProtocol: "http",
-        otlpEndpoint: `http://localhost:${opts.port}`
-      });
-      return settings;
-    },
-    removeInstallConfig(existing) {
-      const settings = { ...existing };
-      const hooks = settings.hooks;
-      if (hooks) {
-        for (const event of Object.keys(hooks)) {
-          hooks[event] = hooks[event].map((group) => ({
-            ...group,
-            hooks: (group.hooks || []).filter(
-              (h) => !h.command?.includes("panopticon") && !h.path?.includes("panopticon")
-            )
-          })).filter((group) => group.hooks.length > 0);
-          if (hooks[event].length === 0) delete hooks[event];
-        }
-        if (Object.keys(hooks).length === 0) delete settings.hooks;
-      }
-      delete settings.hooksConfig;
-      const servers = settings.mcpServers;
-      if (servers) {
-        delete servers.panopticon;
-        if (Object.keys(servers).length === 0) delete settings.mcpServers;
-      }
-      delete settings.telemetry;
-      return settings;
-    }
-  },
-  shellEnv: {
-    envVars(port) {
-      return [
-        ["GEMINI_TELEMETRY_ENABLED", "true"],
-        ["GEMINI_TELEMETRY_TARGET", "local"],
-        ["GEMINI_TELEMETRY_USE_COLLECTOR", "true"],
-        ["GEMINI_TELEMETRY_OTLP_ENDPOINT", `http://localhost:${port}`],
-        ["GEMINI_TELEMETRY_OTLP_PROTOCOL", "http"],
-        ["GEMINI_TELEMETRY_LOG_PROMPTS", "true"]
-      ];
-    }
-  },
-  events: {
-    eventMap: {
-      BeforeTool: "PreToolUse",
-      AfterTool: "PostToolUse",
-      BeforeModel: "UserPromptSubmit"
-    },
-    normalizePayload(data) {
-      const messages = data.llm_request;
-      if (messages?.messages && Array.isArray(messages.messages)) {
-        const lastUser = [...messages.messages].reverse().find((m) => m.role === "user");
-        if (lastUser?.content) {
-          const text = typeof lastUser.content === "string" ? lastUser.content : Array.isArray(lastUser.content) ? lastUser.content.filter((p) => p.type === "text").map((p) => p.text).join("\n") : "";
-          if (text) {
-            data.user_prompt = text;
-          }
-        }
-      }
-      return data;
-    },
-    formatPermissionResponse({ allow, reason }) {
-      return { decision: allow ? "allow" : "deny", reason };
-    }
-  },
-  detect: {
-    displayName: "Gemini CLI",
-    isInstalled: () => fs3.existsSync(GEMINI_DIR),
-    isConfigured() {
-      try {
-        const settings = JSON.parse(
-          fs3.readFileSync(path2.join(GEMINI_DIR, "settings.json"), "utf-8")
-        );
-        return !!settings.telemetry?.enabled;
-      } catch {
-        return false;
-      }
-    }
-  },
-  proxy: {
-    upstreamHost: "generativelanguage.googleapis.com",
-    accumulatorType: "openai"
-  },
-  otel: {
-    serviceName: "gemini-cli",
-    metrics: {
-      metricNames: ["gemini_cli.token.usage", "gen_ai.client.token.usage"],
-      aggregation: "MAX",
-      tokenTypeAttrs: ['$."gen_ai.token.type"'],
-      modelAttrs: ['$."gen_ai.response.model"']
-    }
-  },
-  scanner: {
-    normalizeToolCategory: geminiToolCategory,
-    discover() {
-      const tmpDir = path2.join(GEMINI_DIR, "tmp");
-      const files = [];
-      const safeReaddir = (d) => {
-        try {
-          return fs3.readdirSync(d);
-        } catch {
-          return [];
-        }
-      };
-      for (const project of safeReaddir(tmpDir)) {
-        const chatsDir = path2.join(tmpDir, project, "chats");
-        for (const entry of safeReaddir(chatsDir)) {
-          if (entry.startsWith("session-") && entry.endsWith(".json"))
-            files.push({ filePath: path2.join(chatsDir, entry) });
-        }
-      }
-      return files;
-    },
-    parseFile(filePath, fromByteOffset) {
-      let size;
-      try {
-        size = fs3.statSync(filePath).size;
-      } catch {
-        return null;
-      }
-      if (size <= fromByteOffset) return null;
-      let session;
-      try {
-        session = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
-      } catch {
-        return null;
-      }
-      const sessionId = session.sessionId;
-      if (!sessionId) return null;
-      const messages = session.messages;
-      if (!messages?.length) return null;
-      const meta = {
-        sessionId,
-        startedAtMs: session.startTime ? new Date(session.startTime).getTime() : void 0
-      };
-      const turns = [];
-      const events = [];
-      const parsedMessages = [];
-      let turnIndex = 0;
-      let ordinal = 0;
-      let firstPrompt;
-      for (const msg of messages) {
-        const type = msg.type;
-        const timestamp = msg.timestamp;
-        const timestampMs = timestamp ? new Date(timestamp).getTime() : Date.now();
-        if (type === "user") {
-          const content = msg.content;
-          const textParts = [];
-          if (content) {
-            for (const block of content) {
-              if (block.text) textParts.push(block.text);
-            }
-          }
-          const fullContent = textParts.join("\n");
-          const preview = textParts[0]?.slice(0, 200);
-          if (!firstPrompt && preview) firstPrompt = preview;
-          turns.push({
-            sessionId,
-            turnIndex: turnIndex++,
-            timestampMs,
-            role: "user",
-            contentPreview: preview,
-            inputTokens: 0,
-            outputTokens: 0,
-            cacheReadTokens: 0,
-            cacheCreationTokens: 0,
-            reasoningTokens: 0
-          });
-          if (fullContent.length > 0) {
-            parsedMessages.push({
-              sessionId,
-              ordinal: ordinal++,
-              role: "user",
-              content: fullContent,
-              timestampMs,
-              hasThinking: false,
-              hasToolUse: false,
-              isSystem: false,
-              contentLength: fullContent.length,
-              hasContextTokens: false,
-              hasOutputTokens: false,
-              toolCalls: [],
-              toolResults: /* @__PURE__ */ new Map()
-            });
-          }
-        }
-        if (type === "gemini") {
-          const model = msg.model;
-          const tokens = msg.tokens;
-          if (model && !meta.model) meta.model = model;
-          const inputTokens = tokens?.input ?? 0;
-          const outTokens = tokens?.output ?? 0;
-          const cacheRead = tokens?.cached ?? 0;
-          const reasoning = tokens?.thoughts ?? 0;
-          turns.push({
-            sessionId,
-            turnIndex: turnIndex++,
-            timestampMs,
-            model,
-            role: "assistant",
-            contentPreview: typeof msg.content === "string" ? msg.content.slice(0, 200) : void 0,
-            inputTokens,
-            outputTokens: outTokens,
-            cacheReadTokens: cacheRead,
-            cacheCreationTokens: 0,
-            reasoningTokens: reasoning
-          });
-          const textParts = [];
-          if (typeof msg.content === "string") textParts.push(msg.content);
-          const msgToolCalls = msg.toolCalls;
-          const toolCalls = [];
-          const toolResults = /* @__PURE__ */ new Map();
-          if (msgToolCalls) {
-            for (let tcIdx = 0; tcIdx < msgToolCalls.length; tcIdx++) {
-              const tc = msgToolCalls[tcIdx];
-              const toolName = tc.name ?? tc.displayName ?? "";
-              const inputJson = tc.args ? JSON.stringify(tc.args) : void 0;
-              const toolUseId = tc.id || `${toolName}-${timestampMs}-${tcIdx}`;
-              toolCalls.push({
-                toolUseId,
-                toolName,
-                category: geminiToolCategory(toolName),
-                inputJson
-              });
-              const result = tc.result;
-              const fnResponse = result?.[0]?.functionResponse;
-              const responseObj = fnResponse?.response;
-              const output = typeof responseObj?.output === "string" ? responseObj.output : fnResponse ? JSON.stringify(fnResponse) : void 0;
-              if (output) {
-                toolResults.set(toolUseId, {
-                  contentLength: output.length,
-                  contentRaw: output
-                });
-              }
-              events.push({
-                sessionId,
-                eventType: "tool_call",
-                timestampMs,
-                toolName,
-                toolInput: inputJson?.slice(0, 1e3),
-                toolOutput: output?.slice(0, 1e3)
-              });
-            }
-          }
-          let hasThinking = false;
-          const thoughts = msg.thoughts;
-          if (thoughts) {
-            hasThinking = true;
-            for (const t of thoughts) {
-              const text = t.description ?? t.subject;
-              if (text) textParts.push(`[Thinking]
-${text}
-[/Thinking]`);
-              events.push({
-                sessionId,
-                eventType: "reasoning",
-                timestampMs,
-                content: text?.slice(0, 500)
-              });
-            }
-          }
-          const fullContent = textParts.join("\n");
-          const ctxTokens = inputTokens + cacheRead;
-          const hasCtx = inputTokens > 0 || cacheRead > 0;
-          parsedMessages.push({
-            sessionId,
-            ordinal: ordinal++,
-            role: "assistant",
-            content: fullContent,
-            timestampMs,
-            hasThinking,
-            hasToolUse: toolCalls.length > 0,
-            isSystem: false,
-            contentLength: fullContent.length,
-            model,
-            tokenUsage: tokens ? JSON.stringify(tokens) : void 0,
-            contextTokens: hasCtx ? ctxTokens : void 0,
-            outputTokens: outTokens > 0 ? outTokens : void 0,
-            hasContextTokens: hasCtx,
-            hasOutputTokens: outTokens > 0,
-            toolCalls,
-            toolResults
-          });
-        }
-        if (type === "info") {
-          events.push({
-            sessionId,
-            eventType: "info",
-            timestampMs,
-            content: typeof msg.content === "string" ? msg.content.slice(0, 500) : void 0
-          });
-        }
-      }
-      if (firstPrompt) meta.firstPrompt = firstPrompt;
-      return {
-        meta,
-        turns,
-        events,
-        messages: parsedMessages,
-        newByteOffset: size,
-        absoluteIndices: true
-      };
-    }
-  }
-};
-registerTarget(gemini);
-var CODEX_TOOL_CATEGORIES = {
-  shell_command: "Bash",
-  shell: "Bash",
-  exec_command: "Bash",
-  write_stdin: "Bash",
-  run_command: "Bash",
-  read_file: "Read",
-  write_file: "Write",
-  create_file: "Write",
-  edit_file: "Edit",
-  list_dir: "Glob",
-  grep_search: "Grep",
-  finder: "Grep",
-  spawn_agent: "Task"
-};
-function codexToolCategory(toolName) {
-  return CODEX_TOOL_CATEGORIES[toolName] ?? defaultToolCategory(toolName);
-}
-var CODEX_SYSTEM_PREFIXES = [
-  "# AGENTS.md",
-  "<environment_context>",
-  "<INSTRUCTIONS>",
-  "<subagent_notification>"
-];
-function isCodexSystemMessage(content) {
-  return CODEX_SYSTEM_PREFIXES.some((p) => content.startsWith(p));
-}
-var CODEX_DIR = path3.join(os3.homedir(), ".codex");
-var CODEX_HOOKS_JSON = path3.join(CODEX_DIR, "hooks.json");
-var HOOK_EVENTS = [
-  "SessionStart",
-  "UserPromptSubmit",
-  "PreToolUse",
-  "PostToolUse",
-  "Stop"
-];
-function readHooksJson() {
-  try {
-    return JSON.parse(fs4.readFileSync(CODEX_HOOKS_JSON, "utf-8"));
-  } catch {
-    return {};
-  }
-}
-function writeHooksJson(data) {
-  fs4.mkdirSync(CODEX_DIR, { recursive: true });
-  fs4.writeFileSync(CODEX_HOOKS_JSON, `${JSON.stringify(data, null, 2)}
-`);
-}
-var codex = {
-  id: "codex",
-  config: {
-    dir: CODEX_DIR,
-    configPath: path3.join(CODEX_DIR, "config.toml"),
-    configFormat: "toml"
-  },
-  hooks: {
-    events: HOOK_EVENTS,
-    applyInstallConfig(existing, opts) {
-      const codexConfig = { ...existing };
-      const hookBin = path3.join(opts.pluginRoot, "bin", "hook-handler");
-      const mcpBin = path3.join(opts.pluginRoot, "bin", "mcp-server");
-      codexConfig.features = codexConfig.features ?? {};
-      codexConfig.features.codex_hooks = true;
-      codexConfig.suppress_unstable_features_warning = true;
-      delete codexConfig.hooks;
-      const hooksFile = readHooksJson();
-      const hooks = hooksFile.hooks ?? {};
-      const proxyFlag = opts.proxy ? " --proxy" : "";
-      const command = `node ${hookBin} codex ${opts.port}${proxyFlag}`;
-      for (const event of HOOK_EVENTS) {
-        const groups = hooks[event] ?? [];
-        hooks[event] = groups.filter((g) => {
-          const h = g.hooks ?? [];
-          return !h.some(
-            (entry) => entry.command?.includes("panopticon")
-          );
-        });
-        hooks[event].push({
-          hooks: [{ type: "command", command, timeout: 10 }]
-        });
-      }
-      hooksFile.hooks = hooks;
-      writeHooksJson(hooksFile);
-      if (opts.proxy) {
-        codexConfig.openai_base_url = `http://localhost:${opts.port}/proxy/codex`;
-      } else {
-        delete codexConfig.openai_base_url;
-      }
-      delete codexConfig.telemetry;
-      const endpoint = `http://localhost:${opts.port}`;
-      const exporterConfig = { endpoint, protocol: "binary" };
-      codexConfig.otel = {
-        ...codexConfig.otel ?? {},
-        log_user_prompt: true,
-        exporter: { "otlp-http": exporterConfig },
-        trace_exporter: { "otlp-http": exporterConfig },
-        metrics_exporter: { "otlp-http": exporterConfig }
-      };
-      const mcpServers = codexConfig.mcp_servers ?? {};
-      mcpServers.panopticon = { command: "node", args: [mcpBin] };
-      codexConfig.mcp_servers = mcpServers;
-      return codexConfig;
-    },
-    removeInstallConfig(existing) {
-      const cfg = { ...existing };
-      const features = cfg.features;
-      if (features) {
-        delete features.codex_hooks;
-        if (Object.keys(features).length === 0) delete cfg.features;
-      }
-      delete cfg.suppress_unstable_features_warning;
-      delete cfg.hooks;
-      const hooksFile = readHooksJson();
-      const hooks = hooksFile.hooks;
-      if (hooks) {
-        for (const event of Object.keys(hooks)) {
-          hooks[event] = hooks[event].filter((g) => {
-            const h = g.hooks ?? [];
-            return !h.some(
-              (entry) => entry.command?.includes("panopticon")
-            );
-          });
-          if (hooks[event].length === 0) delete hooks[event];
-        }
-        if (Object.keys(hooks).length === 0) {
-          try {
-            fs4.unlinkSync(CODEX_HOOKS_JSON);
-          } catch {
-          }
-        } else {
-          hooksFile.hooks = hooks;
-          writeHooksJson(hooksFile);
-        }
-      }
-      if (typeof cfg.openai_base_url === "string" && cfg.openai_base_url.includes("panopticon")) {
-        delete cfg.openai_base_url;
-      }
-      delete cfg.telemetry;
-      const otel = cfg.otel;
-      if (otel) {
-        delete otel.log_user_prompt;
-        delete otel.exporter;
-        delete otel.trace_exporter;
-        delete otel.metrics_exporter;
-        if (Object.keys(otel).length === 0) delete cfg.otel;
-      }
-      const servers = cfg.mcp_servers;
-      if (servers) {
-        delete servers.panopticon;
-        if (Object.keys(servers).length === 0) delete cfg.mcp_servers;
-      }
-      return cfg;
-    }
-  },
-  shellEnv: {
-    // Codex CLI reads its config from TOML, no shell env vars needed
-    envVars() {
-      return [];
-    }
-  },
-  events: {
-    // Codex uses snake_case but the hook handler already accepts both cases;
-    // no mapping needed since ingest.ts normalizes at storage time
-    eventMap: {},
-    formatPermissionResponse({ allow, reason }) {
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PreToolUse",
-          permissionDecision: allow ? "allow" : "deny",
-          permissionDecisionReason: reason
-        }
-      };
-    }
-  },
-  detect: {
-    displayName: "Codex CLI",
-    isInstalled: () => fs4.existsSync(CODEX_DIR),
-    isConfigured() {
-      try {
-        const content = fs4.readFileSync(CODEX_HOOKS_JSON, "utf-8");
-        return content.includes("panopticon");
-      } catch {
-        return false;
-      }
-    }
-  },
-  otel: {
-    serviceName: "codex_cli_rs",
-    metrics: {
-      metricNames: ["codex.turn.token_usage"],
-      aggregation: "SUM",
-      tokenTypeAttrs: ["$.token_type"],
-      modelAttrs: ["$.model"],
-      tokenTypeMap: {
-        cached_input: "cacheRead",
-        reasoning_output: "output"
-      },
-      excludeTokenTypes: ["total"]
-    },
-    logFields: {
-      eventTypeExprs: ["body", `json_extract(attributes, '$."event.name"')`],
-      timestampMsExprs: [
-        "CAST(timestamp_ns / 1000000 AS INTEGER)",
-        `CAST(strftime('%s', json_extract(attributes, '$."event.timestamp"')) AS INTEGER) * 1000`
-      ]
-    }
-  },
-  ident: {
-    modelPatterns: [/^(gpt-|o[1-9]|chatgpt-)/]
-  },
-  proxy: {
-    upstreamHost(headers) {
-      const auth = headers.authorization ?? "";
-      return auth.startsWith("Bearer eyJ") ? "chatgpt.com" : "api.openai.com";
-    },
-    rewritePath(requestPath, headers) {
-      const auth = headers.authorization ?? "";
-      const isChatGptOAuth = auth.startsWith("Bearer eyJ");
-      return isChatGptOAuth ? `/backend-api/codex${requestPath}` : `/v1${requestPath}`;
-    },
-    accumulatorType: "openai"
-  },
-  scanner: {
-    normalizeToolCategory: codexToolCategory,
-    discover() {
-      const sessionsDir = path3.join(CODEX_DIR, "sessions");
-      const files = [];
-      const safeReaddir = (d) => {
-        try {
-          return fs4.readdirSync(d);
-        } catch {
-          return [];
-        }
-      };
-      for (const year of safeReaddir(sessionsDir)) {
-        for (const month of safeReaddir(path3.join(sessionsDir, year))) {
-          for (const day of safeReaddir(path3.join(sessionsDir, year, month))) {
-            const dayDir = path3.join(sessionsDir, year, month, day);
-            for (const entry of safeReaddir(dayDir)) {
-              if (entry.endsWith(".jsonl"))
-                files.push({ filePath: path3.join(dayDir, entry) });
-            }
-          }
-        }
-      }
-      return files;
-    },
-    parseFile(filePath, fromByteOffset) {
-      const { lines, newByteOffset } = readNewLines(filePath, fromByteOffset);
-      if (lines.length === 0) return null;
-      let meta;
-      const turns = [];
-      const events = [];
-      const messages = [];
-      let turnIndex = 0;
-      let ordinal = 0;
-      let currentModel;
-      let firstPrompt;
-      let pendingToolCalls = [];
-      let pendingAssistantContent = "";
-      const toolResultsByCallId = /* @__PURE__ */ new Map();
-      for (const line of lines) {
-        let obj;
-        try {
-          obj = JSON.parse(line);
-        } catch {
-          continue;
-        }
-        const type = obj.type;
-        const timestamp = obj.timestamp;
-        const tsMs = timestamp ? new Date(timestamp).getTime() : Date.now();
-        const payload = obj.payload;
-        if (type === "session_meta" && payload) {
-          meta = {
-            sessionId: payload.id,
-            cwd: payload.cwd,
-            cliVersion: payload.cli_version,
-            startedAtMs: payload.timestamp ? new Date(payload.timestamp).getTime() : tsMs
-          };
-        }
-        if (type === "turn_context" && payload) {
-          currentModel = payload.model;
-          if (meta && currentModel && !meta.model) meta.model = currentModel;
-        }
-        const sid = meta?.sessionId ?? "";
-        if (type === "event_msg" && payload) {
-          const eventType = payload.type;
-          if (eventType === "user_message") {
-            const message = payload.message;
-            if (!firstPrompt && message) firstPrompt = message.slice(0, 200);
-            turns.push({
-              sessionId: sid,
-              turnIndex: turnIndex++,
-              timestampMs: tsMs,
-              model: currentModel,
-              role: "user",
-              contentPreview: message?.slice(0, 200),
-              inputTokens: 0,
-              outputTokens: 0,
-              cacheReadTokens: 0,
-              cacheCreationTokens: 0,
-              reasoningTokens: 0
-            });
-            if (message && !isCodexSystemMessage(message)) {
-              messages.push({
-                sessionId: sid,
-                ordinal: ordinal++,
-                role: "user",
-                content: message,
-                timestampMs: tsMs,
-                hasThinking: false,
-                hasToolUse: false,
-                isSystem: false,
-                contentLength: message.length,
-                hasContextTokens: false,
-                hasOutputTokens: false,
-                toolCalls: [],
-                toolResults: /* @__PURE__ */ new Map()
-              });
-            }
-          }
-          if (eventType === "token_count") {
-            const info = payload.info;
-            if (!info) continue;
-            const lastUsage = info.last_token_usage;
-            if (!lastUsage) continue;
-            const inputTokens = lastUsage.input_tokens ?? 0;
-            const outTokens = lastUsage.output_tokens ?? 0;
-            const cacheRead = lastUsage.cached_input_tokens ?? 0;
-            const reasoning = lastUsage.reasoning_output_tokens ?? 0;
-            const ctxTokens = inputTokens + cacheRead;
-            const hasCtx = inputTokens > 0 || cacheRead > 0;
-            turns.push({
-              sessionId: sid,
-              turnIndex: turnIndex++,
-              timestampMs: tsMs,
-              model: currentModel,
-              role: "assistant",
-              inputTokens,
-              outputTokens: outTokens,
-              cacheReadTokens: cacheRead,
-              cacheCreationTokens: 0,
-              reasoningTokens: reasoning
-            });
-            const toolResults = /* @__PURE__ */ new Map();
-            for (const tc of pendingToolCalls) {
-              const result = toolResultsByCallId.get(tc.toolUseId);
-              if (result) toolResults.set(tc.toolUseId, result);
-            }
-            messages.push({
-              sessionId: sid,
-              ordinal: ordinal++,
-              role: "assistant",
-              content: pendingAssistantContent,
-              timestampMs: tsMs,
-              hasThinking: false,
-              hasToolUse: pendingToolCalls.length > 0,
-              isSystem: false,
-              contentLength: pendingAssistantContent.length,
-              model: currentModel,
-              tokenUsage: JSON.stringify(lastUsage),
-              contextTokens: hasCtx ? ctxTokens : void 0,
-              outputTokens: outTokens > 0 ? outTokens : void 0,
-              hasContextTokens: hasCtx,
-              hasOutputTokens: outTokens > 0,
-              toolCalls: pendingToolCalls,
-              toolResults
-            });
-            pendingToolCalls = [];
-            pendingAssistantContent = "";
-          }
-          if (eventType === "agent_message") {
-            events.push({
-              sessionId: sid,
-              eventType: "agent_message",
-              timestampMs: tsMs,
-              content: payload.message?.slice(0, 500),
-              metadata: { phase: payload.phase }
-            });
-          }
-        }
-        if (type === "response_item") {
-          const p = obj.payload;
-          const itemType = p?.type;
-          if (itemType === "message" || itemType === "text") {
-            const text = p?.text ?? p?.content ?? p?.output_text;
-            if (text) {
-              pendingAssistantContent += (pendingAssistantContent ? "\n" : "") + text;
-            }
-          }
-          if (itemType === "function_call") {
-            const toolName = p?.name ?? "";
-            const callId = p?.call_id ?? "";
-            const inputJson = typeof p?.arguments === "string" ? p.arguments : JSON.stringify(p?.arguments);
-            pendingToolCalls.push({
-              toolUseId: callId,
-              toolName,
-              category: codexToolCategory(toolName),
-              inputJson
-            });
-            events.push({
-              sessionId: sid,
-              eventType: "tool_call",
-              timestampMs: tsMs,
-              toolName,
-              toolInput: inputJson?.slice(0, 1e3),
-              metadata: { call_id: callId }
-            });
-          }
-          if (itemType === "function_call_output") {
-            const callId = p?.call_id ?? "";
-            const output = typeof p?.output === "string" ? p.output : void 0;
-            if (output) {
-              toolResultsByCallId.set(callId, {
-                contentLength: output.length,
-                contentRaw: output
-              });
-            }
-            events.push({
-              sessionId: sid,
-              eventType: "tool_result",
-              timestampMs: tsMs,
-              toolOutput: output?.slice(0, 1e3),
-              metadata: { call_id: callId }
-            });
-          }
-        }
-      }
-      if (meta && firstPrompt && !meta.firstPrompt)
-        meta.firstPrompt = firstPrompt;
-      return { meta, turns, events, messages, newByteOffset };
-    }
-  }
-};
-registerTarget(codex);
-
-// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-SHXOVUQD.js
-function dbStats() {
-  const db = getDb();
-  const logs = db.prepare("SELECT COUNT(*) as count FROM otel_logs").get();
-  const metrics = db.prepare("SELECT COUNT(*) as count FROM otel_metrics").get();
-  const hooks = db.prepare("SELECT COUNT(*) as count FROM hook_events").get();
-  const spans = db.prepare("SELECT COUNT(*) as count FROM otel_spans").get();
-  const sessions = db.prepare("SELECT COUNT(*) as count FROM sessions").get();
-  const scannerTurns = db.prepare("SELECT COUNT(*) as count FROM scanner_turns").get();
-  const scannerEvents = db.prepare("SELECT COUNT(*) as count FROM scanner_events").get();
-  const messages = db.prepare("SELECT COUNT(*) as count FROM messages").get();
-  const toolCalls = db.prepare("SELECT COUNT(*) as count FROM tool_calls").get();
-  return {
-    sessions: sessions.count,
-    messages: messages.count,
-    tool_calls: toolCalls.count,
-    scanner_turns: scannerTurns.count,
-    scanner_events: scannerEvents.count,
-    hook_events: hooks.count,
-    otel_logs: logs.count,
-    otel_metrics: metrics.count,
-    otel_spans: spans.count
-  };
-}
-
-// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-N4KQ56HJ.js
-import fs5 from "fs";
-import http from "http";
-import os4 from "os";
-import path4 from "path";
-function checkHealth(port, host) {
-  return new Promise((resolve) => {
-    const req = http.request(
-      { hostname: host, port, path: "/health", method: "GET", timeout: 2e3 },
-      (res) => {
-        res.resume();
-        resolve(res.statusCode === 200);
-      }
-    );
-    req.on("error", () => resolve(false));
-    req.on("timeout", () => {
-      req.destroy();
-      resolve(false);
-    });
-    req.end();
-  });
-}
-async function doctor() {
-  const checks = [];
-  const isSandbox = process.env.SANDBOX !== void 0 || fs5.existsSync(path4.join(os4.homedir(), ".sandbox-home"));
-  if (!fs5.existsSync(config.dbPath)) {
-    checks.push({
-      label: "Database",
-      status: "fail",
-      detail: `Not found at ${config.dbPath}. Run install to initialize.`
-    });
-  } else {
-    try {
-      const stats = dbStats();
-      const total = stats.hook_events + stats.otel_logs + stats.otel_metrics;
-      checks.push({
-        label: "Database",
-        status: "ok",
-        detail: `${total} rows (${stats.hook_events} hooks, ${stats.otel_logs} logs, ${stats.otel_metrics} metrics)`
-      });
-      closeDb();
-    } catch (err) {
-      checks.push({
-        label: "Database",
-        status: "fail",
-        detail: `Error: ${err instanceof Error ? err.message : String(err)}`
-      });
-    }
-  }
-  const serverUp = await checkHealth(config.port, "127.0.0.1");
-  if (serverUp) {
-    checks.push({
-      label: "Server",
-      status: "ok",
-      detail: `Listening on 127.0.0.1:${config.port}`
-    });
-  } else {
-    checks.push({
-      label: "Server",
-      status: "warn",
-      detail: `Not responding on port ${config.port}`
-    });
-  }
-  const shellRc = path4.join(
-    os4.homedir(),
-    process.env.SHELL?.includes("zsh") ? ".zshrc" : ".bashrc"
-  );
-  const rcContent = fs5.existsSync(shellRc) ? fs5.readFileSync(shellRc, "utf-8") : "";
-  const hasTelemetry = rcContent.includes("CLAUDE_CODE_ENABLE_TELEMETRY");
-  const hasEndpoint = rcContent.includes("OTEL_EXPORTER_OTLP_ENDPOINT");
-  if (hasTelemetry && hasEndpoint) {
-    checks.push({
-      label: "Shell Env",
-      status: "ok",
-      detail: `Telemetry configured in ${path4.basename(shellRc)}`
-    });
-  } else if (hasTelemetry || hasEndpoint) {
-    checks.push({
-      label: "Shell Env",
-      status: "warn",
-      detail: `Partial config in ${path4.basename(shellRc)} \u2014 re-run install`
-    });
-  } else {
-    checks.push({
-      label: "Shell Env",
-      status: "warn",
-      detail: `Not configured. Run install to set up telemetry.`
-    });
-  }
-  const tools = [];
-  for (const t of allTargets()) {
-    if (t.detect.isInstalled()) {
-      tools.push({
-        name: t.detect.displayName,
-        dir: t.config.dir,
-        configured: t.detect.isConfigured()
-      });
-    }
-  }
-  if (tools.length === 0) {
-    checks.push({
-      label: "Tools",
-      status: "warn",
-      detail: "No supported coding tools found"
-    });
-  } else {
-    const configured = tools.filter((t) => t.configured);
-    const unconfigured = tools.filter((t) => !t.configured);
-    if (unconfigured.length === 0) {
-      checks.push({
-        label: "Tools",
-        status: "ok",
-        detail: configured.map((t) => t.name).join(", ")
-      });
-    } else {
-      const detail = tools.map((t) => `${t.name} ${t.configured ? "\u2713" : "(not configured)"}`).join(", ");
-      checks.push({
-        label: "Tools",
-        status: "warn",
-        detail: `${detail} \u2014 re-run install`
-      });
-    }
-  }
-  if (fs5.existsSync(config.dbPath)) {
-    try {
-      const db = getDb();
-      const latest = db.prepare("SELECT MAX(timestamp_ms) as ts FROM hook_events").get();
-      closeDb();
-      if (latest?.ts) {
-        const ago = Date.now() - latest.ts;
-        const minutes = Math.floor(ago / 6e4);
-        if (minutes < 60) {
-          checks.push({
-            label: "Data Flow",
-            status: "ok",
-            detail: `Last event ${minutes}m ago`
-          });
-        } else if (minutes < 1440) {
-          checks.push({
-            label: "Data Flow",
-            status: "ok",
-            detail: `Last event ${Math.floor(minutes / 60)}h ago`
-          });
-        } else {
-          checks.push({
-            label: "Data Flow",
-            status: "warn",
-            detail: `Last event ${Math.floor(minutes / 1440)}d ago`
-          });
-        }
-      } else {
-        checks.push({
-          label: "Data Flow",
-          status: "warn",
-          detail: "No events recorded yet"
-        });
-      }
-    } catch {
-    }
-  }
-  try {
-    const cfg = loadUnifiedConfig();
-    const targets2 = cfg.sync.targets;
-    if (targets2.length === 0) {
-      checks.push({
-        label: "Sync",
-        status: "ok",
-        detail: "No targets configured"
-      });
-    } else {
-      const tables = ["hook_events", "otel_logs", "otel_metrics"];
-      const targetDetails = [];
-      for (const t of targets2) {
-        const watermarks = tables.map(
-          (table) => readWatermark(watermarkKey(table, t.name))
-        );
-        const minWm = Math.min(...watermarks);
-        const wmLabel = minWm > 0 ? `synced to #${minWm}` : "not synced yet";
-        targetDetails.push(`${t.name} \u2192 ${t.url} (${wmLabel})`);
-      }
-      checks.push({
-        label: "Sync",
-        status: "ok",
-        detail: `${targets2.length} target${targets2.length > 1 ? "s" : ""}: ${targetDetails.join("; ")}`
-      });
-    }
-  } catch {
-    checks.push({
-      label: "Sync",
-      status: "warn",
-      detail: "Could not read sync config"
-    });
-  }
-  try {
-    const cfg = loadUnifiedConfig();
-    const dsn = process.env.PANOPTICON_SENTRY_DSN ?? cfg.sentryDsn;
-    checks.push({
-      label: "Sentry",
-      status: dsn ? "ok" : "ok",
-      detail: dsn ? "Configured" : "Not configured (optional)"
-    });
-  } catch {
-  }
-  let recentEvents = [];
-  let recentErrors = [];
-  if (fs5.existsSync(config.dbPath)) {
-    try {
-      const db = getDb();
-      const events = db.prepare(
-        "SELECT event_type, tool_name, timestamp_ms FROM hook_events ORDER BY id DESC LIMIT 3"
-      ).all();
-      recentEvents = events.map((e) => ({
-        eventType: e.event_type,
-        toolName: e.tool_name,
-        timestamp: new Date(e.timestamp_ms).toISOString()
-      }));
-      const errors = db.prepare(
-        "SELECT id, body FROM otel_logs WHERE severity_text = 'ERROR' ORDER BY id DESC LIMIT 3"
-      ).all();
-      recentErrors = errors.map((e) => ({
-        id: e.id,
-        body: (e.body ?? "").slice(0, 200)
-      }));
-      closeDb();
-    } catch {
-    }
-  }
-  return {
-    checks,
-    system: {
-      os: `${os4.platform()} (${os4.release()} ${os4.arch()})`,
-      node: process.version,
-      sandbox: isSandbox
-    },
-    recentEvents,
-    recentErrors
-  };
-}
-
-// node_modules/.pnpm/@fml-inc+panopticon@0.2.2/node_modules/@fml-inc/panopticon/dist/chunk-ZEC4LRKS.js
-import fs6 from "fs";
-import os5 from "os";
-import path5 from "path";
-var CLAUDE_DESKTOP_DIR = path5.join(
-  os5.homedir(),
-  "Library",
-  "Application Support",
-  "Claude"
-);
-var CLAUDE_DESKTOP_CONFIG = path5.join(
-  CLAUDE_DESKTOP_DIR,
-  "claude_desktop_config.json"
-);
-var claudeDesktop = {
-  id: "claude-desktop",
-  config: {
-    dir: CLAUDE_DESKTOP_DIR,
-    configPath: CLAUDE_DESKTOP_CONFIG,
-    configFormat: "json"
-  },
-  hooks: {
-    // Claude Desktop uses MCP servers, not hooks
-    events: [],
-    applyInstallConfig(existing, opts) {
-      const cfg = { ...existing };
-      const serverBin = path5.join(opts.pluginRoot, "bin", "mcp-server");
-      cfg.mcpServers = cfg.mcpServers ?? {};
-      cfg.mcpServers.panopticon = {
-        command: "node",
-        args: [serverBin]
-      };
-      return cfg;
-    },
-    removeInstallConfig(existing) {
-      const cfg = { ...existing };
-      const servers = cfg.mcpServers;
-      if (servers) {
-        delete servers.panopticon;
-        if (Object.keys(servers).length === 0) delete cfg.mcpServers;
-      }
-      return cfg;
-    }
-  },
-  shellEnv: {
-    envVars() {
-      return [];
-    }
-  },
-  events: {
-    eventMap: {},
-    formatPermissionResponse({ allow, reason }) {
-      return {
-        hookSpecificOutput: {
-          hookEventName: "PreToolUse",
-          permissionDecision: allow ? "allow" : "deny",
-          permissionDecisionReason: reason
-        }
-      };
-    }
-  },
-  detect: {
-    displayName: "Claude Desktop",
-    isInstalled: () => fs6.existsSync(CLAUDE_DESKTOP_DIR),
-    isConfigured() {
-      try {
-        const cfg = JSON.parse(fs6.readFileSync(CLAUDE_DESKTOP_CONFIG, "utf-8"));
-        return !!cfg.mcpServers?.panopticon;
-      } catch {
-        return false;
-      }
-    }
-  }
-};
-registerTarget(claudeDesktop);
-export {
-  doctor
-};
-//# sourceMappingURL=doctor-YV6KQEGW.js.map