hx-cli 0.2.8__tar.gz → 0.2.10__tar.gz

{hx_cli-0.2.8 → hx_cli-0.2.10}/CHANGELOG.md

@@ -28,6 +28,39 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.10] - 2026-09-29
+
+### Fixed
+
+- `AGENTS.md` at the repository root now applies when HX is started in a
+  subdirectory, followed by each `AGENTS.md` down to that directory.
+- Subagents started with `Task` now follow `~/.hx/AGENTS.md` and the project's
+  `AGENTS.md`, as the main session does.
+- A saved `/effort` level shows on the status bar from the first screen of every
+  new session, not only after `/effort` is run again.
+- `ctrl+l` switches the model and saves it for later sessions, as `/model` does;
+  it used to relabel the status bar only.
+- `/model`, `ctrl+l` and `/effort` open with the cursor on the choice in force.
+
+---
+
+## [0.2.9] - 2026-09-27
+
+### Added
+
+- `~/.hx/AGENTS.md` holds your own instructions and is loaded into every
+  session in every project, ahead of the project's `AGENTS.md`. The first
+  session creates it empty, ready to fill in. `hx prompt` and `/prompt` now
+  name each `AGENTS.md` in force, and `/prompt` says when one has changed on
+  disk since the session started.
+
+### Fixed
+
+- An `AGENTS.md` or system-prompt override that is not valid UTF-8 is skipped
+  like an unreadable one, instead of stopping HX from starting.
+
+---
+
 ## [0.2.8] - 2026-09-27
 
 ### Changed
