noah-code 0.6.0__tar.gz → 0.7.0__tar.gz

{noah_code-0.6.0 → noah_code-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: noah-code
-Version: 0.6.0
+Version: 0.7.0
 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
@@ -137,6 +137,9 @@ noah --mode plan .
 # Run one task and exit
 noah run "Explain how authentication is wired" .
 
+# Emit one structured result on stdout (progress goes to stderr)
+noah run --json "Fix the failing unit test" .
+
 # Allow actions that would normally ask; explicit deny rules still apply
 noah run --auto "Fix the failing unit test" .
 
@@ -148,6 +151,13 @@ noah --session SESSION_ID .
 noah --console .
 ```
 
+`run --json` reports `status` (`completed`, `needs_input`, `failed`, or `cancelled`),
+`exit_code`, `explanation`, `session_id`, `run_id`, session `usage`, and recorded `checks`.
+Check `status` when automating: a request for input keeps the existing exit code 0,
+but its status is `needs_input`. Check results are separate from task completion;
+an empty list means no checks were recorded. Errors keep nonzero exit codes and
+Ctrl+C returns 130. Delegated agents also retain `needs_input` in the work ledger.
+
 Check the installation and resolved configuration with:
 
 ```bash
@@ -170,9 +180,14 @@ Type `/` to search the full command and configuration reference. The most common
 | `Shift+Enter` / `Ctrl+J` | Insert a newline |
 | `Alt+Enter` | Expand or collapse the composer |
 | `Alt+Z` | Restore a displaced draft |
+| Click / arrows in the prompt | Position the editing cursor |
+| `Ctrl+A` / `Ctrl+X` / `Ctrl+V` | Select all / cut / paste prompt text |
+| `Ctrl+Z` / `Ctrl+Y` | Undo / redo prompt edits |
+| `Ctrl+Home` / `Ctrl+End` | Jump to the beginning / end of the prompt; Shift selects |
 | 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+P` | Search and run slash commands |
 | `Ctrl+L` | Open the model picker |
 | `Ctrl+R` | Search and recall a prior prompt |
 | `Ctrl+T` | Expand or collapse live tool output |
@@ -180,6 +195,7 @@ Type `/` to search the full command and configuration reference. The most common
 | `Alt+Up` | Recall the newest queued prompt for editing |
 | `Ctrl+]` | Return to live transcript output |
 | `Tab` / `Shift+Tab` | Navigate focus; Tab completes suggestions |
+| `Enter` or click a command | Run the selected slash command or open its picker; required arguments stay editable |
 | `Ctrl+B` | Switch between build and plan mode |
 | `Ctrl+D` | Review changes while working or idle |
 | `Ctrl+C` | Stop the current run and pause queued follow-ups |

{noah_code-0.6.0 → noah_code-0.7.0}/README.md

@@ -91,6 +91,9 @@ noah --mode plan .
 # Run one task and exit
 noah run "Explain how authentication is wired" .
 
+# Emit one structured result on stdout (progress goes to stderr)
+noah run --json "Fix the failing unit test" .
+
 # Allow actions that would normally ask; explicit deny rules still apply
 noah run --auto "Fix the failing unit test" .
 
@@ -102,6 +105,13 @@ noah --session SESSION_ID .
 noah --console .
 ```
 
+`run --json` reports `status` (`completed`, `needs_input`, `failed`, or `cancelled`),
+`exit_code`, `explanation`, `session_id`, `run_id`, session `usage`, and recorded `checks`.
+Check `status` when automating: a request for input keeps the existing exit code 0,
+but its status is `needs_input`. Check results are separate from task completion;
+an empty list means no checks were recorded. Errors keep nonzero exit codes and
+Ctrl+C returns 130. Delegated agents also retain `needs_input` in the work ledger.
+
 Check the installation and resolved configuration with:
 
 ```bash
@@ -124,9 +134,14 @@ Type `/` to search the full command and configuration reference. The most common
 | `Shift+Enter` / `Ctrl+J` | Insert a newline |
 | `Alt+Enter` | Expand or collapse the composer |
 | `Alt+Z` | Restore a displaced draft |
+| Click / arrows in the prompt | Position the editing cursor |
+| `Ctrl+A` / `Ctrl+X` / `Ctrl+V` | Select all / cut / paste prompt text |
+| `Ctrl+Z` / `Ctrl+Y` | Undo / redo prompt edits |
+| `Ctrl+Home` / `Ctrl+End` | Jump to the beginning / end of the prompt; Shift selects |
 | 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+P` | Search and run slash commands |
 | `Ctrl+L` | Open the model picker |
 | `Ctrl+R` | Search and recall a prior prompt |
 | `Ctrl+T` | Expand or collapse live tool output |
