agentfootprint-lens 0.14.2 → 0.15.0

package/dist/chunk-MXIMEL7W.js

@@ -0,0 +1,810 @@
+// src/v2/core/LensRecorder.ts
+import { SequenceRecorder } from "footprintjs/trace";
+import {
+  LiveStateRecorder
+} from "agentfootprint";
+var LensRecorder = class extends SequenceRecorder {
+  constructor(rootLabel = "Run") {
+    super();
+    /** SequenceRecorder requires a stable id for idempotent attach. */
+    this.id = "lens";
+    this.stack = [];
+    this.seqCounter = 0;
+    this.unsubscribes = [];
+    this.finalStatus = "running";
+    /** Live transient state of the in-flight run. Subscribed in `observe()`,
+     *  cleared/disposed on `detach()`. Lens reads `liveState.isLLMInFlight()`
+     *  / `getPartialLLM()` / etc. for O(1) live commentary, instead of
+     *  folding the event log every render. */
+    this.liveState = new LiveStateRecorder();
+    /**
+     * External-store subscribers — React (`useSyncExternalStore`) and any
+     * non-React consumer that wants push-based refresh. Called synchronously
+     * at the end of every `handleEvent`, so views re-render event-by-event
+     * without polling. Zero setInterval, zero requestAnimationFrame fallback.
+     */
+    this.changeListeners = /* @__PURE__ */ new Set();
+    /**
+     * Bumping version is cheap (number increment) but lets
+     * `useSyncExternalStore` detect a change by identity. React compares
+     * `getSnapshot()` return values by `Object.is` — a bumped version
+     * guarantees a fresh reference each event.
+     */
+    this.version = 0;
+    this.root = {
+      id: "run-root",
+      kind: "run",
+      label: rootLabel,
+      status: "running",
+      startOffsetMs: 0,
+      children: [],
+      events: []
+    };
+    this.stack.push(this.root);
+  }
+  /**
+   * Push-based change subscription. Every `handleEvent` pass fires every
+   * listener synchronously — React's `useSyncExternalStore` re-renders,
+   * non-React consumers refresh whatever view they're driving. Return
+   * value detaches the listener; safe to call multiple times.
+   */
+  subscribe(listener) {
+    this.changeListeners.add(listener);
+    return () => {
+      this.changeListeners.delete(listener);
+    };
+  }
+  getVersion() {
+    return this.version;
+  }
+  /**
+   * Subscribe to a v2 Runner's typed dispatcher. Call once per run.
+   * Returns an unsubscribe for the consumer — calling it detaches the
+   * recorder (useful for cleanup after post-run rendering is done).
+   */
+  observe(runner) {
+    const offEvent = runner.on("*", (event) => {
+      this.handleEvent(event);
+    });
+    const offLive = this.liveState.subscribe(runner);
+    const composed = () => {
+      offEvent();
+      offLive();
+    };
+    this.unsubscribes.push(composed);
+    return () => {
+      const idx = this.unsubscribes.indexOf(composed);
+      if (idx >= 0) {
+        this.unsubscribes.splice(idx, 1);
+        composed();
+      }
+    };
+  }
+  /** Detach from all observed runners. Idempotent. */
+  detach() {
+    for (const off of this.unsubscribes) off();
+    this.unsubscribes.length = 0;
+  }
+  // ─── Event handling ────────────────────────────────────────────
+  handleEvent(event) {
+    const wallClockMs = event.meta.wallClockMs;
+    if (this.runStartMs === void 0) {
+      this.runStartMs = wallClockMs;
+      this.root.startOffsetMs = 0;
+    }
+    const runOffsetMs = wallClockMs - this.runStartMs;
+    const entry = {
+      seq: this.seqCounter++,
+      wallClockMs,
+      runOffsetMs,
+      event,
+      // Lift runtimeStageId onto the entry so the inherited
+      // SequenceRecorder index keys correctly — gives us O(1)
+      // `getEntriesForStep(rid)` and the per-step range index for
+      // free, no parallel data structure.
+      runtimeStageId: event.meta.runtimeStageId
+    };
+    this.emit(entry);
+    this.top().events.push(entry);
+    this.dispatch(event, runOffsetMs, entry);
+    this.version++;
+    for (const listener of this.changeListeners) {
+      try {
+        listener();
+      } catch {
+      }
+    }
+  }
+  /**
+   * Kind-specific handling. Keeps the switch exhaustive over every v2
+   * event type we structurally care about; the default branch is the
+   * "attach to current top, no structural change" path which has
+   * already fired above.
+   */
+  dispatch(event, runOffsetMs, entry) {
+    const type = event.type;
+    if (type === "agentfootprint.composition.enter") {
+      const p = event.payload;
+      this.push({
+        id: `comp:${p.id}:${entry.seq}`,
+        kind: "composition",
+        label: `${p.kind}: ${p.name}`,
+        status: "running",
+        startOffsetMs: runOffsetMs,
+        children: [],
+        events: [],
+        composition: { compositionKind: p.kind, childCount: p.childCount }
+      });
+      return;
+    }
+    if (type === "agentfootprint.composition.exit") {
+      const p = event.payload;
+      this.popIfKind("composition", {
+        endOffsetMs: runOffsetMs,
+        status: p.status === "ok" ? "ok" : p.status === "budget_exhausted" ? "budget_exhausted" : "err"
+      });
+      return;
+    }
+    if (type === "agentfootprint.composition.iteration_start") {
+      const p = event.payload;
+      this.push({
+        id: `iter:${p.loopId}:${p.iteration}`,
+        kind: "iteration",
+        label: `Iteration ${p.iteration}`,
+        status: "running",
+        startOffsetMs: runOffsetMs,
+        children: [],
+        events: [],
+        iteration: { iteration: p.iteration }
+      });
+      return;
+    }
+    if (type === "agentfootprint.composition.iteration_exit") {
+      const p = event.payload;
+      this.popIfKind("iteration", {
+        endOffsetMs: runOffsetMs,
+        status: p.reason === "budget" ? "budget_exhausted" : "ok",
+        iterationExit: p.reason
+      });
+      return;
+    }
+    if (type === "agentfootprint.agent.turn_start") {
+      this.push({
+        id: `turn:${entry.seq}`,
+        kind: "iteration",
+        label: "Turn",
+        status: "running",
+        startOffsetMs: runOffsetMs,
+        children: [],
+        events: [],
+        iteration: { iteration: 0 }
+      });
+      return;
+    }
+    if (type === "agentfootprint.agent.turn_end") {
+      this.popIfKind("iteration", { endOffsetMs: runOffsetMs, status: "ok" });
+      return;
+    }
+    if (type === "agentfootprint.agent.iteration_start") {
+      const p = event.payload;
+      this.push({
+        id: `agent-iter:${p.iterIndex}`,
+        kind: "iteration",
+        label: `Iteration ${p.iterIndex}`,
+        status: "running",
+        startOffsetMs: runOffsetMs,
+        children: [],
+        events: [],
+        iteration: { iteration: p.iterIndex }
+      });
+      return;
+    }
+    if (type === "agentfootprint.agent.iteration_end") {
+      this.popIfKind("iteration", { endOffsetMs: runOffsetMs, status: "ok" });
+      return;
+    }
+    if (type === "agentfootprint.stream.llm_start") {
+      const p = event.payload;
+      const node = {
+        id: `llm:${entry.seq}`,
+        kind: "llm-call",
+        label: `LLM: ${p.model}`,
+        status: "running",
+        startOffsetMs: runOffsetMs,
+        children: [],
+        events: [entry],
+        llm: {
+          provider: p.provider,
+          model: p.model,
+          systemPromptChars: p.systemPromptChars,
+          messagesCount: p.messagesCount,
+          toolsCount: p.toolsCount
+        }
+      };
+      this.top().children.push(node);
+      this.stack.push(node);
+      return;
+    }
+    if (type === "agentfootprint.stream.llm_end") {
+      const p = event.payload;
+      this.popIfKind("llm-call", {
+        endOffsetMs: runOffsetMs,
+        status: "ok",
+        llmEnd: {
+          content: p.content,
+          toolCallCount: p.toolCallCount,
+          usage: p.usage,
+          stopReason: p.stopReason
+        }
+      });
+      return;
+    }
+    if (type === "agentfootprint.stream.tool_start") {
+      const p = event.payload;
+      const node = {
+        id: `tool:${p.toolCallId}`,
+        kind: "tool-call",
+        label: `Tool: ${p.toolName}`,
+        status: "running",
+        startOffsetMs: runOffsetMs,
+        children: [],
+        events: [entry],
+        tool: {
+          toolName: p.toolName,
+          toolCallId: p.toolCallId,
+          args: p.args
+        }
+      };
+      this.top().children.push(node);
+      this.stack.push(node);
+      return;
+    }
+    if (type === "agentfootprint.stream.tool_end") {
+      const p = event.payload;
+      this.popIfKind("tool-call", {
+        endOffsetMs: runOffsetMs,
+        status: p.error === true ? "err" : "ok",
+        toolEnd: { result: p.result, error: p.error ?? false }
+      });
+      return;
+    }
+    if (type === "agentfootprint.pause.request") {
+      const p = event.payload;
+      const node = {
+        id: `pause:${entry.seq}`,
+        kind: "pause",
+        label: `Paused: ${p.reason}`,
+        status: "paused",
+        startOffsetMs: runOffsetMs,
+        endOffsetMs: runOffsetMs,
+        children: [],
+        events: [entry],
+        pause: { reason: p.reason, questionPayload: p.questionPayload }
+      };
+      this.top().children.push(node);
+      this.finalStatus = "paused";
+      return;
+    }
+  }
+  // ─── Stack helpers ────────────────────────────────────────────
+  top() {
+    return this.stack[this.stack.length - 1] ?? this.root;
+  }
+  push(node) {
+    this.top().children.push(node);
+    this.stack.push(node);
+  }
+  /**
+   * Pop the top node IF its kind matches, applying finalization fields.
+   * Mismatched kinds (indicating malformed event ordering) are logged
+   * but don't throw — Lens prefers partial correctness to crashes.
+   */
+  popIfKind(kind, finalize) {
+    const top = this.top();
+    if (top.kind !== kind) {
+      return;
+    }
+    top.endOffsetMs = finalize.endOffsetMs;
+    top.status = finalize.status;
+    if (finalize.iterationExit && top.iteration) {
+      top.iteration.exitReason = finalize.iterationExit;
+    }
+    if (finalize.llmEnd && top.llm) {
+      Object.assign(top.llm, finalize.llmEnd);
+    }
+    if (finalize.toolEnd && top.tool) {
+      top.tool.result = finalize.toolEnd.result;
+      top.tool.error = finalize.toolEnd.error;
+    }
+    this.stack.pop();
+  }
+  // ─── Selectors ────────────────────────────────────────────────
+  /** The complete ordered event log. Inherited storage from
+   *  `SequenceRecorder<EventLogEntry>` — no parallel array. */
+  selectEventLog() {
+    return this.getEntries();
+  }
+  /** The RunTree — frozen, recursive, immutable snapshot. */
+  selectRunTree() {
+    if (this.root.endOffsetMs === void 0 && this.entryCount > 0) {
+      const last = this.getEntries()[this.entryCount - 1];
+      this.root.endOffsetMs = last.runOffsetMs;
+      this.root.status = this.finalStatus === "running" ? "ok" : this.finalStatus;
+    }
+    return freezeNode(this.root);
+  }
+  /** Summary stats — computed lazily via the inherited `.aggregate()`
+   *  fold from `SequenceRecorder<EventLogEntry>`. Single-pass, types
+   *  derived from the AgentfootprintEvent discriminated union. */
+  selectSummary() {
+    const init = {
+      llmCallCount: 0,
+      toolCallCount: 0,
+      iterationCount: 0,
+      totalInputTokens: 0,
+      totalOutputTokens: 0,
+      totalUsd: void 0,
+      permissionDenials: 0,
+      paused: false
+    };
+    const acc = this.aggregate((a, { event }) => {
+      switch (event.type) {
+        case "agentfootprint.stream.llm_start":
+          return { ...a, llmCallCount: a.llmCallCount + 1 };
+        case "agentfootprint.stream.tool_start":
+          return { ...a, toolCallCount: a.toolCallCount + 1 };
+        case "agentfootprint.agent.iteration_start":
+        case "agentfootprint.composition.iteration_start":
+          return { ...a, iterationCount: a.iterationCount + 1 };
+        case "agentfootprint.stream.llm_end":
+          return {
+            ...a,
+            totalInputTokens: a.totalInputTokens + event.payload.usage.input,
+            totalOutputTokens: a.totalOutputTokens + event.payload.usage.output
+          };
+        case "agentfootprint.cost.tick":
+          return { ...a, totalUsd: event.payload.cumulative.estimatedUsd };
+        case "agentfootprint.permission.check":
+          return event.payload.result === "deny" ? { ...a, permissionDenials: a.permissionDenials + 1 } : a;
+        case "agentfootprint.pause.request":
+          return { ...a, paused: true };
+        case "agentfootprint.pause.resume":
+          return { ...a, paused: false };
+        default:
+          return a;
+      }
+    }, init);
+    const entries = this.getEntries();
+    const startedAt = entries[0]?.wallClockMs ?? 0;
+    const endedAt = entries[entries.length - 1]?.wallClockMs;
+    return {
+      startedAt,
+      ...endedAt !== void 0 && { endedAt, durationMs: endedAt - startedAt },
+      status: acc.paused ? "paused" : this.finalStatus === "running" ? "ok" : this.finalStatus,
+      llmCallCount: acc.llmCallCount,
+      toolCallCount: acc.toolCallCount,
+      iterationCount: acc.iterationCount,
+      totalTokens: { input: acc.totalInputTokens, output: acc.totalOutputTokens },
+      ...acc.totalUsd !== void 0 && { totalUsd: acc.totalUsd },
+      permissionDenials: acc.permissionDenials,
+      paused: acc.paused
+    };
+  }
+};
+function freezeNode(n) {
+  const children = n.children.map(freezeNode);
+  const base = {
+    id: n.id,
+    kind: n.kind,
+    label: n.label,
+    status: n.status,
+    startOffsetMs: n.startOffsetMs,
+    ...n.endOffsetMs !== void 0 && {
+      durationMs: n.endOffsetMs - n.startOffsetMs
+    },
+    children,
+    events: [...n.events],
+    ...buildDetails(n) && { details: buildDetails(n) }
+  };
+  return base;
+}
+function buildDetails(n) {
+  if (n.kind === "llm-call" && n.llm) {
+    const l = n.llm;
+    return { kind: "llm-call", llm: l };
+  }
+  if (n.kind === "tool-call" && n.tool) {
+    const t = n.tool;
+    return { kind: "tool-call", tool: t };
+  }
+  if (n.kind === "composition" && n.composition) {
+    return { kind: "composition", composition: n.composition };
+  }
+  if (n.kind === "iteration" && n.iteration) {
+    const i = n.iteration;
+    return { kind: "iteration", iteration: i };
+  }
+  if (n.kind === "pause" && n.pause) {
+    return { kind: "pause", pause: n.pause };
+  }
+  return void 0;
+}
+function lensRecorder(rootLabel) {
+  return new LensRecorder(rootLabel);
+}
+
+// src/v2/core/humanizer.ts
+import {
+  defaultCommentaryTemplates,
+  extractCommentaryVars,
+  renderCommentary,
+  selectCommentaryKey
+} from "agentfootprint";
+var defaultHumanizer = (event) => {
+  switch (event.type) {
+    // Composition
+    case "agentfootprint.composition.enter":
+      return `Entered ${event.payload.kind} "${event.payload.name}" with ${event.payload.childCount} children.`;
+    case "agentfootprint.composition.exit":
+      return `${event.payload.kind} finished \u2014 ${event.payload.status} in ${event.payload.durationMs}ms.`;
+    case "agentfootprint.composition.fork_start":
+      return `Fanning out ${event.payload.branches.length} branches.`;
+    case "agentfootprint.composition.merge_end":
+      return `Merged ${event.payload.mergedBranchCount} branches via ${event.payload.strategy}.`;
+    case "agentfootprint.composition.route_decided":
+      return `Routed to "${event.payload.chosen}" \u2014 ${event.payload.rationale}`;
+    case "agentfootprint.composition.iteration_start":
+      return `Iteration ${event.payload.iteration} begins.`;
+    case "agentfootprint.composition.iteration_exit":
+      return `Iteration ${event.payload.iteration} ended (${event.payload.reason}).`;
+    // Agent
+    case "agentfootprint.agent.turn_start":
+      return `Agent turn begins: "${event.payload.userPrompt}".`;
+    case "agentfootprint.agent.turn_end":
+      return `Agent turn complete: "${event.payload.finalContent}" (${event.payload.iterationCount} iterations, ${event.payload.totalInputTokens}+${event.payload.totalOutputTokens} tokens).`;
+    case "agentfootprint.agent.iteration_start":
+      return `ReAct iteration ${event.payload.iterIndex}.`;
+    case "agentfootprint.agent.iteration_end":
+      return `Iteration ${event.payload.iterIndex} ended (${event.payload.toolCallCount} tool calls).`;
+    case "agentfootprint.agent.route_decided":
+      return `Agent routed to "${event.payload.chosen}" \u2014 ${event.payload.rationale}`;
+    // Stream
+    case "agentfootprint.stream.llm_start":
+      return `Calling ${event.payload.provider}/${event.payload.model} (iter ${event.payload.iteration}, ${event.payload.messagesCount} messages, ${event.payload.toolsCount} tools).`;
+    case "agentfootprint.stream.llm_end":
+      return `Model replied in ${event.payload.durationMs}ms (${event.payload.usage.input}+${event.payload.usage.output} tokens, ${event.payload.toolCallCount} tool calls, stop: ${event.payload.stopReason}).`;
+    case "agentfootprint.stream.tool_start":
+      return `Calling tool "${event.payload.toolName}" with ${JSON.stringify(event.payload.args)}.`;
+    case "agentfootprint.stream.tool_end":
+      return `Tool "${event.payload.toolCallId}" returned in ${event.payload.durationMs}ms${event.payload.error === true ? " (error)" : ""}.`;
+    case "agentfootprint.stream.token":
+      return null;
+    // too low-signal for the analyst view
+    // Context
+    case "agentfootprint.context.injected":
+      return `Injected ${event.payload.slot}: "${event.payload.contentSummary}" (from ${event.payload.source}).`;
+    case "agentfootprint.context.slot_composed":
+      return `Slot "${event.payload.slot}" composed (iter ${event.payload.iteration}, ${event.payload.budget.used}/${event.payload.budget.cap} tokens).`;
+    case "agentfootprint.context.evicted":
+      return `Evicted from "${event.payload.slot}" \u2014 ${event.payload.reason} (survived ${event.payload.survivalMs}ms).`;
+    case "agentfootprint.context.budget_pressure":
+      return `Budget pressure on "${event.payload.slot}": ${event.payload.projectedTokens}/${event.payload.capTokens} tokens \u2192 plan: ${event.payload.planAction}.`;
+    // Cost
+    case "agentfootprint.cost.tick":
+      return `Cost +$${event.payload.estimatedUsd.toFixed(6)} \u2014 cumulative $${event.payload.cumulative.estimatedUsd.toFixed(6)}.`;
+    case "agentfootprint.cost.limit_hit":
+      return `\u26A0 Cost budget ${event.payload.limit} crossed \u2014 actual ${event.payload.actual} (${event.payload.action}).`;
+    // Permission
+    case "agentfootprint.permission.check":
+      return `Permission: ${event.payload.capability} \u2192 "${event.payload.target}" = ${event.payload.result}${event.payload.rationale ? ` (${event.payload.rationale})` : ""}.`;
+    case "agentfootprint.permission.gate_opened":
+      return `Gate "${event.payload.gateId}" opened by ${event.payload.openedBy}.`;
+    case "agentfootprint.permission.gate_closed":
+      return `Gate "${event.payload.gateId}" closed \u2014 ${event.payload.reason}.`;
+    // Pause
+    case "agentfootprint.pause.request":
+      return `\u23F8 Paused \u2014 ${event.payload.reason}.`;
+    case "agentfootprint.pause.resume":
+      return `\u25B6 Resumed after ${event.payload.pausedDurationMs}ms.`;
+    // Eval / memory / skill (consumer-emitted, often domain-specific)
+    case "agentfootprint.eval.score":
+      return `Eval "${event.payload.metricId}" = ${event.payload.value}${event.payload.threshold !== void 0 ? ` (threshold ${event.payload.threshold})` : ""}.`;
+    case "agentfootprint.eval.threshold_crossed":
+      return `Eval "${event.payload.metricId}" crossed ${event.payload.threshold} ${event.payload.direction} \u2192 ${event.payload.value}.`;
+    case "agentfootprint.memory.strategy_applied":
+      return `Memory strategy "${event.payload.strategyKind}" applied \u2014 ${event.payload.reason}.`;
+    case "agentfootprint.memory.written":
+      return `Memory write: "${event.payload.memoryId}" \u2014 ${event.payload.contentSummary} (${event.payload.source}).`;
+    case "agentfootprint.skill.activated":
+      return `Skill "${event.payload.skillId}" activated \u2014 ${event.payload.reason}.`;
+    case "agentfootprint.skill.deactivated":
+      return `Skill "${event.payload.skillId}" deactivated \u2014 ${event.payload.reason}.`;
+    // Error
+    case "agentfootprint.error.fatal":
+      return `\u26D4 Fatal error in ${event.payload.stage}: ${event.payload.error}.`;
+    default:
+      return `[${event.type}]`;
+  }
+};
+function humanizeWith(overrides) {
+  return (event) => {
+    const override = overrides[event.type];
+    if (override) {
+      const result = override(event);
+      if (result !== void 0) return result;
+    }
+    return defaultHumanizer(event);
+  };
+}
+function makeTeachingHumanizer(options = {}) {
+  const appName = options.appName ?? "Chatbot";
+  const getToolDescription = options.getToolDescription;
+  const templates = options.commentaryTemplates ? { ...defaultCommentaryTemplates, ...options.commentaryTemplates } : defaultCommentaryTemplates;
+  const ctx = { appName, getToolDescription };
+  return (event) => {
+    const key = selectCommentaryKey(event);
+    if (key === null) return null;
+    if (key === void 0) return defaultHumanizer(event);
+    const template = templates[key];
+    if (template === void 0) return defaultHumanizer(event);
+    const vars = extractCommentaryVars(event, ctx, templates);
+    return renderCommentary(template, vars);
+  };
+}
+var teachingHumanizer = makeTeachingHumanizer();
+
+// src/v2/core/selectors/selectAgentInstances.ts
+function selectAgentInstances(graph) {
+  const boundaries = graph.nodes.filter((n) => n.isPrimitiveBoundary === true);
+  if (boundaries.length === 0) {
+    const rootSubflow = graph.nodes.find((n) => n.kind === "subflow");
+    const primitiveKind = rootSubflow?.primitiveKind;
+    return [
+      {
+        groupId: "agent-root",
+        llmId: "stage-llm-root",
+        toolId: "stage-tool-root",
+        label: primitiveKind ?? "Runner",
+        subflowPath: [],
+        ...primitiveKind ? { primitiveKind } : {}
+      }
+    ];
+  }
+  return boundaries.map((b) => ({
+    groupId: `agent-group-${b.id}`,
+    llmId: `stage-llm-${b.id}`,
+    toolId: `stage-tool-${b.id}`,
+    label: b.label,
+    subflowPath: b.subflowPath,
+    ...b.primitiveKind ? { primitiveKind: b.primitiveKind } : {}
+  }));
+}
+
+// src/v2/core/selectors/selectTouched.ts
+function selectTouched(visibleSteps) {
+  const touched = /* @__PURE__ */ new Set(["user"]);
+  for (const s of visibleSteps) {
+    if (s.kind === "llm->tool" || s.kind === "tool->llm") touched.add("tool");
+    if (s.kind === "user->llm" || s.kind === "tool->llm" || s.kind === "llm->user") {
+      touched.add("llm");
+    }
+    if (s.label.toLowerCase().includes("skill")) touched.add("skill");
+  }
+  return touched;
+}
+
+// src/v2/core/selectors/selectEdges.ts
+function stepToStageEndpoints(step, agent) {
+  switch (step.kind) {
+    case "user->llm":
+      return {
+        source: "actor-user",
+        target: agent.llmId,
+        sourceHandle: "user-out",
+        targetHandle: "llm-top-in",
+        dashed: false
+      };
+    case "llm->tool":
+      return {
+        source: agent.llmId,
+        target: agent.toolId,
+        sourceHandle: "llm-right-out",
+        targetHandle: "tool-left-in",
+        dashed: false
+      };
+    case "tool->llm":
+      return {
+        source: agent.toolId,
+        target: agent.llmId,
+        sourceHandle: "tool-bottom-out",
+        targetHandle: "llm-bottom-in",
+        dashed: true
+      };
+    case "llm->user":
+      return {
+        source: agent.llmId,
+        target: "actor-user",
+        sourceHandle: "llm-top-out",
+        targetHandle: "user-in",
+        dashed: false
+      };
+    default:
+      return null;
+  }
+}
+function stepEdgeLabel(step) {
+  if (step.tokens) return `${step.tokens.in}\u2192${step.tokens.out} tok`;
+  if (step.toolName) return step.toolName;
+  const dur = step.endOffsetMs !== void 0 ? step.endOffsetMs - step.startOffsetMs : 0;
+  if (dur > 0) return dur < 1e3 ? `${Math.round(dur)}ms` : `${(dur / 1e3).toFixed(2)}s`;
+  return "";
+}
+function selectEdges(visibleSteps, agent) {
+  const byKey = /* @__PURE__ */ new Map();
+  visibleSteps.forEach((step, idx) => {
+    const mapping = stepToStageEndpoints(step, agent);
+    if (!mapping) return;
+    const id = `${mapping.source}->${mapping.target}`;
+    const label = stepEdgeLabel(step);
+    const existing = byKey.get(id);
+    if (existing) {
+      existing.count = existing.count + 1;
+      existing.mostRecentIdx = idx;
+      if (label) existing.label = label;
+    } else {
+      byKey.set(id, {
+        id,
+        source: mapping.source,
+        target: mapping.target,
+        sourceHandle: mapping.sourceHandle,
+        targetHandle: mapping.targetHandle,
+        kind: step.kind,
+        label,
+        count: 1,
+        mostRecentIdx: idx,
+        dashed: mapping.dashed
+      });
+    }
+  });
+  return [...byKey.values()];
+}
+
+// src/v2/core/selectors/selectFocusDetail.ts
+function selectFocusDetail(step, log) {
+  if (!step) return void 0;
+  const isLLM = step.kind === "user->llm" || step.kind === "tool->llm" || step.kind === "llm->user";
+  const isTool = step.kind === "llm->tool";
+  if (!isLLM && !isTool) return void 0;
+  const openType = isLLM ? "agentfootprint.stream.llm_start" : "agentfootprint.stream.tool_start";
+  let openIdx = -1;
+  let bestDelta = Number.POSITIVE_INFINITY;
+  for (let i = 0; i < log.length; i++) {
+    const entry = log[i];
+    if (entry.event.type !== openType) continue;
+    const delta = Math.abs(entry.runOffsetMs - step.startOffsetMs);
+    if (delta < bestDelta) {
+      bestDelta = delta;
+      openIdx = i;
+    }
+  }
+  if (openIdx === -1) return { stepId: step.id, kind: step.kind };
+  const detail = { stepId: step.id, kind: step.kind };
+  if (isTool) {
+    const openEvent = log[openIdx].event;
+    detail.toolArgs = openEvent.payload.args;
+    for (let i = openIdx + 1; i < log.length; i++) {
+      const e = log[i].event;
+      if (e.type === "agentfootprint.stream.tool_end" && e.payload.toolCallId === openEvent.payload.toolCallId) {
+        detail.toolResult = String(e.payload.result ?? "");
+        break;
+      }
+    }
+    return detail;
+  }
+  for (let i = openIdx + 1; i < log.length; i++) {
+    const e = log[i].event;
+    if (e.type === "agentfootprint.stream.llm_end") {
+      const p = e.payload;
+      detail.llmReasoning = p.content;
+      detail.tokens = { in: p.usage.input, out: p.usage.output };
+      break;
+    }
+  }
+  for (let i = openIdx + 1; i < Math.min(log.length, openIdx + 12); i++) {
+    const e = log[i].event;
+    if (e.type === "agentfootprint.agent.route_decided") {
+      const p = e.payload;
+      detail.llmDecision = { route: p.chosen, rationale: p.rationale };
+      break;
+    }
+  }
+  return detail;
+}
+
+// src/v2/core/selectors/selectStepView.ts
+function selectStepView(args) {
+  const { graph, log, focusIndex, drillPath } = args;
+  const totalSteps = graph.nodes.length;
+  const clampedFocus = Math.min(
+    Math.max(0, focusIndex),
+    Math.max(0, totalSteps - 1)
+  );
+  const agents = selectAgentInstances(graph);
+  const mode = drillPath.length === 0 ? "top-level" : "drill-down";
+  const agentForEdges = drillPath.length > 0 ? agents.find((a) => a.subflowPath.join("/") === drillPath.join("/")) ?? agents[0] : agents[0];
+  const isMultiAgentTopLevel = drillPath.length === 0 && agents.length > 1;
+  const scopedSteps = drillPath.length === 0 ? isMultiAgentTopLevel ? graph.nodes.filter((s) => s.kind === "subflow" && s.isPrimitiveBoundary === true) : graph.nodes : graph.nodes.filter((s) => startsWith(s.subflowPath, drillPath));
+  const scopedFocus = Math.min(clampedFocus, Math.max(0, scopedSteps.length - 1));
+  const visibleSteps = scopedSteps.slice(0, scopedFocus + 1);
+  const currentStep = visibleSteps[visibleSteps.length - 1];
+  const touched = selectTouched(visibleSteps);
+  const edges = selectEdges(visibleSteps, agentForEdges);
+  const focusMapping = currentStep ? stepToStageEndpoints(currentStep, agentForEdges) : null;
+  const activeEdgeKey = focusMapping ? `${focusMapping.source}->${focusMapping.target}` : void 0;
+  void selectFocusDetail;
+  return {
+    mode,
+    agents: drillPath.length > 0 ? [agentForEdges] : agents,
+    visibleSteps,
+    touched,
+    edges,
+    activeEdgeKey,
+    currentStep,
+    totalSteps: scopedSteps.length,
+    breadcrumb: buildBreadcrumb(drillPath, agents),
+    graph
+  };
+}
+function startsWith(path, prefix) {
+  if (path.length < prefix.length) return false;
+  for (let i = 0; i < prefix.length; i++) {
+    if (path[i] !== prefix[i]) return false;
+  }
+  return true;
+}
+function buildBreadcrumb(drillPath, agents) {
+  const out = [{ id: "", label: "Run" }];
+  for (let i = 0; i < drillPath.length; i++) {
+    const partial = drillPath.slice(0, i + 1);
+    const key = partial.join("/");
+    const match = agents.find((a) => a.subflowPath.join("/") === key);
+    out.push({ id: key, label: match?.label ?? key });
+  }
+  return out;
+}
+
+// src/v2/core/selectors/selectContextEngineeringInjections.ts
+var BASELINE_SOURCES = /* @__PURE__ */ new Set([
+  "user",
+  "tool-result",
+  "assistant",
+  "base",
+  "registry"
+]);
+function isContextEngineering(inj) {
+  return !BASELINE_SOURCES.has(inj.source);
+}
+function selectContextEngineeringInjections(injections) {
+  if (!injections || injections.length === 0) return [];
+  return injections.filter(isContextEngineering);
+}
+
+export {
+  LensRecorder,
+  lensRecorder,
+  defaultHumanizer,
+  humanizeWith,
+  makeTeachingHumanizer,
+  teachingHumanizer,
+  selectAgentInstances,
+  selectTouched,
+  stepToStageEndpoints,
+  stepEdgeLabel,
+  selectEdges,
+  selectFocusDetail,
+  selectStepView,
+  BASELINE_SOURCES,
+  isContextEngineering,
+  selectContextEngineeringInjections
+};
+//# sourceMappingURL=chunk-MXIMEL7W.js.map