@@ -725,7 +758,9 @@ First release, published to PyPI as [`hx-cli`](https://pypi.org/project/hx-cli/)
 - `/configure` and `hx auth` for the OpenRouter key, `hx upgrade` for
   self-update, and `install.sh` bootstrapping uv with a pinned Python.
 
-[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.8...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.10...HEAD
+[0.2.10]: https://github.com/aletisunil/hx/compare/v0.2.9...v0.2.10
+[0.2.9]: https://github.com/aletisunil/hx/compare/v0.2.8...v0.2.9
 [0.2.8]: https://github.com/aletisunil/hx/compare/v0.2.7...v0.2.8
 [0.2.7]: https://github.com/aletisunil/hx/compare/v0.2.6...v0.2.7
 [0.2.6]: https://github.com/aletisunil/hx/compare/v0.2.5...v0.2.6

{hx_cli-0.2.8 → hx_cli-0.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.8
+Version: 0.2.10
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev
@@ -753,6 +753,7 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 | `~/.hx/keybindings.json` | your key overrides |
 | `~/.hx/system-prompt.md` | your system prompt, replacing the built-in one |
 | `~/.hx/system-prompt-append.md` | text appended to whichever prompt is in force |
+| `~/.hx/AGENTS.md` | your instructions, loaded into every session in every project; created empty |
 | `~/.hx/sessions/` | transcripts, spilled tool output, subagent sessions |
 | `~/.hx/sessions/<id>/trace.html` | where `/trace` writes, unless you name a path |
 | `~/.hx/skills/`, `~/.hx/agents/` | your skills and agents |
@@ -761,12 +762,25 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 | `./.hx/mcp.json` | project MCP servers |
 | `./.hx/system-prompt.md`, `./.hx/system-prompt-append.md` | project prompt overrides |
 | `./.hx/skills/`, `./.hx/agents/` | project skills and agents |
-| `./AGENTS.md` | project instructions, loaded into every session |
+| `AGENTS.md` | project instructions: the repository root's, then each one down to where HX started |
 
 `AGENTS.md` is the place for things a newcomer would get wrong: how to run the
 tests, conventions, what not to touch. `/init` writes a first draft. It is
 loaded once per session and frozen, so it costs one prefix, not one per turn.
 
+`~/.hx/AGENTS.md` is the same thing for you rather than the project: how you
+like commits written, tools you always want used, in every repository. It is
+loaded first and the project's `AGENTS.md` after it, so where the two disagree
+the project has the last word. The first session creates it empty, ready to
+fill in; empty, it adds nothing. `hx prompt` and `/prompt` list each one in force.
+
+Started below the repository root - in `services/billing`, say - HX still loads
+the root's `AGENTS.md`, then every `AGENTS.md` on the way down to that directory,
+the nearest last, so a package can refine the repository's rules. A submodule
+counts as part of the repository around it. Nothing above the repository root is
+read; outside a repository only the current directory is.
+Subagents run under the same files as the session that started them.
+
 ---
 
 ## Safety

{hx_cli-0.2.8 → hx_cli-0.2.10}/README.md

@@ -713,6 +713,7 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 | `~/.hx/keybindings.json` | your key overrides |
 | `~/.hx/system-prompt.md` | your system prompt, replacing the built-in one |
 | `~/.hx/system-prompt-append.md` | text appended to whichever prompt is in force |
+| `~/.hx/AGENTS.md` | your instructions, loaded into every session in every project; created empty |
 | `~/.hx/sessions/` | transcripts, spilled tool output, subagent sessions |
 | `~/.hx/sessions/<id>/trace.html` | where `/trace` writes, unless you name a path |
 | `~/.hx/skills/`, `~/.hx/agents/` | your skills and agents |
@@ -721,12 +722,25 @@ files load here unchanged. `src/hx/tui/themes/dark.json` is the reference.
 | `./.hx/mcp.json` | project MCP servers |
 | `./.hx/system-prompt.md`, `./.hx/system-prompt-append.md` | project prompt overrides |
 | `./.hx/skills/`, `./.hx/agents/` | project skills and agents |
-| `./AGENTS.md` | project instructions, loaded into every session |
+| `AGENTS.md` | project instructions: the repository root's, then each one down to where HX started |
 
 `AGENTS.md` is the place for things a newcomer would get wrong: how to run the
 tests, conventions, what not to touch. `/init` writes a first draft. It is
 loaded once per session and frozen, so it costs one prefix, not one per turn.
 
+`~/.hx/AGENTS.md` is the same thing for you rather than the project: how you
+like commits written, tools you always want used, in every repository. It is
+loaded first and the project's `AGENTS.md` after it, so where the two disagree
+the project has the last word. The first session creates it empty, ready to
+fill in; empty, it adds nothing. `hx prompt` and `/prompt` list each one in force.
+
+Started below the repository root - in `services/billing`, say - HX still loads
+the root's `AGENTS.md`, then every `AGENTS.md` on the way down to that directory,
+the nearest last, so a package can refine the repository's rules. A submodule
+counts as part of the repository around it. Nothing above the repository root is
+read; outside a repository only the current directory is.
+Subagents run under the same files as the session that started them.
+
 ---
 
 ## Safety

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/__init__.py

@@ -1,5 +1,5 @@
 """HX - an agent harness for the terminal."""
 
-__version__ = "0.2.8"
+__version__ = "0.2.10"
 
 __all__ = ["__version__"]

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/agents/subagent.py

@@ -59,6 +59,7 @@ class SubagentRunner:
         parent_session_id: str | None = None,
         parent_usage: object | None = None,
         hooks: HookEngine | None = None,
+        project_context: str | None = None,
     ) -> None:
         self.definitions = definitions
         self.provider = provider
@@ -72,6 +73,10 @@ class SubagentRunner:
         self.hooks = hooks
         """Shared with the parent: a hook that guards Bash must guard a subagent's
         Bash too, or the guard is one delegation away from being bypassed."""
+        self.project_context = project_context
+        """The parent's project preamble, AGENTS.md included. A subagent edits the
+        same project under the same rules; without it "never add unit tests" is
+        one delegation away from being ignored."""
         self._active: dict[str, str] = {}
 
     async def run(self, agent_type: str, prompt: str, description: str) -> SubagentResult:
@@ -160,6 +165,7 @@ class SubagentRunner:
             bus=self.bus,
             settings=self.settings,
             model_info=self.models.get_or_default(model) if self.models else None,
+            project_context=self.project_context,
             hooks=self.hooks,
         )
         loop.origin = f"{definition.name} subagent"

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/cli.py

@@ -346,7 +346,12 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
     from hx.config import load_settings
     from hx.core.checkpoints import CheckpointStore
     from hx.core.compaction import Compactor
-    from hx.core.context import ContextBuilder, build_project_context, load_system_prompt
+    from hx.core.context import (
+        ContextBuilder,
+        build_project_context,
+        load_instructions,
+        load_system_prompt,
+    )
     from hx.core.events import EventBus
     from hx.core.lateinject import Injection, InjectionRegistry
     from hx.core.loop import AgentLoop
@@ -430,6 +435,8 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
         settings.cwd,
         keep_recent_turns=settings.context.keep_recent_turns,
     )
