superqode 2.4.2__tar.gz → 2.4.4__tar.gz

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

@@ -5,6 +5,44 @@ 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.4] - 2026-09-19
+
+### Progressive tool discovery
+
+- 🔍 Catalogue → search → rank → Jev → activate → permission → execute, without loading every tool schema into context.
+- 🚀 SystemOne ships unified BM25 retrieval, an eight-candidate shortlist, Jev shadow judging, and deferred MCP tools by default.
+- 🛡️ Search never grants permission and never executes. Activation only reveals the chosen schema for the next model step.
+- 🧩 Bring your own retrieval backend while SuperQode owns lifecycle, activation, permissions, and traces.
+- 💻 Inspect the live path in the TUI with `:systemone`, `:systemone discovery`, or the `:discovery` alias.
+
+### Usage
+
+- Launch SystemOne with progressive discovery already enabled:
+
+  ```sh
+  superqode --tui --harness systemone
+  ```
+
+- Or pick SystemOne from `:connect` → Connect a harness with your model.
+- Live Jev evaluations still require `TYPESAFE_API_KEY` before launching the TUI.
+
+## [2.4.3] - 2026-09-18
+
+### Fixed
+
+- SystemOne now appears after Workbench in the `:connect` harness picker.
+  Selecting it activates the SystemOne coding harness before model selection.
+- Agent Card publication checks confirm failed HEAD requests with GET and
+  tolerate temporary host errors while preserving failures for confirmed missing
+  images and card mismatches.
+
+### Usage
+
+- In the TUI, open `:connect`, choose "Connect a harness with your model",
+  then select "SystemOne" and connect your coding model.
+- Direct selection remains available with `:harness use systemone`.
+  Live Jev evaluations require `TYPESAFE_API_KEY` before launching the TUI.
+
 ## [2.4.2] - 2026-09-18
 
 ### Added

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

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

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

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

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

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

@@ -864,7 +864,9 @@ class AgentLoop:
         # so heavy schemas stay out of the prompt until tool_search loads them.
         try:
             from ..tools.tool_search import apply_deferred_tool_policy
+            from ..tools.discovery import resolve_discovery_settings
 
+            self._discovery_settings = resolve_discovery_settings(config.harness_spec)
             apply_deferred_tool_policy(
                 self.tools,
                 provider=config.provider,
@@ -873,8 +875,30 @@ class AgentLoop:
                     getattr(config.harness_spec, "model_policy", None), "config", {}
                 ).get("deferred_tools", ""),
             )
+            if self._discovery_settings.enabled and self._discovery_settings.mode == "unified":
+                apply_deferred_tool_policy(
+                    self.tools,
+                    provider=config.provider,
+                    model=config.model,
+                    policy="all",
+                )
+                from ..tools.tool_search import ToolSearchTool
+
+                if self.tools.get("tool_search") is None:
+                    self.tools.register(ToolSearchTool())
+                if self._discovery_settings.mcp_mode == "deferred_tools":
+                    self.tools.defer("mcp_search", "mcp_execute")
+                elif self._discovery_settings.mcp_mode == "disabled":
+                    self.tools.defer(
+                        "mcp_search",
+                        "mcp_execute",
+                        "mcp_list_resources",
+                        "mcp_read_resource",
+                        "mcp_list_prompts",
+                        "mcp_get_prompt",
+                    )
         except ImportError:
-            pass
+            self._discovery_settings = None
 
         # PERFORMANCE: Cache tool definitions, recomputed when the registry
         # version changes (deferred-tool activation).
@@ -931,6 +955,9 @@ class AgentLoop:
 
         # Aggregate diff of the most recent turn's file changes.
         self.last_turn_diff: str = ""
+        # Latest sanitized progressive-discovery event for the TUI. This is
+        # intentionally in-memory and never contains tool arguments or output.
+        self.last_discovery_event: Dict[str, Any] = {}
 
         # Peer agents (spawn_agent/...). Lazily created; None inside
         # sub/peer agents so the hierarchy stays one level deep.
