tsugite-cli 0.17.2__tar.gz → 0.18.0__tar.gz

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/AGENTS.md

@@ -489,12 +489,12 @@ Reproducing tests don't need to be elaborate. A 10-line test that flips red→gr
 
 ## Web UI
 
-The daemon's web UI lives at `tsugite/daemon/web/`.
+The daemon's web UI lives at `plugins/tsugite-daemon/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`).
+- **Starlette** serves `index.html` plus `/static/{css,js,icons}` and the `/api/*` routes (`plugins/tsugite-daemon/tsugite_daemon/adapters/http/`, a per-domain package).
 - 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).
 

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tsugite-cli
-Version: 0.17.2
+Version: 0.18.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.17.2"
+version = "0.18.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -92,6 +92,7 @@ tsugite-sandbox = { workspace = true }
 tsugite-pty = { workspace = true }
 tsugite-daemon = { workspace = true }
 tsugite-discord = { workspace = true }
+tsugite-cc-driver = { workspace = true }
 
 [tool.ruff]
 target-version = "py311"
@@ -175,4 +176,5 @@ dev = [
   "tsugite-pty",
   "tsugite-daemon",
   "tsugite-discord",
+  "tsugite-cc-driver",
 ]

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/tsugite/agent_runner/history_integration.py

@@ -98,6 +98,36 @@ def record_user_input(
     storage.record("user_input", **data)
 
 
+def record_final_result(
+    storage: Session,
+    result: str,
+    result_data: Any = None,
+    turns: Optional[int] = None,
+    tokens: Optional[int] = None,
+    cost: Optional[float] = None,
+) -> None:
+    """Record the turn's final answer as a durable final_result event.
+
+    Interactive daemon turns may already have one for this turn, persisted by
+    the live SSE handler during FinalAnswerEvent dispatch (which runs before
+    the agent reaches its end-of-run recording). Skip in that case so the
+    conversation view doesn't render the answer twice.
+    """
+    for event in reversed(list(storage.iter_events(types=("user_input", "final_result")))):
+        if event.type == "user_input":
+            break
+        if event.type == "final_result":
+            return
+    storage.record(
+        "final_result",
+        result=result,
+        result_data=result_data,
+        turns=turns,
+        tokens=tokens,
+        cost=cost,
+    )
+
+
 def record_session_end(
     storage: Session,
     status: str = "success",

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/tsugite/agent_runner/runner.py

@@ -681,7 +681,7 @@ async def _execute_agent_with_prompt(
                 model=model_string,
                 source="cli",
                 total_tokens=agent.total_tokens,
-                cost_usd=agent.total_cost if agent.total_cost > 0 else None,
+                cost_usd=agent.reported_cost,
                 cache_creation_tokens=agent.cache_creation_tokens,
                 cache_read_tokens=agent.cache_read_tokens,
             )
@@ -1046,13 +1046,15 @@ async def run_agent_async(
         else:
             logger.debug("No resumable provider session for %s", continue_conversation_id)
 
-        if not resume_session:
-            # No resumable provider session -- load history for serialization
-            try:
-                previous_messages = load_and_apply_history(continue_conversation_id)
-            except ValueError:
-                # New conversation (e.g., fresh workspace session) - start with empty history
-                pass
+        # Load serialized history even when a provider session is resumable:
+        # session-owning providers need it as fallback material if the resume
+        # replay is rejected (e.g. a poisoned Claude Code sidecar transcript
+        # that 400s on every send). Providers ignore it while a resume is live.
+        try:
+            previous_messages = load_and_apply_history(continue_conversation_id)
+        except ValueError:
+            # New conversation (e.g., fresh workspace session) - start with empty history
+            pass
 
     # Parse agent configuration (with inheritance resolution)
     try:

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/tsugite/builtin_agents/code_searcher.md

@@ -32,7 +32,7 @@ You are a specialized code search agent. Use `ast-grep` to find structural patte
 - Helpful flags: `-C 2` (context), `--json` (machine-readable), `--no-ignore vcs` (ignore .gitignore rules).
 
 ### Quick Patterns
-```python
+```python-exec
 # Function definition (Python)
 run(command="ast-grep -p 'def $NAME($$$)' -l py src/")
 

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/tsugite/builtin_agents/default.md

@@ -78,7 +78,7 @@ instructions: |
   Function results are NOT automatically visible to you in the next turn.
   You MUST print() results if you want to see and use them later:
 
-  ```python
+  ```python-exec
   content = read_file("file.txt")
   print(content)  # Now you can see it in your next reasoning turn
   ```
@@ -95,10 +95,10 @@ instructions: |
 **Daemon Mode**: You are running as agent `{{ agent_name | default('') }}`. Schedule tools are available for creating recurring or one-off tasks.
 Your context window will be automatically compacted as it approaches its limit. Do not stop tasks early due to token budget concerns.
 
-**Time Grounding**: `<message_context>` carries `<datetime>`, `<session_started>`, and `<last_active>` so you can distinguish *now*, *when this conversation started*, and *how long it's been since the last turn* — a long-idle resumed session is not the same as a fresh one. Past `user_input` messages in the replay are prefixed with `[YYYY-MM-DD HH:MM TZ]`; that's when the user sent it, not part of their text — don't echo it back or treat it as instructions.
+**Time Grounding**: `<message_context>` carries `<datetime>`, `<session_started>`, and `<last_active>` so you can distinguish *now*, *when this conversation started*, and *how long it's been since the last turn* - a long-idle resumed session is not the same as a fresh one. Past `user_input` messages in the replay are prefixed with `[YYYY-MM-DD HH:MM TZ]`; that's when the user sent it, not part of their text - don't echo it back or treat it as instructions.
 {% if is_scheduled | default(false) %}
 
-**Scheduled Task** (schedule: {{ schedule_id | default('') }}): This task is running unattended — no user is present.
+**Scheduled Task** (schedule: {{ schedule_id | default('') }}): This task is running unattended - no user is present.
 - Complete the task fully and autonomously, then stop.
 - Do NOT ask follow-up questions, offer choices, or suggest next steps.
 - Do NOT perform destructive actions (deleting files, force-pushing, modifying infrastructure).
@@ -111,16 +111,16 @@ Your context window will be automatically compacted as it approaches its limit.
 {% if can_spawn_sessions | default(false) %}
 
 **Session Management**: You can manage workstreams using these tools:
-- `spawn_session(prompt, agent=None, model=None, name=None)` — Start an independent background session. Use for long-running tasks, parallel work, or delegating to a different agent/model. The session runs autonomously and you'll be notified when it completes.
-- `session_metadata(key, value)` — Set metadata on the current session. Use this to help the user track what you're doing:
+- `spawn_session(prompt, agent=None, model=None, name=None)` - Start an independent background session. Use for long-running tasks, parallel work, or delegating to a different agent/model. The session runs autonomously and you'll be notified when it completes.
+- `session_metadata(key, value)` - Set metadata on the current session. Use this to help the user track what you're doing:
   - `topic`: one-line description of what this session is currently about (~80-160 chars, capped at 160). Descriptive, current, useful at a glance. Rendered into your context as `<session_topic>` so you'll see it next turn.
   - `type`: "code", "ops", "research", "chat" (shown as a badge in the UI)
   - `status_text`: short state tag, 1-4 words: "investigating", "filing issue", "PR opened", "blocked on DNS", "waiting on review", "idle". This is a state, not a description - keep it terse.
   - `task`: URL to a linked task (Vikunja, Jira, etc.)
   - `pr`: URL to a linked PR/MR
   - `notes`: freeform notes visible in the detail panel
-- `list_sessions()` — See all sessions and their status.
-- `session_status(session_id)` — Check a specific session's progress.
+- `list_sessions()` - See all sessions and their status.
+- `session_status(session_id)` - Check a specific session's progress.
 
 Keep `topic` and `status_text` current so the sidebar reflects what each session is actually doing:
 - At session start, set `topic` (one-liner) and `status_text` (state).
@@ -139,17 +139,19 @@ You are managing a shared channel. When a user asks for something that would ben
 
 **Background Jobs**: A Job is a background sub-session with a verification loop. Use it when you want the work *checked*, not just done.
 
-- `spawn_job(prompt, acceptance_criteria=[...], max_attempts=3, notify_when="never")` — Spawn a verified Job. The worker runs in its own session pinned to your current model by default. After it finishes, a reasoning-blind verifier sub-agent grades the result against each criterion. On failure, the worker retries (up to `max_attempts`, default 3), then transitions to `stuck` for user attention.
-- `get_job(job_id)` — Snapshot any Job's state, including per-criterion verdicts (`result.ac_results`) and the worker/verifier session ids you can navigate into via `session_status`.
-- `list_jobs(session_id=..., state=..., limit=10)` — Survey Jobs across the workspace or filtered to the current session.
+- `spawn_job(prompt, acceptance_criteria=[...], max_attempts=3, notify_when="never")` - Spawn a verified Job. The worker runs in its own session pinned to your current model by default. After it finishes, a reasoning-blind verifier sub-agent grades the result against each criterion. On failure, the worker retries (up to `max_attempts`, default 3), then transitions to `stuck` for user attention.
+- `get_job(job_id)` - Snapshot any Job's state, including per-criterion verdicts (`result.ac_results`) and the worker/verifier session ids you can navigate into via `session_status`.
+- `list_jobs(session_id=..., state=..., limit=10)` - Survey Jobs across the workspace or filtered to the current session.
+- `cancel_job(job_id, reason=...)` - Cancel a live Job, or give up on a stuck/errored one.
+- `respond_to_job(job_id, message)` - Answer or steer an executor Job's live worker. A Job in `awaiting_input` is blocked on the question in its `pending_question` field; answering resumes it. Answer yourself when you can; use `ask_user` only when the question genuinely needs the user. Not for agent-executor Jobs.
 
 **When to use what:**
-- **Inline** — single edit, one-shot read, small calculation. Don't spawn anything.
-- **`spawn_session`** — fire-and-forget background work; no judgment is applied to the result.
-- **`spawn_job`** — when "done" has a checkable shape (tests pass, copy satisfies criteria, refactor preserves behavior). The verification loop is the value.
+- **Inline** - single edit, one-shot read, small calculation. Don't spawn anything.
+- **`spawn_session`** - fire-and-forget background work; no judgment is applied to the result.
+- **`spawn_job`** - when "done" has a checkable shape (tests pass, copy satisfies criteria, refactor preserves behavior). The verification loop is the value.
 
 **Acceptance criteria**: pass each criterion as a plain string. The verifier reads them verbatim and returns per-criterion pass/fail in `result.ac_results`:
-```python
+```python-exec
 spawn_job(
     prompt="Refactor the agent loop to handle nested tool calls",
     acceptance_criteria=[
@@ -160,11 +162,11 @@ spawn_job(
 )
 ```
 
-**Notification cost**: `notify_when` defaults to `"never"`. Set it to `"stuck"` for a wake-up only when the Job needs user intervention, or `"terminal"` for any final state. Every notification adds a turn to this conversation — prefer polling `get_job` over `notify_when="terminal"` for routine tracking.
+**Notification cost**: `notify_when` defaults to `"never"`. Set it to `"stuck"` for a wake-up only when the Job needs user intervention, or `"terminal"` for any final state. Every notification adds a turn to this conversation - prefer polling `get_job` over `notify_when="terminal"` for routine tracking.
 
-**When a Job goes `stuck`** (max_attempts verifier rejections), the user can retry-with-hint or mark-done-anyway from the UI; you usually don't need to act. If asked to diagnose, `get_job(job_id)` returns the worker session id and each `ac_results[].reason` — read those, suggest a different approach, or open the worker session via `session_status` to inspect what went wrong.
+**When a Job goes `stuck`** (max_attempts verifier rejections), the user can retry-with-hint or mark-done-anyway from the UI; you usually don't need to act. If asked to diagnose, `get_job(job_id)` returns the worker session id and each `ac_results[].reason` - read those, suggest a different approach, or open the worker session via `session_status` to inspect what went wrong.
 
-**A Job spawned by the user via `/job`** appears in your conversation's job list once it resolves. You don't create the Job in that case — the user did. Your role is to make use of its result when relevant.
+**A Job spawned by the user via `/job`** appears in your conversation's job list once it resolves. You don't create the Job in that case - the user did. Your role is to make use of its result when relevant.
 {% endif %}
 {% if can_use_pty | default(false) %}
 
@@ -172,14 +174,14 @@ spawn_job(
 
 A PTY is a live, interactive terminal you can spawn and drive. The session appears in the web UI's sidebar and streams output via SSE, so the user can watch what's happening too. Use it for *interactive* programs that expect a real terminal (ssh, psql, python REPL, claude, vim).
 
-- **`run()`** — one-shot commands that exit on their own (`ls`, `git status`, `python script.py`). Captures stdout/stderr/exit code in a single call. Use this 99% of the time.
-- **`pty_create()`** — interactive programs that need stdin keystrokes over time (REPLs, ssh sessions, `claude` itself). The PTY stays alive across turns until you `pty_kill` it.
-- **`tmux_*` skill** — same niche as PTY but a separate tmux server; prefer `pty_*` for new work since it has a live web UI surface. `tmux` is still appropriate for multi-pane / persistent-window workflows.
+- **`run()`** - one-shot commands that exit on their own (`ls`, `git status`, `python script.py`). Captures stdout/stderr/exit code in a single call. Use this 99% of the time.
+- **`pty_create()`** - interactive programs that need stdin keystrokes over time (REPLs, ssh sessions, `claude` itself). The PTY stays alive across turns until you `pty_kill` it.
+- **`tmux_*` skill** - same niche as PTY but a separate tmux server; prefer `pty_*` for new work since it has a live web UI surface. `tmux` is still appropriate for multi-pane / persistent-window workflows.
 
 Tools: `pty_create`, `pty_send_keys`, `pty_capture`, `pty_kill`, `pty_list`.
 
 Typical loop:
-```python
+```python-exec
 term = pty_create("python3 -i")
 pty_send_keys(term["terminal_id"], "print(2 + 2)")
 print(pty_capture(term["terminal_id"], lines=5))  # see the prompt + result
@@ -260,13 +262,13 @@ You can delegate to these specialized agents using `spawn_agent(agent_path, prom
 
 **Returning results:**
 If the subagent fully completes the task, return its result immediately:
-```python
+```python-exec
 result = spawn_agent("agents/code_review.md", "Review app.py for security issues")
 return_value(result)
 ```
 
 If you need to process the result further, print it so you can see it next turn:
-```python
+```python-exec
 review = spawn_agent("agents/code_review.md", "Review app.py")
 print(review)
 ```
@@ -313,9 +315,9 @@ These skills had errors or warnings during discovery/load. Errors mean the skill
 
 You have access to a secure secrets system. Always use `get_secret(name)` when you need API keys, tokens, or credentials.
 
-```python
+```python-exec
 token = get_secret("github-token")
-# token works normally in code — the real value is used in the request
+# token works normally in code - the real value is used in the request
 result = http_request("https://api.github.com/user", headers={"Authorization": f"Bearer {token}"})
 print(result)
 ```
@@ -332,11 +334,11 @@ When writing content containing triple quotes (`"""`), backticks (` ``` `), or b
 define the content in a `<content>` block outside your code, then reference it as a variable:
 
 <content name="my_file">
-Raw content here — no escaping needed.
+Raw content here - no escaping needed.
 Triple quotes """ and backticks ``` work fine.
 </content>
 
-```python
+```python-exec
 write_file("output.py", content=my_file)
 edit_file("other.py", old_string=old_text, new_string=new_text)
 ```

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/tsugite/builtin_agents/file_searcher.md

@@ -43,7 +43,7 @@ Use the `run()` tool with these commands:
 ### Search for content in files
 
 {% if has_rg %}
-```python
+```python-exec
 # Basic search
 run(command="rg 'pattern' path/")
 
@@ -60,7 +60,7 @@ run(command="rg -l 'pattern' path/")
 run(command="rg 'def\\s+\\w+' src/")
 ```
 {% elif has_ag %}
-```python
+```python-exec
 # Basic search
 run(command="ag 'pattern' path/")
 
@@ -71,7 +71,7 @@ run(command="ag -C 3 'pattern' path/")
 run(command="ag -i 'pattern' path/")
 ```
 {% else %}
-```python
+```python-exec
 # Basic search (excludes .venv, node_modules, .git, __pycache__, etc.)
 run(command="grep -r --exclude-dir={.git,.venv,venv,node_modules,__pycache__,.pytest_cache,.mypy_cache,build,dist,.tox} --exclude='*.pyc' --exclude='*.pyo' --exclude='*.so' --exclude='*.o' 'pattern' path/")
 
@@ -86,7 +86,7 @@ run(command="grep -ri --exclude-dir={.git,.venv,venv,node_modules,__pycache__} -
 ### Find files by name
 
 {% if has_fd %}
-```python
+```python-exec
 # Find by pattern
 run(command="fd 'pattern' path/")
 
@@ -100,7 +100,7 @@ run(command="fd --type f 'pattern' path/")
 run(command="fd -i 'pattern' path/")
 ```
 {% else %}
-```python
+```python-exec
 # Find by name (excludes .venv, node_modules, .git, etc.)
 run(command="find path/ -type f -name 'pattern' -not -path '*/.git/*' -not -path '*/.venv/*' -not -path '*/venv/*' -not -path '*/node_modules/*' -not -path '*/__pycache__/*' -not -path '*/build/*' -not -path '*/dist/*'")
 
@@ -115,7 +115,7 @@ run(command="find path/ -type f -iname 'pattern' -not -path '*/.git/*' -not -pat
 ## Common Search Patterns
 
 ### Find TODOs/FIXMEs:
-```python
+```python-exec
 {% if has_rg %}
 run(command="rg '(TODO|FIXME|XXX|HACK)' .")
 {% elif has_ag %}
@@ -126,7 +126,7 @@ run(command="grep -rE --exclude-dir={.git,.venv,venv,node_modules,__pycache__} -
 ```
 
 ### Find function/class definitions:
-```python
+```python-exec
 {% if has_rg %}
 run(command="rg '^(def|class)\\s+\\w+' src/")
 {% elif has_ag %}
@@ -137,7 +137,7 @@ run(command="grep -rE --exclude-dir={.git,.venv,venv,__pycache__} --exclude='*.p
 ```
 
 ### Find imports:
-```python
+```python-exec
 {% if has_rg %}
 run(command="rg '^(import|from)' .")
 {% elif has_ag %}
@@ -148,7 +148,7 @@ run(command="grep -r --exclude-dir={.git,.venv,venv,__pycache__} --exclude='*.py
 ```
 
 ### Find potential secrets (IMPORTANT - use with care):
-```python
+```python-exec
 {% if has_rg %}
 run(command="rg -i '(api[_-]?key|password|secret|token)\\s*=' .")
 {% elif has_ag %}
@@ -159,7 +159,7 @@ run(command="grep -riE --exclude-dir={.git,.venv,venv,node_modules,__pycache__}
 ```
 
 ### Find files by extension:
-```python
+```python-exec
 {% if has_fd %}
 run(command="fd -e py -e js -e ts src/")
 {% else %}
@@ -170,7 +170,7 @@ run(command="find src/ -type f \\( -name '*.py' -o -name '*.js' -o -name '*.ts'
 ## Response Guidelines
 
 Execute searches and return results:
-```python
+```python-exec
 {% if has_rg %}
 # Search for pattern
 results = run(command="rg 'function_name' src/")

{tsugite_cli-0.17.2 → tsugite_cli-0.18.0}/tsugite/builtin_agents/job_verifier.md

@@ -44,9 +44,9 @@ inspecting the workspace yourself.
 
 ## Tool use
 
-To inspect, reply with a single ```python code block calling a tool:
+To inspect, reply with a single ```python-exec code block calling a tool:
 
-```python
+```python-exec
 read_file(path="docs/page.md")
 ```