+    instructions = load_instructions(settings.cwd)
+    project_context = build_project_context(settings.cwd, instructions)
 
     checkpoints = CheckpointStore(session, session_checkpoints_dir(session.meta.session_id))
     tools = build_default_registry(shell, jobs, tracker, todos, bus_holder, auth, checkpoints)
@@ -458,6 +465,7 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
         parent_session_id=session.meta.session_id,
         parent_usage=session.usage,
         hooks=hooks,
+        project_context=project_context,
     )
     tools.register(TaskTool(subagents))
 
@@ -478,7 +486,8 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
         settings=settings,
         model_info=model_info,
         skills_index=build_index(list(skills.values())) or None,
-        project_context=build_project_context(settings.cwd),
+        project_context=project_context,
+        instructions=instructions,
         hooks=hooks,
     )
 
@@ -842,15 +851,17 @@ def run_print_command(parsed: ParsedArgs) -> int:
 def run_prompt_command(parsed: ParsedArgs) -> int:
     """``hx prompt`` - print the system prompt this directory resolves to.
 
-    The prompt goes to stdout so it can be piped or diffed; where it came from
-    goes to stderr so it never contaminates that output.
+    The prompt goes to stdout so it can be piped or diffed; where it came from,
+    and which AGENTS.md files ride alongside it, goes to stderr so it never
+    contaminates that output.
     """
     from hx.config import load_settings
-    from hx.core.context import resolve_system_prompt
+    from hx.core.context import load_instructions, resolve_system_prompt
 
     try:
         settings = load_settings(parsed.cwd, parsed.overrides)
         resolved = resolve_system_prompt(settings.cwd, settings.prompt)
+        instructions = load_instructions(settings.cwd)
     except Exception as exc:
         return _report(exc)
 
@@ -858,6 +869,8 @@ def run_prompt_command(parsed: ParsedArgs) -> int:
     print(f"[source] {resolved.source}", file=sys.stderr)
     for append in resolved.appends:
         print(f"[append] {append}", file=sys.stderr)
+    for loaded in instructions:
+        print(f"[instructions] {loaded.path}", file=sys.stderr)
     return 0
 
 

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/core/context.py

@@ -10,7 +10,8 @@ Layout, in order::
     [1] system prompt          static for the session
     [2] tool schemas           deterministic sort: builtins, then mcp__* alphabetical
     [3] skills index           name + description only (progressive disclosure)
-    [4] project context        AGENTS.md, cwd, git branch, top-level listing
+    [4] project context        cwd, git branch, top-level listing, ~/.hx/AGENTS.md,
+                               each AGENTS.md from the repository root down to cwd
     --- breakpoint A (static) ---
     [5] conversation history
     --- breakpoint B (rolling, before the last few turns) ---
@@ -238,11 +239,63 @@ def _message_text(message: Message) -> str:
     return "\n".join(parts)
 
 
