seedcode-cli 7.1.0__py3-none-any.whl → 8.1.0__py3-none-any.whl

seedcode/__init__.py

@@ -6,7 +6,7 @@ Plant ideas. Grow code.
 # Single source of truth for the application version. Every consumer reads it:
 # the PyPI build (via [tool.hatch.version]), the CLI --version flag, the
 # Windows installer metadata, the GitHub release tag, and the WinGet manifest.
-__version__ = "7.1.0"
+__version__ = "8.1.0"
 __author__ = "Al Shahriar Sowan"
 __publisher__ = "Eagox Studio"
 # Current author/company links, surfaced by /about and the README credits.

seedcode/app.py

@@ -32,7 +32,12 @@ from .core.agent import AgentEngine, strip_tool_blocks
 from .core.chat import ChatEngine, ChatError
 from .core.lifecycle import LifecycleError, lifecycle
 from .core.models import AppConfig
-from .core.providers import PROVIDERS, provider_label, provider_ready
+from .core.providers import (
+    PROVIDERS,
+    provider_label,
+    provider_ready,
+    sync_custom_providers,
+)
 from .core.providers.freemodel import AUTO_MODEL
 from .memory import HistoryStore
 from .tools import PermissionManager, PermissionMode
@@ -145,23 +150,28 @@ def _key_status(config: AppConfig) -> str:
 
 
 def _mode_status(config: AppConfig) -> str:
-    """Menu status for the Code Mode item (ON only when really active)."""
+    """Menu status for the Code Mode item (ON only when really active).
+
+    Code Mode has its own workspace session, so its status must reflect that
+    session alone. Reading ``agent_mode`` here made the item read ON whenever
+    Agent Mode was on, even though no Code Mode workspace was active — a live
+    status that did not match the live state.
+    """
     try:
         from .codemode_state import codemode_state
 
-        if codemode_state().enabled:
-            return "ON"
+        return "ON" if codemode_state().enabled else "OFF"
     except Exception:
-        pass
-    return "ON" if config.agent_mode else "OFF"
+        return "OFF"
 
 
 def _main_menu(config: AppConfig):
     """The interactive main menu; returns an action id or None (exit).
 
-    v6.2.5 reference layout: the six mode/setup actions carry Ctrl+1..Ctrl+6
+    v6.2.5 reference layout: the mode/setup actions carry Ctrl+1..Ctrl+5
     shortcuts that execute the real handlers (no decorative items), followed
-    by the chat/setup actions kept from earlier releases.
+    by the chat/setup actions kept from earlier releases. There are exactly
+    three modes; Assist Mode no longer exists as a menu entry.
     """
     provider = PROVIDERS.get(config.provider)
     badge = badge_for_status(provider.status if provider is not None else "")
