superqode 2.4.0__tar.gz → 2.4.2__tar.gz

{superqode-2.4.0 → superqode-2.4.2}/CHANGELOG.md

@@ -5,6 +5,57 @@ All notable changes to SuperQode will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.4.2] - 2026-09-18
+
+### Added
+
+- Selectable SystemOne coding harness with Jev shadow tool gates and deferred
+  tool discovery, alongside the existing standalone decision backend.
+- Opt-in Jev tool-search reranking over a bounded candidate set, explicit
+  abstention, lexical fallback on evaluation errors, and separate sanitized
+  discovery traces. Schema activation does not grant execution permission.
+
+### Usage
+
+- Launch with `superqode --harness systemone` or select `:harness use systemone`
+  in a connected coding session. Live Jev evaluations require `TYPESAFE_API_KEY`.
+- Tool gates and discovery default to shadow mode. Set
+  `SUPERQODE_SYSTEMONE_TOOL_SEARCH=rerank` to let Jev select a deferred schema;
+  uncertain decisions activate nothing and evaluation errors retain lexical search.
+- Set `SUPERQODE_SYSTEMONE_TRACE_DIR` to record discovery evidence under
+  `tool-search/`, separately from permission calibration traces.
+
+### Validation
+
+- SystemOne, tool discovery, harness and TUI regressions: 299 passed, 4 skipped.
+- Live Jev tool-selection accuracy and threshold calibration remain to be evaluated.
+
+## [2.4.1] - 2026-09-18
+
+### Added
+
+- Theme-aware Jev JSON replies with highlighted decisions, key fields, numeric
+  values, and abstentions; System One Models on the welcome screen.
+- A SystemOne model route in `:connect`, with Jev, API-key setup guidance, and
+  direct decision-pack sessions.
+- Opt-in Jev shadow tool checks with `:systemone shadow` or
+  `SUPERQODE_SYSTEMONE_MODE=shadow`. Jev recommendations do not change existing
+  permission decisions in this mode.
+- Sanitized decision traces with full typed answers, probability distributions,
+  confidence, policy and permission outcomes, thresholds, and truncation markers.
+- Distribution diagnostics for near ties and spread, plus `harness decision-report`
+  for policy or explicit human-label comparisons, confidence buckets, and offline
+  confidence threshold sweeps. Reports do not apply thresholds or infer safety
+  from confidence or successful execution.
+
+### Fixed
+
+- Jev decision sessions initialize provider/model and usage identity instead of
+  reporting unknown. The decision-session top bar shows only `SystemOne · Jev`,
+  omitting runtime, harness, BUILD mode, and usage details.
+- Jev JSON replies open at the top of the response card. Final completion output
+  no longer scrolls to the bottom; the next task restores normal scrolling.
+
 ## [2.4.0] - 2026-09-18
 
 ### Jev integration

{superqode-2.4.0 → superqode-2.4.2}/PKG-INFO

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

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

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/__init__.py

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

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/agent/loop.py

@@ -865,7 +865,14 @@ class AgentLoop:
         try:
             from ..tools.tool_search import apply_deferred_tool_policy
 
-            apply_deferred_tool_policy(self.tools, provider=config.provider, model=config.model)
+            apply_deferred_tool_policy(
+                self.tools,
+                provider=config.provider,
+                model=config.model,
+                policy=getattr(
+                    getattr(config.harness_spec, "model_policy", None), "config", {}
+                ).get("deferred_tools", ""),
+            )
         except ImportError:
             pass
 
@@ -1253,6 +1260,8 @@ class AgentLoop:
             peer_manager=self._get_peer_manager(),
             permission_manager=self.permission_manager,
             context_status=self._context_status,
+            systemone=self.config.systemone,
+            systemone_client=self._systemone_client,
             harness_store=self.config.harness_store,
             harness_spec=self.config.harness_spec,
             harness_run_id=self.config.harness_run_id,
