superqode 2.4.32__tar.gz → 2.4.34__tar.gz

{superqode-2.4.32 → superqode-2.4.34}/CHANGELOG.md

@@ -7,6 +7,47 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.34] - 2026-09-30
+
+### Fixed
+
+- Keep context preview open while removing references, with Delete to remove and
+  Enter to inspect; preserve draft text, cursor and prompt focus on return.
+- Keep connection-search navigation separate from detail scrolling, open selected
+  Activity actions with Enter, and restore prompt focus after closing panels.
+- Quiet routine success popups while retaining Activity receipts and actionable
+  error feedback.
+
+### Added
+
+- Workspace draft recovery with debounced private saves of text, cursor and
+  attachment references, plus focus-aware panel shortcut hints.
+- Offline real-PTY checks for paste, newline encodings, resize, Escape and OSC 52
+  clipboard output, with a live-terminal compatibility checklist.
+- Keyboard and draft-preservation regression checks, plus a CI responsiveness gate
+  with downloadable timing reports for small and large terminal sizes.
+
+## [2.4.33] - 2026-09-30
+
+### Added
+
+- Task-scoped per-file diff review and guarded undo that preserve pre-existing
+  staged and unstaged edits without changing Git's index.
+- `:context next` to inspect the draft, staged references, available instructions
+  and tools, with reference removal controls.
+- `:connect retry` and connection-catalog retry controls that preserve drafts,
+  conversation content and search filters.
+- Repeatable local TUI responsiveness probe for streaming, long history, typing,
+  scrolling and terminal resizing.
+
+### Fixed
+
+- Keep previous direct-model session state when replacement initialization fails,
+  and defer ACP teardown until the replacement model has initialized.
+- Scroll long Activity evidence and fit diff-review controls in small terminals.
+- Show observed tool execution and approval/question waits in the live indicator.
+- Scan only new streamed markdown characters while buffering unfinished code.
+
 ## [2.4.32] - 2026-09-30
 
 ### Added

{superqode-2.4.32 → superqode-2.4.34}/MANIFEST.in

@@ -3,6 +3,8 @@ include NOTICE
 include README.md
 include CHANGELOG.md
 include scripts/check_release_metadata.py
+include scripts/benchmark_tui_responsiveness.py
+include scripts/check_tui_terminal.py
 recursive-include examples *.md *.py *.yaml
 recursive-include src/superqode/data/eval_fixtures *.log
 recursive-include src/superqode/data/eval_packs *.yaml

{superqode-2.4.32 → superqode-2.4.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.32
+Version: 2.4.34
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.32 → superqode-2.4.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.4.32"
+version = "2.4.34"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

superqode-2.4.34/scripts/benchmark_tui_responsiveness.py

@@ -0,0 +1,168 @@
+"""Repeatable local TUI probe; requires no provider credentials or network.
+
+Reports event-loop delay during streamed code, typing, scrolling and resizing.
+Times include Textual's headless rendering and are not SSH/network measurements.
+"""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import platform
+from pathlib import Path
+import statistics
+import tempfile
+from time import perf_counter
+
+from superqode.app_main import SuperQodeApp, SelectionAwareInput
+from superqode.app.widgets import ConversationLog
+
+
+# Generous budgets accommodate shared CI hosts while rejecting visible stalls.
+# Raw timings are retained as artifacts to guide tighter measured baselines.
+PERFORMANCE_BUDGETS_MS = {
+    "stream_ms": 2500,
+    "chunk_and_yield_p95_ms": 10,
+    "chunk_and_yield_max_ms": 1000,
+    "event_loop_max_delay_ms": 1000,
+    "typing_two_keys_ms": 1500,
+    "scroll_with_settle_ms": 750,
+    "resize_with_settle_ms": 1500,
+}
+
+
+def budget_failures(report):
+    failures = []
+    results = report.get("results") or []
+    if sorted(tuple(result.get("size") or ()) for result in results) != [(80, 24), (120, 40)]:
+        failures.append("Expected both terminal-size results.")
+    for result in results:
+        size = result.get("size")
+        for metric, limit in PERFORMANCE_BUDGETS_MS.items():
+            value = result.get(metric)
+            if not isinstance(value, (int, float)) or not 0 <= value <= limit:
+                failures.append(f"{size}: {metric}={value!r}; budget {limit} ms")
+        lines = result.get("rendered_lines")
+        if not isinstance(lines, int) or not 0 < lines < 4000:
+            failures.append(f"{size}: rendered history/output exceeded the 4,000-line budget")
+    return failures
+
+
+async def probe(size):
+    from superqode.app.draft_recovery import DraftStore
+
+    app = SuperQodeApp()
+    app._draft_store = DraftStore(Path.cwd() / f"draft-probe-{size[0]}x{size[1]}")
+    for name in (
+        "_start_models_dev_refresh",
+        "_start_acp_registry_refresh",
+        "_report_catalog_freshness",
+        "_run_startup_connect",
+        "_prewarm_litellm",
+    ):
+        setattr(app, name, lambda *a, **k: None)
+    timings = []
+    async with app.run_test(size=size) as pilot:
+        log = app.query_one("#log", ConversationLog)
+        log.replay_history(
+            [
+                {
+                    "role": "user" if i % 2 == 0 else "assistant",
+                    "content": f"Turn {i}\n\n" + "Repeated output. " * 30,
+                }
+                for i in range(10000)
+            ]
+        )
+        await pilot.pause()
+        log.start_agent_session("Fixture", "offline")
+        text = "```python\n" + "print('a long streamed code block')\n\n" * 1000 + "```\n\n"
+
+        async def stream():
+            started = perf_counter()
+            for offset in range(0, len(text), 32):
+                tick = perf_counter()
+                log.add_response_chunk(text[offset : offset + 32])
+                await asyncio.sleep(0)
+                timings.append((perf_counter() - tick) * 1000)
+            return (perf_counter() - started) * 1000
+
+        loop_delays = []
+
+        async def heartbeat():
+            while not producer.done():
+                tick = perf_counter()
+                await asyncio.sleep(0.005)
+                loop_delays.append(max(0, (perf_counter() - tick) * 1000 - 5))
+
+        producer = asyncio.create_task(stream())
+        monitor = asyncio.create_task(heartbeat())
+        prompt = app.query_one("#prompt-input", SelectionAwareInput)
+        prompt.focus()
+        tick = perf_counter()
+        await pilot.press("h", "i")
+        typing_ms = (perf_counter() - tick) * 1000
+        assert prompt.value == "hi"
+        tick = perf_counter()
+        log.scroll_home(animate=False)
+        await pilot.pause()
+        scroll_ms = (perf_counter() - tick) * 1000
+        tick = perf_counter()
+        await pilot.resize_terminal(size[0] + 10, size[1] + 5)
+        await pilot.pause()
+        resize_ms = (perf_counter() - tick) * 1000
+        stream_ms = await producer
+        await monitor
+        assert prompt.value == "hi"
+        return {
+            "size": list(size),
+            "history_messages": 10000,
+            "rendered_lines": len(log.lines),
+            "stream_chars": len(text),
+            "stream_ms": round(stream_ms, 2),
+            "event_loop_max_delay_ms": round(max(loop_delays, default=0), 3),
+            "chunk_and_yield_p50_ms": round(statistics.median(timings), 3),
+            "chunk_and_yield_p95_ms": round(sorted(timings)[int(len(timings) * 0.95)], 3),
+            "chunk_and_yield_max_ms": round(max(timings), 3),
+            "typing_two_keys_ms": round(typing_ms, 2),
+            "scroll_with_settle_ms": round(scroll_ms, 2),
+            "resize_with_settle_ms": round(resize_ms, 2),
+        }
+
+
+async def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--check", action="store_true", help="Fail on a responsiveness budget regression"
+    )
+    parser.add_argument("--output", type=Path, help="Save the JSON measurements")
+    args = parser.parse_args()
+    output = args.output.resolve() if args.output else None
+    original_cwd = Path.cwd()
+    os.environ.pop("SUPERQODE_CONNECT", None)
+    os.environ["SUPERQODE_VIM_MODE"] = "0"
+    try:
+        with tempfile.TemporaryDirectory() as directory:
+            os.chdir(directory)
+            results = [await probe(size) for size in ((80, 24), (120, 40))]
+    finally:
+        os.chdir(original_cwd)
+    report = {
+        "kind": "headless local probe",
+        "python": platform.python_version(),
+        "platform": platform.system(),
+        "budgets_ms": PERFORMANCE_BUDGETS_MS,
+        "results": results,
+    }
+    failures = budget_failures(report)
+    report["budget_failures"] = failures
+    text = json.dumps(report, indent=2)
+    if output:
+        output.write_text(text + "\n", encoding="utf-8")
+    print(text)
+    return 1 if args.check and failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(asyncio.run(main()))

