pal-code 0.1.0__tar.gz → 0.1.2__tar.gz

{pal_code-0.1.0 → pal_code-0.1.2}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Nandini Singh
+Copyright (c) 2026 Vrushal More
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

{pal_code-0.1.0 → pal_code-0.1.2}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: pal-code
-Version: 0.1.0
+Version: 0.1.2
 Summary: Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency.
-Author: Nandini Singh
+Author: Vrushal More
 License: MIT
 Keywords: ai,coding-assistant,cli,llm,ollama,tokens,code-graph
 Classifier: Development Status :: 4 - Beta

{pal_code-0.1.0 → pal_code-0.1.2}/pyproject.toml

@@ -4,12 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pal-code"
-version = "0.1.0"
+version = "0.1.2"
 description = "Pal: build and plan with AI in your terminal (pal cli) or browser (pal web), on a layer that cuts tokens and latency."
 readme = "README.md"
 requires-python = ">=3.10"
 license = { text = "MIT" }
-authors = [{ name = "Nandini Singh" }]
+authors = [{ name = "Vrushal More" }]
 keywords = ["ai", "coding-assistant", "cli", "llm", "ollama", "tokens", "code-graph"]
 classifiers = [
   "Development Status :: 4 - Beta",

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/__init__.py

@@ -13,7 +13,7 @@ def _version() -> str:
             return version(name)
         except PackageNotFoundError:
             continue
-    return "0.1.0"           # a source checkout that is not installed
+    return "0.1.2"           # a source checkout that is not installed
 
 
 __version__ = _version()

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/cli.py

@@ -212,7 +212,7 @@ def load_dotenv(path: str | os.PathLike | None = None, env=None) -> list[str]:
     return loaded
 
 
-def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None) -> int:
+def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph=None, documents: list | None = None, project_dir=None) -> int:
     from pal.chat import ChatService
     from pal.web import create_app
 
@@ -221,7 +221,7 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
     service = ChatService(settings, graph=graph) if graph is not None else ChatService(settings)
     if documents:
         service.preload_docs = list(documents)
