noah-code 0.4.1__tar.gz → 0.5.1__tar.gz

{noah_code-0.4.1 → noah_code-0.5.1}/.github/workflows/ci.yml

@@ -109,8 +109,6 @@ jobs:
             runner: ubuntu-24.04-arm
           - name: macOS arm64
             runner: macos-15
-          - name: macOS x86_64
-            runner: macos-15-intel
     steps:
       - name: Check out source
         uses: actions/checkout@v7

{noah_code-0.4.1 → noah_code-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: noah-code
-Version: 0.4.1
+Version: 0.5.1
 Summary: Noah Code terminal coding agent, built on NVIDIA OO Agents (NOOA)
 Project-URL: Homepage, https://github.com/skundu42/noah-code
 Project-URL: Documentation, https://github.com/skundu42/noah-code#readme
@@ -21,8 +21,8 @@ Classifier: Topic :: Software Development
 Requires-Python: <3.14,>=3.12
 Requires-Dist: click<9.0.0,>=8.1.0
 Requires-Dist: litellm<1.99.0,>=1.96.0
-Requires-Dist: nooa-cli==0.0.9
-Requires-Dist: nooa==0.0.9
+Requires-Dist: nooa-cli==0.0.10
+Requires-Dist: nooa==0.0.10
 Requires-Dist: packaging<27.0,>=24.0
 Requires-Dist: pydantic<3.0.0,>=2.5.0
 Requires-Dist: pyyaml<7.0.0,>=6.0.0
@@ -37,9 +37,9 @@ Requires-Dist: pytest>=8.0.0; extra == 'dev'
 Requires-Dist: ruff>=0.8.0; extra == 'dev'
 Requires-Dist: types-pyyaml>=6.0.12.20260815; extra == 'dev'
 Provides-Extra: mcp
-Requires-Dist: nooa[mcp]==0.0.9; extra == 'mcp'
+Requires-Dist: nooa[mcp]==0.0.10; extra == 'mcp'
 Provides-Extra: tracing
-Requires-Dist: nooa[tracing]==0.0.9; extra == 'tracing'
+Requires-Dist: nooa[tracing]==0.0.10; extra == 'tracing'
 Requires-Dist: opentelemetry-exporter-otlp-proto-http<2.0.0,>=1.44.0; extra == 'tracing'
 Description-Content-Type: text/markdown
 
@@ -170,11 +170,17 @@ Type `/` to search the full command and configuration reference. The most common
 | Drag, then `Cmd+C` / `Ctrl+Shift+C` | Select and copy TUI text |
 | `Ctrl+Shift+C` with no selection | Copy the latest Noah reply |
 | `Ctrl+G` | Open the searchable skills picker |
+| `Ctrl+L` | Open the model picker |
+| `Ctrl+R` | Search and recall a prior prompt |
+| `Ctrl+T` | Expand or collapse live tool output |
+| `Shift+Tab` | Open the reasoning-effort picker |
+| `Alt+Up` | Recall the newest queued prompt for editing |
 | `Ctrl+]` | Return to live transcript output |
 | `Tab` | Switch between build and plan mode |
 | `F2` | Open execution activity |
 | `F3` | Open paginated conversation history |
 | `F4` | Open the live agent, terminal, and job ledger |
+| `Shift+F7` | Focus or leave the scrollable context rail |
 | `/model` | Configure a provider or switch the session model |
 | `/theme` | Choose Atom One Dark, Noah Ocean, Graphite, or High Contrast |
 | `/diff` | Review staged and unstaged changes |
@@ -188,6 +194,8 @@ On wide terminals, the side rail prioritizes the active operation, delegated age
 terminals, Git branch and change counts, session, model usage, update state, and plan. Git status is refreshed in the background at turn
 boundaries, so the animated working state stays responsive. The main pane remains centered on the
 large Noah wordmark until the first prompt, then becomes the conversation and execution timeline.
+The composer footer keeps contextual keys and compact token, cache, and cost telemetry visible at
+every terminal width where they fit.
 
 ## Sessions and crash recovery
 

{noah_code-0.4.1 → noah_code-0.5.1}/README.md

@@ -125,11 +125,17 @@ Type `/` to search the full command and configuration reference. The most common
 | Drag, then `Cmd+C` / `Ctrl+Shift+C` | Select and copy TUI text |
 | `Ctrl+Shift+C` with no selection | Copy the latest Noah reply |
 | `Ctrl+G` | Open the searchable skills picker |
+| `Ctrl+L` | Open the model picker |
+| `Ctrl+R` | Search and recall a prior prompt |
+| `Ctrl+T` | Expand or collapse live tool output |
+| `Shift+Tab` | Open the reasoning-effort picker |
+| `Alt+Up` | Recall the newest queued prompt for editing |
 | `Ctrl+]` | Return to live transcript output |
 | `Tab` | Switch between build and plan mode |
 | `F2` | Open execution activity |
 | `F3` | Open paginated conversation history |
 | `F4` | Open the live agent, terminal, and job ledger |
+| `Shift+F7` | Focus or leave the scrollable context rail |
 | `/model` | Configure a provider or switch the session model |
 | `/theme` | Choose Atom One Dark, Noah Ocean, Graphite, or High Contrast |
 | `/diff` | Review staged and unstaged changes |
@@ -143,6 +149,8 @@ On wide terminals, the side rail prioritizes the active operation, delegated age
 terminals, Git branch and change counts, session, model usage, update state, and plan. Git status is refreshed in the background at turn
 boundaries, so the animated working state stays responsive. The main pane remains centered on the
 large Noah wordmark until the first prompt, then becomes the conversation and execution timeline.
+The composer footer keeps contextual keys and compact token, cache, and cost telemetry visible at
+every terminal width where they fit.
 
 ## Sessions and crash recovery
 

{noah_code-0.4.1 → noah_code-0.5.1}/docs/interactive-reference.md

@@ -9,7 +9,12 @@
 | `Tab` | Toggle `build`/`plan` mode; accept the highlighted slash option while suggestions are open |
 | `Ctrl+P` | Open the command palette |
 | `Ctrl+G` | Open the searchable skills picker |
+| `Ctrl+L` | Open the model picker |
 | `Ctrl+O` | Open the session picker |
+| `Ctrl+R` | Search prior prompts and recall one into the composer |
+| `Ctrl+T` | Expand or collapse live tool output |
+| `Alt+Up` | Recall the newest queued prompt into the composer |
+| `Shift+Tab` | Open the reasoning-effort picker |
 | `Ctrl+N` | Start a new session |
 | `Ctrl+C` | Cancel the active turn and clear queued follow-ups; press twice while idle to quit |
 | `Ctrl+Q` | Quit |
@@ -17,6 +22,7 @@
 | `F2` | Open recent activity and full captured output |
 | `F3` | Open paginated persisted conversation history |
 | `F4` | Open the live work ledger for agents, terminals, and background jobs |
+| `Shift+F7` | Focus or leave the context rail on wide terminals |
 | `Ctrl+]` | Return to live transcript output and clear the new-output counter |
 
 At an approval prompt, press `1` to approve once, `2` to remember the approval for the current
@@ -29,16 +35,29 @@ branch and staged/modified/new counts, session, model usage, and up to six open
 Narrow terminals retain the transcript, live activity, suggestions, and composer without the rail.
 Terminals 25 rows high or shorter use compact spacing.
 
+The line below the composer keeps the active keyboard guidance on the left and, when space permits,
+session input/output tokens, cache hit rate, and estimated cost on the right. This telemetry remains
+available even when the wide context rail is hidden.
+
+Live tool output stays in a compact two-line drawer so long commands do not push the conversation
+away. Press `Ctrl+T` to expand the drawer in place; `F2` retains the complete output after the tool
+finishes. The drawer replaces the animated working banner while a visible tool is active, avoiding
+duplicate status lines; the banner returns between tools.
+
 Type `/` in the composer to open the inline command list; the list remains visible and filters
 continuously. Use `Up`/`Down` to highlight a command, `Enter` or `Tab` to complete it, and `Esc` to
 close the list. Press `Enter` again to run the completed command. Typing `/config` expands the list
 to every resolved configuration path and its current redacted value.
 
+Press `Ctrl+R` to search prompts already shown in the current session. Choosing one loads it into
+the composer without sending it; pressing `Esc` keeps the current draft unchanged.
+
 Until a session has its first user prompt, the main pane keeps the large Noah wordmark centered. Startup,
 repository changes, model, mode, usage, and update state live in the context rail on wide
-terminals. Git status is collected in a background worker at startup and turn boundaries; the
-animated Noah path updates only the working banner and live activity. Existing sessions with user history restore
-their transcript normally.
+terminals. The rail scrolls when its sections exceed the available rows; press `Shift+F7`, then use
+arrows, Page Up/Down, Home, or End without leaving the keyboard. Git status is collected in a
+background worker at startup and turn boundaries; the animated Noah path updates only the working
+banner and live activity. Existing sessions with user history restore their transcript normally.
 
 Drag across transcript, activity, diff, or history text to select it. `Cmd+C` on macOS or
 `Ctrl+Shift+C` in other terminals copies the selection; when there is no selection, the same
@@ -59,6 +78,8 @@ While Noah is working, the composer stays open. `Enter` queues the current text
 a second turn. Chrome shows `queued · n`. When the in-flight `handle()` returns (`DONE`,
 `NEED_INPUT`, or `WAIT`), the host injects the next item in the same journaled turn — one persist
 and one checkpoint for the whole steered run. `/undo` therefore reverts every follow-up together.
+Press `Alt+Up` with an empty composer to pull the newest queued prompt and its attachments back for
+editing.
 
 The queue holds at most 100 items. A 101st `Enter` drops the oldest and status-prints
 `steer dropped oldest`. `@path` mentions and `/attach` paths expand when the item is injected, not

noah_code-0.5.1/docs/releases/v0.5.0.md

@@ -0,0 +1,64 @@
+# Noah Code v0.5.0
+
+This release improves task completion, terminal interaction, and bounded resource use. It includes
+the unreleased prompt recall, model shortcuts, scrollable context rail, and composer usage telemetry.
+
+## More reliable task completion
+
+- Token-limited model replies no longer report a partial answer as successfully completed. The
+  runtime retries within its existing limits and reports failure if the model cannot continue.
+- Subagents wait for their background jobs and resume the task instead of closing their tools
+  early. Requests for user input remain visible even after result summarization.
+- Session deadlines now bound asynchronous model requests, queued provider calls, and background
+  waits. Provider requests receive the remaining timeout as well.
+- Resumed sessions honor newer mode, model, and reasoning choices over older checkpoints and agent
+  snapshots. Resuming another worktree loads its configuration while preserving explicit CLI
+  overrides. Failed one-shot startup releases its host resources; repeated cleanup preserves the
+  saved undo journal.
+
+## Smoother terminal UX
+
+- Search previous prompts, recall queued prompts for editing, and use direct model and reasoning
+  shortcuts. The context rail scrolls and the composer shows compact usage telemetry.
+- Transcript refreshes preserve your reading position. Switching sessions clears stale activity,
+  buffered output, and unread indicators.
+- Cancelling keeps the interface busy until cleanup finishes, preventing overlapping turns and
+  session changes during teardown.
+- File mentions support quoted paths, prioritize matching directories, and preserve nested image
+  paths when pasted. Text and image attachments share the same file-count limit.
+- Console output renders literal tool/error text safely and preserves shell output chunk boundaries.
+- Console resume preserves the saved model; `-h` and slash commands pasted with whitespace work.
+
+## Safer edits and execution
+
+- Stale edit anchors cannot overwrite newly changed content, even after a file has been reread.
+- Read-only shell calls enforce workspace permissions and retain their stdin and timeout options.
+  Generated code cannot invoke the internal trusted-command bypass.
+- Attachment paths resolve symlinks before containment checks, preventing outside-workspace reads.
+- Background launches serialize capacity and name checks. Split terminal completion markers and
+  oversized log events no longer break completion or stall pagination.
+- Invalid process deadlines fail before execution. Log storage failures preserve bounded in-memory
+  output, keep pipes draining, and do not prevent process cleanup.
+
+## Less context and file I/O
+
+- Subagent results obey their character budget, preserve the end of the findings, and bound the
+  input sent for distillation.
+- Text attachment reads stop at their inline limit. Managed output ranges stream only as far as
+  the requested lines, avoiding whole-file allocation.
+- Repeated glob patterns reuse compiled translations, with bracket pattern support.
+- Runtime database connections close after each transaction, preventing connection accumulation
+  during long-running sessions.
+- The existing prompt-size, cache-prefix stability, and helper-context scorecards remain release
+  checks. No new runtime dependencies were added by these fixes.
+
+## Upgrade
+
+```bash
+noah update
+```
+
+Validation uses deterministic provider responses and headless terminal tests; live provider billing
+and end-to-end model quality are not benchmarked by this release.
+
+**Full changelog:** https://github.com/skundu42/noah-code/compare/v0.4.1...v0.5.0

noah_code-0.5.1/docs/releases/v0.5.1.md

@@ -0,0 +1,36 @@
+# Noah Code v0.5.1
+
+This release migrates Noah to NOOA 0.0.10 and preserves reasoning state in the default
+lean execution mode.
+
+## Reasoning continuity
+
+- Structured reasoning returned alongside tool calls is retained in lean-mode history and
+  included in the next provider request. Noah keeps its compact tool transcript while gaining
+  upstream's reasoning-state support.
+- Regression checks cover the follow-up provider request, multiple tool calls, and responses
+  without reasoning state.
+
+## Runtime migration
+
+- Pin NOOA and NOOA CLI, including MCP and tracing extras, to 0.0.10.
+- Adopt upstream's shell framing fixes: malformed quotes and heredocs report syntax errors,
+  and commands that read stdin cannot consume the shell's internal control protocol.
+- Carry upstream's configured error-output limits into Noah's macOS sandbox worker.
+- Preserve Noah's background-task and recovery notifications after upstream's queue changes.
+- Supply absolute file locations for upstream's updated edit anchors, keeping Noah's stale-edit
+  protections and workspace-relative display paths.
+
+The migration also includes upstream's bounded, source-aware sandbox diagnostics and preservation
+of MCP call timeouts during OAuth refresh.
+
+## Upgrade
+
+```bash
+noah update
+```
+
+Validation uses deterministic provider responses and runtime regressions. This release does not
+claim measured live-provider quality improvements or general token savings.
+
+**Full changelog:** https://github.com/skundu42/noah-code/compare/v0.5.0...v0.5.1

{noah_code-0.4.1 → noah_code-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "noah-code"
-version = "0.4.1"
+version = "0.5.1"
 description = "Noah Code terminal coding agent, built on NVIDIA OO Agents (NOOA)"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -19,8 +19,8 @@ classifiers = [
 ]
 
 dependencies = [
-    "nooa==0.0.9",
-    "nooa-cli==0.0.9",
+    "nooa==0.0.10",
+    "nooa-cli==0.0.10",
     # LiteLLM 1.92.0-1.95.x intermittently shipped without macOS wheels,
     # forcing a Rust source build. Wheels are back for every release since
     # 1.96.0 (abi3 since 1.96.2), so the installer stays binary-only.
@@ -53,10 +53,10 @@ dev = [
     "types-pyyaml>=6.0.12.20260815",
 ]
 mcp = [
-    "nooa[mcp]==0.0.9",
+    "nooa[mcp]==0.0.10",
 ]
 tracing = [
-    "nooa[tracing]==0.0.9",
+    "nooa[tracing]==0.0.10",
     "opentelemetry-exporter-otlp-proto-http>=1.44.0,<2.0.0",
 ]
 

{noah_code-0.4.1 → noah_code-0.5.1}/src/noah_code/__init__.py

@@ -1,3 +1,3 @@
 """Noah Code: terminal coding agent on NVIDIA OO Agents."""
 
-__version__ = "0.4.1"
+__version__ = "0.5.1"

{noah_code-0.4.1 → noah_code-0.5.1}/src/noah_code/agent.py

@@ -8,6 +8,7 @@ import platform
 import site
 import sys
 import sysconfig
+import threading
 import types
 from collections.abc import Iterator
 from contextlib import contextmanager, suppress
@@ -16,10 +17,14 @@ from typing import Annotated, Any, Literal
 
 from nooa import Agent, Context, hidden, strategy
 from nooa.config import CodeActConfig, PredictConfig
+from nooa.context_blocks import RenderedMessage, ResolvedBlock, Role, ToolCallEvent
 from nooa.interactive import InteractiveAgent, RespondReason, RespondResult
+from nooa.runtime.channels import Channel
 from nooa.runtime.restrictions import RESTRICTED_MODULES, RestrictionsConfig
 from nooa.runtime.sandbox.config import FileRule, SandboxConfig, resolve_spec
 from nooa.runtime.sandbox.executor import SandboxedExecutor
+from nooa.runtime.sandbox.serialization import effective_error_limit
+from nooa.storage.markers import nosnapshot
 from nooa.strategies import CodeActStrategy
 from nooa.strategies.codeact_lite import PlainCodeActBlockFormatter
 from nooa.tools import TodoManager
@@ -126,7 +131,6 @@ class _PermissionSandboxedExecutor(SandboxedExecutor):
             ("ws", "read_output"),
             ("ws", "replace"),
             ("ws", "run"),
-            ("ws", "run_trusted_readonly"),
             ("ws", "search"),
             ("ws", "write"),
             ("ws", "write_file"),
@@ -196,6 +200,8 @@ def _spawn_safe_local_agent(agent: Any) -> Any:
 
 
 _OMIT = object()
+# ``spawnv_passfds`` is process-global; patch and restore it as one critical section.
+_SPAWN_PASSFDS_LOCK = threading.RLock()
 
 
 def _pipe_picklable(value: Any) -> bool:
@@ -246,28 +252,29 @@ def _unique_spawn_passfds() -> Iterator[None]:
     import multiprocessing.util as util
     import os
 
-    original = util.spawnv_passfds
-
-    def _inherit_fds(passfds: Any) -> tuple[int, ...]:
-        kept: list[int] = []
-        for fd in sorted({int(fd) for fd in passfds}):
-            if fd < 0:
-                continue
-            try:
-                os.fstat(fd)
-            except OSError:
-                continue
-            kept.append(fd)
-        return tuple(kept)
-
-    def _spawnv(path: Any, args: Any, passfds: Any) -> Any:
-        return original(path, args, _inherit_fds(passfds))
-
-    util.spawnv_passfds = _spawnv
-    try:
-        yield
-    finally:
-        util.spawnv_passfds = original
+    with _SPAWN_PASSFDS_LOCK:
+        original = util.spawnv_passfds
+
+        def _inherit_fds(passfds: Any) -> tuple[int, ...]:
+            kept: list[int] = []
+            for fd in sorted({int(fd) for fd in passfds}):
+                if fd < 0:
+                    continue
+                try:
+                    os.fstat(fd)
+                except OSError:
+                    continue
+                kept.append(fd)
+            return tuple(kept)
+
+        def _spawnv(path: Any, args: Any, passfds: Any) -> Any:
+            return original(path, args, _inherit_fds(passfds))
+
+        util.spawnv_passfds = _spawnv
+        try:
+            yield
+        finally:
+            util.spawnv_passfds = original
 
 
 class _MacOSPermissionSandboxedExecutor(_PermissionSandboxedExecutor):
@@ -281,6 +288,8 @@ class _MacOSPermissionSandboxedExecutor(_PermissionSandboxedExecutor):
         cell_timeout: float | None,
         framework_builtins: dict[str, Any] | None = None,
         restrictions: Any = None,
+        max_error: int | None = None,
+        error_tail: int | None = None,
     ) -> None:
         # NOOA probes specifically for Linux Landlock/seccomp. Preserve
         # its worker and broker implementation, but install equivalent native
@@ -298,6 +307,8 @@ class _MacOSPermissionSandboxedExecutor(_PermissionSandboxedExecutor):
         self._cell_timeout = cell_timeout
         self._framework_builtins = framework_builtins or {}
         self._restrictions = restrictions
+        self._max_error = effective_error_limit(max_error)
+        self._error_tail = error_tail
         self._spec = resolve_spec(worker_config)
         self._degraded: list[str] = []
         # Forking a multithreaded Textual process can deadlock in inherited
@@ -344,6 +355,8 @@ class _MacOSPermissionSandboxedExecutor(_PermissionSandboxedExecutor):
                     ),
                     "restrictions": self._restrictions,
                     "spec": self._spec,
+                    "max_error": self._max_error,
+                    "error_tail": self._error_tail,
                 }
             )
         except Exception:
