tsugite-cli 0.12.2__tar.gz → 0.13.0__tar.gz

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/.github/copilot-instructions.md

@@ -4,16 +4,16 @@ Tsugite is a micro-agent CLI: agents are Markdown + YAML frontmatter, rendered v
 
 ### Architecture
 
-**Flow:** `Agent.md` (YAML + Jinja2) → `renderer.py` → `TsugiteAgent` → LiteLLM → Tools
+**Flow:** `Agent.md` (YAML + Jinja2) → `renderer.py` → `TsugiteAgent` → Provider → Tools
 
 **Key Modules:**
-- `cli/__init__.py` - Typer CLI (run, chat, render, config, mcp, tools, agents, attachments, cache)
+- `cli/__init__.py` - Typer CLI (run, chat, render, config, tools, agents, attachments, cache)
 - `md_agents.py` - Parse frontmatter + agent resolution + directives
 - `builtin_agents/` - File-based built-in agent definitions (default.md, chat-assistant.md)
 - `agent_inheritance.py` - Agent resolution pipeline + inheritance chain
 - `chat.py` - Chat session management with history
 - `agent_runner.py` - Execution orchestration, prefetch, tool wiring, multi-step
-- `core/agent.py` - LiteLLM agent loop + streaming
+- `core/agent.py` - agent loop + streaming
 - `renderer.py` - Jinja2 rendering + helpers (now, today, slugify, env, file_exists, read_text, is_file, is_dir)
 - `tools/` - Tool registry + implementations
 - `shell_tool_config.py` + `tools/shell_tools.py` - Custom shell command wrappers
@@ -62,7 +62,6 @@ File-based agents distributed with the package in `tsugite/builtin_agents/` dire
 **Merge rules:**
 - Scalars (model, max_steps): Child overwrites
 - Lists (tools): Merge + deduplicate
-- Dicts (mcp_servers): Merge, child keys override
 - Strings (instructions): Concatenate with `\n\n`
 
 **Opt-out:** `extends: none` skips all inheritance.
@@ -236,7 +235,6 @@ assert tool is not None
 
 **Safety:**
 - Shell tool guard: Never relax dangerous patterns blocklist
-- MCP: Requires `--trust-mcp-code` flag
 - File ops: Use `Path.resolve()` to prevent traversal
 
 **Testing:** Test-first workflow. Add minimal failing test, run target, widen to full suite before merge.

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/AGENTS.md

@@ -54,7 +54,7 @@ Tsugite is an agentic CLI that executes AI agents defined as markdown files with
 1. **CLI Entry** (`tsugite/cli/__init__.py`)
    - Typer-based CLI with subcommands
    - Main commands: `run` (single-shot), `chat` (interactive), `render` (preview)
-   - Additional: `daemon`, `workspace`, `init`, `validate`, `mcp`, `serve`, `agents`, `config`, `attachments`, `cache`, `tools`, `history`
+   - Additional: `daemon`, `workspace`, `init`, `validate`, `agents`, `config`, `attachments`, `cache`, `tools`, `history`
 
 2. **Agent Resolution & Inheritance** (`tsugite/agent_inheritance.py`)
    - Resolves agent names to file paths using search order:
@@ -102,22 +102,20 @@ Tsugite is an agentic CLI that executes AI agents defined as markdown files with
    - Integrates with history system for conversation continuity
 
 7. **LLM Agent Loop** (`tsugite/core/agent.py`)
-   - `TsugiteAgent` - Custom agent using LiteLLM directly
+   - `TsugiteAgent` - Custom agent using tsugite's provider abstraction
    - Think-Code-Observation loop (max_turns iterations)
    - Supports reasoning models (o1, o3, Claude extended thinking)
    - Direct control over model parameters (temperature, reasoning_effort)
    - Code execution via `LocalExecutor`
 
 8. **Tool System** (`tsugite/tools/`)
