superqode 2.4.37__tar.gz → 2.4.38__tar.gz

{superqode-2.4.37 → superqode-2.4.38}/CHANGELOG.md

@@ -7,6 +7,39 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.38] - 2026-10-01
+
+### Added
+
+- Run SuperQode inside Herdr with automatic working, idle, approval and question
+  status reporting, plus harness, model and session details.
+- Restore durable interactive conversations after a Herdr server restart,
+  preserving the harness, model, runtime, approval policy and plan/build mode.
+  Update restore commands when switching or forking sessions, and replace stale
+  commands with a fresh launch when the active backend cannot resume.
+- Open saved conversations with `superqode --resume <session-id>` or fork them
+  with `superqode --fork <session-id>`. Set startup decisions with
+  `--approval-mode ask|auto|deny` and `--interaction-mode build|plan`.
+- Document setup, status semantics, pane input, restoration and troubleshooting
+  in the Herdr integration guide and CLI reference. Add Herdr checks to the
+  Linux, macOS and Windows CI matrix.
+
+### Fixed
+
+- Prevent nested coding agents, SDKs and shell tools from claiming their
+  parent's Herdr pane. Keep reporting bounded and release pane authority when
+  SuperQode exits.
+
+### Known limitations
+
+- Herdr's built-in agent registry does not yet include SuperQode. Launch it
+  normally inside a pane and use pane input; `agent start --kind`,
+  `agent prompt` and `agent send-keys` require an upstream registry entry.
+- Conversation restoration requires a durable SuperQode session and Herdr
+  0.9.2 or later. Unsupported backends reopen a fresh TUI. Native lifecycle
+  and restart tests passed with Herdr 0.9.3 on macOS; Linux and Windows checks
+  are configured in CI.
+
 ## [2.4.37] - 2026-10-01
 
 ### Added

{superqode-2.4.37 → superqode-2.4.38}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.37
+Version: 2.4.38
 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.37 → superqode-2.4.38}/pyproject.toml

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

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/__init__.py

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

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/acp/client.py

@@ -40,6 +40,8 @@ from superqode.acp.types import (
     AvailableCommandsResponse,
 )
 
+from superqode.herdr import child_env
+
 
 async def cancel_prompt_with_grace(
     client, prompt_task: asyncio.Task, *, timeout: float = 2.0
@@ -342,7 +344,7 @@ class ACPClient:
                 stdout=asyncio.subprocess.PIPE,
                 stderr=asyncio.subprocess.STDOUT,  # Merge stderr into stdout
                 cwd=str(self.project_root),
-                env=env,
+                env=child_env(env),
                 limit=10 * 1024 * 1024,  # 10MB buffer
             )
 
@@ -1656,7 +1658,7 @@ class ACPClient:
                 stderr=asyncio.subprocess.STDOUT,
                 stdin=asyncio.subprocess.PIPE,
                 cwd=cwd or str(self.project_root),
-                env=env,
+                env=child_env(env),
             )
 
             self._terminals[terminal_id] = {

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/agents/client.py

@@ -59,6 +59,8 @@ from acp.schema import (
     WriteTextFileResponse,
 )
 
+from superqode.herdr import child_env
+
 
 class SuperQodeACPClient(Client):
     """ACP client implementation for SuperQode."""
@@ -191,7 +193,7 @@ class ACPAgentManager:
                 stdin=asyncio.subprocess.PIPE,
                 stdout=asyncio.subprocess.PIPE,
                 cwd=cwd or os.getcwd(),
-                env={**os.environ, **extra_env} if extra_env else None,
+                env=child_env({**os.environ, **(extra_env or {})}),
             )
 
             if proc.stdin is None or proc.stdout is None:

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/__init__.py

@@ -111,15 +111,20 @@ def _print_launch_splash() -> None:
         pass
 
 
-def run_textual_app():
+def run_textual_app(**startup):
     """Run the SuperQode Textual TUI application."""
     _print_launch_splash()
 
     # Import from parent module to avoid duplication
     from superqode.app_main import SuperQodeApp
 
