tsugite-cli 0.24.0__tar.gz → 0.25.0__tar.gz

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/.gitignore

@@ -196,3 +196,4 @@ plugins/tsugite-daemon/tsugite_daemon/web/
 !plugins/tsugite-daemon/frontend/src/lib/**
 # Per-job git worktrees provisioned by the daemon.
 .tsugite-jobs/
+/packaging/runtime/.cache/

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tsugite-cli
-Version: 0.24.0
+Version: 0.25.0
 Summary: Micro-agent runner for task automation using markdown definitions
 Author: Justyn Shull
 License: GNU AFFERO GENERAL PUBLIC LICENSE
@@ -241,6 +241,7 @@ License: GNU AFFERO GENERAL PUBLIC LICENSE
 License-File: LICENSE
 Keywords: agents,automation,cli,jinja2
 Requires-Python: >=3.11
+Requires-Dist: certifi>=2026.10.23
 Requires-Dist: cryptography>=46.0.5
 Requires-Dist: html2text>=2020.1.16
 Requires-Dist: httpx>=0.25

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tsugite-cli"
-version = "0.24.0"
+version = "0.25.0"
 description = "Micro-agent runner for task automation using markdown definitions"
 authors = [{ name = "Justyn Shull" }]
 requires-python = ">=3.11"
@@ -12,6 +12,7 @@ dependencies = [
   "jinja2>=3.1",
   "pyyaml>=6.0",
   "httpx>=0.25",
+  "certifi>=2026.10.23",
   "rich>=13.0",
   "questionary>=2.1.1",
   "html2text>=2020.1.16",

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/agent_preparation.py

@@ -434,7 +434,6 @@ class AgentPreparer:
             _combine_instructions,
             execute_exec_directives,
             execute_tool_directives,
-            get_default_instructions,
         )
         from tsugite.core.agent import build_system_prompt
         from tsugite.renderer import AgentRenderer
@@ -506,12 +505,16 @@ class AgentPreparer:
                     skip_reason=skip_reason,
                 )
 
+        tools = self._expand_tools(agent_config, full_context, interactive_mode)
+        # Templates test membership against the names actually installed, not the
+        # frontmatter specs (`"@secrets"`).
+        full_context["tools"] = [t.name for t in tools]
+
         try:
             rendered_prompt = renderer.render(modified_content, full_context)
         except Exception as e:
             raise RuntimeError(f"Template rendering failed: {e}") from e
 
-        base_instructions = get_default_instructions()
         agent_instructions = getattr(agent_config, "instructions", "")
 
         # Render agent instructions as Jinja2 template
@@ -521,9 +524,7 @@ class AgentPreparer:
             except Exception as e:
                 raise RuntimeError(f"Failed to render agent instructions: {e}") from e
 
-        combined_instructions = _combine_instructions(base_instructions, agent_instructions)
-
-        tools = self._expand_tools(agent_config, full_context, interactive_mode)
+        combined_instructions = _combine_instructions(agent_instructions)
 
         skill_load = self._load_skills(agent_config, prompt, full_context, _skill_manager, event_bus)
         skills, expiring_skills = skill_load.skills, skill_load.expiring

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/agent_runner/__init__.py

@@ -31,7 +31,6 @@ from tsugite.agent_runner.runner import (  # noqa: F401
     _execute_agent_with_prompt,
     execute_prefetch,
     execute_tool_directives,
-    get_default_instructions,
     preview_multistep_agent,
     run_agent,
     run_agent_async,
@@ -47,7 +46,6 @@ __all__ = [
     "execute_exec_directives",
     "run_python_block",
     "ExecBlockResult",
-    "get_default_instructions",
     "AgentExecutionResult",
     "StepMetrics",
     "display_step_metrics",

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/agent_runner/runner.py

@@ -10,7 +10,7 @@ from pathlib import Path  # noqa: E402
 from types import SimpleNamespace  # noqa: E402
 from typing import TYPE_CHECKING, Any, Dict, List, Optional  # noqa: E402
 
-from tsugite.core.agent import TsugiteAgent  # noqa: E402
+from tsugite.core.agent import NO_ACTION_MESSAGE, AgentResult, TsugiteAgent  # noqa: E402
 from tsugite.core.executor_registry import get_executor_class  # noqa: E402
 from tsugite.core.proxy import _parse_pattern  # noqa: E402
 from tsugite.core.state import session_state_path  # noqa: E402
@@ -155,31 +155,6 @@ def _setup_event_context(event_bus: Optional["EventBus"]) -> None:
         set_ui_context(event_bus=event_bus)
 
 
-def get_default_instructions() -> str:
-    """Get minimal default instructions. Detailed guidance comes from skills.
-
-    Returns:
-        Default instructions for code execution mode
-    """
-    base = "You accomplish tasks by writing Python code.\n\n"
-
-    output = (
-        "## Output\n\n"
-        "- `print(x)` - See in next turn (internal)\n"
-        "- `send_message(msg)` - Show user progress\n"
-        "- `final_answer(msg)` - Final response (stops execution)\n\n"
-    )
-
-    rules = (
-        "## Rules\n\n"
-        "1. Always respond with Python code blocks\n"
-        "2. Call `final_answer()` when done\n"
-        "3. Variables persist between turns\n"
-    )
-
-    return base + output + rules
-
-
 def _render_args(value: Any, renderer: AgentRenderer, context: Dict[str, Any]) -> Any:
     """Recursively render Jinja in string leaves of a tool args structure.
 
@@ -320,32 +295,17 @@ def execute_tool_directives(
     return modified_content, new_context
 
 
-def _extract_reasoning_content(agent: TsugiteAgent, custom_logger: Optional[Any] = None) -> None:
-    """Extract and display reasoning content from TsugiteAgent memory.
-
-    For models like Claude/Deepseek that expose reasoning_content, displays the actual reasoning.
-
-    Args:
-        agent: The TsugiteAgent instance that just completed execution
-        custom_logger: Custom logger to display reasoning content
-    """
-    if not hasattr(agent, "memory") or not agent.memory.reasoning_history:
-        return
+# Daemon chat sources with a person at the other end; any other source counts as background.
+INTERACTIVE_SOURCES = frozenset({"http", "discord"})
 
-    # Display each reasoning entry
-    for reasoning_content in agent.memory.reasoning_history:
-        if reasoning_content and custom_logger:
-            # Check if custom_logger has ui_handler (custom UI mode)
-            ui_handler = get_ui_handler(custom_logger)
-            if ui_handler:
-                from tsugite.events import EventBus, ReasoningContentEvent
 
-                event_bus = EventBus()
-                event_bus.subscribe(ui_handler.handle_event)
-                event_bus.emit(ReasoningContentEvent(content=reasoning_content, step=None))
+def _run_is_interactive(channel_metadata: Optional[Dict[str, Any]]) -> bool:
+    """Whether a person is present: the session source in the daemon, the TTY otherwise."""
+    source = (channel_metadata or {}).get("source")
+    return source in INTERACTIVE_SOURCES if source else is_interactive()
 
 
-def _make_pre_llm_call_callback(hooks_dir: Path, agent_name: str):
+def _make_pre_llm_call_callback(hooks_dir: Path, agent_name: str, interactive: bool):
     """Build an async callback that fires pre_llm_call hooks to mutate outgoing
     messages in place. Returns None when no such hooks exist (keeps the hot path clean)."""
     from tsugite.hooks import fire_hooks, load_hooks_config
@@ -359,7 +319,7 @@ def _make_pre_llm_call_callback(hooks_dir: Path, agent_name: str):
             hooks_dir,
             "pre_llm_call",
             {"messages": messages, "model": model, "agent": agent_name},
-            interactive=is_interactive(),
+            interactive=interactive,
         )
 
     return _callback
@@ -401,6 +361,7 @@ async def _execute_agent_with_prompt(
     user_input_for_history: Optional[str] = None,
     channel_metadata: Optional[Dict[str, Any]] = None,
     usage_sink: Optional[Dict[str, Any]] = None,
+    requires_action: bool = False,
 ) -> str | AgentExecutionResult:
     """Execute agent with a prepared agent.
 
@@ -409,6 +370,9 @@ async def _execute_agent_with_prompt(
     `usage_sink`, when given, receives this call's token and cost counters. It is
     how a multi-step run collects accounting from steps that return plain
     strings.
+
+    `requires_action` makes a run that ends without executing any code raise, so a
+    step whose result feeds later steps cannot pass on a prose answer.
     """
     if exec_options is None:
         exec_options = ExecutionOptions()
@@ -445,8 +409,9 @@ async def _execute_agent_with_prompt(
         hooks_dir = path_context.effective_cwd
     else:
         hooks_dir = Path.cwd()
-    setup_hook_handler(hooks_dir, event_bus, interactive=is_interactive())
-    pre_llm_call_cb = _make_pre_llm_call_callback(hooks_dir, agent_config.name)
+    interactive = _run_is_interactive(channel_metadata)
+    setup_hook_handler(hooks_dir, event_bus, interactive=interactive)
+    pre_llm_call_cb = _make_pre_llm_call_callback(hooks_dir, agent_config.name, interactive)
 
     # Start with tools from prepared agent
     tools = list(prepared.tools)  # Make a copy
@@ -615,7 +580,7 @@ async def _execute_agent_with_prompt(
             hook_vars=hook_vars,
             storage=session_storage,
             pre_llm_call=pre_llm_call_cb,
-            expects_action=(channel_metadata or {}).get("source") == "scheduler",
+            expects_action=requires_action or (channel_metadata or {}).get("source") == "scheduler",
         )
         # Set event_bus in context so tools can access it during execution
         _setup_event_context(event_bus)
@@ -633,9 +598,6 @@ async def _execute_agent_with_prompt(
             stream=exec_options.stream,
         )
 
-        # Extract and display reasoning content if present
-        _extract_reasoning_content(agent, custom_logger)
-
         if usage_sink is not None:
             usage_sink.update(
                 token_count=agent.total_tokens,
@@ -666,10 +628,18 @@ async def _execute_agent_with_prompt(
         except Exception as e:
             logger.debug("Failed to record usage: %s", e)
 
+        if requires_action and agent.ended_no_action:
+            steps = result.steps if isinstance(result, AgentResult) and result.steps else []
+            raise AgentExecutionError(
+                NO_ACTION_MESSAGE,
+                execution_steps=steps,
+                token_usage=agent.total_tokens,
+                cost=agent.reported_cost,
+                step_count=len(steps),
+            )
+
         # Return appropriate format
         if exec_options.return_token_usage:
-            from tsugite.core.agent import AgentResult
-
             if isinstance(result, AgentResult):
                 step_count = len(result.steps) if result.steps else 0
                 steps_list = result.steps if result.steps else []
@@ -712,8 +682,6 @@ async def _execute_agent_with_prompt(
                     session_id=session_storage.session_id if session_storage else None,
                 )
         else:
-            from tsugite.core.agent import AgentResult
-
             if isinstance(result, AgentResult):
                 return str(result.output)
             else:
@@ -829,15 +797,17 @@ def _domain_within_ceiling(desired_pattern: str, ceiling: list) -> bool:
 
 
 def _resolve_workspace_dir(workspace: Optional[Any], path_context: Optional[Any]) -> Optional[Path]:
-    """Resolve the executor's workspace directory.
+    """Resolve the directory the executor runs code in.
 
-    Prefer an explicit Workspace object (CLI workspace runs); otherwise fall back
-    to the PathContext's workspace_dir. The daemon passes only a path_context (no
-    Workspace), so without this fallback the sandbox would bind/chdir the daemon's
-    CWD instead of the agent's workspace (or job worktree).
+    Checks: an explicit Workspace -> the directory bound with set_workspace_dir
+    (the daemon binds the session's working directory) -> path_context.workspace_dir.
     """
+    from tsugite.cli.helpers import get_workspace_dir
+
     if workspace:
         return workspace.path
+    if bound := get_workspace_dir():
+        return bound
     if path_context and getattr(path_context, "workspace_dir", None):
         return path_context.workspace_dir
     return None
@@ -872,6 +842,7 @@ class _RunSetup:
     resume_after_compaction: bool = False
     resume_cost_baseline: float = 0.0
     conversation_id: Optional[str] = None
+    requires_action: bool = False
 
 
 def _prepare_step(agent: Any, prompt: str, context: Dict[str, Any], setup: "_RunSetup") -> "PreparedAgent":
@@ -923,7 +894,7 @@ async def _run_unit(
             "rendered_prompt": prepared.rendered_prompt[:500] if prepared.rendered_prompt else "",
             "tools": [t.name for t in prepared.tools] if prepared.tools else [],
         },
-        interactive=is_interactive(),
+        interactive=_run_is_interactive(setup.channel_metadata),
         on_status=setup.on_status,
         on_result=setup.on_hook_result,
     )
@@ -955,6 +926,7 @@ async def _run_unit(
         model_kwargs=model_kwargs,
         injectable_vars=injectable_vars,
         usage_sink=usage_sink,
+        requires_action=setup.requires_action,
     )
 
     try:
@@ -1128,10 +1100,11 @@ async def run_agent_async(
         on_status = None
         on_hook_result = None
 
+    interactive = _run_is_interactive(channel_metadata)
     hook_vars = await fire_pre_message_hooks(
         hooks_dir,
         {"message": hook_message, "agent_name": agent_path.stem},
-        interactive=is_interactive(),
+        interactive=interactive,
         on_status=on_status,
         on_result=on_hook_result,
     )
@@ -1145,7 +1118,7 @@ async def run_agent_async(
         hooks_dir,
         "pre_context_build",
         {"message": hook_message, "agent_name": agent_path.stem, **context, "blocks": context_blocks},
-        interactive=is_interactive(),
+        interactive=interactive,
         on_status=on_status,
         on_result=on_hook_result,
     )

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/agent_runner/steps.py

@@ -252,6 +252,7 @@ async def _execute_step_with_retries(
         resume_session=None,
         resume_after_compaction=False,
         resume_cost_baseline=0.0,
+        requires_action=bool(step.assign_var),
     )
     errors = []
     step_start_time = time.time()

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/approval.py

@@ -31,23 +31,28 @@ _LABEL_TO_DECISION = {
 
 
 def request_approval(
-    prompt: str, *, allow_always: bool = False, allow_never: bool = False, detail: Optional[str] = None
+    prompt: str,
+    *,
+    allow_always: bool = False,
+    allow_never: bool = False,
+    extra_options: Optional[dict[str, str]] = None,
+    detail: Optional[str] = None,
 ) -> str:
     """Ask the user to approve an action, returning an :data:`ApprovalDecision`.
 
-    Builds ``Approve``/``Deny`` options (plus ``Always allow`` when ``allow_always``
-    and ``Always deny`` when ``allow_never``) and routes them through the active
-    interaction backend as an ``"approval"`` question, then maps the chosen label
-    back to a decision.
+    Offers ``Approve``/``Deny`` plus the optional choices below as an
+    ``"approval"`` question on the active interaction backend, and maps the
+    chosen label back to a decision.
 
     Args:
         prompt: The action to approve, phrased as a question.
         allow_always: Offer an "Always allow" option (a persistent allow).
         allow_never: Offer an "Always deny" option (a persistent deny).
+        extra_options: Caller-specific choices, as ``{label: decision}``.
         detail: Extra context appended below the prompt for the user to read.
 
     Returns:
-        One of ``"approve"``, ``"deny"``, ``"always"``, or ``"never"``.
+        One of ``"approve"``, ``"deny"``, ``"always"``, ``"never"``, or a value of ``extra_options``.
 
     Fail-closed: returns ``"deny"`` WITHOUT prompting when there is no backend or
     the backend is non-interactive, and for any unrecognized reply.
@@ -61,7 +66,9 @@ def request_approval(
         options.append(ALWAYS_LABEL)
     if allow_never:
         options.append(NEVER_LABEL)
+    decisions = _LABEL_TO_DECISION | (extra_options or {})
+    options.extend(extra_options or ())
 
     question = f"{prompt}\n\n{detail}" if detail else prompt
     answer = backend.ask_user(question, "approval", options)
-    return _LABEL_TO_DECISION.get(answer, "deny")
+    return decisions.get(answer, "deny")

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/attachments/agent_config.py

@@ -181,7 +181,7 @@ def _resolve_spec(
     if not resolved.exists():
         if spec.assign:
             bindings[spec.assign] = None
-        else:
+        elif not spec.optional:
             _warn_skipped(spec.path, f"not found: {resolved}")
         return
 

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/builtin_agents/default.md

@@ -6,9 +6,17 @@ extends: none
 # volatile memory last, so a change to today's memory / now.md doesn't invalidate
 # the identity files' cache. A flat list would be one block; these are three.
 attachments:
-  - [PERSONA.md, SOUL.md, USER.md, IDENTITY.md, AGENTS.md]
-  - [MEMORY.md, "memory/{{ yesterday() }}.md", "memory/{{ date_format(now(), '%Y-%m') }}.md"]
-  - ["memory/{{ today() }}.md", notes/context/now.md, NOW.md]
+  - - {path: PERSONA.md, optional: true}
+    - {path: SOUL.md, optional: true}
+    - {path: USER.md, optional: true}
+    - {path: IDENTITY.md, optional: true}
+    - {path: AGENTS.md, optional: true}
+  - - {path: MEMORY.md, optional: true}
+    - {path: "memory/{{ yesterday() }}.md", optional: true}
+    - {path: "memory/{{ date_format(datetime.now().replace(day=1) - timedelta(days=1), '%Y-%m') }}.md", optional: true}
+  - - {path: "memory/{{ today() }}.md", optional: true}
+    - {path: notes/context/now.md, optional: true}
+    - {path: NOW.md, optional: true}
 max_turns: 10
 tools:
   - spawn_agent
@@ -65,7 +73,7 @@ instructions: |
   - Break down complex tasks into clear steps
   - Ask clarifying questions when the task is ambiguous
   - Write Python code to accomplish tasks
-  - Call return_value(result) when you've completed the task
+  - When you've completed the task, reply in plain text, or call return_value() for structured output
   - If you intend to call multiple tools and there are no dependencies between the calls, make all independent calls in a single code block
   - Never guess about code you have not read. Use read_file or list_files to investigate before answering questions about code
 
@@ -227,13 +235,6 @@ You have running tmux sessions that you can interact with using tmux tools (tmux
 {% endfor %}
 {% endif %}
 
-{% if "run" in tools and "tmux_create" in tools %}
-## Shell vs Tmux
-
-- Use `run()` for commands that produce output and exit: `run("ls -la")`, `run("git status")`, `run("python script.py")`
-- Use tmux tools for interactive programs (htop, k9s, psql, python REPL), long-running processes you want to monitor, or when you need a persistent shell session where state carries across commands
-{% endif %}
-
 {% if subagent_instructions is defined and subagent_instructions %}
 {{ subagent_instructions }}
 {% endif %}
@@ -291,11 +292,11 @@ Load these skills for specialized knowledge:
 - **{{ skill.name }}** - {{ skill.description }}
 {% endfor %}
 
-Call `load_skill("skill_name")` and stop. The skill content appears next turn as `<loaded_skill>`. Then use what you learned.
+Call `load_skill("skill_name")` and stop. The skill content appears next turn as `<skill_content>`. Then use what you learned.
 
 Do not act in the same turn you load a skill. Skip loading if you already know how to do the task.
 
-Skills may show bash commands. Translate to Python: `shell.run("kubectl get pods")`
+Skills may show bash commands. Translate to Python: `run("kubectl get pods")`
 </available_skills>
 {% endif %}
 

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/builtin_agents/job_verifier.md

@@ -76,7 +76,9 @@ is `true` only if every `ac_results[i].pass` is `true`.
 
 `reason` opens with the basis for the verdict, then one sentence:
 
-- `inspected:` - you read the artifact, file, or Output text yourself.
+- `inspected:` - you read the artifact or file yourself with a tool call.
+- `read Output:` - the deliverable is inline text and you judged the `## Output`
+  text itself, with no tool call.
 - `ran <command>:` - you executed the command and judged its exit status.
 - `accepted worker claim:` - you could not check it, so the verdict rests on
   the worker's report.

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/builtin_skills/codebase-exploration/SKILL.md

@@ -365,7 +365,7 @@ If available via custom tools configuration, consider using:
 tools:
   - name: ast_search
     description: Search code using AST patterns
-    command: "ast-grep -p '{pattern}' {path}"
+    command: "ast-grep -p {pattern} {path}"
     parameters:
       pattern: {required: true}
       path: "."

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/builtin_skills/response-patterns/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: response-patterns
-description: How to respond effectively - when to use print/send_message/final_answer/ask_user
+description: How to respond effectively - when to use print/send_message/return_value/ask_user
 ---
 
 # Response Patterns
@@ -11,21 +11,18 @@ description: How to respond effectively - when to use print/send_message/final_a
 |----------|----------|-----------|---------|
 | `print(x)` | You (next turn) | Continues | Intermediate data |
 | `send_message(msg)` | User | Continues | Progress updates |
-| `final_answer(msg)` | User | **Stops** | Final response |
+| `return_value(value)` | User | **Stops** | Structured final result |
 | `ask_user(q)` | User | **Blocks** | Get user input |
 
 ## Simple Responses
 
-No functions needed? One line:
+No functions needed? Reply in plain text:
 
-```python-exec
-final_answer("Hello! What can I help you with?")
-```
+- "Thanks" replies `You're welcome!`
+- "What's 2+2?" replies `4`
+- "What can you do?" replies `I can read/write files, run commands, and help with tasks.`
 
-More examples:
-- "Thanks" → `final_answer("You're welcome!")`
-- "What's 2+2?" → `final_answer("4")`
-- "What can you do?" → `final_answer("I can read/write files, run commands, search code, and help with tasks.")`
+Call `return_value(value)` only when the caller needs a structured result.
 
 ## Progress Updates
 
@@ -33,14 +30,14 @@ For longer tasks, keep user informed:
 
 ```python-exec
 send_message("Searching codebase...")
-results = search_code("def main")
+results = run("grep -rn 'def main' .")
 print(results)  # You'll see this next turn
 ```
 
 ```python-exec
-send_message(f"Found {len(results)} matches. Analyzing...")
+send_message(f"Found {len(results.splitlines())} matches. Analyzing...")
 # ... more work ...
-final_answer("Here's what I found: ...")
+return_value("Here's what I found: ...")
 ```
 
 ## Asking the User
@@ -87,7 +84,7 @@ Use `ask_user` when:
 - Ask unnecessary questions when a reasonable default exists
 
 ✅ Do:
-- `final_answer()` immediately for simple responses
+- Plain text immediately for simple responses
 - `send_message()` for progress on tasks > 5 seconds
 - `ask_user()` when you genuinely need user input
 - `print()` only for data YOU need to see

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/cli/helpers.py

@@ -500,8 +500,8 @@ class PathContext:
     effective_cwd: Path
 
 
-# Mirrors PathContext.workspace_dir for call sites (fs tools, shell, subprocesses)
-# that don't receive PathContext explicitly. Task-local so concurrent agent runs
+# The directory the running agent's code and fs tools work in, for call sites
+# (fs tools, shell, subprocesses, the executor) that don't receive PathContext explicitly. Task-local so concurrent agent runs
 # don't share state.
 _workspace_dir_cv: contextvars.ContextVar[Optional[Path]] = contextvars.ContextVar("workspace_dir", default=None)
 

{tsugite_cli-0.24.0 → tsugite_cli-0.25.0}/tsugite/cli/run.py

@@ -257,7 +257,6 @@ def run(
     ),
     no_workspace: bool = typer.Option(False, "--no-workspace", help="Disable workspace (ignore default workspace)"),
     new_session: bool = typer.Option(False, "--new-session", help="Start fresh session (ignore workspace session)"),
-    join_daemon: bool = typer.Option(False, "--daemon", "-d", help="Join the daemon's most recent session"),
     sandbox: bool = typer.Option(False, "--sandbox", help="Run agent code in bubblewrap sandbox"),
     no_sandbox: bool = typer.Option(False, "--no-sandbox", help="Disable sandbox (overrides config)"),
     allow_domain: Optional[List[str]] = typer.Option(
@@ -282,7 +281,6 @@ def run(
         tsu run --continue "prompt"  # Continue latest conversation (auto-detect agent)
         tsu run +assistant --continue "prompt"  # Continue latest with specific agent
         tsu run --continue --conversation-id CONV_ID "prompt"  # Continue specific conversation
-        tsu run --daemon "follow up message"  # Join the daemon's most recent session
     """
     from tsugite.agent_runner import get_agent_info, run_agent
     from tsugite.console import get_stderr_console
@@ -381,7 +379,7 @@ def run(
     # Resolve UI mode to update ui_opts
     ui_opts = _resolve_ui_mode(ui, ui_opts, stderr_console)
 
-    # Handle subagent mode and daemon mode (both need os)
+    # Handle subagent mode
     import os
 
     if subagent_mode:
@@ -393,54 +391,6 @@ def run(
         history_opts.enabled = False
         os.environ["TSUGITE_SUBAGENT_MODE"] = "1"
 
-    daemon_metadata = None
-    if join_daemon:
-        from tsugite.agent_runner.history_integration import get_latest_conversation
-
-        try:
-            from tsugite_daemon.config import load_daemon_config
-
-            # Probe: the daemon battery has to be installed and configured.
-            load_daemon_config()
-        except ModuleNotFoundError as e:
-            stderr_console.print(
-                "[red]The daemon battery is not installed.[/red] Install it with: pip install tsugite-cli[daemon]"
-            )
-            raise typer.Exit(1) from e
-        except ValueError as e:
-            stderr_console.print(f"[red]Daemon config not found: {e}[/red]")
-            stderr_console.print("[dim]Run 'tsugite daemon' to start daemon first[/dim]")
-            raise typer.Exit(1)
-
-        user_id = os.environ.get("USER", "cli-user")
-
-        latest_conv_id = get_latest_conversation()
-        if latest_conv_id:
-            stderr_console.print(f"[cyan]Joining daemon session: {latest_conv_id}[/cyan]")
-            history_opts.continue_id = latest_conv_id
-        else:
-            stderr_console.print("[yellow]No active daemon session found[/yellow]")
-            stderr_console.print("[dim]Creating new daemon-managed session...[/dim]")
-
-        # Build CLI metadata for history
-        from datetime import datetime, timezone
-
-        daemon_metadata = {
-            "source": "cli",
-            "channel_id": None,
-            "user_id": user_id,
-            "reply_to": "cli",
-            "is_daemon_managed": True,
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-        }
-
-        all_attachments = list(attachment) if attachment else []
-        attach_opts = AttachmentOptions(
-            sources=all_attachments,
-            refresh_cache=refresh_cache,
-            auto_context=auto_context,
-        )
-
     # Handle conversation continuation - check before parsing args
     if continue_conversation and not history_opts.continue_id:
         from tsugite.agent_runner.history_integration import get_latest_conversation
@@ -641,7 +591,6 @@ def run(
                     continue_conversation_id=target_session,
                     system_prompt=system_prompt,
                     attachments=attachments,
-                    channel_metadata=daemon_metadata,
                     status=status,
                     error_message=error_message,
                 )