agent-devkit 0.3.1 → 0.3.2

package/README.md

@@ -30,7 +30,7 @@ agent doctor
 Expected version for this release:
 
 ```text
-agent 0.3.1
+agent 0.3.2
 ```
 
 ## Quick Start
@@ -45,10 +45,13 @@ agent llm list
 agent commands list
 ```
 
-Agent DevKit `v0.3.1` also includes the embedded Qwen2.5-0.5B mini-brain
+Agent DevKit `v0.3.2` includes the embedded Qwen2.5-0.5B mini-brain
 contract for local bootstrap conversations without Ollama, Claude, Codex or API
 keys. The npm package stays small; `agent setup mini-brain --yes` downloads the
 GGUF into `.agent-devkit/models` after explicit opt-in.
+When you rename the local agent, Agent DevKit now creates a matching command
+alias under `.agent-devkit/bin` and can add that directory to PATH with
+`agent alias path --yes`.
 The `v0.3.0` deterministic runtime discovery and integration commands remain
 available:
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-devkit",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "description": "Agent DevKit CLI runtime for specialist AI agents, capabilities and provider-aware automations.",
   "type": "module",
   "license": "MIT",

package/runtime/cli/aikit/__init__.py

@@ -1,3 +1,3 @@
 """Public CLI implementation for AI DevKit."""
 
-__version__ = "0.3.1"
+__version__ = "0.3.2"

package/runtime/cli/aikit/aliases.py

@@ -3,9 +3,11 @@
 from __future__ import annotations
 
 import json
+import os
 import re
 import shutil
 import sys
+import unicodedata
 from pathlib import Path
 from typing import Any
 
@@ -14,6 +16,8 @@ from cli.aikit.app_home import app_home, ensure_app_home
 
 ALIAS_PATTERN = re.compile(r"^[A-Za-z][A-Za-z0-9_-]{1,63}$")
 RESERVED_ALIASES = {"agent", "aikit", "ai-devkit", "python", "python3"}
+SHELL_BLOCK_BEGIN = "# >>> agent-devkit aliases >>>"
+SHELL_BLOCK_END = "# <<< agent-devkit aliases <<<"
 
 
 def aliases_config_path() -> Path:
@@ -84,6 +88,38 @@ def add_alias(name: str, *, force: bool = False) -> dict[str, Any]:
     return payload
 
 
+def ensure_alias_for_agent_name(agent_name: str, *, force: bool = False) -> dict[str, Any]:
+    suggested = suggest_alias_name(agent_name)
+    payload: dict[str, Any] = {
+        "kind": "alias",
+        "requested_name": agent_name,
+        "suggested_name": suggested,
+        "created": False,
+    }
+    if not suggested:
+        return {
+            **payload,
+            "status": "invalid",
+            "message": "Agent name cannot be converted to a safe command alias.",
+            "path_status": alias_path_status(),
+        }
+    try:
+        added = add_alias(suggested, force=force)
+    except ValueError as exc:
+        return {
+            **payload,
+            "name": suggested,
+            "status": "blocked",
+            "message": str(exc),
+            "path_status": alias_path_status(suggested),
+        }
+    added["created"] = True
+    added["requested_name"] = agent_name
+    added["suggested_name"] = suggested
+    added["path_status"] = alias_path_status(suggested)
+    return added
+
+
 def remove_alias(name: str) -> dict[str, Any]:
     alias = validate_alias_name(name)
     config = load_aliases()
@@ -138,6 +174,7 @@ def alias_payload(alias: str, item: dict[str, Any]) -> dict[str, Any]:
         "cmd_path": str(aliases_bin_dir() / f"{alias}.cmd"),
         "ps1_path": str(aliases_bin_dir() / f"{alias}.ps1"),
         "created_by": item.get("created_by"),
+        "path_status": alias_path_status(alias),
     }
 
 
@@ -194,3 +231,147 @@ def alias_executable_path(alias: str) -> Path:
 
 def alias_paths(alias: str) -> list[Path]:
     return [alias_executable_path(alias), aliases_bin_dir() / f"{alias}.cmd", aliases_bin_dir() / f"{alias}.ps1"]
+
+
+def suggest_alias_name(agent_name: str) -> str | None:
+    cleaned = " ".join(str(agent_name or "").split()).strip()
+    if not cleaned:
+        return None
+    try:
+        return validate_alias_name(cleaned)
+    except ValueError:
+        pass
+    ascii_name = unicodedata.normalize("NFKD", cleaned).encode("ascii", "ignore").decode("ascii")
+    alias = re.sub(r"[^A-Za-z0-9_-]+", "-", ascii_name).strip("-_")
+    if alias and not alias[0].isalpha():
+        alias = f"agent-{alias}"
+    if len(alias) == 1:
+        alias = f"{alias}-agent"
+    alias = alias[:64].strip("-_")
+    if not alias:
+        return None
+    try:
+        return validate_alias_name(alias)
+    except ValueError:
+        return None
+
+
+def alias_path_status(alias: str | None = None) -> dict[str, Any]:
+    bin_dir = aliases_bin_dir()
+    path_entries = os.environ.get("PATH", "").split(os.pathsep) if os.environ.get("PATH") else []
+    bin_dir_in_path = any(paths_equal(Path(entry), bin_dir) for entry in path_entries if entry)
+    found = shutil.which(alias) if alias else None
+    available = False
+    if alias and found:
+        try:
+            available = Path(found).resolve() in {path.resolve() for path in alias_paths(alias)}
+        except OSError:
+            available = False
+    plan = alias_path_setup_plan()
+    return {
+        "bin_dir": str(bin_dir),
+        "bin_dir_in_path": bin_dir_in_path,
+        "alias_available": available,
+        "found": found,
+        "setup_required": not bin_dir_in_path,
+        "setup": plan,
+    }
+
+
+def paths_equal(left: Path, right: Path) -> bool:
+    try:
+        return left.expanduser().resolve() == right.expanduser().resolve()
+    except OSError:
+        return left.expanduser() == right.expanduser()
+
+
+def alias_path_setup_plan() -> dict[str, Any]:
+    bin_dir = aliases_bin_dir()
+    if os.name == "nt":
+        return {
+            "platform": "windows",
+            "target": "user PATH",
+            "command": f'agent alias path --yes',
+            "description": f"Add {bin_dir} to the current user's PATH.",
+        }
+    profile = detect_shell_profile()
+    return {
+        "platform": "posix",
+        "target": str(profile),
+        "command": "agent alias path --yes",
+        "description": f"Add {bin_dir} to PATH for future shell sessions.",
+    }
+
+
+def setup_alias_path(*, yes: bool = False) -> dict[str, Any]:
+    status = alias_path_status()
+    payload: dict[str, Any] = {
+        "kind": "alias-path",
+        "bin_dir": status["bin_dir"],
+        "path_status": status,
+        "executed": False,
+    }
+    if not status["setup_required"]:
+        return {**payload, "status": "ok", "message": "Agent DevKit alias bin directory is already on PATH."}
+    if not yes:
+        return {
+            **payload,
+            "status": "needs-confirmation",
+            "message": "Run `agent alias path --yes` to make configured aliases available as shell commands.",
+        }
+    if os.name == "nt":
+        return install_windows_user_path(payload)
+    return install_posix_shell_path(payload)
+
+
+def install_posix_shell_path(payload: dict[str, Any]) -> dict[str, Any]:
+    profile = detect_shell_profile()
+    bin_dir = aliases_bin_dir()
+    profile.parent.mkdir(parents=True, exist_ok=True)
+    current = profile.read_text(encoding="utf-8") if profile.exists() else ""
+    export_line = f'export PATH="{bin_dir}:$PATH"'
+    block = f"\n{SHELL_BLOCK_BEGIN}\n{export_line}\n{SHELL_BLOCK_END}\n"
+    if str(bin_dir) not in current:
+        profile.write_text(current.rstrip() + block, encoding="utf-8")
+    return {
+        **payload,
+        "status": "updated",
+        "executed": True,
+        "profile": str(profile),
+        "message": "Alias PATH configured for future shell sessions. Restart the terminal or source the profile.",
+    }
+
+
+def install_windows_user_path(payload: dict[str, Any]) -> dict[str, Any]:
+    bin_dir = str(aliases_bin_dir())
+    try:
+        import winreg
+
+        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment", 0, winreg.KEY_READ | winreg.KEY_WRITE) as key:
+            try:
+                current, value_type = winreg.QueryValueEx(key, "Path")
+            except FileNotFoundError:
+                current, value_type = "", winreg.REG_EXPAND_SZ
+            entries = [entry for entry in str(current).split(os.pathsep) if entry]
+            if not any(paths_equal(Path(entry), aliases_bin_dir()) for entry in entries):
+                new_value = os.pathsep.join([bin_dir, *entries])
+                winreg.SetValueEx(key, "Path", 0, value_type, new_value)
+    except OSError as exc:
+        return {**payload, "status": "failed", "executed": False, "message": str(exc)}
+    return {
+        **payload,
+        "status": "updated",
+        "executed": True,
+        "profile": "HKCU\\Environment\\Path",
+        "message": "Alias PATH configured for future Windows terminal sessions.",
+    }
+
+
+def detect_shell_profile() -> Path:
+    shell = Path(os.environ.get("SHELL", "")).name
+    home = Path.home()
+    if shell == "zsh":
+        return home / ".zshrc"
+    if shell == "bash":
+        return home / ".bashrc"
+    return home / ".profile"

package/runtime/cli/aikit/cli_dispatch.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any
 
 from cli.aikit import __version__
-from cli.aikit.aliases import add_alias, list_aliases, remove_alias, sync_aliases
+from cli.aikit.aliases import add_alias, list_aliases, remove_alias, setup_alias_path, sync_aliases
 from cli.aikit.agentic_commands import agentic_execute, agentic_plan
 from cli.aikit.app_home import app_home_status, migrate_default_home
 from cli.aikit.architecture import architecture_contract
@@ -1530,6 +1530,10 @@ def dispatch_alias(args: argparse.Namespace) -> dict[str, Any]:
             if args.name:
                 raise DevKitError("alias sync does not accept a name")
             return sync_aliases()
+        if args.action == "path":
+            if args.name:
+                raise DevKitError("alias path does not accept a name")
+            return setup_alias_path(yes=args.yes)
     except ValueError as exc:
         raise DevKitError(str(exc)) from exc
     raise DevKitError(f"unsupported alias action: {args.action}")

package/runtime/cli/aikit/cli_parser.py

@@ -251,9 +251,10 @@ def build_parser(prog: str | None = None) -> argparse.ArgumentParser:
 
     alias_parser = subparsers.add_parser("alias", help="manage local command aliases for agent")
     alias_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)
-    alias_parser.add_argument("action", nargs="?", default="list", choices=["add", "list", "remove", "sync"])
+    alias_parser.add_argument("action", nargs="?", default="list", choices=["add", "list", "remove", "sync", "path"])
     alias_parser.add_argument("name", nargs="?")
     alias_parser.add_argument("--force", action="store_true", help="allow replacing an existing local alias file")
+    alias_parser.add_argument("--yes", action="store_true", help="confirm alias PATH setup")
 
     session_parser = subparsers.add_parser("session", help="manage local conversation sessions")
     session_parser.add_argument("--json", action="store_true", default=argparse.SUPPRESS, help=argparse.SUPPRESS)

package/runtime/cli/aikit/human_output.py

@@ -115,6 +115,8 @@ def print_human(result: dict[str, Any]) -> None:
         print_aliases(result)
     elif kind == "alias":
         print_alias(result)
+    elif kind == "alias-path":
+        print_alias_path(result)
     elif kind == "sessions":
         print_sessions(result)
     elif kind == "session":
@@ -630,6 +632,9 @@ def print_architecture(result: dict[str, Any]) -> None:
 def print_agent_response(result: dict[str, Any]) -> None:
     if result.get("status") == "ok":
         print(result.get("response", ""))
+        alias = result.get("alias") if isinstance(result.get("alias"), dict) else None
+        if alias:
+            print_alias_path_hint(alias.get("path_status") if isinstance(alias.get("path_status"), dict) else None)
         return
     print(result.get("message") or result.get("response") or "Agent execution did not complete.")
     question = result.get("next_question") or ((result.get("setup_wizard") or {}).get("next_question") if isinstance(result.get("setup_wizard"), dict) else None)
@@ -815,6 +820,12 @@ def print_personality(result: dict[str, Any]) -> None:
         print("Setup questions:")
         for question in result["questions"]:
             print(f"- {question}")
+    alias = result.get("alias") if isinstance(result.get("alias"), dict) else None
+    if alias:
+        print(f"Alias: {alias.get('name') or alias.get('suggested_name') or '-'} ({alias.get('status')})")
+        if alias.get("path"):
+            print(f"Alias path: {alias['path']}")
+        print_alias_path_hint(alias.get("path_status") if isinstance(alias.get("path_status"), dict) else None)
 
 
 def print_aliases(result: dict[str, Any]) -> None:
@@ -824,6 +835,7 @@ def print_aliases(result: dict[str, Any]) -> None:
         return
     for item in result["items"]:
         print(f"- {item['name']}: {item['path']}")
+        print_alias_path_hint(item.get("path_status") if isinstance(item.get("path_status"), dict) else None, indent="  ")
 
 
 def print_alias(result: dict[str, Any]) -> None:
@@ -835,6 +847,26 @@ def print_alias(result: dict[str, Any]) -> None:
         for path in result["removed_paths"]:
             print(f"- {path}")
     print(f"Config: {result['config_path']}")
+    print_alias_path_hint(result.get("path_status") if isinstance(result.get("path_status"), dict) else None)
+
+
+def print_alias_path(result: dict[str, Any]) -> None:
+    print(f"Alias PATH: {result.get('status')}")
+    print(f"Bin: {result.get('bin_dir') or '-'}")
+    if result.get("profile"):
+        print(f"Profile: {result['profile']}")
+    if result.get("message"):
+        print(result["message"])
+
+
+def print_alias_path_hint(path_status: dict[str, Any] | None, *, indent: str = "") -> None:
+    if not path_status or not path_status.get("setup_required"):
+        return
+    setup = path_status.get("setup") if isinstance(path_status.get("setup"), dict) else {}
+    print(f"{indent}PATH: {path_status.get('bin_dir')} is not active in this shell.")
+    command = setup.get("command")
+    if command:
+        print(f"{indent}Run: {command}")
 
 
 def print_sessions(result: dict[str, Any]) -> None:

package/runtime/cli/aikit/interactive_wizard.py

@@ -2,11 +2,13 @@
 
 from __future__ import annotations
 
+import os
 import sys
 from typing import Any
 
 from cli.aikit.core.requests import AgentPromptRequest
 from cli.aikit.core.runtime import run_agent_prompt
+from cli.aikit.aliases import setup_alias_path
 from cli.aikit.llm import BACKENDS, configure_backend
 from cli.aikit.mini_brain import DEFAULT_OLLAMA_MODEL
 from cli.aikit.ollama import ollama_status
@@ -15,6 +17,30 @@ from cli.aikit.personality import load_personality, update_personality
 from cli.aikit.runtime_paths import ROOT
 from cli.aikit.wizard_state import WizardStateError, answer_wizard, cancel_wizard, show_wizard
 
+ONBOARDING_MODE_OPTIONS = [
+    {
+        "id": "minimal",
+        "number": "1",
+        "label": "minimo",
+        "description": "identidade, mini-cerebro local embarcado e memoria",
+        "recommended": True,
+    },
+    {
+        "id": "complete",
+        "number": "2",
+        "label": "completo",
+        "description": "minimo + toolchain, sources, notificacoes, knowledge e memorias",
+        "recommended": False,
+    },
+    {
+        "id": "skip",
+        "number": "3",
+        "label": "pular",
+        "description": "",
+        "recommended": False,
+    },
+]
+
 
 def maybe_run_interactive_wizard(result: dict[str, Any]) -> dict[str, Any]:
     if not sys.stdin.isatty() or not sys.stdout.isatty():
@@ -126,18 +152,148 @@ def run_interactive_onboarding(result: dict[str, Any]) -> dict[str, Any]:
 
 
 def choose_onboarding_mode() -> str:
+    selected = choose_onboarding_mode_with_arrows()
+    if selected:
+        return selected
+    print("\nModos de onboarding:")
+    for option in ONBOARDING_MODE_OPTIONS:
+        print(format_onboarding_option(option, selected=False, include_selector=False))
+    answer = ask_text("Escolha o modo:").strip().lower()
+    return parse_onboarding_mode_answer(answer)
+
+
+def choose_onboarding_mode_with_arrows() -> str | None:
+    if not sys.stdin.isatty() or not sys.stdout.isatty() or os.environ.get("TERM") == "dumb":
+        return None
+    try:
+        return read_onboarding_mode_selection()
+    except KeyboardInterrupt:
+        print()
+        return "skip"
+    except (OSError, ValueError):
+        return None
+
+
+def read_onboarding_mode_selection() -> str:
+    selected_index = 0
+    typed_answer = ""
     print("\nModos de onboarding:")
-    print("1. minimo: identidade, mini-cerebro local embarcado e memoria")
-    print("2. completo: minimo + toolchain, sources, notificacoes, knowledge e memorias")
-    print("3. pular")
-    answer = ask_text("Escolha o modo", default="minimo").strip().lower()
+    render_onboarding_options(selected_index)
+    print_onboarding_prompt(typed_answer)
+    while True:
+        key = read_key()
+        if key in {"\x03", "\x04"}:
+            raise KeyboardInterrupt
+        if key in {"\r", "\n"}:
+            if typed_answer:
+                parsed = parse_onboarding_mode_answer(typed_answer.strip().lower(), default="")
+                if parsed:
+                    return parsed
+                typed_answer = ""
+                rerender_onboarding_options(selected_index, typed_answer)
+                continue
+            return str(ONBOARDING_MODE_OPTIONS[selected_index]["id"])
+        if key in {"\x1b[A", "k"}:
+            typed_answer = ""
+            selected_index = (selected_index - 1) % len(ONBOARDING_MODE_OPTIONS)
+            rerender_onboarding_options(selected_index, typed_answer)
+            continue
+        if key in {"\x1b[B", "j"}:
+            typed_answer = ""
+            selected_index = (selected_index + 1) % len(ONBOARDING_MODE_OPTIONS)
+            rerender_onboarding_options(selected_index, typed_answer)
+            continue
+        if key in {"\x7f", "\b"}:
+            typed_answer = typed_answer[:-1]
+            rerender_onboarding_options(selected_index, typed_answer)
+            continue
+        parsed = parse_onboarding_mode_answer(key.strip().lower(), default="")
+        if parsed:
+            print()
+            return parsed
+        if key.isprintable():
+            typed_answer += key
+            rerender_onboarding_options(selected_index, typed_answer)
+
+
+def render_onboarding_options(selected_index: int) -> None:
+    for index, option in enumerate(ONBOARDING_MODE_OPTIONS):
+        print(format_onboarding_option(option, selected=index == selected_index, include_selector=True))
+
+
+def rerender_onboarding_options(selected_index: int, typed_answer: str) -> None:
+    lines_to_move = len(ONBOARDING_MODE_OPTIONS) + 1
+    sys.stdout.write(f"\x1b[{lines_to_move}A")
+    for index, option in enumerate(ONBOARDING_MODE_OPTIONS):
+        sys.stdout.write("\x1b[2K")
+        sys.stdout.write(format_onboarding_option(option, selected=index == selected_index, include_selector=True) + "\n")
+    sys.stdout.write("\x1b[2K")
+    sys.stdout.write(onboarding_prompt_line(typed_answer) + "\n")
+    sys.stdout.flush()
+
+
+def format_onboarding_option(option: dict[str, Any], *, selected: bool, include_selector: bool) -> str:
+    selector = "> " if selected else "  "
+    prefix = selector if include_selector else ""
+    description = f": {option['description']}" if option.get("description") else ""
+    recommended = " (Recomendado)" if option.get("recommended") else ""
+    return f"{prefix}{option['number']}. {option['label']}{description}{recommended}"
+
+
+def parse_onboarding_mode_answer(answer: str, *, default: str = "minimal") -> str:
+    if not answer:
+        return default
     if answer in {"1", "minimo", "mínimo", "minimal"}:
         return "minimal"
     if answer in {"2", "completo", "complete", "full"}:
         return "complete"
     if answer in {"3", "pular", "skip", "cancelar", "cancel"}:
         return "skip"
-    return "minimal"
+    return default
+
+
+def print_onboarding_prompt(typed_answer: str) -> None:
+    print(onboarding_prompt_line(typed_answer))
+
+
+def onboarding_prompt_line(typed_answer: str) -> str:
+    suffix = f" {typed_answer}" if typed_answer else ""
+    return f"Escolha o modo:{suffix}"
+
+
+def read_key() -> str:
+    if os.name == "nt":
+        import msvcrt
+
+        char = msvcrt.getwch()
+        if char in {"\x00", "\xe0"}:
+            code = msvcrt.getwch()
+            if code == "H":
+                return "\x1b[A"
+            if code == "P":
+                return "\x1b[B"
+        return char
+
+    import termios
+    import tty
+    import select
+
+    fd = sys.stdin.fileno()
+    old_settings = termios.tcgetattr(fd)
+    try:
+        tty.setraw(fd)
+        char = sys.stdin.read(1)
+        if char == "\x1b":
+            sequence = ""
+            for _ in range(2):
+                ready, _, _ = select.select([sys.stdin], [], [], 0.01)
+                if not ready:
+                    break
+                sequence += sys.stdin.read(1)
+            char += sequence
+        return char
+    finally:
+        termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
 
 
 def configure_personality_interactively(agent: dict[str, Any]) -> None:
@@ -149,13 +305,27 @@ def configure_personality_interactively(agent: dict[str, Any]) -> None:
     language = ask_text("Idioma padrao das respostas?", default=str(agent.get("language") or "pt-BR"))
     tone = ask_text("Tom das respostas?", default=current_tone)
     detail_level = ask_text("Nivel de detalhe?", default=current_detail)
-    update_personality(
+    payload = update_personality(
         agent_name=agent_name,
         user_name=user_name,
         language=language,
         tone=tone,
         detail_level=detail_level,
     )
+    alias = payload.get("alias") if isinstance(payload.get("alias"), dict) else None
+    if not alias:
+        return
+    if alias.get("status") == "added":
+        print(f"Comando local criado: {alias.get('name')}")
+    elif alias.get("message"):
+        print(f"Alias nao configurado automaticamente: {alias['message']}")
+    path_status = alias.get("path_status") if isinstance(alias.get("path_status"), dict) else {}
+    if path_status.get("setup_required"):
+        bin_dir = path_status.get("bin_dir")
+        print(f"O comando foi criado em {bin_dir}, mas essa pasta ainda nao esta no PATH.")
+        if ask_yes_no("Deseja habilitar aliases do Agent DevKit no shell para proximas sessoes?", default=True):
+            setup = setup_alias_path(yes=True)
+            print(setup.get("message") or "PATH de aliases atualizado.")
 
 
 def configure_llm_interactively() -> None:

package/runtime/cli/aikit/natural_prompt_runtime.py

@@ -62,6 +62,21 @@ def clean_requested_name(value: str) -> str | None:
     return cleaned[:80]
 
 
+def rename_response(updated: dict[str, Any]) -> str:
+    name = updated.get("agent_name")
+    alias = updated.get("alias") if isinstance(updated.get("alias"), dict) else {}
+    alias_name = alias.get("name") or alias.get("suggested_name")
+    path_status = alias.get("path_status") if isinstance(alias.get("path_status"), dict) else {}
+    if alias_name and path_status.get("setup_required"):
+        return (
+            f"Pronto. Meu nome local agora e {name}, e criei o comando {alias_name}. "
+            "Para chama-lo diretamente em novas sessoes do shell, execute `agent alias path --yes`."
+        )
+    if alias_name:
+        return f"Pronto. Meu nome local agora e {name}, e voce tambem pode me chamar com o comando {alias_name}."
+    return f"Pronto. Meu nome local agora e {name}."
+
+
 def is_capabilities_help_prompt(prompt: str) -> bool:
     normalized = normalize_text(prompt)
     if normalized in {"ajuda", "help", "o que voce faz", "o que voce consegue fazer"}:
@@ -220,7 +235,8 @@ def run_agent_prompt_request(request: AgentPromptRequest) -> dict[str, Any]:
             "prompt_length": len(prompt),
             "identity": {"name": updated.get("agent_name"), "source": "local"},
             "action": "rename",
-            "response": f"Pronto. Meu nome local agora e {updated.get('agent_name')}.",
+            "response": rename_response(updated),
+            "alias": updated.get("alias"),
         }
         return finalize_agent_session(result, session, prompt, backend=request.llm)
     if is_identity_question(prompt):

package/runtime/cli/aikit/personality.py

@@ -6,6 +6,7 @@ import re
 from pathlib import Path
 from typing import Any
 
+from cli.aikit.aliases import ensure_alias_for_agent_name
 from cli.aikit.identity import DEFAULT_PUBLIC_NAME
 from cli.aikit.memory import MEMORY_FILE_TEMPLATES, ensure_memory, memory_home
 
@@ -60,6 +61,8 @@ def update_personality(
     path.write_text(render_personality(values), encoding="utf-8")
     payload = load_personality()
     payload["status"] = "updated"
+    if agent_name is not None and payload.get("agent_name") != DEFAULT_PUBLIC_NAME:
+        payload["alias"] = ensure_alias_for_agent_name(str(payload["agent_name"]))
     return payload
 
 

package/runtime/scripts/release-catalog-snapshot.json

@@ -1,6 +1,6 @@
 {
   "schema_version": "ai-devkit.release-catalog-snapshot/v1",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "summary": {
     "agents": 48,
     "capabilities": 397,