-   - Tool registry with built-in tools (fs, http, shell, tasks, agents, memory, skills, history, interactive)
-   - Category system: `@fs`, `@http`, `@shell`, `@tasks`, `@agents`, `@memory`, `@skills`, `@history`, `@interactive`
-   - Custom shell tools (config-based command wrappers)
-   - MCP integration (`tsugite/mcp_client.py`)
-   - Tool expansion supports globs (`*_search`) and exclusions (`-delete_file`)
+   - Tool registry with built-in tools (fs, http, shell, agents, skills, history, interactive) plus optional categories (notify, schedule, scratchpad, sessions, secrets, tmux — gated by `_OPTIONAL_CATEGORIES` in `tools/__init__.py`)
+   - Custom shell tools (config-based command wrappers in `tools/shell_tools.py`)
+   - Tool expansion supports globs (`*_search`), categories (`@fs`), and exclusions (`-delete_file`)
 
 9. **Event System** (`tsugite/events/`)
    - Event-driven architecture for UI decoupling
-   - 20 event types: execution, LLM, meta, progress, skills
+   - 28 event types: execution, LLM, meta, progress, skills
    - `EventBus` dispatches to multiple handlers
    - Handlers: Rich console, plain text, JSONL, chat, REPL
 
@@ -131,17 +129,16 @@ Tsugite is an agentic CLI that executes AI agents defined as markdown files with
     - XDG-compliant paths: `~/.config/tsugite/` or `$XDG_CONFIG_HOME/tsugite/`
     - JSON config with model aliases, default settings
     - Attachment storage (reusable context)
-    - MCP server registration
     - Auto-context discovery (CLAUDE.md, AGENTS.md, CONTEXT.md)
 
 ### Key Data Structures
 
-**AgentConfig** (`md_agents.py:43`)
+**AgentConfig** (`md_agents.py:36`)
 - Pydantic model for agent frontmatter
 - Validates all fields (name, model, tools, max_turns, etc.)
 - Schema exported to `tsugite/schemas/agent.schema.json`
 
-**PreparedAgent** (`agent_preparation.py:17`)
+**PreparedAgent** (`agent_preparation.py:69`)
 - Dataclass containing everything for execution/display
 - Ensures `render` shows exactly what `run` executes
 - Contains: agent, config, system_message, user_message, tools, context
@@ -241,7 +238,7 @@ Tsugite supports vision (images), audio, and document understanding through the
 **How It Works:**
 
 1. **URL Attachments** (Images/Documents):
-   - LiteLLM fetches the URL directly (no download overhead)
+   - The provider fetches the URL directly (no download overhead — support varies by provider and content type; see `tsugite/attachments/url.py`)
    - Example: `tsu run -f https://example.com/chart.png "Describe this chart"`
    - Automatically detected via HTTP HEAD request
 
@@ -286,6 +283,63 @@ tsu run -f image1.jpg -f image2.jpg "Compare these images"
 - YouTube handler: `tsugite/attachments/youtube.py` (fetches transcripts)
 - LLM formatting: `tsugite/core/agent.py:_format_attachment()`
 
+#### Frontmatter Attachment Specs
+
+The `attachments:` field accepts either plain string paths (legacy) or dict-form `AttachmentSpec` entries. Both forms can be mixed in the same list.
+
+**String form** (existing): rendered through Jinja, then loaded as a single file. Prefix with `-` to remove a workspace default (e.g., `-MEMORY.md`).
+
+```yaml
+attachments:
+  - MEMORY.md
+  - "{{ today() }}.md"
+  - -SKIP.md  # remove a workspace default named SKIP.md
+```
+
+**Dict form** (`AttachmentSpec`): adds `assign:`, `mode: index`, glob expansion, and other knobs.
+
+```yaml
+attachments:
+  - path: MEMORY.md
+    assign: memory_content        # bind file content as Jinja variable
+
+  - path: USER.md
+    assign: user_prefs
+    attach: false                 # bind variable but don't inject into prompt
+
+  - path: "memory/topics/*.md"    # glob - one Attachment per matched file
+    assign: topic_files           # bound as list[dict] of {path, content}
+
+  - path: "memory/topics/*.md"
+    mode: index                   # render path+heading list, not full content
+    name: topic_index             # explicit attachment name (default derives from glob)
+    assign: topics                # bound as list[dict] of {path, heading, size_bytes, mtime}
+    index_format: first_heading   # path_only | first_line | first_heading | frontmatter
+    max_entries: 50               # cap, warns if exceeded
+```
+
+**Variable shapes** (when `assign:` is set):
+
+| Spec | Shape |
+|---|---|
+| `mode: full`, single concrete file | `str` (file content) |
+| `mode: full`, glob | `list[dict]` of `{path, content}` (binaries skipped) |
+| `mode: index` | `list[dict]` of `{path, heading, size_bytes, mtime}` |
+| Single file, missing | `None` |
+| Empty glob | `[]` |
+
+**Constraints (validated at parse time):**
+- `assign:` must be a valid Python identifier.
+- Two specs can't share the same `assign` value.
+- `attach: false` requires `assign:` (otherwise the attachment loads for nothing).
+- `path:` cannot start with `-` (use string form for removal).
+
+**Index mode rendering** wraps the formatted index in an existing `<attachment>` tag with a `mode="index"` attribute, e.g. `<attachment name="topic_index" mode="index">...</attachment>`. Agents are expected to call `read_file(path=...)` to fetch individual entries on demand.
+
+**Collisions:** if an `assign:` name shadows a built-in or prefetch variable, the assignment wins and a warning is logged.
+
+See `examples/attachment_assign_demo.md` and `examples/attachment_index_demo.md` for runnable references.
+
 ## Development Patterns
 
 ### Adding a New Built-in Agent
