superqode 2.6.0__tar.gz → 2.7.1__tar.gz

{superqode-2.6.0 → superqode-2.7.1}/CHANGELOG.md

@@ -7,6 +7,72 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.7.1] - 2026-10-07
+
+### Fixed
+
+- Pasting output with tilde markers and image filenames no longer triggers an
+  uncaught home-directory lookup. Malformed image URLs, unresolved home paths,
+  invalid completion paths and image symlink loops fail safely while retaining
+  the composer draft. The file sidebar also tolerates unresolvable entries.
+
+## [2.7.0] - 2026-10-07
+
+### Added
+
+- Live Runs, Approvals and Delivery overview with `Ctrl+O`, `:runs`,
+  `:approvals` and `:delivery`, plus a persistent navigation and queue strip.
+  Inspect reported main/child-agent state and project WorkOrders while retaining
+  the composer draft and cursor.
+- WorkOrder Delivery inspection connects candidate changes, recorded checks,
+  human review and separate, confirmed merge/rollback actions to existing
+  repository acceptance checks.
+- Large-paste folding with paged previews, removal and exact-content expansion
+  on send. Unsent folded text recovers through the existing private draft store.
+- Explicit local shell-output preview and excerpt staging through `:output`.
+  Staging adds context to the next draft without sending it.
+- Versioned Omnigent import compatibility receipts identifying mapped fields,
+  preservation without enforcement, unsupported fields and behavioral changes.
+- `harness drift --require-complete` returns exit code 2 for incomplete static
+  verification when no known drift already requires exit code 1.
+
+### Fixed
+
+- Contextual ASK approvals carry single-use receipts scoped to invocation,
+  arguments and policy revision. DENY remains final; changed requests require
+  fresh consent and unavailable original policy scope blocks resumption.
+- Dynamic MCP calls use the governed call/result boundary, including policy
+  suppression before disallowed result persistence or exposure.
+- Drift checks resolve harness backends through the execution registry and
+  distinguish unknown backends from missing dependencies or unknown readiness.
+  Unknown checks no longer produce a clean report or an all-matched summary.
+
+### Changed
+
+- Mark the model-to-harness route in `:connect` as Recommended.
+- Bound composer previews, queue previews and submitted-message rendering while
+  retaining full message evidence. Folded payloads and shell-output handles have
+  explicit size limits; serialized draft recovery is bounded to 32 MiB.
+- Drift JSON retains its existing fields and adds completeness, known drift and
+  static-verification indicators. Default exit behavior remains unchanged.
+
+### Notes
+
+- Overview telemetry depends on what each runtime reports. Vendor-native
+  prompts outside those interfaces remain in their vendor UI.
+- Import receipts and static drift checks do not certify runtime equivalence,
+  credential readiness or live behavioral capability support.
+
+## [2.6.1] - 2026-10-05
+
+### Fixed
+
+- Inspecting RLM profiles, routing or peers before the first task now creates
+  a session for the selected harness. Switching profiles no longer reuses a
+  shared inspection worker or fails with "Changing an RLM profile requires a
+  new session" because of retained history from an earlier connection.
+- Inspection retains an existing session identity and does not call a model.
+
 ## [2.6.0] - 2026-10-05
 
 ### Added

{superqode-2.6.0 → superqode-2.7.1}/PKG-INFO

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

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

{superqode-2.6.0 → superqode-2.7.1}/scripts/benchmark_tui_responsiveness.py

@@ -30,6 +30,10 @@ PERFORMANCE_BUDGETS_MS = {
     "typing_two_keys_ms": 1500,
     "scroll_with_settle_ms": 750,
     "resize_with_settle_ms": 1500,
+    "folded_paste_ms": 1000,
+    "block_preview_ms": 1500,
+    "folded_draft_typing_ms": 1500,
+    "large_submission_render_ms": 1000,
 }
 
 
@@ -65,6 +69,7 @@ async def probe(size):
         setattr(app, name, lambda *a, **k: None)
     timings = []
     async with app.run_test(size=size) as pilot:
