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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: noah-code
-Version: 0.5.0
+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
 

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.5.0 → noah_code-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "noah-code"
-version = "0.5.0"
+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.5.0 → 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.5.0"
+__version__ = "0.5.1"

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

@@ -17,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
@@ -284,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
@@ -301,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
@@ -347,6 +355,8 @@ class _MacOSPermissionSandboxedExecutor(_PermissionSandboxedExecutor):
                     ),
                     "restrictions": self._restrictions,
                     "spec": self._spec,
+                    "max_error": self._max_error,
+                    "error_tail": self._error_tail,
                 }
             )
         except Exception:
@@ -580,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."""
 
@@ -594,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)
@@ -630,6 +664,7 @@ class CodingAgent(InteractiveAgent):
 
     workspace_root: str = "."
     mode: Literal["build", "plan"] = "build"
+    _system_messages_in: Annotated[Channel, hidden, nosnapshot]
 
     def __init__(
         self,
@@ -656,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.5.0 → noah_code-0.5.1}/src/noah_code/nooa_compat.py

@@ -1,7 +1,7 @@
 """Single seam for NOOA internals that have no public API yet.
 
 Every private-attribute reach-through into the framework lives here so an
-upgrade only requires auditing this one module. Pinned upstream: nooa==0.0.9.
+upgrade only requires auditing this one module. Pinned upstream: nooa==0.0.10.
 """
 
 from __future__ import annotations

{noah_code-0.5.0 → noah_code-0.5.1}/src/noah_code/tools/workspace_tools.py

@@ -343,7 +343,7 @@ class WorkspaceTools(Skill):
         with resolved.open(encoding="utf-8") as stream:
             content = stream.read()
         total = len(content.splitlines(keepends=True))
-        return WorkspaceMatch(str(resolved), 1, total, content)
+        return WorkspaceMatch(str(resolved), 1, total, content, resolved_path=resolved)
 
     @staticmethod
     def _read_line_range(resolved: Path, lines: tuple[int, int]) -> WorkspaceMatch:
@@ -363,7 +363,7 @@ class WorkspaceTools(Skill):
             else:
                 # The file ended before the range did; clamp like a full read.
                 end = min(end, last)
-        return WorkspaceMatch(str(resolved), start, end, "".join(collected))
+        return WorkspaceMatch(str(resolved), start, end, "".join(collected), resolved_path=resolved)
 
     async def search(
         self,
@@ -1322,7 +1322,9 @@ class WorkspaceTools(Skill):
             if not candidate.is_absolute():
                 candidate = (base / candidate).resolve()
             rewritten.append(
-                WorkspaceMatch(str(candidate), match.start, match.end, match.text)
+                WorkspaceMatch(
+                    str(candidate), match.start, match.end, match.text, resolved_path=candidate
+                )
             )
         result.matches = rewritten
 

{noah_code-0.5.0 → noah_code-0.5.1}/tests/test_agent_security.py

@@ -12,6 +12,8 @@ from types import SimpleNamespace
 import pytest
 from nooa.runtime.restrictions import RestrictionsConfig
 from nooa.runtime.sandbox.config import SandboxConfig
+from nooa.runtime.sandbox.errors import SandboxExecutionError
+from nooa.runtime.sandbox.serialization import effective_error_limit
 
 from noah_code.agent import (
     _codeact_config,
@@ -75,6 +77,7 @@ def test_sandbox_broker_exposes_only_permission_gated_capabilities() -> None:
 @pytest.mark.asyncio
 async def test_sandbox_cannot_call_the_host_only_readonly_runner() -> None:
     executor = object.__new__(_PermissionSandboxedExecutor)
+    executor._max_error = effective_error_limit(None)
     executor._agent = SimpleNamespace(
         ws=SimpleNamespace(run_trusted_readonly=lambda _command: "private host data")
     )
@@ -125,8 +128,10 @@ async def test_macos_sandbox_blocks_unbrokered_file_and_network_access() -> None
 
     assert safe.stdout.strip() == "2"
     assert safe.error is None
-    assert isinstance(blocked_file.error, PermissionError)
-    assert isinstance(blocked_network.error, PermissionError)
+    for blocked in (blocked_file, blocked_network):
+        assert isinstance(blocked.error, SandboxExecutionError)
+        assert blocked.error.original_type == "PermissionError"
+        assert isinstance(blocked.error.original_error, PermissionError)
 
 
 def test_spawn_safe_local_agent_drops_instance_file_descriptors() -> None:

noah_code-0.5.1/tests/test_lean_reasoning.py

@@ -0,0 +1,201 @@
+"""Compact history must replay opaque provider reasoning with its tool call."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+
+import pytest
+from nooa.context_blocks import BlockMetadata, ResolvedBlock, Role, ToolCallEvent, ToolResult
+from nooa.context_blocks.formatter import OpenAIProviderFormatter, ResponsesProviderFormatter
+from nooa.interactive import RespondReason
+from nooa.strategies.codeact_lite import PlainCodeActBlockFormatter
+from nooa.unifiedllm import FakeLLMClient, LLMResponse, ToolCall
+
+from noah_code import nooa_compat
+from noah_code.agent import CodingAgent, _ReasoningPlainCodeActBlockFormatter
+from noah_code.config import NoahCodeConfig
+from noah_code.workspace import Workspace
+
+
+@pytest.mark.parametrize(
+    "reasoning_items",
+    [None, [], [{"type": "reasoning", "id": "rs_fixture", "encrypted_content": "opaque-fixture"}]],
+)
+def test_lean_formatter_preserves_reasoning_without_changing_compact_history(reasoning_items):
+    blocks = [
+        ResolvedBlock(
+            key="instructions",
+            content="Stable instructions.",
+            metadata=BlockMetadata(static=True),
+        ),
+        ResolvedBlock(key="task", content="Inspect the repository.", role=Role.USER),
+    ]
+    for index in range(2):
+        call_id = f"call_{index}"
+        blocks.append(
+            ResolvedBlock(
+                key=call_id,
+                content="",
+                role=Role.ASSISTANT,
+                event=ToolCallEvent(
+                    tool_call_id=call_id,
+                    name="execute_python",
+                    arguments={"code": f"print({index})"},
+                    reasoning_items=reasoning_items if index == 0 else None,
+                    result=ToolResult(tool_call_id=call_id, content=f"result {index}"),
+                ),
+            )
+        )
+
+    baseline = PlainCodeActBlockFormatter().format(blocks)
+    rendered = _ReasoningPlainCodeActBlockFormatter().format(blocks)
+
+    assert [message.model_dump(exclude={"reasoning_items"}) for message in rendered] == [
+        message.model_dump(exclude={"reasoning_items"}) for message in baseline
+    ]
+    assert [message.reasoning_items for message in rendered if message.tool_call] == [
+        reasoning_items or None,
+        None,
+    ]
+    assert all(message.reasoning_items is None for message in rendered if not message.tool_call)
+
+    chat_messages = OpenAIProviderFormatter().format(rendered)
+    calls = [message for message in chat_messages if message.get("tool_calls")]
+    assert calls[0].get("reasoning_items") == (reasoning_items or None)
+    assert "reasoning_items" not in calls[1]
+    responses_messages = ResponsesProviderFormatter().format(rendered)
+    assert [message for message in responses_messages if message.get("type") == "reasoning"] == (
+        reasoning_items or []
+    )
+    if reasoning_items:
+        first_call = next(
+            i
+            for i, message in enumerate(responses_messages)
+            if message.get("type") == "function_call"
+        )
+        assert responses_messages[first_call - 1] == reasoning_items[0]
+
+
+@pytest.mark.parametrize("later_state", [None, [], [{"type": "reasoning", "id": "rs_later"}]])
+def test_reused_tool_call_ids_keep_reasoning_with_the_original_event(later_state):
+    first_state = [{"type": "reasoning", "id": "rs_first"}]
+    blocks = [
+        ResolvedBlock(
+            key=f"event_{index}",
+            content="",
+            role=role,
+            event=ToolCallEvent(
+                tool_call_id="reused-call",
+                name="execute_python",
+                arguments={"code": "print('ok')"},
+                reasoning_items=state,
+            ),
+        )
+        for index, (role, state) in enumerate(
+            [
+                (Role.SYSTEM, [{"type": "reasoning", "id": "not-rendered-system"}]),
+                (Role.RUNTIME_EVENT, [{"type": "reasoning", "id": "not-rendered-runtime"}]),
+                (Role.ASSISTANT, first_state),
+                (Role.ASSISTANT, later_state),
+            ]
+        )
+    ]
+
+    rendered = _ReasoningPlainCodeActBlockFormatter().format(blocks)
+
+    assert [message.reasoning_items for message in rendered if message.tool_call] == [
+        first_state,
+        later_state or None,
+    ]
+    provider_messages = OpenAIProviderFormatter().format(rendered)
+    assert [
+        message.get("reasoning_items") for message in provider_messages if message.get("tool_calls")
+    ] == [first_state, later_state or None]
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("with_reasoning", [False, True])
+async def test_default_lean_agent_replays_reasoning_on_next_model_call(
+    tmp_path: Path,
+    with_reasoning: bool,
+) -> None:
+    reasoning_items = [
+        {"type": "reasoning", "id": "rs_fixture", "encrypted_content": "opaque-fixture"}
+    ]
+    first_assistant = {"role": "assistant", "content": "", "tool_calls": []}
+    if with_reasoning:
+        first_assistant["reasoning_items"] = reasoning_items
+    llm = FakeLLMClient(
+        scripted_responses=[
+            LLMResponse(
+                raw_response=None,
+                content="",
+                finish_reason="tool_calls",
+                assistant_message=first_assistant,
+                tool_calls=[
+                    ToolCall(
+                        id=f"call_{index}",
+                        name="execute_python",
+                        arguments=json.dumps({"code": f"print('result {index}')"}),
+                    )
+                    for index in range(2)
+                ],
+            ),
+            LLMResponse(
+                raw_response=None,
+                content="",
+                finish_reason="tool_calls",
+                assistant_message={"role": "assistant", "content": "", "tool_calls": []},
+                tool_calls=[
+                    ToolCall(
+                        id="call_done",
+                        name="execute_python",
+                        arguments=json.dumps(
+                            {
+                                "code": 'return_result(RespondReason.DONE, explanation="verified")',
+                            }
+                        ),
+                    )
+                ],
+            ),
+        ]
+    )
+    agent = CodingAgent(
+        Workspace(root=tmp_path.resolve()),
+        NoahCodeConfig(auto_approve=True, unsafe_inprocess_code_execution=True),
+        llm=llm,
+        nested=True,
+    )
+    try:
+        nooa_compat.queue_user_message(agent, "Run both checks.")
+        wins = await agent.queue_manager.race()
+        notification: dict[str, list] = {}
+        for name, item in wins:
+            notification.setdefault(name, []).append(item)
+        result = await asyncio.wait_for(agent.handle(notification), timeout=10)
+    finally:
+        await agent.close_tools()
+
+    assert result.kind == RespondReason.DONE
+    assert llm.call_count == 2
+    # NOOA also includes a synthetic prefill call before the model's history.
+    calls = [
+        message
+        for message in llm.last_messages
+        if message.get("tool_calls") and message["tool_calls"][0]["id"].startswith("call_")
+    ]
+    assert [message["tool_calls"][0]["id"] for message in calls] == ["call_0", "call_1"]
+    assert calls[0].get("reasoning_items") == (reasoning_items if with_reasoning else None)
+    assert "reasoning_items" not in calls[1]
+    results = [
+        message
+        for message in llm.last_messages
+        if message.get("role") == "tool" and message["tool_call_id"].startswith("call_")
+    ]
+    assert [(message["tool_call_id"], message["content"]) for message in results] == [
+        ("call_0", "result 0\n"),
+        ("call_1", "result 1\n"),
+    ]
+    assert all("opaque-fixture" not in str(message.get("content")) for message in llm.last_messages)

