pcli-agent 0.1.0__py3-none-any.whl

pcli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

pcli/__main__.py

@@ -0,0 +1,4 @@
+from pcli.cli import main
+
+if __name__ == "__main__":
+    main()

pcli/agent/activity.py

@@ -0,0 +1,116 @@
+"""Ephemeral live-activity state for the TUI's status pane.
+
+Deliberately NOT part of Session (not persisted, not exported/imported): it
+exists only so a running subagent can report its progress up to the screen
+without cluttering the main conversation with its intermediate tool calls
+(see tools/builtin/subagent_tool.py's own docstring on that design choice).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from pcli.util.text import truncate
+
+
+@dataclass
+class SubagentToolCall:
+    name: str
+    arguments: str
+
+
+@dataclass
+class SubagentActivity:
+    task: str
+    tool_calls: int = 0
+    last_tool: str | None = None
+    call_log: list[SubagentToolCall] = field(default_factory=list)
+    """Full history of tool calls made so far (name + raw arguments JSON),
+    for the /subagent inspect command and for giving the user something to
+    relate an in-flight ask_user_question to - tool_calls/last_tool above
+    stay as plain counters/names for the existing status-bar line."""
+    pending_question: tuple[str, list[str] | None] | None = None
+    """Set while the subagent is blocked inside ask_user_question, so /subagent
+    can show what it's currently waiting on."""
+
+
+class ActivityTracker:
+    """One shared instance per chat screen. A single subagent slot is enough
+    since the agent loop dispatches tool calls sequentially, never
+    concurrently — at most one subagent is ever running at a time."""
+
+    def __init__(self) -> None:
+        self._subagent: SubagentActivity | None = None
+        self._subscribers: list[Callable[[], None]] = []
+
+    def subscribe(self, callback: Callable[[], None]) -> None:
+        self._subscribers.append(callback)
+
+    def unsubscribe(self, callback: Callable[[], None]) -> None:
+        """No-op if callback isn't currently subscribed (e.g. a modal that
+        never mounted, or an already-cleaned-up double dismiss) - cleanup
+        code should never have to guard this call itself."""
+        if callback in self._subscribers:
+            self._subscribers.remove(callback)
+
+    @property
+    def subagent(self) -> SubagentActivity | None:
+        return self._subagent
+
+    def start_subagent(self, task: str) -> None:
+        self._subagent = SubagentActivity(task=task)
+        self._notify()
+
+    def record_subagent_tool_call(self, tool_name: str, arguments: str = "") -> None:
+        if self._subagent is None:
+            return
+        self._subagent.tool_calls += 1
+        self._subagent.last_tool = tool_name
+        self._subagent.call_log.append(SubagentToolCall(name=tool_name, arguments=arguments))
+        self._notify()
+
+    def set_subagent_pending_question(self, question: str, options: list[str] | None) -> None:
+        if self._subagent is None:
+            return
+        self._subagent.pending_question = (question, options)
+        self._notify()
+
+    def clear_subagent_pending_question(self) -> None:
+        if self._subagent is None:
+            return
+        self._subagent.pending_question = None
+        self._notify()
+
+    def finish_subagent(self) -> None:
+        self._subagent = None
+        self._notify()
+
+    def _notify(self) -> None:
+        for callback in self._subscribers:
+            callback()
+
+
+def format_subagent_activity(sub: SubagentActivity) -> str:
+    """Shared rendering of a SubagentActivity snapshot - used by both the
+    /subagent command (a one-off system message, rendered as Markdown - see
+    message_view.py's _render_message) and SubagentActivityModal (a live
+    view wrapped in Text instead, precisely to sidestep Rich console markup
+    parsing of untrusted tool arguments - see that widget's own docstring).
+    Real Markdown here (blank lines between blocks) so the /subagent
+    rendering doesn't collapse into one run-on paragraph the way plain
+    "\\n"-joined lines would; "N. " tool-call entries were already valid
+    Markdown ordered-list syntax on their own, so those are unchanged."""
+    lines = [f"**Subagent task:** {sub.task}", "", f"**Tool calls so far:** {len(sub.call_log)}"]
+    if sub.pending_question is not None:
+        question, options = sub.pending_question
+        lines.append("")
+        lines.append(f"**Currently waiting on your answer to:**\n{question}")
+        if options:
+            lines.append("")
+            lines.append("Options: " + ", ".join(options))
+    if sub.call_log:
+        lines.append("")
+        for i, call in enumerate(sub.call_log, start=1):
+            lines.append(f"{i}. {call.name}({truncate(call.arguments, 200)})")
+    return "\n".join(lines)

pcli/agent/compaction.py

@@ -0,0 +1,205 @@
+"""Auto-compaction: when a session's conversation grows large relative to its
+model's context window, summarizes the oldest turns via a single dedicated
+LLM call and replaces them with the summary — archiving the original, full
+transcript to the artifact library first (the same ArtifactStore/
+fetch_artifact mechanism that already archives oversized tool results in
+agent/loop.py's _archive_if_large), so nothing is silently lost, just moved
+out of the live context.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from pcli.llm.client import GatewayClient
+from pcli.llm.models import ChatMessage, Usage
+from pcli.session.models import Message, Session
+from pcli.tools.artifacts import ArtifactStore
+from pcli.tools.builtin.todo_tool import render_todos
+
+_COMPACTION_SYSTEM_PROMPT = (
+    "You are summarizing an in-progress coding-agent conversation so it can continue with "
+    "much less context. Write a concise but complete summary covering: what the user asked "
+    "for, what has been done so far (files changed, commands run, key outcomes), and any "
+    "assumptions you made along the way and why — state them explicitly, since the "
+    "continuation must not silently re-litigate or contradict something already assumed and "
+    "acted on. The session's own recorded decisions and current todo list are appended "
+    "separately, verbatim, after your summary — don't restate them, but do mention anything "
+    "still pending or unresolved that isn't already reflected there. Do not include "
+    "pleasantries or restate this instruction — write plain prose/bullets the assistant can "
+    "use to pick up exactly where it left off."
+)
+
+
+@dataclass
+class CompactionResult:
+    summary_message: Message
+    artifact_id: str
+    messages_compacted: int
+    usage: Usage
+
+
+def turn_boundaries(messages: list[Message]) -> list[int]:
+    """Indices of role=='user' messages — the only safe places to cut, since
+    a full turn's tool_calls/tool-result pairs always live entirely between
+    one user message and the next. Cutting anywhere else risks splitting an
+    assistant(tool_calls=...) from its matching tool-role response, which
+    breaks the chat-completions wire format.
+
+    Used (via compaction_cutoff) by both this module and
+    agent/context_pruning.py — the same turn-boundary-safety reasoning
+    applies to pruning old tool results, not just full-turn compaction."""
+    return [i for i, m in enumerate(messages) if m.role == "user"]
+
+
+def _round_boundaries(messages: list[Message]) -> list[int]:
+    """Finer-grained fallback for turn_boundaries: every index safe to cut
+    at (message.role != "tool", so a tool result is never separated from the
+    assistant tool_calls message that requested it) - not just role=='user'.
+
+    A single long-running task (one user message, then dozens of internal
+    assistant/tool round trips as the model works through it) has exactly
+    one 'user' boundary for its entire life. Gating on turn_boundaries alone
+    means that session's eligibility check (len(boundaries) <= keep_recent_
+    turns) never becomes false, no matter how much context that one turn's
+    own history has accumulated - real debugged case: a session hit its
+    model's context limit and stalled with no visible error (see
+    cost/context.py's looks_like_context_ceiling), and /compact reported
+    "nothing to compact" even though the conversation was enormous, because
+    it had only ever received a single user message. Used only as a
+    fallback, when turn_boundaries alone doesn't yield enough boundaries to
+    safely keep keep_recent_turns of them - a normal multi-turn conversation
+    is unaffected and keeps using turn_boundaries exactly as before."""
+    return [i for i, m in enumerate(messages) if m.role != "tool"]
+
+
+_MIN_ROUNDS_FOR_FALLBACK = 20
+"""How many round trips a single (or few) user turn must accumulate before
+the _round_boundaries fallback below kicks in at all. Deliberately much
+bigger than any ordinary keep_recent_turns value (2 by default): an
+ordinary short turn - a handful of tool calls, still the single most recent
+thing the user is looking at - has nowhere near this many round-boundary
+entries, so it's left completely alone, exactly as if the fallback didn't
+exist. Only once a single turn has genuinely ballooned well past that (a
+long autonomous task making dozens of tool calls) does the fallback treat
+it as something worth compacting/pruning into."""
+
+
+def compaction_cutoff(messages: list[Message], *, keep_recent_turns: int) -> int | None:
+    """The index up to which messages are eligible to be summarized/pruned,
+    keeping the most recent turns' worth of exchanges verbatim - None if
+    there isn't enough history yet to safely do anything.
+
+    Prefers turn_boundaries (real user-typed turns): if there are more of
+    those than keep_recent_turns, behavior is exactly what it always was.
+    Otherwise falls back to the finer _round_boundaries - but only once the
+    single (or few) turn(s) have grown past _MIN_ROUNDS_FOR_FALLBACK, and
+    even then keeping at least that many of the most recent rounds verbatim
+    (not the much smaller keep_recent_turns itself, which is calibrated for
+    whole turns, not individual round trips) - see both docstrings for why."""
+    boundaries = turn_boundaries(messages)
+    if len(boundaries) > keep_recent_turns:
+        return boundaries[-keep_recent_turns] if keep_recent_turns > 0 else len(messages)
+
+    round_boundaries = _round_boundaries(messages)
+    fallback_keep = max(keep_recent_turns, _MIN_ROUNDS_FOR_FALLBACK)
+    if len(round_boundaries) <= fallback_keep:
+        return None
+    return round_boundaries[-fallback_keep]
+
+
+def _system_prompt_prefix_len(messages: list[Message]) -> int:
+    """1 if the very first message is the session's leading system prompt
+    (role=='system'), else 0. Deliberately checks only messages[0], not a
+    run of every leading system-role message: a previous compaction's own
+    summary message also has role=='system' and sits right after the real
+    prompt, but must stay eligible to be folded into a *later* compaction —
+    counting a run would permanently protect it instead."""
+    return 1 if messages and messages[0].role == "system" else 0
+
+
+def _render_transcript(messages: list[Message]) -> str:
+    """Plain-text rendering of a message range for archiving — a human/LLM
+    -readable record retrievable via fetch_artifact, not sent to any model
+    as-is."""
+    lines: list[str] = []
+    for m in messages:
+        header = f"--- {m.role} ---"
+        if m.tool_calls:
+            calls = ", ".join(f"{c.function.name}({c.function.arguments})" for c in m.tool_calls)
+            lines.append(f"{header}\n[tool_calls: {calls}]")
+        elif m.content:
+            lines.append(f"{header}\n{m.content}")
+    return "\n\n".join(lines)
+
+
+def _render_ground_truth_state(session: Session) -> str:
+    """Renders the session's own recorded decisions and current todo list —
+    both live on Session directly (record_decision/write_todos), not inside
+    session.messages, so this source data is never itself at risk from
+    compaction. Spliced verbatim into the compaction summary rather than
+    trusted to the summarizer's own prose reconstruction of the raw
+    transcript: a decision's rationale (the "why") is exactly the kind of
+    detail easy to lose in a lossy re-summarization pass, and the todo
+    list needs to reflect its actual current state, not whatever it
+    happened to look like at some earlier point in the now-compacted
+    history. Returns "" (nothing to append) if there are no decisions and
+    no todos yet."""
+    parts: list[str] = []
+    if session.decisions:
+        lines = [f"- {d.decision} — {d.rationale}" for d in session.decisions]
+        parts.append("**Decisions recorded so far:**\n" + "\n".join(lines))
+    if session.todos:
+        parts.append("**Current todo list:**\n" + render_todos(session.todos))
+    return "\n\n".join(parts)
+
+
+async def maybe_compact(
+    session: Session,
+    *,
+    gateway_client: GatewayClient,
+    model: str | None,
+    artifact_store: ArtifactStore,
+    keep_recent_turns: int = 2,
+) -> CompactionResult | None:
+    """Compacts the oldest turns of session.messages in place, returning
+    None if there isn't enough history to safely compact yet (fewer than
+    keep_recent_turns+1 user turns, or - the fallback compaction_cutoff
+    applies for a session dominated by one long, tool-call-heavy turn -
+    round trips)."""
+    cut_index = compaction_cutoff(session.messages, keep_recent_turns=keep_recent_turns)
+    if cut_index is None:
+        return None
+
+    prefix_len = _system_prompt_prefix_len(session.messages)
+    to_compact = session.messages[prefix_len:cut_index]
+    if not to_compact:
+        return None
+
+    transcript = _render_transcript(to_compact)
+    artifact_id = artifact_store.put(transcript)
+
+    summary_messages = [
+        ChatMessage(role="system", content=_COMPACTION_SYSTEM_PROMPT),
+        ChatMessage(role="user", content=transcript),
+    ]
+    assistant_message, usage = await gateway_client.collect(summary_messages, model=model)
+    summary_text = assistant_message.content or "(no summary produced)"
+
+    note = (
+        f"\n\n[Compacted {len(to_compact)} earlier message(s) to reduce context usage. "
+        f"Archived as artifact_id='{artifact_id}'. Call fetch_artifact(artifact_id="
+        f"'{artifact_id}') if you need something specific from the original conversation.]"
+    )
+    ground_truth = _render_ground_truth_state(session)
+    content = summary_text + (f"\n\n{ground_truth}" if ground_truth else "") + note
+    summary_message = Message(role="system", content=content)
+
+    session.messages[prefix_len:cut_index] = [summary_message]
+
+    return CompactionResult(
+        summary_message=summary_message,
+        artifact_id=artifact_id,
+        messages_compacted=len(to_compact),
+        usage=usage,
+    )

pcli/agent/context_pruning.py

@@ -0,0 +1,88 @@
+"""Tool-result pruning: a lightweight, mechanical (no LLM call) pass that
+shrinks the content of old, already-resolved tool-role messages down to a
+short placeholder — archiving the original first (retrievable via
+fetch_artifact, same ArtifactStore mechanism agent/loop.py's
+_archive_if_large and agent/compaction.py's maybe_compact already use).
+
+Distinct from maybe_compact: compaction is coarse and late (only fires once
+context usage crosses a threshold, replaces entire old turns with one LLM
+summary). This pass runs every turn, touches only tool-role message content
+(never user/assistant text or the assistant's own tool_calls), and needs no
+model call — small, already-spent tool results (a `which foo` probe, a
+one-line `ls`) are exactly what this targets, well before compaction's
+threshold would ever notice them.
+"""
+
+from __future__ import annotations
+
+import json
+
+from pcli.agent.compaction import compaction_cutoff
+from pcli.session.models import Message, Session
+from pcli.tools.artifacts import ArtifactStore
+
+
+def extract_purpose(arguments_json: str) -> str | None:
+    """Best-effort: given a tool call's raw JSON arguments string, returns
+    the model-supplied "purpose" value (see ToolSpec.to_openai_tool) if
+    present and well-formed, else None. Never raises — a malformed or
+    missing purpose is just not shown, not an error."""
+    try:
+        arguments = json.loads(arguments_json or "{}")
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(arguments, dict):
+        return None
+    purpose = arguments.get("purpose")
+    return purpose if isinstance(purpose, str) and purpose.strip() else None
+
+
+def _find_purpose(messages: list[Message], tool_call_id: str | None) -> str | None:
+    """Scans every assistant tool_calls entry for one matching tool_call_id
+    and extracts its purpose — tool_call ids are unique per call, so a full
+    scan (not just the immediately preceding message) is correct and, for
+    real session sizes, cheap."""
+    if tool_call_id is None:
+        return None
+    for message in messages:
+        if message.role != "assistant" or not message.tool_calls:
+            continue
+        for call in message.tool_calls:
+            if call.id == tool_call_id:
+                return extract_purpose(call.function.arguments)
+    return None
+
+
+def prune_old_tool_results(
+    session: Session, *, keep_recent_turns: int, artifact_store: ArtifactStore
+) -> int:
+    """Replaces old tool-role message content with a compact placeholder,
+    mutating session.messages in place — the most recent keep_recent_turns
+    turns' tool results stay verbatim. Idempotent: a message already pruned
+    (pruned_artifact_id set) is skipped, so this is safe to call every turn
+    without re-archiving or duplicating artifacts. Returns how many messages
+    were pruned this call (0 if nothing was old enough yet)."""
+    cutoff_index = compaction_cutoff(session.messages, keep_recent_turns=keep_recent_turns)
+    if cutoff_index is None:
+        return 0  # nothing old enough to prune yet
+
+    pruned_count = 0
+    for i in range(cutoff_index):
+        message = session.messages[i]
+        if message.role != "tool" or message.pruned_artifact_id is not None or not message.content:
+            continue
+
+        original_content = message.content
+        artifact_id = artifact_store.put(original_content)
+        purpose = _find_purpose(session.messages, message.tool_call_id)
+
+        note = f"[Pruned tool result ({len(original_content):,} chars) to save context."
+        if purpose:
+            note += f" Purpose: {purpose}."
+        note += f" Call fetch_artifact(artifact_id='{artifact_id}') if you need it.]"
+
+        message.content = note
+        message.pruned_artifact_id = artifact_id
+        pruned_count += 1
+
+    return pruned_count

pcli/agent/headless.py

@@ -0,0 +1,209 @@
+"""Runs a single task non-interactively - the machinery behind `pcli run`
+(cli.py) and each incoming message `pcli telegram` handles (telegram/
+daemon.py). No MessageView/StatusBar: progress is reported through a plain
+callback instead. `ask`/`ask_question` both default to None - no UI to ask
+through - which the permission/ask_user_question machinery already handles
+safely on its own (see agent/runtime.py's make_tool_context); `pcli
+telegram` is the one caller that actually supplies them, wired to Telegram
+inline-keyboard prompts instead of None.
+
+Deliberately narrower than ChatScreen._run_one_turn: no tool-result
+pruning, no auto-compaction, and no memory-extraction pass (all three are
+tied to ChatScreen's own StatusBar/MessageView plumbing and are aimed at a
+long-lived interactive session accumulating history over hours - a
+headless run is normally short-lived per invocation). It does replicate
+one piece: auto-continuing a response truncated by the token limit
+(TurnCompleteEvent.response_truncated, see agent/loop.py) - skipping that
+would be a *worse* silent-stall bug here than in the TUI, since there's no
+user present to notice and type "continue" themselves.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from pcli.agent.loop import AgentLoop
+from pcli.agent.prompt import PLAN_MODE_REINFORCEMENT, build_system_prompt
+from pcli.agent.runtime import (
+    AgentRuntime,
+    effective_max_tool_iterations,
+    make_tool_context,
+    record_tool_invocation,
+)
+from pcli.config.settings import Settings
+from pcli.cost.tracker import CostTracker, cost_budget_reason
+from pcli.llm.models import ChatMessage
+from pcli.memory.models import render_memory_section
+from pcli.memory.store import read_memory
+from pcli.permissions.manager import AskCallback, PermissionManager
+from pcli.session.models import Message, Session
+from pcli.session.store import SessionStore
+from pcli.tools.artifacts import SessionArtifactStore
+from pcli.tools.base import AskQuestionCallback
+from pcli.tools.registry import ToolRegistry
+
+_MAX_CONSECUTIVE_AUTO_CONTINUES = 3
+"""Same cap and reasoning as ChatScreen's own _MAX_CONSECUTIVE_AUTO_CONTINUES
+(tui/screens/chat.py) - not shared as a single constant, since the two
+call sites' own docstrings are the more useful place to read the reasoning
+from, and a numeric constant this small isn't worth an import just to avoid
+repeating "3"."""
+_AUTO_CONTINUE_MESSAGE = "Continue."
+
+ProgressCallback = Callable[[str], None]
+
+
+@dataclass
+class HeadlessTurnResult:
+    session: Session
+    final_text: str
+    terminated_early: bool
+    truncations_exhausted: bool = False
+    """True if the response was still being cut off by the token limit
+    after _MAX_CONSECUTIVE_AUTO_CONTINUES automatic retries - the caller
+    may want to flag this distinctly from an ordinary finish (e.g. a
+    non-zero exit code from `pcli run`, since the work is likely genuinely
+    incomplete)."""
+
+
+def new_headless_session(
+    store: SessionStore, settings: Settings, cwd: Path
+) -> Session:
+    """A fresh Session with the same system prompt (incl. global user
+    memory, if enabled) a brand-new TUI session gets - see ChatScreen.
+    __init__'s identical construction in tui/screens/chat.py."""
+    extra_sections: list[str] = []
+    if settings.memory_enabled:
+        memory_section = render_memory_section(read_memory().entries)
+        if memory_section:
+            extra_sections.append(memory_section)
+    session = store.new_session(
+        model=settings.default_model,
+        gateway_base_url=settings.gateway_base_url,
+        working_dir=str(cwd),
+    )
+    session.messages.append(
+        Message(role="system", content=build_system_prompt(extra_sections=extra_sections or None))
+    )
+    return session
+
+
+async def run_headless_task(
+    task: str,
+    *,
+    session: Session,
+    runtime: AgentRuntime,
+    settings: Settings,
+    permission_manager: PermissionManager,
+    cwd: Path,
+    store: SessionStore,
+    on_progress: ProgressCallback = lambda _line: None,
+    ask: AskCallback | None = None,
+    ask_question: AskQuestionCallback | None = None,
+    plan_mode: bool = False,
+    tool_registry: ToolRegistry | None = None,
+) -> HeadlessTurnResult:
+    """plan_mode/tool_registry mirror ChatScreen._set_plan_mode's own two
+    layers (see agent/prompt.py's PLAN_MODE_REINFORCEMENT for the third):
+    tool_registry is the primary mechanism (the model never even sees a
+    disallowed tool - the caller is expected to pass runtime.tool_registry
+    pre-filtered via ToolRegistry.filtered(lambda t: t.plan_mode_safe) when
+    plan_mode is True, the same way ChatScreen._effective_tool_registry
+    does; this function has no opinion of its own on what "plan mode"
+    means, it just wires through whatever registry it's given), defaulting
+    to runtime.tool_registry when not overridden; plan_mode itself both
+    activates AgentLoop's dispatch-time backstop (via ctx.plan_mode, below)
+    and injects the per-turn reinforcement message further down."""
+    artifact_store = SessionArtifactStore(store, session.id)
+    cost_tracker = CostTracker(session)
+    effective_tool_registry = tool_registry if tool_registry is not None else runtime.tool_registry
+
+    def tool_context_factory():
+        return make_tool_context(
+            runtime,
+            settings,
+            cwd,
+            session=session,
+            permission_manager=permission_manager,
+            artifact_store=artifact_store,
+            ask=ask,
+            ask_question=ask_question,
+            plan_mode=plan_mode,
+        )
+
+    agent_loop = AgentLoop(
+        runtime.client,
+        model=settings.default_model or None,
+        tool_registry=effective_tool_registry,
+        permission_manager=permission_manager,
+        tool_context_factory=tool_context_factory,
+        max_tool_iterations=effective_max_tool_iterations(settings),
+        artifact_threshold_chars=settings.artifact_threshold_chars,
+        temperature=settings.default_temperature,
+    )
+
+    session.messages.append(Message(role="user", content=task))
+    on_progress(f"> {task}")
+    store.save(session)
+
+    final_text = ""
+    terminated_early = False
+    truncations_exhausted = False
+    consecutive_truncations = 0
+    run_again = True
+    while run_again:
+        run_again = False
+        chat_messages = [m.to_chat_message() for m in session.messages]
+        if plan_mode:
+            chat_messages.append(ChatMessage(role="system", content=PLAN_MODE_REINFORCEMENT))
+        text_parts: list[str] = []
+        async for event in agent_loop.run_turn(
+            chat_messages,
+            ask=ask,
+            budget_check=lambda: cost_budget_reason(session, settings.max_session_cost_usd),
+        ):
+            if event.kind == "text_delta":
+                text_parts.append(event.text)
+            elif event.kind == "usage":
+                cost_tracker.record_turn(settings.default_model or session.model, event.usage)
+            elif event.kind == "tool_start":
+                on_progress(
+                    f"  -> {event.tool_call.function.name}({event.tool_call.function.arguments})"
+                )
+            elif event.kind == "tool_result":
+                for extra in event.extra_usage:
+                    cost_tracker.record_turn(
+                        settings.default_model or session.model, extra, source="subagent"
+                    )
+                preview = event.output if len(event.output) <= 200 else event.output[:200] + "..."
+                on_progress(f"  <- {preview}")
+                record_tool_invocation(
+                    session, event, audit_enabled=settings.audit_mode_enabled
+                )
+            elif event.kind == "turn_complete":
+                session.messages.extend(Message.from_chat_message(m) for m in event.new_messages)
+                terminated_early = event.terminated_early
+                if event.response_truncated:
+                    if consecutive_truncations < _MAX_CONSECUTIVE_AUTO_CONTINUES:
+                        consecutive_truncations += 1
+                        on_progress(
+                            "  [pcli] Response was cut off by the token limit - continuing "
+                            f"automatically ({consecutive_truncations}/{_MAX_CONSECUTIVE_AUTO_CONTINUES})."
+                        )
+                        session.messages.append(Message(role="user", content=_AUTO_CONTINUE_MESSAGE))
+                        run_again = True
+                    else:
+                        truncations_exhausted = True
+                else:
+                    consecutive_truncations = 0
+        store.save(session)
+        final_text = "".join(text_parts) or final_text
+
+    return HeadlessTurnResult(
+        session=session,
+        final_text=final_text,
+        terminated_early=terminated_early,
+        truncations_exhausted=truncations_exhausted,
+    )