-def build_project_context(cwd: Path) -> str:
-    """Static per-session project preamble: AGENTS.md contents, cwd, git branch, listing.
+@dataclass(slots=True)
+class Instructions:
+    """One AGENTS.md in force: what it is, where it lives, what it says."""
+
+    heading: str
+    path: Path
+    text: str
+
+
+def load_instructions(cwd: Path) -> list[Instructions]:
+    """Every AGENTS.md in force, least specific first.
+
+    ``~/.hx/AGENTS.md`` follows the user into every project; then each
+    ``AGENTS.md`` from the repository root down to ``cwd``. Where two disagree
+    the more specific one comes later and has the last word. A blank or
+    unreadable file is skipped, and a path reached twice - running from inside
+    ``$HX_HOME``, say - is loaded once.
+    """
+    from hx.paths import project_instructions_files, project_root, tilde, user_instructions_file
+
+    user = user_instructions_file()
+    here = cwd.resolve()
+    root = project_root(here)
+    base = root or here
+    candidates = [(f"User instructions ({tilde(user)})", user)]
+    for path in project_instructions_files(here, root):
+        where = path.relative_to(base).as_posix()
+        candidates.append((f"Project instructions ({where})", path))
+
+    found: list[Instructions] = []
+    seen: set[Path] = set()
+    for heading, path in candidates:
+        body = _read_prompt_file(path)
+        if not body or path.resolve() in seen:
+            continue
+        seen.add(path.resolve())
+        found.append(Instructions(heading, path, body))
+    return found
+
+
+INSTRUCTIONS_PREAMBLE = (
+    "The sections below are AGENTS.md files: standing instructions from the user "
+    "and this project, already loaded in full - there is no need to read them "
+    "again. Follow them over your own defaults and habits. Where two disagree, "
+    "the later, more specific one wins."
+)
+"""Said once, ahead of the files. Without it a rule like "no unit tests" reads
+as background next to a request to make something "well covered", and the
+model re-reads the file it was already given to find out whether it counts."""
+
+
+def build_project_context(cwd: Path, instructions: list[Instructions] | None = None) -> str:
+    """Static per-session project preamble: cwd, git branch, listing, AGENTS.md contents.
 
     Computed once at startup and then frozen - refreshing it mid-session would
-    invalidate the prefix.
+    invalidate the prefix. Pass ``instructions`` to fold in the AGENTS.md files
+    already loaded, so the caller can remember exactly which ones are in force.
     """
     lines = [f"Working directory: {cwd}"]
 
@@ -256,9 +309,11 @@ def build_project_context(cwd: Path) -> str:
     if entries:
         lines.append("Top level: " + ", ".join(entries[:60]))
 
-    agents_md = cwd / "AGENTS.md"
-    if agents_md.is_file():
-        lines.append(f"\n# Project instructions (AGENTS.md)\n\n{agents_md.read_text()}")
+    loaded = load_instructions(cwd) if instructions is None else instructions
+    if loaded:
+        lines.append(f"\n{INSTRUCTIONS_PREAMBLE}")
+    for entry in loaded:
+        lines.append(f"\n# {entry.heading}\n\n{entry.text}")
 
     return "\n".join(lines)
 
@@ -367,12 +422,12 @@ def resolve_system_prompt(cwd: Path, prompt: PromptSettings | None = None) -> Re
 def _read_prompt_file(path: Path) -> str:
     """Contents of a prompt override file, or ``""`` when it is absent or empty.
 