@@ -386,8 +399,9 @@ _NOAH_CODEACT_INSTRUCTIONS = """## Noah CodeAct
 
 Work through tool calls; plain assistant prose cannot run code or end a turn.
 Use `execute_python(code)` for work and `return_result(...)` to finish. Python
-cell state persists. Parameters and `self` are preloaded; call async `self.*`
-tools with `await`. `self.message(text)` is synchronous—never await it.
+cell state persists. Parameters and `self` are preloaded. Every `self.ws.*`
+call is async: always `await` it before iterating or accessing the result.
+`self.message(text)` is synchronous—never await it.
 
 ### Tools
 
@@ -396,9 +410,10 @@ tools with `await`. `self.message(text)` is synchronous—never await it.
   three arguments; two-argument calls are invalid. Prefer one atomic
   `self.ws.apply_patch(changes)` for a
   coherent batch; `self.ws.apply_unified_diff` accepts git-style hunks.
-- Common shapes: `ws.search(pattern, path=".", paths=None, regex=True)` returns
-  iterable Matches plus `.stdout`; `ws.read(path, lines=None)` returns a Match
-  with `.text`/`.content`; `ws.list(pattern="**/*", path=".")` returns paths.
+- Common shapes: `await ws.search(pattern, path=".", paths=None, regex=True)`
+  returns iterable Matches plus `.stdout`; `await ws.read(path, lines=None)`
+  returns text with `.text`/`.content`; `lines=60` reads the first 60 lines;
+  `await ws.list(pattern="**/*", path=".")` returns paths.
 - Run commands with `await self.ws.run(command)` and inspect
   returncode/stdout/stderr. `read_only=True` skips approval only for commands
   the engine recognizes as read-only (Git inspection, search, listing, text
@@ -575,9 +590,31 @@ class _PermissionCodeActStrategy(CodeActStrategy):
             cell_timeout=self.config.cell_timeout,
             framework_builtins=framework_builtins,
             restrictions=self.config.restrictions,
+            max_error=runtime.truncation_config.capture.max_error,
+            error_tail=runtime.truncation_config.capture.tail,
         )
 
 
+class _ReasoningPlainCodeActBlockFormatter(PlainCodeActBlockFormatter):
+    """Retain opaque reasoning state omitted by NOOA 0.0.10's plain formatter."""
+
+    def format(self, blocks: list[ResolvedBlock]) -> list[RenderedMessage]:
+        messages = super().format(blocks)
+        # Plain formatting preserves event order; IDs may repeat across turns.
+        reasoning_items = iter(
+            block.event.reasoning_items
+            for block in blocks
+            if block.role not in (Role.SYSTEM, Role.RUNTIME_EVENT)
+            and isinstance(block.event, ToolCallEvent)
+        )
+        for index, message in enumerate(messages):
+            if message.tool_call is not None:
+                reasoning = next(reasoning_items)
+                if reasoning:
+                    messages[index] = message.model_copy(update={"reasoning_items": reasoning})
+        return messages
+
+
 class _LeanPermissionCodeActStrategy(_PermissionCodeActStrategy):
     """Compact NOOA event rendering while retaining cross-turn history."""
 