@@ -1352,6 +1361,20 @@ class AgentLoop:
 
     async def _check_tool_permission(
         self, name: str, arguments: Dict[str, Any], tool_call_id: Optional[str] = None
+    ) -> Optional[ToolResult]:
+        from ..systemone.audit import finish_trace
+
+        self.last_systemone_decision = None
+        try:
+            result = await self._check_tool_permission_inner(name, arguments, tool_call_id)
+        except ToolApprovalRequired:
+            finish_trace(self, tool_call_id, "ask")
+            raise
+        finish_trace(self, tool_call_id, "allow" if result is None else "deny", result)
+        return result
+
+    async def _check_tool_permission_inner(
+        self, name: str, arguments: Dict[str, Any], tool_call_id: Optional[str] = None
     ) -> Optional[ToolResult]:
         """Apply central permission checks before any local tool executes.
 
@@ -1422,7 +1445,15 @@ class AgentLoop:
 
         from ..systemone.runtime import apply_systemone_gate
 
+        baseline_allowed = (
+            (permission == Permission.ALLOW and not rule_ask)
+            or (tool_call_id and tool_call_id in self._approved_tool_call_ids)
+            or ((verdict.allowed or rule_allow) and not rule_ask)
+        )
+        baseline = "allow" if baseline_allowed else "ask"
         so_denied, so_allow, so_ask = await apply_systemone_gate(self, name, arguments)
+        if self.last_systemone_decision is not None:
+            self.last_systemone_decision["policyAction"] = baseline
         if so_denied is not None:
             return so_denied
 

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/constants.py

@@ -325,6 +325,7 @@ COMMANDS = [
     ":evals",
     ":systemone",
     ":systemone live",
+    ":systemone shadow",
     ":systemone off",
     ":systemone packs",
     ":systemone connect",

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/mixins/connect.py

@@ -1509,7 +1509,32 @@ class ConnectMixin:
             if conn == "acp":
                 log.add_info(f"{profile.label} needs setup: {profile.unavailable_hint}")
                 return
-        if conn == "copilot":
+        if conn == "systemone-picker":
+            from superqode.providers.connection_profiles import CONNECT_MENU_SYSTEMONE
+
+            self._show_connect_type_picker(log, menu=CONNECT_MENU_SYSTEMONE)
+        elif conn == "systemone":
+            import os
+
+            if not os.environ.get("TYPESAFE_API_KEY", "").strip():
+                log.add_info(
+                    "Jev needs a TypeSafe AI API key. Get one at https://console.typesafe.ai "
+                    "(request access at https://typesafe.ai if needed). In your terminal, run "
+                    "export TYPESAFE_API_KEY='your-key', restart SuperQode, then choose "
+                    ":connect → Connect with SystemOne models → Jev."
+                )
+                return
+            pure = self._ensure_pure_mode()
+            try:
+                pure.connect_decision("factory_route")
+            except (ValueError, OSError) as exc:
+                log.add_error(str(exc))
+                return
+            self._activate_decision_connection(pure, log)
+            log.add_info(
+                "Use :systemone packs to explore packs, then :systemone connect <pack> to switch."
+            )
+        elif conn == "copilot":
             self._connect_copilot_subscription(profile, log)
         elif conn == "prime-rpc":
             self._connect_prime_rpc("", log)

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/mixins/dialogs.py

@@ -2337,8 +2337,13 @@ class DialogsMixin:
         # Keep the view pinned to the latest response. We no longer clear the
         # log each turn, so scrolling home would jump away from the answer the
         # user just asked for — scroll to the end and resume follow mode.
-        log.auto_scroll = True
-        self.set_timer(0.1, lambda: log.scroll_end(animate=False))
+        from superqode.rendering.systemone import render_systemone_json
+
+        if render_systemone_json(response_text, THEME) is not None:
+            log.reveal_decision_response()
+        else:
+            log.auto_scroll = True
+            self.set_timer(0.1, lambda: log.scroll_end(animate=False))
 
     #: Suggested commands, in the order they become useful. Only unused ones
     #: are offered.

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/mixins/helpers.py

@@ -155,7 +155,10 @@ class HelpersMixin(
             if not harness and pure is not None:
                 runtime_name = str(getattr(pure, "runtime_name", "") or "")
                 connected = bool(getattr(getattr(pure, "session", None), "connected", False))
-                if connected and runtime_name in getattr(
+                spec = getattr(pure, "_harness_spec", None)
+                if connected and getattr(spec, "is_decision", False):
+                    harness = str(spec.name)
+                elif connected and runtime_name in getattr(
                     self, "_SELF_CONTAINED_RUNTIMES", frozenset()
                 ):
                     # These runtimes own the agent loop and tool harness. The

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/mixins/slash_commands.py

@@ -91,8 +91,8 @@ class SlashCommandMixin:
                 return
             self._activate_decision_connection(pure, log)
             return
-        if action not in {"", "status", "live", "on", "off", "0"}:
-            log.add_error("Use :systemone [status|live|off|packs|connect <pack>]")
+        if action not in {"", "status", "live", "shadow", "on", "off", "0"}:
+            log.add_error("Use :systemone [status|live|shadow|off|packs|connect <pack>]")
             return
         spec = None
         pure = (
@@ -102,15 +102,16 @@ class SlashCommandMixin:
             spec = getattr(pure, "_harness_spec", None)
         key_env = getattr(getattr(spec, "systemone", None), "api_key_env", LIVE_API_KEY_ENV)
         key_set = bool(os.environ.get(key_env, "").strip()) if key_env else True
-        if action in {"live", "on"}:
+        if action in {"live", "shadow", "on"}:
             if not key_set:
                 log.add_error(
                     f"Set {key_env} in this shell, then restart the TUI, then :systemone live"
                 )
                 return
             os.environ[SYSTEMONE_ENV] = "live"
+            os.environ["SUPERQODE_SYSTEMONE_MODE"] = "shadow" if action == "shadow" else "enforce"
             log.add_system(
-                "System One live enabled for the native runtime. Tool checks will report request outcomes."
+                f"System One {os.environ['SUPERQODE_SYSTEMONE_MODE']} enabled for the native runtime."
             )
         elif action in {"off", "0"}:
             os.environ[SYSTEMONE_ENV] = "0"
@@ -146,6 +147,7 @@ class SlashCommandMixin:
             )
             t.append("  Simple chat without tools does not call Jev.\n\n", style=THEME["muted"])
         t.append(f"    enabled     {settings.enabled}\n", style=THEME["muted"])
+        t.append(f"    mode        {settings.mode}\n", style=THEME["muted"])
         t.append(f"    client      {settings.client}\n", style=THEME["muted"])
         t.append(f"    model       {settings.model}\n", style=THEME["muted"])
         t.append(f"    pack        {settings.pack}\n", style=THEME["muted"])
@@ -165,6 +167,24 @@ class SlashCommandMixin:
         self.current_agent = "pure"
         self.current_provider = "systemone"
         self.current_model = pure.session.model
+        from superqode.providers.usage import get_usage_tracker
+
+        tracker = get_usage_tracker()
+        tracker.set_provider("systemone", pure.session.model)
+        try:
+            from superqode.app.widgets import ColorfulStatusBar
+
+            status = self.query_one("#status-bar", ColorfulStatusBar)
+            summary = tracker.get_summary()
+            status.update_byok_status(
+                provider="systemone",
+                model=pure.session.model,
+                tokens=summary["tokens"],
+                cost=summary["cost"],
+            )
+            status.active_harness = pure._harness_spec.name
+        except Exception:  # noqa: BLE001 - status updates must not break connect
+            pass
         self._install_pure_permission_bridge(pure, log)
         self._set_status_runtime("systemone")
         self._set_status_model(pure.session.model)

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/welcome.py

@@ -230,7 +230,7 @@ def render_welcome(
     desc_text.append("Terminal-first · Any agent or model\n", style=f"bold {THEME['purple']}")
     if not narrow:
         desc_text.append("\n", style="")
-    interoperability = "Local · ACP · MCP · A2A · UHP · BYOK"
+    interoperability = "Local · ACP · MCP · A2A · UHP · BYOK · System One Models"
     if narrow:
         desc_text.append(interoperability, style=THEME["muted"])
     else:

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/app/widgets.py

@@ -227,7 +227,13 @@ class ColorfulStatusBar(Static):
         provider_limit = 24 if medium else 12 if width >= 64 else 8
         conn_start = cell_len(result.plain)
         conn_action = ""
-        if self.byok_provider:
+        decision_session = self.active_runtime == "systemone"
+        if decision_session:
+            conn_action = "disconnect"
+            result.append("SystemOne", style="bold #06b6d4")
+            result.append(" · ", style="#71717a")
+            result.append("Jev", style="bold #a855f7")
+        elif self.byok_provider:
             separator()
             conn_start = cell_len(result.plain)
             conn_action = "disconnect"
@@ -266,113 +272,118 @@ class ColorfulStatusBar(Static):
             result.append("Model: not connected", style="#a1a1aa")
         conn_end = cell_len(result.plain)
 
-        # A specialized runtime is useful when a model is also named. The
-        # default built-in runtime is intentionally omitted as visual noise.
-        runtime = (self.active_runtime or "").strip()
-        if runtime and self.active_model:
-            separator()
-            result.append("rt ", style="#71717a")
-            runtime_limit = 20 if medium else 7
-            result.append(self._truncate_status_value(runtime, runtime_limit), style="#06b6d4")
-
-        harness = (self.active_harness or "").strip()
-        if harness:
-            separator()
-            result.append("harness " if wide else "h ", style="#71717a")
-            harness_limit = 18 if wide else 10 if medium else 6
-            result.append(
-                self._truncate_status_value(harness, harness_limit),
-                style="bold #a855f7",
-            )
+        if not decision_session:
+            # A specialized runtime is useful when a model is also named. The
+            # default built-in runtime is intentionally omitted as visual noise.
+            runtime = (self.active_runtime or "").strip()
+            if runtime and self.active_model:
+                separator()
+                result.append("rt ", style="#71717a")
+                runtime_limit = 20 if medium else 7
+                result.append(self._truncate_status_value(runtime, runtime_limit), style="#06b6d4")
+
+            harness = (self.active_harness or "").strip()
+            if harness:
+                separator()
+                result.append("harness " if wide else "h ", style="#71717a")
+                harness_limit = 18 if wide else 10 if medium else 6
+                result.append(
+                    self._truncate_status_value(harness, harness_limit),
+                    style="bold #a855f7",
+                )
 
-        # Interaction mode is always visible, on the right cluster.
-        mode = (self.interaction_mode or "").strip().lower()
-        if mode:
-            mode_label = {"chat": "CHAT", "plan": "PLAN", "build": "BUILD"}.get(mode, mode.upper())
-            mode_color = {
-                "chat": "#06b6d4",
-                "plan": "#fbbf24",
-                "build": "#22c55e",
-            }.get(mode, "#a855f7")
-            right.append(mode_label, style=f"bold {mode_color}")
-
-        # Keep the interaction mode and the optional input mode distinct.
-        vim_state = (self.vim_state or "").strip().lower()
-        if vim_state:
-            vim_label = {
-                "normal": "NORMAL",
-                "insert": "INSERT",
-                "command": "COMMAND",
-                "search": "SEARCH",
-            }.get(vim_state, vim_state.upper())
-            vim_color = {
-                "normal": "#a855f7",
-                "insert": "#06b6d4",
-                "command": "#fbbf24",
-                "search": "#ec4899",
-            }.get(vim_state, "#a855f7")
-            if right.plain:
-                right_separator()
-            if medium:
-                right.append("VIM ", style="#a1a1aa")
-                right.append(vim_label, style=f"bold {vim_color}")
-            else:
-                right.append(vim_label[:1], style=f"bold {vim_color}")
-
-        # Usage remains visible whenever known. Figures compact on narrower
-        # terminals, while connection/runtime/mode retain priority.
-        context_used = self.context_used or self.byok_tokens
-        if medium and self.context_window > 0 and context_used > 0:
-            pct = min(100, round(100 * context_used / self.context_window))
-            if pct < 60:
-                context_color = "#22c55e"
-            elif pct < 85:
-                context_color = "#fbbf24"
-            else:
-                context_color = "#ef4444"
-            if right.plain:
-                right_separator()
-            right.append("ctx ", style="#a1a1aa")
-            right.append(f"{pct}%", style=context_color)
-            if wide:
-                right.append(
-                    f" · {self._format_token_count(context_used)}/"
-                    f"{self._format_token_count(self.context_window)}",
-                    style="#a1a1aa",
+            # Interaction mode is always visible, on the right cluster.
+            mode = (self.interaction_mode or "").strip().lower()
+            if mode:
+                mode_label = {"chat": "CHAT", "plan": "PLAN", "build": "BUILD"}.get(
+                    mode, mode.upper()
+                )
+                mode_color = {
+                    "chat": "#06b6d4",
+                    "plan": "#fbbf24",
+                    "build": "#22c55e",
+                }.get(mode, "#a855f7")
+                right.append(mode_label, style=f"bold {mode_color}")
+
+            # Keep the interaction mode and the optional input mode distinct.
+            vim_state = (self.vim_state or "").strip().lower()
+            if vim_state:
+                vim_label = {
+                    "normal": "NORMAL",
+                    "insert": "INSERT",
+                    "command": "COMMAND",
+                    "search": "SEARCH",
+                }.get(vim_state, vim_state.upper())
+                vim_color = {
+                    "normal": "#a855f7",
+                    "insert": "#06b6d4",
+                    "command": "#fbbf24",
+                    "search": "#ec4899",
+                }.get(vim_state, "#a855f7")
+                if right.plain:
+                    right_separator()
+                if medium:
+                    right.append("VIM ", style="#a1a1aa")
+                    right.append(vim_label, style=f"bold {vim_color}")
+                else:
+                    right.append(vim_label[:1], style=f"bold {vim_color}")
+
+            # Usage remains visible whenever known. Figures compact on narrower
+            # terminals, while connection/runtime/mode retain priority.
+            context_used = self.context_used or self.byok_tokens
+            if medium and self.context_window > 0 and context_used > 0:
+                pct = min(100, round(100 * context_used / self.context_window))
+                if pct < 60:
+                    context_color = "#22c55e"
+                elif pct < 85:
+                    context_color = "#fbbf24"
+                else:
+                    context_color = "#ef4444"
+                if right.plain:
+                    right_separator()
+                right.append("ctx ", style="#a1a1aa")
+                right.append(f"{pct}%", style=context_color)
+                if wide:
+                    right.append(
+                        f" · {self._format_token_count(context_used)}/"
+                        f"{self._format_token_count(self.context_window)}",
+                        style="#a1a1aa",
+                    )
+            elif medium and self.byok_tokens > 0:
+                if right.plain:
+                    right_separator()
+                right.append(self._format_token_count(self.byok_tokens), style="#06b6d4")
+                right.append(" tok", style="#71717a")
+
+            # Launch fires the models.dev and ACP registry refreshes behind the
+            # first frame. Saying so costs one chip and turns a quiet couple of
+            # seconds into visible progress.
+            if self.catalog_state and medium:
+                if right.plain:
+                    right_separator()
+                right.append("⟳ ", style="#06b6d4")
+                right.append(self.catalog_state.strip(), style="#a1a1aa")
+
+            if self.plan_state:
+                state = self.plan_state.strip()
+                color = {
+                    "ON": "#fbbf24",
+                    "pending": "#f59e0b",
+                    "active": "#06b6d4",
+                    "approved": "#22c55e",
+                }.get(state, "#a855f7")
+                if right.plain:
+                    right_separator()
+                right.append("PLAN", style=f"bold {color}")
+                right.append(f" {state}", style=color)
+
+            if self.byok_cost > 0 and medium:
+                if right.plain:
+                    right_separator()
+                cost = (
+                    f"${self.byok_cost:.2f}" if self.byok_cost >= 0.01 else f"${self.byok_cost:.3f}"
                 )
-        elif medium and self.byok_tokens > 0:
-            if right.plain:
-                right_separator()
-            right.append(self._format_token_count(self.byok_tokens), style="#06b6d4")
-            right.append(" tok", style="#71717a")
-
-        # Launch fires the models.dev and ACP registry refreshes behind the
-        # first frame. Saying so costs one chip and turns a quiet couple of
-        # seconds into visible progress.
-        if self.catalog_state and medium:
-            if right.plain:
-                right_separator()
-            right.append("⟳ ", style="#06b6d4")
-            right.append(self.catalog_state.strip(), style="#a1a1aa")
-
-        if self.plan_state:
-            state = self.plan_state.strip()
-            color = {
-                "ON": "#fbbf24",
-                "pending": "#f59e0b",
-                "active": "#06b6d4",
-                "approved": "#22c55e",
-            }.get(state, "#a855f7")
-            if right.plain:
-                right_separator()
-            right.append("PLAN", style=f"bold {color}")
-            right.append(f" {state}", style=color)
-
-        if self.byok_cost > 0 and medium:
-            if right.plain:
-                right_separator()
-            cost = f"${self.byok_cost:.2f}" if self.byok_cost >= 0.01 else f"${self.byok_cost:.3f}"
-            right.append(cost, style="#fbbf24")
+                right.append(cost, style="#fbbf24")
 
         # The way out of a session sits at the far right, where a window
         # control would be: one fixed place, present at every width, and
@@ -1908,7 +1919,12 @@ class ConversationLog(RichLog):
         width-safe: Rich reflows code panels and tables within the remaining
         width. Shared by the streaming and final-commit paths so both match.
         """
