@moxxy/cli 0.12.3 → 0.12.5

package/dist/bin.js

@@ -195,6 +195,22 @@ var init_log = __esm({
       listeners = /* @__PURE__ */ new Set();
       clearListeners = /* @__PURE__ */ new Set();
       now;
+      /**
+       * Lazy secondary indexes so `ofType`/`byTurn` are O(matches) instead of an
+       * O(n) full-array `filter` per call (these back hot paths: token-accounting's
+       * `ofType('provider_response')`, lazy-tool gating's
+       * `ofType('tool_call_requested')`, and remote-session's per-turn
+       * `byTurn(turnId)` priming). Built lazily on first query so a cold/seeded log
+       * pays the one-time O(n) build only if anything ever queries it, then kept
+       * O(1) per append/ingest. Reset to `null` (rebuild-on-next-query) by
+       * `clear`/`rebase`, which mutate `events` wholesale.
+       *
+       * Each index holds the SAME event object references in their original
+       * append order — so a query returns an array deep-equal to the old
+       * `events.filter(...)` for every input.
+       */
+      byType = null;
+      byTurnId = null;
       /**
        * Seq of the FIRST event this log holds. 0 for an authoring log; a mirror
        * primed by a partial attach replay (runner protocol v6 `replay.start`)
@@ -224,11 +240,53 @@ var init_log = __esm({
       slice(from = 0, to = this.base + this.events.length) {
         return this.events.slice(Math.max(0, from - this.base), Math.max(0, to - this.base));
       }
+      /** Build both secondary indexes from the current `events` array, preserving
+       * append order. Bucket arrays hold the original event references. */
+      buildIndexes() {
+        const byType = /* @__PURE__ */ new Map();
+        const byTurnId = /* @__PURE__ */ new Map();
+        for (const e3 of this.events) {
+          let typeBucket = byType.get(e3.type);
+          if (!typeBucket)
+            byType.set(e3.type, typeBucket = []);
+          typeBucket.push(e3);
+          let turnBucket = byTurnId.get(e3.turnId);
+          if (!turnBucket)
+            byTurnId.set(e3.turnId, turnBucket = []);
+          turnBucket.push(e3);
+        }
+        this.byType = byType;
+        this.byTurnId = byTurnId;
+      }
+      /** Append one event to the live indexes (no-op while they're cold). Called
+       * after the event is pushed to `events`, so order is preserved. */
+      indexEvent(e3) {
+        if (this.byType) {
+          const bucket = this.byType.get(e3.type);
+          if (bucket)
+            bucket.push(e3);
+          else
+            this.byType.set(e3.type, [e3]);
+        }
+        if (this.byTurnId) {
+          const bucket = this.byTurnId.get(e3.turnId);
+          if (bucket)
+            bucket.push(e3);
+          else
+            this.byTurnId.set(e3.turnId, [e3]);
+        }
+      }
       ofType(type) {
-        return this.events.filter((e3) => e3.type === type);
+        if (!this.byType)
+          this.buildIndexes();
+        const bucket = this.byType.get(type);
+        return bucket ? [...bucket] : [];
       }
       byTurn(turnId) {
-        return this.events.filter((e3) => e3.turnId === turnId);
+        if (!this.byTurnId)
+          this.buildIndexes();
+        const bucket = this.byTurnId.get(turnId);
+        return bucket ? [...bucket] : [];
       }
       toJSON() {
         return [...this.events];
@@ -236,6 +294,7 @@ var init_log = __esm({
       async append(partial) {
         const event = materializeEvent(partial, this.base + this.events.length, this.now);
         this.events.push(event);
+        this.indexEvent(event);
         const snapshot = [...this.listeners];
         for (const fn of snapshot) {
           try {
@@ -262,6 +321,7 @@ var init_log = __esm({
         if (event.seq !== this.base + this.events.length)
           return;
         this.events.push(event);
+        this.indexEvent(event);
         const snapshot = [...this.listeners];
         for (const fn of snapshot) {
           try {
@@ -300,9 +360,13 @@ var init_log = __esm({
           throw new Error(`EventLog.rebase(${seq}): seq must be a non-negative integer`);
         }
         this.base = seq;
+        this.byType = null;
+        this.byTurnId = null;
       }
       clear() {
         this.events.length = 0;
+        this.byType = null;
+        this.byTurnId = null;
         this.base = 0;
         const snapshot = [...this.clearListeners];
         for (const fn of snapshot) {
@@ -2224,6 +2288,18 @@ var init_host2 = __esm({
       dataListeners = /* @__PURE__ */ new Set();
       /** In-flight opens, so concurrent `open(kind)` calls share one instance. */
       opening = /* @__PURE__ */ new Map();
+      /**
+       * Viewer attach count per kind. A surface is SHARED (the agent's tool + every
+       * attached viewer drive the same PTY/page), so `open` retains and `close`
+       * releases; the instance is only torn down when the last viewer detaches.
+       * Without this, a single viewer's `close` would destroy the resource out from
+       * under the others — and React StrictMode (dev) makes that routine: it
+       * mounts → unmounts → remounts, so the first mount's late-resolving `open`
+       * closes the very instance the remount just attached to, leaving `input`/
+       * `resize` to hit a now-missing instance (output still flows from the
+       * snapshot, but keystrokes/navigation silently vanish).
+       */
+      refs = /* @__PURE__ */ new Map();
       constructor(registry, ctx, logger) {
         this.registry = registry;
         this.ctx = ctx;
@@ -2256,28 +2332,25 @@ var init_host2 = __esm({
       async open(kind3) {
         const existing = this.instances.get(kind3);
         if (existing) {
-          return {
-            surfaceId: existing.id,
-            kind: existing.kind,
-            ...existing.snapshot ? { snapshot: existing.snapshot() } : {}
-          };
+          this.retain(kind3);
+          return this.describe(existing);
         }
         const pending2 = this.opening.get(kind3);
-        if (pending2)
-          return pending2;
+        if (pending2) {
+          const res = await pending2;
+          this.retain(kind3);
+          return res;
+        }
         const def = this.registry.get(kind3);
         if (!def)
           throw new Error(`No surface registered for kind: ${kind3}`);
         const promise = (async () => {
           const instance = await def.open(this.ctx);
           this.instances.set(kind3, instance);
+          this.refs.set(kind3, 1);
           const unsub = instance.onData((payload) => this.emit({ surfaceId: instance.id, kind: instance.kind, payload }));
           this.unsubs.set(instance.id, unsub);
-          return {
-            surfaceId: instance.id,
-            kind: instance.kind,
-            ...instance.snapshot ? { snapshot: instance.snapshot() } : {}
-          };
+          return this.describe(instance);
         })();
         this.opening.set(kind3, promise);
         try {
@@ -2302,9 +2375,16 @@ var init_host2 = __esm({
         const instance = this.byId(surfaceId);
         if (!instance)
           return;
+        const kind3 = instance.kind;
+        const remaining = (this.refs.get(kind3) ?? 1) - 1;
+        if (remaining > 0) {
+          this.refs.set(kind3, remaining);
+          return;
+        }
+        this.refs.delete(kind3);
         this.unsubs.get(surfaceId)?.();
         this.unsubs.delete(surfaceId);
-        this.instances.delete(instance.kind);
+        this.instances.delete(kind3);
         try {
           await instance.close();
         } catch (err) {
@@ -2314,11 +2394,24 @@ var init_host2 = __esm({
           });
         }
       }
+      /** Bump the viewer attach count for an already-open kind. */
+      retain(kind3) {
+        this.refs.set(kind3, (this.refs.get(kind3) ?? 0) + 1);
+      }
+      describe(instance) {
+        return {
+          surfaceId: instance.id,
+          kind: instance.kind,
+          ...instance.snapshot ? { snapshot: instance.snapshot() } : {}
+        };
+      }
       onData(cb) {
         this.dataListeners.add(cb);
         return () => this.dataListeners.delete(cb);
       }
       async closeAll() {
+        for (const kind3 of [...this.instances.keys()])
+          this.refs.set(kind3, 1);
         const ids = [...this.unsubs.keys()];
         for (const id of ids)
           await this.close(id);
@@ -3960,6 +4053,14 @@ var init_persistence = __esm({
        * can flush.
        */
       writeQueue = createMutex();
+      /**
+       * Memoized one-time setup: `mkdir -p` the sessions dir and create the empty
+       * `.jsonl` (so resume lists the session before any event). Awaited by both
+       * `attach` and `writeIndex` so an early debounced index flush can't race the
+       * initial creation — but it runs the open+close syscalls ONCE, not on every
+       * 250ms flush as before.
+       */
+      ready = null;
       closed = false;
       logger;
       /**
@@ -3997,7 +4098,7 @@ var init_persistence = __esm({
        * reuses the same Session object.
        */
       attach(log) {
-        void this.ensureDir().then(() => this.ensureLogFile()).then(() => this.scheduleIndexWrite()).catch(() => void 0);
+        void this.ensureReady().then(() => this.scheduleIndexWrite()).catch(() => void 0);
         const unsub = log.subscribe((event) => {
           if (this.closed)
             return;
@@ -4112,19 +4213,27 @@ var init_persistence = __esm({
       async writeIndex() {
         try {
           if (!this.closed) {
-            await this.ensureDir();
-            await this.ensureLogFile();
+            await this.ensureReady();
           }
           await writeJsonAtomic(metaPath(this.dir, this.meta.id), this.meta);
         } catch {
         }
       }
-      async ensureDir() {
-        await promises.mkdir(this.dir, { recursive: true });
-      }
-      async ensureLogFile() {
-        const handle2 = await promises.open(this.logPath, "a");
-        await handle2.close();
+      /** One-time, memoized: `mkdir -p` the dir + create the empty `.jsonl`. On
+       *  failure the latch is cleared so a later flush retries (matching the old
+       *  per-write ensureDir/ensureLogFile recoverability). */
+      ensureReady() {
+        if (!this.ready) {
+          this.ready = (async () => {
+            await promises.mkdir(this.dir, { recursive: true });
+            const handle2 = await promises.open(this.logPath, "a");
+            await handle2.close();
+          })().catch((err) => {
+            this.ready = null;
+            throw err;
+          });
+        }
+        return this.ready;
       }
     };
   }
@@ -85197,35 +85306,40 @@ function handleSubagentEvent(e3, subagents, root, groupRef) {
     return;
   }
 }
-function pairToolEvents(events, compactByName = EMPTY_COMPACT_MAP) {
-  const root = [];
-  const callTargets = /* @__PURE__ */ new Map();
-  const suppressedCallIds = /* @__PURE__ */ new Set();
-  let pendingLoadSkillCallId = null;
-  let openScope = null;
-  let continuationSkillEvent = null;
-  let openLive = null;
-  const subagents = /* @__PURE__ */ new Map();
-  const subagentGroup = { current: null };
+function createFoldState(compactByName = EMPTY_COMPACT_MAP) {
+  return {
+    root: [],
+    compactByName,
+    callTargets: /* @__PURE__ */ new Map(),
+    suppressedCallIds: /* @__PURE__ */ new Set(),
+    pendingLoadSkillCallId: null,
+    openScope: null,
+    continuationSkillEvent: null,
+    openLive: null,
+    subagents: /* @__PURE__ */ new Map(),
+    subagentGroup: { current: null }
+  };
+}
+function stepFold(s2, e3) {
   const pushBlock = (block) => {
-    subagentGroup.current = null;
-    if (openScope) {
-      openScope.children.push(block);
+    s2.subagentGroup.current = null;
+    if (s2.openScope) {
+      s2.openScope.children.push(block);
     } else {
-      root.push(block);
+      s2.root.push(block);
     }
   };
   const closeOpenLive = () => {
-    if (openLive) {
-      openLive.closed = true;
-      openLive = null;
+    if (s2.openLive) {
+      s2.openLive.closed = true;
+      s2.openLive = null;
     }
   };
   const closeOpenScope = () => {
     closeOpenLive();
-    if (openScope) {
-      openScope.closed = true;
-      openScope = null;
+    if (s2.openScope) {
+      s2.openScope.closed = true;
+      s2.openScope = null;
     }
   };
   const removeBlockByCallId = (callId) => {
@@ -85237,12 +85351,12 @@ function pairToolEvents(events, compactByName = EMPTY_COMPACT_MAP) {
       }
       return false;
     };
-    if (openScope && removeFrom(openScope.children))
+    if (s2.openScope && removeFrom(s2.openScope.children))
       return;
-    removeFrom(root);
+    removeFrom(s2.root);
   };
   const markOrphansAtTurnBoundary = () => {
-    for (const target of callTargets.values()) {
+    for (const target of s2.callTargets.values()) {
       if (target.outcome === null) {
         target.outcome = {
           type: "denied",
@@ -85250,116 +85364,119 @@ function pairToolEvents(events, compactByName = EMPTY_COMPACT_MAP) {
         };
       }
     }
-    callTargets.clear();
+    s2.callTargets.clear();
   };
-  for (const e3 of events) {
-    if (e3.type === "user_prompt") {
-      closeOpenScope();
-      markOrphansAtTurnBoundary();
-      pendingLoadSkillCallId = null;
-      continuationSkillEvent = null;
-      suppressedCallIds.clear();
-      subagentGroup.current = null;
-      root.push({ kind: "event", id: e3.id, event: e3 });
-      continue;
+  if (e3.type === "user_prompt") {
+    closeOpenScope();
+    markOrphansAtTurnBoundary();
+    s2.pendingLoadSkillCallId = null;
+    s2.continuationSkillEvent = null;
+    s2.suppressedCallIds.clear();
+    s2.subagentGroup.current = null;
+    s2.root.push({ kind: "event", id: e3.id, event: e3 });
+    return;
+  }
+  if (e3.type === "skill_invoked") {
+    closeOpenScope();
+    s2.continuationSkillEvent = null;
+    if (s2.pendingLoadSkillCallId) {
+      s2.suppressedCallIds.add(s2.pendingLoadSkillCallId);
+      removeBlockByCallId(s2.pendingLoadSkillCallId);
+      s2.pendingLoadSkillCallId = null;
+    }
+    s2.subagentGroup.current = null;
+    s2.openScope = {
+      kind: "skill-scope",
+      id: e3.id,
+      skillEvent: e3,
+      children: [],
+      closed: false
+    };
+    s2.root.push(s2.openScope);
+    return;
+  }
+  if (e3.type === "tool_call_requested") {
+    if (e3.name === "load_skill") {
+      s2.pendingLoadSkillCallId = e3.callId;
     }
-    if (e3.type === "skill_invoked") {
-      closeOpenScope();
-      continuationSkillEvent = null;
-      if (pendingLoadSkillCallId) {
-        suppressedCallIds.add(pendingLoadSkillCallId);
-        removeBlockByCallId(pendingLoadSkillCallId);
-        pendingLoadSkillCallId = null;
-      }
-      subagentGroup.current = null;
-      openScope = {
+    if (!s2.openScope && s2.continuationSkillEvent) {
+      s2.openScope = {
         kind: "skill-scope",
-        id: e3.id,
-        skillEvent: e3,
+        id: `${s2.continuationSkillEvent.id}:cont:${e3.id}`,
+        skillEvent: s2.continuationSkillEvent,
         children: [],
         closed: false
       };
-      root.push(openScope);
-      continue;
-    }
-    if (e3.type === "tool_call_requested") {
-      if (e3.name === "load_skill") {
-        pendingLoadSkillCallId = e3.callId;
-      }
-      if (!openScope && continuationSkillEvent) {
-        openScope = {
-          kind: "skill-scope",
-          id: `${continuationSkillEvent.id}:cont:${e3.id}`,
-          skillEvent: continuationSkillEvent,
-          children: [],
-          closed: false
-        };
-        root.push(openScope);
-        continuationSkillEvent = null;
-      }
-      const compact = FILE_DIFF_TOOL_NAMES.has(e3.name) ? void 0 : compactByName.get(e3.name);
-      if (compact) {
-        if (!openLive) {
-          openLive = { kind: "live-tools", id: e3.id, calls: [], closed: false };
-          pushBlock(openLive);
-        }
-        const call = { id: e3.id, request: e3, compact, outcome: null };
-        openLive.calls.push(call);
-        callTargets.set(e3.callId, call);
-        continue;
-      }
-      closeOpenLive();
-      const block = {
-        kind: "tool-call",
-        id: e3.id,
-        request: e3,
-        outcome: null
-      };
-      callTargets.set(e3.callId, block);
-      pushBlock(block);
-      continue;
-    }
-    if (e3.type === "tool_result") {
-      if (suppressedCallIds.has(e3.callId))
-        continue;
-      const target = callTargets.get(e3.callId);
-      if (target) {
-        target.outcome = e3;
-        continue;
-      }
-    }
-    if (e3.type === "tool_call_denied") {
-      if (suppressedCallIds.has(e3.callId))
-        continue;
-      const target = callTargets.get(e3.callId);
-      if (target) {
-        target.outcome = { type: "denied", reason: e3.reason };
-        continue;
-      }
+      s2.root.push(s2.openScope);
+      s2.continuationSkillEvent = null;
+    }
+    const compact = FILE_DIFF_TOOL_NAMES.has(e3.name) ? void 0 : s2.compactByName.get(e3.name);
+    if (compact) {
+      if (!s2.openLive) {
+        s2.openLive = { kind: "live-tools", id: e3.id, calls: [], closed: false };
+        pushBlock(s2.openLive);
+      }
+      const call = { id: e3.id, request: e3, compact, outcome: null };
+      s2.openLive.calls.push(call);
+      s2.callTargets.set(e3.callId, call);
+      return;
     }
-    if (e3.type === "tool_call_approved") {
-      continue;
+    closeOpenLive();
+    const block = {
+      kind: "tool-call",
+      id: e3.id,
+      request: e3,
+      outcome: null
+    };
+    s2.callTargets.set(e3.callId, block);
+    pushBlock(block);
+    return;
+  }
+  if (e3.type === "tool_result") {
+    if (s2.suppressedCallIds.has(e3.callId))
+      return;
+    const target = s2.callTargets.get(e3.callId);
+    if (target) {
+      target.outcome = e3;
+      return;
     }
-    if (e3.type === "assistant_message") {
-      closeOpenLive();
-      if (openScope) {
-        continuationSkillEvent = openScope.skillEvent;
-        openScope.closed = true;
-        openScope = null;
-      } else {
-        continuationSkillEvent = null;
-      }
-      subagentGroup.current = null;
-      root.push({ kind: "event", id: e3.id, event: e3 });
-      continue;
+  }
+  if (e3.type === "tool_call_denied") {
+    if (s2.suppressedCallIds.has(e3.callId))
+      return;
+    const target = s2.callTargets.get(e3.callId);
+    if (target) {
+      target.outcome = { type: "denied", reason: e3.reason };
+      return;
     }
-    if (e3.type === "plugin_event" && e3.pluginId === SUBAGENT_PLUGIN_ID2) {
-      handleSubagentEvent(e3, subagents, root, subagentGroup);
-      continue;
+  }
+  if (e3.type === "tool_call_approved") {
+    return;
+  }
+  if (e3.type === "assistant_message") {
+    closeOpenLive();
+    if (s2.openScope) {
+      s2.continuationSkillEvent = s2.openScope.skillEvent;
+      s2.openScope.closed = true;
+      s2.openScope = null;
+    } else {
+      s2.continuationSkillEvent = null;
     }
-    pushBlock({ kind: "event", id: e3.id, event: e3 });
+    s2.subagentGroup.current = null;
+    s2.root.push({ kind: "event", id: e3.id, event: e3 });
+    return;
   }
-  return root;
+  if (e3.type === "plugin_event" && e3.pluginId === SUBAGENT_PLUGIN_ID2) {
+    handleSubagentEvent(e3, s2.subagents, s2.root, s2.subagentGroup);
+    return;
+  }
+  pushBlock({ kind: "event", id: e3.id, event: e3 });
+}
+function pairToolEvents(events, compactByName = EMPTY_COMPACT_MAP) {
+  const state = createFoldState(compactByName);
+  for (const e3 of events)
+    stepFold(state, e3);
+  return state.root;
 }
 function isSettled(block) {
   if (block.kind === "event")
@@ -85445,13 +85562,97 @@ function countToolCalls(blocks) {
   }
   return n2;
 }
-var SUBAGENT_PLUGIN_ID2, FILE_DIFF_TOOL_NAMES, EMPTY_COMPACT_MAP;
+var SUBAGENT_PLUGIN_ID2, FILE_DIFF_TOOL_NAMES, EMPTY_COMPACT_MAP, IncrementalFold;
 var init_pair_events = __esm({
   "../chat-model/dist/pair-events.js"() {
     init_format();
     SUBAGENT_PLUGIN_ID2 = "@moxxy/subagents";
     FILE_DIFF_TOOL_NAMES = /* @__PURE__ */ new Set(["Write", "Edit"]);
     EMPTY_COMPACT_MAP = /* @__PURE__ */ new Map();
+    IncrementalFold = class {
+      state;
+      prefixLength = 0;
+      rev = 0;
+      /** `id` of the first / last event folded so far — used to detect when the
+       *  source array's prefix has shifted (a scroll-up prepend) or been replaced
+       *  (/clear, a fresh session), in which case the carried fold state is no
+       *  longer valid and we must rebuild from scratch. */
+      headId = null;
+      tailId = null;
+      constructor(compactByName = EMPTY_COMPACT_MAP) {
+        this.state = createFoldState(compactByName);
+      }
+      /** Number of events folded so far (the high-water mark). */
+      get length() {
+        return this.prefixLength;
+      }
+      /** Bumps whenever the folded tree may have changed (every `push`). Use as
+       *  a memo key instead of the (stable) `tree()` reference. */
+      get version() {
+        return this.rev;
+      }
+      /** Fold one freshly-committed event onto the existing tree. */
+      push(event) {
+        stepFold(this.state, event);
+        if (this.prefixLength === 0)
+          this.headId = event.id;
+        this.tailId = event.id;
+        this.prefixLength += 1;
+        this.rev += 1;
+      }
+      /** Fold a batch of newly-committed events (e.g. a replayed page). */
+      pushMany(events) {
+        for (const e3 of events)
+          this.push(e3);
+      }
+      /**
+       * Re-sync to `events` when the source array is the authoritative log. Folds
+       * only the tail past the current high-water mark when `events` extends the
+       * already-folded prefix unchanged (the common live-append case), and
+       * rebuilds from scratch only when that prefix shifted or was replaced (a
+       * scroll-up prepend, /clear, a fresh session). Returns the (stable) root.
+       *
+       * Prefix-unchanged is detected by event `id`: the log never rewrites a
+       * settled event in place (only its tool outcome, which the fold owns), so
+       * matching head+tail ids over an unshrunk length proves the leading
+       * `prefixLength` events are exactly the ones already folded.
+       */
+      syncTo(events) {
+        if (this.canExtend(events)) {
+          for (let i2 = this.prefixLength; i2 < events.length; i2 += 1)
+            this.push(events[i2]);
+          return this.state.root;
+        }
+        this.reset();
+        this.pushMany(events);
+        return this.state.root;
+      }
+      /** Discard all state — folds again from empty. */
+      reset() {
+        this.state = createFoldState(this.state.compactByName);
+        this.prefixLength = 0;
+        this.headId = null;
+        this.tailId = null;
+        this.rev += 1;
+      }
+      /** The folded block tree (stable reference, mutated in place). */
+      tree() {
+        return this.state.root;
+      }
+      /** True when `events` is the already-folded prefix plus zero or more new
+       *  tail events — i.e. a pure append. Requires the head id to still match
+       *  (no prepend) and the event at `prefixLength-1` to be the last one we
+       *  folded (no in-place rewrite or replacement of the prefix). */
+      canExtend(events) {
+        if (this.prefixLength === 0)
+          return true;
+        if (events.length < this.prefixLength)
+          return false;
+        if (events[0].id !== this.headId)
+          return false;
+        return events[this.prefixLength - 1].id === this.tailId;
+      }
+    };
   }
 });
 
@@ -86090,6 +86291,31 @@ var init_BlockLine = __esm({
 });
 
 // ../plugin-cli/dist/components/chat/StreamingPreview.js
+function lastNonEmptyLineShown(content, innerCols) {
+  let end = content.length;
+  let chosenStart = -1;
+  let chosenEnd = -1;
+  while (end > 0) {
+    const nl = content.lastIndexOf("\n", end - 1);
+    const start = nl + 1;
+    if (content.slice(start, end).trim()) {
+      chosenStart = start;
+      chosenEnd = end;
+      break;
+    }
+    if (start === 0)
+      break;
+    end = nl;
+  }
+  let line;
+  if (chosenStart >= 0) {
+    line = content.slice(chosenStart, chosenEnd);
+  } else {
+    const lastNl = content.lastIndexOf("\n");
+    line = lastNl < 0 ? content : content.slice(lastNl + 1);
+  }
+  return line.length > innerCols ? `\u2026${line.slice(line.length - (innerCols - 1))}` : line;
+}
 function tailForViewport(content) {
   return content;
 }
@@ -86103,17 +86329,7 @@ var init_StreamingPreview = __esm({
     StreamingPreview = (0, import_react40.memo)(function StreamingPreview2({ content, dim: dim3 }) {
       const cols = process.stdout.columns ?? 80;
       const innerCols = Math.max(20, cols - 4);
-      const lines = content.split("\n");
-      let line = "";
-      for (let i2 = lines.length - 1; i2 >= 0; i2 -= 1) {
-        if (lines[i2].trim()) {
-          line = lines[i2];
-          break;
-        }
-      }
-      if (!line)
-        line = lines[lines.length - 1] ?? "";
-      const shown = line.length > innerCols ? `\u2026${line.slice(line.length - (innerCols - 1))}` : line;
+      const shown = lastNonEmptyLineShown(content, innerCols);
       return (0, import_jsx_runtime19.jsxs)(Box_default, { flexDirection: "row", marginTop: 1, children: [(0, import_jsx_runtime19.jsx)(Box_default, { marginRight: 1, children: (0, import_jsx_runtime19.jsx)(Text, { dimColor: true, children: Glyphs.filled }) }), (0, import_jsx_runtime19.jsx)(Text, { dimColor: dim3, children: shown || " " })] });
     });
   }
@@ -86130,16 +86346,26 @@ var init_ChatView = __esm({
     init_dist8();
     await init_StreamingPreview();
     ChatView = ({ events, streamingDelta, reasoningDelta, expandToolOutputs, compactTools, hideLive }) => {
-      const blocks = (0, import_react41.useMemo)(() => pairToolEvents(events, compactTools), [events, compactTools]);
+      const foldRef = (0, import_react41.useRef)(null);
+      const compactRef = (0, import_react41.useRef)(void 0);
+      const blocks = (0, import_react41.useMemo)(() => {
+        if (typeof IncrementalFold !== "function")
+          return pairToolEvents(events, compactTools);
+        if (!foldRef.current || compactRef.current !== compactTools) {
+          foldRef.current = new IncrementalFold(compactTools);
+          compactRef.current = compactTools;
+        }
+        return foldRef.current.syncTo(events).slice();
+      }, [events, compactTools]);
       const settledRef = (0, import_react41.useRef)([]);
       const clearGenerationRef = (0, import_react41.useRef)(0);
       if (blocks.length < settledRef.current.length) {
         settledRef.current = [];
         clearGenerationRef.current += 1;
       }
-      let settledCount = 0;
-      for (const b3 of blocks) {
-        if (isSettled(b3))
+      let settledCount = settledRef.current.length;
+      for (let i2 = settledRef.current.length; i2 < blocks.length; i2 += 1) {
+        if (isSettled(blocks[i2]))
           settledCount += 1;
         else
           break;
@@ -88213,6 +88439,13 @@ function modelBreakdownRows(file, liveByModel) {
     output: m3.outputTokens
   })).sort((a2, b3) => b3.prompt - a2.prompt);
 }
+function peak(series, seed = 0) {
+  let m3 = seed;
+  for (const v3 of series)
+    if (v3 > m3)
+      m3 = v3;
+  return m3;
+}
 function perCallPrompt(events) {
   const out = [];
   for (const e3 of events) {
@@ -88297,7 +88530,7 @@ var init_UsagePanel = __esm({
       const subtitle = hasSession ? `${s2.calls} calls   \xB7   ${fmt(s2.totalPrompt)} prompt   \xB7   ${fmt(s2.totalOutput)} output` : "saved across sessions";
       const showSession = hasSession && (!tabs || activeTab === "session");
       const showLifetime = hasModels && (!tabs || activeTab === "lifetime");
-      return (0, import_jsx_runtime28.jsxs)(Modal, { title: "Usage", subtitle, ...tabs ? { tabs, activeTabId: activeTab, onTabChange: (id) => setActiveTab(id) } : {}, ...onClose ? { onClose } : {}, children: [showSession ? (0, import_jsx_runtime28.jsxs)(import_jsx_runtime28.Fragment, { children: [(0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "Prompt composition" }), (0, import_jsx_runtime28.jsx)(CompRow, { label: "cache read", frac: readFrac, value: s2.totalCacheRead, color: Colors.active }), (0, import_jsx_runtime28.jsx)(CompRow, { label: "fresh input", frac: freshFrac, value: s2.totalInput }), (0, import_jsx_runtime28.jsx)(CompRow, { label: "cache write", frac: writeFrac, value: s2.totalCacheCreation, color: Colors.busy }), (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: 1, flexDirection: "column", children: [(0, import_jsx_runtime28.jsx)(MetricRow, { label: "Cache hit", frac: s2.cacheHitRate, color: s2.cacheHitRate >= 0.5 ? Colors.active : Colors.busy }), ctxFrac != null ? (0, import_jsx_runtime28.jsx)(MetricRow, { label: "Context fill", frac: ctxFrac, color: ctxColor, suffix: `${fmt(contextTokens ?? 0)} / ${fmt(contextWindow ?? 0)}` }) : null] }), (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: 1, children: [(0, import_jsx_runtime28.jsx)(Box_default, { width: LABEL_COL, children: (0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "Input cost" }) }), (0, import_jsx_runtime28.jsxs)(Text, { children: [fmt(s2.billedInputEq), " billed-eq"] }), saved > 5e-3 ? (0, import_jsx_runtime28.jsx)(Text, { color: Colors.active, bold: true, children: `   saved ${pct(saved)}` }) : (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: "   no cache savings yet" })] }), (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: 1, flexDirection: "column", children: [(0, import_jsx_runtime28.jsxs)(Box_default, { children: [(0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "Per-call prompt " }), (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: `peak ${fmt(Math.max(...series, 0))}` })] }), (0, import_jsx_runtime28.jsxs)(Box_default, { children: [(0, import_jsx_runtime28.jsx)(Text, { children: sparkline(series) }), trend ? (0, import_jsx_runtime28.jsx)(Text, { color: trend === "growing" ? Colors.busy : Colors.active, children: trend === "growing" ? "  \u2191 growing" : "  \u2248 bounded" }) : null] })] }), !s2.cacheEffective ? (0, import_jsx_runtime28.jsx)(Box_default, { marginTop: 1, children: (0, import_jsx_runtime28.jsx)(Text, { color: Colors.danger, children: "\u26A0 cache ineffective \u2014 writing cache but not reading it back (prefix likely unstable)" }) }) : null] }) : null, showLifetime ? (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: showSession ? 1 : 0, flexDirection: "column", children: [(0, import_jsx_runtime28.jsxs)(Box_default, { children: [(0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "By model " }), (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: `(saved + this session \xB7 ${lifeRows.length} model${lifeRows.length === 1 ? "" : "s"})` })] }), lifeRows.slice(0, 8).map((r2) => (0, import_jsx_runtime28.jsx)(ModelRow, { name: r2.name, calls: r2.calls, prompt: r2.prompt, output: r2.output }, r2.name)), lifeRows.length > 1 ? (0, import_jsx_runtime28.jsx)(ModelRow, { name: "total", calls: lifeTotal.calls, prompt: lifeTotal.prompt, output: lifeTotal.output, dim: true }) : null, (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: "  /usage clear resets saved history" })] }) : null] });
+      return (0, import_jsx_runtime28.jsxs)(Modal, { title: "Usage", subtitle, ...tabs ? { tabs, activeTabId: activeTab, onTabChange: (id) => setActiveTab(id) } : {}, ...onClose ? { onClose } : {}, children: [showSession ? (0, import_jsx_runtime28.jsxs)(import_jsx_runtime28.Fragment, { children: [(0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "Prompt composition" }), (0, import_jsx_runtime28.jsx)(CompRow, { label: "cache read", frac: readFrac, value: s2.totalCacheRead, color: Colors.active }), (0, import_jsx_runtime28.jsx)(CompRow, { label: "fresh input", frac: freshFrac, value: s2.totalInput }), (0, import_jsx_runtime28.jsx)(CompRow, { label: "cache write", frac: writeFrac, value: s2.totalCacheCreation, color: Colors.busy }), (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: 1, flexDirection: "column", children: [(0, import_jsx_runtime28.jsx)(MetricRow, { label: "Cache hit", frac: s2.cacheHitRate, color: s2.cacheHitRate >= 0.5 ? Colors.active : Colors.busy }), ctxFrac != null ? (0, import_jsx_runtime28.jsx)(MetricRow, { label: "Context fill", frac: ctxFrac, color: ctxColor, suffix: `${fmt(contextTokens ?? 0)} / ${fmt(contextWindow ?? 0)}` }) : null] }), (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: 1, children: [(0, import_jsx_runtime28.jsx)(Box_default, { width: LABEL_COL, children: (0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "Input cost" }) }), (0, import_jsx_runtime28.jsxs)(Text, { children: [fmt(s2.billedInputEq), " billed-eq"] }), saved > 5e-3 ? (0, import_jsx_runtime28.jsx)(Text, { color: Colors.active, bold: true, children: `   saved ${pct(saved)}` }) : (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: "   no cache savings yet" })] }), (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: 1, flexDirection: "column", children: [(0, import_jsx_runtime28.jsxs)(Box_default, { children: [(0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "Per-call prompt " }), (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: `peak ${fmt(peak(series))}` })] }), (0, import_jsx_runtime28.jsxs)(Box_default, { children: [(0, import_jsx_runtime28.jsx)(Text, { children: sparkline(series) }), trend ? (0, import_jsx_runtime28.jsx)(Text, { color: trend === "growing" ? Colors.busy : Colors.active, children: trend === "growing" ? "  \u2191 growing" : "  \u2248 bounded" }) : null] })] }), !s2.cacheEffective ? (0, import_jsx_runtime28.jsx)(Box_default, { marginTop: 1, children: (0, import_jsx_runtime28.jsx)(Text, { color: Colors.danger, children: "\u26A0 cache ineffective \u2014 writing cache but not reading it back (prefix likely unstable)" }) }) : null] }) : null, showLifetime ? (0, import_jsx_runtime28.jsxs)(Box_default, { marginTop: showSession ? 1 : 0, flexDirection: "column", children: [(0, import_jsx_runtime28.jsxs)(Box_default, { children: [(0, import_jsx_runtime28.jsx)(Text, { bold: true, children: "By model " }), (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: `(saved + this session \xB7 ${lifeRows.length} model${lifeRows.length === 1 ? "" : "s"})` })] }), lifeRows.slice(0, 8).map((r2) => (0, import_jsx_runtime28.jsx)(ModelRow, { name: r2.name, calls: r2.calls, prompt: r2.prompt, output: r2.output }, r2.name)), lifeRows.length > 1 ? (0, import_jsx_runtime28.jsx)(ModelRow, { name: "total", calls: lifeTotal.calls, prompt: lifeTotal.prompt, output: lifeTotal.output, dim: true }) : null, (0, import_jsx_runtime28.jsx)(Text, { dimColor: true, children: "  /usage clear resets saved history" })] }) : null] });
     };
   }
 });
@@ -129343,6 +129576,15 @@ async function* walk(root, regex2, cursor, signal, visited) {
     }
   }
 }
+var MAX_FILE_BYTES = 10 * 1024 * 1024;
+function looksBinary(content) {
+  const limit2 = Math.min(content.length, 8192);
+  for (let i2 = 0; i2 < limit2; i2 += 1) {
+    if (content.charCodeAt(i2) === 0)
+      return true;
+  }
+  return false;
+}
 var grepTool = defineTool({
   name: "Grep",
   description: "Recursively search files for a regex pattern. Returns lines as `path:line:text`.",
@@ -129406,12 +129648,21 @@ async function walk2(root, cursor, re2, fileRe, matches, max, signal) {
       continue;
     if (fileRe && !fileRe.test(entry.name))
       continue;
+    try {
+      const st3 = await promises.stat(full);
+      if (st3.size > MAX_FILE_BYTES)
+        continue;
+    } catch {
+      continue;
+    }
     let content;
     try {
       content = await promises.readFile(full, "utf8");
     } catch {
       continue;
     }
+    if (looksBinary(content))
+      continue;
     const lines = content.split("\n");
     for (let i2 = 0; i2 < lines.length; i2++) {
       if (re2.test(lines[i2])) {
@@ -135706,9 +135957,38 @@ var workflowResumeParamsSchema = z.object({
 var surfaceOpenParamsSchema = z.object({
   kind: z.string().min(1).max(64)
 });
+var MAX_SURFACE_INPUT_BYTES = 1e6;
+function surfaceInputWithinCap(m3) {
+  let upper = 2;
+  let primitiveOnly = true;
+  for (const key in m3) {
+    if (!Object.prototype.hasOwnProperty.call(m3, key))
+      continue;
+    const v3 = m3[key];
+    const t2 = typeof v3;
+    if (v3 === void 0 || t2 === "function")
+      continue;
+    upper += key.length * 6 + 2 + 1 + 1;
+    if (t2 === "string") {
+      upper += v3.length * 6 + 2;
+    } else if (t2 === "number") {
+      upper += 25;
+    } else if (t2 === "boolean" || v3 === null) {
+      upper += 5;
+    } else {
+      primitiveOnly = false;
+      break;
+    }
+    if (upper > MAX_SURFACE_INPUT_BYTES)
+      break;
+  }
+  if (primitiveOnly && upper <= MAX_SURFACE_INPUT_BYTES)
+    return true;
+  return JSON.stringify(m3).length <= MAX_SURFACE_INPUT_BYTES;
+}
 var surfaceInputParamsSchema = z.object({
   surfaceId: z.string().min(1).max(120),
-  message: z.object({ type: z.string().min(1).max(64) }).passthrough().refine((m3) => JSON.stringify(m3).length <= 1e6, {
+  message: z.object({ type: z.string().min(1).max(64) }).passthrough().refine((m3) => surfaceInputWithinCap(m3), {
     message: "surface input message too large"
   })
 });
@@ -138600,6 +138880,8 @@ function defaultShell() {
     return process.env["COMSPEC"] ?? "powershell.exe";
   return process.env["SHELL"] ?? "/bin/bash";
 }
+var MAX_SCROLLBACK = 2e5;
+var SCROLLBACK_SLACK = 1e5;
 var TerminalProcessImpl = class {
   backend;
   pty;
@@ -138623,7 +138905,10 @@ var TerminalProcessImpl = class {
     }
   }
   emitData(d2) {
-    this.buffer = (this.buffer + d2).slice(-2e5);
+    this.buffer += d2;
+    if (this.buffer.length > MAX_SCROLLBACK + SCROLLBACK_SLACK) {
+      this.buffer = this.buffer.slice(-MAX_SCROLLBACK);
+    }
     for (const cb of this.dataListeners) {
       try {
         cb(d2);
@@ -138651,7 +138936,7 @@ var TerminalProcessImpl = class {
     return () => this.exitListeners.delete(cb);
   }
   scrollback() {
-    return this.buffer;
+    return this.buffer.length > MAX_SCROLLBACK ? this.buffer.slice(-MAX_SCROLLBACK) : this.buffer;
   }
   write(data) {
     if (!this.alive)
@@ -138798,11 +139083,17 @@ function runCommand(proc, command, marker, timeoutMs) {
       clearTimeout(timer);
       resolve13({ output: cleanOutput(acc, command, marker), exitCode, timedOut });
     };
+    const sentinel2 = new RegExp(`${marker} (\\d+)`);
+    const carry = marker.length + 32;
+    let scanFrom = 0;
     const unsub = proc.onData((d2) => {
+      const from = Math.max(scanFrom, acc.length - carry, 0);
       acc += d2;
-      const m3 = new RegExp(`${marker} (\\d+)`).exec(acc);
+      sentinel2.lastIndex = 0;
+      const m3 = sentinel2.exec(from > 0 ? acc.slice(from) : acc);
       if (m3)
         finish(Number(m3[1]), false);
+      scanFrom = Math.max(0, acc.length - carry);
     });
     const timer = setTimeout(() => finish(null, true), timeoutMs);
     proc.write(`${command}
@@ -139859,7 +140150,7 @@ var IS_DARWIN = process.platform === "darwin";
 function runProcess(cmd, args, opts = {}) {
   return new Promise((resolve13, reject) => {
     const child = spawn(cmd, [...args], { stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = Buffer.alloc(0);
+    const stdoutChunks = [];
     let stderr = "";
     let settled = false;
     const onAbort = () => {
@@ -139880,7 +140171,7 @@ function runProcess(cmd, args, opts = {}) {
       }
     }, opts.timeoutMs) : null;
     child.stdout.on("data", (chunk) => {
-      stdout = Buffer.concat([stdout, chunk]);
+      stdoutChunks.push(chunk);
     });
     child.stderr.on("data", (chunk) => {
       stderr += chunk.toString("utf8");
@@ -139903,7 +140194,7 @@ function runProcess(cmd, args, opts = {}) {
       opts.signal?.removeEventListener("abort", onAbort);
       resolve13({
         exitCode: code ?? -1,
-        stdout: stdout.toString("utf8"),
+        stdout: Buffer.concat(stdoutChunks).toString("utf8"),
         stderr
       });
     });
@@ -140552,43 +140843,7 @@ async function syncSkillSchedules(registry, store) {
     if (draft)
       wanted.set(skill.frontmatter.name, draft);
   }
-  const existing = await store.list();
-  const existingSkill = /* @__PURE__ */ new Map();
-  for (const e3 of existing) {
-    if (e3.source === "skill" && e3.skillName)
-      existingSkill.set(e3.skillName, e3);
-  }
-  let added = 0;
-  let removed = 0;
-  let updated = 0;
-  for (const [skillName2, entry] of existingSkill) {
-    if (!wanted.has(skillName2)) {
-      const ok = await store.delete(entry.id);
-      if (ok)
-        removed += 1;
-    }
-  }
-  for (const [skillName2, draft] of wanted) {
-    const current = existingSkill.get(skillName2);
-    if (!current) {
-      await store.create(draft);
-      added += 1;
-      continue;
-    }
-    const changed = current.prompt !== draft.prompt || current.cron !== draft.cron || current.runAt !== draft.runAt || current.timeZone !== draft.timeZone || current.channel !== draft.channel || current.enabled !== draft.enabled;
-    if (changed) {
-      await store.update(current.id, {
-        prompt: draft.prompt,
-        ...draft.cron ? { cron: draft.cron } : { cron: void 0 },
-        ...draft.runAt !== void 0 ? { runAt: draft.runAt } : { runAt: void 0 },
-        ...draft.timeZone ? { timeZone: draft.timeZone } : { timeZone: void 0 },
-        ...draft.channel ? { channel: draft.channel } : { channel: void 0 },
-        enabled: draft.enabled
-      });
-      updated += 1;
-    }
-  }
-  return { added, removed, updated };
+  return store.reconcileSkillSchedules(wanted);
 }
 
 // ../plugin-scheduler/dist/poller.js
@@ -140820,6 +141075,79 @@ var ScheduleStore = class {
     });
     return removed;
   }
+  /**
+   * Batch-reconcile every `source='skill'` row against `wanted` (skillName →
+   * desired draft) in a SINGLE atomic write, instead of one whole-file
+   * serialization + fsync per changed row. The diff (and the resulting array)
+   * is byte-identical to running the equivalent sequence of
+   * create/update/delete calls:
+   *   - skill rows whose skillName is absent from `wanted` are removed;
+   *   - present skillNames with no existing row are created (fresh id +
+   *     createdAt), appended in `wanted` iteration order;
+   *   - present skillNames with an existing row are updated IN PLACE (id,
+   *     createdAt, position preserved) only when a field actually changed.
+   * Returns the add/remove/update counts so the caller's telemetry is
+   * unchanged. Manual/workflow rows are never touched.
+   */
+  async reconcileSkillSchedules(wanted) {
+    let added = 0;
+    let removed = 0;
+    let updated = 0;
+    await this.store.mutate((schedules) => {
+      const existingByName = /* @__PURE__ */ new Map();
+      for (let i2 = 0; i2 < schedules.length; i2 += 1) {
+        const s2 = schedules[i2];
+        if (s2.source === "skill" && s2.skillName && !existingByName.has(s2.skillName)) {
+          existingByName.set(s2.skillName, i2);
+        }
+      }
+      const next = [];
+      for (const s2 of schedules) {
+        if (s2.source === "skill" && s2.skillName && !wanted.has(s2.skillName)) {
+          removed += 1;
+          continue;
+        }
+        next.push(s2);
+      }
+      const posInNext = /* @__PURE__ */ new Map();
+      for (let i2 = 0; i2 < next.length; i2 += 1) {
+        const s2 = next[i2];
+        if (s2.source === "skill" && s2.skillName && !posInNext.has(s2.skillName)) {
+          posInNext.set(s2.skillName, i2);
+        }
+      }
+      for (const [skillName2, draft] of wanted) {
+        const idx = posInNext.get(skillName2);
+        if (idx === void 0) {
+          next.push(scheduleEntrySchema.parse({
+            ...draft,
+            id: ulid(),
+            createdAt: Date.now(),
+            enabled: draft.enabled ?? true,
+            source: draft.source ?? "skill"
+          }));
+          added += 1;
+          continue;
+        }
+        const current = next[idx];
+        const patch = {
+          prompt: draft.prompt,
+          ...draft.cron ? { cron: draft.cron } : { cron: void 0 },
+          ...draft.runAt !== void 0 ? { runAt: draft.runAt } : { runAt: void 0 },
+          ...draft.timeZone ? { timeZone: draft.timeZone } : { timeZone: void 0 },
+          ...draft.channel ? { channel: draft.channel } : { channel: void 0 },
+          enabled: draft.enabled ?? true
+        };
+        const changed = current.prompt !== patch.prompt || current.cron !== patch.cron || current.runAt !== patch.runAt || current.timeZone !== patch.timeZone || current.channel !== patch.channel || current.enabled !== patch.enabled;
+        if (changed) {
+          next[idx] = scheduleEntrySchema.parse({ ...current, ...patch });
+          updated += 1;
+        }
+      }
+      return next;
+    });
+    return { added, removed, updated };
+  }
   /**
    * Replace every `source='skill'` schedule for the given `skillName`
    * with the supplied entry, OR remove all of them if `entry` is null.
@@ -141259,14 +141587,17 @@ function readHeader(headers, name) {
     return v3[0] ?? null;
   return v3 ?? null;
 }
-function readJsonPath(body, path60) {
-  let parsed;
+function parseBody(body) {
   try {
-    parsed = JSON.parse(body.toString("utf8"));
+    return { ok: true, value: JSON.parse(body.toString("utf8")) };
   } catch {
-    return null;
+    return { ok: false, value: null };
   }
-  let cur = parsed;
+}
+function readJsonPath(parsed, path60) {
+  if (!parsed.ok)
+    return null;
+  let cur = parsed.value;
   for (const seg of path60.split(".")) {
     if (cur === null || cur === void 0 || typeof cur !== "object")
       return null;
@@ -141274,8 +141605,8 @@ function readJsonPath(body, path60) {
   }
   return asString2(cur);
 }
-function ruleMatches(rule, input) {
-  const value = rule.source === "header" ? readHeader(input.headers, rule.name) : readJsonPath(input.body, rule.path);
+function ruleMatches(rule, input, parsed) {
+  const value = rule.source === "header" ? readHeader(input.headers, rule.name) : readJsonPath(parsed, rule.path);
   if (value === null)
     return false;
   if (rule.equals && rule.equals.includes(value))
@@ -141291,11 +141622,12 @@ function ruleMatches(rule, input) {
   return false;
 }
 function shouldFire(filter, input) {
-  if (filter.exclude.some((r2) => ruleMatches(r2, input)))
+  const parsed = parseBody(input.body);
+  if (filter.exclude.some((r2) => ruleMatches(r2, input, parsed)))
     return false;
   if (filter.include.length === 0)
     return true;
-  return filter.include.some((r2) => ruleMatches(r2, input));
+  return filter.include.some((r2) => ruleMatches(r2, input, parsed));
 }
 
 // ../plugin-webhooks/dist/template.js
@@ -145461,7 +145793,7 @@ function buildSubagentSpecWithDeps(step, scope, deps, opts) {
 }
 var dagExecutor = defineWorkflowExecutor({
   name: DAG_EXECUTOR_NAME,
-  description: "Parallel DAG runner: steps with settled dependencies run in waves up to `concurrency`.",
+  description: "DAG runner: steps with settled dependencies are scheduled in waves of up to `concurrency` ready steps, then executed sequentially within each wave (no overlap yet \u2014 `concurrency` caps the batch size, not wall-clock latency).",
   run: runExecutor
 });