abstractcode 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

abstractcode/react_shell.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import json
 import os
+import re
 import sys
 import threading
 import time
@@ -12,8 +13,16 @@ from typing import Any, Callable, Dict, List, Optional, Sequence, Tuple
 from prompt_toolkit.formatted_text import HTML
 
 from .input_handler import create_prompt_session, create_simple_session
-from .fullscreen_ui import FullScreenUI
+from .file_mentions import (
+    default_workspace_mounts,
+    default_workspace_root,
+    find_at_file_mentions,
+    normalize_relative_path,
+    resolve_workspace_path,
+)
+from .fullscreen_ui import BLOCKING_PROMPT_CANCEL_TOKEN, FullScreenUI, SubmittedInput
 from .terminal_markdown import TerminalMarkdownRenderer
+from .theme import BUILTIN_THEMES, Theme, ansi_bg, ansi_fg, blend_hex, get_theme, is_dark, theme_from_env
 
 
 def _supports_color() -> bool:
@@ -61,6 +70,15 @@ class _ToolSpec:
     parameters: Dict[str, Any]
 
 
+@dataclass(frozen=True)
+class _BundledAgentTemplate:
+    bundle_id: str
+    bundle_version: str
+    flow_id: str
+    name: str
+    description: str
+
+
 def _now_iso() -> str:
     from datetime import datetime, timezone
 
@@ -185,6 +203,27 @@ class ReactShell:
             self._max_tokens = None
         # Enable ANSI colors - fullscreen_ui uses ANSI class to parse escape codes
         self._color = bool(color and _supports_color())
+        self._theme: Theme = theme_from_env().normalized()
+        # Optional user-defined system prompt override (applies to new runs; can be set via /system).
+        self._system_prompt_override: Optional[str] = None
+        # ReAct runtime heuristics (configurable).
+        # - check_plan: retry if output claims it will act but emits no tool calls (default OFF).
+        self._check_plan: bool = False
+        # Attachment persistence:
+        # - when OFF (default), `@file` chips are consumed for the next user message only.
+        # - when ON, attachment chips persist across turns until removed.
+        self._files_keep: bool = False
+        # Host/Gateway GPU meter (optional).
+        self._gpu_monitor_enabled: bool = self._gpu_monitor_enabled_from_env()
+        self._gpu_utilization_pct: Optional[float] = None
+        self._gpu_last_error: Optional[str] = None
+        self._gpu_last_ok_at: Optional[float] = None
+        self._gpu_monitor_thread: Optional[threading.Thread] = None
+        self._gpu_monitor_lock = threading.Lock()
+        # Bundled `.flow` agent templates (for TUI selector).
+        self._bundled_agent_templates: List[_BundledAgentTemplate] = []
+        # Current agent selector key (shown in the footer dropdown).
+        self._agent_selector_key: str = agent_lower if agent_lower in ("react", "codeact", "memact") else raw_agent
         # Session-level tool allowlist (None = default/all tools for the agent kind).
         self._allowed_tools: Optional[List[str]] = None
         # Whether to include tool usage examples in the prompted tool section (token-expensive).
@@ -213,11 +252,14 @@ class ReactShell:
             from abstractagent.agents.react import ReactAgent
             from abstractagent.tools import execute_python, self_improve
             from abstractcore.tools import ToolDefinition
+            from abstractcore.tools.abstractignore import AbstractIgnore
             from abstractcore.tools.common_tools import (
                 list_files,
+                skim_folders,
                 search_files,
                 analyze_code,
                 read_file,
+                skim_files,
                 write_file,
                 edit_file,
                 execute_command,
@@ -247,13 +289,16 @@ class ReactShell:
         self._Snapshot = Snapshot
         self._JsonSnapshotStore = JsonSnapshotStore
         self._InMemorySnapshotStore = InMemorySnapshotStore
+        self._AbstractIgnore = AbstractIgnore
 
         # Default tools for AbstractCode (curated subset for coding tasks)
         DEFAULT_TOOLS = [
             list_files,
+            skim_folders,
             search_files,
             analyze_code,
             read_file,
+            skim_files,
             write_file,
             edit_file,
             execute_command,
@@ -261,19 +306,27 @@ class ReactShell:
             fetch_url,
             self_improve,
         ]
+        # Keep references so we can rebuild agents/toolsets at runtime (e.g. /agent switch).
+        self._default_tools = list(DEFAULT_TOOLS)
+        self._codeact_tools = [execute_python]
+        self._agent_classes = {
+            "react": ReactAgent,
+            "memact": MemActAgent,
+            "codeact": CodeActAgent,
+        }
 
         if self._workflow_agent_ref is not None:
             # Workflow agents use the "safe" default toolset (same as ReAct).
-            self._tools = list(DEFAULT_TOOLS)
+            self._tools = list(self._default_tools)
             agent_cls = None
         elif self._agent_kind == "react":
-            self._tools = list(DEFAULT_TOOLS)
+            self._tools = list(self._default_tools)
             agent_cls = ReactAgent
         elif self._agent_kind == "memact":
-            self._tools = list(DEFAULT_TOOLS)
+            self._tools = list(self._default_tools)
             agent_cls = MemActAgent
         else:
-            self._tools = [execute_python]
+            self._tools = list(self._codeact_tools)
             agent_cls = CodeActAgent
 
         self._tool_specs: Dict[str, _ToolSpec] = {}
@@ -306,6 +359,9 @@ class ReactShell:
         if self._state_file:
             self._config_file = Path(self._state_file).with_suffix(".config.json")
             self._load_config()
+        # Best-effort: discover bundled `.flow` agents for the footer selector.
+        self._refresh_bundled_agent_templates()
+        self._agent_selector_key = self._normalize_agent_selector_key(getattr(self, "_agent_selector_key", "") or "")
 
         # Tool execution: passthrough by default so we can gate by approval in the CLI.
         tool_executor = PassthroughToolExecutor(mode="approval_required")
@@ -322,6 +378,74 @@ class ReactShell:
             llm_kwargs=llm_kwargs or None,
         )
 
+        # Artifact storage is the durability-safe place for large payloads (including attachments).
+        #
+        # Important: create the ArtifactStore BEFORE wiring the Runtime so effect handlers
+        # (LLM_CALL media resolution) and host-side ingestion use the same store instance.
+        if self._store_dir is not None:
+            self._artifact_store = FileArtifactStore(self._store_dir)
+        else:
+            self._artifact_store = InMemoryArtifactStore()
+
+        # Best-effort: enable AbstractMemory KG effects for workflow agents and memory-enabled flows.
+        #
+        # Without these handlers, VisualFlow nodes like `memory_kg_query` fail at runtime with:
+        # "No effect handler registered for memory_kg_query".
+        extra_effect_handlers: Optional[Dict[Any, Any]] = None
+        try:
+            from abstractmemory import InMemoryTripleStore, LanceDBTripleStore  # type: ignore
+            from abstractmemory.embeddings import AbstractGatewayTextEmbedder  # type: ignore
+            from abstractruntime.core.runtime import utc_now_iso
+            from abstractruntime.integrations.abstractmemory.effect_handlers import build_memory_kg_effect_handlers
+
+            from .gateway_cli import default_gateway_token, default_gateway_url
+        except Exception:
+            extra_effect_handlers = None
+        else:
+            base_dir: Optional[Path] = None
+            mem_dir_raw = (
+                os.getenv("ABSTRACTCODE_MEMORY_DIR")
+                or os.getenv("ABSTRACTMEMORY_DIR")
+                or os.getenv("ABSTRACTFLOW_MEMORY_DIR")
+            )
+            if isinstance(mem_dir_raw, str) and mem_dir_raw.strip():
+                try:
+                    base_dir = Path(mem_dir_raw).expanduser().resolve()
+                except Exception:
+                    base_dir = None
+            if base_dir is None and self._store_dir is not None:
+                base_dir = self._store_dir / "abstractmemory"
+
+            embedder = None
+            embed_provider = (
+                os.getenv("ABSTRACTCODE_EMBEDDING_PROVIDER")
+                or os.getenv("ABSTRACTMEMORY_EMBEDDING_PROVIDER")
+                or os.getenv("ABSTRACTFLOW_EMBEDDING_PROVIDER")
+                or os.getenv("ABSTRACTGATEWAY_EMBEDDING_PROVIDER")
+            )
+            if str(embed_provider or "").strip().lower() not in {"__disabled__", "disabled", "none", "off"}:
+                try:
+                    gateway_url = str(default_gateway_url() or "").strip()
+                    auth_token = default_gateway_token()
+                    if gateway_url:
+                        embedder = AbstractGatewayTextEmbedder(base_url=gateway_url, auth_token=auth_token)
+                except Exception:
+                    embedder = None
+
+            try:
+                if base_dir is None:
+                    store_obj = InMemoryTripleStore(embedder=embedder)
+                else:
+                    base_dir.mkdir(parents=True, exist_ok=True)
+                    store_obj = LanceDBTripleStore(base_dir / "kg", embedder=embedder)
+                extra_effect_handlers = build_memory_kg_effect_handlers(
+                    store=store_obj,
+                    run_store=run_store,
+                    now_iso=utc_now_iso,
+                )
+            except Exception:
+                extra_effect_handlers = None
+
         self._runtime = create_local_runtime(
             provider=self._provider,
             model=self._model,
@@ -329,14 +453,27 @@ class ReactShell:
             run_store=run_store,
             ledger_store=ledger_store,
             tool_executor=tool_executor,
+            artifact_store=self._artifact_store,
+            extra_effect_handlers=extra_effect_handlers,
         )
-        # Artifact storage is the durability-safe place for large payloads (including archived memory spans).
-        if self._store_dir is not None:
-            self._artifact_store = FileArtifactStore(self._store_dir)
-        else:
-            self._artifact_store = InMemoryArtifactStore()
         self._runtime.set_artifact_store(self._artifact_store)
 
+        # Workspace root for `@file` mentions / attachments.
+        self._workspace_root: Path = default_workspace_root()
+        self._workspace_mounts: Dict[str, Path] = default_workspace_mounts()
+        self._workspace_mount_ignores: Dict[str, Any] = {}
+        self._workspace_blocked_paths: List[Path] = []
+        try:
+            self._workspace_ignore = self._AbstractIgnore.for_path(self._workspace_root)
+            for name, root in dict(self._workspace_mounts).items():
+                try:
+                    self._workspace_mount_ignores[name] = self._AbstractIgnore.for_path(root)
+                except Exception:
+                    self._workspace_mount_ignores[name] = None
+        except Exception:
+            self._workspace_ignore = None
+            self._workspace_mount_ignores = {}
+
         if self._workflow_agent_ref is not None:
             try:
                 from .workflow_agent import WorkflowAgent
@@ -374,20 +511,50 @@ class ReactShell:
             get_status_text=self._get_status_text,
             on_input=self._handle_input,
             on_copy_payload=self._copy_to_clipboard,
+            on_cancel=self._handle_ui_cancel,
             color=self._color,
+            theme=self._theme,
         )
+        # Keep `@file` chips behavior consistent with the saved preference.
+        try:
+            setter = getattr(self._ui, "set_files_keep", None)
+            if callable(setter):
+                setter(bool(getattr(self, "_files_keep", False)))
+        except Exception:
+            pass
+        # Populate the footer agent selector (best-effort).
+        self._sync_agent_selector_to_ui()
+        # Keep `@file` completion consistent with the shell's workspace policy.
+        try:
+            setter = getattr(self._ui, "set_workspace_policy", None)
+            if callable(setter):
+                setter(
+                    workspace_root=self._workspace_root,
+                    mounts=dict(self._workspace_mounts),
+                    blocked_paths=list(self._workspace_blocked_paths),
+                )
+        except Exception:
+            pass
 
         # Keep simple session for tool approvals (runs within full-screen)
         self._simple_session = create_simple_session(color=self._color)
 
         # Pending input for the run loop
         self._pending_input: Optional[str] = None
+        # Async run-loop interrupts (set by UI thread, consumed by run thread).
+        self._pending_conclude_note: Optional[str] = None
+        self._pending_conclude_lock = threading.Lock()
 
         # Per-turn observability (for copy + traceability)
         self._turn_task: Optional[str] = None
         self._turn_trace: List[str] = []
         # Turn-level timing (for per-answer stats).
         self._turn_started_at: Optional[float] = None
+        # Session-level attachment refs (workspace-relative path -> artifact-backed ref dict).
+        # Avoids re-ingesting the same file every turn when attachments persist.
+        self._attachment_ref_cache: Dict[str, Dict[str, Any]] = {}
+        # Attachment file signatures (path -> (size_bytes, mtime_ns)) used to detect file changes.
+        self._attachment_sig_cache: Dict[str, Tuple[int, int]] = {}
         # Simple in-session dedup for obviously repeated shell commands.
         self._last_execute_command: Optional[str] = None
         self._last_execute_command_result: Optional[Dict[str, Any]] = None
@@ -398,7 +565,9 @@ class ReactShell:
         self._pending_tool_markers: List[str] = []
         # Pending tool call metadata (aligned with tool markers/results).
         self._pending_tool_metas: List[Dict[str, Any]] = []
-        # Keep the last started run id so /log can show traces even after completion.
+        # Links extracted from the most recent assistant answer (for /links, /open).
+        self._last_answer_links: List[str] = []
+        # Keep the last started run id so /logs can show traces even after completion.
         self._last_run_id: Optional[str] = None
         # Status bar cache (token counting can be expensive; avoid per-frame rescans).
         self._status_cache_key: Optional[Tuple[Any, ...]] = None
@@ -426,6 +595,21 @@ class ReactShell:
     # UI helpers
     # ---------------------------------------------------------------------
 
+    def _handle_ui_cancel(self) -> None:
+        """Handle an Esc cancel request coming from the full-screen UI."""
+        run_id = self._attached_run_id()
+        if run_id is None:
+            return
+        try:
+            state = self._runtime.get_state(run_id)
+        except Exception:
+            state = None
+
+        status = getattr(state, "status", None) if state is not None else None
+        if status not in (self._RunStatus.RUNNING, self._RunStatus.WAITING):
+            return
+        self._cancel()
+
     def _safe_get_state(self):
         """Safely get agent state, returning None if unavailable.
 
@@ -445,6 +629,13 @@ class ReactShell:
             # Run doesn't exist (completed/cleaned up) or other error
             return None
 
+    def _safe_get_active_state(self):
+        """Safely get only the *active* run state (no last-run fallback)."""
+        try:
+            return self._agent.get_state()
+        except (KeyError, Exception):
+            return None
+
     def _select_messages_for_llm(self, state: Any) -> List[Dict[str, Any]]:
         """Return the best-effort LLM-visible message view for a state."""
         if state is None or not hasattr(state, "vars") or not isinstance(getattr(state, "vars", None), dict):
@@ -504,6 +695,9 @@ class ReactShell:
         state: Any,
         messages: List[Dict[str, Any]],
         effective_model: Optional[str] = None,
+        task_text: Optional[str] = None,
+        extra_messages: Optional[List[Dict[str, Any]]] = None,
+        tool_specs: Optional[List[Dict[str, Any]]] = None,
     ) -> Dict[str, Any]:
         """Estimate the next prompt token usage (best effort).
 
@@ -532,23 +726,27 @@ class ReactShell:
         system_text = ""
         prompt_text = ""
 
-        logic = getattr(self._agent, "logic", None)
-        if (
-            state is not None
-            and logic is not None
-            and hasattr(state, "vars")
-            and isinstance(getattr(state, "vars", None), dict)
-        ):
-            context_ns = state.vars.get("context") if isinstance(state.vars.get("context"), dict) else {}
-            task = str(context_ns.get("task") or "")
-            limits = state.vars.get("_limits") if isinstance(state.vars.get("_limits"), dict) else {}
-            try:
-                iteration = int(limits.get("current_iteration", 0) or 0) + 1
-                max_iterations = int(limits.get("max_iterations", 25) or 25)
-            except Exception:
-                iteration = 1
-                max_iterations = 25
+        vars_ns: Dict[str, Any] = {}
+        if state is not None and hasattr(state, "vars") and isinstance(getattr(state, "vars", None), dict):
+            vars_ns = state.vars
+
+        context_ns = vars_ns.get("context") if isinstance(vars_ns.get("context"), dict) else {}
+        task = str(task_text or context_ns.get("task") or "")
 
