@yumiai/chat-widget 0.1.2 → 0.2.1

package/dist/chunk-KQV7IKET.js

@@ -0,0 +1,1621 @@
+import {
+  I18nContext,
+  resolveMessages,
+  useChatWidgetI18n
+} from "./chunk-QLVPIM6R.js";
+
+// src/provenance/ProvenanceGraphDrawerContent.tsx
+import React4, { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+import { Spin, Empty } from "antd";
+
+// src/provenance/hooks/useProvenanceGraph.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/provenance/GraphBuilder.ts
+var GraphBuilder = class _GraphBuilder {
+  sessionId = 0;
+  agents = /* @__PURE__ */ new Map();
+  actions = /* @__PURE__ */ new Map();
+  files = /* @__PURE__ */ new Map();
+  tasks = /* @__PURE__ */ new Map();
+  reasonings = /* @__PURE__ */ new Map();
+  edges = [];
+  edgeKeys = /* @__PURE__ */ new Set();
+  lastCompletedActions = /* @__PURE__ */ new Map();
+  handlers = {
+    agent_start: (p) => this.handleAgentStart(p),
+    agent_end: (p) => this.handleAgentEnd(p),
+    mcp_start: (p) => this.handleMcpStart(p),
+    mcp_end: (p) => this.handleMcpEnd(p),
+    artifact_result: (p) => this.handleArtifactResult(p),
+    plan_result: (p) => this.handlePlanResult(p),
+    model_start: (p) => this.handleModelStart(p),
+    model_result: (p) => this.handleModelResult(p),
+    model_end: (p) => this.handleModelEnd(p)
+  };
+  /** Apply an SSE event. Returns true if the event was handled. */
+  applyEvent(payload) {
+    const type = payload.notification_type ?? "";
+    const handler = this.handlers[type];
+    if (!handler) return false;
+    handler(payload);
+    return true;
+  }
+  /** Replace all state from a backend snapshot (initial load). */
+  replaceWithSnapshot(snapshot) {
+    this.sessionId = snapshot.session_id;
+    this.agents.clear();
+    this.actions.clear();
+    this.files.clear();
+    this.tasks.clear();
+    this.reasonings.clear();
+    this.edges = [];
+    this.edgeKeys.clear();
+    for (const n of snapshot.nodes.agents) this.agents.set(n.agent_instance_id, { ...n });
+    for (const n of snapshot.nodes.actions) this.actions.set(n.tool_call_id, { ...n });
+    for (const n of snapshot.nodes.files) this.files.set(n.id, { ...n });
+    for (const n of snapshot.nodes.tasks) this.tasks.set(n.id, { ...n });
+    for (const n of snapshot.nodes.reasonings) this.reasonings.set(n.id, { ...n });
+    for (const e of snapshot.edges) {
+      const key = this.edgeKey(e.source, e.target, e.type, e.label);
+      if (!this.edgeKeys.has(key)) {
+        this.edgeKeys.add(key);
+        this.edges.push({ ...e });
+      }
+    }
+  }
+  /** Merge an incremental snapshot (reconnection). */
+  mergeSnapshot(snapshot) {
+    for (const n of snapshot.nodes.agents) this.agents.set(n.agent_instance_id, { ...n });
+    for (const n of snapshot.nodes.actions) this.actions.set(n.tool_call_id, { ...n });
+    for (const n of snapshot.nodes.files) this.files.set(n.id, { ...n });
+    for (const n of snapshot.nodes.tasks) this.tasks.set(n.id, { ...n });
+    for (const n of snapshot.nodes.reasonings) this.reasonings.set(n.id, { ...n });
+    for (const e of snapshot.edges) {
+      const key = this.edgeKey(e.source, e.target, e.type, e.label);
+      if (!this.edgeKeys.has(key)) {
+        this.edgeKeys.add(key);
+        this.edges.push({ ...e });
+      }
+    }
+  }
+  /** Produce an immutable snapshot for React state. */
+  getSnapshot() {
+    const agents = Array.from(this.agents.values());
+    const actions = Array.from(this.actions.values());
+    const files = Array.from(this.files.values());
+    const tasks = Array.from(this.tasks.values());
+    const reasonings = Array.from(this.reasonings.values());
+    const nodeCount = agents.length + actions.length + files.length + tasks.length + reasonings.length;
+    const maxDepth = agents.length > 0 ? Math.max(...agents.map((a) => a.level)) : 0;
+    return {
+      session_id: this.sessionId,
+      generated_at: Date.now(),
+      node_count: nodeCount,
+      edge_count: this.edges.length,
+      max_turn_id: null,
+      nodes: { agents, actions, files, tasks, reasonings },
+      edges: [...this.edges],
+      stats: {
+        agent_count: agents.length,
+        action_count: actions.length,
+        file_count: files.length,
+        task_count: tasks.length,
+        reasoning_count: reasonings.length,
+        max_depth: maxDepth
+      }
+    };
+  }
+  // -----------------------------------------------------------------------
+  // Handlers
+  // -----------------------------------------------------------------------
+  handleAgentStart(p) {
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const caller = p.caller_instance_id ?? null;
+    const ts = this.parseTimestamp(p.timestamp);
+    const node = {
+      id: `agent-inst-${callee}`,
+      type: "agent",
+      label: p.agent_name ?? p.agent_id ?? `agent-${callee}`,
+      timestamp: ts,
+      metadata: {},
+      agent_id: p.agent_id ?? `agent-${callee}`,
+      agent_instance_id: callee,
+      agent_name: p.agent_name ?? `agent-${callee}`,
+      level: p.level ?? 0,
+      parent_agent_instance_id: caller != null && caller >= 0 ? caller : null,
+      status: "running"
+    };
+    this.agents.set(callee, node);
+    if (caller != null && caller >= 0 && this.agents.has(caller)) {
+      this.addEdge(`agent-inst-${caller}`, `agent-inst-${callee}`, "spawns", ts);
+    }
+  }
+  handleAgentEnd(p) {
+    const callee = p.callee_instance_id ?? p.agent_instance_id;
+    if (callee == null) return;
+    const existing = this.agents.get(callee);
+    if (existing) {
+      this.agents.set(callee, { ...existing, status: "completed" });
+    }
+  }
+  handleMcpStart(p) {
+    const tcid = this.extractString(p.ext, "tool_call_id") ?? p.tool_call_id;
+    if (!tcid) return;
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const ts = this.parseTimestamp(p.timestamp);
+    const node = {
+      id: `action-${tcid}`,
+      type: "action",
+      label: this.extractString(p.ext, "tool_name") ?? p.tool_name ?? tcid,
+      timestamp: ts,
+      metadata: {},
+      tool_name: this.extractString(p.ext, "tool_name") ?? p.tool_name ?? "",
+      tool_call_id: tcid,
+      task_purpose: this.extractString(p.ext, "task_purpose") ?? p.task_purpose ?? "",
+      agent_instance_id: callee,
+      status: "running",
+      duration_ms: null
+    };
+    this.actions.set(tcid, node);
+    if (this.agents.has(callee)) {
+      this.addEdge(`agent-inst-${callee}`, `action-${tcid}`, "executes", ts);
+    }
+    const latestReasoning = this.findLatestReasoning(callee);
+    if (latestReasoning) {
+      this.addEdge(latestReasoning.id, `action-${tcid}`, "triggers", ts);
+    }
+    for (const [fid, fileNode] of this.files) {
+      if (fileNode.tool_call_id === tcid) {
+        const op = fileNode.operation;
+        const et = op === "create" ? "produces" : op === "delete" ? "deletes" : "modifies";
+        this.addEdge(`action-${tcid}`, fid, et, ts);
+      }
+    }
+  }
+  handleMcpEnd(p) {
+    const tcid = this.extractString(p.ext, "tool_call_id") ?? p.tool_call_id;
+    if (!tcid) return;
+    const existing = this.actions.get(tcid);
+    if (!existing) return;
+    const statusStr = this.extractString(p.ext, "status") ?? p.tool_status ?? "success";
+    const status = statusStr === "error" ? "error" : "success";
+    const endTs = this.parseTimestamp(p.timestamp);
+    const duration = endTs - existing.timestamp;
+    this.actions.set(tcid, { ...existing, status, duration_ms: duration > 0 ? duration : null });
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const prev = this.lastCompletedActions.get(callee) ?? [];
+    prev.push(tcid);
+    this.lastCompletedActions.set(callee, prev);
+  }
+  handleArtifactResult(p) {
+    if (p.ext?.xref_scan_result) {
+      this.handleXrefScanResult(p);
+      return;
+    }
+    const data = this.extractArtifactData(p.content);
+    if (!data) return;
+    const fileId = data.file_id ?? data.identifier ?? "";
+    if (!fileId) return;
+    const fid = `file-${fileId}`;
+    const op = this.normalizeOperation(data.operation_type);
+    const tcid = this.extractString(p.ext, "tool_call_id") ?? p.tool_call_id ?? null;
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const ts = this.parseTimestamp(p.timestamp);
+    const existing = this.files.get(fid);
+    const node = {
+      id: fid,
+      type: "file",
+      label: data.file_name ?? data.git_path ?? fileId,
+      timestamp: existing?.timestamp ?? ts,
+      metadata: {},
+      file_id: fileId,
+      file_name: data.file_name ?? "",
+      git_path: data.git_path ?? "",
+      operation: op,
+      agent_instance_id: callee,
+      tool_call_id: tcid,
+      task_purpose: this.extractString(p.ext, "task_purpose") ?? p.task_purpose ?? null
+    };
+    this.files.set(fid, node);
+    this.absorbPlaceholders(node);
+    const edgeType = op === "create" ? "produces" : op === "delete" ? "deletes" : "modifies";
+    if (tcid && this.actions.has(tcid)) {
+      this.addEdge(`action-${tcid}`, fid, edgeType, ts);
+    } else if (this.reasonings.size > 0) {
+      let latest = null;
+      for (const r of this.reasonings.values()) {
+        if (!latest || r.timestamp > latest.timestamp) latest = r;
+      }
+      if (latest) {
+        this.addEdge(latest.id, fid, edgeType, ts);
+      }
+    }
+  }
+  /** JETP-026: create references edges from xref scan result. */
+  handleXrefScanResult(p) {
+    const ext = p.ext;
+    if (!ext) return;
+    const sourceFileId = ext.source_file_id;
+    const xrefs = ext.xrefs;
+    if (!sourceFileId || !xrefs) return;
+    const ts = this.parseTimestamp(p.timestamp);
+    const sourceNodeId = `file-${sourceFileId}`;
+    for (const xref of xrefs) {
+      const targetFileId = xref.target_file_id;
+      const targetResource = xref.target_resource ?? "";
+      let targetNodeId;
+      if (targetFileId) {
+        targetNodeId = `file-${targetFileId}`;
+        if (!this.files.has(targetNodeId)) {
+          const resolved = this.resolveFileByName(targetFileId);
+          if (resolved) {
+            targetNodeId = resolved;
+          } else {
+            this.files.set(targetNodeId, {
+              id: targetNodeId,
+              type: "file",
+              label: targetFileId,
+              timestamp: ts,
+              metadata: { placeholder: true },
+              file_id: targetFileId,
+              file_name: "",
+              git_path: "",
+              operation: "referenced",
+              agent_instance_id: 0,
+              tool_call_id: null,
+              task_purpose: null
+            });
+          }
+        }
+      } else {
+        const hash = this.simpleHash(targetResource);
+        targetNodeId = `file-ext-url-${hash}`;
+        if (!this.files.has(targetNodeId)) {
+          const displayUrl = targetResource.replace("url://", "");
+          this.files.set(targetNodeId, {
+            id: targetNodeId,
+            type: "file",
+            label: displayUrl.length > 50 ? displayUrl.slice(0, 47) + "..." : displayUrl,
+            timestamp: ts,
+            metadata: { external: true },
+            file_id: `ext-url-${hash}`,
+            file_name: displayUrl,
+            git_path: targetResource,
+            operation: "external",
+            agent_instance_id: 0,
+            tool_call_id: null,
+            task_purpose: null
+          });
+        }
+      }
+      const description = xref.description ?? "";
+      this.addEdge(sourceNodeId, targetNodeId, "references", ts, description);
+    }
+  }
+  handlePlanResult(p) {
+    const checklist = this.extractChecklist(p.content);
+    if (!checklist) return;
+    for (const task of checklist) {
+      const tid = task.id ? `task-${task.id}` : `task-${task.description.slice(0, 20)}`;
+      const node = {
+        id: tid,
+        type: "task",
+        label: task.description,
+        timestamp: Date.now(),
+        metadata: {},
+        task_id: task.id ?? tid,
+        description: task.description,
+        status: task.status ?? "pending"
+      };
+      this.tasks.set(tid, node);
+    }
+  }
+  handleModelStart(p) {
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const ts = this.parseTimestamp(p.timestamp);
+    const rid = `reasoning-${callee}-${ts}`;
+    const node = {
+      id: rid,
+      type: "reasoning",
+      label: this.extractString(p.ext, "model") ?? "reasoning",
+      timestamp: ts,
+      metadata: {},
+      agent_instance_id: callee,
+      model: this.extractString(p.ext, "model") ?? "",
+      content_preview: "",
+      token_count: null,
+      duration_ms: null,
+      status: "thinking"
+    };
+    this.reasonings.set(rid, node);
+    if (this.agents.has(callee)) {
+      this.addEdge(`agent-inst-${callee}`, rid, "thinks", ts);
+    }
+    const prevActions = this.lastCompletedActions.get(callee) ?? [];
+    for (const tcid of prevActions) {
+      this.addEdge(`action-${tcid}`, rid, "informs", ts);
+    }
+    this.lastCompletedActions.delete(callee);
+  }
+  handleModelResult(p) {
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const latest = this.findLatestReasoning(callee);
+    if (!latest) return;
+    const preview = String(this.extractString(p.ext, "content_preview") ?? "").slice(0, 200);
+    this.reasonings.set(latest.id, {
+      ...latest,
+      status: "completed",
+      ...preview ? { content_preview: preview } : {}
+    });
+  }
+  handleModelEnd(p) {
+    const callee = p.callee_instance_id ?? p.agent_instance_id ?? 0;
+    const latest = this.findLatestReasoning(callee);
+    if (!latest) return;
+    const endTs = this.parseTimestamp(p.timestamp);
+    const duration = endTs - latest.timestamp;
+    const tokens = this.extractNumber(p.ext, "total_tokens");
+    this.reasonings.set(latest.id, {
+      ...latest,
+      status: "completed",
+      duration_ms: duration > 0 ? duration : null,
+      token_count: tokens
+    });
+  }
+  // -----------------------------------------------------------------------
+  // Helpers
+  // -----------------------------------------------------------------------
+  addEdge(source, target, type, ts, label) {
+    const key = this.edgeKey(source, target, type, label);
+    if (this.edgeKeys.has(key)) return;
+    this.edgeKeys.add(key);
+    this.edges.push({ source, target, type, label, timestamp: ts });
+  }
+  edgeKey(source, target, type, label) {
+    return label ? `${source}:${target}:${type}:${label}` : `${source}:${target}:${type}`;
+  }
+  findLatestReasoning(agentInstanceId) {
+    let latest = null;
+    for (const r of this.reasonings.values()) {
+      if (r.agent_instance_id === agentInstanceId) {
+        if (!latest || r.timestamp > latest.timestamp) latest = r;
+      }
+    }
+    return latest;
+  }
+  parseTimestamp(ts) {
+    if (ts == null) return Date.now();
+    if (typeof ts === "number") return ts;
+    const n = Date.parse(ts);
+    return Number.isNaN(n) ? Date.now() : n;
+  }
+  extractString(ext, key) {
+    if (!ext) return null;
+    const v = ext[key];
+    return typeof v === "string" ? v : null;
+  }
+  extractNumber(ext, key) {
+    if (!ext) return null;
+    const v = ext[key];
+    return typeof v === "number" ? v : null;
+  }
+  extractArtifactData(content) {
+    if (!content || !Array.isArray(content)) return null;
+    for (const part of content) {
+      const c = part?.content;
+      if (c?.data) return c.data;
+    }
+    return null;
+  }
+  normalizeOperation(op) {
+    const o = (op ?? "create").toLowerCase();
+    if (o === "create" || o === "update" || o === "delete" || o === "external" || o === "referenced") return o;
+    if (o.includes("create") || o.includes("add")) return "create";
+    if (o.includes("delete") || o.includes("remove")) return "delete";
+    return "update";
+  }
+  /** Merge placeholder file nodes into a real node, remapping all edges.
+   *  Uses exact + stem matching (same ambiguity-safe logic as resolveFileByName). */
+  absorbPlaceholders(realNode) {
+    const names = /* @__PURE__ */ new Set();
+    if (realNode.file_name) {
+      names.add(realNode.file_name);
+      const fnStem = _GraphBuilder.fileStem(realNode.file_name);
+      if (fnStem !== realNode.file_name) names.add(fnStem);
+    }
+    if (realNode.git_path) {
+      names.add(realNode.git_path);
+      const gpStem = _GraphBuilder.fileStem(realNode.git_path);
+      if (gpStem !== realNode.git_path) names.add(gpStem);
+      if (realNode.git_path.includes("/")) {
+        const basename = realNode.git_path.split("/").pop();
+        names.add(basename);
+        const bnStem = _GraphBuilder.fileStem(basename);
+        if (bnStem !== basename) names.add(bnStem);
+      }
+    }
+    const stemHits = /* @__PURE__ */ new Map();
+    for (const [id, node] of this.files) {
+      if (id === realNode.id) continue;
+      if (!node.metadata?.placeholder) continue;
+      const matchKey = node.file_id || node.label;
+      if (names.has(matchKey)) {
+        stemHits.set(id, [...stemHits.get(id) ?? [], matchKey]);
+      }
+    }
+    const toRemove = [];
+    for (const [id] of stemHits) {
+      for (const edge of this.edges) {
+        if (edge.source === id) edge.source = realNode.id;
+        if (edge.target === id) edge.target = realNode.id;
+      }
+      toRemove.push(id);
+    }
+    for (const id of toRemove) this.files.delete(id);
+  }
+  /** Match a file name/path against existing FileNodes by git_path or file_name.
+   *  Pass 1 — exact match.  Pass 2 — stem match (extension stripped) when
+   *  *name* has no extension and exactly one non-placeholder candidate exists. */
+  resolveFileByName(name) {
+    for (const node of this.files.values()) {
+      if (node.git_path === name || node.file_name === name) return node.id;
+      if (node.git_path && node.git_path.endsWith("/" + name)) return node.id;
+    }
+    if (_GraphBuilder.nameHasExtension(name)) return null;
+    const candidates = [];
+    for (const node of this.files.values()) {
+      if (node.operation === "referenced" || node.operation === "external") continue;
+      if (node.file_name && _GraphBuilder.fileStem(node.file_name) === name) {
+        candidates.push(node.id);
+        continue;
+      }
+      if (node.git_path) {
+        const gpStem = _GraphBuilder.fileStem(node.git_path);
+        if (gpStem === name || gpStem.endsWith("/" + name)) {
+          candidates.push(node.id);
+          continue;
+        }
+      }
+    }
+    const unique = [...new Set(candidates)];
+    return unique.length === 1 ? unique[0] : null;
+  }
+  /** Strip trailing extension: 'arch.md' → 'arch', 'a/b.txt' → 'a/b'. */
+  static fileStem(name) {
+    const slash = name.lastIndexOf("/");
+    const basename = name.slice(slash + 1);
+    const dot = basename.lastIndexOf(".");
+    if (dot > 0) return name.slice(0, slash + 1 + dot);
+    return name;
+  }
+  /** True when the trailing path component carries a dot-extension (ignores dotfiles). */
+  static nameHasExtension(name) {
+    const slash = name.lastIndexOf("/");
+    const basename = name.slice(slash + 1);
+    return basename.lastIndexOf(".") > 0;
+  }
+  simpleHash(s) {
+    let h = 0;
+    for (let i = 0; i < s.length; i++) {
+      h = (h << 5) - h + s.charCodeAt(i) | 0;
+    }
+    return Math.abs(h).toString(16).padStart(8, "0").slice(0, 8);
+  }
+  extractChecklist(content) {
+    if (!content || !Array.isArray(content)) return null;
+    for (const part of content) {
+      const typed = part;
+      if (typed.type === "checklist" && typed.content?.tasks) {
+        return typed.content.tasks;
+      }
+    }
+    return null;
+  }
+};
+
+// src/provenance/api.ts
+async function fetchProvenanceGraph(fetcher, opts) {
+  const params = {};
+  if (opts.sinceTurnId != null && opts.sinceTurnId > 0) {
+    params.since_turn_id = opts.sinceTurnId;
+  }
+  if (opts.limit != null && opts.limit > 0) {
+    params.limit = opts.limit;
+  }
+  return fetcher(opts.sessionId, Object.keys(params).length > 0 ? params : void 0);
+}
+
+// src/provenance/hooks/useProvenanceGraph.ts
+var EMPTY_SNAPSHOT = {
+  session_id: 0,
+  generated_at: 0,
+  node_count: 0,
+  edge_count: 0,
+  max_turn_id: null,
+  nodes: { agents: [], actions: [], files: [], tasks: [], reasonings: [] },
+  edges: [],
+  stats: { agent_count: 0, action_count: 0, file_count: 0, task_count: 0, reasoning_count: 0, max_depth: 0 }
+};
+var DEBOUNCE_MS = 80;
+function useProvenanceGraph(opts) {
+  const { sessionId, fetcher, enabled = true, pollInterval = 3e3 } = opts;
+  const builderRef = useRef(new GraphBuilder());
+  const maxTurnIdRef = useRef(null);
+  const debounceTimerRef = useRef(null);
+  const mountedRef = useRef(true);
+  const [graph, setGraph] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const flushSnapshot = useCallback(() => {
+    if (!mountedRef.current) return;
+    const snap = builderRef.current.getSnapshot();
+    setGraph(snap);
+  }, []);
+  const scheduleFlush = useCallback(() => {
+    if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+    debounceTimerRef.current = setTimeout(flushSnapshot, DEBOUNCE_MS);
+  }, [flushSnapshot]);
+  const fetchSnapshot = useCallback(
+    async (sinceTurnId) => {
+      if (!sessionId || !fetcher) return;
+      setLoading(true);
+      setError(null);
+      try {
+        const snap = await fetchProvenanceGraph(fetcher, {
+          sessionId,
+          sinceTurnId
+        });
+        if (!mountedRef.current) return;
+        if (sinceTurnId != null && sinceTurnId > 0) {
+          builderRef.current.mergeSnapshot(snap);
+        } else {
+          builderRef.current.replaceWithSnapshot(snap);
+        }
+        maxTurnIdRef.current = snap.max_turn_id;
+        flushSnapshot();
+      } catch (e) {
+        if (!mountedRef.current) return;
+        const err = e instanceof Error ? e : new Error(String(e));
+        setError(err);
+      } finally {
+        if (mountedRef.current) setLoading(false);
+      }
+    },
+    [sessionId, fetcher, flushSnapshot]
+  );
+  const processEvent = useCallback(
+    (payload) => {
+      const handled = builderRef.current.applyEvent(payload);
+      if (handled) scheduleFlush();
+    },
+    [scheduleFlush]
+  );
+  const refetch = useCallback(() => {
+    fetchSnapshot(maxTurnIdRef.current);
+  }, [fetchSnapshot]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (sessionId && enabled) {
+      builderRef.current = new GraphBuilder();
+      maxTurnIdRef.current = null;
+      fetchSnapshot(null);
+    } else {
+      setGraph(sessionId ? null : EMPTY_SNAPSHOT);
+    }
+    return () => {
+      mountedRef.current = false;
+      if (debounceTimerRef.current) clearTimeout(debounceTimerRef.current);
+    };
+  }, [sessionId, enabled, fetchSnapshot]);
+  useEffect(() => {
+    if (!sessionId || !enabled || pollInterval <= 0) return;
+    const id = setInterval(() => {
+      if (!mountedRef.current) return;
+      fetchSnapshot(maxTurnIdRef.current);
+    }, pollInterval);
+    return () => clearInterval(id);
+  }, [sessionId, enabled, pollInterval, fetchSnapshot]);
+  return { graph, loading, error, processEvent, refetch };
+}
+
+// src/provenance/components/ProvenanceGraph3D.tsx
+import React, { useCallback as useCallback2, useEffect as useEffect2, useMemo, useRef as useRef2, useState as useState2 } from "react";
+import ForceGraph3D from "react-force-graph-3d";
+import * as THREE2 from "three";
+import SpriteText from "three-spritetext";
+
+// src/provenance/components/NodeMeshFactory.ts
+import * as THREE from "three";
+
+// src/provenance/constants.ts
+var NODE_COLORS = {
+  agent: "#667eea",
+  action: "#f5a623",
+  file: "#50c878",
+  task: "#e74c8b",
+  reasoning: "#9b59b6"
+};
+var NODE_COLORS_HEX = {
+  agent: 6717162,
+  action: 16098851,
+  file: 5294200,
+  task: 15158411,
+  reasoning: 10181046
+};
+var NODE_EMISSIVE = {
+  agent: 3363008,
+  action: 12614160,
+  file: 2787912,
+  task: 12071024,
+  reasoning: 7223946
+};
+var NODE_SIZES = {
+  agent: 6,
+  action: 4.5,
+  file: 3.5,
+  task: 4,
+  reasoning: 5
+};
+var EDGE_COLORS = {
+  spawns: "#667eea",
+  executes: "#f5a623",
+  produces: "#50c878",
+  modifies: "#36a3d9",
+  deletes: "#e74c3c",
+  thinks: "#9b59b6",
+  triggers: "#e67e22",
+  informs: "#3498db",
+  references: "#8e44ad"
+  // JETP-026: purple for cross-references
+};
+var EDGE_WIDTHS = {
+  spawns: 3,
+  executes: 2,
+  produces: 1.8,
+  modifies: 1.8,
+  deletes: 1.5,
+  thinks: 2.5,
+  triggers: 2,
+  informs: 1.8,
+  references: 1
+  // JETP-026: thin for cross-references
+};
+var SCENE_BG = 16119802;
+var CAMERA_DISTANCE = 400;
+var CAMERA_FOCUS_DURATION_MS = 600;
+var LINK_PARTICLE_COUNT = 2;
+var LINK_PARTICLE_WIDTH = 3;
+var LINK_PARTICLE_SPEED = 4e-3;
+var DIM_OPACITY = 0.08;
+var SELECTED_SCALE = 1.4;
+var NORMAL_OPACITY = 0.9;
+var LABEL_FONT_SIZE = 3;
+var LABEL_COLOR = "#333";
+
+// src/provenance/components/NodeMeshFactory.ts
+var geoCache = /* @__PURE__ */ new Map();
+function getOrCreateGeometry(type) {
+  const cached = geoCache.get(type);
+  if (cached) return cached;
+  let geo;
+  const s = NODE_SIZES[type];
+  switch (type) {
+    case "agent":
+      geo = new THREE.SphereGeometry(s, 24, 16);
+      break;
+    case "action":
+      geo = new THREE.IcosahedronGeometry(s, 0);
+      break;
+    case "file":
+      geo = new THREE.BoxGeometry(s * 1.2, s * 1.2, s * 1.2);
+      break;
+    case "task":
+      geo = new THREE.OctahedronGeometry(s, 0);
+      break;
+    case "reasoning":
+      geo = new THREE.TorusGeometry(s * 0.7, s * 0.3, 12, 24);
+      break;
+    default:
+      geo = new THREE.SphereGeometry(s, 16, 12);
+  }
+  geoCache.set(type, geo);
+  return geo;
+}
+function createNodeMesh(type, opts = {}) {
+  const geo = getOrCreateGeometry(type);
+  const mat = new THREE.MeshStandardMaterial({
+    color: NODE_COLORS_HEX[type],
+    emissive: NODE_EMISSIVE[type],
+    emissiveIntensity: opts.selected ? 0.6 : 0.25,
+    metalness: 0.15,
+    roughness: 0.55,
+    transparent: true,
+    opacity: opts.dimmed ? DIM_OPACITY : NORMAL_OPACITY
+  });
+  const mesh = new THREE.Mesh(geo, mat);
+  if (opts.selected) {
+    mesh.scale.setScalar(SELECTED_SCALE);
+  }
+  mesh.castShadow = false;
+  mesh.receiveShadow = false;
+  return mesh;
+}
+function disposeGeometryCache() {
+  for (const geo of geoCache.values()) {
+    geo.dispose();
+  }
+  geoCache.clear();
+}
+
+// src/provenance/components/ProvenanceGraph3D.tsx
+import { jsx } from "react/jsx-runtime";
+var HIDDEN_EDGE_TYPES = /* @__PURE__ */ new Set(["spawns", "executes", "thinks"]);
+function flattenNodes(snap) {
+  const { actions, files, tasks, reasonings } = snap.nodes;
+  return [...actions, ...files, ...tasks, ...reasonings];
+}
+function getConnectedIds(nodeId, edges, hops) {
+  const visited = /* @__PURE__ */ new Set([nodeId]);
+  let frontier = /* @__PURE__ */ new Set([nodeId]);
+  for (let h = 0; h < hops; h++) {
+    const next = /* @__PURE__ */ new Set();
+    for (const e of edges) {
+      if (frontier.has(e.source) && !visited.has(e.target)) {
+        visited.add(e.target);
+        next.add(e.target);
+      }
+      if (frontier.has(e.target) && !visited.has(e.source)) {
+        visited.add(e.source);
+        next.add(e.source);
+      }
+    }
+    if (next.size === 0) break;
+    frontier = next;
+  }
+  return visited;
+}
+function truncate(s, maxLen) {
+  return s.length > maxLen ? s.slice(0, maxLen - 1) + "\u2026" : s;
+}
+function wrapText(s, lineWidth, maxLines) {
+  const clean = s.replace(/\n/g, " ").trim();
+  const lines = [];
+  let pos = 0;
+  for (let i = 0; i < maxLines && pos < clean.length; i++) {
+    const remaining = clean.slice(pos);
+    if (remaining.length <= lineWidth) {
+      lines.push(remaining);
+      break;
+    }
+    lines.push(remaining.slice(0, lineWidth));
+    pos += lineWidth;
+  }
+  const result = lines.join("\n");
+  return pos < clean.length ? result + "\u2026" : result;
+}
+var ProvenanceGraph3DInner = ({
+  graph,
+  width,
+  height,
+  selectedNodeId = null,
+  onNodeClick,
+  onNodeHover,
+  onBackgroundClick,
+  depthFilter
+}) => {
+  const fgRef = useRef2(void 0);
+  const [hoveredNodeId, setHoveredNodeId] = useState2(null);
+  const graphData = useMemo(() => {
+    const allNodes = flattenNodes(graph);
+    const nodeMap = new Set(allNodes.map((n) => n.id));
+    const purposeByNodeId = /* @__PURE__ */ new Map();
+    for (const a of graph.nodes.actions) {
+      if (a.task_purpose) purposeByNodeId.set(a.id, a.task_purpose);
+    }
+    for (const f of graph.nodes.files) {
+      if (f.task_purpose) purposeByNodeId.set(f.id, f.task_purpose);
+    }
+    const previewById = /* @__PURE__ */ new Map();
+    for (const r of graph.nodes.reasonings) {
+      if (r.content_preview) previewById.set(r.id, r.content_preview);
+    }
+    const agentNameByInstId = /* @__PURE__ */ new Map();
+    for (const a of graph.nodes.agents) {
+      agentNameByInstId.set(a.agent_instance_id, a.agent_name || a.agent_id || `agent-${a.agent_instance_id}`);
+    }
+    const nodes = allNodes.map((n) => {
+      const instId = "agent_instance_id" in n ? n.agent_instance_id : void 0;
+      return {
+        id: n.id,
+        type: n.type,
+        label: n.label,
+        subtitle: purposeByNodeId.get(n.id),
+        contentPreview: previewById.get(n.id),
+        agentLabel: instId != null ? agentNameByInstId.get(instId) : void 0,
+        status: "status" in n ? n.status : void 0,
+        level: "level" in n ? n.level : void 0,
+        agentInstanceId: instId
+      };
+    });
+    const links = graph.edges.filter((e) => !HIDDEN_EDGE_TYPES.has(e.type) && nodeMap.has(e.source) && nodeMap.has(e.target)).map((e) => {
+      const purpose = purposeByNodeId.get(e.target) ?? purposeByNodeId.get(e.source) ?? void 0;
+      return {
+        source: e.source,
+        target: e.target,
+        type: e.type,
+        timestamp: e.timestamp,
+        label: e.label || purpose
+      };
+    });
+    return { nodes, links };
+  }, [graph]);
+  const connectedSet = useMemo(() => {
+    if (!selectedNodeId) return null;
+    return getConnectedIds(selectedNodeId, graph.edges, depthFilter ?? 2);
+  }, [selectedNodeId, graph.edges, depthFilter]);
+  const nodeThreeObject = useCallback2(
+    (node) => {
+      const isDimmed = connectedSet != null && !connectedSet.has(node.id);
+      const isSelected = node.id === selectedNodeId;
+      const isRunning = node.status === "running" || node.status === "thinking";
+      const group = new THREE2.Group();
+      if (node.type === "reasoning") {
+        const agentName = node.agentLabel ?? "Agent";
+        const bodyText = node.contentPreview ? wrapText(node.contentPreview, 28, 2) : isRunning ? "Thinking\u2026" : "";
+        const dimAlpha = isDimmed ? 0.15 : 1;
+        const header = new SpriteText(
+          (isRunning ? "\u25CF " : "") + agentName,
+          2,
+          isDimmed ? "#bbb" : isRunning ? "#9b59b6" : "#667eea"
+        );
+        header.fontFace = "Inter, system-ui, sans-serif";
+        header.fontWeight = "600";
+        header.backgroundColor = "transparent";
+        header.padding = [0, 0];
+        header.position.y = bodyText ? 4.5 : 0;
+        header.material.opacity = dimAlpha;
+        group.add(header);
+        if (bodyText) {
+          const body = new SpriteText(
+            bodyText,
+            2.2,
+            isDimmed ? "#ccc" : "#444"
+          );
+          body.fontFace = "Inter, system-ui, sans-serif";
+          body.backgroundColor = isDimmed ? "rgba(245,245,245,0.2)" : isSelected ? "rgba(102,126,234,0.08)" : "rgba(255,255,255,0.92)";
+          body.borderWidth = isSelected ? 1 : 0.4;
+          body.borderColor = isDimmed ? "transparent" : isSelected ? "rgba(102,126,234,0.5)" : "rgba(0,0,0,0.08)";
+          body.borderRadius = 3;
+          body.padding = [2.5, 4];
+          body.material.opacity = dimAlpha;
+          group.add(body);
+        }
+        return group;
+      }
+      const mesh = createNodeMesh(node.type, {
+        selected: isSelected,
+        dimmed: isDimmed,
+        running: isRunning
+      });
+      group.add(mesh);
+      const nodeRadius = NODE_SIZES[node.type] ?? 5;
+      if (isRunning && !isDimmed) {
+        const ringGeo = new THREE2.RingGeometry(nodeRadius * 1.6, nodeRadius * 1.8, 32);
+        const ringMat = new THREE2.MeshBasicMaterial({
+          color: NODE_COLORS[node.type] ?? "#667eea",
+          transparent: true,
+          opacity: 0.4,
+          side: THREE2.DoubleSide
+        });
+        const ring = new THREE2.Mesh(ringGeo, ringMat);
+        ring.rotation.x = Math.PI / 2;
+        ring.userData.__orbitRing = true;
+        group.add(ring);
+      }
+      if (!isDimmed) {
+        const nameLabel = new SpriteText(
+          truncate(node.label, 20),
+          LABEL_FONT_SIZE,
+          LABEL_COLOR
+        );
+        nameLabel.backgroundColor = "rgba(255,255,255,0.85)";
+        nameLabel.borderRadius = 2;
+        nameLabel.padding = [1, 3];
+        nameLabel.position.y = -(nodeRadius + 4);
+        group.add(nameLabel);
+        if (node.subtitle) {
+          const purposeLabel = new SpriteText(
+            truncate(node.subtitle, 16),
+            2.2,
+            "#888"
+          );
+          purposeLabel.backgroundColor = "rgba(245,247,250,0.9)";
+          purposeLabel.borderRadius = 1.5;
+          purposeLabel.padding = [0.5, 2];
+          purposeLabel.position.y = -(nodeRadius + 8);
+          group.add(purposeLabel);
+        }
+      }
+      return group;
+    },
+    [connectedSet, selectedNodeId]
+  );
+  const CAUSAL_EDGES = /* @__PURE__ */ new Set(["triggers", "informs"]);
+  const linkColor = useCallback2(
+    (link) => {
+      const edgeColor = EDGE_COLORS[link.type] ?? "#c0c0c0";
+      if (connectedSet) {
+        const srcId = typeof link.source === "object" ? link.source.id : link.source;
+        const tgtId = typeof link.target === "object" ? link.target.id : link.target;
+        if (!connectedSet.has(srcId) || !connectedSet.has(tgtId)) {
+          return `rgba(200,200,200,${DIM_OPACITY})`;
+        }
+      }
+      return edgeColor;
+    },
+    [connectedSet]
+  );
+  const linkWidth = useCallback2(
+    (link) => {
+      const base = EDGE_WIDTHS[link.type] ?? 1.5;
+      return base * 1.2;
+    },
+    []
+  );
+  const linkCurvature = useCallback2(
+    (link) => {
+      if (link.type === "references") return 0.35;
+      if (link.type === "informs") return 0.3;
+      if (link.type === "triggers") return 0.2;
+      return 0.06;
+    },
+    []
+  );
+  const linkParticleSpeed = useCallback2(
+    (link) => {
+      if (CAUSAL_EDGES.has(link.type)) return 8e-3;
+      return LINK_PARTICLE_SPEED;
+    },
+    []
+  );
+  const linkArrowLength = useCallback2(
+    (link) => {
+      if (CAUSAL_EDGES.has(link.type)) return 7;
+      return 4;
+    },
+    []
+  );
+  const linkParticles = useCallback2(
+    (link) => {
+      if (link.type === "references") return 0;
+      if (connectedSet) {
+        const srcId = typeof link.source === "object" ? link.source.id : link.source;
+        const tgtId = typeof link.target === "object" ? link.target.id : link.target;
+        if (!connectedSet.has(srcId) || !connectedSet.has(tgtId)) return 0;
+      }
+      return LINK_PARTICLE_COUNT;
+    },
+    [connectedSet]
+  );
+  useEffect2(() => {
+    if (!fgRef.current) return;
+    const fg = fgRef.current;
+    try {
+      fg.d3Force("charge")?.strength(-420);
+      fg.d3Force("link")?.distance((link) => {
+        switch (link.type) {
+          case "references":
+            return 160;
+          case "informs":
+            return 120;
+          case "triggers":
+            return 100;
+          case "spawns":
+            return 140;
+          default:
+            return 80;
+        }
+      });
+      fg.d3Force("center")?.strength(0.04);
+    } catch {
+    }
+  }, [graphData]);
+  useEffect2(() => {
+    if (!selectedNodeId || !fgRef.current) return;
+    const node = graphData.nodes.find((n) => n.id === selectedNodeId);
+    if (!node || node.x == null || node.y == null || node.z == null) return;
+    fgRef.current.cameraPosition(
+      { x: node.x + CAMERA_DISTANCE * 0.3, y: node.y + CAMERA_DISTANCE * 0.2, z: node.z + CAMERA_DISTANCE * 0.5 },
+      { x: node.x, y: node.y, z: node.z },
+      CAMERA_FOCUS_DURATION_MS
+    );
+  }, [selectedNodeId, graphData.nodes]);
+  useEffect2(() => {
+    if (!fgRef.current) return;
+    try {
+      const scene = fgRef.current.scene();
+      if (!scene) return;
+      if (scene.userData.__lightsConfigured) return;
+      scene.userData.__lightsConfigured = true;
+      const ambient = new THREE2.AmbientLight(16777215, 0.7);
+      const directional = new THREE2.DirectionalLight(16777215, 0.8);
+      directional.position.set(100, 200, 150);
+      scene.add(ambient, directional);
+      scene.fog = new THREE2.Fog(SCENE_BG, 600, 1600);
+    } catch {
+    }
+  });
+  useEffect2(() => {
+    let frameId;
+    const animate = () => {
+      if (!fgRef.current) return;
+      try {
+        const scene = fgRef.current.scene();
+        if (!scene) return;
+        scene.traverse((obj) => {
+          if (obj.userData.__orbitRing) {
+            obj.rotation.z += 0.02;
+          }
+        });
+      } catch {
+      }
+      frameId = requestAnimationFrame(animate);
+    };
+    frameId = requestAnimationFrame(animate);
+    return () => cancelAnimationFrame(frameId);
+  }, []);
+  useEffect2(() => {
+    return () => {
+      disposeGeometryCache();
+    };
+  }, []);
+  const handleNodeClick = useCallback2(
+    (node) => {
+      onNodeClick?.(node.id, node.type);
+    },
+    [onNodeClick]
+  );
+  const handleNodeHover = useCallback2(
+    (node) => {
+      const id = node?.id ?? null;
+      setHoveredNodeId(id);
+      onNodeHover?.(id);
+    },
+    [onNodeHover]
+  );
+  const handleBgClick = useCallback2(() => {
+    onBackgroundClick?.();
+  }, [onBackgroundClick]);
+  const EDGE_TYPE_LABELS = {
+    spawns: "Spawns",
+    executes: "Executes",
+    produces: "Produces",
+    modifies: "Modifies",
+    deletes: "Deletes",
+    thinks: "Thinks",
+    triggers: "Triggers",
+    informs: "Informs",
+    references: "\u5F15\u7528"
+    // JETP-026
+  };
+  const linkLabel = useCallback2(
+    (link) => {
+      const typeLabel = EDGE_TYPE_LABELS[link.type] ?? link.type;
+      const color = EDGE_COLORS[link.type] ?? "#888";
+      const lines = [
+        `<span style="color:${color};font-weight:600">${typeLabel}</span>`
+      ];
+      if (link.label) lines.push(link.label);
+      return `<div style="background:rgba(255,255,255,0.96);color:#444;padding:8px 12px;border-radius:6px;font-size:13px;line-height:1.6;box-shadow:0 2px 8px rgba(0,0,0,0.12);max-width:320px;word-break:break-all;border:1px solid #e8e8e8">${lines.join("<br/>")}</div>`;
+    },
+    []
+  );
+  const nodeLabel = useCallback2(
+    (node) => {
+      if (hoveredNodeId !== node.id) return "";
+      const lines = [];
+      if (node.type === "reasoning") {
+        lines.push(`<b>${node.agentLabel ?? "Reasoning"}</b>`);
+        if (node.status) lines.push(`Status: ${node.status}`);
+        if (node.contentPreview) {
+          const preview = node.contentPreview.length > 120 ? node.contentPreview.slice(0, 120) + "\u2026" : node.contentPreview;
+          lines.push(`<span style="color:#666">${preview}</span>`);
+        }
+      } else {
+        lines.push(`<b>${node.label}</b>`);
+        if (node.subtitle) lines.push(`Purpose: ${node.subtitle}`);
+        if (node.status) lines.push(`Status: ${node.status}`);
+      }
+      return `<div style="background:rgba(255,255,255,0.96);color:#333;padding:8px 12px;border-radius:6px;font-size:13px;line-height:1.6;box-shadow:0 2px 8px rgba(0,0,0,0.15);border:1px solid #e8e8e8;max-width:360px;word-break:break-all">${lines.join("<br/>")}</div>`;
+    },
+    [hoveredNodeId]
+  );
+  return /* @__PURE__ */ jsx(
+    ForceGraph3D,
+    {
+      ref: fgRef,
+      graphData,
+      width,
+      height,
+      backgroundColor: `#${SCENE_BG.toString(16).padStart(6, "0")}`,
+      showNavInfo: false,
+      nodeThreeObject,
+      nodeLabel,
+      linkLabel,
+      linkColor,
+      linkWidth,
+      linkOpacity: 0.75,
+      linkCurvature,
+      linkDirectionalParticles: linkParticles,
+      linkDirectionalParticleWidth: LINK_PARTICLE_WIDTH,
+      linkDirectionalParticleSpeed: linkParticleSpeed,
+      linkDirectionalParticleColor: linkColor,
+      linkDirectionalArrowLength: linkArrowLength,
+      linkDirectionalArrowRelPos: 0.92,
+      linkDirectionalArrowColor: linkColor,
+      d3AlphaDecay: 0.04,
+      d3VelocityDecay: 0.4,
+      warmupTicks: 200,
+      cooldownTicks: 0,
+      cooldownTime: 3e3,
+      onNodeClick: handleNodeClick,
+      onNodeHover: handleNodeHover,
+      onBackgroundClick: handleBgClick,
+      enableNodeDrag: true,
+      enableNavigationControls: true
+    }
+  );
+};
+var ProvenanceGraph3D = React.memo(ProvenanceGraph3DInner);
+
+// src/provenance/components/GraphStatsLegend.tsx
+import React2, { useMemo as useMemo2 } from "react";
+import { Badge, Space } from "antd";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var LEGEND_LABEL_KEYS = {
+  reasoning: "provenance.legend.reasoning",
+  action: "provenance.legend.action",
+  file: "provenance.legend.file",
+  task: "provenance.legend.task"
+};
+var LEGEND_TYPES = ["reasoning", "action", "file", "task"];
+var statKey = (type) => {
+  const map = {
+    agent: "agent_count",
+    action: "action_count",
+    file: "file_count",
+    task: "task_count",
+    reasoning: "reasoning_count"
+  };
+  return map[type];
+};
+var GraphStatsLegendInner = ({
+  stats,
+  edgeCount
+}) => {
+  const { t } = useChatWidgetI18n();
+  const legendItems = useMemo2(
+    () => LEGEND_TYPES.map((type) => ({ type, label: t(LEGEND_LABEL_KEYS[type]) })),
+    [t]
+  );
+  return /* @__PURE__ */ jsx2(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        left: 16,
+        bottom: 16,
+        zIndex: 10,
+        background: "rgba(255,255,255,0.92)",
+        backdropFilter: "blur(8px)",
+        padding: "10px 14px",
+        borderRadius: 10,
+        boxShadow: "0 1px 6px rgba(0,0,0,0.08)",
+        fontSize: 12,
+        lineHeight: 1.8
+      },
+      children: /* @__PURE__ */ jsxs(Space, { orientation: "vertical", size: 2, children: [
+        legendItems.map(({ type, label }) => {
+          const count = stats[statKey(type)];
+          if (count === 0) return null;
+          return /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+            /* @__PURE__ */ jsx2(Badge, { color: NODE_COLORS[type] }),
+            /* @__PURE__ */ jsx2("span", { style: { color: "#555" }, children: label }),
+            /* @__PURE__ */ jsx2("span", { style: { fontWeight: 600, color: "#333" }, children: count })
+          ] }, type);
+        }),
+        /* @__PURE__ */ jsxs("div", { style: { display: "flex", alignItems: "center", gap: 6 }, children: [
+          /* @__PURE__ */ jsx2(
+            "div",
+            {
+              style: {
+                width: 14,
+                height: 0,
+                borderTop: `2px dashed ${EDGE_COLORS.references}`
+              }
+            }
+          ),
+          /* @__PURE__ */ jsx2("span", { style: { color: "#555" }, children: t("provenance.legend.references") })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { style: { borderTop: "1px solid #eee", paddingTop: 4, marginTop: 2 }, children: [
+          /* @__PURE__ */ jsx2("span", { style: { color: "#999" }, children: t("provenance.legend.edges") }),
+          /* @__PURE__ */ jsx2("span", { style: { fontWeight: 600, color: "#333" }, children: edgeCount }),
+          /* @__PURE__ */ jsxs("span", { style: { color: "#999", marginLeft: 8 }, children: [
+            t("provenance.legend.depth"),
+            stats.max_depth
+          ] })
+        ] })
+      ] })
+    }
+  );
+};
+var GraphStatsLegend = React2.memo(GraphStatsLegendInner);
+
+// src/provenance/components/NodeDetailPanel.tsx
+import React3, { useMemo as useMemo3 } from "react";
+import { Drawer, Descriptions, Tag, Typography, Space as Space2, Badge as Badge2 } from "antd";
+import { Fragment, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+var { Text, Paragraph } = Typography;
+var TYPE_LABEL_KEYS = {
+  agent: "provenance.filter.type.agent",
+  action: "provenance.filter.type.action",
+  file: "provenance.filter.type.file",
+  task: "provenance.filter.type.task",
+  reasoning: "provenance.filter.type.reasoning"
+};
+function findNode(graph, nodeId) {
+  const all = [
+    ...graph.nodes.agents,
+    ...graph.nodes.actions,
+    ...graph.nodes.files,
+    ...graph.nodes.tasks,
+    ...graph.nodes.reasonings
+  ];
+  return all.find((n) => n.id === nodeId) ?? null;
+}
+function formatTimestamp(ts) {
+  return new Date(ts).toLocaleString("zh-CN");
+}
+function formatDuration(ms) {
+  if (ms == null) return "-";
+  if (ms < 1e3) return `${ms}ms`;
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+var NodeDetailPanelInner = ({
+  open,
+  nodeId,
+  graph,
+  onClose
+}) => {
+  const { t } = useChatWidgetI18n();
+  const node = useMemo3(() => nodeId ? findNode(graph, nodeId) : null, [graph, nodeId]);
+  const relatedEdges = useMemo3(() => {
+    if (!nodeId) return [];
+    return graph.edges.filter((e) => e.source === nodeId || e.target === nodeId);
+  }, [graph.edges, nodeId]);
+  if (!node) {
+    return /* @__PURE__ */ jsx3(Drawer, { title: t("provenance.detail.title"), open, onClose, width: 360, children: /* @__PURE__ */ jsx3(Text, { type: "secondary", children: t("provenance.detail.noSelection") }) });
+  }
+  return /* @__PURE__ */ jsxs2(
+    Drawer,
+    {
+      title: /* @__PURE__ */ jsxs2(Space2, { children: [
+        /* @__PURE__ */ jsx3(Badge2, { color: NODE_COLORS[node.type] }),
+        /* @__PURE__ */ jsx3("span", { children: t(TYPE_LABEL_KEYS[node.type]) }),
+        /* @__PURE__ */ jsx3(Tag, { children: node.type })
+      ] }),
+      open,
+      onClose,
+      width: 380,
+      destroyOnHidden: true,
+      children: [
+        /* @__PURE__ */ jsxs2(Descriptions, { column: 1, size: "small", bordered: true, children: [
+          /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.name"), children: /* @__PURE__ */ jsx3(Text, { strong: true, children: node.label }) }),
+          /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.id"), children: /* @__PURE__ */ jsx3(Text, { code: true, copyable: true, children: node.id }) }),
+          /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.timestamp"), children: formatTimestamp(node.timestamp) }),
+          node.type === "agent" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.agentId"), children: /* @__PURE__ */ jsx3(Text, { code: true, children: node.agent_id }) }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.instanceId"), children: node.agent_instance_id }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.level"), children: node.level }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.status"), children: /* @__PURE__ */ jsx3(Tag, { color: node.status === "running" ? "processing" : node.status === "completed" ? "success" : "error", children: node.status ?? "unknown" }) })
+          ] }),
+          node.type === "action" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.tool"), children: node.tool_name }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.purpose"), children: node.task_purpose || "-" }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.status"), children: /* @__PURE__ */ jsx3(Tag, { color: node.status === "success" ? "success" : node.status === "error" ? "error" : "processing", children: node.status }) }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.duration"), children: formatDuration(node.duration_ms) })
+          ] }),
+          node.type === "file" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.path"), children: /* @__PURE__ */ jsx3(Text, { code: true, children: node.git_path }) }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.operation"), children: /* @__PURE__ */ jsx3(Tag, { color: node.operation === "create" ? "green" : node.operation === "delete" ? "red" : "blue", children: node.operation }) })
+          ] }),
+          node.type === "task" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.taskId"), children: node.task_id }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.status"), children: /* @__PURE__ */ jsx3(Tag, { children: node.status }) }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.description"), children: /* @__PURE__ */ jsx3(Paragraph, { ellipsis: { rows: 3 }, children: node.description }) })
+          ] }),
+          node.type === "reasoning" && /* @__PURE__ */ jsxs2(Fragment, { children: [
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.model"), children: node.model || "-" }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.tokenCount"), children: node.token_count ?? "-" }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.duration"), children: formatDuration(node.duration_ms) }),
+            /* @__PURE__ */ jsx3(Descriptions.Item, { label: t("provenance.detail.label.reasoningPreview"), children: /* @__PURE__ */ jsx3(Paragraph, { ellipsis: { rows: 5 }, children: node.content_preview || "(empty)" }) })
+          ] })
+        ] }),
+        relatedEdges.length > 0 && /* @__PURE__ */ jsxs2(Fragment, { children: [
+          /* @__PURE__ */ jsx3(Text, { strong: true, style: { display: "block", marginTop: 16, marginBottom: 8 }, children: t("provenance.detail.relatedEdges", { count: relatedEdges.length }) }),
+          /* @__PURE__ */ jsx3(Space2, { orientation: "vertical", size: 4, style: { width: "100%" }, children: relatedEdges.slice(0, 20).map((e, i) => /* @__PURE__ */ jsxs2("div", { style: { fontSize: 12, color: "#666" }, children: [
+            /* @__PURE__ */ jsx3(Tag, { color: "default", style: { fontSize: 11 }, children: e.type }),
+            e.source === nodeId ? `\u2192 ${e.target}` : `\u2190 ${e.source}`
+          ] }, i)) })
+        ] })
+      ]
+    }
+  );
+};
+var NodeDetailPanel = React3.memo(NodeDetailPanelInner);
+
+// src/provenance/ProvenanceGraphDrawerContent.tsx
+import { Fragment as Fragment2, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
+function useContainerSize(ref) {
+  const [size, setSize] = React4.useState({ width: 600, height: 500 });
+  React4.useEffect(() => {
+    if (!ref.current) return;
+    const observer = new ResizeObserver((entries) => {
+      for (const entry of entries) {
+        const { width, height } = entry.contentRect;
+        setSize({ width: Math.floor(width), height: Math.floor(height) });
+      }
+    });
+    observer.observe(ref.current);
+    return () => observer.disconnect();
+  }, [ref]);
+  return size;
+}
+var ProvenanceGraphDrawerContent = ({
+  sessionId,
+  onProcessEventRef
+}) => {
+  const { t } = useChatWidgetI18n();
+  const containerRef = useRef3(null);
+  const { width, height } = useContainerSize(containerRef);
+  const { graph, loading, error, processEvent } = useProvenanceGraph({
+    sessionId,
+    enabled: true
+  });
+  useEffect3(() => {
+    if (onProcessEventRef) {
+      onProcessEventRef.current = processEvent;
+    }
+    return () => {
+      if (onProcessEventRef) {
+        onProcessEventRef.current = null;
+      }
+    };
+  }, [onProcessEventRef, processEvent]);
+  const [selectedNodeId, setSelectedNodeId] = useState3(null);
+  const [detailOpen, setDetailOpen] = useState3(false);
+  const handleNodeClick = useCallback3((nodeId, _nodeType) => {
+    setSelectedNodeId(nodeId);
+    setDetailOpen(true);
+  }, []);
+  const handleBackgroundClick = useCallback3(() => {
+    setSelectedNodeId(null);
+    setDetailOpen(false);
+  }, []);
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      ref: containerRef,
+      style: { width: "100%", height: "100%", minHeight: 400, position: "relative" },
+      children: [
+        loading && !graph && /* @__PURE__ */ jsx4("div", { className: "ycw-provenance-loading", children: /* @__PURE__ */ jsx4(Spin, { size: "large" }) }),
+        error && !graph && /* @__PURE__ */ jsx4("div", { className: "ycw-provenance-empty", children: /* @__PURE__ */ jsx4("span", { style: { color: "#ff4d4f" }, children: error.message }) }),
+        graph && graph.node_count === 0 && !loading && /* @__PURE__ */ jsx4(Empty, { description: t("provenance.drawer.emptyGraph"), style: { paddingTop: 80 } }),
+        graph && graph.node_count > 0 && /* @__PURE__ */ jsxs3(Fragment2, { children: [
+          /* @__PURE__ */ jsx4(
+            ProvenanceGraph3D,
+            {
+              graph,
+              width,
+              height,
+              selectedNodeId,
+              onNodeClick: handleNodeClick,
+              onBackgroundClick: handleBackgroundClick
+            }
+          ),
+          /* @__PURE__ */ jsx4(GraphStatsLegend, { stats: graph.stats, edgeCount: graph.edges.length })
+        ] }),
+        graph && /* @__PURE__ */ jsx4(
+          NodeDetailPanel,
+          {
+            open: detailOpen,
+            nodeId: selectedNodeId,
+            graph,
+            onClose: () => {
+              setDetailOpen(false);
+              setSelectedNodeId(null);
+            }
+          }
+        )
+      ]
+    }
+  );
+};
+var ProvenanceGraphDrawerContent_default = ProvenanceGraphDrawerContent;
+
+// src/provenance/ProvenanceI18nProvider.tsx
+import React5 from "react";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var ProvenanceI18nProvider = ({
+  locale = "zh-CN",
+  messages: overrides,
+  children
+}) => {
+  const resolved = React5.useMemo(
+    () => resolveMessages(locale, overrides),
+    [locale, overrides]
+  );
+  return /* @__PURE__ */ jsx5(I18nContext.Provider, { value: resolved, children });
+};
+
+// src/provenance/components/FilterBar.tsx
+import React6, { useCallback as useCallback4, useMemo as useMemo4 } from "react";
+import { Checkbox, Slider, Space as Space3, Typography as Typography2, Badge as Badge3 } from "antd";
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var { Text: Text2 } = Typography2;
+var ALL_TYPES = ["agent", "action", "file", "task", "reasoning"];
+var TYPE_LABEL_KEYS2 = {
+  agent: "provenance.filter.type.agent",
+  action: "provenance.filter.type.action",
+  file: "provenance.filter.type.file",
+  task: "provenance.filter.type.task",
+  reasoning: "provenance.filter.type.reasoning"
+};
+var FilterBarInner = ({
+  visibleTypes,
+  onVisibleTypesChange,
+  depth,
+  onDepthChange,
+  hasSelection
+}) => {
+  const { t } = useChatWidgetI18n();
+  const typeOptions = useMemo4(() => ALL_TYPES.map((tp) => ({
+    label: /* @__PURE__ */ jsxs4(Space3, { size: 4, children: [
+      /* @__PURE__ */ jsx6(Badge3, { color: NODE_COLORS[tp] }),
+      /* @__PURE__ */ jsx6("span", { children: t(TYPE_LABEL_KEYS2[tp]) })
+    ] }),
+    value: tp
+  })), [t]);
+  const handleTypeChange = useCallback4(
+    (values) => {
+      onVisibleTypesChange(new Set(values));
+    },
+    [onVisibleTypesChange]
+  );
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      style: {
+        display: "flex",
+        alignItems: "center",
+        gap: 16,
+        padding: "8px 16px",
+        background: "rgba(255,255,255,0.92)",
+        backdropFilter: "blur(8px)",
+        borderBottom: "1px solid #eee"
+      },
+      children: [
+        /* @__PURE__ */ jsx6(
+          Checkbox.Group,
+          {
+            options: typeOptions,
+            value: Array.from(visibleTypes),
+            onChange: handleTypeChange
+          }
+        ),
+        hasSelection && /* @__PURE__ */ jsxs4(Space3, { size: 8, style: { marginLeft: "auto" }, children: [
+          /* @__PURE__ */ jsx6(Text2, { type: "secondary", style: { fontSize: 12 }, children: t("provenance.filter.depth") }),
+          /* @__PURE__ */ jsx6(
+            Slider,
+            {
+              min: 1,
+              max: 5,
+              value: depth,
+              onChange: onDepthChange,
+              style: { width: 100 },
+              tooltip: { open: false }
+            }
+          ),
+          /* @__PURE__ */ jsx6(Text2, { style: { fontSize: 12, minWidth: 20 }, children: depth })
+        ] })
+      ]
+    }
+  );
+};
+var FilterBar = React6.memo(FilterBarInner);
+
+// src/provenance/components/GraphToolbar.tsx
+import React7 from "react";
+import { Button, Space as Space4, Tooltip } from "antd";
+import {
+  ExpandOutlined,
+  ReloadOutlined,
+  AimOutlined
+} from "@ant-design/icons";
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var GraphToolbarInner = ({
+  onZoomToFit,
+  onResetCamera,
+  onRefresh,
+  loading
+}) => {
+  const { t } = useChatWidgetI18n();
+  return /* @__PURE__ */ jsx7(
+    "div",
+    {
+      style: {
+        position: "absolute",
+        right: 16,
+        top: 16,
+        zIndex: 10,
+        display: "flex",
+        flexDirection: "column",
+        gap: 4
+      },
+      children: /* @__PURE__ */ jsxs5(Space4, { orientation: "vertical", size: 4, children: [
+        /* @__PURE__ */ jsx7(Tooltip, { title: t("provenance.toolbar.zoomToFit"), placement: "left", children: /* @__PURE__ */ jsx7(
+          Button,
+          {
+            type: "text",
+            icon: /* @__PURE__ */ jsx7(ExpandOutlined, {}),
+            onClick: onZoomToFit,
+            style: toolBtnStyle
+          }
+        ) }),
+        /* @__PURE__ */ jsx7(Tooltip, { title: t("provenance.toolbar.resetCamera"), placement: "left", children: /* @__PURE__ */ jsx7(
+          Button,
+          {
+            type: "text",
+            icon: /* @__PURE__ */ jsx7(AimOutlined, {}),
+            onClick: onResetCamera,
+            style: toolBtnStyle
+          }
+        ) }),
+        /* @__PURE__ */ jsx7(Tooltip, { title: t("provenance.toolbar.refresh"), placement: "left", children: /* @__PURE__ */ jsx7(
+          Button,
+          {
+            type: "text",
+            icon: /* @__PURE__ */ jsx7(ReloadOutlined, {}),
+            onClick: onRefresh,
+            loading,
+            style: toolBtnStyle
+          }
+        ) })
+      ] })
+    }
+  );
+};
+var toolBtnStyle = {
+  background: "rgba(255,255,255,0.92)",
+  backdropFilter: "blur(8px)",
+  boxShadow: "0 1px 4px rgba(0,0,0,0.08)",
+  borderRadius: 8,
+  width: 36,
+  height: 36
+};
+var GraphToolbar = React7.memo(GraphToolbarInner);
+
+export {
+  GraphBuilder,
+  fetchProvenanceGraph,
+  useProvenanceGraph,
+  ProvenanceGraph3D,
+  GraphStatsLegend,
+  NodeDetailPanel,
+  ProvenanceGraphDrawerContent_default,
+  ProvenanceI18nProvider,
+  FilterBar,
+  GraphToolbar
+};
+//# sourceMappingURL=chunk-KQV7IKET.js.map