@@ -1165,7 +1192,13 @@ class AgentLoop:
             )
 
         # Inject MCP search/execute tools if requested
-        if self.include_mcp:
+        discovery_owns_mcp = bool(
+            getattr(self, "_discovery_settings", None)
+            and self._discovery_settings.enabled
+            and self._discovery_settings.mode == "unified"
+            and self._discovery_settings.mcp_mode in {"deferred_tools", "disabled"}
+        )
+        if self.include_mcp and not discovery_owns_mcp:
             try:
                 from ..tools.mcp_tools import get_mcp_tools
 
@@ -1184,15 +1217,21 @@ class AgentLoop:
                 pass
 
         # Add explicitly passed MCP tools if available
-        definitions.extend(self._mcp_tools)
+        if not discovery_owns_mcp:
+            definitions.extend(self._mcp_tools)
 
         # Hide tools the resolved model profile excludes.
         profile = resolve_model_profile(self.config.provider, self.config.model)
         if profile.excluded_tools:
             definitions = [d for d in definitions if d.name not in profile.excluded_tools]
 
-        definitions.sort(key=lambda d: d.name)
-        return definitions
+        # Keep the initial prefix deterministic, then append newly activated
+        # schemas so progressive discovery preserves provider cache prefixes.
+        previous_names = [definition.name for definition in getattr(self, "_cached_tool_defs", ())]
+        by_name = {definition.name: definition for definition in definitions}
+        ordered_names = [name for name in previous_names if name in by_name]
+        ordered_names.extend(sorted(name for name in by_name if name not in ordered_names))
+        return [by_name[name] for name in ordered_names]
 
     def _get_tool_definitions(self) -> List[ToolDefinition]:
         """Get tool definitions, recomputing when the registry changed.
@@ -1271,8 +1310,14 @@ class AgentLoop:
             harness_model=self.config.model,
             harness_sandbox_backend=self.config.harness_sandbox_backend,
             delegation_depth=self.config.harness_delegation_depth,
+            mcp_allowed=self.config.loop_policy.mcp,
+            on_discovery=self._record_discovery_event,
         )
 
+    def _record_discovery_event(self, event: Dict[str, Any]) -> None:
+        """Expose the latest sanitized discovery lifecycle to local UX."""
+        self.last_discovery_event = dict(event)
+
     def _context_status(self) -> Dict[str, Any]:
         """Live context-budget snapshot for the get_context_remaining tool."""
         window = self._effective_context_window()
@@ -1512,6 +1557,29 @@ class AgentLoop:
         lifecycle_ctx = self._lifecycle_context()
 
         async def _finalize(result: ToolResult) -> ToolResult:
+            origin = (
+                self.tools.activation_origin(name)
+                if hasattr(self.tools, "activation_origin")
+                else {}
+            )
+            if origin:
+                result.metadata = {
+                    **(result.metadata or {}),
+                    "activatedByDiscovery": origin,
+                }
+                current = self.last_discovery_event
+                if current.get("discoveryId") == origin.get("discoveryId"):
+                    executions = list(current.get("executions") or [])
+                    executions.append(
+                        {
+                            "tool": name,
+                            "status": "success" if result.success else "error",
+                            "permission": str(
+                                (result.metadata or {}).get("permission") or "allowed"
+                            ),
+                        }
+                    )
+                    self.last_discovery_event = {**current, "executions": executions[-10:]}
             result = self._bound_tool_result(name, result)
             await self.hooks.fire(AFTER_TOOL_CALL, lifecycle_ctx, name, arguments, result)
             return result

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

@@ -329,6 +329,9 @@ COMMANDS = [
     ":systemone off",
     ":systemone packs",
     ":systemone connect",
+    ":systemone discovery",
+    ":discovery",
+    ":discovery status",
     ":connect systemone",
     ":tour",
     ":tour next",

{superqode-2.4.2 → superqode-2.4.4}/src/superqode/app/mixins/model_catalog.py

@@ -23,6 +23,7 @@ from superqode.design_system import (
 )
 from superqode.providers.models import (
     LATEST_GOOGLE_FLASH_3_6_MODEL,
+    LATEST_GOOGLE_FLASH_3_7_MODEL,
     LATEST_GOOGLE_FLASH_MODEL,
     LATEST_GOOGLE_PRO_MODEL,
 )
@@ -140,9 +141,16 @@ class ModelCatalogMixin:
         return [
             {
                 "id": LATEST_GOOGLE_FLASH_MODEL,
+                "name": "Gemini 3.8 Flash",
+                "context": 1000000,
+                "desc": "Latest stable Gemini 3.8 Flash - 1M context",
+                "recommended": True,
+            },
+            {
+                "id": LATEST_GOOGLE_FLASH_3_7_MODEL,
                 "name": "Gemini 3.7 Flash",
                 "context": 1000000,
-                "desc": "Latest stable Gemini 3.7 Flash from models.dev - 1M context",
+                "desc": "Gemini 3.7 Flash - 1M context",
                 "recommended": True,
             },
             {
@@ -1536,11 +1544,13 @@ class ModelCatalogMixin:
                     "gpt-5.3-codex",
                     "gpt-5.2",
                     "gpt-5.1",
+                    "gemini-3.8-flash",
                     "gemini-3.7-flash",
                     "gemini-3.6-flash",
                     "gemini-3.5-flash-lite",
                     "gemini-3.5-flash",
                     "gemini-3.1-pro",
+                    "gemini 3.8",
                     "gemini 3.7",
                     "gemini 3.5",
                     "gemini 3.1",
@@ -2054,11 +2064,13 @@ class ModelCatalogMixin:
                 "5.3",
                 "gpt-5.2",
                 "5.2",
+                "gemini-3.8-flash",
                 "gemini-3.7-flash",
                 "gemini-3.6-flash",
                 "gemini-3.5-flash-lite",
                 "gemini-3.5-flash",
                 "gemini-3.1-pro",
+                "gemini 3.8",
                 "gemini 3.7",
                 "gemini 3.5",
                 "gemini 3.1",

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

@@ -63,6 +63,9 @@ class SlashCommandMixin:
             log.add_error("Invalid quoting. Use :systemone connect <pack>.")
             return
         action = words[0].lower() if words else ""
+        if action == "discovery" and len(words) == 1:
+            self._discovery_cmd("", log)
+            return
         if action == "packs":
             from superqode.systemone.pack import builtin_pack_ids, load_pack
 
@@ -92,7 +95,7 @@ class SlashCommandMixin:
             self._activate_decision_connection(pure, log)
             return
         if action not in {"", "status", "live", "shadow", "on", "off", "0"}:
-            log.add_error("Use :systemone [status|live|shadow|off|packs|connect <pack>]")
+            log.add_error("Use :systemone [status|discovery|live|shadow|off|packs|connect <pack>]")
             return
         spec = None
         pure = (
@@ -153,12 +156,144 @@ class SlashCommandMixin:
         t.append(f"    pack        {settings.pack}\n", style=THEME["muted"])
         t.append(f"    skip        {settings.skip_reason or 'no'}\n", style=THEME["muted"])
         t.append(f"    api key     {'set' if key_set else 'missing'}\n", style=THEME["muted"])
+        from superqode.tools.discovery import resolve_discovery_settings
+
+        discovery = resolve_discovery_settings(spec)
+        latest_discovery = dict(
+            getattr(getattr(pure, "_agent", None), "last_discovery_event", None) or {}
+        )
+        t.append("\n  Tool discovery\n", style=f"bold {THEME['purple']}")
+        t.append(
+            f"    {discovery.mode} · {discovery.search_backend} → "
+            f"{discovery.rank_backend} · Jev {discovery.judge_mode} · MCP {discovery.mcp_mode}\n",
+            style=THEME["muted"],
+        )
+        if latest_discovery:
+            decision = latest_discovery.get("judge") or {}
+            t.append(
+                f"    latest      {latest_discovery.get('query') or '—'}\n"
+                f"    outcome     {decision.get('reason') or 'retrieved'} · "
+                f"activated {len(latest_discovery.get('activated') or [])} · "
+                f"executed {len(latest_discovery.get('executions') or [])}\n",
+                style=THEME["muted"],
+            )
+        else:
+            t.append("    latest      no discovery event yet\n", style=THEME["dim"])
         t.append(
             "\n  :systemone live   turn the sidecar on (needs the API key)\n", style=THEME["dim"]
         )
         t.append("  :systemone off    force the sidecar off\n", style=THEME["dim"])
         t.append("  :systemone connect <pack>   evaluate directly with Jev\n", style=THEME["dim"])
         t.append("  :systemone packs           list decision packs\n", style=THEME["dim"])
+        t.append("  :systemone discovery       inspect ranked tool discovery\n", style=THEME["dim"])
+        self._show_command_output(log, t)
+
+    def _discovery_cmd(self, args: str, log: ConversationLog) -> None:
+        """Show the active discovery pipeline and its latest lifecycle event."""
+        if args.strip().lower() not in {"", "status"}:
+            log.add_error("Use :discovery [status]")
+            return
+
+        from superqode.tools.discovery import resolve_discovery_settings
+
+        pure = getattr(self, "_pure_mode", None)
+        spec = getattr(pure, "_harness_spec", None) if pure is not None else None
+        try:
+            settings = resolve_discovery_settings(spec)
+        except ValueError as exc:
+            log.add_error(f"Invalid tool discovery configuration: {exc}")
+            return
+        agent = getattr(pure, "_agent", None)
+        event = dict(getattr(agent, "last_discovery_event", None) or {})
+
+        t = Text()
+        t.append("\n  Progressive tool discovery\n\n", style=f"bold {THEME['purple']}")
+        if pure is not None and getattr(pure, "runtime_name", "builtin") != "builtin":
+            t.append(
+                "  Live discovery inspection requires the native Core/BYOK runtime.\n\n",
+                style=THEME["warning"],
+            )
+        t.append(f"    enabled       {settings.enabled}\n", style=THEME["muted"])
+        t.append(f"    mode          {settings.mode}\n", style=THEME["muted"])
+        t.append(f"    search        {settings.search_backend}\n", style=THEME["muted"])
+        t.append(f"    rank          {settings.rank_backend}\n", style=THEME["muted"])
+        judge = (
+            f"{settings.judge_backend} ({settings.judge_mode})"
+            if settings.judge_backend != "none"
+            else "off"
+        )
+        t.append(f"    Jev           {judge}\n", style=THEME["muted"])
+        t.append(f"    MCP           {settings.mcp_mode}\n", style=THEME["muted"])
+
+        if not event:
+            t.append(
+                "\n  No discovery event in this session yet. Ask the agent for a capability "
+                "that is not currently loaded, then run :discovery again.\n",
+                style=THEME["dim"],
+            )
+            self._show_command_output(log, t)
+            return
+
+        retrieval = event.get("retriever") or {}
+        t.append("\n  Latest query\n", style=f"bold {THEME['purple']}")
+        t.append(f"    {event.get('query') or '—'}\n", style=THEME["muted"])
+        t.append(
+            f"    backend       {retrieval.get('backend') or '—'}"
+            f" → {retrieval.get('ranker') or '—'}\n",
+            style=THEME["muted"],
+        )
+
+        candidates = list(event.get("candidates") or [])
+        selected = str((event.get("judge") or {}).get("selectedTool") or "")
+        activated = {str(name) for name in event.get("activated") or []}
+        t.append("\n  Ranked candidates\n", style=f"bold {THEME['purple']}")
+        if not candidates:
+            t.append("    no candidates\n", style=THEME["warning"])
+        for index, candidate in enumerate(candidates, start=1):
+            name = str(candidate.get("name") or candidate.get("id") or "unknown")
+            marker = "◆" if name == selected else ("✓" if name in activated else "·")
+            source = str(candidate.get("source") or "native")
+            score = float(candidate.get("score") or 0.0)
+            style = THEME["success"] if name in activated else THEME["muted"]
+            t.append(f"    {marker} {index:>2}  {name}", style=style)
+            t.append(f"  [{source}]  {score:.3f}\n", style=THEME["dim"])
+
+        decision = event.get("judge") or {}
+        t.append("\n  Jev selection\n", style=f"bold {THEME['purple']}")
+        if not decision:
+            t.append("    off — retrieval order used\n", style=THEME["muted"])
+        else:
+            t.append(
+                f"    {decision.get('status') or 'unknown'} · "
+                f"{decision.get('reason') or '—'} · selected {selected or 'none'}",
+                style=THEME["muted"],
+            )
+            confidence = decision.get("confidence")
+            if confidence is not None:
+                t.append(f" · confidence {float(confidence):.2f}", style=THEME["muted"])
+            t.append("\n")
+
+        t.append("\n  Activated schemas\n", style=f"bold {THEME['purple']}")
+        t.append(
+            f"    {', '.join(sorted(activated)) if activated else 'none'}\n",
+            style=THEME["success"] if activated else THEME["warning"],
+        )
+        t.append("\n  Execution outcome\n", style=f"bold {THEME['purple']}")
+        executions = list(event.get("executions") or [])
+        if not executions:
+            t.append("    not executed yet\n", style=THEME["dim"])
+        for execution in executions:
+            status = str(execution.get("status") or "unknown")
+            style = THEME["success"] if status == "success" else THEME["warning"]
+            t.append(
+                f"    {execution.get('tool') or 'unknown'} · {status} · "
+                f"permission {execution.get('permission') or 'unknown'}\n",
+                style=style,
+            )
+        t.append(
+            f"\n  trace {event.get('discoveryId') or 'not persisted'}\n",
+            style=THEME["dim"],
+        )
         self._show_command_output(log, t)
 
     def _activate_decision_connection(self, pure, log: ConversationLog) -> None:
@@ -552,6 +687,8 @@ class SlashCommandMixin:
             self._set_approval_mode(args, log)
         elif c == "systemone":
             self._systemone_cmd(args, log)
+        elif c == "discovery":
+            self._discovery_cmd(args, log)
         elif c == "log":
             self._handle_log_verbosity(args, log)
         elif c == "thinking":

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

@@ -56,6 +56,7 @@ from .spec import (
     ChecksSpec,
     CheckStepSpec,
     SystemOneSpec,
+    ToolDiscoverySpec,
     WorkflowMode,
     WorkflowSpec,
 )
@@ -372,6 +373,7 @@ __all__ = [
     "ExecutionPolicySpec",
     "HarnessFlavor",
     "HarnessSpec",
+    "ToolDiscoverySpec",
     "HookRuleSpec",
     "HooksSpec",
     "ModelPolicySpec",

{superqode-2.4.2 → superqode-2.4.4}/src/superqode/harness/loader.py

@@ -23,6 +23,7 @@ from .spec import (
     OptimizationSpec,
     RecursionSpec,
     SystemOneSpec,
+    ToolDiscoverySpec,
     RemoteHarnessSpec,
     RuntimeSpec,
     ChecksSpec,
@@ -171,6 +172,7 @@ def harness_spec_from_dict(data: dict[str, Any]) -> HarnessSpec:
         context=_context(raw.get("context")),
         checks=_checks(raw.get("checks")),
         observability=_observability(raw.get("observability")),
+        tool_discovery=_tool_discovery(raw.get("tool_discovery")),
         hooks=_hooks(raw.get("hooks")),
         optimization=_optimization(raw.get("optimization")),
         systemone=_systemone(raw.get("systemone")),
@@ -347,6 +349,16 @@ def harness_spec_to_dict(spec: HarnessSpec) -> dict[str, Any]:
             "run_store": spec.observability.run_store,
             **({"config": spec.observability.config} if spec.observability.config else {}),
         },
+        "tool_discovery": {
+            "enabled": spec.tool_discovery.enabled,
+            "mode": spec.tool_discovery.mode,
+            "trace_dir": spec.tool_discovery.trace_dir,
+            "search": spec.tool_discovery.search,
+            "rank": spec.tool_discovery.rank,
+            "judge": spec.tool_discovery.judge,
+            "activation": spec.tool_discovery.activation,
+            "mcp": spec.tool_discovery.mcp,
+        },
         **(
             {
                 "hooks": {
@@ -630,6 +642,23 @@ def harness_spec_json_schema() -> dict[str, Any]:
                     "config": {"type": "object"},
                 },
             },
+            "tool_discovery": {
+                "type": "object",
+                "additionalProperties": False,
+                "properties": {
+                    "enabled": {"type": "boolean"},
+                    "trace_dir": {"type": "string"},
+                    "mode": {
+                        "type": "string",
+                        "enum": ["legacy", "shadow", "unified"],
+                    },
+                    "search": {"type": "object"},
+                    "rank": {"type": "object"},
+                    "judge": {"type": "object"},
+                    "activation": {"type": "object"},
+                    "mcp": {"type": "object"},
+                },
+            },
             "hooks": {
                 "type": "object",
                 "additionalProperties": False,
@@ -956,6 +985,26 @@ def _observability(value: Any) -> ObservabilitySpec:
     )
 
 
+def _tool_discovery(value: Any) -> ToolDiscoverySpec:
+    data = value if isinstance(value, dict) else {}
+    mode = str(data.get("mode") or "legacy").strip().lower()
+    if mode not in {"legacy", "shadow", "unified"}:
+        raise ValueError("tool_discovery.mode must be one of: legacy, shadow, unified")
+
+    sections: dict[str, dict[str, Any]] = {}
+    for key in ("search", "rank", "judge", "activation", "mcp"):
+        raw = data.get(key)
+        if raw is not None and not isinstance(raw, dict):
+            raise ValueError(f"tool_discovery.{key} must be a mapping")
+        sections[key] = dict(raw or {})
+    return ToolDiscoverySpec(
+        enabled=bool(data.get("enabled", False)),
+        mode=mode,
+        trace_dir=str(data.get("trace_dir") or ""),
+        **sections,
+    )
+
+
 def _hooks(value: Any) -> HooksSpec:
     data = value if isinstance(value, dict) else {}
     rules: list[HookRuleSpec] = []

{superqode-2.4.2 → superqode-2.4.4}/src/superqode/harness/spec.py

@@ -217,6 +217,26 @@ class ObservabilitySpec:
     config: dict[str, Any] = field(default_factory=dict)
 
 
+@dataclass(frozen=True)
+class ToolDiscoverySpec:
+    """Portable progressive tool-discovery policy.
+
+    SuperQode owns the pipeline contract, while each stage remains replaceable.
+    ``legacy`` preserves the existing native and MCP search tools; ``shadow``
+    evaluates the configured pipeline without changing activation; ``unified``
+    makes the configured pipeline authoritative.
+    """
+
+    enabled: bool = False
+    mode: str = "legacy"  # legacy | shadow | unified
+    trace_dir: str = ""
+    search: dict[str, Any] = field(default_factory=dict)
+    rank: dict[str, Any] = field(default_factory=dict)
+    judge: dict[str, Any] = field(default_factory=dict)
+    activation: dict[str, Any] = field(default_factory=dict)
+    mcp: dict[str, Any] = field(default_factory=dict)
+
+
 @dataclass(frozen=True)
 class SystemOneSpec:
     """Opt-in System One decision plane. Disabled by default.