noah_code-0.5.1/tests/test_nooa_migration.py

@@ -0,0 +1,28 @@
+"""Runtime behaviors required from the pinned NOOA release."""
+
+from pathlib import Path
+
+import pytest
+from nooa.tools.shell_tools import ShellTools
+
+
+@pytest.mark.asyncio
+@pytest.mark.parametrize("command,expected_codes", [("printf 'unterminated", (1, 2)), ("cat", (0,))])
+async def test_shell_commands_cannot_consume_the_control_protocol(
+    tmp_path: Path, command: str, expected_codes: tuple[int, ...]
+) -> None:
+    shell = ShellTools(cwd=str(tmp_path))
+    try:
+        await shell.run("printf ready", timeout=2)
+        result = await shell.run(command, timeout=0.5)
+        # Bash 3 (macOS) and Bash 5 (Linux) use different syntax-error codes.
+        assert result.returncode in expected_codes
+        assert not result.timed_out
+        assert result.stdout == ""
+        if result.returncode:
+            assert "unexpected EOF" in result.stderr
+        recovered = await shell.run("printf recovered", timeout=2)
+        assert recovered.returncode == 0
+        assert recovered.stdout == "recovered"
+    finally:
+        await shell.close()

{noah_code-0.5.0 → noah_code-0.5.1}/tests/test_textual_tui.py

