superqode 2.8.0__tar.gz → 2.9.0__tar.gz

{superqode-2.8.0 → superqode-2.9.0}/CHANGELOG.md

@@ -7,6 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.9.0] - 2026-10-08
+
+### Added
+
+- Shared `:codex help` and completion catalog, with native ChatGPT browser/device
+  sign-in, fresh chats, unarchive, Plan mode, approval policy, usage, Codex-owned
+  skills/MCP/plugins/apps/hooks/features/config inspection, CLI doctor diagnostics,
+  descendant agents, background terminals and cancellation controls.
+- Full Codex 0.160.0 CLI and slash-command coverage audit documenting supported,
+  partial and deferred integrations.
+
+### Fixed
+
+- Selecting Codex CLI or SDK clears an active repository harness override;
+  startup ignores saved project defaults for direct Codex routes. Harness status
+  and the sidebar report Codex instead of a nearby `harness.yaml`.
+- Codex session listings show full IDs and pagination with retained filters.
+  Resume supports `--last`, fork defaults to the active thread, and native review
+  supports branch/commit targets. Session mutations refuse running tasks, and
+  archiving the active thread detaches it before the next prompt.
+
 ## [2.8.0] - 2026-10-08
 
 ### Added

{superqode-2.8.0 → superqode-2.9.0}/PKG-INFO

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

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

{superqode-2.8.0 → superqode-2.9.0}/src/superqode/__init__.py

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

{superqode-2.8.0 → superqode-2.9.0}/src/superqode/app/constants.py

@@ -2,6 +2,8 @@
 SuperQode App Constants - Theme, Icons, Colors, and Messages.
 """
 
+from superqode.codex_commands import CODEX_COMMANDS
+
 # Clean ASCII art for SUPERQODE - Standard style (upright, thin)
 ASCII_LOGO = """
  ____  _   _ ____  _____ ____   ___    ___  ____  _____
@@ -573,21 +575,7 @@ COMMANDS = [
     ":runtime copilot-sdk",
     ":runtime doctor",
     ":codex",
-    ":codex status",
-    ":codex models",
-    ":codex model",
-    ":codex effort",
-    ":codex sandbox",
-    ":codex review",
-    ":codex compact",
-    ":codex thread",
-    ":codex sessions",
-    ":codex resume",
-    ":codex fork",
-    ":codex rename",
-    ":codex archive",
-    ":codex account",
-    ":codex logout",
+    *(f":codex {name}" for name, _ in CODEX_COMMANDS),
     ":copilot",
     ":copilot login",
     ":copilot sdk",

{superqode-2.8.0 → superqode-2.9.0}/src/superqode/app/mixins/codex.py

@@ -18,9 +18,11 @@ from superqode.app.widgets import (
 
 # --- helpers extracted from app_main (A1) ---
 from superqode.app.recipes import PromptCompletionCandidate
+from superqode.codex_commands import CODEX_ALIASES, CODEX_COMMANDS, CODEX_OPTIONS
+from .codex_controls import CodexControlsMixin, codex_options
 
 
-class CodexMixin:
+class CodexMixin(CodexControlsMixin):
     """Codex model/effort pickers and execution."""
 
     @property
@@ -251,23 +253,7 @@ class CodexMixin:
 
         prefix = ":codex "
         partial = value[len(prefix) :].lower()
-        subcommands = (
-            ("status", "Show Codex CLI/app-server status"),
-            ("model", "Pick or set the Codex model for future turns"),
-            ("models", "List models available to this Codex account"),
-            ("effort", "Pick or set Codex reasoning effort"),
-            ("sandbox", "Set the Codex sandbox override"),
-            ("review", "Run a read-only Codex diff review"),
-            ("thread", "Show the current Codex thread"),
-            ("sessions", "List Codex sessions for this repo"),
-            ("resume", "Resume a Codex thread"),
-            ("fork", "Fork a Codex thread"),
-            ("compact", "Compact the current Codex thread"),
-            ("rename", "Rename the current Codex thread"),
-            ("archive", "Archive a Codex thread"),
-            ("account", "Show the signed-in Codex account"),
-            ("logout", "Sign out of Codex"),
-        )
+        subcommands = CODEX_COMMANDS
         return [
             PromptCompletionCandidate(
                 value=f"{prefix}{subcommand}",
@@ -279,6 +265,23 @@ class CodexMixin:
             if subcommand.startswith(partial) and f"{prefix}{subcommand}" != value
         ]
 
+    @staticmethod
+    def _codex_option_completion_candidates(value: str) -> list[PromptCompletionCandidate]:
+        parts = value.split(" ", 2)
+        if len(parts) != 3:
+            return []
+        sub = CODEX_ALIASES.get(parts[1].lower(), parts[1].lower())
+        prefix = f"{parts[0]} {parts[1]} "
+        # Complete one option without guessing branch names, IDs or cursors.
+        partial = parts[2].lower()
+        return [
+            PromptCompletionCandidate(
+                value=f"{prefix}{option}", label=option, description=description, kind="codex"
+            )
+            for option, description in CODEX_OPTIONS.get(sub, ())
+            if option.startswith(partial) and f"{prefix}{option}" != value
+        ]
+
     def _codex_effort_completion_candidates(self, value: str) -> list[PromptCompletionCandidate]:
         """Offer valid SDK effort values without starting an app-server per keypress."""
 
@@ -409,16 +412,30 @@ class CodexMixin:
                 log.add_error(f"Codex subscription verification failed: {exc}")
 
     def _codex_cmd(self, args: str, log) -> None:
-        """Handle :codex and Codex SDK runtime subcommands."""
+        """Handle Codex controls, with explicit CLI-only capabilities."""
         raw = (args or "").strip()
         parts = raw.split(maxsplit=1)
         sub = parts[0].lower() if parts else "connect"
+        sub = CODEX_ALIASES.get(sub, sub)
         rest = parts[1].strip() if len(parts) > 1 else ""
         if sub in {"", "connect", "start"}:
             self._requested_runtime_target = "codex-cli"
             self._requested_runtime_billing = "subscription"
             self._runtime_cmd("codex-cli", log)
             return
+        if self._codex_extended_cmd(sub, rest, log):
+            return
+        if self.is_busy and sub in {
+            "resume",
+            "fork",
+            "archive",
+            "logout",
+            "compact",
+            "sandbox",
+            "review",
+        }:
+            log.add_error("A Codex task is running; cancel it or wait before changing the session")
+            return
         status_expr = f"{sub} {rest}".strip()
         if status_expr in {"status", "doctor", "status --probe", "status probe", "status models"}:
             self._codex_status(log, probe=status_expr not in {"status", "doctor"})
@@ -473,7 +490,7 @@ class CodexMixin:
             return
         log.add_error(f"Unknown codex command: {sub}")
         log.add_info(
-            "Usage: :codex [status|models|model|effort|sandbox|review|compact|thread|sessions|resume|fork|rename|archive|account|logout]"
+            "Use :codex help for supported controls. !codex --help lists the installed CLI commands."
         )
 
     def _codex_runtime_or_connect(self, log):
@@ -519,6 +536,10 @@ class CodexMixin:
                     on_result(response)
             except Exception as exc:
                 log.add_error(f"Codex {label} failed: {exc}")
+                if getattr(exc, "code", None) == -32601:
+                    log.add_info(
+                        "This installed Codex CLI does not expose that control. Update Codex or use its CLI; no SDK fallback was attempted."
+                    )
                 self._codex_config_error_hint(log, exc)
 
         self.run_worker(execute(), exclusive=False)
@@ -989,8 +1010,11 @@ class CodexMixin:
         log.write(text)
 
     def _codex_sessions_cmd(self, args: str, log, *, response=None) -> None:
-        archived = "archived" in args.split() or "--archived" in args.split()
         try:
+            if args == "archived":
+                args = "--archived"
+            options = codex_options(args, flags=("--archived", "--all"), values=("--cursor",))
+            archived = bool(options.get("--archived"))
             runtime = self._codex_runtime_or_connect(log)
             if response is None:
                 if getattr(runtime, "name", "") == "codex-cli":
@@ -998,10 +1022,17 @@ class CodexMixin:
                         log,
                         "sessions",
                         runtime,
-                        lambda: runtime.list_threads(limit=20, archived=archived),
+                        lambda: runtime.list_threads(
+                            limit=20,
+                            archived=archived,
+                            cursor=options.get("--cursor"),
+                            all_cwds=bool(options.get("--all")),
+                        ),
                         lambda result: self._codex_sessions_cmd(args, log, response=result),
                     )
                     return
+                if options.get("--cursor") or options.get("--all"):
+                    raise ValueError("Session pagination and --all require :connect codex (CLI)")
                 response = runtime.list_threads(limit=20, archived=archived)
         except Exception as exc:  # noqa: BLE001
             log.add_error(f"Could not list Codex sessions: {exc}")
@@ -1019,7 +1050,7 @@ class CodexMixin:
         for thread in threads:
             data = self._codex_obj_dict(thread)
             tid = str(data.get("id") or "")
-            text.append(f"  {tid[:12]:<14}", style=f"bold {THEME['cyan']}")
+            text.append(f"  {tid}  ", style=f"bold {THEME['cyan']}")
             text.append(
                 str(data.get("name") or data.get("preview") or "(unnamed)")[:80],
                 style=THEME["text"],
@@ -1030,11 +1061,44 @@ class CodexMixin:
         text.append(" or ", style=THEME["muted"])
         text.append(":codex fork <thread_id>", style=THEME["cyan"])
         text.append(".\n", style=THEME["muted"])
+        cursor = self._codex_obj_dict(response).get("nextCursor")
+        if cursor:
+            flags = " --archived" if archived else ""
+            flags += " --all" if options.get("--all") else ""
+            text.append(f"  Next page: :codex sessions{flags} --cursor {cursor}\n")
         log.write(text)
 
     def _codex_resume_cmd(self, thread_id: str, log) -> None:
         if not thread_id:
-            log.add_info("Usage: :codex resume <thread_id>")
+            self._codex_sessions_cmd("", log)
+            return
+        if thread_id == "--last":
+            try:
+                runtime = self._codex_runtime_or_connect(log)
+                if getattr(runtime, "name", "") != "codex-cli":
+                    raise ValueError("--last requires the native Codex CLI connection")
+
+                async def resume_last():
+                    result = await runtime.list_threads(limit=1)
+                    threads = result.get("data", [])
+                    if not threads:
+                        raise ValueError("No saved Codex chat exists for this directory")
+                    return await runtime.resume_thread(threads[0]["id"])
+
+                self._codex_async_read(
+                    log,
+                    "resume last",
+                    runtime,
+                    resume_last,
+                    lambda result: log.add_success(
+                        f"Codex resumed {result.get('thread', {}).get('id')}"
+                    ),
+                )
+            except Exception as exc:
+                log.add_error(f"Codex resume: {exc}")
+            return
+        if thread_id.startswith("-") or len(thread_id.split()) != 1:
+            log.add_error("Usage: :codex resume <thread_id>|--last")
             return
         self._codex_runtime_action(
             log, f"resume {thread_id[:12]}", lambda runtime: runtime.resume_thread(thread_id)
@@ -1042,8 +1106,14 @@ class CodexMixin:
 
     def _codex_fork_cmd(self, thread_id: str, log) -> None:
         if not thread_id:
-            log.add_info("Usage: :codex fork <thread_id>")
-            return
+            try:
+                runtime = self._codex_runtime_or_connect(log)
+                thread_id = runtime.thread_id
+                if not thread_id:
+                    raise ValueError("No current Codex thread to fork; provide a saved thread ID")
+            except Exception as exc:
+                log.add_error(f"Codex fork: {exc}")
+                return
         self._codex_runtime_action(
             log, f"fork {thread_id[:12]}", lambda runtime: runtime.fork_thread(thread_id)
         )
@@ -1106,16 +1176,38 @@ class CodexMixin:
 
     def _codex_review_cmd(self, prompt: str, log) -> None:
         try:
+            if self.is_busy:
+                raise ValueError("A task is running; cancel it or wait before starting a review")
+            base = commit = None
+            if prompt.startswith("--"):
+                options = codex_options(
+                    prompt, flags=("--uncommitted",), values=("--base", "--commit")
+                )
+                if len(options) != 1:
+                    raise ValueError("Choose --base <branch>, --commit <sha>, or --uncommitted")
+                base, commit = options.get("--base"), options.get("--commit")
+                prompt = ""
             runtime = self._codex_runtime_or_connect(log)
             if getattr(runtime, "name", "") == "codex-cli":
-                runtime.set_review(prompt)
+                if base or commit:
+                    runtime.set_review(base=base, commit=commit)
+                else:
+                    runtime.set_review(prompt)
             else:
+                if base or commit:
+                    raise ValueError("Structured review targets require :connect codex (CLI)")
                 runtime.set_next_turn_sandbox("read-only")
         except Exception as exc:  # noqa: BLE001
             log.add_error(f"Could not start Codex review: {exc}")
             self._codex_config_error_hint(log, exc)
             return
-        review_prompt = prompt or (
+        review_prompt = (
+            f"Review changes against {base}"
+            if base
+            else f"Review commit {commit}"
+            if commit
+            else prompt
+        ) or (
             "Review the current uncommitted diff only. Do not edit files or run commands that modify state. "
             "Prioritize correctness bugs, regressions, safety risks, and missing tests. "
             "Return findings first with file/line references where possible."
@@ -1138,11 +1230,26 @@ class CodexMixin:
         if getattr(runtime, "name", "") == "codex-cli":
             text.append(f"  App-server  {runtime.app_server_source}\n")
             text.append(f"  Thread      {runtime.thread_id or 'not started'}\n")
+            text.append(
+                f"  Model       {runtime.active_model or runtime.model or 'Codex default'}\n"
+            )
+            text.append(f"  Effort      {runtime.reasoning_effort or 'Codex default'}\n")
+            text.append(
+                f"  Sandbox     {getattr(runtime, 'sandbox_backend', None) or 'Codex default'}\n"
+            )
+            text.append(
+                f"  Mode        {getattr(runtime, '_collaboration_mode', None) or 'Codex default'}\n"
+            )
+            text.append(
+                f"  Approval    {getattr(runtime, '_approval_policy', None) or 'Codex default'}\n"
+            )
             text.append(
                 f"  Auth        {runtime.subscription_status.get('billing_verified', 'unknown')}\n"
             )
             if runtime.rate_limits:
                 text.append(f"  Rate limits {runtime.rate_limits}\n")
+            if getattr(runtime, "token_usage", None):
+                text.append(f"  Token usage {runtime.token_usage}\n")
             for phase, elapsed in runtime.timings.items():
                 text.append(f"  {phase:<16} {elapsed:.1f} ms\n")
         if not probe:

superqode-2.9.0/src/superqode/app/mixins/codex_controls.py

@@ -0,0 +1,259 @@
+"""Additional controls for the native Codex connection."""
+
+from __future__ import annotations
+
+import json
+import inspect
+import shlex
+
+from rich.text import Text
+
+from superqode.codex_commands import CODEX_COMMANDS, redact_codex_data
+
+
+def codex_options(args, *, flags=(), values=()):
+    words = iter(shlex.split(args))
+    options = {}
+    for word in words:
+        if word in flags:
+            options[word] = True
+        elif word in values:
+            value = next(words, None)
+            if value is None or value.startswith("--"):
+                raise ValueError(f"{word} requires a value")
+            options[word] = value
+        else:
+            raise ValueError(f"Unknown option: {word}")
+    return options
+
+
+class CodexControlsMixin:
+    def _codex_help(self, log):
+        text = Text("\nCodex commands\n\n")
+        for command, description in CODEX_COMMANDS:
+            text.append(f"  :codex {command:<13} {description}\n")
+        text.append(
+            "\nNew controls use Codex CLI. SDK connections retain their existing session controls.\n"
+            "Codex owns these inventories; SuperQode's :mcp and :skills manage separate tools.\n"
+            "Cloud, daemon, deletion, worktrees, updates and terminal customization stay in Codex CLI.\n"
+            "Run !codex --help to inspect your installed CLI.\n"
+        )
+        log.write(text)
+
+    def _codex_control_result(self, log, label, result, *, command=None):
+        safe = redact_codex_data(result)
+        content = json.dumps(safe, indent=2, ensure_ascii=False, default=str)
+        text = Text(f"\nCodex {label}\n\n")
+        text.append(content[:32000])
+        if len(content) > 32000:
+            text.append("\nDisplay shortened; use a narrower query or Codex CLI for full output.")
+        if isinstance(result, dict) and result.get("nextCursor") and command:
+            text.append(f"\nNext page: :codex {command} --cursor {result['nextCursor']}")
+        log.write(text)
+
+    def _codex_extended_cmd(self, sub, rest, log):
+        supported = {
+            "help",
+            "doctor",
+            "new",
+            "unarchive",
+            "login",
+            "usage",
+            "mcp",
+            "skills",
+            "plugins",
+            "apps",
+            "hooks",
+            "features",
+            "config",
+            "permissions",
+            "plan",
+            "ps",
+            "stop",
+            "cancel",
+            "agents",
+            "rollout",
+            "pwd",
+            "diff",
+            "copy",
+        }
+        if sub not in supported:
+            return False
+        try:
+            if sub == "help":
+                self._codex_help(log)
+                return True
+            if sub == "diff":
+                pending = self._handle_diff(rest, log)
+                if inspect.isawaitable(pending):
+                    self.run_worker(pending, exclusive=False)
+                return True
+            if sub == "copy":
+                self._handle_copy(log, rest or "response")
+                return True
+            # Parse before connecting: invalid input must not start an agent.
+            if sub in {
+                "skills",
+                "plugins",
+                "apps",
+                "hooks",
+                "features",
+                "mcp",
+                "permissions",
+                "ps",
+                "agents",
+            }:
+                options = None
+                if sub == "mcp" and rest in {"reload", "verbose"}:
+                    options = {}
+                elif sub == "permissions" and rest in {"on-request", "never"}:
+                    options = {}
+                else:
+                    flags = ("--reload",) if sub in {"skills", "plugins", "apps"} else ()
+                    values = (
+                        ("--cursor",)
+                        if sub in {"apps", "features", "mcp", "permissions", "ps", "agents"}
+                        else ()
+                    )
+                    options = codex_options(rest, flags=flags, values=values)
+            elif sub == "login":
+                if rest not in {"", "--device-auth", "status", "cancel"}:
+                    raise ValueError("Usage: :codex login [--device-auth|status|cancel]")
+            elif sub == "plan":
+                if rest not in {"", "on", "off"}:
+                    raise ValueError("Usage: :codex plan [on|off]")
+            elif sub == "usage":
+                options = codex_options(rest, flags=("--tokens",))
+            elif sub == "unarchive":
+                if not rest or len(rest.split()) != 1 or rest.startswith("-"):
+                    raise ValueError("Usage: :codex unarchive <thread_id>")
+            elif sub not in {"new"} and rest:
+                raise ValueError(f"Usage: :codex {sub}")
+
+            runtime = self._codex_runtime_or_connect(log)
+            if getattr(runtime, "name", "") != "codex-cli":
+                log.add_info(
+                    f":codex {sub} requires Codex CLI. Select :connect codex to use it; your SDK connection is still active."
+                )
+                return True
+            idle_only = {"new", "plan", "login", "permissions", "unarchive"}
+            if (
+                sub in idle_only
+                and not (sub == "login" and rest in {"status", "cancel"})
+                or sub == "mcp"
+                and rest == "reload"
+            ) and self.is_busy:
+                raise ValueError(
+                    "A Codex task is running; cancel it or wait before changing the session"
+                )
+
+            def read(operation, label=None, command=None):
+                self._codex_async_read(
+                    log,
+                    sub,
+                    runtime,
+                    operation,
+                    lambda result: self._codex_control_result(
+                        log, label or sub, result, command=command
+                    ),
+                )
+
+            if sub == "new":
+                read(lambda: runtime.new_thread(rest), "new chat")
+            elif sub == "unarchive":
+                read(lambda: runtime.unarchive_thread(rest), "unarchive")
+            elif sub == "login":
+                if rest == "status":
+                    self._codex_account_cmd(log)
+                elif rest == "cancel":
+                    read(runtime.cancel_login, "sign-in cancelled")
+                else:
+                    self._codex_async_read(
+                        log,
+                        "login",
+                        runtime,
+                        lambda: runtime.login(device=rest == "--device-auth"),
+                        lambda result: self._codex_show_login(log, result),
+                    )
+            elif sub == "usage":
+                read(
+                    lambda: runtime.usage(tokens=bool(options.get("--tokens"))),
+                    "token activity" if options.get("--tokens") else "rate limits",
+                )
+            elif sub == "config":
+                read(runtime.read_config, "configuration and requirements (redacted)")
+            elif sub == "doctor":
+                read(runtime.doctor, "installation health (redacted)")
+            elif sub == "plan":
+                if not rest:
+                    log.add_info(
+                        f"Codex collaboration mode: {runtime._collaboration_mode or 'configured default'}. Use :codex plan on or :codex plan off."
+                    )
+                else:
+                    read(lambda: runtime.set_plan_mode(rest == "on"), "collaboration mode")
+            elif sub == "permissions" and rest in {"on-request", "never"}:
+                runtime.set_approval_policy(rest)
+                log.add_success(
+                    f"Codex approval policy: {rest} (next turn). Sandbox unchanged; :codex sandbox controls filesystem access."
+                )
+            elif sub == "mcp" and rest == "reload":
+                read(runtime.reload_mcp, "MCP configuration reloaded")
+            elif sub in {"ps", "stop"}:
+                read(
+                    lambda: runtime.background_terminals(
+                        stop=sub == "stop", cursor=options.get("--cursor") if sub == "ps" else None
+                    ),
+                    "background terminals",
+                    command="ps" if sub == "ps" else None,
+                )
+            elif sub == "cancel":
+                runtime.cancel()
+                log.add_info("Codex turn interruption requested.")
+            elif sub == "agents":
+                read(
+                    lambda: runtime.list_threads(
+                        descendants=True, all_cwds=True, cursor=options.get("--cursor")
+                    ),
+                    "descendant agent sessions; :codex resume <id> switches thread",
+                    command="agents",
+                )
+            elif sub == "pwd":
+                log.add_info(f"Codex directory: {runtime.config.working_directory}")
+            elif sub == "rollout":
+
+                async def path():
+                    if not runtime.thread_id:
+                        return {"path": None, "message": "No Codex thread is active"}
+                    result = await runtime.read_thread()
+                    return {
+                        "threadId": runtime.thread_id,
+                        "path": result.get("thread", {}).get("path"),
+                    }
+
+                read(path, "saved transcript")
+            else:
+                read(
+                    lambda: runtime.inspect(
+                        sub, reload=bool(options.get("--reload")), cursor=options.get("--cursor")
+                    ),
+                    command=sub,
+                )
+        except Exception as exc:
+            log.add_error(f"Codex {sub}: {exc}")
+        return True
+
+    @staticmethod
+    def _codex_show_login(log, result):
+        # Show only the public sign-in URL and one-time code, never tokens.
+        url = result.get("authUrl") or result.get("verificationUrl")
+        if not url:
+            log.add_error("Codex returned no sign-in URL. Run codex login in another terminal.")
+            return
+        text = Text("\nSign in to Codex with ChatGPT\n\n")
+        text.append(url)
+        if result.get("userCode"):
+            text.append(f"\nOne-time code: {result['userCode']}")
+        text.append(
+            "\nComplete sign-in, then use :codex account to check it. :codex login cancel cancels this sign-in.\n"
+        )
+        log.write(text)

{superqode-2.8.0 → superqode-2.9.0}/src/superqode/app/mixins/commands_impl.py

@@ -2233,6 +2233,7 @@ class CommandImplMixin:
                 and Path(getattr(existing.session, "working_directory", Path.cwd())).resolve()
                 == Path.cwd().resolve()
                 and getattr(existing, "_runtime", None) is not None
+                and getattr(existing, "_harness_spec", None) is None
                 and not (
                     sub == "codex-cli"
                     and (
@@ -2283,6 +2284,12 @@ class CommandImplMixin:
         if sub in self._SELF_CONTAINED_RUNTIMES:
             try:
                 pure = self._ensure_pure_mode()
+                if sub in {"codex-cli", "codex-sdk"}:
+                    # Choosing Codex selects its harness as well as its
+                    # transport. Otherwise connect() prefers a loaded YAML
+                    # spec and never constructs the requested Codex runtime.
+                    pure.clear_harness()
+                    _os.environ["SUPERQODE_HARNESS"] = "core"
                 self._install_pure_permission_bridge(pure, log)
                 pure.runtime_name = sub
                 pure.billing_requested = requested_billing

{superqode-2.8.0 → superqode-2.9.0}/src/superqode/app/mixins/completion.py

@@ -99,7 +99,7 @@ class CompletionMixin:
                 PromptCompletionCandidate(
                     value=":codex",
                     label=":codex",
-                    description="Connect to the Codex SDK runtime",
+                    description="Connect to the installed Codex CLI",
                     kind="command",
                 ),
                 *self._codex_subcommand_completion_candidates(":codex "),
@@ -111,6 +111,8 @@ class CompletionMixin:
         if lowered.startswith(":codex sandbox "):
             return self._codex_sandbox_completion_candidates(value)
         if lowered.startswith(":codex "):
+            if len(value.split(" ", 2)) == 3:
+                return self._codex_option_completion_candidates(value)
             return self._codex_subcommand_completion_candidates(value)
         if lowered == ":copilot":
             return [