haru-cli 0.1.0__tar.gz

haru_cli-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,120 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: Python ${{ matrix.python }}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python: ["3.13", "3.14"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+          python-version: ${{ matrix.python }}
+
+      - name: Sync dependencies
+        run: uv sync --locked
+
+      - name: Lint
+        run: uv run ruff check
+
+      - name: Format check
+        run: uv run ruff format --check
+
+      - name: Type check
+        run: uv run mypy src
+
+      - name: Tests (coverage gate 90%)
+        run: uv run pytest
+
+      - name: CLI smoke test
+        run: uv run haru --version
+
+  # Auto-tag on push to main (dcert pattern): determine the next semver patch
+  # version from the latest v* tag, bump pyproject.toml + uv.lock with a
+  # [skip ci] commit, push the tag, then explicitly dispatch the release
+  # workflow at that tag (tags pushed with GITHUB_TOKEN do not trigger
+  # workflows on their own; workflow_dispatch is exempt).
+  auto-tag:
+    name: Auto-tag release
+    if: github.ref == 'refs/heads/main' && github.event_name == 'push'
+    needs: [test]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      actions: write
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Determine next version
+        id: version
+        run: |
+          LATEST_TAG=$(git tag --list 'v[0-9]*.[0-9]*.[0-9]*' --sort=-v:refname | head -1)
+          if [ -z "$LATEST_TAG" ]; then
+            # First release: use the version already declared in pyproject.toml
+            NEXT=$(python3 -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])")
+          else
+            CURRENT="${LATEST_TAG#v}"
+            MAJOR=$(echo "$CURRENT" | cut -d. -f1)
+            MINOR=$(echo "$CURRENT" | cut -d. -f2)
+            PATCH=$(echo "$CURRENT" | cut -d. -f3 | cut -d- -f1)
+            NEXT="${MAJOR}.${MINOR}.$((PATCH + 1))"
+          fi
+          echo "version=${NEXT}" >> "$GITHUB_OUTPUT"
+          echo "tag=v${NEXT}" >> "$GITHUB_OUTPUT"
+          echo "Next version: ${NEXT} (tag: v${NEXT})"
+
+      - name: Check if tag already exists
+        id: check_tag
+        run: |
+          if git rev-parse "refs/tags/${{ steps.version.outputs.tag }}" >/dev/null 2>&1; then
+            echo "exists=true" >> "$GITHUB_OUTPUT"
+            echo "Tag ${{ steps.version.outputs.tag }} already exists, skipping"
+          else
+            echo "exists=false" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Bump version, commit, and tag
+        if: steps.check_tag.outputs.exists == 'false'
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          TAG="${{ steps.version.outputs.tag }}"
+
+          sed -i "s/^version = \".*\"/version = \"$VERSION\"/" pyproject.toml
+          uv lock
+
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          if ! git diff --quiet; then
+            git add pyproject.toml uv.lock
+            git commit -m "chore: bump version to ${VERSION} [skip ci]"
+            git push origin main
+          fi
+
+          git tag "$TAG"
+          git push origin "$TAG"
+          echo "::notice::Created tag $TAG"
+
+      - name: Dispatch release workflow
+        if: steps.check_tag.outputs.exists == 'false'
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: gh workflow run release.yml --ref "${{ steps.version.outputs.tag }}"

haru_cli-0.1.0/.github/workflows/release.yml

