synth-ai 0.2.9.dev4__py3-none-any.whl → 0.2.9.dev6__py3-none-any.whl

synth_ai/api/train/cli.py

@@ -2,21 +2,22 @@ from __future__ import annotations
 
 import os
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any
 
 import click
+from synth_ai.config.base_url import get_backend_from_env
 
-from .builders import RLBuildResult, SFTBuildResult, build_rl_payload, build_sft_payload
+from .builders import build_rl_payload, build_sft_payload
 from .config_finder import discover_configs, prompt_for_config
 from .env_resolver import KeySpec, resolve_env
 from .pollers import RLJobPoller, SFTJobPoller
 from .task_app import check_task_app_health
 from .utils import (
-    TrainError,
     REPO_ROOT,
+    TrainError,
     ensure_api_base,
-    http_post,
     http_get,
+    http_post,
     limit_jsonl_examples,
     mask_value,
     post_multipart,
@@ -92,20 +93,72 @@ def _prompt_manual_dataset() -> Path:
     return Path(manual).expanduser()
 
 
+def _default_backend() -> str:
+    """Resolve backend URL with proper production default."""
+    # Check explicit override first
+    explicit = os.getenv("BACKEND_BASE_URL", "").strip()
+    if explicit:
+        return explicit
+    # Use standard resolution logic
+    base, _ = get_backend_from_env()
+    return f"{base}/api" if not base.endswith("/api") else base
+
+
 @click.command("train")
-@click.option("--config", "config_paths", multiple=True, type=click.Path(), help="Path to training TOML (repeatable)")
+@click.option(
+    "--config",
+    "config_paths",
+    multiple=True,
+    type=click.Path(),
+    help="Path to training TOML (repeatable)",
+)
 @click.option("--type", "train_type", type=click.Choice(["auto", "rl", "sft"]), default="auto")
-@click.option("--env-file", "env_files", multiple=True, type=click.Path(), help=".env file(s) to preload (skips selection prompt)")
+@click.option(
+    "--env-file",
+    "env_files",
+    multiple=True,
+    type=click.Path(),
+    help=".env file(s) to preload (skips selection prompt)",
+)
 @click.option("--task-url", default=None, help="Override task app base URL (RL only)")
-@click.option("--dataset", "dataset_path", type=click.Path(), default=None, help="Override dataset JSONL path (SFT)")
-@click.option("--backend", default=lambda: os.getenv("BACKEND_BASE_URL", "http://localhost:8000/api"), help="Backend base URL")
+@click.option(
+    "--dataset",
+    "dataset_path",
+    type=click.Path(),
+    default=None,
+    help="Override dataset JSONL path (SFT)",
+)
+@click.option("--backend", default=_default_backend, help="Backend base URL")
 @click.option("--model", default=None, help="Override model identifier")
+@click.option(
+    "--allow-experimental",
+    "allow_experimental",
+    is_flag=True,
+    flag_value=True,
+    default=None,
+    help="Allow experimental models (overrides SDK_EXPERIMENTAL env)",
+)
+@click.option(
+    "--no-allow-experimental",
+    "allow_experimental",
+    is_flag=True,
+    flag_value=False,
+    help="Disallow experimental models (overrides SDK_EXPERIMENTAL env)",
+)
 @click.option("--idempotency", default=None, help="Idempotency-Key header for job creation")
-@click.option("--dry-run", is_flag=True, help="Preview payload without submitting")
+@click.option("--dry-run", is_flag=True, hidden=True, help="Deprecated: no-op")
 @click.option("--poll/--no-poll", default=True, help="Poll job status until terminal state")
-@click.option("--poll-timeout", default=3600.0, type=float, help="Maximum seconds to poll before timing out")
+@click.option(
+    "--poll-timeout", default=3600.0, type=float, help="Maximum seconds to poll before timing out"
+)
 @click.option("--poll-interval", default=5.0, type=float, help="Seconds between poll attempts")
-@click.option("--examples", "examples_limit", type=int, default=None, help="Limit SFT training to the first N examples")
+@click.option(
+    "--examples",
+    "examples_limit",
+    type=int,
+    default=None,
+    help="Limit SFT training to the first N examples",
+)
 def train_command(
     config_paths: tuple[str, ...],
     train_type: str,
@@ -114,6 +167,7 @@ def train_command(
     dataset_path: str | None,
     backend: str,
     model: str | None,
+    allow_experimental: bool | None,
     idempotency: str | None,
     dry_run: bool,
     poll: bool,
@@ -123,12 +177,20 @@ def train_command(
 ) -> None:
     """Interactive launcher for RL / SFT jobs."""
 
-    candidates = discover_configs(list(config_paths), requested_type=train_type if train_type != "auto" else None)
-    selection = prompt_for_config(candidates, requested_type=train_type if train_type != "auto" else None)
+    candidates = discover_configs(
+        list(config_paths), requested_type=train_type if train_type != "auto" else None
+    )
+    selection = prompt_for_config(
+        candidates,
+        requested_type=train_type if train_type != "auto" else None,
+        allow_autoselect=bool(config_paths),
+    )
 
     effective_type = train_type if train_type != "auto" else selection.train_type
     if effective_type not in {"rl", "sft"}:
-        effective_type = click.prompt("Detected config type is ambiguous. Enter type", type=click.Choice(["rl", "sft"]))
+        effective_type = click.prompt(
+            "Detected config type is ambiguous. Enter type", type=click.Choice(["rl", "sft"])
+        )
 
     cfg_path = selection.path
     click.echo(f"Using config: {cfg_path} ({effective_type})")
@@ -199,6 +261,7 @@ def train_command(
             task_url_override=task_url,
             model_override=model,
             idempotency=idempotency,
+            allow_experimental=allow_experimental,
             dry_run=dry_run,
             poll=poll,
             poll_timeout=poll_timeout,
@@ -211,6 +274,7 @@ def train_command(
             backend_base=backend_base,
             synth_key=synth_key,
             dataset_override=dataset_override_path,
+            allow_experimental=allow_experimental,
             dry_run=dry_run,
             poll=poll,
             poll_timeout=poll_timeout,
@@ -219,11 +283,14 @@ def train_command(
         )
 
 
-def _wait_for_training_file(backend_base: str, api_key: str, file_id: str, *, timeout: float = 120.0) -> None:
+def _wait_for_training_file(
+    backend_base: str, api_key: str, file_id: str, *, timeout: float = 120.0
+) -> None:
     url = f"{backend_base}/learning/files/{file_id}"
     headers = {"Authorization": f"Bearer {api_key}"}
     elapsed = 0.0
     interval = 2.0
+    first_check = True
     while True:
         resp = http_get(url, headers=headers, timeout=30.0)
         if resp.status_code == 200:
@@ -231,17 +298,55 @@ def _wait_for_training_file(backend_base: str, api_key: str, file_id: str, *, ti
                 data = resp.json()
             except Exception:
                 data = {}
-            status = str(data.get("status") or data.get("state") or data.get("storage_state") or "ready").lower()
+            status = str(
+                data.get("status") or data.get("state") or data.get("storage_state") or "ready"
+            ).lower()
+            if first_check:
+                click.echo(f"File uploaded successfully (id={file_id}, status={status})")
+                first_check = False
             if status in {"ready", "uploaded", "stored", "complete"}:
+                click.echo(f"✓ Training file ready (status={status})")
                 return
+            # Show progress for processing states
+            if status in {"processing", "pending", "validating"}:
+                click.echo(
+                    f"  Waiting for file processing... (status={status}, {elapsed:.0f}s elapsed)"
+                )
         elif resp.status_code == 404:
             # Keep polling; object may not be visible yet
-            pass
+            if first_check:
+                click.echo(f"Waiting for file {file_id} to become visible...")
+                first_check = False
+        elif resp.status_code in {401, 403}:
+            # Auth errors won't resolve by polling - fail immediately
+            try:
+                error_body = resp.json()
+            except Exception:
+                error_body = resp.text[:400]
+            click.echo("\n[ERROR] Authentication failed when checking training file:")
+            click.echo(f"  URL: {url}")
+            click.echo(f"  Status: {resp.status_code}")
+            click.echo(f"  Response: {error_body}")
+            click.echo(f"  API key: {mask_value(api_key)}")
+            raise click.ClickException(
+                f"Authentication error ({resp.status_code}). "
+                "Check that your SYNTH_API_KEY is valid and has permission to access this organization's files."
+            )
         else:
-            click.echo(f"[WARN] Unexpected response while checking training file {file_id}: {resp.status_code}")
+            # Other errors - show details but keep polling
+            try:
+                error_body = resp.json()
+            except Exception:
+                error_body = resp.text[:400]
+            click.echo(f"[WARN] Unexpected response checking file {file_id}:")
+            click.echo(f"  URL: {url}")
+            click.echo(f"  Status: {resp.status_code}")
+            click.echo(f"  Response: {error_body}")
 
         if elapsed >= timeout:
-            raise click.ClickException(f"Training file {file_id} not ready after {timeout:.0f}s")
+            raise click.ClickException(
+                f"Training file {file_id} not ready after {timeout:.0f}s (last status: {resp.status_code})"
+            )
         sleep(interval)
         elapsed += interval
 
@@ -254,31 +359,41 @@ def handle_rl(
     task_url_override: str | None,
     model_override: str | None,
     idempotency: str | None,
+    allow_experimental: bool | None,
     dry_run: bool,
     poll: bool,
     poll_timeout: float,
     poll_interval: float,
 ) -> None:
-    overrides: Dict[str, Any] = {"backend": backend_base, "task_url": task_url_override, "model": model_override}
+    overrides: dict[str, Any] = {
+        "backend": backend_base,
+        "task_url": task_url_override,
+        "model": model_override,
+    }
     build = build_rl_payload(
         config_path=cfg_path,
         task_url=task_url_override or os.environ.get("TASK_APP_URL", ""),
         overrides=overrides,
         idempotency=idempotency,
+        allow_experimental=allow_experimental,
     )
 
     # Backend-side verification: try ALL org environment keys against /health and /task_info
     verify_url = f"{backend_base}/rl/verify_task_app"
     verify_headers = {"Authorization": f"Bearer {synth_key}", "Content-Type": "application/json"}
     try:
-        vresp = http_post(verify_url, headers=verify_headers, json_body={"endpoint_base_url": build.task_url})
+        vresp = http_post(
+            verify_url, headers=verify_headers, json_body={"endpoint_base_url": build.task_url}
+        )
         try:
             vjs = vresp.json()
         except Exception:
             vjs = {"status": vresp.status_code, "text": (vresp.text or "")[:400]}
     except Exception as _ve:
-        raise click.ClickException(f"Task app verification call failed: {type(_ve).__name__}: {_ve}") from _ve
-    if vresp.status_code >= 400:
+        raise click.ClickException(
+            f"Task app verification call failed: {type(_ve).__name__}: {_ve}"
+        ) from _ve
+    if vresp.status_code is not None and vresp.status_code >= 400:
         click.echo("Task app verification error:\n" + preview_json(vjs, limit=800))
         raise click.ClickException(f"Verification failed with status {vresp.status_code}")
     if not bool(vjs.get("any_ok")):
@@ -314,9 +429,6 @@ def handle_rl(
 
     click.echo(f"POST {create_url}")
     click.echo("Payload preview:\n" + preview_json(build.payload, limit=800))
-    if dry_run:
-        click.echo("Dry run enabled; skipping submission")
-        return
 
     resp = http_post(create_url, headers=headers, json_body=build.payload)
     try:
@@ -346,6 +458,7 @@ def handle_sft(
     backend_base: str,
     synth_key: str,
     dataset_override: Path | None,
+    allow_experimental: bool | None,
     dry_run: bool,
     poll: bool,
     poll_timeout: float,
@@ -356,7 +469,11 @@ def handle_sft(
 
     while True:
         try:
-            build = build_sft_payload(config_path=cfg_path, dataset_override=dataset_path)
+            build = build_sft_payload(
+                config_path=cfg_path,
+                dataset_override=dataset_path,
+                allow_experimental=allow_experimental,
+            )
             break
         except TrainError as exc:
             click.echo(str(exc))
@@ -379,55 +496,94 @@ def handle_sft(
             validate_sft_jsonl(build.validation_file)
 
         upload_url = f"{backend_base}/learning/files"
-        click.echo(f"Uploading dataset {build.train_file}")
-        if dry_run:
-            click.echo("Dry run: skipping upload")
-            train_file_id = "dry-run-train"
-            val_file_id = None
-        else:
-            resp = post_multipart(upload_url, api_key=synth_key, file_field="file", file_path=build.train_file)
-            js = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
-            if resp.status_code >= 400 or "id" not in js:
-                raise click.ClickException(f"Training file upload failed ({resp.status_code}): {js or resp.text[:200]}")
-            train_file_id = js["id"]
-            val_file_id = None
-            if build.validation_file:
-                click.echo(f"Uploading validation dataset {build.validation_file}")
-                vresp = post_multipart(upload_url, api_key=synth_key, file_field="file", file_path=build.validation_file)
-                vjs = vresp.json() if vresp.headers.get("content-type", "").startswith("application/json") else {}
-                if vresp.status_code < 400 and "id" in vjs:
-                    val_file_id = vjs["id"]
-                else:
-                    click.echo(f"[WARN] Validation upload failed: {vresp.status_code} {vjs or vresp.text[:200]}")
+        click.echo("\n=== Uploading Training Data ===")
+        click.echo(f"Dataset: {build.train_file}")
+        click.echo(f"Destination: {upload_url}")
+        resp = post_multipart(
+            upload_url, api_key=synth_key, file_field="file", file_path=build.train_file
+        )
+        js = (
+            resp.json()
+            if resp.headers.get("content-type", "").startswith("application/json")
+            else {}
+        )
+        if resp.status_code is not None and resp.status_code >= 400 or "id" not in js:
+            click.echo("\n[ERROR] Training file upload failed:")
+            click.echo(f"  URL: {upload_url}")
+            click.echo(f"  Status: {resp.status_code}")
+            click.echo(f"  Response: {js or resp.text[:400]}")
+            click.echo(f"  File: {build.train_file}")
+            raise click.ClickException(
+                f"Training file upload failed with status {resp.status_code}"
+            )
+        train_file_id = js["id"]
+        click.echo(f"✓ Training file uploaded (id={train_file_id})")
+        val_file_id = None
+        if build.validation_file:
+            click.echo(f"Uploading validation dataset: {build.validation_file}")
+            vresp = post_multipart(
+                upload_url,
+                api_key=synth_key,
+                file_field="file",
+                file_path=build.validation_file,
+            )
+            vjs = (
+                vresp.json()
+                if vresp.headers.get("content-type", "").startswith("application/json")
+                else {}
+            )
+            if vresp.status_code is not None and vresp.status_code < 400 and "id" in vjs:
+                val_file_id = vjs["id"]
+                click.echo(f"✓ Validation file uploaded (id={val_file_id})")
+            else:
+                click.echo(
+                    f"[WARN] Validation upload failed ({vresp.status_code}): {vjs or vresp.text[:200]}"
+                )
         payload = dict(build.payload)
         payload["training_file_id"] = train_file_id
         if val_file_id:
-            payload.setdefault("metadata", {}).setdefault("effective_config", {}).setdefault("data", {})["validation_files"] = [val_file_id]
+            payload.setdefault("metadata", {}).setdefault("effective_config", {}).setdefault(
+                "data", {}
+            )["validation_files"] = [val_file_id]
 
+        click.echo("\n=== Checking File Processing Status ===")
         try:
             _wait_for_training_file(backend_base, synth_key, train_file_id)
         except click.ClickException as exc:
             raise click.ClickException(f"Training file {train_file_id} not ready: {exc}") from exc
 
-        click.echo("FFT job payload:\n" + preview_json(payload, limit=800))
-        if dry_run:
-            click.echo("Dry run: skipping job submission")
-            return
+        click.echo("\n=== Creating Training Job ===")
+        click.echo("Job payload preview:")
+        click.echo(preview_json(payload, limit=800))
 
         create_url = f"{backend_base}/learning/jobs"
         headers = {"Authorization": f"Bearer {synth_key}", "Content-Type": "application/json"}
+        click.echo(f"\nPOST {create_url}")
         resp = http_post(create_url, headers=headers, json_body=payload)
-        js = resp.json() if resp.headers.get("content-type", "").startswith("application/json") else {}
-        click.echo(f"Response {resp.status_code}: {preview_json(js, limit=400)}")
+        js = (
+            resp.json()
+            if resp.headers.get("content-type", "").startswith("application/json")
+            else {}
+        )
         if resp.status_code not in (200, 201):
-            raise click.ClickException("Failed to create learning job")
+            click.echo("\n[ERROR] Job creation failed:")
+            click.echo(f"  URL: {create_url}")
+            click.echo(f"  Status: {resp.status_code}")
+            click.echo(f"  Response: {preview_json(js, limit=600)}")
+            raise click.ClickException(f"Job creation failed with status {resp.status_code}")
         job_id = js.get("job_id") or js.get("id")
         if not job_id:
             raise click.ClickException("Response missing job id")
+        click.echo(f"✓ Job created (id={job_id})")
 
+        click.echo("\n=== Starting Training Job ===")
         start_url = f"{backend_base}/learning/jobs/{job_id}/start"
-        click.echo(f"POST {start_url} (start)")
-        _ = http_post(start_url, headers=headers, json_body={})
+        click.echo(f"POST {start_url}")
+        start_resp = http_post(start_url, headers=headers, json_body={})
+        if start_resp.status_code not in (200, 201):
+            click.echo(f"[WARN] Job start returned status {start_resp.status_code}")
+        else:
+            click.echo("✓ Job started")
 
         if not poll:
             click.echo(f"Started job {job_id} (polling disabled)")

synth_ai/api/train/config_finder.py

@@ -1,14 +1,17 @@
 from __future__ import annotations
 
+import json
+import os
+from collections.abc import Iterable
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Iterable
 
 import click
 
 from .utils import REPO_ROOT, load_toml, preview_json
 
 _SKIP_DIRS = {".git", "__pycache__", ".venv", "node_modules", "dist", "build"}
+_STATE_FILE = os.path.expanduser("~/.synth-ai/demo.json")
 
 
 @dataclass(slots=True)
@@ -17,9 +20,43 @@ class ConfigCandidate:
     train_type: str  # "rl", "sft", or "unknown"
 
 
+def _load_last_config() -> Path | None:
+    """Load the last used training config path from state file."""
+    try:
+        if os.path.isfile(_STATE_FILE):
+            with open(_STATE_FILE) as fh:
+                data = json.load(fh)
+                if isinstance(data, dict):
+                    last_config = data.get("LAST_CONFIG")
+                    if last_config:
+                        path = Path(last_config).resolve()
+                        if path.exists():
+                            return path
+    except Exception:
+        pass
+    return None
+
+
+def _save_last_config(config_path: Path) -> None:
+    """Save the last used training config path to state file."""
+    try:
+        data = {}
+        if os.path.isfile(_STATE_FILE):
+            with open(_STATE_FILE) as fh:
+                data = json.load(fh) or {}
+        if not isinstance(data, dict):
+            data = {}
+        data["LAST_CONFIG"] = str(config_path.resolve())
+        os.makedirs(os.path.dirname(_STATE_FILE), exist_ok=True)
+        with open(_STATE_FILE, "w") as fh:
+            json.dump(data, fh)
+    except Exception:
+        pass
+
+
 def _iter_candidate_paths() -> Iterable[Path]:
     seen: set[Path] = set()
-    
+
     # Prioritize current working directory first
     try:
         cwd = Path.cwd().resolve()
@@ -135,23 +172,46 @@ def discover_configs(explicit: list[str], *, requested_type: str | None) -> list
     return candidates
 
 
-def prompt_for_config(candidates: list[ConfigCandidate], *, requested_type: str | None) -> ConfigCandidate:
+def prompt_for_config(
+    candidates: list[ConfigCandidate], *, requested_type: str | None, allow_autoselect: bool = False
+) -> ConfigCandidate:
     if not candidates:
         raise click.ClickException("No training configs found. Pass --config explicitly.")
 
+    # Check for last used config and move it to the top if found
+    last_config = _load_last_config()
+    default_idx = 1
+
+    if allow_autoselect and len(candidates) == 1:
+        chosen = candidates[0]
+        _save_last_config(chosen.path)
+        return chosen
+
+    if last_config:
+        for idx, cand in enumerate(candidates):
+            if cand.path.resolve() == last_config:
+                # Move last used config to the front
+                candidates.insert(0, candidates.pop(idx))
+                break
+
     click.echo("Select a training config:")
     for idx, cand in enumerate(candidates, start=1):
         label = cand.train_type if cand.train_type != "unknown" else "?"
-        click.echo(f"  {idx}) [{label}] {cand.path}")
+        last_marker = " (last used)" if last_config and cand.path.resolve() == last_config else ""
+        click.echo(f"  {idx}) [{label}] {cand.path}{last_marker}")
     click.echo("  0) Abort")
 
-    choice = click.prompt("Enter choice", type=int)
+    choice = click.prompt("Enter choice", type=int, default=default_idx)
     if choice == 0:
         raise click.ClickException("Aborted by user")
     if choice < 0 or choice > len(candidates):
         raise click.ClickException("Invalid selection")
 
     selection = candidates[choice - 1]
+
+    # Save this config as the last used
+    _save_last_config(selection.path)
+
     try:
         data = load_toml(selection.path)
         preview = preview_json({k: data.get(k) for k in list(data.keys())[:4]}, limit=320)

synth_ai/api/train/env_resolver.py

@@ -1,9 +1,9 @@
 from __future__ import annotations
 
 import os
+from collections.abc import Callable, Iterable, MutableMapping
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Callable, Iterable, MutableMapping
 
 import click
 
@@ -56,12 +56,12 @@ class EnvResolver:
 def _collect_default_candidates(config_path: Path | None) -> list[Path]:
     candidates: list[Path] = []
     cwd = Path.cwd()
-    
+
     # Prioritize CWD env files
     cwd_env = cwd / ".env"
     if cwd_env.exists():
         candidates.append(cwd_env.resolve())
-    
+
     # Search for additional .env files in CWD subdirectories
     for sub in cwd.glob("**/.env"):
         try:
@@ -76,13 +76,13 @@ def _collect_default_candidates(config_path: Path | None) -> list[Path]:
         if len(candidates) >= 20:
             break
         candidates.append(resolved)
-    
+
     # Then config path env file
     if config_path:
         cfg_env = config_path.parent / ".env"
         if cfg_env.exists():
             candidates.append(cfg_env.resolve())
-    
+
     # Then repo env files
     repo_env = REPO_ROOT / ".env"
     if repo_env.exists():
@@ -90,7 +90,7 @@ def _collect_default_candidates(config_path: Path | None) -> list[Path]:
     examples_env = REPO_ROOT / "examples" / ".env"
     if examples_env.exists():
         candidates.append(examples_env.resolve())
-    
+
     # Search shallow depth for additional .env files in examples
     for sub in (REPO_ROOT / "examples").glob("**/.env"):
         try:
@@ -105,7 +105,7 @@ def _collect_default_candidates(config_path: Path | None) -> list[Path]:
         if len(candidates) >= 20:
             break
         candidates.append(resolved)
-    
+
     deduped: list[Path] = []
     for path in candidates:
         if path not in deduped:
@@ -156,8 +156,27 @@ def resolve_env(
                 raise click.ClickException(f"Env file not found: {path}")
         resolver = EnvResolver(provided)
     else:
-        resolver = EnvResolver(_collect_default_candidates(config_path))
-        resolver.select_new_env()  # force user selection even if one candidate
+        # Check for saved .env path from demo command
+        try:
+            from synth_ai.demos.demo_task_apps.core import load_env_file_path
+
+            saved_env_path = load_env_file_path()
+            if saved_env_path:
+                saved_path = Path(saved_env_path)
+                if saved_path.exists():
+                    click.echo(f"Using .env file: {saved_path}")
+                    resolver = EnvResolver([saved_path])
+                else:
+                    # Saved path no longer exists, fall back to prompt
+                    resolver = EnvResolver(_collect_default_candidates(config_path))
+                    resolver.select_new_env()
+            else:
+                resolver = EnvResolver(_collect_default_candidates(config_path))
+                resolver.select_new_env()
+        except Exception:
+            # If import fails or any error, fall back to original behavior
+            resolver = EnvResolver(_collect_default_candidates(config_path))
+            resolver.select_new_env()
 
     # Preload selected .env keys into process env so downstream lookups succeed
     try:
@@ -207,10 +226,10 @@ def _resolve_key(resolver: EnvResolver, spec: KeySpec) -> str:
                     break
         if env_val:
             click.echo(f"Found {spec.name} in current sources: {mask_value(env_val)}")
-            if _prompt_yes_no(f"Use this value for {spec.name}?", default=True):
-                _maybe_persist(resolver, spec, env_val)
-                os.environ[spec.name] = env_val
-                return env_val
+            # Automatically use and persist the value (no prompt)
+            _maybe_persist(resolver, spec, env_val)
+            os.environ[spec.name] = env_val
+            return env_val
         options: list[tuple[str, Callable[[], str | None]]] = []
 
         def _enter_manual() -> str:
@@ -254,8 +273,7 @@ def _resolve_key(resolver: EnvResolver, spec: KeySpec) -> str:
 
 
 def _maybe_persist(resolver: EnvResolver, spec: KeySpec, value: str) -> None:
-    if not _prompt_yes_no(f"Save {spec.name} to {resolver.current_path}?", default=True):
-        return
+    # Automatically save (no prompt)
     resolver.set_value(spec.name, value)
     click.echo(f"Saved {spec.name} to {resolver.current_path}")