-    An unreadable file is treated as absent: a permissions problem on an
-    optional override must not stop the session from starting.
+    An unreadable file - no permission, or not UTF-8 - is treated as absent: a
+    problem with an optional override must not stop the session from starting.
     """
     try:
-        return path.read_text().strip() if path.is_file() else ""
-    except OSError:
+        return path.read_text(encoding="utf-8").strip() if path.is_file() else ""
+    except (OSError, UnicodeDecodeError):
         return ""
 
 

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/core/loop.py

@@ -18,7 +18,7 @@ import time
 from dataclasses import dataclass, replace
 from typing import TYPE_CHECKING, Any, ClassVar
 
-from hx.core.context import AssembledContext
+from hx.core.context import AssembledContext, Instructions
 from hx.core.events import (
     CompactionFinished,
     CompactionStarted,
@@ -103,6 +103,7 @@ class AgentLoop:
         active_skills: ActiveSkills | None = None,
         skills_index: str | None = None,
         project_context: str | None = None,
+        instructions: list[Instructions] | None = None,
         hooks: HookEngine | None = None,
     ) -> None:
         self.provider = provider
@@ -118,6 +119,8 @@ class AgentLoop:
         self.active_skills = active_skills
         self.skills_index = skills_index
         self.project_context = project_context
+        self.instructions = instructions or []
+        """The AGENTS.md files folded into ``project_context``, least specific first."""
         self.hooks = hooks
         self._cancelled = False
         self._turn_index = 0

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/paths.py

@@ -30,6 +30,20 @@ def user_home() -> Path:
     return Path(override).expanduser() if override else Path.home() / ".hx"
 
 
+def tilde(path: str | Path) -> str:
+    """``path`` with the home directory written as ``~``.
+
+    Compared as text, not resolved: a session records the path it resolved
+    when it was made, and the directory may be gone by the time it is drawn.
+    """
+    text, home = str(path), str(Path.home())
+    if text == home:
+        return "~"
+    if text.startswith(home.rstrip("/") + "/"):
+        return "~" + text[len(home.rstrip("/")) :]
+    return text
+
+
 def user_settings_file() -> Path:
     return user_home() / "settings.json"
 
@@ -198,7 +212,69 @@ def project_system_prompt_append_file(cwd: Path | None = None) -> Path:
     return project_dir(cwd) / "system-prompt-append.md"
 
 
+def user_instructions_file() -> Path:
+    """Your ``AGENTS.md``: instructions that follow you into every project."""
+    return user_home() / "AGENTS.md"
+
+
+def project_root(cwd: Path | None = None) -> Path | None:
+    """The repository ``cwd`` sits in: the nearest directory holding ``.git``.
+
+    ``.git`` is a directory in a clone and a file in a worktree or submodule.
+    A submodule is part of the repository around it, so the walk carries on
+    past one to the superproject. ``None`` outside a repository.
+    """
+    start = (cwd or Path.cwd()).resolve()
+    submodule: Path | None = None
+    for directory in (start, *start.parents):
+        marker = directory / ".git"
+        if marker.is_dir() or (marker.is_file() and not _is_submodule(marker)):
+            return directory
+        if marker.is_file() and submodule is None:
+            submodule = directory
+    return submodule
+
+
+def _is_submodule(marker: Path) -> bool:
+    """Whether a ``.git`` file points into a superproject's ``.git/modules``."""
+    try:
+        text = marker.read_text(encoding="utf-8", errors="replace")
+    except OSError:
+        return False
+    return text.startswith("gitdir:") and "/modules/" in text.replace("\\", "/")
+
+
+def project_instructions_files(cwd: Path, root: Path | None) -> list[Path]:
+    """Every ``AGENTS.md`` that governs ``cwd``, least specific first.
+
+    From the repository root down to ``cwd``, one candidate per directory, so
+    starting HX in ``src/app`` still finds the root's file - and ``src/app``'s
+    own, which comes last and so has the last word. Outside a repository only
+    ``cwd`` itself is looked at: walking up from an arbitrary directory would
+    pick up whatever happens to sit in its parents.
+
+    ``root`` is :func:`project_root` of ``cwd``, passed in because the caller
+    needs it too and finding it walks the file system.
+    """
+    here = cwd.resolve()
+    if root is None:
+        return [here / "AGENTS.md"]
+    chain = [here, *here.parents]
+    return [directory / "AGENTS.md" for directory in reversed(chain[: chain.index(root) + 1])]
+
+
 def ensure_user_dirs() -> None:
