agentfootprint-lens 0.20.0 → 0.23.5

package/dist/{chunk-N3YJKWK5.js → chunk-ZJKD43L7.js}

@@ -306,6 +306,7 @@ function relTime(runStartMs) {
 }
 
 // src/core/LensRecorder.ts
+var DEFAULT_MAX_EVENTS = 5e4;
 var KNOWN_EVENT_TYPES = new Set(ALL_EVENT_TYPES);
 var LensRecorder = class {
   constructor(rootLabel = "Run", options = {}) {
@@ -387,7 +388,18 @@ var LensRecorder = class {
     /** Unknown types already warned about — warn ONCE per type, not per
      *  event, so a chatty unknown emitter can't flood the console. */
     this.warnedUnknownTypes = /* @__PURE__ */ new Set();
+    /** Entries evicted by the cap so far. Surfaced via `getDiagnostics()`. */
+    this.droppedEventCount = 0;
+    /** Eviction already warned about — warn ONCE per run, not per batch. */
+    this.warnedEviction = false;
     this.debug = options.debug;
+    const cap = options.maxEvents ?? DEFAULT_MAX_EVENTS;
+    if (cap !== Number.POSITIVE_INFINITY && (!Number.isInteger(cap) || cap < 1)) {
+      throw new RangeError(
+        `LensRecorder: maxEvents must be a positive integer or Infinity, got ${cap}`
+      );
+    }
+    this.maxEvents = cap;
     this.root = {
       id: "run-root",
       kind: "run",
@@ -417,6 +429,8 @@ var LensRecorder = class {
     this.unknownEventTypes.clear();
     this.bracketMismatchCount = 0;
     this.warnedUnknownTypes.clear();
+    this.droppedEventCount = 0;
+    this.warnedEviction = false;
     this.liveState.clear();
     this.boundary.clear();
     this.runtime.reset();
@@ -436,14 +450,18 @@ var LensRecorder = class {
    *     `composition.exit`, ...) whose kind didn't match the top of the
    *     build stack (malformed ordering). The close is skipped; the
    *     tree stays partially structured rather than crashing.
+   *   - `droppedEvents` — entries evicted by the `maxEvents` FIFO cap
+   *     (U3). When non-zero, log-derived views cover only the retained
+   *     tail of the run.
    *
-   * Both are `{}` / `0` on a well-formed run. Reset by `clear()`.
-   * Returns a fresh snapshot object on every call.
+   * All are `{}` / `0` on a well-formed run that stayed under the cap.
+   * Reset by `clear()`. Returns a fresh snapshot object on every call.
    */
   getDiagnostics() {
     return {
       unknownEventTypes: Object.fromEntries(this.unknownEventTypes),
-      bracketMismatches: this.bracketMismatchCount
+      bracketMismatches: this.bracketMismatchCount,
+      droppedEvents: this.droppedEventCount
     };
   }
   /** Whether diagnostic warnings go to the console: explicit option
@@ -604,8 +622,52 @@ var LensRecorder = class {
     this.top().events.push(entry);
     this.noteUnknownType(event.type);
     this.dispatch(event, runOffsetMs, entry);
+    this.enforceCap();
     this.bumpVersion();
   }
+  /**
+   * U3 — enforce the `maxEvents` FIFO cap. When the store exceeds the
+   * cap, evict the oldest entries down to ~90% of the cap in ONE batch
+   * (amortized O(1) per event: one O(retained) rebuild per ~10%-of-cap
+   * pushes), then prune the SAME evicted entries from every run-tree
+   * node's `events` list — entry objects are shared references, so
+   * skipping the tree would hide the memory, not release it.
+   *
+   * `SequenceStore` is append-only by design (no removal API), so the
+   * batch rebuild (clear + re-push retained) is the supported eviction
+   * path; the per-step key + range indices rebuild correctly during
+   * re-push.
+   */
+  enforceCap() {
+    if (this.store.size <= this.maxEvents) return;
+    const all = this.store.getAll();
+    const evictBatch = Math.max(1, Math.floor(this.maxEvents / 10));
+    const retainCount = Math.max(1, this.maxEvents - evictBatch);
+    const dropCount = all.length - retainCount;
+    const retained = all.slice(dropCount);
+    this.store.clear();
+    for (const e of retained) this.store.push(e);
+    this.droppedEventCount += dropCount;
+    this.pruneNodeEvents(this.root, retained[0].seq);
+    if (this.debugEnabled() && !this.warnedEviction) {
+      this.warnedEviction = true;
+      console.warn(
+        `[lens] LensRecorder: maxEvents cap (${this.maxEvents}) reached \u2014 evicting oldest events (FIFO, ~10% per batch). Log-derived views now cover only the retained tail; evicted total in getDiagnostics().droppedEvents. Raise the cap via lensRecorder('Run', { maxEvents }) or pass Infinity to disable. (Warned once.)`
+      );
+    }
+  }
+  /** Drop entries with `seq < minSeq` from a node's `events` list (and
+   *  its descendants'). Per-node lists are seq-ordered, so this is a
+   *  prefix splice — in place, preserving the node object identity the
+   *  build stack may still hold. */
+  pruneNodeEvents(node, minSeq) {
+    if (node.events.length > 0 && node.events[0].seq < minSeq) {
+      let keepFrom = 0;
+      while (keepFrom < node.events.length && node.events[keepFrom].seq < minSeq) keepFrom++;
+      node.events.splice(0, keepFrom);
+    }
+    for (const child of node.children) this.pruneNodeEvents(child, minSeq);
+  }
   /** Notify all subscribers + bump version. Delegated to ChangeNotifier. */
   bumpVersion() {
     this.notifier.notify();
@@ -904,7 +966,13 @@ var LensRecorder = class {
   }
   /** Summary stats — computed lazily via `store.aggregate()`.
    *  Single-pass fold; types derived from the AgentfootprintEvent
-   *  discriminated union. */
+   *  discriminated union.
+   *
+   *  U3 caveat: once the `maxEvents` cap has evicted entries
+   *  (`getDiagnostics().droppedEvents > 0`), the folded counts/tokens
+   *  reflect only RETAINED events. `startedAt` / `durationMs` stay
+   *  anchored to the true first event of the run (tracked outside the
+   *  store), so the time axis never shifts. */
   selectSummary() {
     const init = {
       llmCallCount: 0,
@@ -944,7 +1012,7 @@ var LensRecorder = class {
       }
     }, init);
     const entries = this.store.getAll();
-    const startedAt = entries[0]?.wallClockMs ?? 0;
+    const startedAt = this.runStartMs ?? entries[0]?.wallClockMs ?? 0;
     const endedAt = entries[entries.length - 1]?.wallClockMs;
     return {
       startedAt,
@@ -1658,6 +1726,47 @@ function selectCommentaryRanges(boundary) {
   }));
 }
 
+// src/core/selectors/selectToolChoiceCall.ts
+function execIndex(runtimeStageId) {
+  const hash = runtimeStageId.lastIndexOf("#");
+  if (hash < 0) return void 0;
+  const n = Number(runtimeStageId.slice(hash + 1));
+  return Number.isInteger(n) && n >= 0 ? n : void 0;
+}
+function selectToolChoiceCall(calls, cursorRuntimeStageId, cursorKind) {
+  if (calls.length === 0) return void 0;
+  const last = calls[calls.length - 1];
+  if (cursorKind === "user-in") return void 0;
+  if (cursorKind === "user-out") return last;
+  if (!cursorRuntimeStageId) return last;
+  const base = cursorRuntimeStageId.split("#")[0];
+  if (base === "__root__") {
+    return cursorKind === "group-start" ? void 0 : last;
+  }
+  const exact = calls.find((c) => c.runtimeStageId === cursorRuntimeStageId);
+  if (exact) return exact;
+  const cursorIdx = execIndex(cursorRuntimeStageId);
+  if (cursorIdx === void 0) return void 0;
+  const prefix = `${base}/`;
+  let within;
+  let withinIdx = Infinity;
+  let prev;
+  let prevIdx = -1;
+  for (const c of calls) {
+    const idx = execIndex(c.runtimeStageId);
+    if (idx === void 0) continue;
+    if (c.runtimeStageId.startsWith(prefix) && idx > cursorIdx && idx < withinIdx) {
+      within = c;
+      withinIdx = idx;
+    }
+    if (idx <= cursorIdx && idx > prevIdx) {
+      prev = c;
+      prevIdx = idx;
+    }
+  }
+  return within ?? prev;
+}
+
 // src/core/translate/helpers/makeNodeId.ts
 function makeRootNodeId(kind, id) {
   return `${kind.toLowerCase()}:${id}`;
@@ -2000,7 +2109,8 @@ import { walkSubflowSpec, splitStageId } from "footprintjs/trace";
 import { createTraceStructureRecorder } from "footprint-explainable-ui/flowchart";
 import { stageRole } from "agentfootprint";
 function emphasisForRole(role) {
-  if (role === "hero-slot" || role === "hero-llm" || role === "hero-action") return "hero";
+  if (role === "hero-slot" || role === "hero-llm" || role === "hero-action")
+    return "hero";
   if (role === "plumbing") return "muted";
   return void 0;
 }
@@ -2026,9 +2136,12 @@ function slotKindForLocalId(localId) {
   return void 0;
 }
 function structureGraphFromRunner(runner) {
+  return structureGraphFromSpec(runner.getSpec().buildTimeStructure);
+}
+function structureGraphFromSpec(buildTimeStructure) {
   const trace = createTraceStructureRecorder();
   const recorder = trace.recorder;
-  const spec = runner.getSpec().buildTimeStructure;
+  const spec = buildTimeStructure;
   const subflowSpecs = [];
   for (const item of walkSubflowSpec(spec, "", { recurse: false })) {
     switch (item.kind) {
@@ -2076,8 +2189,14 @@ function structureGraphFromRunner(runner) {
   const internal = expandSubflowInternals(subflowSpecs);
   const seenNodes = new Set(baseGraph.nodes.map((n) => n.id));
   const seenEdges = new Set(baseGraph.edges.map((e) => e.id));
-  const nodes = [...baseGraph.nodes, ...internal.nodes.filter((n) => !seenNodes.has(n.id))];
-  const edges = [...baseGraph.edges, ...internal.edges.filter((e) => !seenEdges.has(e.id))];
+  const nodes = [
+    ...baseGraph.nodes,
+    ...internal.nodes.filter((n) => !seenNodes.has(n.id))
+  ];
+  const edges = [
+    ...baseGraph.edges,
+    ...internal.edges.filter((e) => !seenEdges.has(e.id))
+  ];
   for (const node of nodes) {
     const role = stageRole(node.id);
     const data = node.data;
@@ -2111,7 +2230,9 @@ function expandSubflowInternals(subflows) {
             stageId: item.stageId,
             name: item.name,
             type: item.type,
-            ...item.isPausable !== void 0 && { isPausable: item.isPausable },
+            ...item.isPausable !== void 0 && {
+              isPausable: item.isPausable
+            },
             spec: item.spec
           });
           break;
@@ -2143,10 +2264,19 @@ function expandSubflowInternals(subflows) {
     const prefix = path.endsWith("/") ? path : `${path}/`;
     const q = (id) => id.startsWith(prefix) ? id : `${prefix}${id}`;
     for (const n of sub.nodes) {
-      nodes.push({ ...n, id: q(n.id), data: { ...n.data, subflowOf: subflowId } });
+      nodes.push({
+        ...n,
+        id: q(n.id),
+        data: { ...n.data, subflowOf: subflowId }
+      });
     }
     for (const e of sub.edges) {
-      edges.push({ ...e, id: `${q(e.source)}->${q(e.target)}`, source: q(e.source), target: q(e.target) });
+      edges.push({
+        ...e,
+        id: `${q(e.source)}->${q(e.target)}`,
+        source: q(e.source),
+        target: q(e.target)
+      });
     }
   }
   return { nodes, edges };
@@ -2348,6 +2478,7 @@ export {
   ChangeNotifier,
   lensSnapshotRecorder,
   LensSnapshotRecorder,
+  DEFAULT_MAX_EVENTS,
   LensRecorder,
   lensRecorder,
   buildStepGraphFromSnapshot,
@@ -2368,6 +2499,7 @@ export {
   selectContextEngineeringInjections,
   selectCommentaryAt,
   selectCommentaryRanges,
+  selectToolChoiceCall,
   makeRootNodeId,
   makeChildNodeId,
   translateAgent,
@@ -2381,8 +2513,9 @@ export {
   translateSequence,
   lensGroupTranslator,
   structureGraphFromRunner,
+  structureGraphFromSpec,
   toReactFlow,
   defaultSize,
   layoutLensGraph
 };
-//# sourceMappingURL=chunk-N3YJKWK5.js.map
+//# sourceMappingURL=chunk-ZJKD43L7.js.map