+        limits = vars_ns.get("_limits") if isinstance(vars_ns.get("_limits"), dict) else {}
+        try:
+            iteration = int(limits.get("current_iteration", 0) or 0) + 1
+            max_iterations = int(limits.get("max_iterations", self._max_iterations) or self._max_iterations)
+        except Exception:
+            iteration = 1
+            max_iterations = int(self._max_iterations)
+        if max_iterations < 1:
+            max_iterations = 25
+
+        logic = getattr(self._agent, "logic", None)
+        sys_base = ""
+        req_tools = None
+        if logic is not None:
             try:
                 req = logic.build_request(
                     task=task,
@@ -556,27 +754,52 @@ class ReactShell:
                     guidance="",
                     iteration=iteration,
                     max_iterations=max_iterations,
-                    vars=state.vars,
+                    vars=vars_ns,
                 )
-                system_text = str(getattr(req, "system_prompt", "") or "").strip()
+                sys_base = str(getattr(req, "system_prompt", "") or "").strip()
                 prompt_text = str(getattr(req, "prompt", "") or "").strip()
+                req_tools = getattr(req, "tools", None)
             except Exception:
-                system_text = ""
-                prompt_text = ""
+                sys_base = ""
+                prompt_text = task.strip()
+                req_tools = None
+
+        # Apply optional runtime/system prompt overrides.
+        runtime_ns = vars_ns.get("_runtime") if isinstance(vars_ns.get("_runtime"), dict) else {}
+        runtime_override = runtime_ns.get("system_prompt") if isinstance(runtime_ns, dict) else None
+        extra = runtime_ns.get("system_prompt_extra") if isinstance(runtime_ns, dict) else None
+
+        session_override = getattr(self, "_system_prompt_override", None)
+        if isinstance(runtime_override, str) and runtime_override.strip():
+            base_sys = runtime_override.strip()
+        elif isinstance(session_override, str) and session_override.strip():
+            base_sys = session_override.strip()
+        else:
+            base_sys = sys_base
 
-            if self._agent_kind == "memact":
-                try:
-                    from abstractruntime.memory.active_memory import render_memact_system_prompt
+        system_text = base_sys
 
-                    mem_prompt = render_memact_system_prompt(state.vars)
-                    if isinstance(mem_prompt, str) and mem_prompt.strip():
-                        system_text = (mem_prompt.strip() + ("\n\n" + system_text if system_text else "")).strip()
-                except Exception:
-                    pass
+        if self._agent_kind == "memact" and state is not None and isinstance(vars_ns, dict):
+            try:
+                from abstractruntime.memory.active_memory import render_memact_system_prompt
+
+                mem_prompt = render_memact_system_prompt(vars_ns)
+                if isinstance(mem_prompt, str) and mem_prompt.strip():
+                    system_text = (mem_prompt.strip() + ("\n\n" + base_sys if base_sys else "")).strip()
+            except Exception:
+                pass
+
+        if isinstance(extra, str) and extra.strip():
+            system_text = (system_text.rstrip() + "\n\nAdditional system instructions:\n" + extra.strip()).strip()
 
         # Approximate messages by concatenating content with role labels.
+        merged_messages: List[Dict[str, Any]] = []
+        if isinstance(extra_messages, list) and extra_messages:
+            merged_messages.extend([m for m in extra_messages if isinstance(m, dict)])
+        merged_messages.extend(list(messages or []))
+
         text_parts: List[str] = []
-        for m in messages:
+        for m in merged_messages:
             if not isinstance(m, dict):
                 continue
             content = str(m.get("content") or "")
@@ -591,6 +814,27 @@ class ReactShell:
         messages_tokens = estimate_tokens(joined) if joined else 0
         system_tokens = estimate_tokens(system_text) if system_text else 0
         prompt_tokens = estimate_tokens(prompt_text) if prompt_text else 0