@@ -589,7 +626,9 @@ class _LeanPermissionCodeActStrategy(_PermissionCodeActStrategy):
         original = runtime.agent.render_config
         event_format = nooa_compat.truncation_event_format(runtime.agent)
         runtime.agent.render_config = original.model_copy(
-            update={"block_formatter": PlainCodeActBlockFormatter(event_format=event_format)}
+            update={
+                "block_formatter": _ReasoningPlainCodeActBlockFormatter(event_format=event_format)
+            }
         )
         try:
             return await super().execute(runtime, call)
@@ -625,6 +664,7 @@ class CodingAgent(InteractiveAgent):
 
     workspace_root: str = "."
     mode: Literal["build", "plan"] = "build"
+    _system_messages_in: Annotated[Channel, hidden, nosnapshot]
 
     def __init__(
         self,
@@ -651,6 +691,7 @@ class CodingAgent(InteractiveAgent):
 
         llm = wrap_conversational_replies(llm)
         super().__init__(llm=llm, storage=storage, **kwargs)
+        self._system_messages_in = self.queue_manager.queue("system_messages")
         if cache_namespace:
             # NOOA derives prompt_cache_key from this id. A durable Noah
             # session therefore keeps provider cache affinity across restart.

{noah_code-0.4.1 → noah_code-0.5.1}/src/noah_code/budget.py

@@ -83,6 +83,11 @@ class BudgetGuard:
         wall_elapsed = max(time.time() - self._started_wall, 0.0)
         return max(monotonic_elapsed, wall_elapsed)
 
+    def remaining_seconds(self) -> float | None:
+        if self._config.max_seconds is None:
+            return None
+        return max(self._config.max_seconds - self.elapsed_seconds(), 0.0)
+
     def add_usage(
         self,
         *,
@@ -257,28 +262,50 @@ class BudgetedLLM:
         if self._prefix_observer is not None:
             self._prefix_observer.observe_prefix(messages, route=route)
 
+    def _limit_timeout(self, kwargs: dict[str, Any]) -> None:
+        remaining = self._guard.remaining_seconds()
+        if remaining is not None:
+            configured_timeout = kwargs.get("timeout")
+            kwargs["timeout"] = (
+                min(configured_timeout, remaining)
+                if isinstance(configured_timeout, int | float)
+                else remaining
+            )
+
     async def acall(self, messages: list[dict], tools=None, output_model=None, **kwargs) -> Any:
         # Active caps serialize reservations across parent and subagent routes;
         # without this lane, concurrent calls can all pass the same preflight.
-        async with self._guard._async_provider_lock:
-            self._guard.enforce()
-            self._observe_prefix(messages, route=kwargs.get("prompt_cache_key"))
-            response = await self._inner.acall(
-                messages, tools=tools, output_model=output_model, **kwargs
-            )
-            prompt, completion, cost = _usage_from_response(response)
-            self._guard.add_usage(
-                prompt_tokens=prompt,
-                completion_tokens=completion,
-                cost_usd=cost,
-            )
+        self._guard.enforce()
+        try:
+            async with asyncio.timeout(self._guard.remaining_seconds()):
+                async with self._guard._async_provider_lock:
+                    self._guard.enforce()
+                    self._observe_prefix(messages, route=kwargs.get("prompt_cache_key"))
+                    # NOOA shields LiteLLM's provider task from cancellation.
+                    # Bound its own request timeout as well as our outer wait.
+                    self._limit_timeout(kwargs)
+                    response = await self._inner.acall(
+                        messages, tools=tools, output_model=output_model, **kwargs
+                    )
+                    prompt, completion, cost = _usage_from_response(response)
+                    self._guard.add_usage(
+                        prompt_tokens=prompt,
+                        completion_tokens=completion,
+                        cost_usd=cost,
+                    )
+                    self._guard.enforce()
+                    return response
+        except TimeoutError:
+            # Preserve a provider's own timeout unless the session deadline
+            # expired. A session timeout must surface as a sticky budget stop.
             self._guard.enforce()
-            return response
+            raise
 
     def call(self, messages: list[dict], tools=None, output_model=None, **kwargs) -> Any:
         with self._guard._provider_lock:
             self._guard.enforce()
             self._observe_prefix(messages, route=kwargs.get("prompt_cache_key"))
+            self._limit_timeout(kwargs)
             response = self._inner.call(
                 messages, tools=tools, output_model=output_model, **kwargs
             )

{noah_code-0.4.1 → noah_code-0.5.1}/src/noah_code/cli.py

@@ -146,7 +146,7 @@ def _configure_first_run_model(model_override: str | None) -> str | None:
         return selected
 
 
-@click.command("noah-code")
+@click.command("noah-code", context_settings={"help_option_names": ["-h", "--help"]})
 @click.version_option(__version__, prog_name="noah-code")
 @click.argument("path", required=False, type=click.Path())
 @click.option("--continue", "continue_session", is_flag=True, help="Resume latest session")
@@ -856,6 +856,7 @@ async def _prepare(
     store = SessionStore(config.session_dir)
 
     meta = None
+    launch_root = workspace.root
     try:
         if session_id:
             meta = store.load_meta(session_id)
@@ -866,11 +867,18 @@ async def _prepare(
                 click.echo("error: no prior session for this workspace", err=True)
                 return None, EXIT_CONFIG
             workspace = store.workspace_for_resume(meta, workspace)
-        if meta is not None and (model is not None or reasoning_effort is not None):
+        if workspace.root != launch_root:
+            config = load_config(
+                workspace.root,
+                cli_overrides={**overrides, "session_dir": store.session_dir},
+            )
+        if meta is not None and any(value is not None for value in (model, reasoning_effort, mode)):
             if model is not None:
                 meta.model = config.model
             if reasoning_effort is not None:
                 meta.reasoning_effort = config.reasoning_effort
+            if mode is not None:
+                meta.mode = config.mode
             store.save_meta(meta)
     except SessionError as exc:
         click.echo(f"error: {exc}", err=True)
@@ -894,7 +902,7 @@ async def _interactive(
     unsafe_inprocess_code_execution: bool,
 ) -> int:
     first_run = user_default_model() is None
-    if first_run and (model is not None or use_console):
+    if first_run and (model is not None or (use_console and not (continue_session or session_id))):
         try:
             model = _configure_first_run_model(model)
         except (OSError, ValueError) as exc:
@@ -922,7 +930,7 @@ async def _interactive(
         return code
     workspace, config, store, meta = prepared
     use_tui = config.ui.frontend == "tui" and not use_console
-    if first_run and model is None and not use_tui:
+    if first_run and model is None and not use_tui and meta is None:
         try:
             model = _configure_first_run_model(model)
         except (OSError, ValueError) as exc:
@@ -1038,6 +1046,9 @@ async def _run_session(
 
         click.echo(f"error: {safe_error_message(exc)}", err=True)
         return EXIT_AGENT
+    finally:
+        # Startup can fail before run_once reaches its own cleanup block.
+        await host.close()
 
 
 def main(argv: list[str] | None = None) -> None:

{noah_code-0.4.1 → noah_code-0.5.1}/src/noah_code/commands.py

@@ -324,7 +324,5 @@ def parse_slash(text: str) -> tuple[str, str] | None:
     body = stripped[1:]
     if not body:
         return None
-    if " " in body:
-        name, rest = body.split(" ", 1)
-        return name.lower(), rest.strip()
-    return body.lower(), ""
+    parts = body.split(maxsplit=1)
+    return parts[0].lower(), parts[1].strip() if len(parts) > 1 else ""