@@ -273,6 +293,7 @@ class HarnessSpec:
     context: ContextSpec = field(default_factory=ContextSpec)
     checks: ChecksSpec = field(default_factory=ChecksSpec)
     observability: ObservabilitySpec = field(default_factory=ObservabilitySpec)
+    tool_discovery: ToolDiscoverySpec = field(default_factory=ToolDiscoverySpec)
     hooks: HooksSpec = field(default_factory=HooksSpec)
     optimization: OptimizationSpec = field(default_factory=OptimizationSpec)
     systemone: SystemOneSpec = field(default_factory=SystemOneSpec)

{superqode-2.4.2 → superqode-2.4.4}/src/superqode/harness/templates.py

@@ -11,6 +11,7 @@ from .spec import (
     RuntimeSpec,
     ChecksSpec,
     SystemOneSpec,
+    ToolDiscoverySpec,
 )
 from .model_routes import model_policy_for_route
 
@@ -123,7 +124,7 @@ def systemone_template(*, name: str = "systemone") -> HarnessSpec:
 
     return replace(
         base,
-        description="SystemOne harness: coding models write code; Jev shadows tool gates and discovery.",
+        description="SystemOne coding harness with progressive tool discovery and Jev decisions.",
         model_policy=replace(
             base.model_policy,
             config={**base.model_policy.config, "deferred_tools": "all"},
@@ -132,6 +133,24 @@ def systemone_template(*, name: str = "systemone") -> HarnessSpec:
         systemone=SystemOneSpec(
             enabled=True, client="live", mode="shadow", tool_search_mode="shadow"
         ),
+        tool_discovery=ToolDiscoverySpec(
+            enabled=True,
+            mode="unified",
+            search={
+                "backend": "bm25",
+                "limit": 20,
+                "on_error": "fallback",
+                "fallback_chain": ["bm25", "lexical"],
+            },
+            rank={
+                "backend": "score",
+                "candidate_limit": 8,
+                "exact_name_boost": 4.0,
+            },
+            judge={"backend": "jev", "mode": "shadow"},
+            activation={"limit": 3},
+            mcp={"mode": "deferred_tools"},
+        ),
         metadata={**base.metadata, "template": "systemone", "category": "workflow"},
     )
 

{superqode-2.4.2 → superqode-2.4.4}/src/superqode/providers/connection_profiles.py

@@ -543,6 +543,15 @@ _HARNESS_PROFILES: List[ConnectionProfile] = [
         menu=CONNECT_MENU_HARNESS,
         detect=lambda: True,
     ),
+    ConnectionProfile(
+        id="harness-systemone",
+        label="SystemOne",
+        description="Coding models write code; Jev checks decisions and discovers tools",
+        connector="harness-use",
+        runtime="systemone",
+        menu=CONNECT_MENU_HARNESS,
+        detect=lambda: True,
+    ),
     ConnectionProfile(
         id="harness-presets",
         label="Tuned presets",

{superqode-2.4.2 → superqode-2.4.4}/src/superqode/providers/manager.py

@@ -8,6 +8,7 @@ from enum import Enum
 
 from .models import (
     LATEST_GOOGLE_FLASH_3_6_MODEL,
+    LATEST_GOOGLE_FLASH_3_7_MODEL,
     LATEST_GOOGLE_FLASH_LITE_MODEL,
     LATEST_GOOGLE_FLASH_MODEL,
     LATEST_GOOGLE_PRO_MODEL,
@@ -655,7 +656,13 @@ class ProviderManager:
                 models=[
                     ModelInfo(
                         LATEST_GOOGLE_FLASH_MODEL,
-                        "Gemini 3.7 Flash (Latest)",
+                        "Gemini 3.8 Flash (Latest)",
+                        "google",
+                        context_size=1_048_576,
+                    ),
+                    ModelInfo(
+                        LATEST_GOOGLE_FLASH_3_7_MODEL,
+                        "Gemini 3.7 Flash",
                         "google",
                         context_size=1_048_576,
                     ),