@@ -0,0 +1,105 @@
+name: Release
+
+on:
+  push:
+    tags: ["v*"]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    name: Build distributions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+        with:
+          enable-cache: true
+
+      - name: Build sdist and wheel
+        run: uv build
+
+      - name: Smoke test built wheel
+        run: |
+          uv venv smoke-env
+          uv pip install --python smoke-env dist/*.whl
+          smoke-env/bin/haru --version
+
+      - name: Upload distributions
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    name: Publish to PyPI
+    # Trusted Publishing (OIDC) — no tokens or passwords; the trusted publisher
+    # is configured in the PyPI project settings for this repo/workflow/environment.
+    needs: build
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write
+    steps:
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Publish
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  github-release:
+    name: Create GitHub Release
+    needs: [build, publish]
+    if: startsWith(github.ref, 'refs/tags/v')
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Download distributions
+        uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - name: Generate release notes
+        run: |
+          TAG="${{ github.ref_name }}"
+          REPO="${{ github.repository }}"
+          cat > release-notes.md <<EOF
+          ## Installation
+
+          \`\`\`bash
+          pipx install haru-cli==${TAG#v}
+          \`\`\`
+
+          or \`pip install haru-cli==${TAG#v}\` — published on [PyPI](https://pypi.org/project/haru-cli/${TAG#v}/).
+
+          See the [CHANGELOG](https://github.com/${REPO}/blob/main/CHANGELOG.md) for details.
+          EOF
+
+      - name: Create or update release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          TAG="${{ github.ref_name }}"
+          if gh release view "$TAG" > /dev/null 2>&1; then
+            gh release edit "$TAG" --notes-file release-notes.md --latest
+            gh release upload "$TAG" --clobber dist/*
+          else
+            gh release create "$TAG" \
+              --title "$TAG" \
+              --notes-file release-notes.md \
+              --generate-notes \
+              --latest \
+              dist/*
+          fi

haru_cli-0.1.0/.gitignore

@@ -0,0 +1,218 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#   Usually these files are written by a python script from a template
+#   before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+# Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+# uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+# poetry.lock
+# poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+# pdm.lock
+# pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+# pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# Redis
+*.rdb
+*.aof
+*.pid
+
+# RabbitMQ
+mnesia/
+rabbitmq/
+rabbitmq-data/
+
+# ActiveMQ
+activemq-data/
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#   JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#   be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#   and can be added to the global gitignore or merged into this file.  For a more nuclear
+#   option (not recommended) you can uncomment the following to ignore the entire idea folder.
+# .idea/
+
+# Abstra
+#   Abstra is an AI-powered process automation framework.
+#   Ignore directories containing user credentials, local state, and settings.
+#   Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#   Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#   that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#   and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#   you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+# Temporary file for partial code execution
+tempCodeRunnerFile.py
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
+
+# Streamlit
+.streamlit/secrets.toml

haru_cli-0.1.0/.kiro/steering/coding-standards.md

@@ -0,0 +1,14 @@
+---
+inclusion: always
+---
+
+# Coding standards
+
+- Functional first: pure functions, frozen dataclasses, explicit inputs and outputs. Avoid classes unless a library contract requires one.
+- Full type annotations on every function; mypy strict must pass with no ignores except where narrowly justified and commented.
+- No hardcoding: model IDs, regions, ARNs, URLs, ports, and file paths come from YAML config.
+- Configuration is validated into typed schema objects at load time; fail fast with `ConfigError` carrying the offending path.
+- Errors: raise typed exceptions from `errors.py`; never swallow exceptions silently; convert third-party errors at module boundaries.
+- Logging via the standard logging module configured from YAML; structured JSON in production; never log secrets, tokens, or customer data.
+- Docstrings on public functions (PEP 257). Keep functions small and composable.
+- Line length 100. Format with ruff. No dead code.

haru_cli-0.1.0/.kiro/steering/git-workflow.md

@@ -0,0 +1,14 @@
+---
+inclusion: always
+---
+
+# Git workflow
+
+- `main` is protected. Never commit directly to `main`.
+- Every change starts on a new branch off the latest `main`.
+- Branch naming: `feat/<slug>`, `fix/<slug>`, `chore/<slug>`, `docs/<slug>`, `test/<slug>`. Example: `feat/sso-pkce-login`.
+- Commits follow Conventional Commits: `type(scope): summary`, for example `feat(auth): add PKCE authorization code login`.
+- One logical change per commit; keep commits small and reviewable.
+- Open a pull request into `main`; CI (ruff, mypy, pytest with coverage gate) must pass before merge.
+- Rebase on `main` before merge; prefer a linear history. Delete the branch after merge.
+- Each chunk from the specification is its own branch and pull request.

haru_cli-0.1.0/.kiro/steering/product.md

@@ -0,0 +1,17 @@
+---
+inclusion: always
+---
+
+# Product
+
+## Purpose
+haru-cli gives engineers at a regulated asset manager a secure, scriptable command line for interacting with Amazon Bedrock Claude models through governed, observable, multi-agent workflows.
+
+## Users
+Internal engineers and API integration teams who authenticate through corporate IAM Identity Center and operate within the firm's AWS security boundary.
+
+## Key capabilities
+Interactive and one-shot chat, tool use, MCP client integration, supervisor/swarm/graph orchestration, session persistence, OpenTelemetry tracing, and Bedrock Guardrails.
+
+## Non-negotiables
+US data residency by default (us. inference profiles), no secrets in configuration, auditable logs, and enterprise-grade quality gates.

haru_cli-0.1.0/.kiro/steering/security.md

@@ -0,0 +1,15 @@
+---
+inclusion: always
+---
+
+# Security
+
+- Authentication: IAM Identity Center via OAuth 2.0 Authorization Code flow with PKCE (S256). Register a public client, use a 127.0.0.1 loopback redirect, validate the `state` parameter, and never accept non-loopback redirects.
+- Tokens: cache under `~/.aws/sso/cache` with 0600 permissions in the botocore-compatible schema; rely on botocore's SSOTokenProvider for refresh; treat access and refresh tokens as secrets.
+- Credentials: resolve AWS credentials from the SSO session and the standard credential chain; never store long-lived keys.
+- No secrets in configuration or source. YAML carries only references (`${env:VAR}`, ARNs, profile names). Reject inline secrets at config load.
+- Data residency: default to `us.` Bedrock inference profiles; do not use `global.` endpoints without explicit approval.
+- Guardrails: Bedrock Guardrails enabled by default with input redaction; do not disable to pass tests.
+- Logging: never log tokens, credentials, or customer data; redact prompts where required; keep audit-friendly structured logs.
+- Dependencies: keep boto3 and all dependencies current; enable Renovate/Dependabot; review the ruff security (S) rules.
+- This is a regulated financial services firm: prefer least privilege, fail closed, and make every security-relevant action auditable.

haru_cli-0.1.0/.kiro/steering/structure.md

@@ -0,0 +1,13 @@
+---
+inclusion: always
+---
+
+# Project structure
+
+- `src/haru/` holds the package; tests live in `tests/unit` and `tests/integration`.
+- Configuration lives in `config/*.yaml`; prompts in `config/prompts/`.
+- One responsibility per module: auth, config, models, agents, tools, sessions, observability, commands.
+- Commands in `commands/` are thin; business logic lives in the domain modules and is unit tested independently of Click.
+- Naming: modules and functions snake_case; dataclasses PascalCase; constants UPPER_SNAKE_CASE.
+- Imports ordered by ruff isort rules: standard library, third party, first party.
+- Factory functions return Strands objects; they take typed config plus a boto3 session and never read global state.

haru_cli-0.1.0/.kiro/steering/tech.md

@@ -0,0 +1,16 @@
+---
+inclusion: always
+---
+
+# Technology stack
+
+- Language: Python 3.13 (floor), tested on 3.13 and 3.14. PEP 8 and PEP 257.
+- CLI: Click 8.2+.
+- Agents: AWS Strands Agents SDK 1.42+ with the native BedrockModel provider (Converse/ConverseStream, streaming on).
+- AWS: boto3/botocore 1.43+ (always latest), sso-oidc for PKCE login, bedrock-runtime for inference.
+- Packaging: uv with pyproject.toml (hatchling backend) and a committed uv.lock.
+- Quality: ruff (lint and format), mypy strict, pytest with pytest-cov (>=90%).
+- Observability: OpenTelemetry SDK and OTLP exporter via Strands telemetry.
+- Config: PyYAML, validated into typed models.
+
+Prefer these tools over alternatives. Do not add a dependency without a clear need; pin lower bounds and rely on uv.lock for reproducibility.

haru_cli-0.1.0/.kiro/steering/testing.md

@@ -0,0 +1,13 @@
+---
+inclusion: always
+---
+
+# Testing
+
+- Framework: pytest. Coverage: pytest-cov with a 90% floor (`--cov-fail-under=90`), branch coverage on.
+- Every module has a matching `tests/unit/test_<module>.py`. New code ships with tests in the same change.
+- Mock all network and AWS calls: use pytest-mock and moto; never hit real Bedrock, sso-oidc, or S3 in unit tests.
+- Test the CLI with `click.testing.CliRunner`, asserting exit codes and output.
+- Cover happy paths, error paths, and edge cases (missing config, expired tokens, disabled MCP servers, guardrail interventions).
+- Deterministic tests only: no sleeps, no real time dependence, no external services. Use fixtures and `tmp_path`.
+- Integration tests live in `tests/integration` and are marked so they can be skipped in fast CI.

haru_cli-0.1.0/.pre-commit-config.yaml

@@ -0,0 +1,32 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v6.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-toml
+      - id: check-merge-conflict
+      - id: check-added-large-files
+      - id: detect-private-key
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.16.0
+    hooks:
+      - id: ruff-check
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/astral-sh/uv-pre-commit
+    rev: 0.11.32
+    hooks:
+      - id: uv-lock
+
+  - repo: local
+    hooks:
+      - id: mypy
+        name: mypy (strict)
+        entry: uv run mypy src
+        language: system
+        types: [python]
+        pass_filenames: false

haru_cli-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

haru_cli-0.1.0/CHANGELOG.md

@@ -0,0 +1,37 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2026-07-26
+
+### Added
+
+- `haru login`: IAM Identity Center sign-in via the OAuth 2.0 authorization-code
+  flow with PKCE (S256), loopback-only redirect capture, and a
+  botocore-compatible token cache (`~/.aws/sso/cache`, 0600) with automatic
+  refresh via the `refresh_token` grant.
+- `haru chat`: interactive streaming REPL with clean Ctrl-C/Ctrl-D handling,
+  `--agent` selection, and `--session-id` persistence; `haru run` for one-shot
+  prompts; `haru session list` for stored conversations.
+- Typed YAML configuration with includes, `${env:VAR}` interpolation,
+  inline-secret rejection, and load-time cross-reference validation.
+- Strands BedrockModel factory with `us.` data-residency defaults, streaming
+  on, and Bedrock Guardrails attached (input redaction on; enabled guardrails
+  without an id fail closed).
+- Built-in tool allowlist (strands_tools) and MCP clients for stdio and
+  streamable-http transports with disabled/continue-on-error handling.
+- Versioned steering prompts under `config/prompts/` with base+overlay
+  composition.
+- Multi-agent orchestration: supervisor (agents-as-tools), swarm, and graph
+  patterns built from configuration.
+- Session persistence: project-local file backend (default) and S3 backend.
+- OpenTelemetry OTLP tracing via the Strands telemetry helper (no-op when
+  disabled).
+- Toolchain: uv packaging, ruff lint/format, mypy strict, pytest with a 90%
+  coverage gate, pre-commit hooks, Renovate, GitHub Actions CI (Python
+  3.13/3.14), and a PyPI release workflow using Trusted Publishing.

haru_cli-0.1.0/CLAUDE.md

@@ -0,0 +1,45 @@
+# CLAUDE.md
+
+This file guides Claude Code when working in this repository. Read it fully before generating or editing code. The steering documents in `.kiro/steering/` are authoritative and expand on the rules here.
+
+## Project
+
+haru-cli is an open, enterprise-grade Python command line interface for a regulated financial services firm. It is a thin, functional orchestration layer over the AWS Strands Agents SDK, talking to Amazon Bedrock Claude models through the Converse API with streaming, tool use, MCP client support, multi-agent orchestration, session persistence, OpenTelemetry observability, and Bedrock Guardrails.
+
+## Golden rules
+
+1. Latest stable Python (target 3.13, test on 3.13 and 3.14). PEP 8 and PEP 257 compliant.
+2. Functional style. Prefer pure functions and frozen dataclasses. Do not introduce classes unless a third-party contract requires one. No global mutable state.
+3. All configuration lives in YAML under `config/`. No hardcoded values in code. No secrets in YAML: use environment references (`${env:VAR}`) or the AWS credential chain.
+4. Use Click for every command. Package as an installable distribution via pyproject.toml.
+5. Solid unit test coverage with pytest. New code ships with tests. Keep coverage at or above 90%.
+6. Every change goes on a new branch off `main`. Never commit directly to `main`.
+7. Do not weaken security controls, logging, or guardrails to make a test pass.
+
+## Toolchain
+
+- Packaging and environments: uv. Lint and format: ruff. Types: mypy (strict). Tests: pytest with pytest-cov.
+- Run locally: `uv sync`, `uv run ruff check`, `uv run ruff format`, `uv run mypy src`, `uv run pytest`.
+
+## Dependencies
+
+- strands-agents (>=1.42.0), boto3/botocore (>=1.43.0, always latest), click (>=8.2.0), pyyaml, pydantic, opentelemetry-sdk, rich.
+- Keep boto3 current with a lower-bound pin and a committed uv.lock refreshed by Renovate.
+
+## Architecture summary
+
+- `auth/` IAM Identity Center PKCE login and boto3 session construction.
+- `config/` YAML loading and typed schema.
+- `models/` Strands BedrockModel factories.
+- `agents/` agent factories and multi-agent orchestration.
+- `tools/` built-in tool registry and MCP clients.
+- `sessions/` file and S3 session managers.
+- `observability/` OpenTelemetry and Bedrock Guardrails.
+- `commands/` Click command implementations.
+
+## What not to do
+
+- Do not reimplement the agent loop, model transport, or tool execution; delegate to Strands.
+- Do not hardcode model IDs, regions, ARNs, URLs, or ports; read them from YAML.
+- Do not log secrets, tokens, or full prompts containing customer data.
+- Do not consider a chunk done until ruff, mypy, and pytest all pass.