-    app = create_app(service)
+    app = create_app(service, studio={"project_dir": project_dir}) if project_dir else create_app(service)
     if s.host not in _LOOPBACK:
         print(f"WARNING: listening on {s.host}. Pal has no login: anyone who can reach this port can use "
               "your API keys' quota and read stored memory. Put it behind an authenticating reverse proxy.",
@@ -239,6 +239,9 @@ def _serve(settings: Settings, open_browser: bool = False, page: str = "", graph
               "the app still works and sends everything to the API model.", file=sys.stderr)
     else:
         print(f"Local model: {status['detail']}")
+    import threading as _t
+    from pal.context_window import context_window
+    _t.Thread(target=lambda: context_window("openai", "gpt-4o"), daemon=True).start()   # loads LiteLLM's model list now, not on the first page load
     if open_browser:
         import threading
         import webbrowser

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/compression/components/__init__.py

@@ -16,37 +16,37 @@ TextMinifier itself can't be built for the same reason.
 
 try:
     from pal.compression.components.adverbs import Adverbs
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Adverbs = None
 
 try:
     from pal.compression.components.hedges import Hedges
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Hedges = None
 
 try:
     from pal.compression.components.interjections import Interjections
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Interjections = None
 
 try:
     from pal.compression.components.pleonasms import Pleonasms
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Pleonasms = None
 
 try:
     from pal.compression.components.punctuations import Punctuations
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Punctuations = None
 
 try:
     from pal.compression.components.stopwords import Stopwords
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Stopwords = None
 
 try:
     from pal.compression.components.minifier import TextMinifier
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     TextMinifier = None
 
 # No optional deps -- always available.

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/compression/utils/__init__.py

@@ -4,27 +4,27 @@ raise straight out of this package's __init__."""
 
 try:
     from pal.compression.utils.negations import Negations
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Negations = None
 
 try:
     from pal.compression.utils.nltk_setup import NltkSetup
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     NltkSetup = None
 
 try:
     from pal.compression.utils.proselint_setup import ProselintSetup
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     ProselintSetup = None
 
 try:
     from pal.compression.utils.pronouns import Pronouns
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     Pronouns = None
 
 try:
     from pal.compression.utils.spacy_setup import SpacySetup
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     SpacySetup = None
 
 __all__ = ["Negations", "NltkSetup", "ProselintSetup", "Pronouns", "SpacySetup"]

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/context_manager/utils/relevance.py

@@ -6,7 +6,7 @@ try:
     from sentence_transformers import SentenceTransformer
     _EMBEDDER = None
     _EMBED_AVAILABLE = True
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     _EMBED_AVAILABLE = False
 
 

pal_code-0.1.2/src/pal/context_window.py

@@ -0,0 +1,42 @@
+"""How many tokens a model can take in one request (its context window), for the "tokens left" counters in the terminal and the web page.
+
+API models: the size LiteLLM knows for the model, else a safe default. Local models: the context Pal gives Ollama (num_ctx), which is what
+really limits them here, whatever the model could do on paper."""
+from __future__ import annotations
+
+from functools import lru_cache
+
+LOCAL_CONTEXT = 8192            # Pal runs local models with num_ctx 8192 (pal.terminal.backend.make_core)
+API_DEFAULT = 128_000           # a model LiteLLM does not know: most current API models take at least this
+LOCAL_PROVIDERS = ("local", "ollama", "lmstudio", "vllm", "llamacpp", "llama.cpp", "huggingface")
+
+
+@lru_cache(maxsize=256)
+def context_window(provider: str, model: str) -> int:
+    provider = (provider or "").lower()
+    if provider in LOCAL_PROVIDERS:
+        return LOCAL_CONTEXT
+    if not model:
+        return API_DEFAULT
+    try:
+        import litellm
+        for name in (f"{provider}/{model}" if provider else model, model, model.split("/")[-1]):
+            try:
+                info = litellm.get_model_info(name)
+            except Exception:  # noqa: BLE001  (not in LiteLLM's table under this name)
+                continue
+            size = info.get("max_input_tokens") or info.get("max_tokens")
+            if size:
+                return int(size)
+    except Exception:  # noqa: BLE001  (LiteLLM missing or broken: the default)
+        pass
+    return API_DEFAULT
+
+
+def tokens_left(window: int, last_prompt: int) -> int:
+    """What is left of the window after the last request's input (the next one is usually at least as big)."""
+    return max(0, window - max(0, last_prompt))
+
+
+def short(n: int) -> str:
+    return f"{n / 1000:.1f}k".replace(".0k", "k") if n >= 10_000 else f"{n:,}"

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/local_llm/components/huggingface_local.py

@@ -68,7 +68,7 @@ class HuggingFaceLocalLLM(LLMWrapper):
         try:
             import torch
             from transformers import AutoModelForCausalLM, AutoTokenizer
-        except ImportError as e:
+        except (ImportError, OSError) as e:
             raise ImportError(
                 "transformers and torch are required for the in-process local "
                 "core. Run: pip install torch transformers"

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/storage_manager/components/vector_store_backend.py

@@ -19,7 +19,7 @@ log = logging.getLogger(__name__)
 try:
     import chromadb
     _CHROMADB_AVAILABLE = True
-except ImportError:
+except Exception:  # missing OR broken (e.g. a torch DLL error)
     _CHROMADB_AVAILABLE = False
 
 

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/studio/routes.py

@@ -49,7 +49,7 @@ def clean_references(raw) -> list[dict]:
 
 
 def register_studio(app, service, *, planner_core: Callable | None = None, core_factory: Callable | None = None, discover_fn: Callable | None = None,
-                    hot_turns: int | None = None) -> RunStore:
+                    hot_turns: int | None = None, project_dir: Path | None = None) -> RunStore:
     """Add the Studio page and endpoints to the app. The three callables are for tests: the planner's model, the builder's model, local-model discovery."""
     cfg = service.settings
     home = Path(cfg.storage_dir).expanduser() if cfg.storage_dir else data_dir()
@@ -71,7 +71,7 @@ def register_studio(app, service, *, planner_core: Callable | None = None, core_
             raise UserInputError("no local model is chosen: start Ollama and pull a model, or switch to an API model")
         return local_core(m["model"], num_ctx())
 
-    runs = RunStore(home / "studio", core_factory or default_core_factory, max_runs=cfg.studio.max_runs, hot_turns=hot_turns)
+    runs = RunStore(home / "studio", core_factory or default_core_factory, max_runs=cfg.studio.max_runs, hot_turns=hot_turns, project_dir=project_dir)
     app.extensions["studio_runs"] = runs
 
     def local() -> dict:

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/studio/runs.py

@@ -95,9 +95,22 @@ class Run:
         return self.arms[name]
 
 
+def build_target(project: Path, folder: str) -> Path:
+    """Where a build is written in the folder Pal was started in: the folder itself when it is empty, else a new subfolder named after the
+    product (with -2, -3 ... when that name is taken), so nothing that is already there is overwritten."""
+    project = Path(project)
+    if not any(p for p in project.iterdir() if not p.name.startswith(".")):
+        return project
+    target, n = project / folder, 2
+    while target.exists() and (not target.is_dir() or any(target.iterdir())):
+        target, n = project / f"{folder}-{n}", n + 1
+    return target
+
+
 class RunStore:
-    def __init__(self, root: Path, core_factory: Callable, max_runs: int = 6, hot_turns: int | None = None):
+    def __init__(self, root: Path, core_factory: Callable, max_runs: int = 6, hot_turns: int | None = None, project_dir: Path | None = None):
         self.root, self.core_factory, self.max_runs, self.hot_turns = Path(root), core_factory, max_runs, hot_turns
+        self.project_dir = Path(project_dir).resolve() if project_dir else None      # pal web's folder: the build is written there
         self._runs: dict[str, Run] = {}
         self._editors: dict[tuple[str, str], EditorSession] = {}
         self._lock = threading.Lock()
@@ -140,11 +153,17 @@ class RunStore:
                     break
                 policy = Policy(dict(plan["permissions"]))
                 save = plan["permissions"].get("write_project")
-                state = ArmState(arm, label, (self.root / run.id / arm / plan["product"]["folder"]) if save else None)
+                where = None
+                if save:
+                    where = (build_target(self.project_dir, plan["product"]["folder"]) if self.project_dir and arm != "baseline"
+                             else self.root / run.id / arm / plan["product"]["folder"])  # the plain client's comparison copy stays in Pal's folder
+                state = ArmState(arm, label, where)
                 run.arms[arm] = state
                 if state.workspace:
                     state.workspace.mkdir(parents=True, exist_ok=True)
                 run.emit("arm_start", f"{label}: starting" if twice else "Starting", arm=arm)
+                if state.workspace and self.project_dir and arm != "baseline":
+                    run.emit("saved_to", f"Files are written to {state.workspace}", arm=arm, path=str(state.workspace))
                 client: PlainClient | PalClient
                 if arm == "baseline":
                     client = PlainClient(core, SYSTEM)

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/terminal/bench.py

@@ -67,6 +67,7 @@ class BenchResult:
     plain: Arm
     pal: Arm
     when: float = field(default_factory=time.time)
+    pal_files: dict = field(default_factory=dict, repr=False)     # what Pal's way wrote: {path: bytes}, offered to keep in your folder
 
     @property
     def saved(self) -> int:
@@ -78,6 +79,7 @@ class BenchResult:
 
     def to_dict(self) -> dict:
         d = asdict(self)
+        d.pop("pal_files", None)
         d.update(saved=self.saved, saved_pct=self.saved_pct, plain_total=self.plain.total, pal_total=self.pal.total)
         return d
 
@@ -161,7 +163,12 @@ def run_bench(folder: Path, task: str, core_factory: Callable[[], Any], model: s
             pal_arm = _run_arm("pal", pal, steps, progress)
         finally:
             client.close()
-    result = BenchResult(task, model, str(folder), plain_arm, pal_arm)
+        kept = {}
+        for rel in sorted({f for st in pal_arm.steps for f in st.files}):
+            f = pal_dir / rel
+            if f.is_file():
+                kept[rel] = f.read_bytes()
+    result = BenchResult(task, model, str(folder), plain_arm, pal_arm, pal_files=kept)
     save(result, home)
     return result
 

{pal_code-0.1.0 → pal_code-0.1.2}/src/pal/terminal/cli.py

@@ -70,7 +70,7 @@ def build_parser() -> argparse.ArgumentParser:
     a.add_argument("--build", action="store_true", help="use the Build agent: it may propose file changes (asks before writing)")
     b = sub.add_parser("bench", help="run one task as a plain chat and through Pal, on the same model, and compare the real tokens")
     _common(b, suppress=True)
-    b.add_argument("task", nargs="+", help="what to build, as you would type it")
+    b.add_argument("task", nargs="*", help="what to build, as you would type it (leave it out to open the bench screen and type tasks there)")
     b.add_argument("--then", action="append", default=None, metavar="MESSAGE", help="a follow-up message (repeat for more; default: two standard ones)")
     b.add_argument("--no-follow-ups", action="store_true", help="only the task itself")
     b.add_argument("--json", action="store_true", help="print the result as JSON")
@@ -79,13 +79,17 @@ def build_parser() -> argparse.ArgumentParser:
     return p
 
 
-def bench(args) -> int:
-    """pal bench: the same task, plain chat versus Pal, on the same model."""
+def bench(args, core_factory: Callable | None = None) -> int:
+    """pal bench: the same task, plain chat versus Pal, on the same model. Without a task it opens the usual Pal screen (\"pal bench\"), and every
+    task typed there is run both ways, with the results as a table and bar charts."""
     import json as _json
 
-    from rich.table import Table
-
-    from pal.terminal.bench import run_bench
+    if not args.task:
+        if not (sys.stdin.isatty() and sys.stdout.isatty()):
+            print("pal bench: give a task, e.g.  pal bench \"make a todo app\"", file=sys.stderr)
+            return 2
+        args.bench_screen = True
+        return interactive(args, core_factory)
     console = ui.make_console()
     host = args.host or backend.DEFAULT_HOST
     prefs = backend.load_prefs()
@@ -103,17 +107,36 @@ def bench(args) -> int:
     except PalError as e:
         print(f"pal bench: {e}", file=sys.stderr)
         return 2
-    follow = [] if args.no_follow_ups else args.then
-    task = " ".join(args.task)
-    status = console.status(Text("Starting\u2026", style=theme.MUTED), spinner="dots", spinner_style=theme.RED)
-    with status:
-        result = run_bench(Path(args.dir), task, lambda: backend.make_core(provider, model, host), model, follow,
-                           progress=lambda m: status.update(Text(m, style=theme.MUTED)))
+    result = bench_run(console, Path(args.dir), " ".join(args.task), provider, model, host, [] if args.no_follow_ups else args.then)
     if args.json:
         print(_json.dumps(result.to_dict(), indent=1))
         return 0
-    ui.say(console, Text.assemble(("pal bench  ", f"bold {theme.WHITE}"), (f"{model} ({provider})  \u00B7  {ui.short_path(Path(args.dir).resolve())}", theme.MUTED)))
-    ui.say(console, Text(f"Task: {task}", style=theme.INK))
+    show_bench(console, result, provider, model, Path(args.dir))
+    return 0
+
+
+def bench_run(console, folder: Path, task: str, provider: str, model: str, host: str, follow=None, core_factory: Callable | None = None):
+    from pal.terminal.bench import run_bench
+    status = console.status(Text("Starting\u2026", style=theme.MUTED), spinner="dots", spinner_style=theme.RED)
+    with status:
+        return run_bench(folder, task, lambda: (core_factory or backend.make_core)(provider, model, host), model, follow,
+                         progress=lambda m: status.update(Text(m, style=theme.MUTED)))
+
+
+def bars(console, title: str, rows: list[tuple[str, float, str]], width: int = 46) -> None:
+    """A horizontal bar chart in the terminal: (label, value, shown value). Plain chat in grey, Pal in red."""
+    top = max((v for _, v, _ in rows), default=0) or 1
+    ui.say(console, Text(title, style=f"bold {theme.WHITE}"))
+    for label, value, shown in rows:
+        n = max(1, round(width * value / top)) if value > 0 else 0
+        colour = theme.RED if label.lower().startswith("pal") else theme.MUTED
+        ui.say(console, Text.assemble(("  " + f"{label:<11}", theme.INK), ("\u2588" * n, colour), (" " * (width - n + 2), ""), (shown, f"bold {theme.WHITE}")))
+
+
+def show_bench(console, result, provider: str, model: str, folder: Path) -> None:
+    from rich.table import Table
+    ui.say(console, Text.assemble(("pal bench  ", f"bold {theme.WHITE}"), (f"{model} ({provider})  \u00B7  {ui.short_path(Path(folder).resolve())}", theme.MUTED)))
+    ui.say(console, Text(f"Task: {result.task}", style=theme.INK))
     console.print()
     grid = Table(box=None, padding=(0, 2), header_style=f"bold {theme.WHITE}")
     for col, just in (("step", "left"), ("agent", "left"), ("plain chat", "right"), ("Pal", "right"), ("saved", "right")):
@@ -129,6 +152,13 @@ def bench(args) -> int:
                  Text(f"{result.saved:,} ({result.saved_pct:g}%)", style=f"bold {theme.RED_HI}"))
     ui.say(console, grid)
     console.print()
+    bars(console, "Tokens", [("plain chat", result.plain.total, f"{result.plain.total:,}"), ("Pal", result.pal.total, f"{result.pal.total:,}")])
+    console.print()
+    bars(console, "Time", [("plain chat", result.plain.seconds, f"{result.plain.seconds:g}s"), ("Pal", result.pal.seconds, f"{result.pal.seconds:g}s")])
+    console.print()
+    verdict = (f"Pal used {result.saved:,} fewer tokens ({result.saved_pct:g}% less)." if result.saved > 0 else
+               f"Pal used {-result.saved:,} more tokens on this task (it pays off with bigger projects, documents and longer conversations).")
+    ui.say(console, Text(verdict, style=f"bold {theme.RED_HI}"))
     for arm in (result.plain, result.pal):
         files = sorted({f for s in arm.steps for f in s.files})
         ui.say(console, Text(f"{arm.name:<6} {arm.seconds:g}s \u00B7 {arm.calls} model call{'s' if arm.calls != 1 else ''} \u00B7 wrote: {', '.join(files) or 'no files'}"
@@ -137,7 +167,28 @@ def bench(args) -> int:
     ui.say(console, Text("Token counts are the model's own." if not est else f"{est} call(s) had no token count from the model, so those are estimates (characters / 4).", style=theme.MUTED))
     ui.say(console, Text("Pal's local helper jobs are off in the bench, so its saving here comes from the project map, graph, documents and history alone.", style=theme.MUTED))
     console.print()
-    return 0
+
+
+def keep_bench_files(console, result, folder: Path) -> list[str]:
+    """Both ways build in temporary copies; offer to write Pal's version into the folder (asking first, never overwriting without saying so)."""
+    if not result.pal_files:
+        return []
+    folder = Path(folder).resolve()
+    clash = [p for p in result.pal_files if (folder / p).exists()]
+    question = f"Save Pal's version ({len(result.pal_files)} file{'s' if len(result.pal_files) != 1 else ''}) in {ui.short_path(folder)}?" + (
+        f" It replaces {len(clash)} existing file{'s' if len(clash) != 1 else ''}." if clash else "")
+    if not ui.confirm(console, question):
+        return []
+    written = []
+    for rel, data in result.pal_files.items():
+        target = (folder / rel).resolve()
+        if folder not in target.parents:
+            continue                                           # never outside the folder
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_bytes(data)
+        written.append(rel)
+    ui.say(console, Text(f"Saved: {', '.join(written)}", style=theme.INK))
+    return written
 
 
 def setup(args) -> int:
@@ -165,7 +216,7 @@ def first_run() -> None:
         console.print()
 
 
-def prepare_folder(args, console, core_factory: Callable | None = None) -> tuple[str, Project | None]:
+def prepare_folder(args, console, core_factory: Callable | None = None, choose: bool = True) -> tuple[str, Project | None]:
     """Before a session: get local models ready (install and start Ollama, download the models for this GPU, asking first), then set up the
     folder: documents to markdown, the project map, the code graph (in the background). Returns (a line about the local model, the Project)."""
     from pal.terminal.project import Project
@@ -173,7 +224,7 @@ def prepare_folder(args, console, core_factory: Callable | None = None) -> tuple
     local = ""
     if core_factory is None:
         tty = sys.stdin.isatty() and sys.stdout.isatty()
-        local = ensure_local(console, backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=tty).detail
+        local = ensure_local(console, backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=tty, choose=choose).detail
     folder = Path(getattr(args, "dir", ".") or ".")
     if os.environ.get("PAL_SKIP_PROJECT"):
         return local, None
@@ -217,7 +268,7 @@ def web(args) -> int:
         from pal.terminal.project import ProjectGraph
         graph = ProjectGraph(project.root / "graph", settings.knowledge_graph)
     return _serve(settings, open_browser=not args.no_open, page="studio" if args.page == "studio" else "", graph=graph,
-                  documents=project.documents() if project is not None else None)
+                  documents=project.documents() if project is not None else None, project_dir=Path(getattr(args, "dir", ".") or ".").resolve())
 
 
 def _utf8() -> None:
@@ -488,6 +539,14 @@ def handle(line: str, args, session: PalSession, console, core_factory, box: dic
         return session, True
     if cmd == "/help":
         ui.show_help(console)
+    elif cmd == "/agent":
+        from pal.terminal.setup import choose_agent
+        mode = rest if rest in MODES else choose_agent(console, current=session.mode)
+        if mode:
+            session.mode = mode
+            backend.save_prefs(mode=mode)
+            ui.say(console, Text(f"Agent: {mode.capitalize()} ({AGENT_ABOUT[mode]})", style=theme.MUTED))
+        console.print()
     elif cmd == "/mode":
         if rest in MODES:
             session.mode = rest
@@ -707,13 +766,37 @@ def voice_flow(console) -> str:
     return heard.text
 
 
+def choosing(args, core_factory: Callable | None = None) -> bool:
+    """pal cli asks for its models at every start (nothing preselected), unless they were given on the command line or this is not a terminal."""
+    return (core_factory is None and not args.provider and not args.model and sys.stdin.isatty() and sys.stdout.isatty()
+            and not os.environ.get("PAL_SKIP_SETUP") and not api_only(backend.hardware()))
+
+
+def ensure_ready_line(args) -> str:
+    """The local-model line again, after the models were chosen (and maybe downloaded)."""
+    from pal.terminal.setup import ensure_local
+    return ensure_local(ui.make_console(), backend.hardware(), args.host or backend.DEFAULT_HOST, interactive=False, choose=False).detail
+
+
 def interactive(args, core_factory: Callable | None = None) -> int:
     console = ui.make_console()
-    local, project = prepare_folder(args, console, core_factory)
+    ask = choosing(args, core_factory)
+    local, project = prepare_folder(args, console, core_factory, choose=not ask)
+    if ask:
+        from pal.terminal.setup import choose_models
+        console.print()
+        if not choose_models(console, backend.hardware(), args.host or backend.DEFAULT_HOST):
+            console.print(Text("\nNo model chosen. Run  pal cli  again to choose one.\n", style=theme.MUTED))
+            return 1
+        if not args.mode:
+            from pal.terminal.setup import choose_agent
+            args.mode = choose_agent(console) or None
+        local = ensure_ready_line(args)
     session = start(args, core_factory, project)
     if session is None:
         return 1
     session.local_status = local
+    session.brand = "bench" if getattr(args, "bench_screen", False) else "cli"
     if project is not None:
         ui.show_project(console, session)
         console.print()
@@ -753,6 +836,14 @@ def interactive(args, core_factory: Callable | None = None) -> int:
                     session, go = handle(text, args, session, console, core_factory, box)
                     if not go:
                         break
+                elif text and getattr(args, "bench_screen", False):     # pal bench: the task both ways, then the comparison
+                    host = args.host or backend.DEFAULT_HOST
+                    try:
+                        result = bench_run(console, session.cwd, text, session.provider, session.model, host, core_factory=core_factory)
+                        show_bench(console, result, session.provider, session.model, session.cwd)
+                        keep_bench_files(console, result, session.cwd)
+                    except PalError as e:
+                        ui.say(console, Text(f"The bench stopped: {e}", style=theme.RED_HI))
                 elif text:
                     flow_cli.run_turn(box["wf"], text, console)
             except KeyboardInterrupt:                     # Esc or Ctrl+C at an awkward moment: back to the box, never out of Pal
@@ -813,7 +904,7 @@ def main(argv: Sequence[str] | None = None, core_factory: Callable | None = None
     if args.cmd == "setup":
         return setup(args)
     if args.cmd == "bench":
-        return bench(args)
+        return bench(args, core_factory)
     if args.cmd == "ask":
         return ask_once(args, core_factory)
     if not (sys.stdin.isatty() and sys.stdout.isatty()) and core_factory is None: