voidx 1.1.0__tar.gz → 2.0.0__tar.gz

{voidx-1.1.0 → voidx-2.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: voidx
-Version: 1.1.0
+Version: 2.0.0
 Summary: A coding agent that quantifies everything and solves with tools, not fuzzy prompts.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
@@ -14,7 +14,7 @@ Requires-Dist: typer>=0.15.0
 Requires-Dist: rich>=13.9.0
 Requires-Dist: tiktoken>=0.8.0
 Requires-Dist: httpx>=0.28.0
-Requires-Dist: websockets>=16.0
+Requires-Dist: websockets>=14
 Provides-Extra: dev
 Requires-Dist: build>=1.2.0; extra == "dev"
 Requires-Dist: pytest>=8.0.0; extra == "dev"
@@ -26,22 +26,46 @@ voidx is a terminal AI coding agent built in Python.
 
 ## Install
 
-Python users can install the canonical package from PyPI:
+### One-line install (no Python or npm required)
+
+macOS / Linux:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/chikhamx/voidx/main/scripts/install.sh | bash
+```
+
+Windows (PowerShell):
+
+```powershell
+irm https://raw.githubusercontent.com/chikhamx/voidx/main/scripts/install.ps1 | iex
+```
+
+The installer downloads a standalone Python runtime and sets up voidx in an
+isolated environment — nothing else is needed on your machine.
+
+### pip
 
 ```bash
 pip install voidx
 voidx
 ```
 
-Node users can install the npm launcher. The launcher requires Python 3.11+
-on the machine and installs the matching Python package into an isolated
-user-local virtual environment on first run:
+### npm
 
 ```bash
 npm install -g @chikhamx/voidx
 voidx
 ```
 
+### China / slow network
+
+Set mirror environment variables before running any install method:
+
+```bash
+export VOIDX_PYTHON_MIRROR=https://npmmirror.com/mirrors/python-standalone
+export VOIDX_PIP_INDEX=https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
 ## Useful Commands
 
 ```bash

voidx-2.0.0/README.md

@@ -0,0 +1,61 @@
+# voidx
+
+voidx is a terminal AI coding agent built in Python.
+
+## Install
+
+### One-line install (no Python or npm required)
+
+macOS / Linux:
+
+```bash
+curl -fsSL https://raw.githubusercontent.com/chikhamx/voidx/main/scripts/install.sh | bash
+```
+
+Windows (PowerShell):
+
+```powershell
+irm https://raw.githubusercontent.com/chikhamx/voidx/main/scripts/install.ps1 | iex
+```
+
+The installer downloads a standalone Python runtime and sets up voidx in an
+isolated environment — nothing else is needed on your machine.
+
+### pip
+
+```bash
+pip install voidx
+voidx
+```
+
+### npm
+
+```bash
+npm install -g @chikhamx/voidx
+voidx
+```
+
+### China / slow network
+
+Set mirror environment variables before running any install method:
+
+```bash
+export VOIDX_PYTHON_MIRROR=https://npmmirror.com/mirrors/python-standalone
+export VOIDX_PIP_INDEX=https://pypi.tuna.tsinghua.edu.cn/simple
+```
+
+## Useful Commands
+
+```bash
+voidx version
+voidx sessions
+voidx -w /path/to/project
+```
+
+## Development
+
+```bash
+.venv/bin/python -m pytest
+.venv/bin/python scripts/package.py --format all --clean
+npm --prefix npm run check
+```

{voidx-1.1.0 → voidx-2.0.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "voidx"
-version = "1.1.0"
+version = "2.0.0"
 description = "A coding agent that quantifies everything and solves with tools, not fuzzy prompts."
 readme = "README.md"
 requires-python = ">=3.11"
@@ -15,7 +15,7 @@ dependencies = [
     "rich>=13.9.0",
     "tiktoken>=0.8.0",
     "httpx>=0.28.0",
-    "websockets>=16.0",
+    "websockets>=14",
 ]
 
 [project.scripts]
@@ -43,7 +43,10 @@ build-backend = "setuptools.build_meta"
 where = ["src"]
 
 [tool.setuptools.package-data]
-"voidx.skills" = ["bundled/superpowers/*/SKILL.md"]
+"voidx.skills" = [
+    "bundled/superpowers/*/SKILL.md",
+    "bundled/superpowers/*/templates/*.md",
+]
 
 [tool.pytest.ini_options]
 asyncio_mode = "auto"

{voidx-1.1.0 → voidx-2.0.0}/src/voidx/__init__.py

@@ -1,3 +1,3 @@
 """VoidX - A coding agent that quantifies everything."""
 
-__version__ = "1.1.0"
+__version__ = "2.0.0"

{voidx-1.1.0 → voidx-2.0.0}/src/voidx/agent/agents.py

@@ -83,8 +83,8 @@ surgical edits directly when that is the shortest safe path.
      the user explicitly approves.
    - Fix/implement/modify → edit directly for small scoped changes, or delegate
      broad/isolated work to implement.
-   - Ambiguous → continue with read-only investigation when useful. Ask one
-     clarifying question before edits, unsafe bash, or implement delegation.
+   - Ambiguous → continue with read-only investigation when useful. Use clarify
+     for one structured question before edits, unsafe bash, or implement delegation.
 
    Words like "看看", "分析", "梳理", "有什么建议", "如何设计", "优化方案",
    "look at", "analyze", "suggest", and "proposal" do NOT imply permission
@@ -92,11 +92,15 @@ surgical edits directly when that is the shortest safe path.
    says to modify code.
 
 1. **Chat / explain** — just answer. No tools unless you need to look something up.
+   If Current Task State says intent is chat or ambiguous, but the user request
+   appears to require workspace action, call on_intent before other workspace tools.
 
 2. **Simple search** — grab read/glob/grep and find it yourself. Only send explore
    for broad searches across many files.
 
-3. **Design / plan** — hand off to plan for architecture questions.
+3. **Design / plan** — hand off to plan for architecture questions. For
+   non-trivial implementation plans, call plan_checkpoint before changing files,
+   running write-capable commands, or delegating implement.
 
 4. **Code changes**
    - Small, local, or mechanical changes → read first, then call write/edit
@@ -109,9 +113,9 @@ surgical edits directly when that is the shortest safe path.
      reporting completion.
    - If review says FAIL or NEEDS_CHANGE → fix, review again.
 
-5. **Unclear intent** — ask. One specific clarifying question is better than five
-   assumptions. "When you say 'broken', do you mean it crashes, returns wrong data,
-   or something else?"
+5. **Unclear intent** — ask through clarify. One specific clarifying question is
+   better than five assumptions. "When you say 'broken', do you mean it crashes,
+   returns wrong data, or something else?"
 
 ## Rules
 
@@ -119,6 +123,8 @@ surgical edits directly when that is the shortest safe path.
 - In plan mode, do not call write/edit/lsp_format, unsafe bash, or implement.
 - Ambiguous implementation intent is not enough for write/edit/lsp_format,
   unsafe bash, or implement delegation.
+- Child agents do not interact with the user. If a child plan result needs user
+  approval or clarification, call plan_checkpoint or clarify yourself.
 - Don't tell the user "done" until changes are verified.
 - Child agents have isolated context — give them complete, self-contained briefs.
 
@@ -301,6 +307,7 @@ BUILTIN_AGENTS: dict[str, AgentDef] = {
                     "delegates broad work to specialists, reviews results.",
         when_to_use="Default agent for all user interactions. Always use first.",
         tools=[
+            "on_intent", "clarify", "plan_checkpoint",
             "read", "glob", "grep", "bash", "agent", "task_status", "todo",
             "webfetch", "websearch", "repo_map",
             "lsp_diagnostics", "lsp_symbols", "lsp_definition", "lsp_references",

{voidx-1.1.0 → voidx-2.0.0}/src/voidx/agent/graph/compaction.py

@@ -25,7 +25,7 @@ class GraphCompactionMixin:
     async def _maybe_compact(
         self: GraphCompactionHost,
         messages: list,
-        session_msgs: list,
+        session_msgs: list | None = None,
         *,
         force: bool = False,
         ask: bool = True,
@@ -218,14 +218,23 @@ class GraphCompactionMixin:
 
         await delete_messages_through(self._session.id, last_message_id)
 
+        # Sync in-memory cache: drop compacted rows
+        cache = getattr(self, "_session_msg_cache", None)
+        if cache is not None:
+            self._session_msg_cache = [r for r in cache if r.id is not None and r.id > last_message_id]
+
     async def _compact_session_history(self: GraphCompactionHost, *, force: bool = True) -> bool:
         if getattr(self, "_session", None) is None:
             ui.print("[dim]No active session to compact.[/dim]")
             return False
 
-        from voidx.memory.session import load_messages
+        cache = getattr(self, "_session_msg_cache", None)
+        if cache is not None:
+            rows = list(cache)
+        else:
+            from voidx.memory.session import load_messages
+            rows = await load_messages(self._session.id)
 
-        rows = await load_messages(self._session.id)
         messages = messages_from_rows(rows)
 
         head, _tail_id = await self._maybe_compact(messages, rows, force=force, ask=False)

{voidx-1.1.0 → voidx-2.0.0}/src/voidx/agent/graph/contracts.py

@@ -53,6 +53,7 @@ class GraphComponentHost(Protocol):
     _sub_buffers: dict[str, list[BaseMessage]]
     _pending_summary: str | None
     _compaction_summary: str
+    _session_msg_cache: list[Any] | None
     _app: PureTui | None
     _usage_stats: UsageStats
     _compaction: CompactionService
@@ -64,7 +65,6 @@ class GraphComponentHost(Protocol):
     _slash: Any
 
     _any_messages_sent: bool
-    _current_implementation_allowed: bool
     _needs_failure_check: dict[str, dict]
 
     @property
@@ -85,7 +85,7 @@ class GraphComponentHost(Protocol):
     async def _maybe_compact(
         self,
         messages: list[BaseMessage],
-        session_msgs: list[Any],
+        session_msgs: list[Any] | None = None,
         *,
         force: bool = False,
         ask: bool = True,

{voidx-1.1.0 → voidx-2.0.0}/src/voidx/agent/graph/core.py

@@ -37,6 +37,7 @@ from voidx.agent.state import AgentState
 from voidx.agent.graph.streaming import stream_llm as _stream_llm
 from voidx.agent.graph.subagent import run_subagent as _run_subagent
 from voidx.agent.graph.tool_execution import GraphToolExecutionMixin
+from voidx.agent.intent_refinement import refine_intent
 from voidx.agent.runtime_context import InteractionMode, RuntimeContextBuilder
 from voidx.agent.task_state import TaskRun, TaskState
 from voidx.agent.tool_filters import filter_unavailable_lsp_tools
@@ -51,11 +52,11 @@ from voidx.llm.usage import (
     extract_token_usage,
 )
 from voidx.memory.context_frames import save_context_frame_from_messages
-from voidx.memory.session import SessionInfo
-from voidx.agent.slash import SlashHandler
+from voidx.memory.session import MessageRow, SessionInfo
 from voidx.permission.service import PermissionService
 from voidx.tools.registry import ToolRegistry
 from voidx.tools.agent import AgentTool
+from voidx.tools.on_intent import OnIntentInput, OnIntentTool
 from voidx.tools.task_tracker import TaskTracker
 from voidx.ui.output.console import StreamingRenderer
 from voidx.ui.output.dock import dock
@@ -109,6 +110,8 @@ class VoidXGraph(
         # Build tool registry, wire tracker through registry
         self._tracker = TaskTracker()
         self.tools = ToolRegistry(settings=settings, tracker=self._tracker)
+        intent_tool = OnIntentTool(resolver=self._resolve_on_intent)
+        self.tools.register("on_intent", intent_tool, intent_tool.description, intent_tool.parameters_schema())
         agent_tool = AgentTool(runner=self._subagent_runner)
         self.tools.register("agent", agent_tool, agent_tool.description, agent_tool.parameters_schema())
 
@@ -137,6 +140,7 @@ class VoidXGraph(
         # One-turn summary injection vs. persisted summary restored across turns.
         self._pending_summary: str | None = None
         self._compaction_summary: str = ""
+        self._session_msg_cache: list[MessageRow] | None = None
         self._app: PureTui | None = None
         self._next_agent_id: int = 0
         self._task_state = TaskState()
@@ -153,6 +157,8 @@ class VoidXGraph(
         )
 
         self._build()
+        from voidx.agent.slash import SlashHandler
+
         self._slash = SlashHandler(self)
 
         # MCP (Model Context Protocol) servers — start on run()
@@ -187,6 +193,15 @@ class VoidXGraph(
     def interaction_mode(self) -> InteractionMode:
         return self._interaction_mode
 
+    def _resolve_on_intent(self, inp: OnIntentInput, ctx):
+        return refine_intent(
+            inp,
+            ctx,
+            config=self.config,
+            settings=self._settings,
+            registered_tool_ids=self.tools.ids(),
+        )
+
     async def _subagent_runner(self, agent_def: AgentDef, description: str, model_override: str | None) -> str:
         parent_messages = getattr(self, '_current_messages', None)
         sub_buffer: list[BaseMessage] = []
@@ -297,6 +312,8 @@ class VoidXGraph(
             agent=agent_name,
             task_intent=state.get("task_intent"),
             interaction_mode=interaction_mode,
+            scope=_pending_approval_scope(state.get("pending_approval")) or state.get("goal") or latest_user_text,
+            turn_count=state.get("goal_turn_count", 0),
         )
         mode_prompt = PLAN_MODE_APPEND if InteractionMode.parse(interaction_mode) == InteractionMode.PLAN else ""
         summary = self._pending_summary or self._compaction_summary
@@ -313,22 +330,25 @@ class VoidXGraph(
             interaction_mode=interaction_mode,
             instructions=instructions,
             skill_instructions=skill_context.instructions,
+            skill_runs=skill_context.runs,
             active_skill_summaries=skill_context.active,
             summary=summary,
             current_user_text=latest_user_text,
             task_intent=state.get("task_intent"),
-            implementation_allowed=state.get("implementation_allowed"),
             intent_resolution_reason=state.get("intent_resolution_reason", ""),
-            awaiting_implementation_approval=state.get("awaiting_implementation_approval", False),
-            approved_scope=state.get("approved_scope", ""),
+            pending_approval=state.get("pending_approval"),
             goal=state.get("goal", ""),
             goal_phase=state.get("goal_phase", ""),
             goal_status=state.get("goal_status", ""),
             goal_turn_count=state.get("goal_turn_count", 0),
+            available_tool_ids=state.get("available_tool_ids", []),
+            intent_confidence=state.get("intent_confidence"),
+            intent_source=state.get("intent_source", ""),
+            intent_refined=state.get("intent_refined", False),
         ).build()
         context.apply_to_messages(state.get("messages", []))
 
-        return base
+        return {**base, "skill_runs": skill_context.runs}
 
     async def _call_llm(self, state: AgentState) -> dict:
         step = state.get("step_count", 0)
@@ -354,6 +374,9 @@ class VoidXGraph(
             tool_defs = [t for t in all_tool_defs if t["function"]["name"] in agent_tool_ids]
         else:
             tool_defs = all_tool_defs
+        if "available_tool_ids" in state:
+            visible = set(state.get("available_tool_ids") or [])
+            tool_defs = [t for t in tool_defs if t["function"]["name"] in visible]
         tool_defs = filter_unavailable_lsp_tools(tool_defs, getattr(self, "_lsp_manager", None))
 
         has_tool_budget = step < max_s - 1
@@ -447,3 +470,11 @@ def _latest_user_text(messages: list[BaseMessage]) -> str:
                 return "\n".join(parts)
             return str(content)
     return ""
+
+
+def _pending_approval_scope(value: object | None) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, dict):
+        return str(value.get("scope") or "").strip()
+    return str(getattr(value, "scope", "") or "").strip()

{voidx-1.1.0 → voidx-2.0.0}/src/voidx/agent/graph/run_loop.py

@@ -16,8 +16,9 @@ from voidx.agent.attachments import (
 )
 from voidx.agent.graph.runtime import ui
 from voidx.agent.message_rows import messages_from_rows
+from voidx.agent.runtime_context import TaskIntent
 from voidx.agent.state import AgentState
-from voidx.agent.task_state import resolve_turn_intent
+from voidx.agent.task_state import IntentResolution, PendingApproval, resolve_turn_intent
 from voidx.llm.provider import get_context_limit
 from voidx.memory.session import (
     MessageRow,
@@ -179,7 +180,7 @@ class GraphRunLoopMixin:
                 goal_phase=lambda: getattr(getattr(getattr(self, "_task_run", None), "phase", None), "value", "clarify"),
                 goal_status=lambda: getattr(getattr(getattr(self, "_task_run", None), "status", None), "value", "idle"),
                 goal_turn_count=lambda: getattr(getattr(self, "_task_run", None), "turn_count", 0),
-                goal_awaiting_approval=lambda: getattr(getattr(self, "_task_run", None), "awaiting_implementation_approval", False),
+                goal_awaiting_approval=lambda: bool(getattr(getattr(self, "_task_run", None), "pending_approval", None)),
                 mcp_servers=lambda: [
                     McpServerStatus(
                         name=s.name,
@@ -228,6 +229,11 @@ class GraphRunLoopMixin:
                 dock.append_message("\n".join(lsp_lines), markup=True)
 
         if hasattr(self, '_mcp_manager'):
+            servers = self._settings.list_mcp_servers() if self._settings else []
+            enabled = [s for s in servers if not s.disabled]
+            if enabled:
+                names = ", ".join(s.name for s in enabled)
+                dock.append_message(f"[dim]MCP connecting: {names}…[/dim]", markup=True)
             await self._mcp_manager.start_all()
 
         async def handle_user_input(user_input: str) -> bool:
@@ -310,7 +316,13 @@ class GraphRunLoopMixin:
                 ))
             else:
                 self._turn_node = dock.start_turn(payload.display_text)
-            session_msgs = await load_messages(self._session.id) if self._session else []
+            # Load session messages — use in-memory cache when available
+            if self._session_msg_cache is not None:
+                session_msgs = list(self._session_msg_cache)
+            else:
+                session_msgs = (await load_messages(self._session.id)) if self._session else []
+                if self._session:
+                    self._session_msg_cache = list(session_msgs)
             truncation_notice: str | None = None
             # Safety: if session is huge, only load recent messages
             if len(session_msgs) > 500:
@@ -349,13 +361,16 @@ class GraphRunLoopMixin:
                 getattr(self, "_task_state", None),
             )
             task_intent = intent_resolution.intent
-            implementation_allowed = intent_resolution.implementation_allowed
-            self._current_implementation_allowed = implementation_allowed
             goal_scope = (
                 task_run.goal
                 if interaction_mode == "goal" and task_run is not None and task_run.goal
                 else payload.title_text
             )
+            pending_approval = _active_pending_approval(
+                getattr(self, "_task_state", None),
+                task_run,
+                interaction_mode,
+            )
 
             saved_user_content, user_content_format = serialize_message_content(payload.content)
             user_message_id = await save_message(MessageRow(
@@ -365,6 +380,15 @@ class GraphRunLoopMixin:
                 content_format=user_content_format,
                 created_at=_now(),
             ))
+            if self._session_msg_cache is not None:
+                self._session_msg_cache.append(MessageRow(
+                    id=user_message_id,
+                    session_id=self._session.id,
+                    role="user",
+                    content=saved_user_content,
+                    content_format=user_content_format,
+                    created_at=_now(),
+                ))
             self._any_messages_sent = True
 
             initial: AgentState = {
@@ -378,10 +402,8 @@ class GraphRunLoopMixin:
                 "plan_mode": self._plan_mode,
                 "interaction_mode": interaction_mode,
                 "task_intent": task_intent.value,
-                "implementation_allowed": implementation_allowed,
                 "intent_resolution_reason": intent_resolution.reason,
-                "awaiting_implementation_approval": intent_resolution.awaiting_implementation_approval,
-                "approved_scope": intent_resolution.approved_scope,
+                "pending_approval": _dump_pending_approval(pending_approval),
                 "goal": task_run.goal if task_run is not None else "",
                 "goal_phase": task_run.phase.value if task_run is not None else "",
                 "goal_status": task_run.status.value if task_run is not None else "",
@@ -402,43 +424,51 @@ class GraphRunLoopMixin:
                 await ui_events.emit(StatusFinished(status_id="turn:analyzing"))
 
             final = await self.graph.ainvoke(initial, {"recursion_limit": self.config.agent.recursion_limit})
+            final_task_intent = TaskIntent(final.get("task_intent", task_intent.value))
+            final_intent_resolution_reason = final.get(
+                "intent_resolution_reason",
+                intent_resolution.reason,
+            )
+            final_pending_approval = _load_pending_approval(final.get("pending_approval"))
+            final_scope = final_pending_approval.scope if final_pending_approval else goal_scope
+            final_resolution = IntentResolution(
+                intent=final_task_intent,
+                reason=final_intent_resolution_reason,
+                confirmed_approval=intent_resolution.confirmed_approval,
+            )
             if self.model is not None and hasattr(self, "_task_state"):
                 self._task_state.update_after_turn(
-                    intent_resolution,
+                    final_resolution,
                     payload.title_text,
-                    scope_text=goal_scope,
+                    scope_text=final_scope,
                 )
             if self.model is not None and interaction_mode == "goal" and task_run is not None:
                 task_run.update_after_turn(
-                    intent_resolution,
+                    final_resolution,
                     payload.title_text,
-                    scope_text=goal_scope,
+                    scope_text=final_scope,
                 )
+            if self.model is not None and task_run is not None:
+                task_run.merge_skill_runs(final.get("skill_runs", []))
             await save_message_runtime_snapshot(MessageRuntimeSnapshot(
                 message_id=user_message_id,
                 session_id=self._session.id,
                 interaction_mode=interaction_mode,
-                task_intent=task_intent,
-                implementation_allowed=implementation_allowed,
-                intent_resolution_reason=intent_resolution.reason,
+                task_intent=final_task_intent,
+                intent_resolution_reason=final_intent_resolution_reason,
                 goal=task_run.goal if task_run is not None else "",
                 goal_phase=task_run.phase.value if task_run is not None else "",
                 goal_status=task_run.status.value if task_run is not None else "",
                 goal_turn_count=task_run.turn_count if task_run is not None else 0,
-                awaiting_implementation_approval=(
-                    task_run.awaiting_implementation_approval
-                    if interaction_mode == "goal" and task_run is not None
-                    else getattr(
-                        getattr(self, "_task_state", None),
-                        "awaiting_implementation_approval",
-                        False,
-                    )
-                ),
-                approved_scope=(
-                    task_run.approved_scope
-                    if interaction_mode == "goal" and task_run is not None
-                    else getattr(getattr(self, "_task_state", None), "approved_scope", "")
+                pending_approval=_active_pending_approval(
+                    getattr(self, "_task_state", None),
+                    task_run,
+                    interaction_mode,
                 ),
+                intent_confidence=final.get("intent_confidence"),
+                intent_source=final.get("intent_source", ""),
+                intent_refined=bool(final.get("intent_refined", False)),
+                available_tool_ids=list(final.get("available_tool_ids", []) or []),
             ))
             await self._persist_runtime_state()
 
@@ -469,7 +499,7 @@ class GraphRunLoopMixin:
                         else:
                             saved = str(raw_content)
                             fmt = "text"
-                        await save_message(MessageRow(
+                        row_id = await save_message(MessageRow(
                             session_id=self._session.id,
                             role="assistant",
                             content=saved,
@@ -477,14 +507,33 @@ class GraphRunLoopMixin:
                             tool_calls=msg.tool_calls if msg.tool_calls else None,
                             created_at=_now(),
                         ))
+                        if self._session_msg_cache is not None:
+                            self._session_msg_cache.append(MessageRow(
+                                id=row_id,
+                                session_id=self._session.id,
+                                role="assistant",
+                                content=saved,
+                                content_format=fmt,
+                                tool_calls=msg.tool_calls if msg.tool_calls else None,
+                                created_at=_now(),
+                            ))
                     elif isinstance(msg, ToolMessage):
-                        await save_message(MessageRow(
+                        row_id = await save_message(MessageRow(
                             session_id=self._session.id,
                             role="tool",
                             content=str(msg.content),
                             tool_call_id=getattr(msg, "tool_call_id", None),
                             created_at=_now(),
                         ))
+                        if self._session_msg_cache is not None:
+                            self._session_msg_cache.append(MessageRow(
+                                id=row_id,
+                                session_id=self._session.id,
+                                role="tool",
+                                content=str(msg.content),
+                                tool_call_id=getattr(msg, "tool_call_id", None),
+                                created_at=_now(),
+                            ))
                 await touch_session(self._session.id)
 
                 # Auto-title on first message
@@ -517,6 +566,11 @@ class GraphRunLoopMixin:
         except (KeyboardInterrupt, asyncio.CancelledError):
             if self._session is not None and user_message_id is not None:
                 await delete_messages_from(self._session.id, user_message_id)
+                if self._session_msg_cache is not None:
+                    self._session_msg_cache = [
+                        r for r in self._session_msg_cache
+                        if r.id is None or r.id < user_message_id
+                    ]
             raise
         finally:
             session_tracker.finish_turn()
@@ -528,7 +582,6 @@ class GraphRunLoopMixin:
                 await ui_events.drain()
             else:
                 dock.set_input("", [])
-            self._current_implementation_allowed = True
 
     async def _dispatch_slash(self: GraphRunLoopHost, inp: str) -> bool:
         """Try to dispatch a slash command. Returns True if handled."""
@@ -594,3 +647,27 @@ class GraphRunLoopMixin:
             return False
         active_dock.restore_tree(transcript_rows_to_tree(rows), append=append)
         return True
+
+
+def _active_pending_approval(task_state, task_run, interaction_mode: str) -> PendingApproval | None:
+    if interaction_mode == "goal" and task_run is not None:
+        return getattr(task_run, "pending_approval", None)
+    if task_state is not None:
+        return getattr(task_state, "pending_approval", None)
+    return None
+
+
+def _dump_pending_approval(value: PendingApproval | dict | None) -> dict | None:
+    if value is None:
+        return None
+    if isinstance(value, dict):
+        return value
+    return value.model_dump(mode="json")
+
+
+def _load_pending_approval(value: PendingApproval | dict | None) -> PendingApproval | None:
+    if value is None:
+        return None
+    if isinstance(value, PendingApproval):
+        return value
+    return PendingApproval.model_validate(value)