noah-code 0.1.0__tar.gz → 0.1.1__tar.gz

{noah_code-0.1.0 → noah_code-0.1.1}/.github/workflows/release.yml

@@ -105,6 +105,11 @@ jobs:
       id-token: write
       attestations: write
     steps:
+      - name: Check out tagged release notes
+        uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+
       - name: Download release distributions
         uses: actions/download-artifact@v6
         with:
@@ -123,5 +128,12 @@ jobs:
       - name: Create release and upload assets
         env:
           GH_TOKEN: ${{ github.token }}
+          GH_REPO: ${{ github.repository }}
           RELEASE_TAG: ${{ github.ref_name }}
-        run: gh release create "$RELEASE_TAG" dist/* --verify-tag --generate-notes --title "$RELEASE_TAG"
+        run: |
+          notes_file="docs/releases/${RELEASE_TAG}.md"
+          if [ -f "$notes_file" ]; then
+            gh release create "$RELEASE_TAG" dist/* --verify-tag --notes-file "$notes_file" --title "$RELEASE_TAG"
+          else
+            gh release create "$RELEASE_TAG" dist/* --verify-tag --generate-notes --title "$RELEASE_TAG"
+          fi

{noah_code-0.1.0 → noah_code-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: noah-code
-Version: 0.1.0
+Version: 0.1.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
@@ -58,10 +58,6 @@ or system package setup is required.
 ```bash
 curl -LsSf https://raw.githubusercontent.com/skundu42/noah-code/main/install.sh | sh
 ```
-
-The bootstrapper validates macOS/Linux support, installs the standalone uv package manager, and
-downloads an isolated Python 3.12 runtime plus Noah Code. It does not modify a system Python.
-
 Open a new terminal, move into a repository, and run:
 
 ```bash
@@ -80,8 +76,11 @@ and seccomp support. You also need an LLM provider account such as OpenAI, Anthr
 - Switch between implementation-focused **build** mode and read-only **plan** mode.
 - Approve actions once or for a session with ordered `allow`, `ask`, and `deny` rules.
 - Undo and redo journaled file edits across process restarts.
-- Work in a full-screen TUI, a classic console, or one-shot non-interactive mode.
+- Work in an adaptive Atom One Dark cockpit, a classic console, or one-shot non-interactive mode.
+- Type `/` for a live-filtering command and configuration reference; press Enter to send.
+- Follow batched live tool output, then inspect compact execution records with `F2`.
 - Resume workspace-scoped sessions with todos and automatic context compaction.
+- Switch AI models between turns, with optional cross-repository defaults.
 - Extend workflows with slash commands, opt-in skills, MCP servers, model selection, and tracing.
 
 ## Quick start
@@ -133,6 +132,15 @@ The package also installs `noah-code` and `nc` as equivalent entry points. Becau
 refers to netcat, `noah` or `noah-code` is recommended. Keep provider API keys in the environment
 or trusted NOOA user configuration, never in a repository or Noah Code session metadata.
 
+Inside a session, `/model MODEL` switches the active model immediately and remembers it when that
+session is resumed. It does not change other sessions. Use `/model --global MODEL` when the new
+model should also become the default for future sessions in every repository.
+
+The TUI keeps the conversation central and adds a session-and-plan rail on terminals at least
+110 columns wide. Tool output streams in a bounded activity panel and compacts after completion,
+keeping long runs responsive without deleting persisted session data. Press `F2` for activity
+details or `F3` for paginated conversation history.
+
 ## Documentation
 
 - [Interactive interface and sessions](docs/interactive-reference.md)
@@ -140,6 +148,7 @@ or trusted NOOA user configuration, never in a repository or Noah Code session m
 - [Generated-code security](docs/security.md)
 - [Custom commands, skills, MCP, and tracing](docs/extensions.md)
 - [Development, CI, and releases](docs/development.md)
+- [Release notes](docs/releases/)
 
 ## Updates
 

{noah_code-0.1.0 → noah_code-0.1.1}/README.md

@@ -16,10 +16,6 @@ or system package setup is required.
 ```bash
 curl -LsSf https://raw.githubusercontent.com/skundu42/noah-code/main/install.sh | sh
 ```
-
-The bootstrapper validates macOS/Linux support, installs the standalone uv package manager, and
-downloads an isolated Python 3.12 runtime plus Noah Code. It does not modify a system Python.
-
 Open a new terminal, move into a repository, and run:
 
 ```bash
@@ -38,8 +34,11 @@ and seccomp support. You also need an LLM provider account such as OpenAI, Anthr
 - Switch between implementation-focused **build** mode and read-only **plan** mode.
 - Approve actions once or for a session with ordered `allow`, `ask`, and `deny` rules.
 - Undo and redo journaled file edits across process restarts.
-- Work in a full-screen TUI, a classic console, or one-shot non-interactive mode.
+- Work in an adaptive Atom One Dark cockpit, a classic console, or one-shot non-interactive mode.
+- Type `/` for a live-filtering command and configuration reference; press Enter to send.
+- Follow batched live tool output, then inspect compact execution records with `F2`.
 - Resume workspace-scoped sessions with todos and automatic context compaction.
+- Switch AI models between turns, with optional cross-repository defaults.
 - Extend workflows with slash commands, opt-in skills, MCP servers, model selection, and tracing.
 
 ## Quick start
@@ -91,6 +90,15 @@ The package also installs `noah-code` and `nc` as equivalent entry points. Becau
 refers to netcat, `noah` or `noah-code` is recommended. Keep provider API keys in the environment
 or trusted NOOA user configuration, never in a repository or Noah Code session metadata.
 
+Inside a session, `/model MODEL` switches the active model immediately and remembers it when that
+session is resumed. It does not change other sessions. Use `/model --global MODEL` when the new
+model should also become the default for future sessions in every repository.
+
+The TUI keeps the conversation central and adds a session-and-plan rail on terminals at least
+110 columns wide. Tool output streams in a bounded activity panel and compacts after completion,
+keeping long runs responsive without deleting persisted session data. Press `F2` for activity
+details or `F3` for paginated conversation history.
+
 ## Documentation
 
 - [Interactive interface and sessions](docs/interactive-reference.md)
@@ -98,6 +106,7 @@ or trusted NOOA user configuration, never in a repository or Noah Code session m
 - [Generated-code security](docs/security.md)
 - [Custom commands, skills, MCP, and tracing](docs/extensions.md)
 - [Development, CI, and releases](docs/development.md)
+- [Release notes](docs/releases/)
 
 ## Updates
 

{noah_code-0.1.0 → noah_code-0.1.1}/docs/configuration.md

@@ -10,6 +10,28 @@ Configuration is merged in this order, with later layers taking precedence:
 4. `NOAH_CODE_*` environment variables.
 5. CLI flags.
 
+### First-run model setup
+
+The first interactive `noah` launch asks for an AI model before starting the agent. Noah Code
+saves that choice as the top-level `model` in `~/.config/noah-code/config.toml`, making it the
+default for every repository. Enter a LiteLLM model name or an alias from the NOOA model registry.
+
+An explicit `noah --model MODEL` on the first launch is saved without prompting. Project config,
+`NOAH_CODE_MODEL`, and later `--model` flags still override the user default according to the
+precedence above. Non-interactive commands such as `noah run`, `doctor`, and `config show` never
+open the onboarding prompt.
+
+Inside an interactive session, switch only the current session or replace the global default:
+
+```text
+/model openai/MODEL_NAME
+/model --global anthropic/MODEL_NAME
+```
+
+Model switches take effect between turns and are stored in the current session metadata, so a
+resumed session continues with its most recently selected model. A session-only `/model MODEL`
+does not change the user configuration or affect new sessions.
+
 Example user configuration:
 
 ```toml
@@ -21,6 +43,7 @@ cell_timeout = 120
 command_timeout = 60
 
 [ui]
+theme = "atom-one-dark"
 frontend = "tui"       # "tui" or "console"
 markdown = true
 stream_shell = true
@@ -60,12 +83,20 @@ A user-configured `permission_rules` array replaces the default rule array. Copy
 default you still want before adding overrides. Hard secret, destructive-shell, and plan-mode
 gates remain enforced in code.
 
-Inspect the resolved configuration with:
+Inspect the resolved configuration from the CLI or inside an interactive session. `/config`
+lists every nested path, while an optional path scopes the output. Values whose names look like
+credentials are redacted.
 
 ```bash
 noah config show .
 ```
 
+```text
+/config
+/config summarization
+/config updates.auto_install
+```
+
 Model and provider configuration follows NOOA conventions, including its model registry,
 environment variables, and configuration under `~/.config/nooa/`.
 

{noah_code-0.1.0 → noah_code-0.1.1}/docs/development.md

@@ -33,8 +33,10 @@ Before the first release, configure a PyPI Trusted Publisher for package `noah-c
 `skundu42`, repository `noah-code`, workflow `release.yml`, and GitHub environment `pypi`. The
 GitHub environment permits deployments only from tags matching `v*`.
 
-For every release, update the version in `pyproject.toml` and `src/noah_code/__init__.py`, commit
-and push the change, then push a matching annotated tag. For example:
+For every release, update the version in `pyproject.toml`, `src/noah_code/__init__.py`, and
+`uv.lock`. Add curated notes at `docs/releases/vX.Y.Z.md`; the release workflow uses that file
+when it exists and otherwise falls back to generated notes. Commit and push the change, then push
+a matching annotated tag. For example:
 
 ```bash
 git tag -a v0.2.0 -m "Noah Code v0.2.0"

noah_code-0.1.1/docs/interactive-reference.md

@@ -0,0 +1,96 @@
+# Interactive interface and sessions
+
+## TUI keybindings
+
+| Key | Action |
+|-----|--------|
+| `Enter` | Send the current message |
+| `Shift+Enter` | Insert a newline without sending |
+| `Ctrl+P` | Open the command palette |
+| `Ctrl+O` | Open the session picker |
+| `Ctrl+N` | Start a new session |
+| `Ctrl+C` | Cancel the active turn; press twice while idle to quit |
+| `Ctrl+Q` | Quit |
+| `F1` or `?` | Show help |
+| `F2` | Open recent activity and full captured output |
+| `F3` | Open paginated persisted conversation history |
+| `End` | 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
+session, or `3`/`Esc` to reject it.
+
+The TUI uses Atom One Dark by default. Its conversation-first layout adapts to terminal size. At
+110 columns or wider, a context rail shows the session, active tool, and up to six open or blocked
+todos. Narrow terminals retain the transcript, live activity, suggestions, and composer without
+the rail. Terminals 25 rows high or shorter use compact spacing.
+
+Type `/` in the composer to open the inline command list; the list remains visible and filters
+continuously. Use `Up`/`Down` to highlight a command, `Tab` to complete it, and `Esc` to close the
+list. `Enter` always sends the current command. Typing `/config` expands the list to every resolved
+configuration path and its current redacted value.
+
+Tool and shell output is batched into a live execution panel instead of forcing one full-screen
+redraw for every chunk. When the tool finishes, the panel becomes a compact transcript record with
+outcome, duration, and output-line count. `F2` retains the latest 100 activity records, bounded by
+the configured `max_output_chars` per activity.
+
+## Built-in slash commands
+
+| Command | Purpose |
+|---------|---------|
+| `/help` | Show interactive help |
+| `/config [PATH]` | Show every resolved setting or one nested path |
+| `/mode` | Show or switch between `build` and `plan` |
+| `/model [MODEL]` | Show or switch the active session model |
+| `/model --global MODEL` | Switch the active model and save it as the default for all repositories |
+| `/session`, `/sessions`, `/new`, `/continue` | Inspect, switch, create, and resume sessions |
+| `/compact` | Summarize older conversation context |
+| `/todos` | Show the agent's current task list |
+| `/status`, `/diff` | Inspect the repository |
+| `/undo`, `/redo` | Restore or reapply journaled file edits |
+| `/skills` | Inspect discovered skills |
+| `/trace` | Show the active tracing destination |
+| `/exit` | End the session |
+
+Examples:
+
+```text
+/config
+/config ui
+/config ui.theme
+```
+
+Use `/mode build|plan` and `/model MODEL` for settings that support live switching. Use
+`/model --global MODEL` to make that model the cross-repository default. Other settings are
+resolved at startup and should be changed in the user configuration file.
+
+`/model MODEL` takes effect before the next turn and persists in the current session, including
+after resuming it. Other sessions and repositories keep their existing defaults unless the
+`--global` form is used.
+
+## Session management
+
+```bash
+noah sessions list .
+noah sessions show SESSION_ID
+noah sessions delete SESSION_ID
+```
+
+Each session has a NOOA-backed SQLite database plus metadata for its workspace identity, model,
+mode, title, remembered permission rules, todos, and edit journal. Session files are created with
+private filesystem permissions and cannot accidentally be resumed against another workspace.
+
+The latest 50 persisted user, agent, summary, error, and activity events are restored after the
+TUI's first paint. `F3` loads older history in read-only pages of 50, so resuming a long session
+does not delay input or load the entire database into the transcript.
+
+Long conversations use token-budget summarization while preserving recent messages. Force
+compaction with `/compact`.
+
+File edits made through workspace tools record pre-images and post-images with content hashes:
+
+- `/undo` refuses to overwrite a file changed concurrently by the user.
+- A failed multi-file restoration is rolled back.
+- `/redo` survives process restarts.
+- A turn that ran a mutating shell command is marked as not fully reversible because the command
+  may have changed files outside the journal.

noah_code-0.1.1/docs/releases/v0.1.0.md

@@ -0,0 +1,25 @@
+# Noah Code v0.1.0
+
+The first public release of Noah Code: a terminal coding agent built on NVIDIA OO Agents (NOOA).
+
+## Highlights
+
+- One-command installation on macOS and Linux with an isolated, managed Python runtime.
+- Interactive Textual and classic console interfaces, plus one-shot `noah run` automation.
+- Repository exploration, guarded file editing, streamed shell commands, and Git inspection.
+- Build and read-only plan modes with ordered allow, ask, and deny permission rules.
+- Workspace-scoped persistent sessions with todos, context compaction, undo, and redo.
+- Support for repository instructions, custom slash commands, skills, MCP servers, tracing, and
+  multiple LLM providers through NOOA and LiteLLM.
+- Automatic PyPI update checks and a release pipeline with cross-platform CI, trusted publishing,
+  checksums, and artifact attestations.
+
+## Install
+
+```bash
+curl -LsSf https://raw.githubusercontent.com/skundu42/noah-code/main/install.sh | sh
+```
+
+Then open a repository with `noah .`.
+
+**Full changelog:** https://github.com/skundu42/noah-code/commits/v0.1.0

noah_code-0.1.1/docs/releases/v0.1.1.md

@@ -0,0 +1,40 @@
+# Noah Code v0.1.1
+
+This release makes the interactive experience faster, clearer, and easier to configure across
+repositories.
+
+## Highlights
+
+- Added first-run AI model setup with a private global default in
+  `~/.config/noah-code/config.toml`.
+- Added `/model MODEL` for persistent session-level switching and `/model --global MODEL` for the
+  cross-repository default.
+- Made Atom One Dark the default theme and added live slash-command and configuration discovery.
+- Added an adaptive conversation-first cockpit with a session and todo rail on wide terminals.
+- Grouped tool execution into a live activity ledger that compacts successful work while retaining
+  details through `F2`.
+- Added paginated, read-only conversation history through `F3` when resuming sessions.
+- Added keyboard-driven command and session pickers, safer approval cards, scroll locking, and new
+  output indicators.
+- Batched high-volume shell events and bounded display history; the 2,000-chunk local benchmark
+  improved from approximately 454 ms to 123 ms.
+
+## Reliability
+
+- Added structured activity correlation and isolated SQLite history reads.
+- Expanded responsive-layout, event batching, history, model configuration, markup safety, and
+  session persistence coverage to 92 tests.
+- Corrected GitHub release repository context and added curated release-note support to the release
+  workflow.
+
+## Upgrade
+
+Existing managed installations can run:
+
+```bash
+noah update
+```
+
+New installations can use the one-command installer from the README.
+
+**Full changelog:** https://github.com/skundu42/noah-code/compare/v0.1.0...v0.1.1

{noah_code-0.1.0 → noah_code-0.1.1}/pyproject.toml

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

{noah_code-0.1.0 → noah_code-0.1.1}/src/noah_code/__init__.py

@@ -1,3 +1,3 @@
 """Noah Code: terminal coding harness on NVIDIA OO Agents."""
 
-__version__ = "0.1.0"
+__version__ = "0.1.1"

{noah_code-0.1.0 → noah_code-0.1.1}/src/noah_code/cli.py

@@ -3,13 +3,20 @@
 from __future__ import annotations
 
 import asyncio
+import os
 import sys
 from typing import Any, Literal
 
 import click
 
 from noah_code import __version__
-from noah_code.config import config_sources, load_config
+from noah_code.config import (
+    NoahCodeConfig,
+    config_sources,
+    load_config,
+    save_user_default_model,
+    user_default_model,
+)
 from noah_code.host import AgentHost
 from noah_code.sessions import SessionError, SessionStore
 from noah_code.ui.console import ConsoleUI
@@ -41,10 +48,50 @@ def _common_options(fn):  # noqa: ANN001
     fn = click.option(
         "--auto", is_flag=True, help="Auto-approve ask decisions (never overrides deny)"
     )(fn)
-    fn = click.option("--model", "model", default=None, help="Override model alias")(fn)
+    fn = click.option(
+        "--model", "model", default=None, help="Override the model for this launch"
+    )(fn)
     return fn
 
 
+def _configure_first_run_model(model_override: str | None) -> str | None:
+    """Prompt once for a cross-repository default before an interactive launch."""
+
+    if user_default_model() is not None:
+        return model_override
+
+    if model_override is not None:
+        path = save_user_default_model(model_override)
+        click.echo(f"Saved {model_override} as the default model in {path}.", err=True)
+        return model_override
+
+    suggested = os.environ.get("NOAH_CODE_MODEL") or NoahCodeConfig().model
+    click.secho("Noah Code · first-run model setup", fg="bright_blue", bold=True, err=True)
+    click.echo(
+        "Choose the model Noah Code should use by default in every repository.",
+        err=True,
+    )
+    click.echo(
+        "Enter a LiteLLM model name or a configured NOOA model alias. "
+        "Repository config, environment variables, and --model can override it later.",
+        err=True,
+    )
+    click.echo(
+        "You can switch models between turns with /model MODEL, without starting a new session.",
+        err=True,
+    )
+
+    while True:
+        selected = click.prompt("Default model", default=suggested, show_default=True).strip()
+        try:
+            path = save_user_default_model(selected)
+        except ValueError as exc:
+            click.echo(f"Invalid model: {exc}", err=True)
+            continue
+        click.echo(f"Saved the global default in {path}.", err=True)
+        return selected
+
+
 @click.command("noah-code")
 @click.version_option(__version__, prog_name="noah-code")
 @click.argument("path", required=False, type=click.Path())
@@ -327,6 +374,15 @@ async def _interactive(
     use_console: bool,
     unsafe_inprocess_code_execution: bool,
 ) -> int:
+    try:
+        model = _configure_first_run_model(model)
+    except (OSError, ValueError) as exc:
+        click.echo(f"error: first-run model setup failed: {exc}", err=True)
+        return EXIT_CONFIG
+    except click.Abort:
+        click.echo("error: first-run model setup was cancelled", err=True)
+        return EXIT_CONFIG
+
     frontend: Literal["tui", "console"] | None = "console" if use_console else None
     prepared, code = await _prepare(
         path=path,
@@ -399,8 +455,6 @@ async def _run_once(
 
 def _launched_as_nc() -> bool:
     """Detect whether the process was launched as `nc` or `noah`."""
-    import os
-
     name = os.path.basename(sys.argv[0]) if sys.argv else ""
     return name in {"nc", "nc.exe", "noah", "noah.exe"}
 
@@ -408,8 +462,6 @@ def _launched_as_nc() -> bool:
 def main(argv: list[str] | None = None) -> None:
     """Dispatch: subcommands via group; otherwise interactive with optional PATH."""
     args = list(sys.argv[1:] if argv is None else argv)
-    import os
-
     base = os.path.basename(sys.argv[0]) if sys.argv else "noah-code"
     prog = base if base in {"nc", "noah", "noah-code"} else "noah-code"
     if args and args[0] in SUBCOMMANDS:

noah_code-0.1.1/src/noah_code/commands.py

@@ -0,0 +1,173 @@
+"""Slash-command and host command helpers."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from typing import Any
+
+from noah_code.custom_commands import CustomCommand
+
+
+@dataclass(frozen=True)
+class CommandSpec:
+    name: str
+    description: str
+    usage: str | None = None
+    host_only: bool = False
+
+    @property
+    def invocation(self) -> str:
+        return f"/{self.usage or self.name}"
+
+
+@dataclass(frozen=True)
+class CommandSuggestion:
+    invocation: str
+    description: str
+
+
+BUILTIN_COMMANDS: list[CommandSpec] = [
+    CommandSpec("help", "Show available commands", host_only=True),
+    CommandSpec("config", "Show every resolved setting or one path", "config [PATH]", True),
+    CommandSpec("mode", "Show or switch the active mode", "mode [build|plan]", True),
+    CommandSpec("model", "Show or switch the model for this session", "model [MODEL]", True),
+    CommandSpec("session", "Show current session", host_only=True),
+    CommandSpec("sessions", "List or switch sessions", "sessions [SESSION_ID]", True),
+    CommandSpec("new", "Start a new session", host_only=True),
+    CommandSpec("continue", "Resume most recent session", host_only=True),
+    CommandSpec("compact", "Trigger history summarization", host_only=True),
+    CommandSpec("todos", "Show todo list", host_only=True),
+    CommandSpec("status", "Show mode/model/session/context", host_only=True),
+    CommandSpec("diff", "Show git diff", host_only=True),
+    CommandSpec("undo", "Undo last WorkspaceTools turn", host_only=True),
+    CommandSpec("redo", "Redo last undone turn", host_only=True),
+    CommandSpec("skills", "Show discovered/activated skills", host_only=True),
+    CommandSpec("trace", "Show tracing destination", host_only=True),
+    CommandSpec("exit", "Exit Noah Code", host_only=True),
+]
+
+
+_SECRET_CONFIG_PARTS = (
+    "api_key",
+    "authorization",
+    "credential",
+    "password",
+    "private_key",
+    "secret",
+    "token",
+)
+
+
+def _config_mapping(config: Any) -> dict[str, Any]:
+    if hasattr(config, "model_dump"):
+        value = config.model_dump(mode="json")
+    elif isinstance(config, dict):
+        value = config
+    else:
+        raise TypeError("config must be a Pydantic model or mapping")
+    if not isinstance(value, dict):
+        raise TypeError("config did not resolve to a mapping")
+    return value
+
+
+def _redacted_config_value(path: str, value: Any) -> Any:
+    normalized = path.lower().replace("-", "_")
+    if any(part in normalized for part in _SECRET_CONFIG_PARTS):
+        return "***"
+    return value
+
+
+def _flatten_config(value: Any, prefix: str = "") -> list[tuple[str, Any]]:
+    if isinstance(value, dict) and value:
+        rows: list[tuple[str, Any]] = []
+        for key, child in value.items():
+            path = f"{prefix}.{key}" if prefix else str(key)
+            rows.extend(_flatten_config(child, path))
+        return rows
+    return [(prefix, _redacted_config_value(prefix, value))]
+
+
+def config_entries(config: Any, path: str = "") -> list[tuple[str, str]]:
+    """Return redacted leaf settings, optionally scoped to a dotted path."""
+
+    rows = _flatten_config(_config_mapping(config))
+    query = path.strip().lower().strip(".")
+    if query:
+        rows = [
+            (key, value)
+            for key, value in rows
+            if key.lower() == query or key.lower().startswith(f"{query}.")
+        ]
+    return [(key, json.dumps(value, ensure_ascii=False, sort_keys=True)) for key, value in rows]
+
+
+def config_text(config: Any, path: str = "") -> str:
+    rows = config_entries(config, path)
+    if not rows:
+        raise KeyError(path)
+    width = max(len(key) for key, _value in rows)
+    title = f"Resolved configuration ({path.strip()}):" if path.strip() else "Resolved configuration:"
+    return "\n".join([title, "", *(f"  {key:<{width}}  {value}" for key, value in rows)])
+
+
+def all_command_suggestions(
+    custom: dict[str, CustomCommand] | None = None,
+) -> list[CommandSuggestion]:
+    suggestions = [
+        CommandSuggestion(command.invocation, command.description) for command in BUILTIN_COMMANDS
+    ]
+    suggestions.append(
+        CommandSuggestion("/model --global MODEL", "Set the default model for every repository")
+    )
+    if custom:
+        suggestions.extend(
+            CommandSuggestion(f"/{name} [ARGS]", command.description)
+            for name, command in sorted(custom.items())
+        )
+    return suggestions
+
+
+def config_command_suggestions(config: Any) -> list[CommandSuggestion]:
+    suggestions = []
+    for path, value in config_entries(config):
+        display_value = value if len(value) <= 80 else f"{value[:77]}…"
+        suggestions.append(CommandSuggestion(f"/config {path}", f"current: {display_value}"))
+    return suggestions
+
+
+def help_text(custom: dict[str, CustomCommand] | None = None) -> str:
+    lines = ["Noah Code commands:", ""]
+    for cmd in BUILTIN_COMMANDS:
+        lines.append(f"  {cmd.invocation:<28} {cmd.description}")
+    lines.append(f"  {'/model --global MODEL':<28} Set the default model for every repository")
+    if custom:
+        lines.append("")
+        lines.append("Custom commands:")
+        for name, c in sorted(custom.items()):
+            lines.append(f"  /{name:<12} {c.description} ({c.source})")
+    lines.append("")
+    lines.append(
+        "File-journal undo only covers WorkspaceTools edits, not arbitrary shell mutations."
+    )
+    return "\n".join(lines)
+
+
+def all_command_names(custom: dict[str, CustomCommand] | None = None) -> list[str]:
+    names = [f"/{c.name}" for c in BUILTIN_COMMANDS]
+    if custom:
+        names.extend(f"/{n}" for n in sorted(custom))
+    return names
+
+
+def parse_slash(text: str) -> tuple[str, str] | None:
+    stripped = text.strip()
+    if not stripped.startswith("/"):
+        return 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(), ""