Merge remote-tracking branch 'origin/main' into claude/gifted-hawking-03sdhe

# Conflicts:
#	aai_cli/AGENTS.md
#	tests/__snapshots__/test_snapshots_help_run.ambr

Author: claude

REFERENCE.md

@@ -160,8 +160,8 @@ missing `npx`/`uvx`, an offline host) drops only its own tools, so a single brok
 tool never sinks the session. MCP tools are a live-run feature and are not
 reflected in `--show-code` output.
 
-`--files` lets the agent read, write, and run code in the directory you launch
-it from (off by default). Reads run immediately; a write, edit, or command run pauses
+The agent reads, writes, and runs code in the directory you launch it from (on by
+default; pass `--no-files` to disable). Reads run immediately; a write, edit, or command run pauses
 the turn for confirmation in the voice TUI — press `y`/`n` (`a` approves the rest of the
 session) or just say it ("approve" / "run it" / "go ahead"; anything unclear is treated as
 a no). Destructive commands (e.g. `rm -rf`, `sudo`) ignore the spoken answer and require a

aai_cli/AGENTS.md

@@ -8,7 +8,8 @@
 (:func:`build_graph`) and driven turn-by-turn with the running history the
 cascade already keeps (:func:`build_streamer`); tools are read-only and auto-approved,
 because a spoken turn can't pause for a keyboard confirmation, and the system prompt
-keeps every reply short and speakable.
+keeps every reply short and speakable. Context-window management is deepagents' job (its built-in
+``SummarizationMiddleware``), so the engine feeds the full untrimmed history each turn.
 
 The graph is the only network seam: :func:`build_streamer` accepts an injected graph,
 so the per-turn streaming reply leg is unit-tested against a fake with no sockets — the

aai_cli/agent_cascade/brain.py

@@ -27,7 +27,11 @@
     "engine, so write plain spoken prose — no markdown, emoji, bullet lists, or code."
 )
 DEFAULT_GREETING = "Hi! I'm your AssemblyAI voice agent. What can I help you with?"
-# Sliding-window size: keep the last N messages of conversation as LLM context.
+# Sliding-window size for the standalone, hand-rolled cascade: keep the last N messages of
+# conversation as LLM context. Used by the `--show-code` generator and the `assembly init`
+# template, which talk to the gateway directly. The live `assembly live` brain does NOT window
+# client-side — it delegates context management to the deepagents `SummarizationMiddleware`
+# (summarize old turns, offload to a file), so this knob is inert on that path. See brain.py.
 DEFAULT_MAX_HISTORY = 40
 # Per-turn cap on how many tool calls the deepagents brain may make before it must answer.
 # Enforced by a ToolCallLimitMiddleware with exit_behavior="continue": once the budget is hit,

aai_cli/agent_cascade/config.py

@@ -61,7 +61,7 @@
     timeout_error as _timeout_error,
 )
 from aai_cli.agent_cascade.config import CascadeConfig
-from aai_cli.agent_cascade.text import pop_clauses, trim_history
+from aai_cli.agent_cascade.text import pop_clauses
 from aai_cli.core.errors import CLIError
 from aai_cli.ui import output
 
@@ -150,7 +150,6 @@ def on_turn(self, event: object) -> None:
             self.renderer.user_final(text)
             self._barge_in()
             self.history.append({"role": "user", "content": text})
-            trim_history(self.history, self.config.max_history)
             self._start_reply()
         else:
             self.renderer.user_partial(text)
@@ -419,11 +418,16 @@ def _feed(self, pcm: bytes) -> None:
             self.player.enqueue(pcm)
 
     def _record_spoken(self, spoken: list[str]) -> None:
-        """Append what was actually spoken to the history (kept alternating after a barge-in)."""
+        """Append what was actually spoken to the history (kept alternating after a barge-in).
+
+        The transcript is no longer windowed client-side: the deepagents brain's built-in
+        ``SummarizationMiddleware`` does the context-window management (summarizing old turns,
+        offloading the evicted history to a file), so the engine keeps the full running history
+        and lets the graph compact it per turn — see :mod:`aai_cli.agent_cascade.brain`.
+        """
         spoken_text = " ".join(spoken).strip()
         if spoken_text:
             self.history.append({"role": "assistant", "content": spoken_text})
-            trim_history(self.history, self.config.max_history)
 
     def _surface_error(self, exc: CLIError, *, started: bool) -> None:
         """Record a reply-leg failure (LLM/timeout). Before any audio, the error is also shown

aai_cli/agent_cascade/engine.py

@@ -1,7 +1,9 @@
-"""Pure text helpers for the cascade: sentence splitting and history trimming.
+"""Pure text helpers for the cascade: sentence and clause splitting.
 
 Kept Rich-free and dependency-light so the orchestration logic in ``engine`` can
-be unit-tested without any I/O.
+be unit-tested without any I/O. (Conversation-history trimming used to live here as a
+client-side sliding window; the live brain now delegates context-window management to
+the deepagents ``SummarizationMiddleware`` instead — see :mod:`aai_cli.agent_cascade.brain`.)
 """
 
 from __future__ import annotations
@@ -27,6 +29,17 @@ def _is_boundary(text: str, index: int) -> bool:
     return index + 1 < len(text) and text[index + 1].isspace()
 
 
+def _ends_sentence(text: str, index: int, char: str) -> bool:
+    """True when ``char`` at ``index`` closes a sentence: a terminator at end-of-text or
+    followed by whitespace.
+
+    Unlike :func:`_is_boundary` (used for partial streamed chunks), end-of-text *does* close a
+    sentence here: :func:`split_sentences` runs on a complete reply, so a trailing terminator is a
+    real boundary, not a possibly-mid-token one.
+    """
+    return char in _TERMINATORS and (index + 1 == len(text) or text[index + 1].isspace())
+
+
 def pop_clauses(buffer: str, *, min_chars: int) -> tuple[list[str], str]:
     """Pull complete speakable clauses off the front of ``buffer`` for incremental TTS.
 
@@ -68,7 +81,7 @@ def split_sentences(text: str) -> list[str]:
     sentences: list[str] = []
     start = 0
     for index, char in enumerate(text):
-        if char in _TERMINATORS and (index + 1 == len(text) or text[index + 1].isspace()):
+        if _ends_sentence(text, index, char):
             # Boundary confirmed (end-of-text or a following space); the slice includes
             # the terminator, so it is never blank after stripping leading whitespace.
             sentences.append(text[start : index + 1].strip())
@@ -77,13 +90,3 @@ def split_sentences(text: str) -> list[str]:
     if tail:
         sentences.append(tail)
     return sentences
-
-
-def trim_history[T](history: list[T], max_messages: int) -> None:
-    """Cap ``history`` to its most recent ``max_messages`` entries, in place.
-
-    A sliding window over the conversation so an unbounded chat doesn't grow the
-    context (and the per-turn token cost) without limit.
-    """
-    if len(history) > max_messages:
-        del history[: len(history) - max_messages]

aai_cli/agent_cascade/text.py

@@ -62,8 +62,8 @@ def _emit_voice_list(_state: AppState, json_mode: bool) -> None:
                 "assembly --sandbox live --mcp-config ~/.config/mcp/servers.json",
             ),
             (
-                "Let the agent read and write files in the current directory",
-                "assembly --sandbox live --files",
+                "Run a conversation without filesystem access",
+                "assembly --sandbox live --no-files",
             ),
             ("See available voices", "assembly --sandbox live --list-voices"),
             (
@@ -172,9 +172,9 @@ def live(
         rich_help_panel=_PANEL_TOOLS,
     ),
     files: bool = typer.Option(
-        False,
-        "--files",
-        help="Let the agent read, write, and run code in the current directory, sandboxed (writes and runs need confirmation)",
+        True,
+        "--files/--no-files",
+        help="Let the agent read, write, and run code in the current directory, sandboxed (writes and runs need confirmation). Use --no-files to disable",
         rich_help_panel=_PANEL_TOOLS,
     ),
     auto_write: list[str] | None = typer.Option(

aai_cli/commands/agent_cascade/__init__.py

@@ -630,14 +630,17 @@
   │                                                             streaming fields │
   ╰──────────────────────────────────────────────────────────────────────────────╯
   ╭─ Tools ──────────────────────────────────────────────────────────────────────╮
-  │ --mcp-config        FILE  MCP servers config JSON ({"mcpServers": {…}}) to   │
-  │                           add (repeatable; none load by default)             │
-  │ --files                   Let the agent read, write, and run code in the     │
-  │                           current directory, sandboxed (writes and runs need │
-  │                           confirmation)                                      │
-  │ --auto-write        TEXT  Auto-approve --files writes under this             │
-  │                           subdirectory, skipping the confirmation            │
-  │                           (repeatable)                                       │
+  │ --mcp-config                  FILE  MCP servers config JSON ({"mcpServers":  │
+  │                                     {…}}) to add (repeatable; none load by   │
+  │                                     default)                                 │
+  │ --files         --no-files          Let the agent read, write, and run code  │
+  │                                     in the current directory, sandboxed      │
+  │                                     (writes and runs need confirmation). Use │
+  │                                     --no-files to disable                    │
+  │                                     [default: files]                         │
+  │ --auto-write                  TEXT  Auto-approve --files writes under this   │
+  │                                     subdirectory, skipping the confirmation  │
+  │                                     (repeatable)                             │
   ╰──────────────────────────────────────────────────────────────────────────────╯
 
    Examples
@@ -649,8 +652,8 @@
    $ assembly --sandbox live --system-prompt "You are a terse pirate."
    Add your own MCP servers (none load by default)
    $ assembly --sandbox live --mcp-config ~/.config/mcp/servers.json
-   Let the agent read and write files in the current directory
-   $ assembly --sandbox live --files
+   Run a conversation without filesystem access
+   $ assembly --sandbox live --no-files
    See available voices
    $ assembly --sandbox live --list-voices
    Print equivalent Python instead of running

tests/__snapshots__/test_snapshots_help_run.ambr

@@ -32,7 +32,8 @@ def test_default_config_values():
         "without preamble or filler. Your reply is read aloud by a text-to-speech "
         "engine, so write plain spoken prose — no markdown, emoji, bullet lists, or code."
     )
-    # The sliding-window default keeps the last 40 messages of context.
+    # The standalone (--show-code / init template) sliding-window default; the live brain
+    # delegates context management to the deepagents SummarizationMiddleware instead.
     assert config.max_history == 40
     assert DEFAULT_MAX_HISTORY == 40
     # Formatting is on by default, so the reply trigger waits for the formatted turn.

tests/test_agent_cascade_config.py

@@ -11,6 +11,7 @@
 import types
 
 import pytest
+from typer.testing import CliRunner
 
 from aai_cli.agent_cascade import brain, engine
 from aai_cli.agent_cascade.brain import ApprovalPause, SpeechDelta
@@ -19,9 +20,30 @@
 from aai_cli.commands.agent_cascade import _exec
 from aai_cli.commands.agent_cascade._exec import run_agent_cascade
 from aai_cli.core import config
+from aai_cli.main import app
 from tests._cascade_fakes import make_session
 from tests.test_agent_cascade_command import _opts
 
+runner = CliRunner()
+
+
+@pytest.mark.parametrize(
+    ("argv", "expected"),
+    [([], True), (["--no-files"], False), (["--files"], True)],
+)
+def test_files_flag_resolves_into_options(monkeypatch, argv, expected):
+    # Filesystem access is on by default: omitting the flag yields files=True, and --no-files
+    # opts out. Pinned at the argv->options seam so the True default isn't a silent mutation.
+    captured = {}
+
+    def fake_run(opts, state, *, json_mode):
+        captured["opts"] = opts
+
+    monkeypatch.setattr(_exec, "run_agent_cascade", fake_run)
+    result = runner.invoke(app, ["live", *argv])
+    assert result.exit_code == 0
+    assert captured["opts"].files is expected
+
 
 def test_deny_writes_always_rejects():
     # The non-interactive approver declines every write (no channel to confirm one).