hx-cli 0.2.9__tar.gz → 0.2.11__tar.gz

{hx_cli-0.2.9 → hx_cli-0.2.11}/CHANGELOG.md

@@ -28,6 +28,40 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.11] - 2026-10-01
+
+### Fixed
+
+- `esc` while a tool runs no longer breaks the session: the next question is
+  answered instead of every later turn failing. A session that was interrupted
+  or killed mid-tool before this release also carries on after `hx resume`.
+- `esc` during a `Bash` command stops the command. The next `Bash` call gets its
+  own output and exit code, not what was left of the one stopped.
+- An interrupted call keeps what it printed, on screen and for the model, and
+  reads "Interrupted after <time>" instead of looking like a failure.
+- A tool that finished keeps its result when `esc` lands while its
+  `PostToolUse` hook runs.
+- `Bash` shows a short line such as "Starting..." as soon as it is printed,
+  rather than only when more output follows.
+
+---
+
+## [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
@@ -742,7 +776,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.9...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.11...HEAD
+[0.2.11]: https://github.com/aletisunil/hx/compare/v0.2.10...v0.2.11
+[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

{hx_cli-0.2.9 → hx_cli-0.2.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.9
+Version: 0.2.11
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev
@@ -762,7 +762,7 @@ 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
@@ -774,6 +774,13 @@ 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.9 → hx_cli-0.2.11}/README.md

@@ -722,7 +722,7 @@ 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
@@ -734,6 +734,13 @@ 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.9 → hx_cli-0.2.11}/src/hx/__init__.py

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

{hx_cli-0.2.9 → hx_cli-0.2.11}/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.9 → hx_cli-0.2.11}/src/hx/cli.py

@@ -436,6 +436,7 @@ def build_runtime(parsed: ParsedArgs, *, resume: str | None = None) -> Runtime:
         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)
@@ -464,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))
 
@@ -484,7 +486,7 @@ 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, instructions),
+        project_context=project_context,
         instructions=instructions,
         hooks=hooks,
     )