@@ -134,6 +149,7 @@ Type `/` to search the full command and configuration reference. The most common
 | `Alt+Up` | Recall the newest queued prompt for editing |
 | `Ctrl+]` | Return to live transcript output |
 | `Tab` / `Shift+Tab` | Navigate focus; Tab completes suggestions |
+| `Enter` or click a command | Run the selected slash command or open its picker; required arguments stay editable |
 | `Ctrl+B` | Switch between build and plan mode |
 | `Ctrl+D` | Review changes while working or idle |
 | `Ctrl+C` | Stop the current run and pause queued follow-ups |

{noah_code-0.6.0 → noah_code-0.7.0}/docs/interactive-reference.md

@@ -4,13 +4,13 @@
 
 | Key | Action |
 |-----|--------|
-| `Enter` | Send the current message, or queue a follow-up while a turn is running |
+| `Enter` | Run the highlighted command, send the current message, or queue a follow-up while a turn is running |
 | `Shift+Enter` or `Ctrl+J` | Insert a newline without sending |
 | `Alt+Enter` | Expand or collapse the composer |
 | `Alt+Z` | Restore the draft saved before a palette or history selection |
 | `Tab` / `Shift+Tab` | Move focus forward/back; Tab completes an open suggestion |
 | `Ctrl+B` | Switch between build and plan mode |
-| `Ctrl+P` | Open the command palette |
+| `Ctrl+P` | Search and run slash commands |
 | `Ctrl+G` | Open the searchable skills picker |
 | `Ctrl+L` | Open the model picker |
 | `Ctrl+O` | Open the session picker |
@@ -57,9 +57,11 @@ finishes, explicitly marking omitted middle output when the capture limit is rea
 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.
+continuously. Use `Up`/`Down` to highlight a command, then press `Enter` or click once to run it
+or open its picker. `Tab` completes the command for editing, and `Esc` closes the list. Commands
+requiring arguments and file mentions remain editable. Typing `/config` expands the list to every
+resolved configuration path and its current redacted value. `Ctrl+P` offers the same single-action
+selection in a searchable command picker.
 
 Press `Ctrl+R` to search prompts already shown in the current session. Choosing one loads it into
 the composer without sending it and saves the displaced draft for `Alt+Z`. Palette choices
@@ -88,6 +90,28 @@ Inside the composer, `Cmd+C`/`Ctrl+C` copies the composer's
 own selection; `Ctrl+C` with no composer selection keeps its cancel-turn behavior. Selection uses a
 high-contrast highlight in every Noah theme.
 
+The prompt input supports mouse placement, drag selection, and normal text editing:
+
+| Prompt control | Action |
+| --- | --- |
+| Click / arrow keys | Place or move the cursor within the prompt |
+| `Shift` + arrow keys | Extend a selection |
+| `Ctrl+A` / `Cmd+A` | Select the entire prompt |
+| `Ctrl+X` / `Cmd+X` | Cut selected text; with no selection, cut the current line |
+| `Ctrl+C` / `Cmd+C` | Copy selected prompt text |
+| `Ctrl+V` / `Cmd+V` | Paste, replacing the selected text |
+| `Ctrl+Z` / `Ctrl+Y` | Undo / redo prompt edits |
+| `Home` / `End` | Move to the beginning / end of the current line |
+| `Ctrl+Home` / `Ctrl+End` | Move to the beginning / end of the entire prompt |
+| `Ctrl+Shift+Home` / `Ctrl+Shift+End` | Select to the beginning / end of the entire prompt |
+| `Ctrl+Left` / `Ctrl+Right` | Move by word; hold Shift to select |
+| `Alt+Enter` | Expand the prompt for longer edits |
+
+`Ctrl+A` now selects all; use `Home` for the former line-start behavior. Prompt undo is
+separate from `/undo`, which reverts workspace edits. A paste waits for an in-progress
+cut/copy to reach the clipboard; if the draft, selection, focus, or session changes while
+the clipboard is being read, that paste is cancelled to protect the newer input.
+
 ### Mid-turn follow-ups
 
 While Noah is working, the composer stays open. `Enter` queues the current text instead of starting