+        app._welcome_active = False
         log = app.query_one("#log", ConversationLog)
         log.replay_history(
             [
@@ -115,6 +120,32 @@ async def probe(size):
         stream_ms = await producer
         await monitor
         assert prompt.value == "hi"
+        # Exercise the new composer against the same long-history fixture.
+        from textual import events
+
+        prompt.focus()
+        pasted = "fixture line\n" * 80000
+        tick = perf_counter()
+        app.post_message(events.Paste(pasted))
+        await pilot.pause()
+        paste_ms = (perf_counter() - tick) * 1000
+        assert len(prompt.value) < 100
+        assert app._expand_composer_blocks(prompt.value) == "hi" + pasted
+        tick = perf_counter()
+        app.action_preview_composer_block()
+        await pilot.pause()
+        preview_ms = (perf_counter() - tick) * 1000
+        app.screen.action_close()
+        await pilot.pause()
+        tick = perf_counter()
+        await pilot.press("!")
+        folded_typing_ms = (perf_counter() - tick) * 1000
+        assert app._expand_composer_blocks(prompt.value) == "hi" + pasted + "!"
+        tick = perf_counter()
+        log.add_user(pasted)
+        await pilot.pause()
+        submission_ms = (perf_counter() - tick) * 1000
+        assert log._messages[-1][1] == pasted
         return {
             "size": list(size),
             "history_messages": 10000,
@@ -128,6 +159,11 @@ async def probe(size):
             "typing_two_keys_ms": round(typing_ms, 2),
             "scroll_with_settle_ms": round(scroll_ms, 2),
             "resize_with_settle_ms": round(resize_ms, 2),
+            "folded_paste_chars": len(pasted),
+            "folded_paste_ms": round(paste_ms, 2),
+            "block_preview_ms": round(preview_ms, 2),
+            "folded_draft_typing_ms": round(folded_typing_ms, 2),
+            "large_submission_render_ms": round(submission_ms, 2),
         }
 
 

{superqode-2.6.0 → superqode-2.7.1}/scripts/check_tui_terminal.py

@@ -168,6 +168,35 @@ def probe(term: str, size: tuple[int, int]):
                 "Escape restores draft and focus",
                 lambda s: s["focused"] == "prompt-input" and s["text"] == "keep this draft",
             )
+            send(b"\x0f")
+            wait_for(
+                "Ctrl+O opens run overview",
+                lambda s: s["screen"] == "RunOverviewScreen" and s["text"] == "keep this draft",
+            )
+            send(b"\x1b")
+            wait_for(
+                "overview Escape restores draft and focus",
+                lambda s: s["screen"] != "RunOverviewScreen"
+                and s["focused"] == "prompt-input"
+                and s["text"] == "keep this draft",
+            )
+            large_paste = "\n".join(f"paste line {n}" for n in range(30))
+            send(b"\x1b[200~" + large_paste.encode() + b"\x1b[201~")
+            state = wait_for(
+                "large paste folds without submitting", lambda s: "[Block " in s["text"]
+            )
+            folded_draft = state["text"]
+            send(b"\x0b")
+            wait_for("palette opens with folded draft", lambda s: s["focused"] != "prompt-input")
+            send(b"\x1b")
+            wait_for(
+                "folded draft survives inspection",
+                lambda s: s["text"] == folded_draft and s["focused"] == "prompt-input",
+            )
+            send(b"\x15")
+            wait_for("clear folded marker", lambda s: s["text"] == "")
+            send(b"keep this draft")
+            wait_for("clear folded draft", lambda s: 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)

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/__init__.py

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

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/agent/loop.py

@@ -958,6 +958,7 @@ class AgentLoop:
         self.pause_on_approval = False
         self._pending_approval: Optional[Dict[str, Any]] = None
         self._approved_tool_call_ids: set[str] = set()
+        self._approval_receipts: dict = {}
 
         # Per-model byte cap for tool output (computed once - same provider/model
         # for the lifetime of the loop). Passed into ToolContext so individual
@@ -1668,9 +1669,16 @@ class AgentLoop:
 
         from ..systemone.runtime import apply_systemone_gate
 
+        from ..tools.approval_receipts import ApprovalReceipt, policy_revision
+
+        receipt = getattr(self, "_approval_receipts", {}).get(tool_call_id or "")
+        invocation_approved = isinstance(receipt, ApprovalReceipt) and receipt.matches(
+            tool_call_id or "", name, arguments
+        )
+
         baseline_allowed = (
             (permission == Permission.ALLOW and not rule_ask)
-            or (tool_call_id and tool_call_id in self._approved_tool_call_ids)
+            or invocation_approved
             or ((verdict.allowed or rule_allow) and not rule_ask)
         )
         baseline = "allow" if baseline_allowed else "ask"
@@ -1682,26 +1690,59 @@ class AgentLoop:
 
         if permission == Permission.ALLOW and not rule_ask and not so_ask:
             return None
-        if tool_call_id and tool_call_id in self._approved_tool_call_ids:
+        if invocation_approved:
             return None
         if (verdict.allowed or rule_allow or so_allow) and not rule_ask and not so_ask:
             return None
 
         if self.pause_on_approval:
+            import uuid
+            from superqode.governance import active_governance, evaluate_active_policy
+            from ..tools.permissions import TOOL_GROUPS
+
+            group = TOOL_GROUPS.get(name)
+            policy = evaluate_active_policy(
+                "tool_call",
+                tool=name,
+                arguments=arguments,
+                tool_group=group.value if group is not None else "",
+                risk=self.permission_manager.get_risk_level(name, arguments),
+            )
+            self._pending_governance = active_governance()
+
             self._pending_approval = {
                 "index": 0,
                 "tool_name": name,
                 "arguments": dict(arguments),
-                "tool_call_id": tool_call_id,
+                "tool_call_id": tool_call_id or uuid.uuid4().hex,
+                "approval_id": uuid.uuid4().hex,
+                "policy_revision": policy_revision(),
+                "reason": policy.reason
+                if policy.enforced
+                else "Human approval required by execution permissions",
+                "risk": self.permission_manager.get_risk_level(name, arguments),
             }
             raise ToolApprovalRequired(name, arguments, tool_call_id)
 
+        consent_revision = policy_revision()
         approved = await self.permission_manager.request_permission(
             name,
             arguments,
             description=f"Agent requested tool `{name}`",
         )
         if approved:
+            from ..tools.approval_receipts import issue_receipt
+
+            if tool_call_id:
+                issue_receipt(
+                    self,
+                    {
+                        "tool_name": name,
+                        "arguments": arguments,
+                        "tool_call_id": tool_call_id,
+                        "policy_revision": consent_revision,
+                    },
+                )
             return None
         return ToolResult(
             success=False,
@@ -1732,12 +1773,33 @@ class AgentLoop:
         from ..acp.tool_call_context import acp_tool_call_context
         from .hooks import AFTER_TOOL_CALL, BEFORE_TOOL_CALL, CONTEXT_RETRIEVAL
 
+        from superqode.governance import active_governance, governance_scope, load_governance
+
+        if active_governance() is None:
+            with governance_scope(
+                load_governance(
+                    self.config.working_directory, harness_spec=self.config.harness_spec
+                )
+            ):
+                return await self._execute_tool(name, arguments, tool_call_id)
+
+        import uuid
+
+        tool_call_id = tool_call_id or uuid.uuid4().hex
+
         lifecycle_ctx = self._lifecycle_context()
+        self._supervision_operation = name
+        self._supervision_last_event = f"Tool requested: {name}"
 
         async def _finalize(result: ToolResult) -> ToolResult:
             import hashlib
             from ..systemone.state import redact_evidence
 
+            self._supervision_operation = ""
+            self._supervision_last_event = (
+                f"Tool {'completed' if result.success else 'failed'}: {name}"
+            )
+
             result.metadata = {
                 **(result.metadata or {}),
                 "invocation_id": tool_call_id,
@@ -1844,20 +1906,17 @@ class AgentLoop:
                     server_id = parts[1]
                     tool_name = parts[2]
                     try:
-                        from superqode.execution_recovery import recoverable_call
-
-                        result = await recoverable_call(
-                            identity=tool_call_id or "",
-                            operation=f"mcp.{server_id}.{tool_name}",
-                            inputs=arguments,
-                            execute=lambda: self.mcp_executor(server_id, tool_name, arguments),
-                            encode=lambda r: {
-                                "success": r.success,
-                                "output": r.output,
-                                "error": r.error,
-                                "metadata": r.metadata,
-                            },
-                            decode=lambda r: ToolResult(**r),
+                        from ..tools.governed import DynamicTool, execute_governed_tool
+
+                        ctx = self._create_tool_context()
+                        ctx.invocation_id = tool_call_id
+                        ctx.approval_receipt = self._approval_receipts.pop(tool_call_id, None)
+                        result = await execute_governed_tool(
+                            DynamicTool(
+                                name, lambda args: self.mcp_executor(server_id, tool_name, args)
+                            ),
+                            arguments,
+                            ctx,
                         )
                         return await _finalize(result)
                     except Exception as e:
@@ -1885,6 +1944,7 @@ class AgentLoop:
 
         ctx = self._create_tool_context()
         ctx.invocation_id = tool_call_id or ""
+        ctx.approval_receipt = self._approval_receipts.pop(tool_call_id, None)
 
         try:
             from ..tools.governed import execute_governed_tool

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/agent/peer_agents.py

@@ -359,42 +359,72 @@ def _pending_approvals(loop: Any) -> List[Dict[str, Any]]:
         return []
     return [
         {
-            "index": 0,
-            "tool_name": pending.get("tool_name"),
+            **pending,
             "arguments": dict(pending.get("arguments") or {}),
-            "tool_call_id": pending.get("tool_call_id"),
         }
     ]
 
 
-async def _approve_loop_pending(loop: Any, index: int = 0, always: bool = False) -> Any:
+async def _approve_loop_pending(
+    loop: Any, index: int = 0, always: bool = False, harness_spec: Any = None
+) -> Any:
+    from superqode.governance import active_governance, governance_scope, load_governance
+
+    if active_governance() is None:
+        spec = harness_spec or getattr(loop.config, "harness_spec", None)
+        bundle = load_governance(loop.config.working_directory, harness_spec=spec)
+        previous = getattr(loop, "_pending_governance", None)
+        if previous is not None:
+            restored_sources = {layer.source for layer in bundle.engine.layers}
+            missing = [
+                layer.name
+                for layer in previous.engine.layers
+                if layer.source not in restored_sources
+            ]
+            if missing:
+                raise RuntimeError(
+                    "Original approval policy scope is unavailable: " + ", ".join(missing)
+                )
+        with governance_scope(bundle):
+            return await _approve_loop_pending_inner(loop, index, always, spec)
+    return await _approve_loop_pending_inner(loop, index, always, harness_spec)
+
+
+async def _approve_loop_pending_inner(loop, index, always, harness_spec):
     if index != 0 or not getattr(loop, "_pending_approval", None):
         raise RuntimeError("No pending approval to approve")
     pending = dict(loop._pending_approval)
     tool_name = str(pending.get("tool_name") or "")
     arguments = dict(pending.get("arguments") or {})
     tool_call_id = pending.get("tool_call_id")
-    if tool_call_id:
-        loop._approved_tool_call_ids.add(str(tool_call_id))
-    if always and getattr(loop.config, "harness_spec", None) is not None:
-        from ..harness.approval_memory import remember_approval_decision
+    from ..tools.approval_receipts import issue_receipt
 
-        remember_approval_decision(
-            loop.config.harness_spec,
-            tool_name=tool_name,
-            arguments=arguments,
-            action="allow",
-        )
+    receipt = issue_receipt(loop, pending)
+    spec = harness_spec or getattr(loop.config, "harness_spec", None)
     loop._pending_approval = None
-    result = await loop._execute_tool(
-        tool_name,
-        arguments,
-        tool_call_id=str(tool_call_id) if tool_call_id else None,
-    )
-    if not always and tool_call_id:
+    from .loop import ToolApprovalRequired, AgentResponse
+
+    try:
+        result = await loop._execute_tool(
+            tool_name, arguments, tool_call_id=str(tool_call_id) if tool_call_id else None
+        )
+    except ToolApprovalRequired:
+        return AgentResponse(
+            content="The request changed. Inspect and approve the current invocation.",
+            messages=[],
+            tool_calls_made=0,
+            iterations=0,
+            stopped_reason="needs_approval",
+        )
+    finally:
+        loop._approval_receipts.pop(receipt.invocation_id, None)
         loop._approved_tool_call_ids.discard(str(tool_call_id))
     if loop.on_tool_result:
         loop.on_tool_result(tool_name, result)
+    if always and spec is not None and result.success:
+        from ..harness.approval_memory import remember_approval_decision
+
+        remember_approval_decision(spec, tool_name=tool_name, arguments=arguments, action="allow")
     from .loop import AgentResponse
 
     return AgentResponse(

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/app/constants.py

@@ -316,6 +316,11 @@ COMMANDS = [
     ":hub setup",
     ":hub custom",
     ":activity",
+    ":blocks",
+    ":output",
+    ":runs",
+    ":approvals",
+    ":delivery",
     ":explore",
     ":explore agents",
     ":explore providers",

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/app/draft_recovery.py

@@ -1,4 +1,4 @@
-"""Bounded, private workspace drafts; attachment payloads are never persisted."""
+"""Bounded, private workspace drafts; image payloads are never persisted."""
 
 from __future__ import annotations
 
@@ -8,7 +8,7 @@ from pathlib import Path
 import tempfile
 from threading import Lock
 
-MAX_DRAFT_BYTES = 1024 * 1024
+MAX_DRAFT_BYTES = 32 * 1024 * 1024
 
 
 class DraftStore:
@@ -39,7 +39,19 @@ class DraftStore:
                 ref in refs and isinstance(path, str) for ref, path in images.items()
             ):
                 return {}
+            blocks = state.get("blocks", {})
+            if not isinstance(blocks, dict) or len(blocks) > 100:
+                return {}
+            for key, block in blocks.items():
+                if not isinstance(key, str) or not isinstance(block, dict):
+                    return {}
+                if not isinstance(block.get("text"), str) or not isinstance(
+                    block.get("label"), str
+                ):
+                    return {}
+                block["lines"] = block["text"].count("\n") + 1
             return {
+                "blocks": blocks,
                 "text": text,
                 "cursor": max(0, min(cursor, len(text))),
                 "refs": list(dict.fromkeys(refs))[:100],

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/app/inputs.py

@@ -207,6 +207,8 @@ class SelectionAwareInput(TextArea):
     def on_text_area_changed(self, event: TextArea.Changed) -> None:
         self._resize_to_content()
         self._sync_working_animation()
+        if getattr(self.app, "_composer_blocks", {}):
+            self.app._refresh_attachment_bar()
         schedule = getattr(self.app, "_schedule_draft_save", None)
         if callable(schedule):
             schedule()

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/app/mixins/agent_run.py

@@ -375,7 +375,9 @@ class AgentRunMixin:
                 cwd=os.getcwd(),
                 timeout=1200 if resume_harness else 60,
             )
-            output = (result.stdout + result.stderr).strip()
+            raw_output = result.stdout + result.stderr
+            self._call_ui(self._remember_shell_output, cmd, raw_output, result.returncode)
+            output = raw_output.strip()
             ok = result.returncode == 0
             self._call_ui(log.add_shell, cmd, output, ok)
 

{superqode-2.6.0 → superqode-2.7.1}/src/superqode/app/mixins/commands_impl.py

@@ -1466,7 +1466,7 @@ class CommandImplMixin:
             return
         self.run_worker(self._superqode_cli_cmd(["skillopt", *tokens], log, "SkillOpt command"))
 
-    def _open_work_inspector(self, args, log):
+    def _open_work_inspector(self, args, log, *, section="overview"):
         from superqode.commands.work import DEFAULT_WORK_STORE
         from superqode.widgets.workorder_inspector import WorkOrderInspector, parse_inspector_args
 
@@ -1491,7 +1491,12 @@ class CommandImplMixin:
 
         self.push_screen(
             WorkOrderInspector(
-                path, reference, on_action=dispatch, worker_running=running, lease_seconds=lease
+                path,
+                reference,
+                on_action=dispatch,
+                worker_running=running,
+                lease_seconds=lease,
+                section=section,
             ),
             callback=lambda _: self._ensure_input_focus(),
         )