-    """Create the user-level directory skeleton if it does not exist."""
+    """Create the user-level skeleton if it does not exist.
+
+    That includes an empty ``AGENTS.md``, so there is a file to find and fill
+    in; empty, it adds nothing to the prompt. An existing one - including a
+    symlink, dangling or not - is never touched, and failing to create it never
+    stops a session: the file is optional.
+    """
     for path in (user_home(), sessions_dir(), user_skills_dir(), user_agents_dir(), logs_dir()):
         path.mkdir(parents=True, exist_ok=True)
+    try:
+        with user_instructions_file().open("x"):
+            pass
+    except OSError:
+        pass

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/tui/commands.py

@@ -107,7 +107,10 @@ async def cmd_model(ctx: CommandContext, args: str) -> None:
     from hx.providers.models import ModelRegistry
     from hx.tui.views.pickers import ModelPicker
 
-    registry: ModelRegistry = ctx.app.models
+    registry: ModelRegistry | None = ctx.app.models
+    if registry is None:
+        ctx.app.notice("No model registry is loaded.", "warning")
+        return
     models = _reachable(ctx, registry.all())
     if not models:
         # A recorded failure replaces the remedy rather than trailing it:
@@ -507,7 +510,7 @@ async def cmd_title(ctx: CommandContext, args: str) -> None:
 
 async def cmd_prompt(ctx: CommandContext, args: str) -> None:
     """``/prompt`` - the system prompt this session is actually running with."""
-    from hx.core.context import resolve_system_prompt
+    from hx.core.context import load_instructions, resolve_system_prompt
 
     in_use = ctx.app.loop.context.system_prompt
     lines = [in_use.rstrip()]
@@ -516,10 +519,15 @@ async def cmd_prompt(ctx: CommandContext, args: str) -> None:
     lines.append(f"\nSource: {resolved.source}")
     for append in resolved.appends:
         lines.append(f"Appended: {append}")
+    in_force = ctx.app.loop.instructions
+    for loaded in in_force:
+        lines.append(f"Instructions: {loaded.path}")
+    # The prompt and AGENTS.md are read once at startup to keep the cache prefix
+    # stable, so an edit since then is real but not yet in force.
     if resolved.text.strip() != in_use.strip():
-        # The prompt is read once at startup to keep the cache prefix stable, so
-        # an override edited since then is real but not yet in force.
         lines.append("An override has changed on disk since startup; it applies next run.")
+    if load_instructions(ctx.settings.cwd) != in_force:
+        lines.append("An AGENTS.md has changed on disk since startup; it applies next run.")
     ctx.app.notice("\n".join(lines))
 
 
@@ -741,8 +749,7 @@ async def cmd_permissions(ctx: CommandContext, args: str) -> None:
         lines.append("")
         lines.append('No rules configured. Add them under "permissions" in .hx/settings.json.')
 
-    from hx.paths import project_local_settings_file
-    from hx.tui.format import tilde
+    from hx.paths import project_local_settings_file, tilde
 
     # Where, and why there: a grant is machine-local, so it is kept per project
     # under the user's home instead of being dropped into the checkout.
@@ -776,7 +783,9 @@ async def cmd_mode(ctx: CommandContext, args: str) -> None:
 
 
 INIT_PROMPT = """\
-Write an AGENTS.md for this project, at its root.
+Write an AGENTS.md in {directory}, the directory HX was started in. Any AGENTS.md
+between the repository root and there is loaded before it, so leave out what
+those already say.
 
 Read enough of the codebase to be accurate. Cover: what the project is, how to
 build, test and lint it, the layout of the source tree, and any conventions a
@@ -788,7 +797,7 @@ If AGENTS.md already exists, improve it rather than replacing it wholesale."""
 
 async def cmd_init(ctx: CommandContext, args: str) -> None:
     """``/init`` - generate an AGENTS.md describing this project."""