{hx_cli-0.2.9 → hx_cli-0.2.11}/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        cwd, git branch, top-level listing, ~/.hx/AGENTS.md, AGENTS.md
+    [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) ---
@@ -250,20 +251,26 @@ class Instructions:
 def load_instructions(cwd: Path) -> list[Instructions]:
     """Every AGENTS.md in force, least specific first.
 
-    ``~/.hx/AGENTS.md`` follows the user into every project; the project's own
-    ``AGENTS.md`` comes after it, so where the two disagree the more specific
-    one has the last word. A blank or unreadable file is skipped, and running
-    from inside ``$HX_HOME`` - where both paths name the same file - loads it once.
+    ``~/.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_file, tilde, user_instructions_file
+    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 (
-        (f"User instructions ({tilde(user)})", user),
-        ("Project instructions (AGENTS.md)", project_instructions_file(cwd)),
-    ):
+    for heading, path in candidates:
         body = _read_prompt_file(path)
         if not body or path.resolve() in seen:
             continue
@@ -272,6 +279,17 @@ def load_instructions(cwd: Path) -> list[Instructions]:
     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.
 
@@ -291,8 +309,11 @@ def build_project_context(cwd: Path, instructions: list[Instructions] | None = N
     if entries:
         lines.append("Top level: " + ", ".join(entries[:60]))
 
-    for loaded in load_instructions(cwd) if instructions is None else instructions:
-        lines.append(f"\n# {loaded.heading}\n\n{loaded.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)
 

{hx_cli-0.2.9 → hx_cli-0.2.11}/src/hx/core/events.py

@@ -67,6 +67,9 @@ class ToolCallFinished(Event):
     metadata: dict[str, Any] = field(default_factory=dict)
     """Structured detail the renderer draws with - an edit's diff, a command's
     exit code. Presentation only: the model never sees it."""
+    interrupted: bool = False
+    """The user stopped the turn while this call ran. Whatever it streamed is
+    kept: how far a command got is what the user wants to see."""
 
 
 @dataclass(slots=True)

{hx_cli-0.2.9 → hx_cli-0.2.11}/src/hx/core/loop.py

@@ -42,7 +42,9 @@ from hx.core.messages import (
     ToolResultBlock,
     ToolUseBlock,
     UserTurn,
+    answer_unanswered_calls,
     assistant_message,
+    interrupted_result,
     tool_result_message,
     user_message,
 )
@@ -50,7 +52,7 @@ from hx.core.session import Environment
 from hx.core.usage import TurnUsage, compute_cost
 from hx.hooks.spec import HookOutcome
 from hx.providers.base import ProviderError, ProviderRequest, StreamDelta, StreamEnd
-from hx.tools.base import ToolContext
+from hx.tools.base import ToolContext, ToolResult
 
 if TYPE_CHECKING:
     from collections.abc import Awaitable, Callable, Sequence
@@ -225,6 +227,27 @@ class AgentLoop:
                 self.bus.publish(TurnFinished(self._turn_index, stop_reason))
 
             calls = message.tool_uses()
+            if calls and self._cancelled:
+                # Stopped between the answer and its tools: none of them ran,
+                # and the transcript has to say so before the turn ends - as
+                # does the screen, which a resumed session draws them on too.
+                for call in calls:
+                    self.bus.publish(
+                        ToolCallStarted(
+                            tool_use_id=call.id,
+                            name=self._display_name(call.name),
+                            input=call.input,
+                        )
+                    )
+                    self.bus.publish(
+                        ToolCallFinished(
+                            tool_use_id=call.id,
+                            is_error=True,
+                            summary="interrupted",
+                            interrupted=True,
+                        )
+                    )
+                produced.append(self._answer_calls(calls, {}))
             if not calls or self._cancelled:
                 # A steer that arrived during the last stretch is the next thing
                 # the user said, so the conversation continues rather than
@@ -234,10 +257,15 @@ class AgentLoop:
                 await self._name_session()
                 return TurnResult(stop_reason, produced)
 
-            results = await self._execute_tools(calls)
-            result_message = tool_result_message(results)
-            self.session.append(result_message)
-            produced.append(result_message)
+            results: dict[str, ToolResultBlock] = {}
+            try:
+                await self._execute_tools(calls, results)
+            finally:
+                # Also on interrupt. The calls are already in the transcript,
+                # and a call left without a result is rejected by every route on
+                # the next request - so every later turn in the session would
+                # fail the same way. What finished keeps its real result.
+                produced.append(self._answer_calls(calls, results))
 
         self.bus.publish(
             ErrorRaised(message=f"Stopped after {self.MAX_TURNS} turns", recoverable=True)
@@ -459,7 +487,9 @@ class AgentLoop:
         )
 
     async def _build_request(self) -> ProviderRequest:
-        messages = await self.injections.apply(self.session.active_messages())
+        messages = answer_unanswered_calls(
+            await self.injections.apply(self.session.active_messages())
+        )
         if self.model_info is None or not self.model_info.supports_images:
             from hx.core.images import without_images
 
@@ -570,31 +600,48 @@ class AgentLoop:
             )
         )
 
-    async def _execute_tools(self, calls: list[ToolUseBlock]) -> list[ToolResultBlock]:
+    async def _execute_tools(
+        self, calls: list[ToolUseBlock], results: dict[str, ToolResultBlock]
+    ) -> None:
         """Permission-check, then run. Read-only calls are gathered concurrently;
         mutating calls run in emission order.
 
+        Each result lands in ``results`` the moment its call finishes, so an
+        interrupt keeps what had already run.
+
         A denied call becomes an ``is_error`` result rather than an exception, so
         the model can react instead of the turn dying.
         """
-        results: dict[str, ToolResultBlock] = {}
         concurrent: list[ToolUseBlock] = []
 
+        async def run(call: ToolUseBlock) -> None:
+            results[call.id] = await self._run_one(call, results)
+
         for call in calls:
             if self._runs_serially(call):
                 for pending in concurrent:
-                    results[pending.id] = await self._run_one(pending)
+                    await run(pending)
                 concurrent.clear()
-                results[call.id] = await self._run_one(call)
+                await run(call)
             else:
                 concurrent.append(call)
 
         if concurrent:
-            gathered = await asyncio.gather(*(self._run_one(c) for c in concurrent))
-            for call, result in zip(concurrent, gathered, strict=True):
-                results[call.id] = result
+            await asyncio.gather(*(run(c) for c in concurrent))
 
-        return [results[c.id] for c in calls]
+    def _answer_calls(
+        self, calls: list[ToolUseBlock], results: dict[str, ToolResultBlock]
+    ) -> Message:
+        """Append the results for ``calls``, in the order the model asked for them.
+
+        A call with no result was cut off by the user, before it started or
+        while it ran, and is answered as exactly that.
+        """
+        message = tool_result_message(
+            [results.get(call.id) or interrupted_result(call.id) for call in calls]
+        )
+        self.session.append(message)
+        return message
 
     def _runs_serially(self, call: ToolUseBlock) -> bool:
         try:
@@ -609,7 +656,10 @@ class AgentLoop:
         """Attribute a subagent's tool calls so they do not read as the parent's."""
         return name if self.origin is None else f"{self.origin} > {name}"
 
-    async def _run_one(self, call: ToolUseBlock) -> ToolResultBlock:
+    async def _run_one(
+        self, call: ToolUseBlock, results: dict[str, ToolResultBlock]
+    ) -> ToolResultBlock:
+        """Run one call. Interrupted, it leaves its answer in ``results``."""
         started = time.monotonic()
 
         # PreToolUse runs before the call is announced. A hook that rewrites the
@@ -626,7 +676,40 @@ class AgentLoop:
                 tool_use_id=call.id, name=self._display_name(call.name), input=call.input
             )
         )
+        streamed: list[str] = []
+        try:
+            return await self._run_announced(call, pre, started, streamed, results)
+        except asyncio.CancelledError:
+            if call.id in results:
+                # The tool had finished and only its hooks were cut off.
+                raise
+            cap = self.settings.context.tool_output_char_cap
+            results[call.id] = interrupted_result(call.id, "".join(streamed)[-cap:])
+            # The call is on screen as running; left alone it would spin on
+            # under the "Interrupted" notice for the rest of the session.
+            self.bus.publish(
+                ToolCallFinished(
+                    tool_use_id=call.id,
+                    is_error=True,
+                    duration_ms=(time.monotonic() - started) * 1000,
+                    summary="interrupted",
+                    interrupted=True,
+                )
+            )
+            raise
 
+    async def _run_announced(
+        self,
+        call: ToolUseBlock,
+        pre: HookOutcome,
+        started: float,
+        streamed: list[str],
+        results: dict[str, ToolResultBlock],
+    ) -> ToolResultBlock:
+        """The part of :meth:`_run_one` after the call is on screen.
+
+        What the tool prints is kept in ``streamed`` for an interrupt to report.
+        """
         if pre.blocked:
             refusal = ToolResultBlock(
                 tool_use_id=call.id,
@@ -657,18 +740,34 @@ class AgentLoop:
             )
             return denied
 
+        def progress(chunk: str) -> None:
+            streamed.append(chunk)
+            self._emit_progress(call.id, chunk)
+
         ctx = ToolContext(
             cwd=self.settings.cwd,
             session_id=self.session.meta.session_id,
             tool_use_id=call.id,
             settings=self.settings,
-            emit_progress=lambda chunk: self._emit_progress(call.id, chunk),
+            emit_progress=progress,
         )
         result = await self.tools.call(call.name, call.input, ctx)
 
-        post = await self._fire_hooks(
-            lambda h: h.post_tool_use(call.name, call.input, result.content, result.is_error)
-        )
+        try:
+            post = await self._fire_hooks(
+                lambda h: h.post_tool_use(call.name, call.input, result.content, result.is_error)
+            )
+        except asyncio.CancelledError:
+            # The tool finished and its effects are real: its own result stands,
+            # rather than telling the model a write that happened never did.
+            results[call.id] = self._finish(call, result, HookOutcome(), started)
+            raise
+        return self._finish(call, result, post, started)
+
+    def _finish(
+        self, call: ToolUseBlock, result: ToolResult, post: HookOutcome, started: float
+    ) -> ToolResultBlock:
+        """Announce a call the tool finished, and its result for the model."""
         content = result.content
         if post.blocked:
             content = f"{content}\n\nA hook rejected this result: {post.reason}"

{hx_cli-0.2.9 → hx_cli-0.2.11}/src/hx/core/messages.py

@@ -9,7 +9,7 @@ from __future__ import annotations
 
 import time
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from enum import StrEnum
 from typing import Any, Literal
 
@@ -238,3 +238,60 @@ def assistant_message(blocks: list[ContentBlock], model: str | None = None) -> M
 def tool_result_message(results: list[ToolResultBlock]) -> Message:
     """Tool results are carried on a ``user``-role message, matching the provider wire format."""
     return Message(role="user", content=list(results))
+
+
+INTERRUPTED = "Interrupted by the user before this call finished."
+_OUTPUT_SO_FAR = "\n\nOutput before the interrupt:\n"
+
+
+def interrupted_result(tool_use_id: str, output: str = "") -> ToolResultBlock:
+    """The answer for a call the user cut off, before it started or while it ran.
+
+    What it printed before then goes with it: how far a command got is what
+    the model needs to decide whether to run it again.
+    """
+    content = f"{INTERRUPTED}{_OUTPUT_SO_FAR}{output}" if output.strip() else INTERRUPTED
+    return ToolResultBlock(tool_use_id=tool_use_id, content=content, is_error=True)
+
+
+def interrupted_output(result: ToolResultBlock) -> str | None:
+    """What an interrupted call printed, or ``None`` when ``result`` is not one."""
+    if not (result.is_error and result.content.startswith(INTERRUPTED)):
+        return None
+    return result.content.removeprefix(INTERRUPTED).removeprefix(_OUTPUT_SO_FAR)
+
+
+def answer_unanswered_calls(messages: Sequence[Message]) -> list[Message]:
+    """``messages`` with every tool call answered by the message after it.
+
+    The loop answers every call it starts, interrupted or not, so a request is
+    never built while a call waits. A transcript can still hold a call with no
+    result: written before the loop did that, or by a process killed mid-tool.
+    Every route rejects such a call - on every request after it, since it never
+    leaves the history - so the missing results are filled in as interrupted.
+    Only the request is repaired; the transcript on disk keeps what happened.
+    """
+    repaired: list[Message] = []
+    waiting: list[ToolUseBlock] = []
+    for message in [*messages, None]:
+        if waiting:
+            results = {r.tool_use_id: r for r in message.tool_results()} if message else {}
+            if any(call.id not in results for call in waiting):
+                answers = [results.get(c.id) or interrupted_result(c.id) for c in waiting]
+                ids = {call.id for call in waiting}
+                if message is not None and results:
+                    # Into the results already there: the calls stay answered
+                    # by one message, in the order they were made.
+                    rest = [
+                        b
+                        for b in message.content
+                        if not (isinstance(b, ToolResultBlock) and b.tool_use_id in ids)
+                    ]
+                    message = replace(message, content=[*answers, *rest])
+                else:
+                    repaired.append(tool_result_message(answers))
+        if message is None:
+            break
+        repaired.append(message)
+        waiting = message.tool_uses() if message.role == "assistant" else []
+    return repaired

{hx_cli-0.2.9 → hx_cli-0.2.11}/src/hx/paths.py

@@ -217,9 +217,50 @@ def user_instructions_file() -> Path:
     return user_home() / "AGENTS.md"
 
 
-def project_instructions_file(cwd: Path | None = None) -> Path:
-    """The project's ``AGENTS.md``, at the root of the working directory."""
-    return (cwd or Path.cwd()) / "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:

{hx_cli-0.2.9 → hx_cli-0.2.11}/src/hx/tools/bash.py

@@ -143,6 +143,13 @@ class PersistentShell:
                 if not interrupted or not await self._drain_stale_sentinel():
                     await self.restart()
                     yield "[hx] shell did not recover from the interrupt; restarted\n"
+            except asyncio.CancelledError:
+                # The user stopped the turn. The command must stop with it, and
+                # its sentinel must not be left for the next command to read -
+                # the same recovery as a timeout, without the output to report.
+                if not await self.interrupt() or not await self._drain_stale_sentinel():
+                    await self.restart()
+                raise
 
             self._duration_ms = (time.monotonic() - started) * 1000
 
@@ -178,11 +185,14 @@ class PersistentShell:
                     yield head
                 return
 
-            # Hold back a partial sentinel so it is never emitted as output.
-            safe = len(buffer) - len(self._sentinel)
-            if safe > 0:
-                yield buffer[:safe]
-                buffer = buffer[safe:]
+            # Hold back only what could be the start of the sentinel, so it is
+            # never emitted as output. Holding back a sentinel's length of
+            # anything hid a short line - "Starting..." before a long build -
+            # until the command ended.
+            held = _sentinel_prefix_at_end(buffer, self._sentinel)
+            if len(buffer) > held:
+                yield buffer[: len(buffer) - held]
+                buffer = buffer[len(buffer) - held :]
 
     async def _drain_stale_sentinel(self, timeout_seconds: float = 5.0) -> bool:
         """Consume output up to the sentinel owed by an interrupted command."""
@@ -564,6 +574,14 @@ class KillShellTool(Tool):
         return ToolResult(content=f"Killed {job_id}.", summary=f"killed {job_id}")
 
 
+def _sentinel_prefix_at_end(buffer: str, sentinel: str) -> int:
+    """Length of the longest end of ``buffer`` that ``sentinel`` starts with."""
+    for size in range(min(len(buffer), len(sentinel) - 1), 0, -1):
+        if sentinel.startswith(buffer[-size:]):
+            return size
+    return 0
+
+
 def _parse_trailer(tail: str, previous: Path) -> tuple[int, Path]:
     """Read the ``<status> <pwd>`` the sentinel is followed by.