lazyclaw 5.4.1 → 5.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaw",
-  "version": "5.4.1",
+  "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).