@@ -315,14 +369,31 @@ tsu run -f image1.jpg -f image2.jpg "Compare these images"
 
 1. Update `AgentConfig` Pydantic model (`md_agents.py`)
 2. Regenerate schema: `uv run python scripts/regenerate_schema.py`
-3. Update documentation in CLAUDE.md (user guide section)
+3. Update relevant documentation in `AGENTS.md` and any user-facing doc under `docs/`
 4. Add validation tests in `tests/test_agent_parser.py`
 
 ## Testing Strategy
 
-- **TDD preferred**: Write tests first when building new features. Tests don't need to be elaborate — simple tests that verify the expected behavior are enough. This creates a fast feedback loop and catches integration issues early (e.g., contextvar propagation, tool registration) before manual testing.
+### TDD is the default
+
+For any non-trivial bug fix or feature, write a failing test **first**. Exceptions: typo fixes, docs, pure refactors, and changes the user has explicitly scoped as exploratory.
+
+The workflow:
+
+1. **Reproduce before fixing.** Write the smallest test that demonstrates the symptom as reported. Run it. If it passes on master, the hypothesis is wrong — do not write a fix. Investigate further, ask the user for more detail, or add logging.
+2. **Implement the fix.** Keep the change minimal. Do not refactor or add adjacent cleanup in the same diff.
+3. **Verify the test is load-bearing.** Temp-revert the production change and re-run. The test must go red again. If it still passes, the test isn't actually exercising the fix — rework it.
+4. **Cover adjacent cases before declaring done.** When touching a parser, protocol boundary, or state machine, enumerate at least two adjacent input shapes and add tests for them. Narrow tests let bugs sneak in through the cases you didn't think about.
+5. **Run the local regression suite.** At minimum, the test files next to the modules you changed. Faster than running everything, catches silent breakage of existing tests.
+6. **Honest uncertainty.** If a hypothesis doesn't reproduce, say so. Don't ship a "probably-this" fix with no failing test to anchor it — that's how placebo fixes get merged.
+
+Reproducing tests don't need to be elaborate. A 10-line test that flips red→green is worth more than a 100-line one that nobody understands.
+
+### Test layers
+
 - **Unit tests**: Individual functions and classes
-- **Pipeline tests**: Mock only `TsugiteAgent`/`litellm.acompletion` but exercise the full pipeline (parsing → rendering → preparation → tool expansion → execution). Most tests in the suite are this style.
+- **Pipeline tests**: Mock only `TsugiteAgent` / the provider's `acompletion` but exercise the full pipeline (parsing → rendering → preparation → tool expansion → execution). Most tests in the suite are this style.
+- **Integration tests**: Live under `tests/integration/` (not collected by default — see `pyproject.toml` `norecursedirs`). Run explicitly with `uv run pytest tests/integration/`. Good for concurrency, cwd, and daemon-wiring tests that need real threading or a real workspace.
 - **Smoke tests**: `tests/smoke_test.sh` hits a real LLM API (requires `OPENAI_API_KEY`, not run in CI)
 - **Fixtures**: `conftest.py` provides shared test data
 - **Mocking**: Use `@pytest.fixture` for LLM responses
