lazyclaw 5.4.0 → 5.4.2

package/cli.mjs

@@ -2702,19 +2702,12 @@ async function cmdChat(flags = {}) {
           try { process.stdout.write(chunk); } catch { /* swallow */ }
         });
       };
-      // v5.4 alt-buffer splash hand-off — when the alt-screen will mount,
-      // pre-print the splash to the PRIMARY buffer so it survives in the
-      // user's normal scrollback after chat exit (mirrors Claude CLI /
-      // opencode behavior). The Static splash item would otherwise live
-      // only inside the alt canvas and disappear on unmount. When alt is
-      // disabled (non-TTY pipelines, LAZYCLAW_NO_ALT), keep the legacy
-      // in-tree splash so the pre-existing visual is unchanged.
-      const _altWillMount = !!process.stdout.isTTY && !process.env.LAZYCLAW_NO_ALT;
-      if (_altWillMount) {
-        try { process.stdout.write(renderSplashToString(splashProps) + '\n'); } catch { /* swallow */ }
-      }
+      // v5.4.1: splash renders INSIDE the alt-buffer (not pre-printed to
+      // primary). The v5.4.0 pre-print made the screen go blank during
+      // chat because alt-buffer cleared it on enter. Splash lives in the
+      // Static scrollback now regardless of alt-buffer state.
       const ink = render(/* @__PURE__ */ React.createElement(ReplApp, {
-        splashProps: _altWillMount ? null : splashProps,
+        splashProps,
         statusInfo: { provider: activeProvName, model: activeModel },
         runTurn: _inkRunTurn,
         onSlashCommand: _inkSlashHandler,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.4.0",
+  "version": "5.4.2",
   "description": "Lazy, elegant terminal CLI for chatting with Claude / OpenAI / Gemini / Ollama, orchestrating multi-step LLM workflows, and running multi-agent Slack teams with cross-task memory. Banner-on-launch, slash-command ghost autocomplete, persistent sessions, local HTTP gateway.",
   "keywords": [
     "claude",

package/tui/editor.mjs

@@ -28,7 +28,7 @@
 // `width: '100%'` so Ink's wrap-ansi (already string-width aware) gets
 // the full terminal budget — fixes the perceived right-edge truncation
 // on long Korean buffers.
-import React, { useState, useEffect } from 'react';
+import React, { useState, useEffect, useRef } from 'react';
 import { Box, Text, useInput } from 'ink';
 import stringWidth from 'string-width';
 import { theme } from './theme.mjs';
@@ -150,15 +150,31 @@ export function Editor({
   const [state, setState] = useState(() => makeEditorState({ history }));
   const slashOpen = Array.isArray(slashSuggestions) && slashSuggestions.length > 0;
 
+  // v5.4.2: keep a synchronous mirror of the editor state so back-to-back
+  // keystrokes don't lose characters to React's stale-closure problem.
+  // Korean / Japanese IME commits each completed syllable as a separate
+  // stdin event; if two events fire inside one React frame the second
+  // useInput call captures the pre-first-event `state` and overwrites
+  // the first event's setState payload — leaving the first character
+  // missing from `buffer`. Reading + writing through the ref means every
+  // applyKey() sees the latest buffer regardless of render timing.
+  const stateRef = useRef(state);
+  useEffect(() => { stateRef.current = state; }, [state]);
+  const commit = (next) => {
+    stateRef.current = next;
+    setState(next);
+  };
+
   useInput((input, key) => {
+    const current = stateRef.current;
     // ─── Slash-popup keyboard contract (highest priority when open) ──
     if (slashOpen) {
       // Esc: clear the buffer and dismiss the popup. The host's onEscape
       // is NOT called in this branch — Esc here is a popup gesture, not
       // a turn-abort. (Outside of popup mode Esc still aborts streaming.)
       if (key.escape) {
-        const cleared = { ...state, buffer: '', cursor: 0, lastSubmit: null, lastWasPaste: false };
-        setState(cleared);
+        const cleared = { ...current, buffer: '', cursor: 0, lastSubmit: null, lastWasPaste: false };
+        commit(cleared);
         if (onBufferChange) {
           try { onBufferChange(''); } catch {}
         }
@@ -184,15 +200,15 @@ export function Editor({
       if (key.tab || key.return) {
         const safeIdx = Math.max(0, Math.min(slashSuggestions.length - 1, slashSelectedIndex || 0));
         const picked = slashSuggestions[safeIdx];
-        const bufTrim = state.buffer.replace(/\s+$/, '');
-        const alreadyExact = !!picked && (state.buffer === picked.cmd || bufTrim === picked.cmd);
+        const bufTrim = current.buffer.replace(/\s+$/, '');
+        const alreadyExact = !!picked && (current.buffer === picked.cmd || bufTrim === picked.cmd);
         if (alreadyExact) {
           if (key.tab) return; // no completion to make
           // key.return on exact match → fall through to applyKey/submit.
         } else {
           if (picked) {
-            const next = fillSlashCommand(state, picked.cmd);
-            setState(next);
+            const next = fillSlashCommand(current, picked.cmd);
+            commit(next);
             if (onBufferChange) {
               try { onBufferChange(next.buffer); } catch {}
             }
@@ -206,8 +222,8 @@ export function Editor({
     // Esc: forward to host (ReplApp uses this to abort an in-flight turn).
     // Do not mutate the buffer — the user may want to keep typing.
     if (key.escape) { if (onEscape) onEscape(); return; }
-    const next = applyKey(state, { input, key });
-    setState(next);
+    const next = applyKey(current, { input, key });
+    commit(next);
     if (onBufferChange) {
       try { onBufferChange(next.buffer); } catch { /* observer is best-effort */ }
     }

package/tui/repl.mjs

@@ -2,11 +2,15 @@
 // (spec §5.8) AND a sticky-bottom chat layout (v5.3).
 //
 // Layout (top → bottom inside the outer column):
-//   1. <Static items={scrollback}/> — splash item + per-turn user/assistant
-//      blocks. Static renders each item ONCE to terminal scrollback and
-//      never re-renders it, so the splash + history scroll away naturally
-//      as new content appends. This is the Claude CLI / opencode pattern
-//      translated to Ink's idiom — Static IS the scroll buffer.
+//   1. Scrollback — splash item + per-turn user/assistant blocks.
+//      Non-alt path uses <Static items={scrollback}/>: Ink writes each
+//      item ONCE to terminal scrollback so the splash + history scroll
+//      away naturally as new content appends (the v5.3 contract).
+//      Alt-buffer path renders the same items as regular flex children
+//      instead — Static's "write above the live frame" mechanism is
+//      invisible inside the DEC 1049 alt canvas (the live frame
+//      immediately overwrites that area), so v5.4.1 splashes vanished.
+//      Flex children re-render each frame; <Splash/> output is stable.
 //   2. Live region — partial assistant stream (state.liveAssistant) and
 //      optional <SlashHints/> while the input buffer starts with '/'.
 //      This Box re-renders on every chunk; the rest of the tree does not.
@@ -366,19 +370,23 @@ export function ReplApp({ splashProps, runTurn, runTurnFactory, slashCommands, o
     React.createElement(
       Box,
       { flexDirection: 'column', height: outerHeight },
-      // 1) Scrollback (write-once via Ink Static).
-      //    In alt-buffer mode the Static lives inside a flex-grow inner
-      //    Box so it absorbs slack rather than pushing the editor out of
-      //    the viewport. In legacy mode it stays sibling-flat so the
-      //    structural test (Editor must be last sibling) still passes.
+      // 1) Scrollback.
+      //    Alt-buffer path: render items as regular flex children, NOT via
+      //    <Static/>. Ink's <Static/> writes once to stdout above the live
+      //    frame — in the DEC 1049 alt canvas that area is immediately
+      //    overwritten by the next live frame, so the splash + history
+      //    end up invisible (v5.4.1 regression). Trade-off: items
+      //    re-render each frame; <Splash/> output is stable so this is
+      //    visually identical to the Static version.
+      //    Non-alt path: keeps <Static/> — the legacy v5.3 contract
+      //    (splash scrolls away naturally on the primary buffer) AND the
+      //    structural snapshot in tests/v53-repl-layout.test.mjs.
       altEnabled
         ? React.createElement(
             Box,
             { flexDirection: 'column', flexGrow: 1, flexShrink: 1, overflow: 'hidden' },
-            React.createElement(
-              Static,
-              { items: state.scrollback },
-              (item) => React.createElement(ScrollbackItem, { key: item.id, item })
+            state.scrollback.map((item) =>
+              React.createElement(ScrollbackItem, { key: item.id, item })
             ),
             // Live region — partial assistant stream (inside the scroll
             // region so it grows naturally above the status bar).