-        return Padding(render_agent_markdown(block), (0, 0, 0, 2))
+        from superqode.rendering.systemone import render_systemone_json
+
+        decision = render_systemone_json(block, THEME)
+        return Padding(
+            decision if decision is not None else render_agent_markdown(block), (0, 0, 0, 2)
+        )
 
     def add_thinking(self, text: str, category: str = "general"):
         """
@@ -2726,6 +2742,13 @@ class ConversationLog(RichLog):
         # Store and render the final response once. Streaming chunks are kept
         # out of the log so markdown tables/code render cleanly here.
         final_response = response_text or self._streaming_response
+        from superqode.rendering.systemone import render_systemone_json
+
+        decision_response = success and render_systemone_json(final_response, THEME) is not None
+        response_start_y = len(self.lines)
+        if decision_response:
+            self.auto_scroll = False
+            self._writing_feedback = True
         if final_response:
             self._streaming_response = final_response
             self.write_final_response(
@@ -2774,6 +2797,28 @@ class ConversationLog(RichLog):
 
         summary_content.append("\n")
         self.write(summary_content)
+        if decision_response:
+            self._writing_feedback = False
+            self.reveal_decision_response(response_start_y)
+
+    def reveal_decision_response(self, fallback_y: int = 0) -> None:
+        """Reveal the latest Jev card after completion chrome has been written."""
+        self.auto_scroll = False
+        self._feedback_anchor_active = True
+
+        def reveal() -> None:
+            if not self._feedback_anchor_active:
+                return
+            anchor_y = fallback_y
+            for index in range(len(self.lines) - 1, -1, -1):
+                if "Jev · System One decision" in self.lines[index].text:
+                    anchor_y = index
+                    break
+            self.scroll_to(y=anchor_y, animate=False)
+
+        reveal()
+        self.call_after_refresh(reveal)
+        self.set_timer(0.1, reveal)
 
     def get_thinking_text(self) -> str:
         """Get all thinking text for copying."""

{superqode-2.4.0 → superqode-2.4.2}/src/superqode/commands/harness/__init__.py

@@ -115,3 +115,5 @@ from .replay import (
     harness_fork,
     harness_graph,
 )
+
+from .systemone import harness_decision_report

superqode-2.4.2/src/superqode/commands/harness/systemone.py

@@ -0,0 +1,37 @@
+"""Inspect Jev shadow evidence without live model calls."""
+
+import json
+from pathlib import Path
+
+import click
+
+from ._group import harness
+
+
+@harness.command("decision-report")
+@click.argument("trace_dir", type=click.Path(exists=True, file_okay=False, path_type=Path))
+@click.option(
+    "--reference", type=click.Choice(["policyAction", "humanAction"]), default="policyAction"
+)
+@click.option(
+    "--allow-confidence",
+    multiple=True,
+    type=click.FloatRange(0, 1),
+    help="Recompose recorded answers at this confidence threshold; repeat to compare.",
+)
+def harness_decision_report(
+    trace_dir: Path, reference: str, allow_confidence: tuple[float, ...]
+) -> None:
+    """Compare intended decisions with policy or explicit human labels (JSON)."""
+    from superqode.systemone.audit import confidence_sweep, disagreement_report
+
+    try:
+        events = [json.loads(path.read_text()) for path in sorted(trace_dir.glob("*.json"))]
+        if any(not isinstance(event, dict) for event in events):
+            raise ValueError("trace must be a JSON object")
+        report = disagreement_report(events, reference)
+        if allow_confidence:
+            report["confidence_sweep"] = confidence_sweep(events, allow_confidence, reference)
+        click.echo(json.dumps(report, indent=2))
+    except (OSError, ValueError, TypeError, AttributeError) as exc:
+        raise click.ClickException(f"Invalid decision traces: {exc}") from exc