shadok-ai 0.6.3 → 0.6.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shadok-ai",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "main": "dist/session.js",
   "scripts": {
     "test": "node --import tsx --test test/*.ts .claude/skills/shadok-ai-agents/test/*.test.mjs context/*/test/*.test.mjs",

package/public/index.html

@@ -1902,7 +1902,7 @@
      request (src/csp.ts). A block without it does not run — which is what makes
      HTML an agent might write into the transcript harmless. -->
 <script type="module" nonce="__CSP_NONCE__">
-  import { extractLiveText } from "/live-text.js";
+  import { extractLiveText, livePreviewDecision } from "/live-text.js";
   import {
     profileBlurb,
     profileBadges,
@@ -1918,6 +1918,7 @@
   window.unionRect = unionRect;
   window.visibleSteps = visibleSteps;
   window.extractLiveText = extractLiveText;
+  window.livePreviewDecision = livePreviewDecision;
   window.profileBlurb = profileBlurb;
   window.profileBadges = profileBadges;
   window.defaultAgentName = defaultAgentName;
@@ -3482,11 +3483,20 @@
     // for a stream-text that never comes.
     if (/^[*_`\s]*nothing to show[*_`\s.!]*$/i.test(txt)) { clearLivePreview(tab); return; }
     const nT = normPreview(txt);
-    // Still showing the previous turn's answer (captured at turn start) — this
-    // turn hasn't produced its own text yet. Suppress until it does.
-    if (tab.livePreviewBaseline && nT === tab.livePreviewBaseline) { clearLivePreview(tab); return; }
-    if (nT && isFinalizedBlock(tab, nT)) { clearLivePreview(tab); return; }
-    tab.livePreviewBaseline = ""; // real new text arrived — baseline no longer applies
+    // Decide what to do with the block (pure, tested — see livePreviewDecision).
+    // The baseline (previous turn's answer) is kept for the WHOLE turn: once new
+    // text has shown, a redraw frame that briefly makes the OLD block the last
+    // one again is HELD, not flipped back — that flip is what made the preview
+    // oscillate new↔old while the model writes.
+    const decision = window.livePreviewDecision
+      ? window.livePreviewDecision({
+          isBaseline: !!tab.livePreviewBaseline && nT === tab.livePreviewBaseline,
+          isFinalized: !!nT && isFinalizedBlock(tab, nT),
+          showing: !!tab.livePreviewBubble,
+        })
+      : "show";
+    if (decision === "keep") return;
+    if (decision === "clear") { clearLivePreview(tab); return; }
     if (!tab.livePreviewEl) {
       const turn = document.createElement("div");
       turn.className = "turn claude live-preview";

package/public/live-text.js

@@ -40,6 +40,21 @@ export function extractLiveText(screen) {
   //  - running tool: "⏺ Running 1 shell command" / "⏺ Ran 1 shell command".
   // Without this, the tool line showed up as a text preview.
   if (/^[\w.-]+\(/.test(head) || /^(Running|Ran)\b/i.test(head)) return "";
+  // Is the next non-empty line after `idx` a "⎿" (tool-result marker)? If so, the
+  // line at `idx` is a running tool's STATUS ("Sleeping for 6 seconds\n  ⎿ $ sleep
+  // 6"), not assistant text. Claude Code flips that status line's leading bullet
+  // on and off between redraws, so read as text it made the preview oscillate
+  // between the tool status and the real block above it — and glued the status
+  // onto the text when the bullet was absent.
+  const nextIsToolDetail = (idx) => {
+    for (let k = idx + 1; k < lines.length; k++) {
+      const t = lines[k].trim();
+      if (t === "") continue;
+      return t.startsWith("⎿");
+    }
+    return false;
+  };
+  if (nextIsToolDetail(start)) return ""; // the head itself is a tool status
 
   const parts = [head];
   const isToolLine = (t) => t.startsWith("⎿") || /^(Ran|Running)\b/.test(t);
@@ -61,7 +76,30 @@ export function extractLiveText(screen) {
     if (!l.startsWith("  ")) break; // unindented → the end (spinner, box, next block)
     const t = l.trim();
     if (isToolLine(t)) break; // a tool's sub-line
+    if (nextIsToolDetail(i)) break; // an indented tool STATUS ("… \n ⎿ $ cmd") — stop before it
     parts.push(t);
   }
   return parts.join(" ");
 }
+
+/**
+ * What to do with the grey live-preview bubble for a freshly extracted block —
+ * pure so the anti-flicker rule is testable; the DOM effect stays in the caller.
+ *
+ * `isBaseline` = the extracted block equals the PREVIOUS turn's answer, captured
+ * at turn start and still (or transiently again) on the screen. `isFinalized` =
+ * it is a block already streamed as authoritative this turn. `showing` = a
+ * preview bubble is currently up.
+ *
+ * The flicker this fixes: while the model writes, a redraw frame can briefly make
+ * the OLD block the last one on screen. Once new text has shown, that must be
+ * HELD (keep), not flipped back to the old text — the old "clear on baseline /
+ * drop the baseline once new text appears" oscillated new↔old every few frames.
+ *
+ * @returns {"show"|"keep"|"clear"}
+ */
+export function livePreviewDecision({ isBaseline, isFinalized, showing }) {
+  if (isBaseline) return showing ? "keep" : "clear";
+  if (isFinalized) return "clear";
+  return "show";
+}