@@ -2291,7 +2291,11 @@ async def test_live_tool_output_stays_compact_until_expanded(tmp_path: Path) ->
                 meta={"activity_id": "tool-1", "stream": "stdout"},
             )
         )
-        await pilot.pause(0.08)
+        # Stream output flushes on a separate timer after host events drain.
+        output = app.query_one("#activity-output")
+        async with asyncio.timeout(5):
+            while "five" not in _log_text(output):
+                await pilot.pause()
 
         live = app.query_one("#live-activity")
         assert live.styles.height.value == 6

{noah_code-0.5.0 → noah_code-0.5.1}/uv.lock

@@ -1021,7 +1021,7 @@ wheels = [
 
 [[package]]
 name = "noah-code"
-version = "0.5.0"
+version = "0.5.1"
 source = { editable = "." }
 dependencies = [
     { name = "click" },
@@ -1058,10 +1058,10 @@ requires-dist = [
     { name = "click", specifier = ">=8.1.0,<9.0.0" },
     { name = "litellm", specifier = ">=1.96.0,<1.99.0" },
     { name = "mypy", marker = "extra == 'dev'", specifier = ">=2.3.1" },
-    { name = "nooa", specifier = "==0.0.9" },
-    { name = "nooa", extras = ["mcp"], marker = "extra == 'mcp'", specifier = "==0.0.9" },
-    { name = "nooa", extras = ["tracing"], marker = "extra == 'tracing'", specifier = "==0.0.9" },
-    { name = "nooa-cli", specifier = "==0.0.9" },
+    { name = "nooa", specifier = "==0.0.10" },
+    { name = "nooa", extras = ["mcp"], marker = "extra == 'mcp'", specifier = "==0.0.10" },
+    { name = "nooa", extras = ["tracing"], marker = "extra == 'tracing'", specifier = "==0.0.10" },
+    { name = "nooa-cli", specifier = "==0.0.10" },
     { name = "opentelemetry-exporter-otlp-proto-http", marker = "extra == 'tracing'", specifier = ">=1.44.0,<2.0.0" },
     { name = "packaging", specifier = ">=24.0,<27.0" },
     { name = "pydantic", specifier = ">=2.5.0,<3.0.0" },
@@ -1079,7 +1079,7 @@ provides-extras = ["dev", "mcp", "tracing"]
 
 [[package]]
 name = "nooa"
-version = "0.0.9"
+version = "0.0.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -1087,9 +1087,9 @@ dependencies = [
     { name = "openinference-instrumentation-litellm" },
     { name = "pydantic" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/34/6f/c4e3ea70b373f72f98c12d23fd61f8525462bcecb4a969b58fbb67092699/nooa-0.0.9.tar.gz", hash = "sha256:c7a90ffb5b54094180efcb845e74a00c4182766745245f4258e613f9c12cb522", size = 3315964, upload-time = "2026-08-18T15:00:15.26Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/27/90/f07e44b57d10e3687caba9b18a1b2064e7c9602f85fdeb9c9b0a4843aeba/nooa-0.0.10.tar.gz", hash = "sha256:91d44a48610b116561d2ddc42ed80a7c4011c7324a67236300d2fe78182d3c78", size = 3504802, upload-time = "2026-09-04T06:04:36.719Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ae/27/11b2754bc31994244418d0a55447f20bc0efbd9d2573802db13c7ca367b5/nooa-0.0.9-py3-none-any.whl", hash = "sha256:60b64663f34a47aec206137035d62e816c1147484bb74a8a4700a47d1a10b60c", size = 1104654, upload-time = "2026-08-18T15:00:13.588Z" },
+    { url = "https://files.pythonhosted.org/packages/02/84/ec56e26a39873862f046146bf677b1d259e7e923180f508747baa1076ed9/nooa-0.0.10-py3-none-any.whl", hash = "sha256:8a74d3e62bb4a216d6fcb1ba912b5d9e49ecc0bf8c2d685f808594a816cbe4ca", size = 1123235, upload-time = "2026-09-04T06:04:38.491Z" },
 ]
 
 [package.optional-dependencies]
@@ -1106,16 +1106,16 @@ tracing = [
 
 [[package]]
 name = "nooa-cli"
-version = "0.0.9"
+version = "0.0.10"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "nooa" },
     { name = "pyyaml" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/41/0b/ab13465d13cfa6b29e1521e672ea44e02a70ebd4977df7c2b4ed34f0d038/nooa_cli-0.0.9.tar.gz", hash = "sha256:5bc45f6328fd4cb02531278db1779f51a83f3b8e631cba818caf133f3631e4c8", size = 68335, upload-time = "2026-08-18T14:59:30.3Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/36/c6/d1e555b461b508cf43b9c8ba55f3359dc94fbcbda231013c101ef5543297/nooa_cli-0.0.10.tar.gz", hash = "sha256:845d029afaed26166ca16ed15bfa69308703aac7aefc6afece5cddfa47ecbf6e", size = 89911, upload-time = "2026-09-04T06:04:33.448Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/34/9acdbac505979b0f765288db9272b10205674240689a9a3901d535412d38/nooa_cli-0.0.9-py3-none-any.whl", hash = "sha256:e8fad7b7a1601c9d7206c8d92c3cabeca2539af96c7e75923261b096a3616b09", size = 72613, upload-time = "2026-08-18T14:59:29.324Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/cd/c9a53e62e08394b30f0f2de466f6d61b2ab66b32de0be1e23be2ff9ffbfa/nooa_cli-0.0.10-py3-none-any.whl", hash = "sha256:0a9414898f12c51797b0ba2cf8ece97899dcf30e684690d72b54cceac6afdb4e", size = 86303, upload-time = "2026-09-04T06:04:34.245Z" },
 ]
 
 [[package]]