noah_code-0.7.0/docs/releases/v0.7.0.md

@@ -0,0 +1,51 @@
+# Noah Code v0.7.0
+
+Slash commands now run with one Enter or click. Check results are shared across agents and
+background jobs, and headless runs expose structured outcomes for automation.
+
+## Commands and editing
+
+- Enter or a single click runs the highlighted slash command or opens its picker. Tab completes
+  the command for editing; required arguments and file mentions remain editable.
+- Ctrl+P opens Noah's command picker and runs the selected command immediately. Displaced drafts
+  remain available through Alt+Z, and typed command arguments are preserved.
+- Prompt editing and clipboard handling are more reliable, including selection and paste behavior.
+
+## Shared verification
+
+- Foreground checks, streamed commands, subagents, background jobs, and terminal commands use a
+  shared session ledger. Records include the command, source, exit code, execution directory when
+  known, and workspace fingerprints before and after execution.
+- Receipts mark results stale when workspace files change during or after a check. Interrupted
+  checks remain incomplete, and unavailable workspace fingerprints are reported as unknown.
+- Agents can inspect the same evidence with `await self.ws.checks()`. Records survive session
+  reopening and are included in JSON outcomes. Headless outcomes refresh after process cleanup.
+- Workspace fingerprints use file metadata. Ignored untracked artifacts, external dependencies,
+  and metadata-preserving changes are outside their scope. Compound shell commands are not
+  credited as individual checks.
+
+## Task outcomes
+
+- Subagents requesting input retain a distinct `needs_input` state. The interface reports
+  "Input needed" instead of showing a completed turn.
+- `noah run --json` emits one result on stdout and sends progress to stderr. The result includes
+  `status`, `exit_code`, `explanation`, `session_id`, `run_id`, session `usage`, and `checks`.
+- Status distinguishes `completed`, `needs_input`, `failed`, and `cancelled`. Existing exit codes
+  remain compatible: both completion and waiting for input return zero, so automation should
+  inspect `status`. Task completion is separate from passing checks.
+- Headless follow-ups using `--session` continue the waiting run. Invalid agent stop reasons
+  and persistence failures are reported as failures.
+
+## Upgrade
+
+```bash
+noah update
+```
+
+Example structured run:
+
+```bash
+noah run --json "Fix the failing unit test" .
+```
+
+**Full changelog:** https://github.com/skundu42/noah-code/compare/v0.6.0...v0.7.0

{noah_code-0.6.0 → noah_code-0.7.0}/docs/reliability.md