superqode-2.4.34/scripts/check_tui_terminal.py

@@ -0,0 +1,236 @@
+"""Offline real-PTY input/rendering smoke check (Unix), not an SSH emulator.
+
+Exercises bracketed paste, newline encodings, resizing, Escape and copy-command
+routing. Clipboard backends are captured; verify native/remote clipboard behavior
+with the live-terminal checklist in docs/advanced/tui.md.
+"""
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import os
+from pathlib import Path
+import select
+import signal
+import struct
+import subprocess
+import sys
+import tempfile
+from time import monotonic
+
+
+def child(state_path: Path):
+    from superqode.app_main import SuperQodeApp, SelectionAwareInput
+    from superqode.app.widgets import ConversationLog
+    from superqode.history import HistoryManager
+
+    class TerminalProbe(SuperQodeApp):
+        def __init__(self):
+            super().__init__()
+            self._history_manager = HistoryManager(history_file=Path.cwd() / "history.jsonl")
+            self.copies = []
+            for name in (
+                "_start_models_dev_refresh",
+                "_start_acp_registry_refresh",
+                "_report_catalog_freshness",
+                "_run_startup_connect",
+                "_prewarm_litellm",
+            ):
+                setattr(self, name, lambda *a, **k: None)
+
+        def on_mount(self):
+            super().on_mount()
+            self._last_response = "copy fixture\nexact code"
+            self.query_one("#log", ConversationLog).add_assistant(self._last_response)
+            self.set_interval(0.05, self.record)
+
+        def _copy_text_to_clipboard(self, text):
+            copied = super()._copy_text_to_clipboard(text)
+            self.copies.append(text)
+            return copied
+
+        def _os_clipboard_copy(self, text):
+            return False  # Emit OSC 52 without changing the host clipboard.
+
+        def record(self):
+            from textual.css.query import NoMatches
+
+            try:
+                prompt = self.query_one("#prompt-input", SelectionAwareInput)
+            except NoMatches:
+                return
+            state = {
+                "text": prompt.value,
+                "cursor": prompt.cursor_position,
+                "focused": getattr(self.focused, "id", None),
+                "screen": type(self.screen).__name__,
+                "size": [self.size.width, self.size.height],
+                "copies": self.copies,
+            }
+            temporary = state_path.with_suffix(".tmp")
+            temporary.write_text(json.dumps(state), encoding="utf-8")
+            os.replace(temporary, state_path)
+
+    TerminalProbe().run()
+
+
+def probe(term: str, size: tuple[int, int]):
+    import fcntl
+    import pty
+    import termios
+
+    checks = []
+    output_bytes = 0
+    with tempfile.TemporaryDirectory(prefix="superqode-pty-") as directory:
+        root = Path(directory)
+        state_path = root / "state.json"
+        master, slave = pty.openpty()
+        fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", size[1], size[0], 0, 0))
+        env = {**os.environ, "TERM": term, "HOME": directory, "SUPERQODE_VIM_MODE": "0"}
+        env.pop("SUPERQODE_CONNECT", None)
+        process = subprocess.Popen(
+            [sys.executable, str(Path(__file__).resolve()), "--child", str(state_path)],
+            stdin=slave,
+            stdout=slave,
+            stderr=slave,
+            cwd=root,
+            env=env,
+            start_new_session=True,
+        )
+        os.close(slave)
+        transcript = bytearray()
+
+        def wait_for(name, predicate, timeout=8):
+            nonlocal output_bytes
+            deadline = monotonic() + timeout
+            state = {}
+            while monotonic() < deadline:
+                ready, _, _ = select.select([master], [], [], 0.05)
+                if ready:
+                    try:
+                        data = os.read(master, 65536)
+                    except OSError:
+                        data = b""
+                    output_bytes += len(data)
+                    transcript.extend(data)
+                    del transcript[:-16000]
+                if process.poll() is not None:
+                    raise RuntimeError(
+                        f"{name}: TUI exited {process.returncode}: {transcript[-3000:]!r}"
+                    )
+                if state_path.exists():
+                    state = json.loads(state_path.read_text())
+                    if predicate(state):
+                        checks.append(name)
+                        return state
+            raise RuntimeError(f"{term} {size}: {name} timed out; last state {state}")
+
+        def send(data):
+            os.write(master, data)
+
+        try:
+            wait_for(
+                "startup and rendering",
+                lambda s: s["focused"] == "prompt-input" and s["size"] == list(size),
+            )
+            send(b"\x1b[200~first\n  second\x1b[201~")
+            wait_for(
+                "bracketed multiline paste remains unsent", lambda s: s["text"] == "first\n  second"
+            )
+            send(b"\x0a")
+            wait_for("Ctrl+J newline", lambda s: s["text"] == "first\n  second\n")
+            send(b"\x1b[13;2u")
+            wait_for("CSI-u Shift+Enter newline", lambda s: s["text"] == "first\n  second\n\n")
+            send(b"\x1b[13;3u")
+            wait_for("CSI-u Alt+Enter newline", lambda s: s["text"] == "first\n  second\n\n\n")
+            send(b"\x15")
+            wait_for("clear multiline input", lambda s: s["text"] == "")
+            send(b":copy response")
+            wait_for("copy command input", lambda s: s["text"] == ":copy response")
+            send(b"\r")
+            wait_for(
+                "copy command routes exact response",
+                lambda s: s["copies"] == ["copy fixture\nexact code"] and s["text"] == "",
+            )
+            encoded = base64.b64encode(b"copy fixture\nexact code")
+            wait_for(
+                "OSC 52 clipboard escape emitted",
+                lambda s: b"\x1b]52;" in transcript and encoded in transcript,
+            )
+            send(b"keep this draft")
+            wait_for("typing", lambda s: s["text"] == "keep this draft")
+            send(b"\x0b")
+            wait_for("command palette keyboard focus", lambda s: s["focused"] != "prompt-input")
+            send(b"\x1b")
+            wait_for(
+                "Escape restores draft and focus",
+                lambda s: s["focused"] == "prompt-input" and s["text"] == "keep this draft",
+            )
+            resized = [size[0] + 10, size[1] + 5]
+            fcntl.ioctl(
+                master, termios.TIOCSWINSZ, struct.pack("HHHH", resized[1], resized[0], 0, 0)
+            )
+            os.kill(process.pid, signal.SIGWINCH)
+            wait_for(
+                "resize preserves draft",
+                lambda s: s["size"] == resized and s["text"] == "keep this draft",
+            )
+            send(b"\x15")
+            wait_for("clear before context command", lambda s: s["text"] == "")
+            send(b":context next")
+            wait_for("context command input", lambda s: s["text"] == ":context next")
+            send(b"\r")
+            wait_for("context panel opens", lambda s: s["screen"] == "ContextPreviewScreen")
+            send(b"\x1b")
+            wait_for(
+                "panel Escape restores prompt focus",
+                lambda s: s["focused"] == "prompt-input" and s["screen"] != "ContextPreviewScreen",
+            )
+            return {
+                "term": term,
+                "size": list(size),
+                "checks": checks,
+                "rendered_bytes": output_bytes,
+            }
+        finally:
+            process.terminate()
+            try:
+                process.wait(timeout=3)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait()
+            os.close(master)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path)
+    parser.add_argument("--child", type=Path, help=argparse.SUPPRESS)
+    args = parser.parse_args()
+    if args.child:
+        child(args.child)
+        return 0
+    if os.name != "posix":
+        parser.error("PTY checks require Unix; use the live-terminal checklist on Windows.")
+    report = {
+        "kind": "real PTY, offline",
+        "clipboard": "command routing and OSC 52 emission; native backend disabled",
+        "results": [],
+        "failures": [],
+    }
+    for term, size in (("xterm-256color", (80, 24)), ("screen-256color", (120, 40))):
+        try:
+            report["results"].append(probe(term, size))
+        except (OSError, RuntimeError, ValueError) as exc:
+            report["failures"].append(str(exc))
+    text = json.dumps(report, indent=2)
+    if args.output:
+        args.output.write_text(text + "\n", encoding="utf-8")
+    print(text)
+    return 1 if report["failures"] else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