+        tools_tokens = 0
+        if tool_specs is None and isinstance(req_tools, list):
+            # Best-effort: convert ToolDefinition objects to dicts so we can estimate token cost.
+            tool_specs0: List[Dict[str, Any]] = []
+            for t in req_tools:
+                to_dict = getattr(t, "to_dict", None)
+                if callable(to_dict):
+                    try:
+                        spec = to_dict()
+                    except Exception:
+                        spec = None
+                    if isinstance(spec, dict):
+                        tool_specs0.append(spec)
+            tool_specs = tool_specs0
+
+        if isinstance(tool_specs, list) and tool_specs:
+            try:
+                raw = json.dumps(tool_specs, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+                tools_tokens = estimate_tokens(raw)
+            except Exception:
+                tools_tokens = 0
 
         return {
             "effective_model": effective_model,
@@ -598,19 +842,52 @@ class ReactShell:
             "system_tokens": system_tokens,
             "prompt_tokens": prompt_tokens,
             "messages_tokens": messages_tokens,
-            "tools_tokens": 0,
-            "total_tokens": int(system_tokens) + int(prompt_tokens) + int(messages_tokens),
+            "tools_tokens": tools_tokens,
+            "total_tokens": int(system_tokens) + int(prompt_tokens) + int(messages_tokens) + int(tools_tokens),
         }
 
     def _get_status_text(self) -> str:
         """Generate status text for the status bar."""
         # Keep this fast: the render thread can call this frequently.
-        state = self._safe_get_state()
+        state = self._safe_get_active_state()
 
         effective_model = self._get_effective_model(state)
         messages = self._select_messages_for_llm(state)
         max_tokens = self._resolve_context_max_tokens(state, effective_model=effective_model)
 
+        # Include pending inputs (draft prompt + attachments) in status estimate.
+        draft_text = ""
+        pending_attachments: List[str] = []
+        try:
+            ui = getattr(self, "_ui", None)
+            getter = getattr(ui, "get_composer_state", None) if ui is not None else None
+            if callable(getter):
+                st = getter()
+                if isinstance(st, dict):
+                    draft_text = str(st.get("draft") or "")
+                    raw_att = st.get("attachments")
+                    if isinstance(raw_att, list):
+                        pending_attachments = [str(p).strip() for p in raw_att if isinstance(p, str) and str(p).strip()]
+        except Exception:
+            draft_text = ""
+            pending_attachments = []
+
+        draft_for_tokens = draft_text.strip()
+        if draft_for_tokens.startswith("/"):
+            draft_for_tokens = ""
+
+        sys_override = getattr(self, "_system_prompt_override", None)
+        sys_override_s = str(sys_override or "").strip() if isinstance(sys_override, str) or sys_override is not None else ""
+
+        def _text_sig(s: str) -> tuple[int, str, str]:
+            t = str(s or "")
+            if len(t) <= 96:
+                return (len(t), t, "")
+            return (len(t), t[:48], t[-48:])
+
+        draft_sig = _text_sig(draft_for_tokens)
+        sys_sig = _text_sig(sys_override_s)
+
         # Cache by a cheap signature to avoid rescanning large contexts every frame.
         last = messages[-1] if isinstance(messages, list) and messages else {}
         last_id = ""
@@ -637,6 +914,20 @@ class ReactShell:
             except Exception:
                 current_iteration = 0
 
+        gpu_enabled = bool(getattr(self, "_gpu_monitor_enabled", False))
+        gpu_pct = getattr(self, "_gpu_utilization_pct", None)
+        gpu_err = getattr(self, "_gpu_last_error", None)
+        gpu_err_s = str(gpu_err or "").strip() if isinstance(gpu_err, str) or gpu_err is not None else ""
+        gpu_key: Optional[int] = None
+        if isinstance(gpu_pct, (int, float)):
+            try:
+                gpu_key = int(round(float(gpu_pct)))
+            except Exception:
+                gpu_key = None
+        gpu_err_key = ""
+        if gpu_key is None and gpu_err_s:
+            gpu_err_key = gpu_err_s.split(":", 1)[0][:32]
+
         cache_key = (
             getattr(state, "run_id", None) if state is not None else None,
             len(messages),
@@ -648,13 +939,113 @@ class ReactShell:
             toolset_id,
             max_tokens,
             self._model,
+            draft_sig,
+            tuple(pending_attachments),
+            sys_sig,
+            tuple(self._allowed_tools) if isinstance(self._allowed_tools, list) else None,
+            bool(getattr(self, "_tool_prompt_examples", False)),
+            str(getattr(self, "_tool_executor_server_id", "") or ""),
+            gpu_enabled,
+            gpu_key,
+            gpu_err_key,
         )
         if self._status_cache_key == cache_key and self._status_cache_text:
             return self._status_cache_text
 
         tokens_used_source = "estimate"
         try:
-            est = self._estimate_next_prompt_tokens(state=state, messages=messages, effective_model=effective_model)
+            extra_msgs: List[Dict[str, Any]] = []
+            if pending_attachments:
+                try:
+                    # Best-effort: mirror runtime's injected "Session attachments" system message.
+                    from abstractruntime.integrations.abstractcore.session_attachments import (
+                        render_session_attachments_system_message,
+                    )
+
+                    entries: List[Dict[str, Any]] = []
+                    # Most recent first (match runtime).
+                    for rel in reversed(list(pending_attachments)):
+                        key = str(rel or "").strip()
+                        if not key:
+                            continue
+                        if not key.startswith("/"):
+                            key = normalize_relative_path(key)
+                        if not key:
+                            continue
+                        cached = self._attachment_ref_cache.get(key)
+                        artifact_id = str(cached.get("$artifact") or "") if isinstance(cached, dict) else ""
+                        sha = str(cached.get("sha256") or "") if isinstance(cached, dict) else ""
+                        ct = str(cached.get("content_type") or "") if isinstance(cached, dict) else ""
+                        fn = str(cached.get("filename") or "") if isinstance(cached, dict) else ""
+                        entry: Dict[str, Any] = {
+                            "handle": key,
+                            "artifact_id": artifact_id,
+                            "filename": fn or key.rsplit("/", 1)[-1],
+                            "sha256": sha,
+                            "content_type": ct,
+                        }
+                        entries.append(entry)
+
+                    msg = render_session_attachments_system_message(entries, max_entries=20, max_chars=4000)
+                    if msg and not (
+                        messages
+                        and isinstance(messages[0], dict)
+                        and messages[0].get("role") == "system"
+                        and isinstance(messages[0].get("content"), str)
+                        and str(messages[0].get("content") or "")
+                        .strip()
+                        .startswith(("Stored session attachments", "Session attachments"))
+                    ):
+                        extra_msgs.append({"role": "system", "content": msg})
+                except Exception:
+                    pass
+
+            tool_specs: Optional[List[Dict[str, Any]]] = None
+            try:
+                # Prefer durable tool_specs if present on the active run.
+                runtime_ns = state.vars.get("_runtime") if state is not None and isinstance(getattr(state, "vars", None), dict) else None
+                if isinstance(runtime_ns, dict):
+                    raw_specs = runtime_ns.get("tool_specs")
+                    if isinstance(raw_specs, list) and raw_specs and all(isinstance(x, dict) for x in raw_specs):
+                        tool_specs = list(raw_specs)
+            except Exception:
+                tool_specs = None
+            if tool_specs is None:
+                try:
+                    logic = getattr(self._agent, "logic", None)
+                    tool_defs = getattr(logic, "tools", None) if logic is not None else None
+                    allow = list(self._allowed_tools) if isinstance(self._allowed_tools, list) else None
+                    if isinstance(tool_defs, list) and tool_defs:
+                        tool_by_name = {t.name: t for t in tool_defs if getattr(t, "name", None)}
+                        ordered = [t.name for t in tool_defs if getattr(t, "name", None)]
+                        if allow is not None:
+                            ordered = [n for n in ordered if str(n) in set(allow)]
+                        built: List[Dict[str, Any]] = []
+                        for name in ordered:
+                            tool = tool_by_name.get(str(name))
+                            if tool is None:
+                                continue
+                            to_dict = getattr(tool, "to_dict", None)
+                            if callable(to_dict):
+                                try:
+                                    spec = to_dict()
+                                except Exception:
+                                    spec = None
+                                if isinstance(spec, dict):
+                                    built.append(spec)
+                        if built:
+                            tool_specs = built
+                except Exception:
+                    tool_specs = None
+
+            est = self._estimate_next_prompt_tokens(
+                state=state,
+                messages=messages,
+                effective_model=effective_model,
+                task_text=draft_for_tokens,
+                extra_messages=extra_msgs,
+                tool_specs=tool_specs,
+            )
             tokens_used_source = str(est.get("source") or "estimate")
             tokens_used = int(est.get("total_tokens") or 0)
         except Exception:
@@ -669,6 +1060,24 @@ class ReactShell:
         pct = (tokens_used / max_tokens) * 100 if max_tokens > 0 else 0.0
         label = "Context" if tokens_used_source == "provider" else "Context(next)"
         status = f"{self._provider} | {self._model} | {label}: {tokens_used:,}/{max_tokens:,} tk ({pct:.0f}%)"
+        if gpu_enabled:
+            if gpu_key is None:
+                if gpu_err_s:
+                    if gpu_err_s.startswith("http_"):
+                        code = gpu_err_s.split(":", 1)[0].replace("http_", "").strip()
+                        status = f"{status} | GPU {code or 'n/a'}"
+                    else:
+                        short = gpu_err_s.split(":", 1)[0].strip()
+                        if len(short) > 12:
+                            short = short[:12] + "…"
+                        status = f"{status} | GPU {short or 'n/a'}"
+                else:
+                    status = f"{status} | GPU n/a"
+            else:
+                try:
+                    status = f"{status} | {self._format_gpu_meter(float(gpu_pct))}"
+                except Exception:
+                    status = f"{status} | GPU n/a"
         self._status_cache_key = cache_key
         self._status_cache_text = status
         return status
@@ -1260,7 +1669,18 @@ class ReactShell:
             return "\n".join(out)
 
         bg = "\033[48;5;238m"
-        fg = "\033[38;5;255m"
+        try:
+            theme = getattr(self, "_theme", None)
+            t = theme.normalized() if isinstance(theme, Theme) else theme_from_env().normalized()
+            bg_target = "#ffffff" if is_dark(t.surface) else "#000000"
+            bg_hex = blend_hex(t.surface, bg_target, 0.08)
+            fg_target = "#ffffff" if is_dark(bg_hex) else "#000000"
+            fg_hex = blend_hex(t.muted, fg_target, 0.90)
+            bg = ansi_bg(bg_hex) or bg
+            fallback_fg = "\033[38;5;255m" if is_dark(bg_hex) else "\033[38;5;0m"
+            fg = ansi_fg(fg_hex) or fallback_fg
+        except Exception:
+            fg = "\033[38;5;255m"
         reset = _C.RESET
 
         def style_full(line_text: str) -> str:
@@ -1287,21 +1707,23 @@ class ReactShell:
         out_lines.append("")
         return "\n".join(out_lines)
 
-    def _handle_input(self, text: str) -> None:
+    def _handle_input(self, inp: SubmittedInput) -> None:
         """Handle user input from the UI (called from worker thread)."""
         import uuid
 
+        attachment_paths: List[str] = []
+        text = ""
+        if isinstance(inp, SubmittedInput):
+            text = str(inp.text or "")
+            if isinstance(inp.attachments, list):
+                attachment_paths = [str(p) for p in inp.attachments if isinstance(p, str) and p.strip()]
+        else:  # pragma: no cover
+            text = str(inp or "")
+
         text = text.strip()
         if not text:
             return
 
-        # Echo user input (styled so user prompts are easy to spot).
-        copy_id = f"user_{uuid.uuid4().hex}"
-        self._ui.register_copy_payload(copy_id, text)
-        ts_text = self._format_timestamp_short(_now_iso())
-        footer = _style(ts_text, _C.DIM, enabled=self._color) if ts_text else ""
-        self._print(self._format_user_prompt_block(text, copy_id=copy_id, footer=footer))
-
         cmd = text.strip()
 
         if cmd.startswith("/"):
@@ -1323,18 +1745,30 @@ class ReactShell:
             "max-messages",
             "max_messages",
             "memory",
+            "files",
+            "files-keep",
+            "files_keep",
             "plan",
             "review",
+            "config",
             "compact",
             "spans",
             "expand",
             "vars",
             "var",
-            "log",
+            "whitelist",
+            "blacklist",
+            "logs",
             "memorize",
             "recall",
             "copy",
             "mouse",
+            "agent",
+            "theme",
+            "system",
+            "gpu",
+            "links",
+            "open",
             "flow",
             "history",
             "resume",
@@ -1353,8 +1787,361 @@ class ReactShell:
             self._print(_style(f"Try: /{lower}", _C.DIM, enabled=self._color))
             return
 
-        # Otherwise treat as a task
-        self._start(cmd)
+        # Otherwise treat as a task. Allow both:
+        # - chips-based attachments (from `@` completion), and
+        # - inline `@file` mentions typed manually.
+        from .file_mentions import extract_at_file_mentions
+
+        cleaned_cmd, mentions = extract_at_file_mentions(cmd)
+        cleaned_cmd_text = str(cleaned_cmd or "").strip()
+        paths: List[str] = []
+        for p in attachment_paths:
+            norm = self._normalize_attachment_token(p)
+            if norm:
+                paths.append(norm)
+        mention_paths: List[str] = []
+        for m in mentions:
+            norm = self._normalize_attachment_token(m)
+            if norm:
+                paths.append(norm)
+                mention_paths.append(norm)
+
+        # Persist manual `@file` mentions into the attachment chips bar when:
+        # - files_keep is enabled (attachments persist across turns), OR
+        # - this is an attachment-only message (used to stage chips for the next prompt).
+        persist_mentions = bool(mention_paths) and (bool(getattr(self, "_files_keep", False)) or not cleaned_cmd_text)
+        if persist_mentions:
+            try:
+                adder = getattr(self._ui, "add_attachments", None)
+                if callable(adder):
+                    adder(mention_paths)
+            except Exception:
+                pass
+
+        # De-dup while preserving order.
+        seen: set[str] = set()
+        paths = [p for p in paths if not (p in seen or seen.add(p))]
+
+        # Ingest missing attachments once; reuse cached refs across turns.
+        newly_added: List[str] = []
+        if paths:
+            def _attachment_sig(key: str) -> Optional[Tuple[int, int]]:
+                resolved = self._resolve_attachment_file(key)
+                if resolved is None:
+                    return None
+                p, _source_path = resolved
+                try:
+                    st = p.stat()
+                    size = int(st.st_size)
+                    mtime_ns = int(getattr(st, "st_mtime_ns", int(st.st_mtime * 1e9)))
+                    return (size, mtime_ns)
+                except Exception:
+                    return None
+
+            needs_ingest: List[str] = []
+            for rel in paths:
+                cached = self._attachment_ref_cache.get(rel)
+                if not isinstance(cached, dict) or not cached:
+                    needs_ingest.append(rel)
+                    continue
+                cached_sig = self._attachment_sig_cache.get(rel)
+                cur_sig = _attachment_sig(rel)
+                if cached_sig is not None and cur_sig is not None and cached_sig != cur_sig:
+                    needs_ingest.append(rel)
+
+            if needs_ingest:
+                for ref in self._ingest_attachments(needs_ingest):
+                    if not isinstance(ref, dict):
+                        continue
+                    key = str(ref.get("source_path") or "").strip()
+                    if not key:
+                        continue
+                    prev = self._attachment_ref_cache.get(key)
+                    prev_sha = str(prev.get("sha256") or "").strip() if isinstance(prev, dict) else ""
+                    # Strip internal fields before caching/passing to the agent.
+                    clean = {k: v for k, v in dict(ref).items() if isinstance(k, str) and not k.startswith("_")}
+                    sig0 = ref.get("_sig") if isinstance(ref.get("_sig"), dict) else {}
+                    try:
+                        size0 = int((sig0 or {}).get("size_bytes"))
+                    except Exception:
+                        size0 = -1
+                    try:
+                        mtime0 = int((sig0 or {}).get("mtime_ns"))
+                    except Exception:
+                        mtime0 = -1
+                    existed = isinstance(prev, dict)
+                    self._attachment_ref_cache[key] = clean
+                    if size0 >= 0 and mtime0 >= 0:
+                        self._attachment_sig_cache[key] = (size0, mtime0)
+                    if not existed:
+                        newly_added.append(key)
+                    else:
+                        # Only report as "new" when the content hash changed (version update).
+                        next_sha = str(clean.get("sha256") or "").strip()
+                        if next_sha and prev_sha and next_sha != prev_sha:
+                            newly_added.append(key)
+
+        attachment_refs: List[Dict[str, Any]] = []
+        for p in paths:
+            ref = self._attachment_ref_cache.get(p)
+            if isinstance(ref, dict):
+                attachment_refs.append(dict(ref))
+
+        def _display_attachment_token(token: str) -> str:
+            t = str(token or "").strip()
+            if not t:
+                return ""
+            norm = t.replace("\\", "/")
+            if norm.startswith("/") or (len(norm) >= 3 and norm[1] == ":" and norm[2] in ("/", "\\")):
+                return norm.rsplit("/", 1)[-1] or t
+            return t
+
+        def _display_attachment_ref(ref: Dict[str, Any]) -> str:
+            filename = str(ref.get("filename") or "").strip()
+            source_path = str(ref.get("source_path") or "").strip()
+            return _display_attachment_token(filename or source_path or "?")
+
+        # Attachment-only message: update the session attachments and don't start a run.
+        if not cleaned_cmd_text and attachment_refs:
+            joined = ", ".join([_display_attachment_ref(a) for a in attachment_refs if isinstance(a, dict)])
+            if joined:
+                self._print(_style(f"Attachments: {joined}", _C.DIM, enabled=self._color))
+            return
+
+        if not cleaned_cmd_text:
+            return
+
+        # Echo cleaned user prompt (without `@file` mentions).
+        copy_id = f"user_{uuid.uuid4().hex}"
+        self._ui.register_copy_payload(copy_id, cleaned_cmd_text)
+        ts_text = self._format_timestamp_short(_now_iso())
+        footer = _style(ts_text, _C.DIM, enabled=self._color) if ts_text else ""
+        self._print(self._format_user_prompt_block(cleaned_cmd_text, copy_id=copy_id, footer=footer))
+
+        if newly_added:
+            joined = ", ".join([_display_attachment_token(k) for k in newly_added if str(k or "").strip()])
+            self._print(_style(f"Attachments: {joined}", _C.DIM, enabled=self._color))
+
+        self._start(cleaned_cmd_text, attachments=attachment_refs or None)
+
+    def _normalize_attachment_token(self, raw_path: str) -> str:
+        """Normalize an attachment token into a stable key.
+
+        Returns either:
+        - a workspace "virtual path" (`docs/readme.md`, `Desktop/foo.png`), or
+        - a canonical absolute path (`/Users/.../Desktop/foo.png`) for local files outside the workspace.
+        """
+        tok = str(raw_path or "").strip()
+        if not tok:
+            return ""
+        if len(tok) >= 2 and tok[0] == tok[-1] and tok[0] in ("'", '"'):
+            tok = tok[1:-1].strip()
+        if not tok:
+            return ""
+
+        if tok.lower().startswith("file://"):
+            try:
+                from urllib.parse import urlparse, unquote
+
+                parsed = urlparse(tok)
+                tok = unquote(parsed.path) if parsed.scheme == "file" else tok[7:]
+            except Exception:
+                tok = tok[7:]
+            tok = str(tok or "").strip()
+            if not tok:
+                return ""
+
+        tok_ws = tok.replace("\\", "/")
+        while tok_ws.startswith("./"):
+            tok_ws = tok_ws[2:]
+
+        try:
+            _p, virt, _mount, _root = resolve_workspace_path(
+                raw_path=tok_ws,
+                workspace_root=self._workspace_root,
+                mounts=dict(self._workspace_mounts or {}),
+            )
+            key = normalize_relative_path(str(virt or ""))
+            if key:
+                return key
+        except Exception:
+            pass
+
+        p = self._resolve_local_attachment_file(tok)
+        return str(p) if p is not None else ""
+
+    def _resolve_workspace_file(self, rel_path: str) -> Optional[tuple[Path, str]]:
+        rel = normalize_relative_path(rel_path)
+        if not rel:
+            return None
+        try:
+            p, virt, mount, root = resolve_workspace_path(
+                raw_path=rel,
+                workspace_root=self._workspace_root,
+                mounts=dict(self._workspace_mounts or {}),
+            )
+            del root
+        except Exception:
+            return None
+
+        blocked = list(self._workspace_blocked_paths or [])
+        for b in blocked:
+            if not isinstance(b, Path):
+                continue
+            try:
+                if p.resolve() == b.resolve():
+                    return None
+                p.resolve().relative_to(b.resolve())
+                return None
+            except Exception:
+                continue
+
+        try:
+            if not p.is_file():
+                return None
+        except Exception:
+            return None
+        try:
+            ign = self._workspace_ignore if mount is None else self._workspace_mount_ignores.get(str(mount))
+            if ign is not None and ign.is_ignored(p, is_dir=False):
+                return None
+        except Exception:
+            pass
+        return (p, virt)
+
+    def _resolve_local_attachment_file(self, raw_path: str) -> Optional[Path]:
+        tok = str(raw_path or "").strip()
+        if not tok:
+            return None
+        try:
+            p = Path(tok).expanduser()
+            if not p.is_absolute():
+                return None
+            p = p.resolve()
+        except Exception:
+            return None
+
+        blocked = list(self._workspace_blocked_paths or [])
+        for b in blocked:
+            if not isinstance(b, Path):
+                continue
+            try:
+                if p.resolve() == b.resolve():
+                    return None
+                p.resolve().relative_to(b.resolve())
+                return None
+            except Exception:
+                continue
+
+        try:
+            if not p.is_file():
+                return None
+        except Exception:
+            return None
+        return p
+
+    def _resolve_attachment_file(self, token: str) -> Optional[tuple[Path, str]]:
+        key = str(token or "").strip()
+        if not key:
+            return None
+        local = self._resolve_local_attachment_file(key)
+        if local is not None:
+            return (local, str(local))
+        return self._resolve_workspace_file(key)
+
+    def _max_attachment_bytes(self) -> int:
+        raw = os.environ.get("ABSTRACTCODE_MAX_ATTACHMENT_BYTES") or os.environ.get("ABSTRACTGATEWAY_MAX_ATTACHMENT_BYTES")
+        try:
+            n = int(raw) if raw is not None else 25 * 1024 * 1024
+        except Exception:
+            n = 25 * 1024 * 1024
+        return max(1, n)
+
+    def _session_memory_run_id(self) -> Optional[str]:
+        try:
+            ensure = getattr(self._agent, "_ensure_session_id", None)
+            if callable(ensure):
+                sid = ensure()
+                if isinstance(sid, str) and sid.strip():
+                    return f"session_memory_{sid.strip()}"
+        except Exception:
+            return None
+        return None
+
+    def _ingest_attachments(self, paths: Sequence[str]) -> List[Dict[str, Any]]:
+        """Store attachment files in ArtifactStore and return AttachmentRefs (best-effort)."""
+        import hashlib
+        import mimetypes
+
+        keys: list[str] = [str(p or "").strip() for p in (paths or []) if str(p or "").strip()]
+        if not keys:
+            return []
+
+        max_bytes = self._max_attachment_bytes()
+        run_id = self._session_memory_run_id()
+        out: List[Dict[str, Any]] = []
+
+        for key in keys:
+            resolved = self._resolve_attachment_file(key)
+            if resolved is None:
+                self._print(_style(f"Attachment ignored/not found: {key}", _C.YELLOW, enabled=self._color))
+                continue
+            p, source_path = resolved
+
+            try:
+                size = int(p.stat().st_size)
+                mtime_ns = int(getattr(p.stat(), "st_mtime_ns", int(p.stat().st_mtime * 1e9)))
+            except Exception:
+                size = -1
+                mtime_ns = -1
+            if size >= 0 and size > max_bytes:
+                self._print(
+                    _style(
+                        f"Attachment too large ({size:,} bytes > {max_bytes:,}): {source_path}",
+                        _C.YELLOW,
+                        enabled=self._color,
+                    )
+                )
+                continue
+
+            try:
+                content = p.read_bytes()
+            except Exception as e:
+                self._print(_style(f"Attachment read failed: {source_path} ({e})", _C.YELLOW, enabled=self._color))
+                continue
+
+            sha256 = hashlib.sha256(bytes(content)).hexdigest()
+            ct = mimetypes.guess_type(p.name)[0] or "application/octet-stream"
+            try:
+                source = "local" if str(source_path).startswith("/") else "workspace"
+                meta = self._artifact_store.store(
+                    bytes(content),
+                    content_type=str(ct),
+                    run_id=run_id,
+                    tags={
+                        "kind": "attachment",
+                        "source": source,
+                        "path": source_path,
+                        "filename": str(p.name),
+                        "sha256": sha256,
+                    },
+                )
+            except Exception as e:
+                self._print(_style(f"Attachment ingest failed: {source_path} ({e})", _C.YELLOW, enabled=self._color))
+                continue
+
+            out.append(
+                {
+                    "$artifact": str(meta.artifact_id),
+                    "filename": str(p.name),
+                    "content_type": str(ct),
+                    "source_path": str(source_path),
+                    "sha256": sha256,
+                    "_sig": {"size_bytes": size, "mtime_ns": mtime_ns},
+                }
+            )
+
+        return out
 
     def _build_answer_copy_payload(self, *, answer_text: str, prompt_text: Optional[str] = None) -> str:
         """Build the payload for the assistant copy button (best-effort, lossless)."""
@@ -1381,7 +2168,11 @@ class ReactShell:
         answer = "" if answer_text is None else str(answer_text)
         if not answer.strip():
             answer = "(no assistant answer produced yet)"
-
+        try:
+            self._last_answer_links = self._extract_links(answer)
+        except Exception:
+            self._last_answer_links = []
+
         copy_id = f"assistant_{uuid.uuid4().hex}"
         payload = self._build_answer_copy_payload(answer_text=answer, prompt_text=prompt_text)
         self._ui.register_copy_payload(copy_id, payload)
@@ -1390,7 +2181,11 @@ class ReactShell:
         self._print(_style("─" * 60, _C.DIM, enabled=self._color))
         # Render Markdown for the terminal, but keep copy payload lossless (raw answer).
         try:
-            renderer = TerminalMarkdownRenderer(color=self._color)
+            renderer = TerminalMarkdownRenderer(
+                color=self._color,
+                theme=getattr(self, "_theme", None),
+                width=self._terminal_width(),
+            )
             rendered = renderer.render(answer)
         except Exception:
             rendered = answer
@@ -1461,12 +2256,14 @@ class ReactShell:
         This uses blocking_prompt which queues a response and waits for user input.
         """
         result = self._ui.blocking_prompt(message)
+        if result == BLOCKING_PROMPT_CANCEL_TOKEN:
+            return result
         if result:
             self._print(f"  → {result}")
         return result.strip()
 
     def _banner(self) -> None:
-        self._print(_style("AbstractCode (MVP)", _C.CYAN, _C.BOLD, enabled=self._color))
+        self._print(_style("AbstractCode", _C.CYAN, _C.BOLD, enabled=self._color))
         self._print(_style("─" * 60, _C.DIM, enabled=self._color))
         self._print(f"Provider: {self._provider}   Model: {self._model}")
         if self._base_url:
@@ -1491,23 +2288,41 @@ class ReactShell:
             # Show the agent's actual "thinking" (rationale) when it is about to act.
             # We only print this for tool-using iterations to avoid duplicating final answers.
             has_tool_calls = bool(data.get("has_tool_calls"))
-            content = str(data.get("content", "") or "")
-            if has_tool_calls and content.strip():
+            if has_tool_calls:
                 import uuid
 
-                text = content.strip()
-                self._turn_trace.append("Thought:\n" + text)
+                it = data.get("iteration", "?")
+                max_it = data.get("max_iterations", "?")
+                content = str(data.get("content", "") or "")
+                reasoning = str(data.get("reasoning", "") or "")
+                text = content.strip() or reasoning.strip()
+
                 fid = f"thought_{uuid.uuid4().hex}"
-                header = _style("Thought", _C.ORANGE, _C.BOLD, enabled=self._color)
-                lines = text.splitlines() or [""]
-                first_line = lines[0].strip()
-                if len(first_line) > 200:
-                    first_line = first_line[:199] + "…"
-                visible = ["", f"[[FOLD:{fid}]]{header}", _style(f"  {first_line}", _C.ORANGE, enabled=self._color)]
-                # Hidden part shows the remaining thought (avoid duplicating the first line).
-                rest = lines[1:] if len(lines) > 1 else []
-                hidden = [_style(f"  {line}" if line else "  ", _C.ORANGE, enabled=self._color) for line in (rest or [""])]
-                hidden.append("")
+                header = _style(f"Cycle {it}/{max_it}", _C.ORANGE, _C.BOLD, enabled=self._color)
+
+                if text:
+                    self._turn_trace.append(f"Cycle {it}/{max_it} thought:\n{text}".rstrip())
+                    lines = text.splitlines() or [""]
+                    first_line = lines[0].strip()
+                    if len(first_line) > 200:
+                        first_line = first_line[:199] + "…"
+                    visible = ["", f"[[FOLD:{fid}]]{header}", _style(f"  {first_line}", _C.ORANGE, enabled=self._color)]
+                    # Hidden part shows the remaining rationale (avoid duplicating the first line).
+                    rest = lines[1:] if len(lines) > 1 else []
+                    hidden = [
+                        _style(f"  {line}" if line else "  ", _C.ORANGE, enabled=self._color)
+                        for line in (rest or [""])
+                    ]
+                    hidden.append("")
+                else:
+                    self._turn_trace.append(f"Cycle {it}/{max_it} thought: (none)")
+                    visible = [
+                        "",
+                        f"[[FOLD:{fid}]]{header}",
+                        _style("  (model returned tool calls without rationale text)", _C.DIM, enabled=self._color),
+                    ]
+                    hidden = [_style("  (no rationale provided)", _C.DIM, enabled=self._color), ""]
+
                 self._ui_append_fold_region(fold_id=fid, visible_lines=visible, hidden_lines=hidden, collapsed=True)
         elif step == "act":
             import uuid
@@ -1646,7 +2461,7 @@ class ReactShell:
             answer_text = str(data.get("answer", "") or "")
             self._print_answer_block(title="ANSWER", answer_text=answer_text, state=self._safe_get_state())
         elif step == "status":
-            # Workflow-driven status update (e.g., VisualFlow emit_event name="abstractcode.status").
+            # Workflow-driven status update (e.g., VisualFlow emit_event name="abstract.status").
             text = str(data.get("text", "") or "").strip()
             dur_raw = data.get("duration")
             dur: Optional[float]
@@ -1664,7 +2479,7 @@ class ReactShell:
             else:
                 self._ui.set_spinner(text, duration_s=dur)
         elif step == "message":
-            # Workflow-driven message notification (e.g., VisualFlow emit_event name="abstractcode.message").
+            # Workflow-driven message notification (e.g., VisualFlow emit_event name="abstract.message").
             text = str(data.get("text") or data.get("message") or "").rstrip()
             if not text.strip():
                 return
@@ -1708,7 +2523,7 @@ class ReactShell:
     def run(self) -> None:
         # Build initial banner text
         banner_lines = []
-        banner_lines.append(_style("AbstractCode (MVP)", _C.CYAN, _C.BOLD, enabled=self._color))
+        banner_lines.append(_style("AbstractCode", _C.CYAN, _C.BOLD, enabled=self._color))
         banner_lines.append(_style("─" * 60, _C.DIM, enabled=self._color))
         banner_lines.append(f"Provider: {self._provider}   Model: {self._model}")
         if self._base_url:
@@ -1723,17 +2538,81 @@ class ReactShell:
         banner_lines.append(_style("Type '/help' for commands.", _C.DIM, enabled=self._color))
         banner_lines.append("")
 
-        # Add tools list to banner
+        # Add tools list to banner (dynamic; mirrors `/tools`).
+        try:
+            if callable(getattr(self, "_maybe_sync_executor_tools", None)):
+                self._maybe_sync_executor_tools()
+        except Exception:
+            pass
+
+        def _param_names(raw: object) -> List[str]:
+            if not isinstance(raw, dict):
+                return []
+            props = raw.get("properties") if isinstance(raw.get("properties"), dict) else None
+            if isinstance(props, dict) and props:
+                return sorted([str(k) for k in props.keys() if isinstance(k, str) and k.strip()])
+            skip = {"type", "properties", "required", "description", "additionalProperties", "$schema", "title"}
+            keys = [str(k) for k in raw.keys() if isinstance(k, str) and k not in skip and k.strip()]
+            return sorted(keys)
+
+        def _available_tools_for_banner() -> List[tuple[str, List[str]]]:
+            out: List[tuple[str, List[str]]] = []
+            logic = getattr(self._agent, "logic", None)
+            tools = getattr(logic, "tools", None) if logic is not None else None
+            if isinstance(tools, list):
+                for t in tools:
+                    name = getattr(t, "name", None)
+                    if not isinstance(name, str) or not name.strip():
+                        continue
+                    params = _param_names(getattr(t, "parameters", None))
+                    if not params:
+                        td = getattr(t, "_tool_definition", None)
+                        params = _param_names(getattr(td, "parameters", None)) if td is not None else []
+                    out.append((name.strip(), params))
+            if not out:
+                for name, spec in sorted((self._tool_specs or {}).items()):
+                    params = sorted((spec.parameters or {}).keys())
+                    out.append((name, params))
+            out.sort(key=lambda x: x[0])
+            return out
+
+        def _fmt_tool_sig(name: str, params: List[str]) -> str:
+            n = str(name or "").strip()
+            ps = [str(p).strip() for p in (params or []) if str(p).strip()]
+            if not self._color:
+                inside = ", ".join(ps)
+                return f"- {n}({inside})"
+            try:
+                t = getattr(self, "_theme", None)
+                tn = t.normalized() if isinstance(t, Theme) else theme_from_env().normalized()
+                name_fg = ansi_fg(tn.primary)
+                param_fg = ansi_fg(tn.secondary)
+            except Exception:
+                name_fg = ""
+                param_fg = ""
+            dim = _C.DIM
+            bold = _C.BOLD
+            reset = _C.RESET
+            parts: List[str] = ["- ", name_fg, bold, n, reset, dim, "(", reset]
+            for i, p in enumerate(ps):
+                if i:
+                    parts.extend([dim, ", ", reset])
+                parts.extend([param_fg, p, reset])
+            parts.extend([dim, ")", reset])
+            return "".join(parts)
+
         banner_lines.append(_style("Available tools", _C.CYAN, _C.BOLD, enabled=self._color))
         banner_lines.append(_style("─" * 60, _C.DIM, enabled=self._color))
-        for name, spec in sorted(self._tool_specs.items()):
-            params = ", ".join(sorted((spec.parameters or {}).keys()))
-            banner_lines.append(f"- {name}({params})")
+        for name, params in _available_tools_for_banner():
+            banner_lines.append(_fmt_tool_sig(name, params))
         banner_lines.append(_style("─" * 60, _C.DIM, enabled=self._color))
 
         if self._state_file:
             self._try_load_state()
 
+        # Optional host GPU meter (polled from AbstractGateway).
+        self._start_gpu_monitor()
+
         # Run the UI loop - this stays in full-screen mode continuously.
         # All input is handled by _handle_input() via the worker thread.
         self._ui.run_loop(banner="\n".join(banner_lines))
@@ -1775,6 +2654,9 @@ class ReactShell:
         if command == "review":
             self._handle_review(arg)
             return False
+        if command == "config":
+            self._handle_config(arg)
+            return False
         if command == "resume":
             self._resume()
             return False
@@ -1784,6 +2666,9 @@ class ReactShell:
         if command == "cancel":
             self._cancel()
             return False
+        if command == "conclude":
+            self._conclude(arg)
+            return False
         if command == "history":
             sub = arg.strip()
             if sub:
@@ -1841,12 +2726,42 @@ class ReactShell:
         if command in ("vars", "var"):
             self._handle_vars(arg)
             return False
-        if command == "log":
+        if command == "whitelist":
+            self._handle_whitelist(arg)
+            return False
+        if command == "blacklist":
+            self._handle_blacklist(arg)
+            return False
+        if command == "logs":
             self._handle_log(arg)
             return False
         if command == "mouse":
             self._handle_mouse_toggle()
             return False
+        if command == "agent":
+            self._handle_agent(arg)
+            return False
+        if command == "theme":
+            self._handle_theme(arg)
+            return False
+        if command == "files":
+            self._handle_files(arg)
+            return False
+        if command in ("files-keep", "files_keep"):
+            self._handle_files_keep(arg)
+            return False
+        if command == "system":
+            self._handle_system(arg)
+            return False
+        if command == "gpu":
+            self._handle_gpu(arg)
+            return False
+        if command == "links":
+            self._handle_links(arg)
+            return False
+        if command == "open":
+            self._handle_open(arg)
+            return False
         if command == "copy":
             self._handle_copy(arg)
             return False
@@ -1854,19 +2769,815 @@ class ReactShell:
             self._handle_flow(arg)
             return False
 
-        self._print(_style(f"Unknown command: /{command}", _C.YELLOW, enabled=self._color))
-        self._print(_style("Type /help for commands.", _C.DIM, enabled=self._color))
-        return False
+        self._print(_style(f"Unknown command: /{command}", _C.YELLOW, enabled=self._color))
+        self._print(_style("Type /help for commands.", _C.DIM, enabled=self._color))
+        return False
+
+    def _default_bundles_dir(self) -> Path:
+        try:
+            from abstractruntime.workflow_bundle import default_workflow_bundles_dir  # type: ignore
+
+            return default_workflow_bundles_dir()
+        except Exception:
+            candidate = Path("flows") / "bundles"
+            if candidate.exists() and candidate.is_dir():
+                return candidate
+            return Path("flows")
+
+    def _normalize_agent_selector_key(self, raw: str) -> str:
+        s = str(raw or "").strip()
+        if not s:
+            return "react"
+        lower = s.lower()
+        if lower in ("react", "codeact", "memact"):
+            return lower
+
+        # Support "bundle_id:flow_id" (same as the web UI). Avoid Windows drive letters.
+        if ":" in s and not re.match(r"^[A-Za-z]:[\\\\/]", s):
+            left, _right = s.split(":", 1)
+            if left.strip():
+                s = left.strip()
+
+        # If this is a bundle path, prefer manifest.bundle_id.
+        try:
+            p = Path(s).expanduser()
+            if p.exists() and p.is_file() and str(p.suffix or "").lower() == ".flow":
+                try:
+                    from abstractruntime.workflow_bundle import open_workflow_bundle  # type: ignore
+
+                    bid = str(open_workflow_bundle(p).manifest.bundle_id or "").strip()
+                    if bid:
+                        return bid
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+        if s.lower().endswith(".flow"):
+            s = s[:-5]
+        if "@" in s:
+            base, _ver = s.split("@", 1)
+            s = base.strip()
+        return s or lower
+
+    def _discover_bundled_agent_templates(self) -> List[_BundledAgentTemplate]:
+        """Best-effort: list bundled `.flow` entrypoints implementing `abstractcode.agent.v1`."""
+        try:
+            from abstractruntime.workflow_bundle import open_workflow_bundle  # type: ignore
+        except Exception:
+            return []
+
+        bundles_dir = self._default_bundles_dir()
+        if not bundles_dir.exists() or not bundles_dir.is_dir():
+            return []
+
+        try:
+            from packaging.version import Version
+        except Exception:  # pragma: no cover
+
+            def Version(v: str) -> Any:  # type: ignore[misc]
+                return v
+
+        best_by_id: Dict[str, Tuple[Any, _BundledAgentTemplate]] = {}
+        for path in sorted(bundles_dir.glob("*.flow")):
+            if not path.is_file():
+                continue
+            try:
+                bundle = open_workflow_bundle(path)
+            except Exception:
+                continue
+            man = bundle.manifest
+            bundle_id = str(getattr(man, "bundle_id", "") or "").strip()
+            if not bundle_id:
+                continue
+            bundle_version = str(getattr(man, "bundle_version", "") or "0.0.0").strip() or "0.0.0"
+
+            eps = []
+            for ep in getattr(man, "entrypoints", None) or []:
+                interfaces = list(getattr(ep, "interfaces", None) or [])
+                if "abstractcode.agent.v1" not in interfaces:
+                    continue
+                eps.append(ep)
+            if not eps:
+                continue
+
+            default_flow_id = str(getattr(man, "default_entrypoint", "") or "").strip()
+            chosen = None
+            if default_flow_id:
+                chosen = next((ep for ep in eps if str(getattr(ep, "flow_id", "") or "").strip() == default_flow_id), None)
+            if chosen is None:
+                chosen = eps[0]
+
+            flow_id = str(getattr(chosen, "flow_id", "") or "").strip()
+            if not flow_id:
+                continue
+
+            tpl = _BundledAgentTemplate(
+                bundle_id=bundle_id,
+                bundle_version=bundle_version,
+                flow_id=flow_id,
+                name=str(getattr(chosen, "name", "") or "").strip() or bundle_id,
+                description=str(getattr(chosen, "description", "") or ""),
+            )
+
+            try:
+                vkey = Version(bundle_version)
+            except Exception:
+                vkey = bundle_version
+
+            prev = best_by_id.get(bundle_id)
+            if prev is None or vkey > prev[0]:
+                best_by_id[bundle_id] = (vkey, tpl)
+
+        out = [tpl for _v, tpl in best_by_id.values()]
+        out.sort(key=lambda t: t.bundle_id)
+        return out
+
+    def _refresh_bundled_agent_templates(self) -> None:
+        self._bundled_agent_templates = self._discover_bundled_agent_templates()
+        self._sync_agent_selector_to_ui()
+
+    def _agent_selector_items_for_ui(self) -> List[Tuple[str, str, str]]:
+        items: List[Tuple[str, str, str]] = [
+            ("react", "react", "builtin"),
+            ("memact", "memact", "builtin"),
+            ("codeact", "codeact", "builtin"),
+        ]
+        for tpl in list(getattr(self, "_bundled_agent_templates", None) or []):
+            bid = str(getattr(tpl, "bundle_id", "") or "").strip()
+            if not bid:
+                continue
+            flow_id = str(getattr(tpl, "flow_id", "") or "").strip()
+            ver = str(getattr(tpl, "bundle_version", "") or "").strip()
+            meta = flow_id
+            if ver:
+                meta = f"{meta} @{ver}" if meta else f"@{ver}"
+            items.append((bid, bid, meta))
+        return items
+
+    def _sync_agent_selector_to_ui(self) -> None:
+        ui = getattr(self, "_ui", None)
+        if ui is None:
+            return
+        try:
+            ui.set_agent_selector(
+                current_key=str(getattr(self, "_agent_selector_key", "") or "").strip(),
+                items=self._agent_selector_items_for_ui(),
+            )
+        except Exception:
+            return
+
+    def _set_agent(self, selector: str) -> None:
+        raw = str(selector or "").strip()
+        if not raw:
+            return
+
+        lower = raw.lower()
+        if lower in ("react", "codeact", "memact"):
+            agent_kind = lower
+            workflow_ref: Optional[str] = None
+        else:
+            agent_kind = raw
+            workflow_ref = raw
+
+        # Choose toolset.
+        agent_cls = None
+        if workflow_ref is not None:
+            tools = list(getattr(self, "_default_tools", []) or [])
+        elif agent_kind == "react":
+            tools = list(getattr(self, "_default_tools", []) or [])
+            agent_cls = getattr(self, "_agent_classes", {}).get("react")
+        elif agent_kind == "memact":
+            tools = list(getattr(self, "_default_tools", []) or [])
+            agent_cls = getattr(self, "_agent_classes", {}).get("memact")
+        else:
+            tools = list(getattr(self, "_codeact_tools", []) or [])
+            agent_cls = getattr(self, "_agent_classes", {}).get("codeact")
+
+        if not tools:
+            raise RuntimeError("No tools configured for agent selection")
+
+        # Rebuild tool metadata + runner.
+        from abstractcore.tools import ToolDefinition
+        from abstractruntime.integrations.abstractcore import MappingToolExecutor
+
+        self._tools = tools
+        self._tool_runner = MappingToolExecutor.from_tools(self._tools)
+
+        tool_specs: Dict[str, _ToolSpec] = {}
+        for t in self._tools:
+            tool_def = getattr(t, "_tool_definition", None) or ToolDefinition.from_function(t)
+            tool_specs[tool_def.name] = _ToolSpec(
+                name=tool_def.name,
+                description=tool_def.description,
+                parameters=dict(tool_def.parameters or {}),
+            )
+        self._tool_specs = tool_specs
+
+        # Filter allowlist against the new toolset (best-effort).
+        if isinstance(getattr(self, "_allowed_tools", None), list):
+            self._allowed_tools = [t for t in self._allowed_tools if t in self._tool_specs]
+
+        # Rebuild agent instance.
+        if workflow_ref is not None:
+            try:
+                from .workflow_agent import WorkflowAgent
+            except Exception as e:
+                raise RuntimeError(f"Workflow agents require AbstractFlow to be installed/importable.\n\n{e}") from e
+
+            self._workflow_agent_ref = workflow_ref
+            self._agent_kind = raw
+            self._agent = WorkflowAgent(
+                runtime=self._runtime,
+                flow_ref=self._workflow_agent_ref,
+                tools=self._tools,
+                on_step=self._on_step,
+                max_iterations=self._max_iterations,
+                max_tokens=self._max_tokens,
+            )
+        else:
+            if agent_cls is None:
+                raise RuntimeError(f"Unknown agent kind: {agent_kind}")
+            self._workflow_agent_ref = None
+            self._agent_kind = agent_kind
+            self._agent = agent_cls(
+                runtime=self._runtime,
+                tools=self._tools,
+                on_step=self._on_step,
+                max_iterations=self._max_iterations,
+                max_tokens=self._max_tokens,
+                plan_mode=self._plan_mode,
+                review_mode=self._review_mode,
+                review_max_rounds=self._review_max_rounds,
+            )
+
+        self._agent_selector_key = self._normalize_agent_selector_key(raw)
+        self._status_cache_key = None
+        self._status_cache_text = ""
+        self._sync_agent_selector_to_ui()
+
+    def _handle_agent(self, raw: str) -> None:
+        import shlex
+
+        try:
+            parts = shlex.split(raw) if raw else []
+        except ValueError:
+            parts = raw.split() if raw else []
+
+        if not parts:
+            cur = str(getattr(self, "_agent_selector_key", "") or "").strip() or str(getattr(self, "_agent_kind", "") or "")
+            self._print(_style(f"Current agent: {cur or 'react'}", _C.DIM, enabled=self._color))
+            self._print(_style("Usage:", _C.DIM, enabled=self._color))
+            self._print(_style("  /agent list", _C.DIM, enabled=self._color))
+            self._print(_style("  /agent <name|bundle_id|path>", _C.DIM, enabled=self._color))
+            return
+
+        head = str(parts[0] or "").strip().lower()
+        if head in ("list", "ls"):
+            self._refresh_bundled_agent_templates()
+            self._print(_style("\nAgents", _C.CYAN, _C.BOLD, enabled=self._color))
+            self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+            for key, label, meta in self._agent_selector_items_for_ui():
+                if not self._color:
+                    self._print(f"- {label}  {meta}".rstrip())
+                    continue
+                try:
+                    t = getattr(self, "_theme", None)
+                    tn = t.normalized() if isinstance(t, Theme) else theme_from_env().normalized()
+                    name_fg = ansi_fg(tn.primary)
+                    meta_fg = ansi_fg(tn.secondary)
+                except Exception:
+                    name_fg = ""
+                    meta_fg = ""
+                reset = _C.RESET
+                dim = _C.DIM
+                line = f"- {name_fg}{label}{reset}"
+                if meta:
+                    line += f"  {dim}{meta_fg}{meta}{reset}"
+                self._print(line)
+            self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+            return
+
+        if head in ("reload", "refresh"):
+            self._refresh_bundled_agent_templates()
+            self._print(_style("Agent templates reloaded.", _C.DIM, enabled=self._color))
+            return
+
+        # Otherwise: treat the raw arg as a selector and switch (silent on success).
+        try:
+            self._set_agent(raw)
+        except Exception as e:
+            self._print(_style(f"Failed to set agent: {e}", _C.YELLOW, enabled=self._color))
+
+    def _handle_theme(self, raw: str) -> None:
+        import shlex
+
+        try:
+            parts = shlex.split(raw) if raw else []
+        except ValueError:
+            parts = raw.split() if raw else []
+
+        if not parts or (len(parts) == 1 and parts[0].strip().lower() in ("list", "ls")):
+            current = getattr(self, "_theme", None)
+            current_name = str(getattr(current, "name", "") or "tokyo")
+            names = sorted(BUILTIN_THEMES.keys())
+            self._print(_style("\nThemes", _C.CYAN, _C.BOLD, enabled=self._color))
+            self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+            self._print(f"Current: {current_name}")
+            self._print("Available: " + ", ".join(names))
+            self._print(_style("Usage:", _C.DIM, enabled=self._color))
+            self._print(_style("  /theme <name>", _C.DIM, enabled=self._color))
+            self._print(_style("  /theme custom <primary> <secondary> <surface> <muted>", _C.DIM, enabled=self._color))
+            return
+
+        head = str(parts[0] or "").strip().lower()
+        if head == "custom":
+            if len(parts) != 5:
+                self._print(_style("Usage: /theme custom <primary> <secondary> <surface> <muted>", _C.DIM, enabled=self._color))
+                return
+            t = Theme(
+                name="custom",
+                primary=str(parts[1]),
+                secondary=str(parts[2]),
+                surface=str(parts[3]),
+                muted=str(parts[4]),
+            ).normalized()
+        else:
+            t = get_theme(head) if head else None
+            if t is None:
+                self._print(_style(f"Unknown theme: {head}", _C.YELLOW, enabled=self._color))
+                self._print(_style("Try: /theme list", _C.DIM, enabled=self._color))
+                return
+            t = t.normalized()
+
+        self._theme = t
+        try:
+            self._ui.set_theme(t)
+        except Exception:
+            pass
+        # Persist user preference (durable when state_file is enabled).
+        self._save_config()
+        # Intentionally no chat output here: theme changes are reflected in the UI immediately
+        # (footer indicator + full rerender), and /theme is considered a UI command.
+
+    def _handle_system(self, raw: str) -> None:
+        """Show or set the system prompt override for the agent/runtime.
+
+        Usage:
+          /system                 (show)
+          /system <text...>       (set override; applies to new runs and the active run)
+          /system clear           (remove override)
+        """
+        import uuid
+
+        arg = str(raw or "").strip()
+
+        def _apply_to_active_run(value: Optional[str]) -> None:
+            run_id = self._attached_run_id()
+            if run_id is None:
+                return
+            try:
+                state = self._runtime.get_state(run_id)
+            except Exception:
+                state = None
+            if state is None or not hasattr(state, "vars") or not isinstance(state.vars, dict):
+                return
+            runtime_ns = state.vars.get("_runtime")
+            if not isinstance(runtime_ns, dict):
+                runtime_ns = {}
+                state.vars["_runtime"] = runtime_ns
+            if value is None:
+                runtime_ns.pop("system_prompt", None)
+            else:
+                runtime_ns["system_prompt"] = str(value)
+            try:
+                self._runtime.run_store.save(state)
+            except Exception:
+                pass
+            # System prompt affects token estimates shown in the footer.
+            self._status_cache_key = None
+            self._status_cache_text = ""
+
+        if arg.lower() in ("clear", "reset", "off", "default", "none"):
+            self._system_prompt_override = None
+            self._save_config()
+            _apply_to_active_run(None)
+            self._print(_style("System prompt cleared (back to agent default).", _C.DIM, enabled=self._color))
+            return
+
+        if arg:
+            self._system_prompt_override = arg
+            self._save_config()
+            _apply_to_active_run(arg)
+            self._print(_style("System prompt set.", _C.DIM, enabled=self._color))
+            return
+
+        # Show the effective system prompt (active run if available; else session default).
+        state = self._safe_get_state()
+        runtime_override: Optional[str] = None
+        if state is not None and hasattr(state, "vars") and isinstance(getattr(state, "vars", None), dict):
+            runtime_ns = state.vars.get("_runtime") if isinstance(state.vars.get("_runtime"), dict) else {}
+            raw_sys = runtime_ns.get("system_prompt") if isinstance(runtime_ns, dict) else None
+            if isinstance(raw_sys, str) and raw_sys.strip():
+                runtime_override = raw_sys.strip()
+
+        title = "System prompt"
+        prompt_text = ""
+        if runtime_override is not None:
+            title = "System prompt (override)"
+            prompt_text = runtime_override
+        else:
+            session_override = getattr(self, "_system_prompt_override", None)
+            if state is None and isinstance(session_override, str) and session_override.strip():
+                title = "System prompt (default override)"
+                prompt_text = session_override.strip()
+            else:
+                # Best-effort: build the agent-generated system prompt (next call).
+                logic = getattr(self._agent, "logic", None)
+                if logic is not None:
+                    try:
+                        messages = self._select_messages_for_llm(state) if state is not None else []
+                    except Exception:
+                        messages = []
+
+                    iteration = 1
+                    max_iterations = int(getattr(self, "_max_iterations", 25) or 25)
+                    vars_ns: Optional[Dict[str, Any]] = None
+                    if state is not None and hasattr(state, "vars") and isinstance(getattr(state, "vars", None), dict):
+                        vars_ns = state.vars
+                        context_ns = state.vars.get("context") if isinstance(state.vars.get("context"), dict) else {}
+                        limits = state.vars.get("_limits") if isinstance(state.vars.get("_limits"), dict) else {}
+                        try:
+                            cur = int(limits.get("current_iteration", 0) or 0)
+                        except Exception:
+                            cur = 0
+                        try:
+                            max_iterations = int(limits.get("max_iterations", max_iterations) or max_iterations)
+                        except Exception:
+                            max_iterations = max_iterations
+                        if max_iterations < 1:
+                            max_iterations = 1
+                        iteration = max(1, cur + 1)
+                    try:
+                        task_txt = ""
+                        if vars_ns is not None and isinstance(context_ns, dict):
+                            task_txt = str(context_ns.get("task") or "")
+                        req = logic.build_request(
+                            task=task_txt,
+                            messages=list(messages or []),
+                            guidance="",
+                            iteration=iteration,
+                            max_iterations=max_iterations,
+                            vars=vars_ns,
+                        )
+                        prompt_text = str(getattr(req, "system_prompt", "") or "").strip()
+                    except Exception:
+                        prompt_text = ""
+
+        if not prompt_text:
+            self._print(_style("No system prompt available yet. Start a task, then run /system again.", _C.DIM, enabled=self._color))
+            return
+
+        copy_id = f"system_{uuid.uuid4().hex}"
+        self._ui.register_copy_payload(copy_id, prompt_text)
+        self._print(_style(f"\n{title}", _C.CYAN, _C.BOLD, enabled=self._color))
+        self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+        self._print(prompt_text)
+        self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+        self._print(f"[[COPY:{copy_id}]]")
+
+    def _gpu_monitor_enabled_from_env(self) -> bool:
+        """Return whether the GPU meter should run.
+
+        Default: OFF (opt-in), to avoid constant polling/noisy gateway logs.
+
+        Control via `ABSTRACTCODE_GPU_MONITOR`:
+        - 0/false/off/no  -> disabled
+        - 1/true/on/yes   -> enabled
+        - auto            -> enabled when a gateway URL/token is configured
+        """
+        v = str(os.getenv("ABSTRACTCODE_GPU_MONITOR", "") or "").strip().lower()
+        if v in ("0", "false", "off", "no"):
+            return False
+        if v in ("1", "true", "on", "yes"):
+            return True
+        if v in ("auto", "detect", "default"):
+            return bool(
+                str(os.getenv("ABSTRACTCODE_GATEWAY_URL", "") or "").strip()
+                or str(os.getenv("ABSTRACTFLOW_GATEWAY_URL", "") or "").strip()
+                or str(os.getenv("ABSTRACTGATEWAY_URL", "") or "").strip()
+                or str(os.getenv("ABSTRACTCODE_GATEWAY_TOKEN", "") or "").strip()
+                or str(os.getenv("ABSTRACTGATEWAY_AUTH_TOKEN", "") or "").strip()
+                or str(os.getenv("ABSTRACTFLOW_GATEWAY_AUTH_TOKEN", "") or "").strip()
+                or str(os.getenv("ABSTRACTGATEWAY_AUTH_TOKENS", "") or "").strip()
+                or str(os.getenv("ABSTRACTFLOW_GATEWAY_AUTH_TOKENS", "") or "").strip()
+            )
+        return False
+
+    def _start_gpu_monitor(self) -> None:
+        """Start the GPU polling thread (best-effort)."""
+        if not bool(getattr(self, "_gpu_monitor_enabled", False)):
+            return
+        try:
+            lock = getattr(self, "_gpu_monitor_lock", None)
+            if lock is None:
+                lock = threading.Lock()
+                self._gpu_monitor_lock = lock
+        except Exception:
+            lock = None
+
+        if lock is None:  # pragma: no cover
+            return
+
+        with lock:
+            t = getattr(self, "_gpu_monitor_thread", None)
+            if t is not None and getattr(t, "is_alive", lambda: False)():
+                return
+            self._gpu_monitor_thread = threading.Thread(target=self._gpu_monitor_loop, daemon=True)
+            self._gpu_monitor_thread.start()
+
+    def _fetch_gateway_gpu_utilization_pct(self, *, timeout_s: float = 0.8) -> tuple[Optional[float], Optional[str]]:
+        """Fetch GPU utilization from AbstractGateway (best-effort)."""
+        try:
+            from urllib.error import HTTPError
+            from urllib.request import Request, urlopen
+        except Exception:  # pragma: no cover
+            return None, "urllib_unavailable"
+
+        try:
+            from .gateway_cli import default_gateway_token, default_gateway_url
+        except Exception:
+            return None, "gateway_cli_unavailable"
+
+        base = str(default_gateway_url() or "").rstrip("/")
+        if not base:
+            return None, "gateway_url_missing"
+        url = f"{base}/api/gateway/host/metrics/gpu"
+        headers = {"Accept": "application/json"}
+        token = default_gateway_token()
+        if token:
+            headers["Authorization"] = f"Bearer {token}"
+
+        req = Request(url=url, headers=headers, method="GET")
+        raw = ""
+        try:
+            with urlopen(req, timeout=float(max(0.1, timeout_s))) as resp:
+                raw = resp.read().decode("utf-8")
+        except HTTPError as e:
+            detail = ""
+            try:
+                detail = (e.read().decode("utf-8") or "").strip()
+            except Exception:
+                detail = ""
+            msg = f"http_{e.code}"
+            if detail:
+                msg = f"{msg}: {detail}"
+            return None, msg
+        except Exception as e:
+            return None, f"network_error: {e}"
+
+        try:
+            payload = json.loads(raw) if raw else {}
+        except Exception:
+            payload = {}
+
+        if not isinstance(payload, dict):
+            return None, "invalid_json"
+        if payload.get("supported") is False:
+            reason = payload.get("reason")
+            reason_s = str(reason).strip() if isinstance(reason, str) else ""
+            return None, reason_s or "unsupported"
+
+        def _as_float(x: object) -> Optional[float]:
+            try:
+                v = float(x)  # type: ignore[arg-type]
+            except Exception:
+                return None
+            if v != v:  # NaN
+                return None
+            return v
+
+        direct = _as_float(payload.get("utilization_gpu_pct"))
+        if direct is not None:
+            return max(0.0, min(100.0, direct)), None
+
+        gpus = payload.get("gpus")
+        if isinstance(gpus, list) and gpus:
+            vals: List[float] = []
+            for g in gpus:
+                if not isinstance(g, dict):
+                    continue
+                v = _as_float(g.get("utilization_gpu_pct"))
+                if v is None:
+                    continue
+                vals.append(v)
+            if vals:
+                avg = sum(vals) / max(1, len(vals))
+                return max(0.0, min(100.0, avg)), None
+
+        return None, "missing_utilization"
+
+    def _gpu_monitor_loop(self) -> None:
+        failures = 0
+        last_emitted: Optional[int] = None
+        last_err: Optional[str] = None
+        poll_s = 2.0
+
+        while True:
+            ui = getattr(self, "_ui", None)
+            if ui is not None and bool(getattr(ui, "_shutdown", False)):
+                return
+            if not bool(getattr(self, "_gpu_monitor_enabled", False)):
+                time.sleep(0.5)
+                continue
+
+            pct, err = self._fetch_gateway_gpu_utilization_pct(timeout_s=0.8)
+            updated = False
+            if pct is None:
+                failures += 1
+                err_s = str(err or "unavailable")
+                self._gpu_last_error = err_s
+                if err_s != (last_err or ""):
+                    last_err = err_s
+                    updated = True
+                if getattr(self, "_gpu_utilization_pct", None) is not None:
+                    self._gpu_utilization_pct = None
+                    last_emitted = None
+                    updated = True
+            else:
+                failures = 0
+                self._gpu_last_error = None
+                if last_err is not None:
+                    last_err = None
+                    updated = True
+                self._gpu_last_ok_at = time.time()
+                pct_int = int(round(float(pct)))
+                if last_emitted is None or pct_int != last_emitted:
+                    self._gpu_utilization_pct = float(pct)
+                    last_emitted = pct_int
+                    updated = True
+
+            if updated:
+                try:
+                    self._ui.request_refresh()
+                except Exception:
+                    pass
+
+            sleep_s = poll_s if failures < 3 else min(10.0, poll_s * float(failures))
+            time.sleep(float(sleep_s))
+
+    def _format_gpu_meter(self, pct: float) -> str:
+        p = max(0.0, min(100.0, float(pct)))
+        bar_len = 10
+        filled = int(round((p / 100.0) * bar_len))
+        filled = max(0, min(bar_len, filled))
+        bar = ("█" * filled) + ("░" * (bar_len - filled))
+        return f"GPU {bar} {p:.0f}%"
+
+    def _handle_gpu(self, raw: str) -> None:
+        arg = str(raw or "").strip().lower()
+        if not arg or arg in ("status", "show"):
+            enabled = bool(getattr(self, "_gpu_monitor_enabled", False))
+            pct = getattr(self, "_gpu_utilization_pct", None)
+            meter = self._format_gpu_meter(float(pct)) if isinstance(pct, (int, float)) else "GPU n/a"
+            err = getattr(self, "_gpu_last_error", None)
+            err_s = str(err or "").strip() if err is not None else ""
+            ok_at = getattr(self, "_gpu_last_ok_at", None)
+            age_s = ""
+            if isinstance(ok_at, (int, float)) and ok_at > 0:
+                try:
+                    age_s = f"{max(0, int(time.time() - float(ok_at)))}s ago"
+                except Exception:
+                    age_s = ""
+
+            try:
+                from .gateway_cli import default_gateway_token, default_gateway_url
+
+                gw_url = str(default_gateway_url() or "")
+                has_token = bool(default_gateway_token())
+            except Exception:
+                gw_url = ""
+                has_token = False
+
+            line = f"GPU meter: {'ON' if enabled else 'OFF'}  ({meter})"
+            if age_s:
+                line = f"{line}  (last ok: {age_s})"
+            self._print(_style(line, _C.DIM, enabled=self._color))
+            if gw_url:
+                self._print(_style(f"Gateway: {gw_url}  token: {'set' if has_token else 'missing'}", _C.DIM, enabled=self._color))
+                if not has_token:
+                    self._print(
+                        _style(
+                            "Tip: set a gateway token with --gateway-token or $ABSTRACTGATEWAY_AUTH_TOKEN.",
+                            _C.DIM,
+                            enabled=self._color,
+                        )
+                    )
+            if err_s:
+                self._print(_style(f"Last error: {err_s}", _C.DIM, enabled=self._color))
+            if not enabled:
+                self._print(_style("Enable with: /gpu on", _C.DIM, enabled=self._color))
+            return
+        if arg in ("on", "enable", "enabled", "1", "true"):
+            self._gpu_monitor_enabled = True
+            self._start_gpu_monitor()
+            try:
+                self._ui.request_refresh()
+            except Exception:
+                pass
+            self._print(_style("GPU meter: ON", _C.DIM, enabled=self._color))
+            return
+        if arg in ("off", "disable", "disabled", "0", "false"):
+            self._gpu_monitor_enabled = False
+            self._gpu_utilization_pct = None
+            self._gpu_last_error = None
+            try:
+                self._ui.request_refresh()
+            except Exception:
+                pass
+            self._print(_style("GPU meter: OFF", _C.DIM, enabled=self._color))
+            return
+        self._print(_style("Usage: /gpu [status|on|off]", _C.DIM, enabled=self._color))
+
+    _LINK_RE_MD = re.compile(r"\[[^\]]+\]\((?P<url>[^)\s]+)")
+    _LINK_RE_URL = re.compile(r"(?P<url>https?://[^\s<>()\]]+)")
+
+    def _extract_links(self, text: str) -> List[str]:
+        """Extract URLs (best-effort) from markdown/plain text.
+
+        Returns unique URLs preserving first-seen order.
+        """
+        s = str(text or "")
+        candidates: List[str] = []
+        candidates.extend([m.group("url") for m in self._LINK_RE_MD.finditer(s) if m.group("url")])
+        candidates.extend([m.group("url") for m in self._LINK_RE_URL.finditer(s) if m.group("url")])
+
+        out: List[str] = []
+        seen: set[str] = set()
+        for u in candidates:
+            url = str(u or "").strip()
+            while url and url[-1] in ".,;:)]}":
+                url = url[:-1]
+            if not url.startswith(("http://", "https://")):
+                continue
+            if url in seen:
+                continue
+            seen.add(url)
+            out.append(url)
+        return out
+
+    def _open_url(self, url: str) -> bool:
+        u = str(url or "").strip()
+        if not u.startswith(("http://", "https://")):
+            return False
+        try:
+            import webbrowser
+
+            threading.Thread(target=webbrowser.open, args=(u,), kwargs={"new": 2}, daemon=True).start()
+            return True
+        except Exception:
+            return False
+
+    def _handle_links(self, raw: str) -> None:
+        _ = raw
+        links = list(getattr(self, "_last_answer_links", []) or [])
+        if not links:
+            self._print(_style("No links captured from the last answer.", _C.DIM, enabled=self._color))
+            return
+        self._print(_style("\nLinks (last answer)", _C.CYAN, _C.BOLD, enabled=self._color))
+        self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+        for i, u in enumerate(links, start=1):
+            self._print(f"{i}. {u}")
+
+    def _handle_open(self, raw: str) -> None:
+        arg = str(raw or "").strip()
+        if not arg:
+            self._print(_style("Usage: /open <N|URL>", _C.DIM, enabled=self._color))
+            return
+        if arg.isdigit():
+            idx = int(arg)
+            links = list(getattr(self, "_last_answer_links", []) or [])
+            if idx < 1 or idx > len(links):
+                self._print(_style(f"Invalid link index: {idx}", _C.YELLOW, enabled=self._color))
+                self._print(_style("Try: /links", _C.DIM, enabled=self._color))
+                return
+            url = links[idx - 1]
+        else:
+            url = arg
+
+        ok = self._open_url(url)
+        if not ok:
+            self._print(_style(f"Failed to open: {url}", _C.YELLOW, enabled=self._color))
 
     def _handle_log(self, raw: str) -> None:
         """Show durable logs for the current run.
 
-        `/log runtime` is the AbstractRuntime-centric view (step trace, payloads).
-        `/log provider` is the provider wire view (request sent + response received).
+        `/logs runtime` is the AbstractRuntime-centric view (step trace, payloads).
+        `/logs provider` is the provider wire view (request sent + response received).
 
         Usage:
-          /log runtime [copy] [--last] [--json-only] [--save <path>]
-          /log provider [copy] [--last|--all] [--json-only] [--save <path>]
+          /logs runtime [copy] [--last] [--json-only] [--save <path>]
+          /logs provider [copy] [--last|--all] [--json-only] [--save <path>]
         """
         import shlex
 
@@ -1877,8 +3588,8 @@ class ReactShell:
 
         usage = (
             "Usage:\n"
-            "  /log runtime [copy] [--last] [--json-only] [--save <path>]\n"
-            "  /log provider [copy] [--last|--all] [--json-only] [--save <path>]\n"
+            "  /logs runtime [copy] [--last] [--json-only] [--save <path>]\n"
+            "  /logs provider [copy] [--last|--all] [--json-only] [--save <path>]\n"
         )
         if not parts:
             self._print(_style(usage, _C.DIM, enabled=self._color))
@@ -1895,7 +3606,7 @@ class ReactShell:
             self._handle_log_provider(rest_raw)
             return
 
-        self._print(_style(f"Unknown /log kind: {kind}", _C.YELLOW, enabled=self._color))
+        self._print(_style(f"Unknown /logs kind: {kind}", _C.YELLOW, enabled=self._color))
         self._print(_style(usage, _C.DIM, enabled=self._color))
 
     def _append_to_active_context(self, *, role: str, content: str, metadata: Optional[Dict[str, Any]] = None) -> None:
@@ -2304,6 +4015,122 @@ class ReactShell:
         self._print(_style(f"Review mode set to {status} (max_rounds={self._review_max_rounds}).", _C.DIM, enabled=self._color))
         self._save_config()
 
+    def _handle_config(self, raw: str) -> None:
+        """Configure durable runtime options.
+
+        Usage:
+          /config
+          /config check-plan
+          /config check-plan on|off
+        """
+        text = str(raw or "").strip()
+        if not text:
+            status = "on" if bool(getattr(self, "_check_plan", False)) else "off"
+            self._print(_style("\nConfig", _C.CYAN, _C.BOLD, enabled=self._color))
+            self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+            self._print(f"- check-plan: {status}")
+            self._print(_style("Usage: /config check-plan on|off", _C.DIM, enabled=self._color))
+            return
+
+        parts = text.split()
+        key = str(parts[0] or "").strip().lower()
+        if key in ("check-plan", "check_plan", "checkplan"):
+            if len(parts) < 2:
+                status = "on" if bool(getattr(self, "_check_plan", False)) else "off"
+                self._print(_style(f"check-plan: {status}", _C.DIM, enabled=self._color))
+                return
+
+            value = str(parts[1] or "").strip().lower()
+            if value in ("toggle",):
+                enabled = not bool(getattr(self, "_check_plan", False))
+            elif value in ("on", "true", "1", "yes", "y", "enabled"):
+                enabled = True
+            elif value in ("off", "false", "0", "no", "n", "disabled"):
+                enabled = False
+            else:
+                self._print(_style("Usage: /config check-plan on|off", _C.DIM, enabled=self._color))
+                return
+
+            self._check_plan = bool(enabled)
+            self._save_config()
+
+            rid = self._attached_run_id()
+            if rid is not None:
+                self._sync_tool_prompt_settings_to_run(rid)
+
+            # Invalidate footer cache (small but keeps status reactive).
+            self._status_cache_key = None
+            self._status_cache_text = ""
+
+            status = "on" if self._check_plan else "off"
+            self._print(_style(f"Config set: check-plan={status}", _C.DIM, enabled=self._color))
+            return
+
+        self._print(_style(f"Unknown config key: {key}", _C.YELLOW, enabled=self._color))
+        self._print(_style("Usage: /config check-plan on|off", _C.DIM, enabled=self._color))
+
+    def _handle_files(self, raw: str) -> None:
+        """List pending `@file` attachment chips (files that will be sent with the next prompt)."""
+        if str(raw or "").strip():
+            self._print(_style("Usage: /files", _C.DIM, enabled=self._color))
+            return
+
+        attachments: List[str] = []
+        try:
+            getter = getattr(self._ui, "get_composer_state", None)
+            if callable(getter):
+                state = getter()
+                if isinstance(state, dict) and isinstance(state.get("attachments"), list):
+                    attachments = [str(x) for x in state["attachments"] if isinstance(x, str) and x.strip()]
+        except Exception:
+            attachments = []
+
+        keep_status = "on" if bool(getattr(self, "_files_keep", False)) else "off"
+        self._print(_style("\nFiles", _C.CYAN, _C.BOLD, enabled=self._color))
+        self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+        self._print(_style(f"files-keep: {keep_status}", _C.DIM, enabled=self._color))
+        if not attachments:
+            self._print(_style("(no pending files)", _C.DIM, enabled=self._color))
+            return
+        for rel in attachments:
+            self._print(f"- {rel}")
+        self._print(_style("Tip: click a chip ‘×’ (or Backspace) to remove.", _C.DIM, enabled=self._color))
+
+    def _handle_files_keep(self, raw: str) -> None:
+        """Toggle whether `@file` chips persist across turns."""
+        value = str(raw or "").strip().lower()
+        if not value:
+            status = "ON" if bool(getattr(self, "_files_keep", False)) else "OFF"
+            self._print(_style(f"Files keep: {status}", _C.DIM, enabled=self._color))
+            return
+
+        if value in ("toggle",):
+            enabled = not bool(getattr(self, "_files_keep", False))
+        elif value in ("on", "true", "1", "yes", "y", "enabled"):
+            enabled = True
+        elif value in ("off", "false", "0", "no", "n", "disabled"):
+            enabled = False
+        else:
+            self._print(_style("Usage: /files-keep [on|off]", _C.DIM, enabled=self._color))
+            return
+
+        self._files_keep = bool(enabled)
+        self._save_config()
+
+        try:
+            setter = getattr(self._ui, "set_files_keep", None)
+            if callable(setter):
+                setter(bool(self._files_keep))
+        except Exception:
+            pass
+
+        # Invalidate footer cache (token estimate includes attachments).
+        self._status_cache_key = None
+        self._status_cache_text = ""
+
+        status = "ON" if self._files_keep else "OFF"
+        self._print(_style(f"Files keep set to {status}.", _C.DIM, enabled=self._color))
+
     def _handle_max_tokens(self, raw: str) -> None:
         """Show or set max tokens for context."""
         value = raw.strip()
@@ -2401,6 +4228,16 @@ class ReactShell:
                 self._auto_approve = config["auto_approve"]
             if "plan_mode" in config:
                 self._plan_mode = bool(config["plan_mode"])
+            if "check_plan" in config or "check-plan" in config:
+                raw = config.get("check_plan")
+                if raw is None:
+                    raw = config.get("check-plan")
+                self._check_plan = bool(raw)
+            if "files_keep" in config or "files-keep" in config:
+                raw = config.get("files_keep")
+                if raw is None:
+                    raw = config.get("files-keep")
+                self._files_keep = bool(raw)
             if "review_mode" in config:
                 self._review_mode = bool(config["review_mode"])
             if "review_max_rounds" in config:
@@ -2424,6 +4261,43 @@ class ReactShell:
                     self._tool_executor_server_id = None
                 elif isinstance(raw_exec, str) and raw_exec.strip():
                     self._tool_executor_server_id = raw_exec.strip()
+            if "theme" in config:
+                raw_theme = config.get("theme")
+                try:
+                    t: Optional[Theme] = None
+                    if isinstance(raw_theme, str) and raw_theme.strip():
+                        t = get_theme(raw_theme.strip())
+                    elif isinstance(raw_theme, dict):
+                        name = str(raw_theme.get("name") or raw_theme.get("id") or raw_theme.get("theme") or "").strip()
+                        colors = raw_theme.get("colors") if isinstance(raw_theme.get("colors"), dict) else raw_theme
+                        primary = colors.get("primary") if isinstance(colors, dict) else None
+                        secondary = colors.get("secondary") if isinstance(colors, dict) else None
+                        surface = colors.get("surface") if isinstance(colors, dict) else None
+                        muted = colors.get("muted") if isinstance(colors, dict) else None
+                        if any(isinstance(x, str) and str(x).strip() for x in (primary, secondary, surface, muted)):
+                            t = Theme(
+                                name=name or "custom",
+                                primary=str(primary or ""),
+                                secondary=str(secondary or ""),
+                                surface=str(surface or ""),
+                                muted=str(muted or ""),
+                            ).normalized()
+                        elif name:
+                            t = get_theme(name)
+                    if isinstance(t, Theme):
+                        self._theme = t.normalized()
+                except Exception:
+                    pass
+            if "system_prompt" in config or "system" in config:
+                raw_sys = config.get("system_prompt")
+                if raw_sys is None:
+                    raw_sys = config.get("system")
+                if raw_sys is None:
+                    self._system_prompt_override = None
+                elif isinstance(raw_sys, str) and raw_sys.strip():
+                    self._system_prompt_override = raw_sys.strip()
+                else:
+                    self._system_prompt_override = None
             if "mcp_servers" in config:
                 raw = config.get("mcp_servers")
                 if isinstance(raw, dict):
@@ -2503,18 +4377,48 @@ class ReactShell:
 
             config = dict(existing)
             mcp_servers = getattr(self, "_mcp_servers", None)
+            theme_payload: Any = None
+            try:
+                t = getattr(self, "_theme", None)
+                if isinstance(t, Theme):
+                    tn = t.normalized()
+                    key = str(tn.name or "").strip().lower()
+                    base = BUILTIN_THEMES.get(key) if key else None
+                    if isinstance(base, Theme) and base.normalized() == tn:
+                        theme_payload = base.name
+                    else:
+                        theme_payload = {
+                            "name": tn.name,
+                            "colors": {
+                                "primary": tn.primary,
+                                "secondary": tn.secondary,
+                                "surface": tn.surface,
+                                "muted": tn.muted,
+                            },
+                        }
+            except Exception:
+                theme_payload = None
+            sys_override = getattr(self, "_system_prompt_override", None)
             config.update(
                 {
                     "max_tokens": self._max_tokens,
                     "max_history_messages": getattr(self, "_max_history_messages", -1),
                     "auto_approve": self._auto_approve,
                     "plan_mode": self._plan_mode,
+                    "check_plan": bool(getattr(self, "_check_plan", False)),
+                    "files_keep": bool(getattr(self, "_files_keep", False)),
                     "review_mode": self._review_mode,
                     "review_max_rounds": self._review_max_rounds,
                     "allowed_tools": self._allowed_tools,
                     "tool_prompt_examples": bool(self._tool_prompt_examples),
                     "tool_executor": getattr(self, "_tool_executor_server_id", None),
                     "mcp_servers": dict(mcp_servers or {}) if isinstance(mcp_servers, dict) else {},
+                    "theme": theme_payload,
+                    "system_prompt": (
+                        str(sys_override).strip()
+                        if isinstance(sys_override, str) and str(sys_override).strip()
+                        else None
+                    ),
                 }
             )
             self._config_file.write_text(json.dumps(config, indent=2))
@@ -4069,12 +5973,238 @@ class ReactShell:
         self._print(_style("─" * 60, _C.DIM, enabled=self._color))
         self._print(json.dumps(out, ensure_ascii=False, indent=2, sort_keys=True, default=str))
 
+    def _sync_workspace_policy_to_ui(self) -> None:
+        """Best-effort: keep UI `@file` completion aligned with shell workspace policy."""
+        try:
+            setter = getattr(self._ui, "set_workspace_policy", None)
+            if callable(setter):
+                setter(
+                    workspace_root=self._workspace_root,
+                    mounts=dict(self._workspace_mounts or {}),
+                    blocked_paths=list(self._workspace_blocked_paths or []),
+                )
+        except Exception:
+            pass
+
+    def _handle_whitelist(self, raw: str) -> None:
+        """Whitelist directories for this session as named workspace mounts.
+
+        Usage:
+          /whitelist
+          /whitelist <dir...>
+          /whitelist name=/abs/dir [name2=/abs/dir2 ...]
+
+        Notes:
+        - Mounts are referenced in prompts as: `@<mount>/<path/to/file>`
+        - Blacklist has priority over whitelist.
+        """
+        import re
+        import shlex
+
+        try:
+            parts = shlex.split(raw) if raw else []
+        except ValueError:
+            parts = raw.split() if raw else []
+
+        if not parts:
+            mounts = dict(self._workspace_mounts or {})
+            if not mounts:
+                self._print(_style("No mounts configured. Use /whitelist <dir...>.", _C.DIM, enabled=self._color))
+                return
+            self._print(_style("\nWorkspace mounts", _C.CYAN, _C.BOLD, enabled=self._color))
+            self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+            for name, root in sorted(mounts.items()):
+                self._print(f"- {name}={root}")
+            return
+
+        def _sanitize_mount_name(name: str) -> str:
+            s = re.sub(r"[^a-zA-Z0-9_-]+", "_", str(name or "").strip())
+            s = s.strip("_-")
+            if not s:
+                s = "mount"
+            return s[:32]
+
+        existing = dict(self._workspace_mounts or {})
+        added: list[tuple[str, Path]] = []
+
+        for tok in parts:
+            name: Optional[str] = None
+            path_text = str(tok or "").strip()
+            if not path_text:
+                continue
+            if "=" in path_text:
+                a, b = path_text.split("=", 1)
+                cand_name = a.strip()
+                cand_path = b.strip()
+                if cand_name and re.match(r"^[a-zA-Z0-9_-]{1,32}$", cand_name):
+                    name = cand_name
+                    path_text = cand_path
+
+            if not path_text:
+                continue
+
+            p = Path(path_text).expanduser()
+            try:
+                resolved = p.resolve() if p.is_absolute() else (self._workspace_root / p).resolve()
+            except Exception:
+                self._print(_style(f"Invalid path: {path_text}", _C.YELLOW, enabled=self._color))
+                continue
+            try:
+                if not resolved.exists() or not resolved.is_dir():
+                    self._print(_style(f"Not a directory: {resolved}", _C.YELLOW, enabled=self._color))
+                    continue
+            except Exception:
+                self._print(_style(f"Directory not accessible: {resolved}", _C.YELLOW, enabled=self._color))
+                continue
+
+            # Whitelisting the workspace root is redundant (it's already accessible), and the
+            # default auto-name can shadow a real top-level folder (breaking @file resolution).
+            try:
+                if name is None and resolved.resolve() == self._workspace_root.resolve():
+                    self._print(_style(f"Workspace root already accessible: {resolved}", _C.DIM, enabled=self._color))
+                    continue
+            except Exception:
+                pass
+
+            mount = _sanitize_mount_name(name or resolved.name or "mount")
+
+            # Avoid mounts that shadow an existing workspace-relative path segment.
+            # Example: workspace has `mnemosyne/` and user mounts `/.../workspace` with mount name `mnemosyne`,
+            # then `@mnemosyne/...` resolves against the mount instead of the workspace folder.
+            try:
+                candidate = (self._workspace_root / mount)
+                if candidate.exists():
+                    try:
+                        if candidate.resolve() != resolved.resolve():
+                            mount = _sanitize_mount_name(f"{mount}_mount")
+                    except Exception:
+                        mount = _sanitize_mount_name(f"{mount}_mount")
+            except Exception:
+                pass
+
+            base = mount
+            i = 2
+            while mount in existing and existing.get(mount) != resolved:
+                suffix = f"_{i}"
+                mount = (base[: max(1, 32 - len(suffix))] + suffix)[:32]
+                i += 1
+
+            existing[mount] = resolved
+            try:
+                self._workspace_mount_ignores[mount] = self._AbstractIgnore.for_path(resolved)
+            except Exception:
+                self._workspace_mount_ignores[mount] = None
+            added.append((mount, resolved))
+
+        self._workspace_mounts = existing
+        self._sync_workspace_policy_to_ui()
+
+        rid = self._attached_run_id()
+        if rid is not None:
+            self._sync_tool_prompt_settings_to_run(rid)
+
+        if not added:
+            return
+        self._print(_style("Whitelisted:", _C.DIM, enabled=self._color))
+        for mount, root in added:
+            self._print(_style(f"  {mount}={root}", _C.DIM, enabled=self._color))
+
+    def _handle_blacklist(self, raw: str) -> None:
+        """Blacklist folders/files for this session (overrides whitelist)."""
+        import shlex
+
+        try:
+            parts = shlex.split(raw) if raw else []
+        except ValueError:
+            parts = raw.split() if raw else []
+
+        if not parts:
+            blocked = list(self._workspace_blocked_paths or [])
+            if not blocked:
+                self._print(_style("No blacklist entries.", _C.DIM, enabled=self._color))
+                return
+            self._print(_style("\nWorkspace blacklist", _C.CYAN, _C.BOLD, enabled=self._color))
+            self._print(_style("─" * 60, _C.DIM, enabled=self._color))
+            for p in blocked:
+                self._print(f"- {p}")
+            return
+
+        head = str(parts[0] or "").strip().lower()
+        if head in ("reset", "clear"):
+            self._workspace_blocked_paths = []
+            self._sync_workspace_policy_to_ui()
+            rid = self._attached_run_id()
+            if rid is not None:
+                self._sync_tool_prompt_settings_to_run(rid)
+            self._print(_style("Blacklist cleared.", _C.DIM, enabled=self._color))
+            return
+
+        blocked = list(self._workspace_blocked_paths or [])
+        added: list[Path] = []
+        for tok in parts:
+            text = str(tok or "").strip()
+            if not text:
+                continue
+            p = Path(text).expanduser()
+            if p.is_absolute():
+                try:
+                    resolved = p.resolve()
+                except Exception:
+                    self._print(_style(f"Invalid path: {text}", _C.YELLOW, enabled=self._color))
+                    continue
+            else:
+                norm = normalize_relative_path(text)
+                if not norm:
+                    self._print(_style(f"Invalid path: {text}", _C.YELLOW, enabled=self._color))
+                    continue
+                try:
+                    resolved, _virt, _mount, _root = resolve_workspace_path(
+                        raw_path=norm,
+                        workspace_root=self._workspace_root,
+                        mounts=dict(self._workspace_mounts or {}),
+                    )
+                except Exception:
+                    self._print(_style(f"Invalid path: {text}", _C.YELLOW, enabled=self._color))
+                    continue
+
+            try:
+                resolved = resolved.resolve()
+            except Exception:
+                pass
+
+            # De-dup
+            already = False
+            for cur in blocked:
+                try:
+                    if resolved == cur.resolve():
+                        already = True
+                        break
+                except Exception:
+                    continue
+            if already:
+                continue
+            blocked.append(resolved)
+            added.append(resolved)
+
+        self._workspace_blocked_paths = blocked
+        self._sync_workspace_policy_to_ui()
+
+        rid = self._attached_run_id()
+        if rid is not None:
+            self._sync_tool_prompt_settings_to_run(rid)
+
+        if not added:
+            return
+        self._print(_style("Blacklisted:", _C.DIM, enabled=self._color))
+        for p in added:
+            self._print(_style(f"  {p}", _C.DIM, enabled=self._color))
+
     def _handle_context(self, raw: str) -> None:
         """(Deprecated) Legacy context preview command.
 
         The public `/context` and `/llm` commands were removed in favor of:
-        - `/log runtime`
-        - `/log provider`
+        - `/logs runtime`
+        - `/logs provider`
         """
         import copy
         import shlex
@@ -4092,7 +6222,7 @@ class ReactShell:
             return
 
         copy_to_clipboard = False
-        # Accept `copy` as either a leading or trailing token (UX: "/log runtime ... copy").
+        # Accept `copy` as either a leading or trailing token (UX: "/logs runtime ... copy").
         if parts and str(parts[0] or "").strip().lower() == "copy":
             copy_to_clipboard = True
             parts = parts[1:]
@@ -4112,7 +6242,7 @@ class ReactShell:
             self._print(_style(f"Unknown flag: {p}", _C.YELLOW, enabled=self._color))
             self._print(
                 _style(
-                    "Usage: /log runtime  |  /log provider",
+                    "Usage: /logs runtime  |  /logs provider",
                     _C.DIM,
                     enabled=self._color,
                 )
@@ -4133,7 +6263,7 @@ class ReactShell:
                 "provider": self._provider,
                 "model": self._model,
                 "note": "No active run. This is the current session context that will be included in the next /task.",
-                "tip": "Use /log runtime (or /log provider) to inspect durable LLM/tool call payloads from the last run.",
+                "tip": "Use /logs runtime (or /logs provider) to inspect durable LLM/tool call payloads from the last run.",
                 "session_messages": list(self._agent.session_messages or []),
             }
             if state is not None and hasattr(state, "run_id") and hasattr(state, "status"):
@@ -4453,7 +6583,7 @@ class ReactShell:
         Source of truth: `RunState.vars["_runtime"]["node_traces"]`.
 
         Usage:
-          /log runtime [copy] [--last] [--json-only] [--save <path>]
+          /logs runtime [copy] [--last] [--json-only] [--save <path>]
         """
         import shlex
         import uuid
@@ -4465,7 +6595,7 @@ class ReactShell:
             parts = raw.split() if raw else []
 
         copy_to_clipboard = False
-        # Accept `copy` as either a leading or trailing token (UX: "/log runtime ... copy").
+        # Accept `copy` as either a leading or trailing token (UX: "/logs runtime ... copy").
         if parts and str(parts[0] or "").strip().lower() == "copy":
             copy_to_clipboard = True
             parts = parts[1:]
@@ -4478,7 +6608,7 @@ class ReactShell:
         all_calls = False
         verbatim = False
         save_path: Optional[str] = None
-        usage = "Usage: /log runtime [copy] [--last] [--json-only] [--save <path>]"
+        usage = "Usage: /logs runtime [copy] [--last] [--json-only] [--save <path>]"
         i = 0
         while i < len(parts):
             p = parts[i]
@@ -4809,7 +6939,7 @@ class ReactShell:
         - response: `result.raw_response` (provider JSON response, best-effort preserved)
 
         Usage:
-          /log provider [copy] [--last] [--run] [--json-only] [--save <path>]
+          /logs provider [copy] [--last] [--run] [--json-only] [--save <path>]
         """
         import shlex
         import uuid
@@ -4821,7 +6951,7 @@ class ReactShell:
             parts = raw.split() if raw else []
 
         copy_to_clipboard = False
-        # Accept `copy` as either a leading or trailing token (UX: "/log provider --all copy").
+        # Accept `copy` as either a leading or trailing token (UX: "/logs provider --all copy").
         if parts and str(parts[0] or "").strip().lower() == "copy":
             copy_to_clipboard = True
             parts = parts[1:]
@@ -4834,7 +6964,7 @@ class ReactShell:
         run_only = False
         no_tool_defs = False
         save_path: Optional[str] = None
-        usage = "Usage: /log provider [copy] [--last] [--run] [--json-only] [--no-tool-defs] [--save <path>]"
+        usage = "Usage: /logs provider [copy] [--last] [--run] [--json-only] [--no-tool-defs] [--save <path>]"
 
         i = 0
         while i < len(parts):
@@ -4891,7 +7021,7 @@ class ReactShell:
             if not run_only and isinstance(session_id, str) and session_id.strip() and isinstance(self._runtime.run_store, QueryableRunStore):
                 # Pull a bounded set of runs and filter client-side by session_id.
                 # (QueryableRunStore doesn't expose a session_id filter in v0.1.)
-                # Prefer completeness over speed: /log provider is a debugging tool.
+                # Prefer completeness over speed: /logs provider is a debugging tool.
                 # JsonFileRunStore scans all run_*.json files anyway; a low limit can hide older runs.
                 runs = self._runtime.run_store.list_runs(limit=100000)
                 run_ids = [r.run_id for r in runs if getattr(r, "session_id", None) == session_id]
@@ -5030,7 +7160,7 @@ class ReactShell:
             def _extract_tool_calls(resp_obj: Any) -> list[Any]:
                 """Best-effort tool-call extraction for human-readable logs.
 
-                `/log provider` is intentionally provider-wire oriented, but this line helps
+                `/logs provider` is intentionally provider-wire oriented, but this line helps
                 quickly spot whether the model asked for tools. Not all providers share the
                 OpenAI `choices[0].message.tool_calls` shape (e.g. Anthropic `tool_use` blocks).
                 """
@@ -5289,6 +7419,8 @@ class ReactShell:
             "  /review ...         Toggle Review mode (self-check) [saved]\n"
             "                     - /review [on|off] [max_rounds]\n"
             "                     - /review rounds <N>\n"
+            "  /config ...         Configure runtime options [saved]\n"
+            "                     - /config check-plan [on|off]\n"
             "  /max-tokens [N]     Show or set max tokens (-1 = auto) [saved]\n"
             "  /max-messages [N]   Show or set max history messages (-1 = unlimited) [saved]\n"
             "  /memory             Show MemAct Active Memory (MemAct only)\n"
@@ -5297,12 +7429,26 @@ class ReactShell:
             "  /expand <span>      Expand an archived span (--show, --into-context)\n"
             "  /recall [opts]      Recall spans by time/tags/query (--into-context)\n"
             "  /vars [path]        Inspect run vars (scratchpad, _runtime, ...)\n"
-            "  /log runtime        Show runtime step trace for LLM/tool calls (durable)\n"
-            "                     - /log runtime [copy] [--last] [--json-only] [--save <path>]\n"
-            "  /log provider       Show provider wire request+response (durable)\n"
-            "                     - /log provider [copy] [--last|--all] [--json-only] [--save <path>]\n"
+            "  /whitelist ...      Add workspace mounts for this session\n"
+            "                     - /whitelist <dir...>\n"
+            "                     - /whitelist name=/abs/dir [name2=/abs/dir2 ...]\n"
+            "  /blacklist ...      Block folders/files for this session (overrides whitelist)\n"
+            "                     - /blacklist <path...>\n"
+            "                     - /blacklist reset\n"
+            "  /logs runtime       Show runtime step trace for LLM/tool calls (durable)\n"
+            "                     - /logs runtime [copy] [--last] [--json-only] [--save <path>]\n"
+            "  /logs provider      Show provider wire request+response (durable)\n"
+            "                     - /logs provider [copy] [--last|--all] [--json-only] [--save <path>]\n"
             "  /memorize <note>    Store a durable memory note (tags + provenance)\n"
             "  /mouse              Toggle mouse mode (wheel scroll vs terminal selection)\n"
+            "  /agent [name]       Switch agent (/agent list, /agent reload)\n"
+            "  /theme [name]       Switch UI theme (/theme list, /theme custom ...)\n"
+            "  /files              List pending @file attachments\n"
+            "  /files-keep [on|off] Keep @file attachments across turns [saved]\n"
+            "  /system [text]      Show or set system prompt override [saved]\n"
+            "  /gpu [status|on|off] Toggle host GPU meter (via AbstractGateway)\n"
+            "  /links              List links captured from last answer\n"
+            "  /open <N|URL>       Open a link in your default browser\n"
             "  /flow ...           Run AbstractFlow workflows inside this REPL\n"
             "                     - /flow run <flow_id_or_path> [--verbosity none|default|full] [--key value ...]\n"
             "                     - /flow resume [--verbosity none|default|full] [--wait-until]\n"
@@ -5315,6 +7461,7 @@ class ReactShell:
             "  /resume             Resume the saved/attached run\n"
             "  /pause              Pause the current run (durable)\n"
             "  /cancel             Cancel the current run (durable)\n"
+            "  /conclude [note]    Ask the agent to conclude now (best-effort; no new tools)\n"
             "  /clear              Clear memory and clear the screen\n"
             "  /snapshot save <n>  Save current state as named snapshot\n"
             "  /snapshot load <n>  Load snapshot by name\n"
@@ -5448,6 +7595,16 @@ class ReactShell:
 
         selected = turns[-limit_int:]
 
+        renderer: Optional[TerminalMarkdownRenderer] = None
+        try:
+            renderer = TerminalMarkdownRenderer(
+                color=self._color,
+                theme=getattr(self, "_theme", None),
+                width=self._terminal_width(),
+            )
+        except Exception:
+            renderer = None
+
         self._print(_style(f"\nHistory (last {len(selected)} interaction(s))", _C.CYAN, _C.BOLD, enabled=self._color))
         self._print(_style("─" * 80, _C.DIM, enabled=self._color))
 
@@ -5480,14 +7637,26 @@ class ReactShell:
                     mid = _get_message_id(msg) or f"system_{uuid.uuid4().hex}"
                     self._ui.register_copy_payload(mid, content)
                     self._print(_style("[system]", _C.DIM, enabled=self._color))
-                    self._print(content)
+                    if renderer is not None:
+                        try:
+                            self._print(renderer.render(content))
+                        except Exception:
+                            self._print(content)
+                    else:
+                        self._print(content)
                     self._print(f"[[COPY:{mid}]] {footer}".rstrip())
                     continue
 
                 # Default: assistant/other roles (no role prefix; rely on styling/structure).
                 mid = _get_message_id(msg) or f"assistant_{uuid.uuid4().hex}"
                 self._ui.register_copy_payload(mid, content)
-                self._print(content)
+                if renderer is not None:
+                    try:
+                        self._print(renderer.render(content))
+                    except Exception:
+                        self._print(content)
+                else:
+                    self._print(content)
                 self._print(f"[[COPY:{mid}]] {footer}".rstrip())
 
         self._print(_style("\n" + "─" * 80, _C.DIM, enabled=self._color))
@@ -5688,6 +7857,10 @@ class ReactShell:
         # Reset approval state (clear = full reset)
         self._approve_all_session = False
 
+        # Force status bar recompute (no last-run fallback for token meter).
+        self._status_cache_key = None
+        self._status_cache_text = ""
+
         self._print(_style("Memory cleared. Ready for a fresh start.", _C.GREEN, enabled=self._color))
 
     def _handle_snapshot(self, arg: str) -> None:
@@ -5830,12 +8003,90 @@ class ReactShell:
             runtime_ns = {}
             state.vars["_runtime"] = runtime_ns
         runtime_ns["tool_prompt_examples"] = bool(self._tool_prompt_examples)
+        runtime_ns["check_plan"] = bool(getattr(self, "_check_plan", False))
+        # Apply session system prompt override to new runs (don't clobber an existing run override).
+        sys_override = getattr(self, "_system_prompt_override", None)
+        if (
+            isinstance(sys_override, str)
+            and sys_override.strip()
+            and not (isinstance(runtime_ns.get("system_prompt"), str) and str(runtime_ns.get("system_prompt")).strip())
+        ):
+            runtime_ns["system_prompt"] = sys_override.strip()
+
+        # Workspace policy (tool-call scoping): keep it JSON-safe and stable across runs.
+        #
+        # Notes:
+        # - `workspace_root` applies to relative paths and command working_directory defaults.
+        # - Mount roots are expressed as `workspace_allowed_paths` (absolute paths).
+        # - Blacklist uses `workspace_ignored_paths` (absolute paths) and always has priority.
+        try:
+            if "workspace_root" not in state.vars:
+                state.vars["workspace_root"] = str(self._workspace_root)
+
+            allowed_paths = [str(p) for p in (self._workspace_mounts or {}).values() if isinstance(p, Path)]
+            ignored_paths = [str(p) for p in (self._workspace_blocked_paths or []) if isinstance(p, Path)]
+
+            def _as_list(value: Any) -> List[str]:
+                if value is None:
+                    return []
+                if isinstance(value, list):
+                    return [str(x).strip() for x in value if isinstance(x, (str, int, float, bool)) and str(x).strip()]
+                if isinstance(value, str):
+                    s = value.strip()
+                    if not s:
+                        return []
+                    if s.startswith("["):
+                        try:
+                            parsed = json.loads(s)
+                            if isinstance(parsed, list):
+                                return [str(x).strip() for x in parsed if isinstance(x, str) and str(x).strip()]
+                        except Exception:
+                            pass
+                    return [ln.strip() for ln in s.splitlines() if ln.strip()]
+                return []
+
+            def _merge_unique(existing: Any, extra: List[str]) -> List[str]:
+                base = _as_list(existing)
+                seen: set[str] = set()
+                out: List[str] = []
+                for x in list(base) + list(extra):
+                    if not isinstance(x, str):
+                        continue
+                    s = x.strip()
+                    if not s or s in seen:
+                        continue
+                    seen.add(s)
+                    out.append(s)
+                return out
+
+            if allowed_paths:
+                state.vars["workspace_allowed_paths"] = _merge_unique(
+                    state.vars.get("workspace_allowed_paths") or state.vars.get("workspaceAllowedPaths"),
+                    allowed_paths,
+                )
+                mode_raw = state.vars.get("workspace_access_mode") or state.vars.get("workspaceAccessMode")
+                mode = str(mode_raw or "").strip().lower()
+                if not mode or mode == "workspace_only":
+                    state.vars["workspace_access_mode"] = "workspace_or_allowed"
+            else:
+                # Default to workspace_only when no allowlist is present and caller didn't specify.
+                if "workspace_access_mode" not in state.vars and "workspaceAccessMode" not in state.vars:
+                    state.vars["workspace_access_mode"] = "workspace_only"
+
+            if ignored_paths:
+                state.vars["workspace_ignored_paths"] = _merge_unique(
+                    state.vars.get("workspace_ignored_paths") or state.vars.get("workspaceIgnoredPaths"),
+                    ignored_paths,
+                )
+        except Exception:
+            pass
+
         try:
             self._runtime.run_store.save(state)
         except Exception:
             pass
 
-    def _start(self, task: str) -> None:
+    def _start(self, task: str, *, attachments: Optional[List[Dict[str, Any]]] = None) -> None:
         if self._run_thread_active():
             self._print(_style("A run is already executing. Use /pause or /cancel first.", _C.DIM, enabled=self._color))
             return
@@ -5845,7 +8096,7 @@ class ReactShell:
         self._turn_task = str(task or "").strip() or None
         self._turn_trace = []
         self._turn_started_at = time.perf_counter()
-        run_id = self._agent.start(task, allowed_tools=self._allowed_tools)
+        run_id = self._agent.start(task, allowed_tools=self._allowed_tools, attachments=attachments)
         self._sync_tool_prompt_settings_to_run(run_id)
         self._last_run_id = run_id
         if self._state_file:
@@ -5900,6 +8151,87 @@ class ReactShell:
         self._print(_style(f"Cancel requested (run_id={run_id}).", _C.DIM, enabled=self._color))
         self._reset_repeat_guardrails()
 
+    def _consume_pending_conclude_note(self) -> Optional[str]:
+        try:
+            with self._pending_conclude_lock:
+                note = self._pending_conclude_note
+                self._pending_conclude_note = None
+                return note
+        except Exception:
+            return None
+
+    def _apply_conclude_request(self, run_id: str, note: str) -> None:
+        """Best-effort: push a one-shot 'conclude now' instruction into the ReAct inbox."""
+        rid = str(run_id or "").strip()
+        if not rid:
+            return
+        try:
+            state = self._runtime.get_state(rid)
+        except Exception:
+            return
+        if state is None or not hasattr(state, "vars") or not isinstance(state.vars, dict):
+            return
+
+        runtime_ns = state.vars.get("_runtime")
+        if not isinstance(runtime_ns, dict):
+            runtime_ns = {}
+            state.vars["_runtime"] = runtime_ns
+
+        inbox = runtime_ns.get("inbox")
+        if not isinstance(inbox, list):
+            inbox = []
+            runtime_ns["inbox"] = inbox
+
+        extra = str(note or "").strip()
+        msg = (
+            "User requested: CONCLUDE NOW.\n"
+            "- Provide your best final answer using ONLY the information already gathered in this run.\n"
+            "- Do NOT call tools.\n"
+            "- If information is missing, say what is unknown and list the most useful next steps."
+        )
+        if extra:
+            msg = f"{msg}\n\nUser note:\n{extra}"
+        inbox.append({"role": "system", "content": msg})
+
+        # Stronger guardrail: hide tools from the next model call (ReAct reads these from _runtime).
+        runtime_ns["allowed_tools"] = []
+        runtime_ns["tool_specs"] = []
+
+        try:
+            self._runtime.run_store.save(state)
+        except Exception:
+            pass
+
+        # System prompt changes affect token estimates shown in the footer.
+        self._status_cache_key = None
+        self._status_cache_text = ""
+
+    def _conclude(self, raw: str) -> None:
+        if str(getattr(self, "_agent_kind", "") or "") != "react":
+            self._print(_style("/conclude is currently supported for the ReAct agent only.", _C.DIM, enabled=self._color))
+            return
+        run_id = self._attached_run_id()
+        if run_id is None:
+            self._print(_style("No run loaded. Start a task or /resume first.", _C.DIM, enabled=self._color))
+            return
+
+        note = str(raw or "").strip()
+
+        # If a run is currently executing, queue an interrupt for the background thread
+        # (avoids run_store lost-update races during tick/save).
+        if self._run_thread_active():
+            try:
+                with self._pending_conclude_lock:
+                    self._pending_conclude_note = note
+            except Exception:
+                self._pending_conclude_note = note
+            self._print(_style(f"Conclude requested (run_id={run_id}). Will apply on the next step.", _C.DIM, enabled=self._color))
+            return
+
+        # Otherwise apply immediately to the persisted run state; user can /resume.
+        self._apply_conclude_request(run_id, note)
+        self._print(_style(f"Conclude requested (run_id={run_id}). Type '/resume' to continue.", _C.DIM, enabled=self._color))
+
     def _try_load_state(self) -> None:
         try:
             state = self._agent.load_state(self._state_file)  # type: ignore[arg-type]
@@ -5923,6 +8255,9 @@ class ReactShell:
 
     def _run_loop(self, run_id: str) -> None:
         while True:
+            note = self._consume_pending_conclude_note()
+            if note is not None:
+                self._apply_conclude_request(run_id, note)
             state = self._agent.step()
 
             if state.status == self._RunStatus.COMPLETED:
@@ -5982,6 +8317,8 @@ class ReactShell:
                         self._agent.session_messages = loaded
                     return
                 response = self._prompt_user(wait.prompt or "Please respond:", wait.choices)
+                if response == BLOCKING_PROMPT_CANCEL_TOKEN:
+                    continue
                 state = self._agent.resume(response)
                 continue
 
@@ -6080,6 +8417,8 @@ class ReactShell:
                         if cur_wait.reason == self._WaitReason.USER:
                             self._ui.clear_spinner()
                             response = self._prompt_user(cur_wait.prompt or "Please respond:", cur_wait.choices)
+                            if response == BLOCKING_PROMPT_CANCEL_TOKEN:
+                                continue
                             self._runtime.resume(
                                 workflow=_workflow_for(current_state),
                                 run_id=current_run_id,
@@ -6096,6 +8435,8 @@ class ReactShell:
                             except Exception:
                                 pass
                             response = self._prompt_user(cur_wait.prompt or "Please respond:", cur_wait.choices)
+                            if response == BLOCKING_PROMPT_CANCEL_TOKEN:
+                                continue
                             self._runtime.resume(
                                 workflow=_workflow_for(current_state),
                                 run_id=current_run_id,
@@ -6112,6 +8453,8 @@ class ReactShell:
                             if payload is None:
                                 self._print(_style("\nLeft run waiting (not resumed).", _C.DIM, enabled=self._color))
                                 return
+                            if isinstance(payload, dict) and payload.get("mode") == "cancelled":
+                                continue
                             self._runtime.resume(
                                 workflow=_workflow_for(current_state),
                                 run_id=current_run_id,
@@ -6155,6 +8498,8 @@ class ReactShell:
                 if payload is None:
                     self._print(_style("\nLeft run waiting (not resumed).", _C.DIM, enabled=self._color))
                     return
+                if isinstance(payload, dict) and payload.get("mode") == "cancelled":
+                    continue
 
                 state = self._runtime.resume(
                     workflow=self._agent.workflow,
@@ -6172,6 +8517,8 @@ class ReactShell:
                 except Exception:
                     pass
                 response = self._prompt_user(wait.prompt or "Please respond:", wait.choices)
+                if response == BLOCKING_PROMPT_CANCEL_TOKEN:
+                    continue
                 state = self._runtime.resume(
                     workflow=self._agent.workflow,
                     run_id=run_id,
@@ -6195,6 +8542,8 @@ class ReactShell:
                 self._print(f"  [{i+1}] {c}")
             while True:
                 raw = self._simple_prompt("Choice (number or text): ")
+                if raw == BLOCKING_PROMPT_CANCEL_TOKEN:
+                    return raw
                 if not raw:
                     continue
                 if raw.isdigit():
@@ -6202,7 +8551,8 @@ class ReactShell:
                     if 0 <= idx < len(choices):
                         return str(choices[idx])
                 return raw
-        return self._simple_prompt(prompt + " ")
+        resp = self._simple_prompt(prompt + " ")
+        return resp if resp == BLOCKING_PROMPT_CANCEL_TOKEN else resp.strip()
 
     def _approve_and_execute(self, tool_calls: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
         auto = bool(self._auto_approve or self._approve_all_session)
@@ -6244,9 +8594,12 @@ class ReactShell:
 
                 if not auto and not approve_all:
                     while True:
-                        choice = self._simple_prompt(
+                        choice_raw = self._simple_prompt(
                             f"Approve {name}? [y]es/[n]o/[a]ll/[e]dit/[q]uit: "
-                        ).lower()
+                        ).strip()
+                        if choice_raw == BLOCKING_PROMPT_CANCEL_TOKEN:
+                            return {"mode": "cancelled"}
+                        choice = choice_raw.lower()
                         if choice in ("y", "yes"):
                             break
                         if choice in ("a", "all"):
@@ -6269,6 +8622,8 @@ class ReactShell:
                             return None
                         if choice in ("e", "edit"):
                             edited = self._simple_prompt("New arguments (JSON): ")
+                            if edited == BLOCKING_PROMPT_CANCEL_TOKEN:
+                                return {"mode": "cancelled"}
                             if edited:
                                 try:
                                     new_args = json.loads(edited)
@@ -6290,7 +8645,10 @@ class ReactShell:
 
                 # Additional confirmation for shell execution (skip if auto/approve_all is set)
                 if name == "execute_command" and not auto and not approve_all:
-                    confirm = self._simple_prompt("Type 'run' to execute this command: ").lower()
+                    confirm_raw = self._simple_prompt("Type 'run' to execute this command: ")
+                    if confirm_raw == BLOCKING_PROMPT_CANCEL_TOKEN:
+                        return {"mode": "cancelled"}
+                    confirm = confirm_raw.lower()
                     if confirm != "run":
                         results.append(
                             {