@@ -142,6 +142,28 @@ unbounded growth. Delete sessions that are no longer needed with `noah sessions
 
 ## Observability
 
+### Verification evidence
+
+Foreground and streamed check commands, subagents, background jobs, and persistent-terminal
+commands share a bounded verification ledger. The agent can inspect it with
+`await self.ws.checks()`. Each record includes the observed exit code, command, source, execution
+directory when known, and workspace fingerprints before and after execution. Records persist with
+the session and are included in `noah run --json` results.
+
+Turn receipts recompute check status against the current workspace. A check becomes `stale` if
+files changed during or after its execution; missing fingerprints produce `unknown`, and an
+interrupted check is `incomplete`. A successful rerun supersedes the earlier attempt in the receipt.
+Completion and verification are separate: `completed` means the agent finished its turn, while
+the check records show the evidence available for its changes.
+
+Fingerprints use file metadata and symlink targets without reading file contents. In Git checkouts
+they cover tracked files and non-ignored untracked files; outside Git, common cache, build, and
+vendor directories are excluded. Ignored artifacts, external dependencies, and metadata-preserving
+edits are outside this check. Commands containing shell chaining, redirection, or expansion are
+not credited as individual checks because their exit code cannot establish each check's result.
+
+### Runtime status
+
 Use `/health` during idle or active work. It reports runtime database and artifact sizes, pending
 inbox items and interactions, live jobs, retained runtime events, and the current non-terminal run.
 Use `/status` for workspace/session state, `/tokens` for model and cache usage, `F2` for activity,

{noah_code-0.6.0 → noah_code-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "noah-code"
-version = "0.6.0"
+version = "0.7.0"
 description = "Noah Code terminal coding agent, built on NVIDIA OO Agents (NOOA)"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"

{noah_code-0.6.0 → noah_code-0.7.0}/src/noah_code/__init__.py

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

{noah_code-0.6.0 → noah_code-0.7.0}/src/noah_code/agent.py

@@ -123,6 +123,7 @@ class _PermissionSandboxedExecutor(SandboxedExecutor):
             ("workspace_root",),
             ("ws", "edit"),
             ("ws", "inspect"),
+            ("ws", "checks"),
             ("ws", "apply_patch"),
             ("ws", "apply_unified_diff"),
             ("ws", "list"),
@@ -484,6 +485,8 @@ call is async: always `await` it before iterating or accessing the result.
   returncode/stdout/stderr. `read_only=True` skips approval only for commands
   the engine recognizes as read-only (Git inspection, search, listing, text
   filters). It is rejected for pytest, uv, Python, builds, and mutations.
+- Inspect `await self.ws.checks()` for shared verification results. Rerun stale
+  checks after edits; a completed command alone does not prove the task is done.
 - Use `self.processes.start/logs/status/input/stop` for long jobs and consume
   logs by cursor. Persistent shells use `open_terminal`, `terminal_run`,
   `terminal_status`, and `close_terminal`; raw terminal input is blocked.
@@ -829,6 +832,7 @@ class CodingAgent(InteractiveAgent):
             lsp=self.lsp,
             runtime=runtime,
             coordinator=self._coordinator,
+            verification_source=f"subagent:{self.agent_id}" if nested else "main",
             output_store_root=runtime.artifact_dir if runtime is not None else None,
             output_store_max_bytes=config.reliability.artifact_max_bytes,
         )

{noah_code-0.6.0 → noah_code-0.7.0}/src/noah_code/cli.py

@@ -3,8 +3,11 @@
 from __future__ import annotations
 
 import asyncio
+import contextlib
+import json
 import os
 import sys
+from dataclasses import asdict, replace
 from pathlib import Path
 from typing import Any, Literal
 
@@ -20,7 +23,8 @@ from noah_code.config import (
     save_user_reasoning_effort,
     user_default_model,
 )
-from noah_code.host import AgentHost
+from noah_code.host import AgentHost, HostResult
+from noah_code.redaction import safe_error_message
 from noah_code.sessions import SessionError, SessionStore
 from noah_code.ui.console import ConsoleUI
 from noah_code.updates import (
@@ -192,6 +196,7 @@ def cli_group() -> None:
 @click.argument("path", required=False, type=click.Path())
 @_common_options
 @click.option("--session", "session_id", default=None)
+@click.option("--json", "json_output", is_flag=True, help="Print one JSON outcome; send progress to stderr")
 def run_cmd(
     prompt: str,
     path: str | None,
@@ -203,6 +208,7 @@ def run_cmd(
     max_iterations: int | None,
     session_id: str | None,
     unsafe_inprocess_code_execution: bool,
+    json_output: bool,
 ) -> None:
     """Run one coding task without opening the interactive interface."""
     code = _run_async(
@@ -217,6 +223,7 @@ def run_cmd(
             max_iterations=max_iterations,
             session_id=session_id,
             unsafe_inprocess_code_execution=unsafe_inprocess_code_execution,
+            json_output=json_output,
         )
     )
     raise SystemExit(code)
@@ -995,46 +1002,61 @@ async def _run_session(
     max_iterations: int | None,
     session_id: str | None,
     unsafe_inprocess_code_execution: bool,
+    json_output: bool = False,
 ) -> int:
     """Run one task through the normal host without automation-only adapters."""
 
-    prepared, code = await _prepare(
-        path=path,
-        model=model,
-        reasoning_effort=reasoning_effort,
-        auto=auto,
-        yolo=yolo,
-        mode=mode,
-        max_iterations=max_iterations,
-        session_id=session_id,
-        frontend="console",
-        unsafe_inprocess_code_execution=unsafe_inprocess_code_execution,
-        allow_auto_install=False,
-    )
-    if prepared is None:
-        return code
-    workspace, config, store, meta = prepared
-    host = AgentHost(
-        workspace,
-        config,
-        session_meta=meta,
-        store=store,
-        ui=ConsoleUI(markdown=config.ui.markdown),
-    )
-    try:
-        result = await host.run_once(prompt)
-        return result.exit_code
-    except KeyboardInterrupt:
-        host.cancel_active_turn()
-        return EXIT_SIGINT
-    except Exception as exc:  # noqa: BLE001 - keep one-shot failures concise
-        from noah_code.redaction import safe_error_message
-
-        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()
+    host: AgentHost | None = None
+    # Some provider libraries print directly; stdout stays machine-readable.
+    with contextlib.redirect_stdout(sys.stderr) if json_output else contextlib.nullcontext():
+        try:
+            prepared, code = await _prepare(
+                path=path,
+                model=model,
+                reasoning_effort=reasoning_effort,
+                auto=auto,
+                yolo=yolo,
+                mode=mode,
+                max_iterations=max_iterations,
+                session_id=session_id,
+                frontend="console",
+                unsafe_inprocess_code_execution=unsafe_inprocess_code_execution,
+                allow_auto_install=False,
+            )
+            if prepared is None:
+                result = HostResult(
+                    code, "Could not prepare the task; see stderr for details.",
+                    session_id, status="failed",
+                )
+            else:
+                workspace, config, store, meta = prepared
+                host = AgentHost(
+                    workspace, config, session_meta=meta, store=store,
+                    ui=ConsoleUI(markdown=config.ui.markdown),
+                )
+                try:
+                    result = await host.run_once(prompt)
+                finally:
+                    # Startup can fail before run_once reaches its cleanup block.
+                    await host.close()
+        except (Exception, asyncio.CancelledError, KeyboardInterrupt) as exc:
+            cancelled = isinstance(exc, (asyncio.CancelledError, KeyboardInterrupt))
+            code = EXIT_SIGINT if cancelled else EXIT_CONFIG if isinstance(exc, ConfigError) else EXIT_AGENT
+            explanation = "cancelled" if cancelled else safe_error_message(exc)
+            previous = getattr(host, "last_result", None)
+            result = replace(
+                previous if isinstance(previous, HostResult) else HostResult(code, session_id=session_id),
+                exit_code=code, explanation=explanation,
+                status="cancelled" if cancelled else "failed",
+            )
+            if cancelled:
+                if host is not None:
+                    host.cancel_active_turn()
+            else:
+                click.echo(f"error: {explanation}", err=True)
+    if json_output:
+        click.echo(json.dumps(asdict(result), ensure_ascii=False))
+    return result.exit_code
 
 
 def main(argv: list[str] | None = None) -> None:

{noah_code-0.6.0 → noah_code-0.7.0}/src/noah_code/host.py

@@ -9,7 +9,7 @@ import logging
 import re
 import shlex
 from collections.abc import Coroutine
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Literal
 
@@ -197,6 +197,10 @@ class HostResult:
     exit_code: int
     explanation: str = ""
     session_id: str | None = None
+    status: Literal["completed", "needs_input", "failed", "cancelled"] = "completed"
+    run_id: str | None = None
+    usage: dict[str, int | float] | None = None
+    checks: list[dict[str, Any]] = field(default_factory=list)
 
 
 @dataclass(frozen=True)
@@ -238,6 +242,7 @@ class AgentHost:
         self._hooks: Any = None
         self._checkpoints: Any = None
         self.last_checkpoint: dict[str, Any] | None = None
+        self.last_result: HostResult | None = None
         self._post_hook_tasks: list[asyncio.Task[Any]] = []
         self._trace_info = "session jsonl"
         self._telemetry = AgentTelemetry()
@@ -750,7 +755,7 @@ class AgentHost:
         prompt = " ".join(str(activity.get("prompt", "")).split())[:80]
         duration = float(activity.get("duration", 0.0) or 0.0)
         detail = f" · {prompt}" if prompt else ""
-        elapsed = f" · {duration:.1f}s" if state in {"completed", "failed", "cancelled"} else ""
+        elapsed = f" · {duration:.1f}s" if state in {"completed", "needs_input", "failed", "cancelled"} else ""
         self.ui.render(
             HostEvent(
                 HostEventKind.STATUS,
@@ -2493,6 +2498,9 @@ class AgentHost:
         explanation = ""
         run_state: Any = "running"
         telemetry_error_type = ""
+        turn_result = HostResult(
+            exit_code=0, session_id=self.meta.session_id if self.meta else None, run_id=run_id,
+        )
         try:
             agent.journal.begin_turn()
             if recovery:
@@ -2508,11 +2516,7 @@ class AgentHost:
                     exit_code = 1
                     run_state = "failed"
                     explanation = "No waiting prompt could be expanded"
-                    return HostResult(
-                        exit_code=exit_code,
-                        explanation=explanation,
-                        session_id=self.meta.session_id if self.meta else None,
-                    )
+                    return turn_result
             else:
                 self._deliver_expanded(agent, self._expand_user_text(text, attach_paths))
 
@@ -2590,9 +2594,11 @@ class AgentHost:
                             "and consume any relevant logs, then continue the task.",
                         )
                         continue
-                    else:
+                    elif kind == RespondReason.DONE:
                         exit_code = 0
                         run_state = "completed"
+                    else:
+                        raise RuntimeError(f"Agent returned an invalid stop reason: {kind!r}")
                 except PermissionError as exc:
                     exit_code = 3
                     run_state = "failed"
@@ -2665,6 +2671,8 @@ class AgentHost:
                     )
             except Exception as persist_error:
                 run_state = "failed"
+                exit_code = 1
+                explanation = safe_error_message(persist_error)
                 telemetry_error_type = type(persist_error).__name__
                 if runtime is not None and run_id is not None:
                     with contextlib.suppress(Exception):
@@ -2680,12 +2688,21 @@ class AgentHost:
                     outcome=outcome,
                     error_type=telemetry_error_type,
                 )
+                turn_result.exit_code = exit_code or (1 if outcome == "failed" else 0)
+                turn_result.explanation = explanation
+                turn_result.status = (
+                    "needs_input" if outcome == "waiting_user" else
+                    "completed" if outcome == "completed" else
+                    "cancelled" if outcome == "cancelled" else "failed"
+                )
+                turn_result.usage = self.usage_snapshot().to_dict()
+                self.last_result = turn_result
                 self._current_run_id = None
-        return HostResult(
-            exit_code=exit_code,
-            explanation=explanation,
-            session_id=self.meta.session_id if self.meta else None,
-        )
+                ledger = getattr(agent.ws, "_verification", None)
+                if ledger is not None:
+                    with contextlib.suppress(Exception):
+                        turn_result.checks = await ledger.snapshot(since=0.0)
+        return turn_result
 
     def _background_task_origin(self, agent: Any) -> _BackgroundTaskOrigin:
         if self.meta is None:
@@ -2909,6 +2926,7 @@ class AgentHost:
 
     async def run_once(self, prompt: str) -> HostResult:
         await self.start()
+        ledger = getattr(self.agent.ws, "_verification", None)
         try:
             if self.config.auto_approve:
 
@@ -2926,7 +2944,15 @@ class AgentHost:
                 self.agent.approvals.set_handler(_reject)
 
             await self.resume_interrupted_run()
-            result = await self._run_user_turn(prompt)
+            continuable = self._runtime.latest_incomplete_run() if self._runtime else None
+            run_id = continuable.run_id if continuable and continuable.state == "waiting_user" else None
+            result = await self._run_user_turn(prompt, run_id=run_id)
             return result
         finally:
-            await self.close()
+            try:
+                await self.close()
+            finally:
+                # Teardown may terminate a check that was still running at DONE.
+                if self.last_result is not None and ledger is not None:
+                    with contextlib.suppress(Exception):
+                        self.last_result.checks = await ledger.snapshot(since=0.0)

{noah_code-0.6.0 → noah_code-0.7.0}/src/noah_code/tools/process_tools.py

@@ -21,6 +21,7 @@ from typing import TYPE_CHECKING, Annotated, Any
 from nooa import Skill, hidden, spec
 
 from noah_code.tools.workspace_tools import WorkspaceTools
+from noah_code.verification import CheckRecord
 
 if TYPE_CHECKING:
     from noah_code.runtime_state import RuntimeStateStore
@@ -56,6 +57,7 @@ class BackgroundJob:
     tasks: list[asyncio.Task[Any]] = field(default_factory=list)
     command_lock: asyncio.Lock = field(default_factory=asyncio.Lock)
     output_event: asyncio.Event = field(default_factory=asyncio.Event)
+    check: CheckRecord | None = None
 
     @property
     def elapsed(self) -> float:
@@ -201,13 +203,20 @@ class ProcessTools(Skill):
                 payload = f"{command}\r\necho {marker}:%errorlevel%\r\n"
             else:
                 payload = f"{command}\nprintf '\\n{marker}:%s\\n' \"$?\"\n"
-            await self._write_input(job, payload)
-            output, returncode = await self._wait_for_terminal_marker(
-                job,
-                cursor=cursor,
-                marker=marker,
-                timeout=wait_timeout,
+            check = await self._ws._verification.begin(
+                command, source=f"{self._ws._verification_source}:terminal:{job.name}"
             )
+            returncode = None
+            try:
+                await self._write_input(job, payload)
+                output, returncode = await self._wait_for_terminal_marker(
+                    job,
+                    cursor=cursor,
+                    marker=marker,
+                    timeout=wait_timeout,
+                )
+            finally:
+                await self._ws._verification.finish(check, returncode)
         bounded = output.strip()
         if len(bounded) > 32_000:
             bounded = bounded[:16_000] + "\n… terminal output bounded …\n" + bounded[-16_000:]
@@ -253,16 +262,24 @@ class ProcessTools(Skill):
                 for job in self._jobs.values()
             ):
                 raise ValueError(f"terminal name already exists: {name}")
-            process = await asyncio.create_subprocess_exec(
-                *argv,
+            check = await self._ws._verification.begin(
+                command, source=f"{self._ws._verification_source}:job:{name}",
                 cwd=self._ws._workspace.root,
-                stdin=asyncio.subprocess.PIPE,
-                stdout=asyncio.subprocess.PIPE,
-                stderr=(
-                    asyncio.subprocess.STDOUT if kind == "terminal" else asyncio.subprocess.PIPE
-                ),
-                start_new_session=os.name != "nt",
-            )
+            ) if kind == "process" else None
+            try:
+                process = await asyncio.create_subprocess_exec(
+                    *argv,
+                    cwd=self._ws._workspace.root,
+                    stdin=asyncio.subprocess.PIPE,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=(
+                        asyncio.subprocess.STDOUT if kind == "terminal" else asyncio.subprocess.PIPE
+                    ),
+                    start_new_session=os.name != "nt",
+                )
+            except BaseException:
+                await self._ws._verification.finish(check, None)
+                raise
             job_id = uuid.uuid4().hex[:8]
             log_path = self._runtime.process_log_dir / f"{job_id}.jsonl" if self._runtime else None
             job = BackgroundJob(
@@ -272,6 +289,7 @@ class ProcessTools(Skill):
                 process=process,
                 log_path=log_path,
                 kind=kind,
+                check=check,
             )
             self._jobs[job_id] = job
         try:
@@ -287,6 +305,7 @@ class ProcessTools(Skill):
                     log_path=log_path or self._runtime.process_log_dir / f"{job_id}.jsonl",
                 )
         except Exception:
+            await self._ws._verification.finish(job.check, None)
             with contextlib.suppress(Exception):
                 await self._terminate(job)
             self._close_transport(process)
@@ -671,6 +690,9 @@ class ProcessTools(Skill):
         elif job.state == "stopping":
             job.state = "stopped"
         job.returncode = returncode
+        await self._ws._verification.finish(
+            job.check, returncode if job.state in {"completed", "failed"} else None
+        )
         job.finished_at = time.monotonic()
         job.output_event.set()
         if self._runtime is not None: