superqode 2.31.2__tar.gz → 2.31.4__tar.gz

{superqode-2.31.2 → superqode-2.31.4}/CHANGELOG.md

@@ -7,6 +7,55 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.31.4] - 2026-11-05
+
+### Added
+
+- Independent input-fixture copies and fresh harness state for evaluation tasks
+  and optimization candidates, with isolation evidence and repository graders.
+- Reviewed repository verifier commands, file assertions and protected test paths;
+  native suite contents are pinned at submission before execution.
+- Local Quick Start model-size suggestions, context and tool-call probes, expanded
+  local model search and regional provider setup guidance.
+
+### Fixed
+
+- macOS navigation preserves composer and file editors, applies pane changes
+  together and keeps covered review/transcript panes mounted when returning from Files.
+- Response formatting and review preparation run away from the UI thread;
+  unchanged state avoids redraws and recovery writes coalesce in the background.
+- Closed engine pipes report a recoverable error instead of terminating the app.
+- Harness badges consistently identify routes; new conversations remain explicitly
+  disconnected until a connection is chosen.
+
+## [2.31.3] - 2026-11-04
+
+### Added
+
+- Project-scoped Local Quick Start in the Mac app, with reviewed runtime setup,
+  model downloads and bounded Core read-tool verification. Setup progress can be
+  reopened, and failed steps require an explicit retry.
+- Clear local CLI, SDK and installer prerequisites for supported agent connections,
+  with installation rechecks and sign-in recovery guidance.
+
+### Fixed
+
+- Forced vendor sign-in waits for successful CLI completion instead of accepting
+  an existing or partially written credential file. EOF no longer starves process
+  completion, and cancellation stops the sign-in process.
+- Failed, cancelled, incomplete and schema-invalid harness executions cannot pass
+  an evaluation or local coding check merely by producing matching output.
+- Local model inventory skips linked directories and external file targets;
+  GGUF memory estimates recognise underscore-separated size and quantization names.
+- Welcome does not inventory model caches or probe a remembered account. Blank
+  conversations require an explicit connection; opening the local model picker
+  discovers installed models on demand.
+- Native workspace recovery uses login-session file protection so saved drafts
+  remain readable after atomic writes on macOS, with private file permissions.
+
+Ships alongside macOS **0.3.4 / build 20**, Public Beta. Super Agent and Pro remain
+previews. Optional runtimes and model weights require their own setup.
+
 ## [2.31.2] - 2026-11-03
 
 ### Added

