seedcode-cli 7.2.5__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.2.5"
+__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

@@ -150,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 "")
@@ -174,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)),
@@ -324,7 +328,7 @@ class _TaskPresenter:
         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).
@@ -497,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
 
@@ -505,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:
@@ -681,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.
@@ -766,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
@@ -818,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
@@ -866,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
@@ -1120,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/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()

seedcode/commands/palette.py

@@ -1,7 +1,7 @@
 """/palette and /files — the command palette (Ctrl+K) and project search (Ctrl+P).
 
 The palette lists every high-level action (Change Provider, Change Model,
-Settings, History, Doctor, Clear History, About, Theme, Assist Mode, Search
+Settings, History, Doctor, Clear History, About, Theme, Agent Mode, Search
 Projects) as a fuzzy-searchable selector, VS Code style. The chat REPL
 binds Ctrl+K / Ctrl+P to these commands so they open mid-conversation.
 """
@@ -16,7 +16,7 @@ from . import CommandContext, CommandResult, command, dispatch
 
 
 def _actions(ctx: CommandContext) -> list[PaletteAction]:
-    assist_on = ctx.config.agent_mode
+    agent_on = ctx.config.agent_mode
     return [
         PaletteAction("Change Provider", "/provider", detail="switch AI backend"),
         PaletteAction("Change Model", "/model", detail="browse the live catalogue"),
@@ -28,9 +28,9 @@ def _actions(ctx: CommandContext) -> list[PaletteAction]:
         PaletteAction("About", "/about", detail="version and credits"),
         PaletteAction("Theme", "/theme", detail="pick a colour theme (live preview)"),
         PaletteAction(
-            "Assist Mode",
-            f"/assist {'off' if assist_on else 'on'}",
-            detail=f"currently {'on' if assist_on else 'off'}",
+            "Agent Mode",
+            f"/agent {'off' if agent_on else 'on'}",
+            detail=f"currently {'on' if agent_on else 'off'}",
         ),
         PaletteAction("Search Projects", "__files__", detail="fuzzy project file search"),
         PaletteAction("Keyboard Shortcuts", "/shortcuts", detail="key reference"),

seedcode/commands/status.py

@@ -1,7 +1,7 @@
 """/status — the live runtime state of the current session (v7.1.0).
 
 One panel, every value read from real application state: the active provider
-and its backend, the selected model, the current mode (Chat / Assist / Code),
+and its backend, the selected model, the current mode (Chat / Code / Agent),
 the Code Mode session (its state, verified progress and whether a stopped one
 can be resumed), the workspace, the provider connection status, and where
 config and project memory live. Nothing here is hardcoded or fabricated — a
@@ -23,14 +23,15 @@ from . import CommandContext, CommandResult, command
 
 
 def mode_label(config) -> str:
-    """The active mode: Code Mode sharpens Assist, which sharpens Chat.
+    """The active mode label: Chat Mode / Code Mode / Agent Mode.
 
-    Shared by /status, /mode, and /chat so every surface names the mode the
-    same way from the same source of truth.
+    Delegates to the single mode resolver (:mod:`seedcode.core.modes`) so
+    /status, /mode, /chat, the dashboard and the header can never disagree,
+    and the retired Assist Mode can never reappear as a fourth name.
     """
-    if codemode_state().enabled:
-        return "Code Mode"
-    return "Assist Mode" if config.agent_mode else "Chat"
+    from ..core.modes import mode_label as _label
+
+    return _label(config)
 
 
 # Backward-compatible private name.

seedcode/computer/permissions.py

@@ -50,7 +50,7 @@ SENSITIVE_CATEGORIES = frozenset(
     }
 )
 
-# The non-sensitive categories Assist Mode grants up-front in ONE prompt when it
+# The non-sensitive categories Agent Mode grants up-front in ONE prompt when it
 # starts, so the session never re-asks for routine control during a task. These
 # are exactly the categories a normal automation session touches; sensitive
 # categories are deliberately excluded — they always confirm per action.
@@ -84,10 +84,10 @@ def _deny_all(category: str, description: str) -> DesktopGrant:
 
 @dataclass
 class SessionPermissionManager:
-    """Session-wide desktop grants, requested ONCE when Assist Mode starts.
+    """Session-wide desktop grants, requested ONCE when Agent Mode starts.
 
     This is the fix for "asks for permission on every action": instead of
-    prompting lazily the first time each category is touched, Assist Mode calls
+    prompting lazily the first time each category is touched, Agent Mode calls
     :meth:`request` at start-up to grant the whole routine-control set in a
     single dialog. Every :class:`DesktopSession` created for the session
     (the app rebuilds them whenever the permission level changes) consults the
@@ -123,7 +123,7 @@ class SessionPermissionManager:
         return category in self.denied
 
     def reset(self) -> None:
-        """Forget the session decision (Assist Mode turned off)."""
+        """Forget the session decision (Agent Mode turned off)."""
         self.granted.clear()
         self.denied.clear()
         self.requested = False