@@ -169,10 +179,9 @@ def _main_menu(config: AppConfig):
         [
             MenuItem("Code Mode", "codemode", status=_mode_status(config), shortcut="1"),
             MenuItem("Agent Mode", "agent", shortcut="2"),
-            MenuItem("Assist Mode", "assist", shortcut="3"),
-            MenuItem("Project Memory", "memory", shortcut="4"),
-            MenuItem("Settings", "settings", shortcut="5"),
-            MenuItem("Exit", "exit", shortcut="6"),
+            MenuItem("Project Memory", "memory", shortcut="3"),
+            MenuItem("Settings", "settings", shortcut="4"),
+            MenuItem("Exit", "exit", shortcut="5"),
             MenuItem("Start Chat", "chat", status=_model_status(config), badge=badge),
             MenuItem("Provider", "provider", status=_provider_status(config)),
             MenuItem("API Key", "apikey", status=_key_status(config)),
@@ -310,8 +319,16 @@ class _TaskPresenter:
             return
         if kind == "error":
             self.ui.dim(f"  ✖ {detail.splitlines()[0][:120]}")
+        elif kind == "switching_provider":
+            # A provider request failed and a healthy fallback took over; the
+            # task continues rather than restarting (v7.2.5).
+            self.ui.warning(f"  Switching provider: {detail}")
+            if flow is not None:
+                flow.set_activity("Switching provider")
+        elif kind == "retry":
+            self.ui.dim(f"  {detail}")
         elif kind == "limit":
-            self.ui.warning(f"Assist stopped: {detail}")
+            self.ui.warning(f"Agent Mode stopped: {detail}")
         elif kind == "call" and flow is None:
             # With a task view on screen the step list already shows the tool
             # work; without one, narrate it (the plain/legacy experience).
@@ -384,10 +401,23 @@ class _TaskPresenter:
             self.ui.warning(detail)
         elif kind == "task_failed":
             self.ui.error(detail)
+        elif kind == "task_skipped":
+            # A skipped task is resolved, never verified work (v7.2.5).
+            self.ui.dim(f"  – {detail}")
         elif kind == "final_verify":
             self.ui.dim("  final verification…")
             if flow is not None:
                 flow.set_activity("Verifying the project (tests / build)")
+        elif kind == "reconnect":
+            # The connection dropped; the session is reconnecting and the task
+            # is preserved rather than failed (v7.2.5).
+            self.ui.warning(f"  {detail}")
+            if flow is not None:
+                flow.set_activity("Reconnecting to the provider")
+        elif kind == "reconnected":
+            self.ui.dim(f"  {detail}")
+        elif kind == "network_lost":
+            self.ui.warning(f"Network: {detail}")
         elif kind in ("retry", "continue"):
             self.ui.dim(f"  {detail}")
         if flow is not None and session is not None:
@@ -471,7 +501,7 @@ def agent_presenter(agent: AgentEngine) -> _TaskPresenter | None:
 
 
 def _task_mode_label(config: AppConfig) -> str:
-    """The mode named in a task header (Code Mode sharpens Assist Mode)."""
+    """The mode named in a task header (Chat / Code Mode / Agent Mode)."""
     try:
         from .codemode_state import codemode_state
 
@@ -479,7 +509,9 @@ def _task_mode_label(config: AppConfig) -> str:
             return "Code Mode"
     except Exception:
         pass
-    return "Assist Mode"
+    from .core.modes import active_mode, mode_title
+
+    return mode_title(active_mode(config))
 
 
 def _save_codemode_summary(agent: AgentEngine, text: str, outcome: str) -> None:
@@ -586,7 +618,13 @@ def _handle_codemode(
         if flow is not None:
             flow.set_state("paused")
             flow.stop()
-        ui.warning("Session paused — state saved. Send /resume to continue.")
+        # Surface the real reason (a network pause says so) but keep the
+        # actionable instruction identical for every pause.
+        reason = (session.reason or "").strip()
+        if reason and "connection" in reason.lower():
+            ui.warning(f"{reason}")
+        else:
+            ui.warning("Session paused — state saved. Send /resume to continue.")
         session_mod.set_current_session(session)
         return
 
@@ -620,6 +658,10 @@ def _report_session_summary(ui: UI, session) -> None:
     graph = session.graph
     done, total = graph.progress()
     ui.success(f"Project completed — {done}/{total} tasks verified")
+    skipped = graph.skipped_count()
+    if skipped:
+        # A skipped task is resolved, never counted as verified work.
+        ui.dim(f"  • Skipped: {skipped} task(s) not needed")
     evidence = session.session_evidence
     if evidence.tests:
         # What matters is the final state: the last test run passed.
@@ -645,7 +687,7 @@ def _handle_agent(
     text: str,
     presenter: _TaskPresenter | None = None,
 ) -> None:
-    """Run one full Assist/Code turn (tool loop) and render the final answer.
+    """Run one full Agent/Code turn (tool loop) and render the final answer.
 
     The turn is shown as a compact live task flow whose step states follow real
     engine activity (see :mod:`seedcode.ui.tasks`) — never a fake progress bar.
@@ -730,7 +772,7 @@ def _handle_agent(
 def _make_agent(
     ui: UI, config: AppConfig, presenter: "_TaskPresenter | None" = None
 ) -> AgentEngine:
-    """Build an Assist engine bound to the CWD and the configured permissions."""
+    """Build an Agent Mode engine bound to the CWD and configured permissions."""
     # Lazy import (matching _make_desktop_session): the optional, platform-
     # specific computer package stays out of app.py's top-level import graph.
     from .computer import is_available
@@ -782,7 +824,7 @@ def _make_desktop_session(ui: UI):
 
     The session is bound to the process-wide
     :class:`~seedcode.computer.SessionPermissionManager` so a permission the
-    user granted once at ``/assist on`` keeps holding even though this gate is
+    user granted once at ``/agent on`` keeps holding even though this gate is
     rebuilt whenever the permission level changes.
     """
     from .computer import DesktopGrant, DesktopSession, session_permissions
@@ -830,14 +872,14 @@ def _chat_loop(
 ) -> None:
     """Interactive chat until /exit (returns to the main menu).
 
-    Only an explicit exit leaves here: a finished task (Code Mode, Assist
-    Mode, Agent Mode or a plain chat turn) returns to the prompt with
+    Only an explicit exit leaves here: a finished task (Code Mode, Agent
+    Mode or a plain chat turn) returns to the prompt with
     ``Ready for next task.`` and the session keeps running.
     """
     ctx = CommandContext(ui=ui, config=config, engine=engine)
     ui.dim(INPUT_HINT)
 
-    # The Assist engine is built lazily on the first assist-mode turn and
+    # The Agent engine is built lazily on the first agent-mode turn and
     # rebuilt when the permission or desktop mode changes (its system
     # prompt and permission gates reflect both). The presenter that owns the
     # live step view lives for the whole chat session, so each turn can bind
@@ -1007,6 +1049,9 @@ def run(ui: UI) -> None:
     interactive menu remains available via /exit for provider/model/settings.
     """
     config = load_config()
+    # Register the saved custom providers before anything resolves a provider
+    # id (v7.2.5): the registry must reflect config.json from the first turn.
+    sync_custom_providers(config)
     set_active_theme(config.theme)
     ui.apply_theme(config.theme)
     ui.banner(config)
@@ -1017,8 +1062,15 @@ def run(ui: UI) -> None:
         config.is_configured(),
     )
 
+    def presenter_on_event(kind: str, detail: str) -> None:
+        """Surface provider retry/failover on the plain chat prompt (v7.2.5)."""
+        if kind == "switching_provider":
+            ui.warning(f"Switching provider: {detail}")
+        elif kind == "retry":
+            ui.dim(f"  {detail}")
+
     active_backend = config.provider
-    engine = ChatEngine(config)
+    engine = ChatEngine(config, on_event=presenter_on_event)
     history = HistoryStore(provider_id=active_backend)
     chat_session = _make_chat_session(ui)
 
@@ -1031,7 +1083,7 @@ def run(ui: UI) -> None:
             if config.provider != active_backend:
                 # Guided setup switched providers: rebuild the backend state.
                 active_backend = config.provider
-                engine = ChatEngine(config)
+                engine = ChatEngine(config, on_event=presenter_on_event)
                 history = HistoryStore(provider_id=active_backend)
             _chat_loop(ui, config, engine, history, chat_session)
         else:
@@ -1048,7 +1100,7 @@ def run(ui: UI) -> None:
             # backend/context and the new provider's own history store.
             _log.info("backend switched: %s -> %s", active_backend, config.provider)
             active_backend = config.provider
-            engine = ChatEngine(config)
+            engine = ChatEngine(config, on_event=presenter_on_event)
             history = HistoryStore(provider_id=active_backend)
 
         try:
@@ -1074,8 +1126,6 @@ def run(ui: UI) -> None:
                 _dispatch_command(ui, config, engine, "/codemode on")
             elif choice == "agent":
                 _dispatch_command(ui, config, engine, "/agent on")
-            elif choice == "assist":
-                _dispatch_command(ui, config, engine, "/assist on")
             elif choice == "memory":
                 _dispatch_command(ui, config, engine, "/codemode status")
             elif choice == "settings":

seedcode/branding.py

@@ -8,10 +8,11 @@ the exact palette so every surface renders identical art:
   bitmaps, the canonical ``assets/logo.png`` and the preview render
 * the installer wizard and the Windows taskbar/Explorer surfaces
 
-v6.2.5 note: the interactive CLI no longer renders any ASCII art. The mark
-is a packaging/desktop asset only (:mod:`seedcode.ui.dashboard` renders a
-borderless text header with no logo), so this module is not imported by the
-terminal UI at all.
+v7.2.5 note: this module stays a packaging/desktop asset. The terminal UI
+renders its own branding from :data:`seedcode.ui.dashboard.LOGO_LINES` (the
+exact ANSI wordmark, with a text fallback on narrow or non-Unicode consoles),
+so no terminal surface imports this module and the pixel-art mark never costs
+anything at startup.
 
 Stdlib only (struct/zlib): safe to import from anywhere in the package,
 costs nothing at startup, and keeps the brand byte-reproducible.

seedcode/codemode_state.py

@@ -1,6 +1,6 @@
 """Code Mode state (v6.2.0): workspace-aware coding agent session state.
 
-Code Mode is Assist Mode sharpened for the current project:
+Code Mode is the workspace-aware coding mode for the current project:
 
 * the CWD at ``/codemode on`` becomes the *workspace* root;
 * ``.seedcode/`` project memory is ensured and the index refreshed

seedcode/commands/agent.py

@@ -1,6 +1,8 @@
-"""Legacy commands: /agent and /permission.
+"""Agent Mode commands: /agent and /permission (v8.1.0).
 
-The old Agent Mode was merged into Assist Mode — /agent now routes there.
+/agent is the primary route into Agent Mode — the single general-purpose
+execution mode that the retired Assist Mode folded into. /assist and
+/desktop remain accepted aliases so an existing habit keeps working.
 /permission keeps its dedicated interactive picker; /index and /tools stay
 as inspection commands.
 """
@@ -15,7 +17,7 @@ from . import CommandContext, CommandResult, command, show_session_bar
 from .assist import disable_assist, enable_assist
 
 
-@command("agent", "Legacy alias for Assist Mode. Usage: /agent [on|off]")
+@command("agent", "Select Agent Mode (general-purpose execution). Usage: /agent [on|off]")
 def _agent(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip().lower()
     if raw in ("on", "off"):
@@ -27,8 +29,6 @@ def _agent(ctx: CommandContext, arg: str) -> CommandResult:
         ctx.ui.dim("Expected: /agent on|off")
         return CommandResult()
 
-    # Agent Mode was merged into Assist Mode — route there transparently.
-    ctx.ui.dim("(/agent is now Assist Mode)")
     if enable:
         enable_assist(ctx.ui, ctx.config)
     else:
@@ -39,7 +39,7 @@ def _agent(ctx: CommandContext, arg: str) -> CommandResult:
 
 @command(
     "permission",
-    "Show or set the Assist permission mode",
+    "Show or set the tool permission level",
     aliases=("perm", "permissions"),
 )
 def _permission(ctx: CommandContext, arg: str) -> CommandResult:
@@ -85,7 +85,7 @@ def _index(ctx: CommandContext, arg: str) -> CommandResult:
     return CommandResult()
 
 
-@command("tools", "List the tools available in Assist Mode")
+@command("tools", "List the tools available to the agent modes")
 def _tools(ctx: CommandContext, arg: str) -> CommandResult:
     from ..ui.layout import columns_grid
 
@@ -95,6 +95,6 @@ def _tools(ctx: CommandContext, arg: str) -> CommandResult:
         kind = "changes files/system" if tool.mutates else "read-only"
         rows.append((name, f"{tool.description}  ({kind})"))
     ctx.ui.panel(
-        columns_grid(rows, ("seed.primary", "seed.text")), title="Assist Tools"
+        columns_grid(rows, ("seed.primary", "seed.text")), title="Agent Tools"
     )
     return CommandResult()

seedcode/commands/assist.py

@@ -1,12 +1,14 @@
-"""Assist Mode: unified AI + computer control.
+"""Agent Mode: unified AI + tool/computer execution (v8.1.0).
 
-/assist on  — enables the full capability set (AI, filesystem, terminal,
-              git, browser, keyboard, mouse, windows, vision, OCR, desktop
-              automation).
-/assist off — back to plain chat.
+/agent on   — selects Agent Mode: the full capability set (AI, filesystem,
+              terminal, git, browser, keyboard, mouse, windows, vision, OCR,
+              desktop automation).
+/agent off  — back to plain Chat Mode.
 
-Assist Mode is the ONLY automation mode Seed Code exposes. The old Agent
-and Desktop modes were merged into it; their commands now route here.
+Agent Mode is the single general-purpose execution mode. The retired Assist
+Mode is this mode under its old name: ``/assist`` and ``/desktop`` still work
+and route here, but they never create a fourth mode. Code Mode is the
+workspace-aware coding agent (see :mod:`seedcode.commands.codemode`).
 """
 
 from __future__ import annotations
@@ -18,7 +20,7 @@ from ..config import save_config
 from ..tools import TOOL_REGISTRY, PermissionMode
 from . import CommandContext, CommandResult, command, show_session_bar
 
-# The Assist capability set, in display order. Desktop-engine rows are
+# The Agent Mode capability set, in display order. Desktop-engine rows are
 # marked so they can be dimmed when the Computer Engine is unavailable.
 _CAPABILITIES: tuple[tuple[str, str, bool], ...] = (
     ("AI", "Chat, reasoning, and code generation", False),
@@ -35,7 +37,7 @@ _CAPABILITIES: tuple[tuple[str, str, bool], ...] = (
 )
 
 
-@command("assist", "Enable/disable Assist Mode (unified AI + computer control)")
+@command("assist", "Legacy alias for Agent Mode. Usage: /assist [on|off]")
 def _assist(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip().lower()
     if raw in ("on", "off"):
@@ -46,7 +48,7 @@ def _assist(ctx: CommandContext, arg: str) -> CommandResult:
         return CommandResult()
     else:
         ctx.ui.warning("[Command Error] Invalid syntax.")
-        ctx.ui.dim("Expected: /assist on|off")
+        ctx.ui.dim("Expected: /agent on|off (or /assist on|off)")
         return CommandResult()
 
     if enable:
@@ -58,7 +60,7 @@ def _assist(ctx: CommandContext, arg: str) -> CommandResult:
 
 
 def capability_table(desktop_ok: bool) -> Table:
-    """The Assist capability list (✓ rows; unavailable rows dim).
+    """The Agent Mode capability list (✓ rows; unavailable rows dim).
 
     OCR is probed independently of the rest of the desktop stack: it needs a
     native engine the Python packages do not supply, so marking it available
@@ -91,12 +93,13 @@ def _ocr_available() -> bool:
 
 
 def enable_assist(ui, config) -> None:
-    """Enable Assist Mode: the full capability set in one switch."""
-    config.agent_mode = True
+    """Select Agent Mode: the full capability set in one switch."""
+    config.mode = "agent"
 
-    # Desktop capabilities require the Computer Engine. When available, Assist
-    # runs at the ``desktop`` level so the AI can drive the computer; otherwise
-    # it stays at ``workspace`` (AI + filesystem + terminal + git still work).
+    # Desktop capabilities require the Computer Engine. When available, Agent
+    # Mode runs at the ``desktop`` level so the AI can drive the computer;
+    # otherwise it stays at ``workspace`` (AI + filesystem + terminal + git
+    # still work).
     desktop_ok, desktop_reason = is_available()
     config.permission_mode = (
         PermissionMode.DESKTOP.value_str if desktop_ok
@@ -104,9 +107,9 @@ def enable_assist(ui, config) -> None:
     )
     save_config(config)
 
-    ui.success("Assist Mode ON")
+    ui.success("Agent Mode ON")
     ui.blank()
-    ui.panel(capability_table(desktop_ok), title="Assist Mode")
+    ui.panel(capability_table(desktop_ok), title="Agent Mode")
     if not desktop_ok:
         ui.dim(f"Desktop capabilities unavailable: {desktop_reason}")
     ui.blank()
@@ -143,14 +146,14 @@ def request_session_permissions(ui) -> bool:
         f"  • {CATEGORY_LABELS.get(c, c)}" for c in SESSION_GRANT_CATEGORIES
     )
     description = (
-        "Grant these for this session so Assist doesn't interrupt every step:\n"
+        "Grant these for this session so Agent Mode doesn't interrupt every step:\n"
         f"{wanted}\n"
         "Sensitive actions (registry writes, passwords, system power, deletions, "
         "purchases) will still ask each time."
     )
 
     try:
-        answer = ui.confirm_desktop("Assist Mode session permissions", description)
+        answer = ui.confirm_desktop("Agent Mode session permissions", description)
     except Exception:
         # No interactive prompt available (headless/non-TTY): leave the
         # per-action flow in place rather than silently granting anything.
@@ -161,25 +164,27 @@ def request_session_permissions(ui) -> bool:
         session.request(SESSION_GRANT_CATEGORIES, allow=True)
         ui.dim("Desktop control granted for this session — you won't be asked again.")
     else:
-        ui.dim("Declined: Assist will ask before each desktop action.")
+        ui.dim("Declined: Agent Mode will ask before each desktop action.")
     return allowed
 
 
 def disable_assist(ui, config) -> None:
-    """Disable Assist Mode: back to plain chat."""
+    """Leave Agent Mode: back to plain Chat."""
     from ..computer.permissions import session_permissions
 
-    config.agent_mode = False
+    config.mode = "chat"
     # Drop back to the safe editing level (removes desktop capability).
     config.permission_mode = PermissionMode.WORKSPACE.value_str
     save_config(config)
-    # Forget the session-wide desktop grant: turning Assist back on asks again.
+    # Forget the session-wide desktop grant: turning Agent Mode back on asks again.
     session_permissions().reset()
-    ui.success("Assist Mode OFF — back to plain chat")
+    ui.success("Agent Mode OFF — back to plain chat")
 
 
 def _show_status(ctx: CommandContext) -> None:
-    """Show current Assist Mode status."""
+    """Show current Agent Mode status."""
+    from ..core.modes import active_mode, mode_title
+
     on = ctx.config.agent_mode
     desktop_ok, desktop_reason = is_available()
 
@@ -188,8 +193,8 @@ def _show_status(ctx: CommandContext) -> None:
     table.add_column()
 
     state = "[seed.accent]ON[/seed.accent]" if on else "[seed.dim]OFF[/seed.dim]"
-    table.add_row("Assist Mode", state)
-    table.add_row("Mode", "Assist" if on else "Chat")
+    table.add_row("Agent Mode", state)
+    table.add_row("Mode", mode_title(active_mode(ctx.config)))
     if not desktop_ok:
         table.add_row("Desktop", f"Unavailable: {desktop_reason}")
     table.add_row("Permission", ctx.config.permission_mode.replace("_", " ").title())
@@ -198,6 +203,6 @@ def _show_status(ctx: CommandContext) -> None:
     desktop_tools = [n for n, t in TOOL_REGISTRY.items() if t.group == "desktop"]
     table.add_row("Available tools", f"{len(core_tools)} core, {len(desktop_tools)} desktop")
 
-    ctx.ui.panel(table, title="Assist Mode")
+    ctx.ui.panel(table, title="Agent Mode")
     ctx.ui.blank()
-    ctx.ui.dim("Toggle with: /assist on | /assist off")
+    ctx.ui.dim("Toggle with: /agent on | /agent off (alias: /assist)")

seedcode/commands/chat.py

@@ -1,7 +1,7 @@
 """/chat — explicit Chat Mode (plain conversation, no tools).
 
 /chat      — show the current mode.
-/chat on   — leave Assist/Code Mode and return to plain Chat: the AI answers
+/chat on   — leave Code/Agent Mode and return to plain Chat: the AI answers
              with text only and never touches the filesystem or terminal.
 
 Chat Mode is the default runtime mode; this command exists so a user can
@@ -19,7 +19,7 @@ def _chat(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip().lower()
     if raw in ("", "status"):
         ctx.ui.info(f"Mode: {mode_label(ctx.config)}")
-        ctx.ui.dim("Switch with: /chat on · /assist on · /codemode on (or /mode chat|assist|code)")
+        ctx.ui.dim("Switch with: /chat on · /agent on · /codemode on (or /mode chat|code|agent)")
         return CommandResult()
 
     if raw != "on":

seedcode/commands/codemode.py

@@ -57,13 +57,13 @@ def _enable_codemode(ctx: CommandContext) -> None:
     state = codemode_state()
     workspace = state.workspace  # already set? keep it (re-enable same project)
 
-    # Agent mode is the engine Code Mode sharpens; turn it on when off.
+    # Agent Mode is the engine Code Mode sharpens; turn it on when off.
     if not config.agent_mode:
         from .assist import enable_assist
 
         enable_assist(ctx.ui, config)
-    # Assist prefers the desktop level when the engine exists; Code Mode is a
-    # *coding* workflow, so keep the editing level (workspace) unless the user
+    # Agent Mode prefers the desktop level when the engine exists; Code Mode is
+    # a *coding* workflow, so keep the editing level (workspace) unless the user
     # had already chosen something stronger.
     if PermissionMode.parse(config.permission_mode) == PermissionMode.DESKTOP:
         config.permission_mode = PermissionMode.WORKSPACE.value_str

seedcode/commands/desktop.py

@@ -1,9 +1,9 @@
-"""Desktop-related commands: /desktop (legacy → Assist), /computer,
+"""Desktop-related commands: /desktop (legacy → Agent Mode), /computer,
 /screenshot, /windows.
 
-The old Desktop Mode was merged into Assist Mode — /desktop now routes
+The old Desktop Mode was merged into Agent Mode — /desktop now routes
 there. /computer shows engine status; /screenshot and /windows work
-immediately (no Assist turn needed) so the user can sanity-check the
+immediately (no Agent Mode turn needed) so the user can sanity-check the
 engine by hand.
 """
 
@@ -16,19 +16,19 @@ from . import CommandContext, CommandResult, command, show_session_bar
 from .assist import disable_assist, enable_assist
 
 
-@command("desktop", "Legacy alias for Assist Mode. Usage: /desktop [on|off]")
+@command("desktop", "Legacy alias for Agent Mode. Usage: /desktop [on|off]")
 def _desktop(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip().lower()
     if raw in ("on", "off"):
         enable = raw == "on"
     elif not raw:
-        enable = not ctx.config.agent_mode  # bare /desktop toggles Assist
+        enable = not ctx.config.agent_mode  # bare /desktop toggles Agent Mode
     else:
         ctx.ui.warning("Usage: /desktop [on|off]")
         return CommandResult()
 
-    # Desktop Mode was merged into Assist Mode — route there transparently.
-    ctx.ui.dim("(/desktop is now Assist Mode)")
+    # Desktop Mode was merged into Agent Mode — route there transparently.
+    ctx.ui.dim("(/desktop is now Agent Mode)")
     if enable:
         enable_assist(ctx.ui, ctx.config)
     else:
@@ -44,7 +44,7 @@ def _computer(ctx: CommandContext, arg: str) -> CommandResult:
     table = Table.grid(padding=(0, 3))
     table.add_column(style="seed.dim", justify="right", no_wrap=True)
     table.add_column(style="seed.text")
-    table.add_row("Mode", "Assist" if ctx.config.agent_mode else "Chat  (/assist on)")
+    table.add_row("Mode", "Agent" if ctx.config.agent_mode else "Chat  (/agent on)")
     table.add_row("Engine", reason if not ok else "Available")
     missing = missing_packages()
     if missing:

seedcode/commands/mode.py

@@ -1,52 +1,55 @@
-"""/mode — one generic switcher for the runtime modes.
+"""/mode — the generic switcher for the three canonical modes (v8.1.0).
 
 /mode           — show the current mode.
 /mode chat      — plain conversation (no tools).
-/mode assist    — the unified AI + tools mode (filesystem, terminal, git, ...).
-/mode code      — Assist sharpened for the current workspace (Code Mode).
-/mode agent     — legacy alias of assist.
+/mode code      — the workspace coding agent (Code Mode).
+/mode agent     — general-purpose execution (Agent Mode).
 
-The individual commands (/chat, /assist, /codemode) remain the direct routes;
+``assist`` is accepted as an input alias and resolves to Agent Mode — the
+retired Assist Mode is Agent Mode now, so no fourth mode can be selected.
+
+The individual commands (/chat, /codemode, /agent) remain the direct routes;
 this command is the single entry point that understands all of them.
 """
 
 from __future__ import annotations
 
+from ..core.modes import MODE_DESCRIPTIONS, Mode, active_mode, mode_title, parse_mode
 from . import CommandContext, CommandResult, command, show_session_bar
 from .status import mode_label
 
 
-@command("mode", "Show or switch the runtime mode. Usage: /mode [chat|assist|code|agent]")
+@command("mode", "Show or switch the runtime mode. Usage: /mode [chat|code|agent]")
 def _mode(ctx: CommandContext, arg: str) -> CommandResult:
     raw = arg.strip().lower()
 
     if not raw:
         ctx.ui.info(f"Mode: {mode_label(ctx.config)}")
-        ctx.ui.dim("Switch with: /mode chat|assist|code|agent")
+        ctx.ui.dim("Switch with: /mode chat|code|agent")
         return CommandResult()
 
-    if raw == "chat":
+    mode = parse_mode(raw, default=Mode.CHAT)
+    if raw not in ("chat", "code", "agent", "assist", "codemode"):
+        ctx.ui.warning("[Command Error] Invalid syntax.")
+        ctx.ui.dim("Expected: /mode chat|code|agent")
+        return CommandResult()
+
+    if raw == "assist":
+        ctx.ui.dim("(Assist Mode is Agent Mode now — selecting Agent Mode)")
+
+    if mode is Mode.CHAT:
         from .chat import _enter_chat
 
         _enter_chat(ctx)
-    elif raw == "assist":
-        from .assist import enable_assist
-
-        enable_assist(ctx.ui, ctx.config)
-    elif raw == "code":
+    elif mode is Mode.CODE:
         from .codemode import _enable_codemode
 
         _enable_codemode(ctx)
-    elif raw == "agent":
-        # Agent Mode merged into Assist Mode; keep the name working.
+    else:  # Mode.AGENT
         from .assist import enable_assist
 
         enable_assist(ctx.ui, ctx.config)
-        ctx.ui.dim("(Agent Mode is Assist Mode now — same engine, same tools)")
-    else:
-        ctx.ui.warning("[Command Error] Invalid syntax.")
-        ctx.ui.dim("Expected: /mode chat|assist|code|agent")
-        return CommandResult()
 
+    ctx.ui.dim(f"Mode: {mode_title(active_mode(ctx.config))} — {MODE_DESCRIPTIONS[mode]}")
     show_session_bar(ctx.ui, ctx.config)
     return CommandResult()