@adhdev/daemon-core 0.9.82-rc.449 → 0.9.82-rc.450

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "fe0e4d2aa03aea2793c2379e5ffc89abef5143d6" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "fe0e4d2a" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.449" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-03T01:58:07.610Z" : void 0);
+  const commit = readInjected(true ? "4d9f330890bc663a858fde1c84931144b825f8b2" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "4d9f3308" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.450" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-03T08:51:21.732Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -19271,6 +19271,15 @@ function validateCondition(c, sectionIds, path44) {
   }
   if ("stable_ms" in w) {
     if (typeof w.stable_ms !== "number") errs.push(`${path44}.stable_ms must be a number`);
+    if (w.section && !sectionIds.has(w.section)) errs.push(`${path44}.section "${w.section}" unknown`);
+    if (w.ignore_lines !== void 0) {
+      if (typeof w.ignore_lines !== "string") errs.push(`${path44}.ignore_lines must be a string`);
+      else try {
+        new RegExp(w.ignore_lines, "m");
+      } catch (e) {
+        errs.push(`${path44}.ignore_lines invalid regex: ${e.message}`);
+      }
+    }
     return errs;
   }
   errs.push(`${path44} is not a recognized condition`);
@@ -19571,10 +19580,13 @@ var init_evaluator = __esm({
 var fsm_evaluator_exports = {};
 __export(fsm_evaluator_exports, {
   evaluateConditionPreview: () => evaluateConditionPreview,
-  evaluateFsm: () => evaluateFsm
+  evaluateFsm: () => evaluateFsm,
+  stableRegionKey: () => stableRegionKey
 });
-function regionKey(cursorAbove) {
-  return cursorAbove && cursorAbove > 0 ? cursorAbove : WHOLE_SCREEN;
+function stableRegionKey(cond) {
+  const region = cond.section ? `section:${cond.section}` : cond.cursor_above && cond.cursor_above > 0 ? cond.cursor_above : WHOLE_SCREEN;
+  if (!cond.ignore_lines) return region;
+  return `${region}#ignore:${cond.ignore_lines}`;
 }
 function isRegex(c) {
   return "matches" in c;
@@ -19622,13 +19634,14 @@ function evalCond(cond, sections, fullScreen, cursor, prevLines, clock, legacyTr
     return { kind: "elapsed", result, detail: `elapsed ${age}ms / ${cond.elapsed_ms}ms`, remainingMs };
   }
   if (isStable(cond)) {
-    const key2 = regionKey(cond.cursor_above);
+    const key2 = stableRegionKey(cond);
     const lastChanged = clock.regionLastChangedAt.get(key2) ?? clock.stateEnteredAt;
     const stableFor = clock.now - lastChanged;
     const result = stableFor >= cond.stable_ms;
     const remainingMs = result ? 0 : cond.stable_ms - stableFor;
-    const where = key2 === WHOLE_SCREEN ? "screen" : `cursor_above=${cond.cursor_above}`;
-    return { kind: "stable", result, detail: `stable ${where} ${stableFor}ms / ${cond.stable_ms}ms`, remainingMs };
+    const where = cond.section ? `section=${cond.section}` : cond.cursor_above && cond.cursor_above > 0 ? `cursor_above=${cond.cursor_above}` : "screen";
+    const ign = cond.ignore_lines ? " (ignore_lines)" : "";
+    return { kind: "stable", result, detail: `stable ${where}${ign} ${stableFor}ms / ${cond.stable_ms}ms`, remainingMs };
   }
   if (isRegex(cond) || isChanged(cond)) {
     const result = evaluateCondition(cond, sections, fullScreen, cursor, prevLines, legacyTrace, stateId);
@@ -37788,8 +37801,10 @@ var FsmDriver = class {
   // ── Clock bookkeeping for time conditions.
   startedAtMs = 0;
   prevScreenLines = [];
-  /** Per cursor_above region (key: cursor_above, -1 = whole screen) → last
-   *  time that region's content changed. Drives stable_ms conditions. */
+  /** Per stable region → last time that region's content changed. Drives
+   *  stable_ms conditions. Key = stableRegionKey(cond): numeric cursor_above
+   *  (−1 = whole screen), or a `section:<id>` / `<region>#ignore:<pat>` string
+   *  when the clause scopes to a section or declares an ignore_lines filter. */
   regionLastChangedAt = /* @__PURE__ */ new Map();
   /** Timer that re-runs evaluate() when a time-condition would flip true
    *  with no PTY frame to trigger it. */
@@ -38215,36 +38230,55 @@ var FsmDriver = class {
     }
     return out;
   }
-  /** Track which cursor_above regions changed since the previous frame so
-   *  stable_ms conditions can measure quiet time. We record every region
-   *  size referenced by a stable_ms condition in the spec, plus the whole
-   *  screen (-1). */
+  /** Track which stable regions changed since the previous frame so
+   *  stable_ms conditions can measure quiet time. We record every distinct
+   *  stable region referenced in the current state (numeric cursor_above /
+   *  whole-screen -1, and named `section:<id>` regions) plus, for each, the
+   *  optional `ignore_lines` filter that folds into its key.
+   *
+   *  `ignore_lines` is the content-aware fix for the busy→idle wedge: lines
+   *  matching it are stripped from BOTH frames before the comparison, so a
+   *  benign residual ticker (bare token counter / elapsed timer that repaints
+   *  every frame post-generation) no longer resets the clock — while an active
+   *  spinner line, which does NOT match the benign pattern, still does (the
+   *  FALSEIDLE2 / FALSEBUSY-B whole-screen invariant is preserved). */
   trackRegionChanges(currentLines, cursor, now) {
     if (this.prevScreenLines.length === 0) return;
-    const sizes = this.stableRegionSizes();
-    for (const size of sizes) {
-      let cur;
-      let prev;
-      if (size < 0) {
-        cur = currentLines.join("\n");
-        prev = this.prevScreenLines.join("\n");
+    const descs = this.stableRegionDescriptors();
+    const needsSections = descs.some((d) => !!d.section);
+    const curSections = needsSections ? resolveSections(this.spec.sections ?? {}, currentLines) : [];
+    const prevSections = needsSections ? resolveSections(this.spec.sections ?? {}, this.prevScreenLines) : [];
+    for (const d of descs) {
+      let curLines;
+      let prevLines;
+      if (d.section) {
+        curLines = sliceSectionLines(currentLines, curSections, d.section);
+        prevLines = sliceSectionLines(this.prevScreenLines, prevSections, d.section);
+      } else if (!d.cursor_above || d.cursor_above <= 0) {
+        curLines = currentLines;
+        prevLines = this.prevScreenLines;
       } else {
-        const start = Math.max(0, cursor.row - size);
-        cur = currentLines.slice(start, cursor.row).join("\n");
-        prev = this.prevScreenLines.slice(start, cursor.row).join("\n");
-      }
-      if (cur !== prev) this.regionLastChangedAt.set(size, now);
-    }
-  }
-  /** All cursor_above region sizes referenced by stable_ms conditions in the
-   *  current state's outgoing transitions, plus whole-screen. Cached lazily
-   *  per spec load would be nicer but the set is tiny. */
-  stableRegionSizes() {
-    const sizes = /* @__PURE__ */ new Set([-1]);
+        const start = Math.max(0, cursor.row - d.cursor_above);
+        curLines = currentLines.slice(start, cursor.row);
+        prevLines = this.prevScreenLines.slice(start, cursor.row);
+      }
+      const cur = filterIgnoredLines(curLines, d.ignoreRe).join("\n");
+      const prev = filterIgnoredLines(prevLines, d.ignoreRe).join("\n");
+      if (cur !== prev) this.regionLastChangedAt.set(d.key, now);
+    }
+  }
+  /** Every distinct stable-region descriptor referenced by stable_ms
+   *  conditions in the current state's outgoing transitions, plus the plain
+   *  whole-screen key (-1) that other machinery (stall watchdog) reads.
+   *  De-duplicated by key. Cached lazily per spec load would be nicer but the
+   *  set is tiny. */
+  stableRegionDescriptors() {
+    const byKey = /* @__PURE__ */ new Map();
+    byKey.set(-1, { key: -1 });
     for (const t of outgoingTransitions(this.spec, this.currentStateId)) {
-      collectStableSizes(t.when, sizes);
+      collectStableDescriptors(t.when, byKey);
     }
-    return sizes;
+    return [...byKey.values()];
   }
   /** Schedule a re-evaluation for the soonest pending time-condition on any
    *  outgoing transition (elapsed_ms / stable_ms / min_hold_ms). Without
@@ -38741,26 +38775,45 @@ function findStable(c) {
   }
   return null;
 }
-function collectStableSizes(when, sizes) {
+function collectStableDescriptors(when, byKey) {
   if (!when) return;
   const w = when;
   if ("stable_ms" in w) {
-    sizes.add(w.cursor_above && w.cursor_above > 0 ? w.cursor_above : -1);
+    const key2 = stableRegionKey(w);
+    if (!byKey.has(key2)) {
+      let ignoreRe;
+      if (w.ignore_lines) {
+        try {
+          ignoreRe = new RegExp(w.ignore_lines, "m");
+        } catch {
+        }
+      }
+      byKey.set(key2, { key: key2, section: w.section, cursor_above: w.cursor_above, ignoreRe });
+    }
     return;
   }
   if ("all" in w) {
-    for (const c of w.all) collectStableSizes(c, sizes);
+    for (const c of w.all) collectStableDescriptors(c, byKey);
     return;
   }
   if ("any" in w) {
-    for (const c of w.any) collectStableSizes(c, sizes);
+    for (const c of w.any) collectStableDescriptors(c, byKey);
     return;
   }
   if ("not" in w) {
-    collectStableSizes(w.not, sizes);
+    collectStableDescriptors(w.not, byKey);
     return;
   }
 }
+function sliceSectionLines(lines, sections, id) {
+  const sec = sections.find((s2) => s2.id === id);
+  if (!sec) return [];
+  return lines.slice(sec.fromLine, sec.toLine);
+}
+function filterIgnoredLines(lines, ignoreRe) {
+  if (!ignoreRe) return lines;
+  return lines.filter((l) => !ignoreRe.test(l));
+}
 
 // src/providers/spec/cli-adapter.ts
 init_evaluator();