@@ -348,6 +419,28 @@ tsu run -f image1.jpg -f image2.jpg "Compare these images"
 6. **Test both sync and async paths**: Many tools support both execution modes
 7. **Don't embed prompts in adapters/code**: Use context variables + conditional blocks in `default.md` instead. Add new context vars in `_build_agent_context()` (base adapter) and default them in `agent_preparation.py`, then use `{% if var %}` in the agent template. This keeps all prompt content in one place and leverages the existing rendering pipeline.
 
+## Web UI
+
+The daemon's web UI lives at `tsugite/daemon/web/`.
+
+### Stack
+
+- **Alpine.js 3** loaded from CDN. No build step. No React. Don't port this to a framework - the design handoff explicitly said match visuals, not internal structure.
+- **Starlette** serves `index.html` plus `/static/{css,js,icons}` and the `/api/*` routes (`tsugite/daemon/adapters/http.py`).
+- CSS lives in three files. Read all three before adding rules: `theme.css` (Catppuccin tokens), `console.css` (Console redesign - the real stylesheet), `styles.css` (legacy modals/auth/forms; ~120 lines, pruned aggressively after the redesign).
+- View modules under `js/views/`: `conversations.js` (orchestrator) + `conversation/{sessions,history,streaming,input,attachments,event_types}.js` mixins, plus `workspace.js`, `schedules.js`, `webhooks.js`, `usage.js`, `file-editor.js`. Shared helpers: `js/api.js` (REST + SSE), `js/utils.js` (markdown, formatters, toast).
+
+### Theme tokens
+
+- Use **bare token names** - `var(--base)`, `var(--mantle)`, `var(--crust)`, `var(--surface0/1/2)`, `var(--text)`, `var(--lavender)`, `var(--blue)`, `var(--peach)`, etc. The legacy `--ctp-*` aliases were removed.
+- **Visual depth is `crust < mantle < base`** (darker → lighter on Frappé/Mocha/Macchiato). For dark-on-dark panels, panels go `var(--mantle)` and inner cards `var(--surface0)` or `var(--crust)`. Don't put a brighter (`--bg`/`--base`) header over a `--mantle` panel - it inverts the depth on dark themes.
+- Never hardcode hex colors. They won't theme-switch. Even in JS palette objects (e.g. `PI_COLORS` in `conversations.js`), use `var(--pink)` strings - they get embedded into `:style="background: ..."` and resolve through the CSS cascade.
+- `<meta name="theme-color">` is synced to the active theme's `--crust` via an `Alpine.effect` in `app.js` so the PWA status bar / mobile chrome track the theme.
+
+### Verification
+
+Browser verification on UI changes is mandatory. The smoketest recipe - daemon spinup, Playwright wiring, and the post-redesign DOM selectors - is captured in the agent's project memory file `project_daemon_ui_smoketest.md`. There's also a `project_webui_console_hotzones.md` memory listing the load-bearing assumptions in the new UI (pulse signal, mid-turn reload guards, theme depth, PWA resume, mobile back-buttons) that bit during the redesign and should be re-read before touching session lifecycle, theme tokens, or PWA behaviour.
+
 ## Code Review Policy
 
 - **Automatically run the `code-simplifier:code-simplifier` agent** (via the Task tool) after implementing any changes, without waiting for the user to ask. This catches duplication, unnecessary complexity, and keeps the codebase DRY.

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.12.2
+Version: 0.13.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -246,7 +246,6 @@ Requires-Dist: ddgs>=9.6.0
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: httpx>=0.25
 Requires-Dist: jinja2>=3.1
-Requires-Dist: mcp>=1.0
 Requires-Dist: nest-asyncio>=1.5.0
 Requires-Dist: pathspec>=0.11.0
 Requires-Dist: portalocker>=2.8.0
@@ -334,8 +333,8 @@ tsu run +default "summarize the files in this directory"
 # Run an agent file directly
 tsu run my-agent.md "do the thing"
 
-# Start the web UI
-tsu serve
+# Start the daemon (web UI, Discord/Telegram bots)
+tsu daemon
 ```
 
 ## Features
@@ -347,7 +346,6 @@ tsu serve
 - **Skills** directory-based knowledge modules (mostly) following the [agentskills.io](https://agentskills.io/) SKILL.md format
 - **Hooks** that fire shell commands on lifecycle events (post-tool, pre-message, pre/post-compact)
 - **Sandbox** (linux only) via bubblewrap with filesystem and network isolation
-- **MCP** integration for connecting to MCP servers
 
 ## Agents in more detail
 
@@ -395,7 +393,7 @@ All paths follow [XDG Base Directory](https://specifications.freedesktop.org/bas
 
 | Path                                   | Default                              | Contents                                     |
 |----------------------------------------|--------------------------------------|----------------------------------------------|
-| `$XDG_CONFIG_HOME/tsugite/`            | `~/.config/tsugite/`                 | `config.json`, `mcp.json`, `daemon.yaml`     |
+| `$XDG_CONFIG_HOME/tsugite/`            | `~/.config/tsugite/`                 | `config.json`, `daemon.yaml`                 |
 | `$XDG_DATA_HOME/tsugite/history/`      | `~/.local/share/tsugite/history/`    | Session history (JSONL per session)          |
 | `$XDG_DATA_HOME/tsugite/daemon/`       | `~/.local/share/tsugite/daemon/`     | Daemon state                                 |
 | `$XDG_DATA_HOME/tsugite/secrets/`      | `~/.local/share/tsugite/secrets/`    | Encrypted secrets (`secrets.db`)             |

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/README.md

@@ -63,8 +63,8 @@ tsu run +default "summarize the files in this directory"
 # Run an agent file directly
 tsu run my-agent.md "do the thing"
 
-# Start the web UI
-tsu serve
+# Start the daemon (web UI, Discord/Telegram bots)
+tsu daemon
 ```
 
 ## Features
@@ -76,7 +76,6 @@ tsu serve
 - **Skills** directory-based knowledge modules (mostly) following the [agentskills.io](https://agentskills.io/) SKILL.md format
 - **Hooks** that fire shell commands on lifecycle events (post-tool, pre-message, pre/post-compact)
 - **Sandbox** (linux only) via bubblewrap with filesystem and network isolation
-- **MCP** integration for connecting to MCP servers
 
 ## Agents in more detail
 
@@ -124,7 +123,7 @@ All paths follow [XDG Base Directory](https://specifications.freedesktop.org/bas
 
 | Path                                   | Default                              | Contents                                     |
 |----------------------------------------|--------------------------------------|----------------------------------------------|
-| `$XDG_CONFIG_HOME/tsugite/`            | `~/.config/tsugite/`                 | `config.json`, `mcp.json`, `daemon.yaml`     |
+| `$XDG_CONFIG_HOME/tsugite/`            | `~/.config/tsugite/`                 | `config.json`, `daemon.yaml`                 |
 | `$XDG_DATA_HOME/tsugite/history/`      | `~/.local/share/tsugite/history/`    | Session history (JSONL per session)          |
 | `$XDG_DATA_HOME/tsugite/daemon/`       | `~/.local/share/tsugite/daemon/`     | Daemon state                                 |
 | `$XDG_DATA_HOME/tsugite/secrets/`      | `~/.local/share/tsugite/secrets/`    | Encrypted secrets (`secrets.db`)             |

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/docs/agents.md

@@ -46,7 +46,6 @@ All fields are optional except `name`.
 | `auto_load_skills` | list | `[]`             | Skills to load automatically at startup                           |
 | `skill_paths`      | list | `[]`             | Extra directories to search for skills                            |
 | `prefetch`         | list | `[]`             | Tools to run before execution, results available in templates     |
-| `mcp_servers`      | dict | `{}`             | MCP server connections                                            |
 | `custom_tools`     | list | `[]`             | Inline tool definitions                                           |
 | `reasoning_effort` | str  | none             | For reasoning models: `low`, `medium`, `high`                     |
 | `disable_history`  | bool | `false`          | Don't save this agent's sessions                                  |
@@ -186,7 +185,57 @@ attachments:
   - "{{ WORKSPACE_DIR }}/notes.md"
 ```
 
-Supports text files, PDFs, images, and URLs.  Jinja2 works in attachment paths.  All attachments are injected as context.
+Supports text files, PDFs, images, and URLs.  Jinja2 works in attachment paths.  All attachments are injected as context. Prefix with `-` to remove a workspace default (e.g. `-MEMORY.md`).
+
+### Attachment specs (dict form)
+
+Use the dict form to bind attachment content to a Jinja variable, render an on-demand index instead of full content, or expand globs:
+
+```yaml
+attachments:
+  # Bind file content as a variable usable in body/instructions templates
+  - path: MEMORY.md
+    assign: memory_content
+
+  # Bind without injecting (the LLM doesn't see it; the template does)
+  - path: USER.md
+    assign: user_prefs
+    attach: false
+
+  # Glob - one attachment per matched file; assign binds list[dict] of {path, content}
+  - path: "notes/*.md"
+    assign: notes
+
+  # Index mode - emits a single <attachment mode="index"> with path+heading bullets,
+  # no full file content. Agents read individual entries via read_file().
+  - path: "memory/topics/*.md"
+    mode: index
+    name: topic_index             # optional override; default derives from glob
+    assign: topics                # list[dict] of {path, heading, size_bytes, mtime}
+    index_format: first_heading   # path_only | first_line | first_heading | frontmatter
+    max_entries: 50
+```
+
+Variable shapes when `assign:` is set:
+
+| Spec | Variable shape |
+|---|---|
+| `mode: full`, single concrete file | `str` (file content) |
+| `mode: full`, glob | `list[dict]` of `{path, content}` (binaries skipped) |
+| `mode: index` | `list[dict]` of `{path, heading, size_bytes, mtime}` |
+| Single file, missing | `None` |
+| Empty glob | `[]` |
+
+Validation rules (enforced at parse time):
+
+- `assign:` must be a valid Python identifier.
+- Two specs cannot share the same `assign:` value.
+- `attach: false` requires `assign:`.
+- `path:` cannot start with `-` (use string form for removal).
+
+Collisions between an `assign:` name and a built-in/prefetch variable resolve in favor of the attachment binding, with a warning logged.
+
+See `examples/attachment_assign_demo.md` and `examples/attachment_index_demo.md` for full working examples.
 
 ## Multi-step agents
 
@@ -227,6 +276,7 @@ The variable `findings` is available in Python.
 | `repeat_while`      | str   | Jinja2 expression, loop while truthy     |
 | `repeat_until`      | str   | Jinja2 expression, loop until truthy     |
 | `max_iterations`    | int   | Loop safety limit (default 10)           |
+| `agent`             | str   | Path to agent file; runs the step via `spawn_agent` instead of inline |
 
 ### Variable passing
 
@@ -235,6 +285,24 @@ When a step has `assign="var_name"`, the result is available in later steps:
 - In Jinja2 templates: `{{ var_name }}`
 - In Python code execution: just use `var_name` directly
 
+### Step context isolation
+
+Each `tsu:step` already runs as an independent agent invocation: a fresh system prompt, no LLM-level conversation history from prior steps.  The only thing that flows between steps is variables captured with `assign=`, substituted into later steps via Jinja.
+
+If you need a step to run with a fully separate identity (its own model defaults, attachments, skills, instructions), use `agent="path/to/other.md"`.  The step content (after Jinja rendering) becomes the spawned agent's prompt.  The spawned agent does not see the parent's `step_context` — only the rendered prompt — so any data the spawned agent needs must already be substituted in.
+
+```markdown
+<!-- tsu:step name="implement" assign="diff" -->
+Write a fix for: {{ user_prompt }}.  Return only the diff.
+
+<!-- tsu:step name="review" agent="agents/code-reviewer.md" assign="verdict" -->
+Review this diff:
+
+{{ diff }}
+```
+
+Path resolution follows the standard agent search order (workspace, project-local `agents/`, builtin agents, global config).  Unresolvable `agent=` paths fail before any step runs, so a typo in step 2 won't waste step 1's work.
+
 ## Other directives
 
 ### tsu:tool

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.12.2"
+version = "0.13.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -13,7 +13,6 @@ dependencies = [
   "pyyaml>=6.0",
   "httpx>=0.25",
   "rich>=13.0",
-  "mcp>=1.0",
   "ddgs>=9.6.0",
   "questionary>=2.1.1",
   "youtube-transcript-api>=0.6.0",

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/scripts/update_model_registry.py

@@ -51,6 +51,13 @@ SKIP_PREFIXES = (
 # Reasoning model name patterns (for supports_reasoning flag)
 REASONING_PATTERNS = re.compile(r"^(o1|o3|o4)(-mini|-preview|-pro)?")
 
+# Reasoning models that accept the reasoning_effort parameter.
+# Excludes o1-mini (unsupported by OpenAI).
+EFFORT_LEVELS_PATTERNS = re.compile(r"^(o1(-pro)?|o3(-mini|-pro)?|o4(-mini|-pro)?)(-\d{4}-\d{2}-\d{2})?$")
+
+# Anthropic models that support extended thinking (Claude 4+ families).
+ANTHROPIC_THINKING_PATTERNS = re.compile(r"^claude-(opus|sonnet|haiku)-4")
+
 
 def fetch_litellm_data() -> dict:
     print(f"Fetching {LITELLM_URL}...")
@@ -96,6 +103,10 @@ def entry_to_model_info(key: str, entry: dict, provider: str) -> str:
         parts.append("supports_vision=True")
     if reasoning:
         parts.append("supports_reasoning=True")
+    if EFFORT_LEVELS_PATTERNS.match(key):
+        parts.append('supported_effort_levels=["low", "medium", "high"]')
+    elif provider == "anthropic" and ANTHROPIC_THINKING_PATTERNS.match(key):
+        parts.append('supported_effort_levels=["low", "medium", "high", "max"]')
 
     return f"ModelInfo({', '.join(parts)})"
 

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/tests/README.md

@@ -26,7 +26,7 @@ uv run pytest --cov=tsugite --cov-report=html
 
 ### Smoke Tests
 
-**Smoke tests are NOT run automatically** to avoid API costs. They test real LiteLLM integration with actual API calls.
+**Smoke tests are NOT run automatically** to avoid API costs. They test real provider integration with actual API calls.
 
 #### Prerequisites
 
@@ -42,7 +42,7 @@ bash tests/smoke_test.sh
 
 #### What Smoke Tests Verify
 
-1. **Real LiteLLM integration** - Tests actual API calls, not mocks
+1. **Real provider integration** - Tests actual API calls, not mocks
 2. **Async context detection** - Catches issues like missing asyncio imports
 3. **Tool integration** - Verifies tools work in real execution
 4. **New agents** - Tests recently added agents end-to-end
@@ -50,7 +50,7 @@ bash tests/smoke_test.sh
 #### When to Run Smoke Tests
 
 - Before releases
-- After upgrading LiteLLM
+- After upgrading provider dependencies
 - After major refactors to agent execution
 - When debugging integration issues
 - After adding new agents
@@ -61,7 +61,7 @@ bash tests/smoke_test.sh
 
 - **`core/`** - Tests for core agent implementation (TsugiteAgent, executor, tools)
 - **`test_*.py`** - Feature-specific tests (CLI, rendering, parsing, etc.)
-- All unit tests mock LiteLLM to avoid API calls
+- All unit tests mock the provider to avoid API calls
 
 ### Integration Tests
 
@@ -69,24 +69,20 @@ Currently implemented as smoke tests (see above).
 
 ## Writing Tests
 
-### Mocking LiteLLM
+### Mocking the provider
 
-When writing unit tests that use `TsugiteAgent`:
+When writing unit tests that use `TsugiteAgent`, use the `mock_provider` and
+`mock_completion_response` fixtures from `tests/conftest.py`:
 
 ```python
-from unittest.mock import AsyncMock, patch
-
 @pytest.mark.asyncio
-async def test_agent_example(mock_litellm_response):
-    with patch("tsugite.core.agent.litellm") as mock_litellm:
-        mock_litellm.acompletion = AsyncMock(
-            return_value=mock_litellm_response("test response")
-        )
+async def test_agent_example(mock_provider, mock_completion_response):
+    mock_provider.acompletion.return_value = mock_completion_response("test response")
 
-        agent = TsugiteAgent(...)
-        result = await agent.run("test task")
+    agent = TsugiteAgent(...)
+    result = await agent.run("test task")
 
-        assert result == expected
+    assert result == expected
 ```
 
 ### Testing Agents

{tsugite_cli-0.12.2 → tsugite_cli-0.13.0}/tests/conftest.py

@@ -50,17 +50,46 @@ def clear_agent_context():
     This prevents test pollution where one test sets current_agent
     and affects another test running in the same worker.
     """
-    from tsugite.agent_runner.helpers import clear_allowed_agents, clear_current_agent
+    from tsugite.agent_runner.helpers import clear_allowed_agents, clear_current_agent, set_allowed_secrets
 
-    # Clear before test
-    clear_current_agent()
-    clear_allowed_agents()
+    def _reset():
+        clear_current_agent()
+        clear_allowed_agents()
+        set_allowed_secrets(None)
 
+    _reset()
     yield
+    _reset()
 
-    # Clear after test
-    clear_current_agent()
-    clear_allowed_agents()
+
+@pytest.fixture
+def secret_backend(tmp_path):
+    """File-backed secrets rooted under tmp_path. Wires the backend, registers a
+    test agent, clears the masking registry, and yields the backend so callers
+    can populate via backend.set(name, value)."""
+    from tsugite.agent_runner.helpers import set_current_agent
+    from tsugite.secrets import set_backend
+    from tsugite.secrets.file import FileSecretBackend
+    from tsugite.secrets.registry import get_registry
+
+    backend = FileSecretBackend({"path": str(tmp_path / "secrets")})
+    set_backend(backend)
+    set_current_agent("test-agent")
+    get_registry().clear()
+    return backend
+
+
+@pytest.fixture(autouse=True)
+def reset_workspace_dir_cv():
+    """Clear the workspace ContextVar between tests so that state from one test
+    doesn't leak into the next (the CV persists across sync tests otherwise)."""
+    from tsugite.cli.helpers import _workspace_dir_cv, set_workspace_dir
+
+    token = set_workspace_dir(None)
+    try:
+        yield
+    finally:
+        _workspace_dir_cv.reset(token)
 
 
 @pytest.fixture
@@ -287,12 +316,12 @@ def spawn_agent_tool(reset_tool_registry, request):
 def interactive_tools(reset_tool_registry):
     """Register interactive tools for testing."""
     from tsugite.tools import tool
-    from tsugite.tools.interactive import ask_user, ask_user_batch, final_answer, react_to_message, send_message
+    from tsugite.tools.interactive import ask_user, ask_user_batch, react_to_message, return_value, send_message
 
     # Re-register the tools after registry reset
     tool(ask_user)
     tool(ask_user_batch)
-    tool(final_answer)
+    tool(return_value)
     tool(send_message)
     tool(react_to_message)
 
@@ -403,33 +432,7 @@ tools: {tools_str}"""
 
 
 @pytest.fixture
-def mcp_config_factory():
-    """Factory for creating MCP server configurations."""
-
-    def _create_config(server_type="stdio", name="test-server", **kwargs):
-        """Create an MCP server config dict.
-
-        Args:
-            server_type: "stdio" or "http"
-            name: Server name
-            **kwargs: Additional config fields (command, args, env, url, etc)
-        """
-        if server_type == "stdio":
-            return {
-                "command": kwargs.get("command", "npx"),
-                "args": kwargs.get("args", ["-y", "test-server"]),
-                "env": kwargs.get("env", {}),
-            }
-        elif server_type == "http":
-            return {"url": kwargs.get("url", "http://localhost:8000/mcp"), "type": "http"}
-        else:
-            raise ValueError(f"Unknown server type: {server_type}")
-
-    return _create_config
-
-
-@pytest.fixture
-def mock_litellm_response():
+def mock_completion_response():
     """Create a mock provider CompletionResponse for agent tests.
 
     This fixture provides a factory function that creates mock LLM responses