{superqode-2.31.2 → superqode-2.31.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.31.2
+Version: 2.31.4
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>
@@ -222,7 +222,7 @@ Dynamic: license-file
 
 The app bundles its Python engine. You do not need to install Python, use the App Store or create a SuperQode account. External agents and local model servers may require their own setup. Provider subscriptions and usage charges still apply.
 
-**Public beta 0.1.11:** Apple Silicon Macs running macOS 14 or later. Some integrations and advanced workflows are experimental; full terminal feature parity is not included. Updates are manual. See the [beta notes](apps/macos/BETA-NOTES.md) and [download checksum](https://superqode.dev/downloads/macos/latest/SuperQode-arm64.dmg.sha256).
+**Public beta 0.3.5:** Apple Silicon Macs running macOS 14 or later. Some integrations and advanced workflows are experimental; full terminal feature parity is not included. Updates are manual. See the [beta notes](apps/macos/BETA-NOTES.md) and [download checksum](https://superqode.dev/downloads/macos/latest/SuperQode-arm64.dmg.sha256).
 
 ## Code, measure and improve in one workspace
 

{superqode-2.31.2 → superqode-2.31.4}/README.md

@@ -52,7 +52,7 @@
 
 The app bundles its Python engine. You do not need to install Python, use the App Store or create a SuperQode account. External agents and local model servers may require their own setup. Provider subscriptions and usage charges still apply.
 
-**Public beta 0.1.11:** Apple Silicon Macs running macOS 14 or later. Some integrations and advanced workflows are experimental; full terminal feature parity is not included. Updates are manual. See the [beta notes](apps/macos/BETA-NOTES.md) and [download checksum](https://superqode.dev/downloads/macos/latest/SuperQode-arm64.dmg.sha256).
+**Public beta 0.3.5:** Apple Silicon Macs running macOS 14 or later. Some integrations and advanced workflows are experimental; full terminal feature parity is not included. Updates are manual. See the [beta notes](apps/macos/BETA-NOTES.md) and [download checksum](https://superqode.dev/downloads/macos/latest/SuperQode-arm64.dmg.sha256).
 
 ## Code, measure and improve in one workspace
 

{superqode-2.31.2 → superqode-2.31.4}/pyproject.toml

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

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.31.2"
+__version__ = "2.31.4"
 
 
 # Stable, lightweight public extension surface.  Importing this package does

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/desktop_service/acp_catalog.py

@@ -323,6 +323,7 @@ def remove_custom_agent(service, params):
 
 def install_plan(service, project, reference):
     from .configuration import install_plan as bundled_plan
+    from .configuration import installer_requirements
 
     root = service.project(project)
     try:
@@ -343,6 +344,7 @@ def install_plan(service, project, reference):
             raise ValueError("This agent needs the vendor's manual installation workflow") from None
         plan = {"reference": reference, "argv": argv, "command": shlex.join(argv)}
     plan["reference"] = reference
+    plan["requirements"] = installer_requirements(plan["argv"])
     plan["digest"] = hashlib.sha256(json.dumps(plan["argv"]).encode()).hexdigest()
     return plan
 

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/desktop_service/configuration.py

@@ -111,6 +111,29 @@ def vendor_key_route(root: Path, entry_id: str):
     return route
 
 
+def installer_requirements(argv):
+    """Identify the local package manager required by a reviewed install plan."""
+    import shutil
+
+    binary = argv[0]
+    name = Path(binary).name
+    docs = {
+        "npm": ("Node.js and npm", "https://nodejs.org/en/download"),
+        "uv": ("uv", "https://docs.astral.sh/uv/getting-started/installation/"),
+        "bun": ("Bun", "https://bun.sh/docs/installation"),
+    }
+    label, url = docs.get(name, (name, ""))
+    return [
+        {
+            "id": "installer",
+            "name": label,
+            "installed": shutil.which(binary) is not None,
+            "instruction": f"Install {label} using its official setup instructions before installing this agent. Then choose Check installation again.",
+            "docs_url": url,
+        }
+    ]
+
+
 def install_plan(root: Path, reference: str):
     from superqode.providers.connection_profiles import get_connection_profile
     from superqode.providers.acp_registry import get_bundled_acp_catalog
@@ -124,7 +147,12 @@ def install_plan(root: Path, reference: str):
         raise ValueError(
             "This agent has no reviewed native install recipe. Use the vendor's setup instructions."
         )
-    return {"reference": reference, "command": plan.command, "argv": plan.argv}
+    return {
+        "reference": reference,
+        "command": plan.command,
+        "argv": plan.argv,
+        "requirements": installer_requirements(plan.argv),
+    }
 
 
 async def install_agent(root: Path, reference: str, status):
@@ -137,6 +165,9 @@ async def run_install_command(argv, status):
     import os
     import signal
 
+    missing = [r for r in installer_requirements(argv) if not r["installed"]]
+    if missing:
+        raise ValueError(" ".join(r["instruction"] + " " + r["docs_url"] for r in missing))
     process = await asyncio.create_subprocess_exec(
         *argv,
         stdout=asyncio.subprocess.PIPE,

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/desktop_service/connect_workflow.py

@@ -93,6 +93,85 @@ def runtime_catalog():
     return rows
 
 
+def connection_requirements(profile, route=None):
+    """Local prerequisites only; presence never certifies account entitlement."""
+    from superqode.providers.subscription_env import resolve_vendor
+    from superqode.providers.subscription_login import get_login_spec, binary_path
+    from superqode.providers.harness_catalog import get_entry
+
+    docs = {
+        "codex": "https://developers.openai.com/codex/cli/",
+        "copilot": "https://docs.github.com/en/copilot/how-tos/set-up/install-copilot-cli",
+        "grok": "https://x.ai/cli",
+        "muse": "https://dev.meta.ai/",
+        "prime-agent": "https://github.com/PrimeIntellect-ai/prime-agent",
+        "fx": "https://github.com/vercel-labs/fx",
+    }
+    rows = []
+    try:
+        login = get_login_spec(resolve_vendor(profile.id) or profile.id)
+        rows.append(
+            {
+                "id": "cli",
+                "name": login.label + " CLI",
+                "installed": binary_path(login) is not None,
+                "instruction": login.install_hint,
+                "docs_url": docs.get(login.id, ""),
+                "required_for_connection": profile.id not in {"codex-sdk", "copilot"},
+            }
+        )
+    except KeyError:
+        pass
+    if profile.id == "codex-sdk":
+        rows.append(
+            {
+                "id": "sdk",
+                "name": "Codex Python SDK in the SuperQode engine",
+                "installed": profile.available,
+                "instruction": "Use an app build that includes the Codex SDK, or choose Codex CLI to use the same account without this optional SDK. Installing Python packages in another environment does not update the app.",
+                "docs_url": "https://developers.openai.com/codex/sdk/",
+                "required_for_connection": True,
+            }
+        )
+    elif profile.id == "copilot":
+        rows.append(
+            {
+                "id": "runtime",
+                "name": "GitHub Copilot CLI or SDK runtime",
+                "installed": profile.available,
+                "instruction": "Install GitHub Copilot CLI with npm install -g @github/copilot, or use an app build that includes the Copilot SDK. The SDK can download its runtime on first connection.",
+                "docs_url": docs["copilot"],
+                "required_for_connection": True,
+            }
+        )
+    elif not rows and (route or {}).get("desktop_kind") == "acp":
+        rows.append(
+            {
+                "id": "agent",
+                "name": profile.label + " local launcher",
+                "installed": route["available"],
+                "instruction": route.get("issue") or profile.unavailable_hint,
+                "docs_url": route.get("website", ""),
+            }
+        )
+    elif not rows and profile.connector in {"runtime", "copilot", "prime-rpc"}:
+        entry = get_entry(profile.id)
+        rows.append(
+            {
+                "id": "runtime",
+                "name": profile.label + " runtime",
+                "installed": profile.available,
+                "instruction": profile.unavailable_hint,
+                "docs_url": "https://antigravity.google/docs/cli-install"
+                if profile.id == "antigravity"
+                else (entry.homepage or entry.repository)
+                if entry
+                else "",
+            }
+        )
+    return rows
+
+
 def profile_route(root: Path, profile_id: str):
     from superqode.providers.connection_profiles import get_connection_profile
     from superqode.providers.subscription_env import resolve_vendor
@@ -134,13 +213,19 @@ def profile_route(root: Path, profile_id: str):
         runtime = "prime-agent"
     if profile.connector not in {"runtime", "copilot", "prime-rpc"}:
         raise ValueError("This profile needs a model, protocol address or harness setup first")
+    requirements = connection_requirements(profile)
+    missing = [
+        row
+        for row in requirements
+        if row.get("required_for_connection", True) and not row["installed"]
+    ]
     route = {
         "id": "connection:" + profile.id,
         "name": profile.label,
         "description": profile.description,
         "runtime": runtime,
-        "available": profile.available,
-        "issue": profile.unavailable_hint,
+        "available": profile.available and not missing,
+        "issue": " ".join(row["instruction"] for row in missing) or profile.unavailable_hint,
         "desktop_kind": "connection",
         "kind": "runtime",
         "subscription_vendor": resolve_vendor(profile.id)
@@ -173,6 +258,7 @@ def connection_menu(root: Path, menu: str):
             "runtime": p.runtime or "",
             "provider": p.byok_provider or "",
             "next": MENU_CONNECTORS.get(p.connector, ""),
+            "menu": menu,
         }
         if p.connector == "language-harness-picker":
             row["next"] = "by-language:" + p.label
@@ -205,19 +291,25 @@ def connection_menu(root: Path, menu: str):
             row["route"] = profile_route(root, p.id)
         except ValueError:
             pass
+        row["requirements"] = connection_requirements(p, row.get("route"))
+        row["setup_ready"] = all(
+            r["installed"] for r in row["requirements"] if r.get("required_for_connection", True)
+        )
         if p.auth_mode == "subscription" or p.connector in {"runtime", "copilot", "acp"}:
             from superqode.providers.subscription_env import resolve_vendor
-            from superqode.providers.subscription_login import get_login_spec, login_command
+            from superqode.providers.subscription_login import get_login_spec, binary_path
 
             try:
                 login = get_login_spec(resolve_vendor(p.id) or p.id)
+                binary = binary_path(login)
                 row["login"] = {
                     "id": login.id,
                     "label": login.label,
-                    "command": login_command(login),
+                    "command": [binary, *login.login_args] if binary else [],
+                    "available": binary is not None,
                     "interactive": login.interactive_tty,
                 }
-            except (KeyError, FileNotFoundError):
+            except KeyError:
                 pass
         from .configuration import install_plan
 

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/desktop_service/connections.py

@@ -81,6 +81,11 @@ def list_connections(credentials: dict[str, str]):
                 else "not configured",
                 "example_models": definition.example_models,
                 "docs_url": definition.docs_url,
+                "category": definition.category.value,
+                "notes": definition.notes,
+                "credential_variables": list(definition.env_vars),
+                "default_base_url": definition.default_base_url,
+                "base_url_env": definition.base_url_env or "",
                 "verified": False,
             }
         )

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/desktop_service/evaluation_review.py

@@ -57,7 +57,12 @@ def _grading_issue(task):
     method = evaluation.get("evaluator")
     if method == "execution" and task.get("status") == "error":
         return ""  # An operational failure is not graded, but loses a baseline success.
-    if not isinstance(method, str) or method not in {"contains", "decision", "jev_rubric"}:
+    if not isinstance(method, str) or method not in {
+        "contains",
+        "decision",
+        "jev_rubric",
+        "repository",
+    }:
         return "The grading method is missing or unsupported."
     return ""
 

{superqode-2.31.2 → superqode-2.31.4}/src/superqode/desktop_service/experiments.py

@@ -1,6 +1,8 @@
 """Read-only suite diagnostics used before native experiment execution."""
 
 from pathlib import Path
+import hashlib
+import shlex
 
 from superqode.harness.eval import eval_pack_path, filter_eval_tasks, load_eval_tasks
 from superqode.harness.loader import load_harness_spec
@@ -65,6 +67,18 @@ def inspect_suite(root, params):
         warnings.append("Optimization needs both held-in training and sealed held-out tasks.")
     if not tasks:
         warnings.append("No tasks match the selected split.")
+    repository_checks = []
+    for task in tasks:
+        grader = task.get("evaluator") or {}
+        if grader.get("type") == "repository":
+            repository_checks.append(
+                {
+                    "id": str(task["id"]),
+                    "commands": [shlex.join(c["argv"]) for c in grader.get("commands", [])],
+                    "file_assertions": [f["path"] for f in grader.get("files", [])],
+                    "require_changes": grader.get("require_changes", False),
+                }
+            )
     return {
         "tasks_hash": data["tasks_hash"],
         "task_count": len(tasks),
@@ -73,7 +87,27 @@ def inspect_suite(root, params):
         "candidate_count": len(candidates) + len(suite_candidates),
         "smoke_task_ids": smoke,
         "warnings": warnings,
+        "repository_checks": repository_checks,
         "optimization_ready": bool(
             data["split_counts"]["held-in"] and data["split_counts"]["held-out"] and not smoke
         ),
     }
+
+
+def reviewed_suite(root, params):
+    """Pin suite bytes so later edits cannot change reviewed verifier commands."""
+    inspection = inspect_suite(root, params)
+    value = str(params.get("tasks") or "")
+    path = eval_pack_path(str(root / value) if (root / value).exists() else value)
+    raw = path.read_bytes()
+    digest = "sha256:" + hashlib.sha256(raw).hexdigest()
+    if digest != inspection["tasks_hash"]:
+        raise ValueError("The evaluation suite changed. Review it again before starting.")
+    expected = params.get("tasks_hash")
+    if expected and expected != digest:
+        raise ValueError(
+            "The evaluation suite changed since review. Check its verifier commands again."
+        )
+    if params.get("live") is True and inspection["repository_checks"] and expected != digest:
+        raise ValueError("Review the repository verifier commands before starting this live suite.")
+    return raw.decode("utf-8")

superqode-2.31.4/src/superqode/desktop_service/local_quickstart.py

@@ -0,0 +1,243 @@
+"""Project-scoped, resumable local setup using the reviewed workbench jobs."""
+
+import hashlib
+import json
+
+from . import local_models
+
+
+def _key(project):
+    return "local-quickstart:" + project
+
+
+def _read(service, project):
+    rows = service._all("SELECT value FROM settings WHERE key=?", (_key(project),))
+    return json.loads(rows[0]["value"]) if rows else {}
+
+
+def _save(service, project, state):
+    service._write(
+        "INSERT OR REPLACE INTO settings VALUES(?,?)", (_key(project), json.dumps(state))
+    )
+
+
+def catalog(service, project):
+    from superqode.local.hardware import detect_hardware
+
+    service.project(project)
+    hardware = detect_hardware()
+    engines = local_models.servers(service)
+    choices = {}
+
+    def add(engine, model, name, detail, installed, *, preset="running", context=None):
+        if any(word in model.lower() for word in ("embed", "rerank", "cloud")):
+            return
+        identity = hashlib.sha256((engine + "\n" + model).encode()).hexdigest()[:24]
+        choices[identity] = dict(
+            id=identity,
+            engine=engine,
+            model=model,
+            name=name,
+            detail=detail,
+            installed=installed,
+            preset=preset,
+            suggested_context=context,
+        )
+
+    for engine in engines:
+        if engine["running"]:
+            try:
+                for model in local_models.available(engine["id"])["models"]:
+                    add(engine["id"], model, model, "Already available · " + engine["name"], True)
+            except (OSError, ValueError):
+                pass
+    # Keep the first setup small. These are starting choices, not quality claims.
+    memory = hardware.available_memory_gb
+    if memory and memory >= 8:
+        suggestions = [
+            (
+                "qwen3.5:2b",
+                "Fast · Qwen 2B",
+                "A small starting model for limited memory.",
+                "fast",
+                8192,
+            )
+        ]
+        if memory >= 16:
+            suggestions += [
+                (
+                    "qwen3.5:9b",
+                    "Balanced · Qwen 9B",
+                    "More memory and latency than Fast.",
+                    "balanced",
+                    16384,
+                ),
+                (
+                    "gemma4:e4b",
+                    "Gemma · alternative",
+                    "Google's open model family.",
+                    "alternative",
+                    16384,
+                ),
+            ]
+        if memory >= 48:
+            suggestions.append(
+                (
+                    "qwen3.5:27b",
+                    "Capable · Qwen 27B",
+                    "A larger starting model for high-memory machines.",
+                    "capable",
+                    32768,
+                )
+            )
+        for model, name, detail, preset, context in suggestions:
+            identity = hashlib.sha256(("ollama\n" + model).encode()).hexdigest()[:24]
+            if identity not in choices:
+                add(
+                    "ollama",
+                    model,
+                    name,
+                    detail
+                    + " Exact artifact size is reported during transfer; these are not measured speed or quality rankings.",
+                    False,
+                    preset=preset,
+                    context=context,
+                )
+    saved = _read(service, project)
+    previous = saved.get("selection")
+    if previous and previous["id"] not in choices:
+        choices[previous["id"]] = {
+            **previous,
+            "installed": False,
+            "detail": "Previous setup · check its server and recorded progress.",
+        }
+    return {
+        "choices": sorted(choices.values(), key=lambda row: not row["installed"]),
+        "selected": saved.get("choice", ""),
+        "memory_gb": memory,
+        "note": "Starting suggestions, not measured coding-quality guarantees. Context and other apps also need memory.",
+    }
+
+
+def prepare(service, params):
+    project, choice_id = params["project"], params["choice"]
+    with service.lock:
+        state = _read(service, project)
+        original = dict(state)
+        job = service._all("SELECT * FROM jobs WHERE id=?", (state.get("job", ""),))
+        if job and job[0]["status"] in {"running", "queued", "needs_approval", "cancelling"}:
+            if state.get("choice") != choice_id:
+                raise ValueError("Finish or cancel the current setup before choosing another model")
+            return {"step": "working", "job": job[0]["id"]}
+        if state.get("choice") == choice_id and job:
+            row = job[0]
+            result = json.loads(row["result"]) if row["result"] else {}
+            passed = (result.get("verification") or {}).get("status") == "passed"
+            if row["status"] != "completed" or (state.get("step") == "verify" and not passed):
+                if not params.get("retry"):
+                    return {
+                        "step": "retry",
+                        "job": row["id"],
+                        "message": "Setup stopped. Review its output, then retry. Completed downloads are reused.",
+                        "verification": result.get("verification", {}),
+                    }
+                state = {"choice": choice_id}
+            elif state.get("step") == "verify":
+                verification = result.get("verification") or {}
+                # Older Core-only checks must run the new readiness checks too.
+                state["verified"] = (verification.get("readiness") or {}).get("status") in {
+                    "ready",
+                    "warning",
+                }
+                state["verification"] = verification
+        else:
+            state = {"choice": choice_id}
+
+    def finish(result):
+        with service.lock:
+            if _read(service, project) != original:
+                raise ValueError("Setup changed. Check its progress again.")
+            _save(
+                service,
+                project,
+                {**state, "selection": choice, "plan": (result.get("plan") or {}).get("id")},
+            )
+        return result
+
+    choice = next(
+        (row for row in catalog(service, project)["choices"] if row["id"] == choice_id), None
+    )
+    if not choice:
+        raise ValueError("Refresh model choices; this model is no longer available here")
+    engine, model = choice["engine"], choice["model"]
+    status = next(row for row in local_models.servers(service) if row["id"] == engine)
+    options = {"engine": engine, "model": model}
+    if not status["installed"] and not status["running"]:
+        if not status["install"]["automatic"]:
+            return finish(
+                {
+                    "step": "manual",
+                    "url": status["install"]["docs_url"],
+                    "message": "Install "
+                    + status["name"]
+                    + " using its official installer, then check again. Your model choice is kept.",
+                }
+            )
+        step = "install"
+    elif not status["running"]:
+        # Reuse existing model-specific configuration for single-model engines.
+        if engine != "ollama":
+            raise ValueError("Start this model from Advanced setup, then check again")
+        step = "serve"
+        options["context"] = choice.get("suggested_context") or 8192
+    elif model not in local_models.available(engine)["models"]:
+        if engine != "ollama":
+            raise ValueError("Load the selected model in its server, then check again")
+        step = "download"
+        options["source"] = "ollama"
+    elif state.get("verified"):
+        return finish(
+            {
+                "step": "ready",
+                "engine": engine,
+                "model": model,
+                "verification": state.get("verification", {}),
+            }
+        )
+    else:
+        step = "verify"
+        options["check"] = "quickstart"
+    plan = local_models.prepare(service, {**options, "action": step})
+    return finish({"step": step, "plan": plan, "engine": engine, "model": model})
+
+
+def start(service, params):
+    project = params["project"]
+    service.project(project)
+    with service.lock:
+        state = _read(service, project)
+        if state.get("choice") != params["choice"]:
+            raise ValueError("Review the selected model again")
+        if state.get("job"):
+            row = service._all("SELECT status FROM jobs WHERE id=?", (state["job"],))
+            if row and row[0]["status"] in {"running", "queued", "needs_approval", "cancelling"}:
+                return {"id": state["job"]}
+        plans = service._all("SELECT plan FROM local_model_plans WHERE id=?", (params["plan"],))
+        if not plans:
+            raise ValueError("Review this step again")
+        plan = json.loads(plans[0]["plan"])
+        if state.get("plan") != params["plan"]:
+            raise ValueError("Review the current setup step again")
+        choice_id = params["choice"]
+        result = local_models.start(service, params)
+        _save(
+            service,
+            project,
+            {
+                "choice": choice_id,
+                "selection": state["selection"],
+                "step": plan["action"],
+                "job": result["id"],
+            },
+        )
+        return result