-    await ctx.app.submit_to_model(INIT_PROMPT)
+    await ctx.app.submit_to_model(INIT_PROMPT.format(directory=ctx.settings.cwd))
 
 
 async def cmd_configure(ctx: CommandContext, args: str) -> None:

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/tui/format.py

@@ -11,7 +11,6 @@ from __future__ import annotations
 
 import re
 from collections.abc import Sequence
-from pathlib import Path
 
 from hx.term.sanitize import plain_text
 from hx.term.width import cell_width, truncate_to_width
@@ -76,17 +75,3 @@ def one_line(text: str, width: int) -> str:
     if cell_width(flat) <= width:
         return flat
     return truncate_to_width(flat, max(0, width - cell_width(ELLIPSIS))) + ELLIPSIS
-
-
-def tilde(path: str | Path) -> str:
-    """``path`` with the home directory written as ``~``.
-
-    Compared as text, not resolved: a session records the path it resolved
-    when it was made, and the directory may be gone by the time it is drawn.
-    """
-    text, home = str(path), str(Path.home())
-    if text == home:
-        return "~"
-    if text.startswith(home.rstrip("/") + "/"):
-        return "~" + text[len(home.rstrip("/")) :]
-    return text

{hx_cli-0.2.8 → hx_cli-0.2.10}/src/hx/tui/runtime.py

@@ -26,10 +26,10 @@ from hx.core.messages import (
 )
 from hx.core.usage import format_tokens
 from hx.git import BranchWatcher
+from hx.paths import tilde
 from hx.term.loop import TuiRunner
 from hx.term.modifiers import ShiftEnter
 from hx.term.terminal import Terminal
-from hx.tui.format import tilde
 from hx.tui.renderers import ToolCall
 from hx.tui.views.blocks import (
     AssistantMessage,
@@ -785,17 +785,9 @@ class HXSession:
             await self._run_command(f"/{chosen}")
 
     async def _open_models(self) -> None:
-        from hx.tui.views.pickers import ModelPicker
-
-        registry = self.extra.get("models")
-        if registry is None:
-            self._notice("no model registry is loaded", "warning")
-            return
-        current = getattr(getattr(self.loop, "model_info", None), "id", "") or ""
-        chosen = await self.ask(ModelPicker(list(registry.all()), current))
-        if chosen:
-            self.view.dock.status.set_model(chosen)
-            self._notice(f"model set to {chosen}")
+        # The same path as `/model`: a picker that only relabelled the status
+        # bar left the session on the old model and the choice unsaved.
+        await self._run_command("/model")
 
     def _commands(self) -> list[Any]:
         return list(self.commands.all()) if self.commands is not None else []
@@ -963,7 +955,8 @@ class HXSession:
             asyncio.create_task(self._open_commands())  # noqa: RUF006
             return
         if name == "ctrl+l":
-            asyncio.create_task(self._open_models())  # noqa: RUF006
+            # Tracked like a typed `/model`, so an interrupt cancels it too.
+            self._side = asyncio.create_task(self._open_models())
             return
         # Only here, on the way to the prompt: nothing else binds shift+enter,
         # so an approval or a picker has to keep the enter it was sent. Not
@@ -1334,8 +1327,13 @@ class HXSession:
         )
         model = getattr(self.loop, "model_info", None)
         if model is not None:
-            status.set_model(getattr(model, "id", "") or "")
+            model_id = getattr(model, "id", "") or ""
+            status.set_model(model_id, subscription=bool(getattr(model, "is_subscription", False)))
             status.set_context(0, getattr(model, "context_window", 0) or 0)
+            # The saved effort is in force from the first turn; a bar that only
+            # shows it once /effort is run again reads as the choice not sticking.
+            if self.models is not None:
+                status.set_effort(self.models.displayed_effort(model_id))
 
 
 async def run_session(