-    app = SuperQodeApp()
-    app.run()
+    app = SuperQodeApp(**startup)
+    try:
+        app.run()
+    finally:
+        from superqode.app.herdr import close
+
+        close(app)
 
 
 __all__ = [

superqode-2.4.38/src/superqode/app/herdr.py

@@ -0,0 +1,108 @@
+"""Bridge the interactive app's shared lifecycle to Herdr."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from superqode.herdr import HerdrReporter, launch_prefix, valid_resume_argv
+
+
+def resume_command(app) -> tuple[str, tuple[str, ...]]:
+    """Advertise only a durable active session, never a recent-session fallback."""
+    approval = getattr(app, "approval_mode", "ask")
+    mode = "plan" if getattr(app, "_plan_mode_enabled", False) else "build"
+    base = (*launch_prefix(), "--tui", "--approval-mode", approval, "--interaction-mode", mode)
+    # Replacing a previous restore command with a fresh launch prevents Herdr
+    # from reopening the old conversation after disconnecting or changing to
+    # a backend without durable SuperQode session storage.
+    fresh = base if valid_resume_argv(base) else ("superqode", "--tui")
+    pure = getattr(app, "_pure_mode", None)
+    if pure is None or not getattr(getattr(pure, "session", None), "connected", False):
+        return "", fresh
+    if getattr(app, "current_agent", "") or getattr(app, "_chat_mode", False):
+        return "", fresh
+    try:
+        sid = pure.get_current_session_id()
+        manager = getattr(pure, "_session_manager", None)
+        meta = manager.get_session_info(sid) if sid and manager else None
+        if meta is None or not meta.provider or not meta.model:
+            return "", fresh
+        # Session storage and Herdr's restored pane both belong to this cwd.
+        if (
+            meta.working_directory
+            and Path(meta.working_directory).resolve() != Path.cwd().resolve()
+        ):
+            return "", fresh
+        harness = meta.harness_path or meta.harness_id or "core"
+        if not meta.harness_session and getattr(pure, "_agent", None) is None:
+            return "", fresh
+        argv = (
+            *base,
+            "--resume",
+            sid,
+            "--provider",
+            meta.provider,
+            "--model",
+            meta.model,
+            "--harness",
+            harness,
+            "--runtime",
+            pure.runtime_name,
+        )
+        if valid_resume_argv(argv):
+            return sid, argv
+    except (AttributeError, OSError, TypeError, ValueError):
+        pass
+    return "", fresh
+
+
+def start(app) -> None:
+    app._herdr_reporter = HerdrReporter.from_env()
+    sync(app)
+
+
+def sync(app) -> None:
+    reporter = getattr(app, "_herdr_reporter", None)
+    if reporter is None:
+        return
+    pending = []
+    pure = getattr(app, "_pure_mode", None)
+    try:
+        pending = pure.get_pending_approvals() if pure is not None else []
+    except Exception:
+        pass
+    if getattr(app, "_herdr_restore_error", "") and not getattr(
+        getattr(pure, "session", None), "connected", False
+    ):
+        state, message = "blocked", "Session restore failed"
+    elif getattr(app, "_awaiting_agent_question", False):
+        state, message = "blocked", "Answer needed"
+    elif getattr(app, "_permission_pending", False) or pending:
+        state, message = "blocked", "Approval needed"
+    else:
+        state = "working" if getattr(app, "is_busy", False) else "idle"
+        message = ""
+    harness = getattr(app, "current_agent", "") or getattr(app, "current_mode", "")
+    model = getattr(app, "current_model", "")
+    try:
+        status = app.query_one("#status-bar")
+        harness = getattr(status, "active_harness", "") or harness
+        model = getattr(status, "active_model", "") or model
+    except Exception:
+        pass
+    sid, argv = resume_command(app)
+    reporter.report(
+        state,
+        message=message,
+        harness=harness,
+        model=model,
+        session_id=sid,
+        resume_argv=argv,
+    )
+
+
+def close(app) -> None:
+    reporter = getattr(app, "_herdr_reporter", None)
+    if reporter is not None:
+        app._herdr_reporter = None
+        reporter.close()

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/agent_run.py

@@ -43,6 +43,8 @@ from superqode.app.recipes import LocalRecipe
 from superqode.app.async_utils import _AsyncLoopThread
 from superqode.app.session_state import get_session
 
+from superqode.herdr import child_env
+
 _ACP_AGENT_SHORT_NAMES: frozenset[str] | None = None
 
 
@@ -1703,7 +1705,7 @@ class AgentRunMixin:
                 cwd=os.getcwd(),
                 text=True,
                 bufsize=1,
-                env=env,
+                env=child_env(env),
             )
 
             # Store process reference for cancellation
@@ -1850,6 +1852,7 @@ class AgentRunMixin:
                 stderr=subprocess.STDOUT,
                 text=True,
                 bufsize=1,
+                env=child_env(),
             )
             self._agent_process = process
 
@@ -3064,7 +3067,7 @@ class AgentRunMixin:
                     cwd=os.getcwd(),
                     text=True,
                     bufsize=1,
-                    env=env,
+                    env=child_env(env),
                 )
                 self._claude_process = process
                 self._claude_session_id = ""
@@ -3660,7 +3663,7 @@ class AgentRunMixin:
                 cwd=os.getcwd(),
                 text=True,
                 bufsize=1,
-                env=env,
+                env=child_env(env),
             )
 
             # Store process reference for cancellation

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/events.py

@@ -134,6 +134,9 @@ class EventHandlerMixin:
                 pass
 
     def on_unmount(self) -> None:
+        from superqode.app.herdr import close
+
+        close(self)
         self._stop_wave_bursts()
         self._flush_draft_recovery()
 

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/helper_interaction_mode.py

@@ -154,3 +154,6 @@ class HelperInteractionModeMixin:
             persist=False,
             dedupe_key=f"interaction-mode:{mode}",
         )
+        from superqode.app.herdr import sync
+
+        sync(self)

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/helper_permissions.py

@@ -53,6 +53,9 @@ class HelperPermissionsMixin:
             return
         if not pending:
             return
+        from superqode.app.herdr import sync
+
+        sync(self)
         card = Text()
         card.append("🔐 Tool approval needed\n\n", style=f"bold {THEME['warning']}")
         card.append(f"{len(pending)} pending item(s)\n", style=THEME["text"])

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/helpers.py

@@ -412,6 +412,9 @@ class HelpersMixin(
             getattr(self, "_permission_pending", False)
             or getattr(self, "_awaiting_agent_question", False)
         )
+        from superqode.app.herdr import sync
+
+        sync(self)
         self._set_composer_working_state(new, interactive=interactive)
         self._sync_navigation_controls()
         if not new:
@@ -763,6 +766,9 @@ class HelpersMixin(
             self.query_one("#status-bar", ColorfulStatusBar).active_runtime = display
         except Exception:  # noqa: BLE001
             pass
+        from superqode.app.herdr import sync
+
+        sync(self)
 
     def _sync_self_contained_status(self, runtime_name: str, *, tokens: int = 0) -> None:
         """Replace stale provider state with runtime-owned identity."""

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/model_catalog.py

@@ -1032,6 +1032,9 @@ class ModelCatalogMixin:
             self.query_one("#status-bar", ColorfulStatusBar).active_model = model or ""
         except Exception:  # noqa: BLE001
             pass
+        from superqode.app.herdr import sync
+
+        sync(self)
 
     def _set_acp_status(self, model: str = "") -> None:
         """Synchronize an ACP connection with the persistent top status bar."""

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app/mixins/slash_commands.py

@@ -1914,6 +1914,10 @@ class SlashCommandMixin:
             guidance="Other sessions remain saved.",
             dedupe_key=f"session-resume:{resolved_id}",
         )
+        from superqode.app.herdr import sync
+
+        self._herdr_restore_error = ""
+        sync(self)
         return True
 
     def _handle_fork_session(self, args: str, log: ConversationLog):
@@ -1937,6 +1941,9 @@ class SlashCommandMixin:
             log=log,
             dedupe_key=f"session-fork:{fork_id}",
         )
+        from superqode.app.herdr import sync
+
+        sync(self)
 
     def _handle_compact(self, log: ConversationLog):
         """Compact or enable compaction for the active local provider session."""

{superqode-2.4.37 → superqode-2.4.38}/src/superqode/app_main.py

@@ -343,7 +343,8 @@ class SuperQodeApp(
         False  # Flag to prevent immediate provider selection after showing picker
     )
     _awaiting_permission = False  # Track if waiting for permission response
-    _awaiting_agent_question = False  # Track if an agent is waiting for user input
+    _awaiting_agent_question = reactive(False)  # Agent needs user input
+    _permission_pending = reactive(False)
     _available_models: Dict[str, List[str]] = {}  # Available models per agent
     _last_response: str = ""  # Store last agent response for :copy command
     _last_user_message: str = ""  # Store last user prompt for :retry
@@ -366,8 +367,20 @@ class SuperQodeApp(
     _pending_plan_content: str = ""  # Exact model-authored plan awaiting review
     _approved_plan_for_next_run: str = ""  # One-shot execution context after approval
 
-    def __init__(self):
+    def __init__(
+        self,
+        *,
+        resume: str | None = None,
+        fork_from: str | None = None,
+        approval_mode: str | None = None,
+        interaction_mode: str | None = None,
+    ):
         super().__init__()
+        self._startup_resume = resume or fork_from or ""
+        self._startup_fork = bool(fork_from)
+        self._startup_interaction_mode = interaction_mode
+        if approval_mode is not None:
+            self.approval_mode = approval_mode
         # Modal prompts declare their Enter/text/Esc/navigation behavior once
         # here instead of being hand-registered across five dispatch sites.
         self._prompts = PromptStack()
@@ -479,6 +492,9 @@ class SuperQodeApp(
         yield CommandPalette(commands=self._build_palette_commands(), id="command-palette")
 
     def on_mount(self):
+        from superqode.app.herdr import start
+
+        start(self)
         # Focus input after a short delay to ensure widgets are fully ready
         self.set_timer(0.1, self._focus_input_on_ready)
         self._set_prompt_border_title()
@@ -506,9 +522,45 @@ class SuperQodeApp(
         if os.getenv("SUPERQODE_STARTUP_HEALTH", "").strip().lower() in ("1", "true", "yes"):
             self._run_startup_health_check()
         # Auto-connect a connection profile if requested via --connect.
-        if os.getenv("SUPERQODE_CONNECT", "").strip():
+        if self._startup_resume:
+            self.set_timer(0.1, self._run_startup_session)
+        elif self._startup_interaction_mode:
+            self._apply_interaction_mode(
+                self._startup_interaction_mode, self.query_one("#log", ConversationLog)
+            )
+        if not self._startup_resume and os.getenv("SUPERQODE_CONNECT", "").strip():
             self.set_timer(1.0, self._run_startup_connect)
 
+    def _run_startup_session(self) -> None:
+        from superqode.app.herdr import sync
+
+        log = self.query_one("#log", ConversationLog)
+        if not self._handle_resume_session(self._startup_resume, log):
+            self._herdr_restore_error = "Session restore failed"
+            sync(self)
+            return
+        self._herdr_restore_error = ""
+        if self._startup_fork:
+            self._handle_fork_session("", log)
+        if self._startup_interaction_mode:
+            self._apply_interaction_mode(self._startup_interaction_mode, log)
+        sync(self)
+
+    def watch_approval_mode(self, mode: str) -> None:
+        from superqode.app.herdr import sync
+
+        sync(self)
+
+    def watch__permission_pending(self, pending: bool) -> None:
+        from superqode.app.herdr import sync
+
+        sync(self)
+
+    def watch__awaiting_agent_question(self, pending: bool) -> None:
+        from superqode.app.herdr import sync
+
+        sync(self)
+
     def _run_startup_connect(self) -> None:
         """Dispatch the connection profile named in SUPERQODE_CONNECT (--connect)."""
         profile_id = os.environ.pop("SUPERQODE_CONNECT", "").strip()
@@ -1358,7 +1410,13 @@ class SuperQodeApp(
 
 
 def run_textual_app():
-    SuperQodeApp().run()
+    app = SuperQodeApp()
+    try:
+        app.run()
+    finally:
+        from superqode.app.herdr import close
+
+        close(app)
 
 
 if __name__ == "__main__":