{superqode-2.4.32 → superqode-2.4.34}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.4.32"
+__version__ = "2.4.34"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.4.32 → superqode-2.4.34}/src/superqode/app/constants.py

@@ -512,6 +512,7 @@ COMMANDS = [
     ":connect setup",
     ":connect search",
     ":connect status",
+    ":connect retry",
     ":connect test",
     ":connect test --infer",
     ":connect test --tools",
@@ -519,6 +520,7 @@ COMMANDS = [
     ":connect a2a",
     ":connect protocols",
     ":context",
+    ":context next",
     ":chat",
     ":chat off",
     ":chat clear",
@@ -627,6 +629,7 @@ COMMANDS = [
     ":permissions",
     ":policy",
     ":diff",
+    ":diff task",
     ":diff files",
     ":diff split",
     ":diff unified",

superqode-2.4.34/src/superqode/app/draft_recovery.py

@@ -0,0 +1,72 @@
+"""Bounded, private workspace drafts; attachment payloads are never persisted."""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+import tempfile
+from threading import Lock
+
+MAX_DRAFT_BYTES = 1024 * 1024
+
+
+class DraftStore:
+    def __init__(self, workspace: Path):
+        self.workspace = workspace.resolve()
+        self.path = self.workspace / ".superqode" / "draft.json"
+        self._lock = Lock()
+        self._last_revision = -1
+
+    def load(self) -> dict:
+        try:
+            with self.path.open("rb") as stream:
+                raw = stream.read(MAX_DRAFT_BYTES + 1)
+            if len(raw) > MAX_DRAFT_BYTES:
+                return {}
+            state = json.loads(raw)
+            if not isinstance(state, dict) or state.get("version") != 1:
+                return {}
+            text = state.get("text")
+            cursor = state.get("cursor")
+            refs = state.get("refs")
+            images = state.get("images")
+            if not isinstance(text, str) or not isinstance(cursor, int):
+                return {}
+            if not isinstance(refs, list) or not all(isinstance(ref, str) for ref in refs):
+                return {}
+            if not isinstance(images, dict) or not all(
+                ref in refs and isinstance(path, str) for ref, path in images.items()
+            ):
+                return {}
+            return {
+                "text": text,
+                "cursor": max(0, min(cursor, len(text))),
+                "refs": list(dict.fromkeys(refs))[:100],
+                "images": images,
+                "prefill": state.get("prefill") if isinstance(state.get("prefill"), str) else "",
+            }
+        except (OSError, ValueError, TypeError):
+            return {}
+
+    def save(self, state: dict, revision: int) -> None:
+        """Serialize writes, refusing a stale background save after an exit flush."""
+        with self._lock:
+            if revision < self._last_revision:
+                return
+            self._last_revision = revision
+            raw = json.dumps({"version": 1, **state}, ensure_ascii=False).encode("utf-8")
+            if not state.get("text") and not state.get("refs") or len(raw) > MAX_DRAFT_BYTES:
+                self.path.unlink(missing_ok=True)
+                return
+            self.path.parent.mkdir(parents=True, exist_ok=True)
+            temporary = None
+            try:
+                descriptor, name = tempfile.mkstemp(prefix=".draft-", dir=self.path.parent)
+                temporary = Path(name)
+                with os.fdopen(descriptor, "wb") as stream:
+                    stream.write(raw)
+                os.replace(temporary, self.path)
+            finally:
+                if temporary is not None:
+                    temporary.unlink(missing_ok=True)

{superqode-2.4.32 → superqode-2.4.34}/src/superqode/app/inputs.py

@@ -126,10 +126,18 @@ class SelectionAwareInput(TextArea):
 
     def on_text_area_changed(self, event: TextArea.Changed) -> None:
         self._resize_to_content()
+        schedule = getattr(self.app, "_schedule_draft_save", None)
+        if callable(schedule):
+            schedule()
         update_panel = getattr(self.app, "_update_prompt_completion_panel", None)
         if callable(update_panel):
             update_panel(self.value)
 
+    def on_text_area_selection_changed(self, event: TextArea.SelectionChanged) -> None:
+        schedule = getattr(self.app, "_schedule_draft_save", None)
+        if callable(schedule):
+            schedule()
+
     def on_resize(self, event: events.Resize) -> None:
         self._resize_to_content()
 

{superqode-2.4.32 → superqode-2.4.34}/src/superqode/app/mixins/agent_run.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 from typing import Any, Dict, List, Optional
+import asyncio
 import os
 import re
 import subprocess
@@ -594,6 +595,10 @@ class AgentRunMixin:
                 log.add_info("Context compacted.")
             return
 
+        begin_changes = getattr(self, "_begin_task_changes", None)
+        if callable(begin_changes):
+            await asyncio.to_thread(begin_changes)
+
         mcp_context = await self._resolve_mcp_attachment_context(log)
         if mcp_context:
             text = f"{mcp_context}\n\n{text}"
@@ -1181,7 +1186,7 @@ class AgentRunMixin:
                         pass
 
                     # Compute file diffs for detected files
-                    file_diffs = self._compute_file_diffs(files_modified) if files_modified else {}
+                    file_diffs = self._compute_file_diffs(files_modified)
 
                     # Use ACP-style outcome display for both ACP and BYOK
                     outcome_agent = (
@@ -1270,7 +1275,7 @@ class AgentRunMixin:
                     except Exception:
                         pass
 
-                    file_diffs = self._compute_file_diffs(files_modified) if files_modified else {}
+                    file_diffs = self._compute_file_diffs(files_modified)
 
                     # Show completion summary with file changes
                     self._show_completion_summary(
@@ -1369,6 +1374,9 @@ class AgentRunMixin:
     @work(exclusive=True, thread=True)
     def _send_to_agent(self, text: str, name: str, log: ConversationLog):
         """Send message to agent with real-time streaming output."""
+        begin_changes = getattr(self, "_begin_task_changes", None)
+        if callable(begin_changes):
+            begin_changes()
         session = get_session()
         agent = session.connected_agent