pythinker-code 0.43.0__py3-none-any.whl → 0.45.0__py3-none-any.whl

pythinker_code/CHANGELOG.md

@@ -15,6 +15,103 @@ GitHub Releases page; `0.8.0` is the new starting line.
 
 ## Unreleased
 
+## 0.45.0 (2026-06-14)
+
+- **Agent-tracing dashboard.** Added `pythinker dashboard` — a local web UI for inspecting sessions, wire events, context messages, tool statistics, and usage over time. It is also reachable from the interactive shell via the `/reports` slash command (aliased `/dashboard`).
+- **Gemini finish_reason is now sticky once truncation is detected.** A second candidate with any non-`MAX_TOKENS` finish reason no longer overwrites a previously captured `"length"` signal at either the streaming or non-streaming path in the Google GenAI provider.
+- **Budget-exhausted and stuck-loop messages are now visible in the shell.** Both handoff messages were appended to context but never sent to the wire, so the interactive shell showed no feedback when a spend ceiling or stuck-loop exit fired. Both now emit a `TextPart` wire event so the message appears in the shell.
+- **Dark-theme prompt_toolkit border colors now match the TUI token constants.** Six stale slate hex values in `_PROMPT_STYLE_DARK` diverged from the current `border` and `border_muted` token values; they are now in sync and a parity test binds them going forward.
+- **Non-review successful agents now show a summary preview in the agent tree.** Completed subagents with a `summary_preview` now display a dim preview line in the RunAgents tree renderer (review runs continue to use the findings table instead).
+- **Non-string values in `required_mcp_servers` YAML are silently dropped.** Integers, booleans, and `null` entries were previously coerced to strings (`"1"`, `"False"`, `"None"`), creating permanently unsatisfiable MCP server names. Only actual string entries are now retained.
+- **Fixed MiniMax token-plan `/usage` accuracy.** The token-plan response now meters by
+  percentage (the count fields are 0) and reports reset times in milliseconds; the adapter was
+  reading the zero counts (showing "0 requests used") and treating milliseconds as seconds
+  (showing resets like "171d" for a 5-hour window). It now reads `*_remaining_percent` and
+  converts reset times correctly, so e.g. a week at 82% remaining shows "18% used" resetting in
+  hours, not days.
+- **GLM-5.2 (1M context) is now the default Z.AI model.** Logging in with Z.AI selects
+  `z-ai/glm-5.2` with its full 1,000,000-token context window. GLM-5.2 is absent from z.ai's
+  model-listing API, so it is pinned into the catalog and offered even when discovery omits it;
+  if z.ai later lists it, the API definition wins and it is shown once (no duplicate). Earlier
+  GLM models (5.1, 5, 5-turbo, 4.7, 4.5-air) remain available.
+- **Kimi K2.7 Code added, and a new Kimi Coding Plan provider.** `kimi-k2.7-code` is now the
+  default model on the Moonshot plan, and a separate "Kimi Coding Plan" provider
+  (`/login kimi`) targets Moonshot's Anthropic-compatible coding endpoint with `kimi-k2.7-code`.
+- **Verb spinner stays visible while a foreground tool or subagent runs.** The shimmering
+  "Working…/Thinking…" activity indicator now persists for the whole active turn — including
+  while a foreground tool (such as a shell-started server) or a subagent is executing — instead
+  of disappearing until the tool finished. This keeps long tool/subagent waits feeling alive
+  rather than frozen. An in-progress todo still swaps the verb for the todo title as before.
+- **Project instructions delivered as a separate authoritative message.** The merged
+  `AGENTS.md` is no longer baked into the system prompt; it is delivered as a session-start,
+  user-role `<system-reminder>` preamble, assembled fresh on every request from session
+  state. This keeps the project rules immune to two regressions a system-prompt move would
+  otherwise risk — context compaction can no longer summarize them away (they never enter the
+  persisted history) and the dynamic-injection token budget can no longer truncate them —
+  while keeping the system prompt free of per-project content. `pythinker system-prompt` shows
+  the reminder below a labeled divider so the dump stays faithful.
+- **Inspect the assembled system prompt.** New `pythinker system-prompt` command
+  renders and prints the fully-assembled system prompt for an agent
+  (`--agent <name>`, `--agent-file <path>`, `--work-dir <dir>`) — substituting the
+  live work directory, OS/shell, merged `AGENTS.md`, and discovered skills. It is
+  read-only: no session is created, no provider auth is required, and no MCP
+  servers are loaded.
+- **Bound parallel tool fan-out.** Parallel-safe tool calls in one turn still
+  overlap, but now up to a fixed concurrency cap (10) instead of without bound, so
+  a turn that fans out many readers (e.g. dozens of web fetches) can no longer open
+  an unbounded number of sockets/file handles at once. Mutating-tool ordering and
+  writer exclusivity are unchanged.
+- **Optional per-session spend ceiling.** New `loop_control.max_session_cost_usd`
+  config option (off by default). When set, a turn stops with a clear
+  budget-exhausted handoff message once the session's accumulated estimated cost
+  reaches the ceiling, instead of running to the step limit — and goal
+  auto-continuations and agent flows halt too. Best-effort: cost is `0` for models
+  with unknown pricing, so the ceiling never blocks when spend cannot be estimated.
+- **Sensitive host files always re-confirm.** Writes to shell startup files
+  (`.zshrc`, `.bash_profile`, …), `.git` internals/hooks, the custom `.githooks`
+  hooks directory, `.ssh`, `.vscode`, and git
+  credentials (`.gitconfig`, `.netrc`, `.git-credentials`) are now classified as a
+  distinct edit action that re-confirms every time — even under yolo/auto — and is
+  never recorded as session-approved, exactly like edits to pythinker's own config.
+  This closes an auto-approve gap where a `.git/hooks` write inside the workspace was
+  treated as an ordinary edit.
+- **Accept-edits mode.** New `/accept-edits` toggle auto-approves reversible
+  in-workspace ordinary file edits while still prompting for shell, destructive,
+  outside-workspace, config-surface, and sensitive host-file edits. It is
+  session-local (not persisted) and suppressed by safe mode. Pairs with the deny-set
+  above so a `.git/hooks` or shell-rc write is never swept into the auto-approve tier.
+- **Agents can declare required MCP servers.** A markdown agent's frontmatter may set
+  `required_mcp_servers: [..]`; spawning that agent (via `Agent` or `RunAgents`) is
+  rejected with a clear message when those servers are configured-and-absent, instead of
+  wasting a turn on an agent that cannot reach its tools. While MCP is still loading the
+  spawn is allowed (the servers may yet connect).
+- **UserPromptSubmit hooks can add context.** A non-blocking `UserPromptSubmit` hook's
+  `additionalContext` is now injected into the user turn as a system reminder, so the
+  model sees it as context for the prompt (previously only a hook *block* was honored).
+  Slash-command parsing still reads only the user's text, never the appended context.
+- **Stale-overwrite guard for file edits.** If you read a file and it then changes on
+  disk (edited by you in another window or by another tool), overwriting it with WriteFile
+  or editing it with StrReplaceFile is now rejected with "File has been modified since you
+  last read it" so external changes are not silently clobbered — read it again first. This
+  catches external edits that StrReplaceFile's exact-string matching alone would miss.
+  First-contact writes (a file you never read) are unaffected, and a tool's own write
+  refreshes the read-state so consecutive edits are never falsely flagged.
+- **Recover from output-token truncation.** When a response is cut off by the
+  output-token limit and makes no tool call, the turn no longer ends with a half-finished
+  answer treated as complete — the model is nudged to continue from where it stopped, up
+  to `loop_control.max_truncation_recoveries` times per turn (default 3; `0` disables).
+  pythinker-core now surfaces the provider's truncation signal so the loop can detect it.
+
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.45.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
+
+## 0.44.0 (2026-06-13)
+
+- **Toggle auto-update from the CLI.** Running `/update` now opens a menu — *Check for updates now* (the default, so a bare `/update` + Enter still checks immediately) or *Auto-update on startup* with its current state — so the toggle is discoverable without knowing a subcommand. `/update auto on|off` still sets it directly, and `/update auto` with no value opens an interactive On/Off picker (cursor defaulted to the current setting). The same toggle appears in the interactive `/settings` panel, and `pythinker info` reports the auto-update status. All surfaces show the *effective* state — an external override (`PYTHINKER_CLI_NO_AUTO_UPDATE` or a source checkout) is surfaced as the reason, renders the `/settings` row read-only, and makes `/update auto` report the read-only state rather than popping a no-op picker, so the toggle is never a silent no-op.
+- **Windows in-app update no longer shows a spurious "could not close the program" error.** The native installer now waits for the launching `pythinker.exe` to fully exit (its PID is passed via `/PID`) before its Restart Manager scan runs, so the scan no longer races the launcher's teardown into a false "close the program and retry" dialog. The update already succeeded in that case; now it completes cleanly without the alarming prompt.
+- **Simplified the Windows pip/uv/pipx update path.** Now that every shipped Windows install updates through the native installer, the Windows-only detached-spawn upgrade helper is removed; the remaining pip/uv/pipx path (a Windows source checkout, or any macOS/Linux install) runs the upgrade inline like POSIX, surfacing real command output and errors instead of a fire-and-forget process.
+
+Upgrade with `pythinker update`, `pip install --upgrade pythinker-code==0.44.0`, or use the native installer for your platform from the [Releases page](https://github.com/Pythoughts-labs/pythinker-code/releases/latest).
+
 ## 0.43.0 (2026-06-13)
 
 - **Silent startup auto-updates (default on).** Managed and native installs now check for and apply updates in the background at startup, surfacing a restart-to-apply notice instead of a blocking prompt. Opt out with `auto_update = false` in config or `PYTHINKER_AUTO_UPDATE=0` in the environment. The Windows update path that replaces the running binary no longer escapes as an uncaught `SystemExit` and crashes the shell.

pythinker_code/agents/default/system.md

@@ -242,19 +242,8 @@ ${PYTHINKER_ADDITIONAL_DIRS_INFO}
 ## 11. Project Instructions (AGENTS.md)
 
 `AGENTS.md` files carry the agent-facing context a README omits — build steps, test commands, conventions, structure, and user preferences — kept separate so agents have a predictable place for instructions while READMEs stay human-focused.
-{% if PYTHINKER_AGENTS_MD %}
 
-The block below is authoritative and already merged: every `AGENTS.md` from the project root down to the working directory, deeper (more specific) files overriding shallower ones, each governing its own directory and everything beneath it.
-
-${PYTHINKER_AGENTS_MD_FENCE}
-${PYTHINKER_AGENTS_MD}
-${PYTHINKER_AGENTS_MD_FENCE}
-
-Treat the merged block as complete for the root-to-working-directory range; look for additional `AGENTS.md` only in directories **below** the working directory and apply them by the same precedence when editing there.
-{% else %}
-
-No `AGENTS.md` files were found between the project root and the working directory; look for them only in directories **below** the working directory and apply them when editing there.
-{% endif %}
+When any `AGENTS.md` files apply between the project root and the working directory, their merged content is **delivered as a separate authoritative message at the start of this session** — every file from the project root down to the working directory, deeper (more specific) files overriding shallower ones, each governing its own directory and everything beneath it. Treat that merged message as complete for the root-to-working-directory range, with the same authority as these instructions; look for additional `AGENTS.md` only in directories **below the working directory** and apply them by the same precedence when editing there.
 
 Precedence per §2. `README`/`README.md` files are optional supplementary context, not instructions. If a change you make invalidates anything an `AGENTS.md` documents (build/test commands, conventions, structure, workflows), update that `AGENTS.md` in the same change so it stays trustworthy.
 

pythinker_code/auth/__init__.py

@@ -7,6 +7,7 @@ OPENAI_CHATGPT_PLATFORM_ID = "openai-chatgpt"
 OPENCODE_GO_PLATFORM_ID = "opencode-go"
 MINIMAX_PLATFORM_ID = "minimax"
 MOONSHOT_PLATFORM_ID = "moonshot"
+KIMI_PLATFORM_ID = "kimi"
 DEEPSEEK_PLATFORM_ID = "deepseek"
 ANTHROPIC_PLATFORM_ID = "anthropic"
 OPENROUTER_PLATFORM_ID = "openrouter"
@@ -18,6 +19,7 @@ __all__ = [
     "ALIBABA_PLATFORM_ID",
     "ANTHROPIC_PLATFORM_ID",
     "DEEPSEEK_PLATFORM_ID",
+    "KIMI_PLATFORM_ID",
     "LM_STUDIO_PLATFORM_ID",
     "MINIMAX_PLATFORM_ID",
     "MOONSHOT_PLATFORM_ID",

pythinker_code/auth/kimi.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+
+import os
+from collections.abc import AsyncIterator, Mapping
+from dataclasses import dataclass
+from typing import Any, cast
+
+import aiohttp
+from pydantic import SecretStr
+
+from pythinker_code.auth import KIMI_PLATFORM_ID
+from pythinker_code.auth.oauth import OAuthEvent
+from pythinker_code.auth.platforms import managed_model_key, managed_provider_key
+from pythinker_code.config import Config, LLMModel, LLMProvider, save_config
+from pythinker_code.thinking import apply_login_thinking_defaults
+from pythinker_code.utils.aiohttp import new_client_session
+
+# The Kimi coding plan is served from Moonshot's Anthropic-compatible endpoint
+# (ANTHROPIC_BASE_URL in the Claude Code integration guide) and authenticates
+# with the same Moonshot API key. It is a distinct plan from the OpenAI-compatible
+# Moonshot provider (`auth/moonshot.py`), which targets `api.moonshot.ai/v1`.
+KIMI_BASE_URL = "https://api.moonshot.ai/anthropic"
+KIMI_MODELS_URL = "https://api.moonshot.ai/anthropic/v1/models"
+KIMI_PROVIDER_KEY = managed_provider_key(KIMI_PLATFORM_ID)
+KIMI_DEFAULT_MODEL_ALIAS = managed_model_key(KIMI_PLATFORM_ID, "kimi-k2.7-code")
+KIMI_MODEL_DISCOVERY_TIMEOUT = aiohttp.ClientTimeout(total=15, sock_connect=8, sock_read=10)
+
+
+@dataclass(frozen=True, slots=True)
+class KimiModel:
+    model_id: str
+    alias_suffix: str
+    display_name: str
+    provider_key: str = KIMI_PROVIDER_KEY
+    max_context_size: int = 262_144
+
+    @property
+    def alias(self) -> str:
+        return f"{KIMI_PLATFORM_ID}/{self.alias_suffix}"
+
+
+KIMI_MODELS: tuple[KimiModel, ...] = (
+    KimiModel("kimi-k2.7-code", "kimi-k2.7-code", "Kimi K2.7 Code"),
+)
+
+
+def get_kimi_api_key_from_env() -> str | None:
+    # The coding plan reuses the Moonshot API key; accept either name.
+    for var in ("KIMI_API_KEY", "MOONSHOT_API_KEY"):
+        value = os.getenv(var)
+        if value and value.strip():
+            return value.strip()
+    return None
+
+
+def _model_by_id() -> dict[str, KimiModel]:
+    return {model.model_id: model for model in KIMI_MODELS}
+
+
+def _parse_discovered_models(data: object) -> tuple[KimiModel, ...] | None:
+    """Return parsed models, or None if the payload is structurally invalid.
+
+    Only models already in the curated catalog are kept: the coding plan is
+    focused on `kimi-k2.7-code`, and discovery is used to refresh its context
+    window/display name, not to widen the plan.
+    """
+    if not isinstance(data, dict):
+        return None
+    raw_items = cast(dict[str, Any], data).get("data")
+    if not isinstance(raw_items, list):
+        return None
+
+    catalog = _model_by_id()
+    seen: set[str] = set()
+    result: list[KimiModel] = []
+    for raw_item in cast(list[Any], raw_items):
+        if not isinstance(raw_item, Mapping):
+            continue
+        item = cast(Mapping[str, Any], raw_item)
+        model_id = item.get("id")
+        if not isinstance(model_id, str) or model_id not in catalog or model_id in seen:
+            continue
+        seen.add(model_id)
+        base = catalog[model_id]
+        max_ctx = base.max_context_size
+        ctx = item.get("context_length")
+        if isinstance(ctx, int) and ctx > 0:
+            max_ctx = ctx
+        display_name = base.display_name
+        api_name = item.get("display_name")
+        if isinstance(api_name, str) and api_name.strip():
+            display_name = api_name.strip()
+        result.append(
+            KimiModel(
+                model_id=base.model_id,
+                alias_suffix=base.alias_suffix,
+                display_name=display_name,
+                provider_key=base.provider_key,
+                max_context_size=max_ctx,
+            )
+        )
+    return tuple(result)
+
+
+async def _discover_kimi_models(api_key: str) -> tuple[KimiModel, ...] | None:
+    async with (
+        new_client_session(timeout=KIMI_MODEL_DISCOVERY_TIMEOUT) as session,
+        session.get(
+            KIMI_MODELS_URL,
+            headers={"Authorization": f"Bearer {api_key}", "x-api-key": api_key},
+            raise_for_status=True,
+        ) as response,
+    ):
+        payload = await response.json(content_type=None)
+    return _parse_discovered_models(payload)
+
+
+def _apply_kimi_config(
+    config: Config,
+    api_key: SecretStr,
+    models: tuple[KimiModel, ...] = KIMI_MODELS,
+) -> None:
+    config.providers[KIMI_PROVIDER_KEY] = LLMProvider(
+        type="anthropic",
+        base_url=KIMI_BASE_URL,
+        api_key=api_key,
+    )
+
+    provider_keys = {KIMI_PROVIDER_KEY}
+    for key, model in list(config.models.items()):
+        if model.provider in provider_keys:
+            del config.models[key]
+
+    for model in models:
+        config.models[model.alias] = LLMModel(
+            provider=model.provider_key,
+            model=model.model_id,
+            max_context_size=model.max_context_size,
+            display_name=model.display_name,
+        )
+
+    fallback = next(
+        (m.alias for m in models),
+        next(iter(config.models), ""),
+    )
+    if KIMI_DEFAULT_MODEL_ALIAS in config.models:
+        config.default_model = KIMI_DEFAULT_MODEL_ALIAS
+    else:
+        config.default_model = fallback
+    apply_login_thinking_defaults(config, thinking=False, effort="off")
+
+
+async def login_kimi_api_key(
+    config: Config, api_key: str | None = None
+) -> AsyncIterator[OAuthEvent]:
+    if not config.is_from_default_location:
+        yield OAuthEvent(
+            "error",
+            "Login requires the default config file; restart without --config/--config-file.",
+        )
+        return
+
+    resolved_key = (api_key or get_kimi_api_key_from_env() or "").strip()
+    if not resolved_key:
+        yield OAuthEvent("error", "Kimi API key is required.")
+        return
+
+    models = KIMI_MODELS
+    try:
+        discovered = await _discover_kimi_models(resolved_key)
+        if discovered is not None and discovered:
+            models = discovered
+    except aiohttp.ClientResponseError as exc:
+        if exc.status in {401, 403}:
+            yield OAuthEvent("error", "Invalid Kimi API key; the key was not saved.")
+            return
+        yield OAuthEvent(
+            "info",
+            "Kimi model listing is unavailable; using the built-in model list.",
+        )
+    except (aiohttp.ClientError, TimeoutError, ValueError):
+        yield OAuthEvent(
+            "info",
+            "Kimi model listing is unavailable; using the built-in model list.",
+        )
+
+    _apply_kimi_config(config, SecretStr(resolved_key), models=models)
+    save_config(config)
+    yield OAuthEvent("success", f"Kimi configured with model {config.default_model}.")
+
+
+async def logout_kimi(config: Config) -> AsyncIterator[OAuthEvent]:
+    if not config.is_from_default_location:
+        yield OAuthEvent(
+            "error",
+            "Logout requires the default config file; restart without --config/--config-file.",
+        )
+        return
+
+    provider_keys = {KIMI_PROVIDER_KEY}
+    config.providers.pop(KIMI_PROVIDER_KEY, None)
+    for key, model in list(config.models.items()):
+        if model.provider in provider_keys:
+            del config.models[key]
+
+    if config.default_model not in config.models:
+        config.default_model = next(iter(config.models), "")
+    save_config(config)
+    yield OAuthEvent("success", "Logged out of Kimi successfully.")
+
+
+def apply_kimi_models(config: Config, models: tuple[KimiModel, ...]) -> bool:
+    """Upsert the live Kimi catalog and prune models no longer returned.
+
+    Preserves user preferences unless the selected Kimi model disappeared.
+    """
+    changed = False
+    aliases: list[str] = []
+    for model in models:
+        alias = model.alias
+        aliases.append(alias)
+        existing = config.models.get(alias)
+        if existing is None:
+            config.models[alias] = LLMModel(
+                provider=model.provider_key,
+                model=model.model_id,
+                max_context_size=model.max_context_size,
+                display_name=model.display_name,
+            )
+            changed = True
+            continue
+        if existing.provider != model.provider_key:
+            existing.provider = model.provider_key
+            changed = True
+        if existing.model != model.model_id:
+            existing.model = model.model_id
+            changed = True
+        if existing.max_context_size != model.max_context_size:
+            existing.max_context_size = model.max_context_size
+            changed = True
+        if existing.display_name != model.display_name:
+            existing.display_name = model.display_name
+            changed = True
+
+    alias_set = set(aliases)
+    removed_default = False
+    for alias, model_cfg in list(config.models.items()):
+        if model_cfg.provider != KIMI_PROVIDER_KEY:
+            continue
+        if alias in alias_set:
+            continue
+        del config.models[alias]
+        if config.default_model == alias:
+            removed_default = True
+        changed = True
+
+    if removed_default:
+        config.default_model = aliases[0] if aliases else next(iter(config.models), "")
+        changed = True
+    elif config.default_model and config.default_model not in config.models:
+        config.default_model = next(iter(config.models), "")
+        changed = True
+    return changed
+
+
+def _kimi_api_key(config: Config) -> str | None:
+    provider = config.providers.get(KIMI_PROVIDER_KEY)
+    if provider is None:
+        return None
+    value = provider.api_key.get_secret_value().strip()
+    return value or None
+
+
+async def refresh_kimi_models(config: Config) -> tuple[KimiModel, ...] | None:
+    api_key = _kimi_api_key(config)
+    if api_key is None:
+        return None
+    return await _discover_kimi_models(api_key)

pythinker_code/auth/moonshot.py

@@ -17,7 +17,7 @@ from pythinker_code.utils.aiohttp import new_client_session
 
 MOONSHOT_BASE_URL = "https://api.moonshot.ai/v1"
 MOONSHOT_PROVIDER_KEY = managed_provider_key(MOONSHOT_PLATFORM_ID)
-MOONSHOT_DEFAULT_MODEL_ALIAS = managed_model_key(MOONSHOT_PLATFORM_ID, "kimi-k2.6")
+MOONSHOT_DEFAULT_MODEL_ALIAS = managed_model_key(MOONSHOT_PLATFORM_ID, "kimi-k2.7-code")
 
 
 @dataclass(frozen=True, slots=True)
@@ -34,6 +34,7 @@ class MoonshotModel:
 
 
 MOONSHOT_MODELS: tuple[MoonshotModel, ...] = (
+    MoonshotModel("kimi-k2.7-code", "kimi-k2.7-code", "Kimi K2.7 Code"),
     MoonshotModel("kimi-k2.6", "kimi-k2.6", "Kimi K2.6"),
     MoonshotModel("kimi-k2.5", "kimi-k2.5", "Kimi K2.5"),
     MoonshotModel("kimi-k2-thinking", "kimi-k2-thinking", "Kimi K2 Thinking"),

pythinker_code/auth/platforms.py

@@ -231,6 +231,12 @@ async def refresh_managed_models(config: Config) -> bool:
     if not config.is_from_default_location:
         return False
 
+    from pythinker_code.auth.kimi import (
+        KIMI_PROVIDER_KEY,
+        KimiModel,
+        apply_kimi_models,
+        refresh_kimi_models,
+    )
     from pythinker_code.auth.minimax import (
         MINIMAX_ANTHROPIC_PROVIDER_KEY,
         MiniMaxModel,
@@ -267,6 +273,7 @@ async def refresh_managed_models(config: Config) -> bool:
         if provider_key in OPENCODE_GO_PROVIDER_KEYS or provider_key in (
             MINIMAX_ANTHROPIC_PROVIDER_KEY,
             ZAI_PROVIDER_KEY,
+            KIMI_PROVIDER_KEY,
         ):
             continue
         platform_id = parse_managed_provider_key(provider_key)
@@ -431,6 +438,14 @@ async def refresh_managed_models(config: Config) -> bool:
     if z_ai_models is not None and apply_z_ai_models(config, z_ai_models):
         changed = True
 
+    kimi_models: tuple[KimiModel, ...] | None = None
+    try:
+        kimi_models = await refresh_kimi_models(config)
+    except (aiohttp.ClientError, TimeoutError, ValueError) as exc:
+        logger.warning("Failed to refresh Kimi models: {error}", error=exc)
+    if kimi_models is not None and apply_kimi_models(config, kimi_models):
+        changed = True
+
     if changed:
         config_for_save = load_config()
         save_changed = False
@@ -443,6 +458,8 @@ async def refresh_managed_models(config: Config) -> bool:
             save_changed = True
         if z_ai_models is not None and apply_z_ai_models(config_for_save, z_ai_models):
             save_changed = True
+        if kimi_models is not None and apply_kimi_models(config_for_save, kimi_models):
+            save_changed = True
         if save_changed:
             save_config(config_for_save)
     return changed

pythinker_code/auth/z_ai.py

@@ -18,7 +18,7 @@ from pythinker_code.utils.aiohttp import new_client_session
 ZAI_BASE_URL = "https://api.z.ai/api/anthropic"
 ZAI_MODELS_URL = "https://api.z.ai/api/anthropic/v1/models"
 ZAI_PROVIDER_KEY = managed_provider_key(ZAI_PLATFORM_ID)
-ZAI_DEFAULT_MODEL_ALIAS = managed_model_key(ZAI_PLATFORM_ID, "glm-5.1")
+ZAI_DEFAULT_MODEL_ALIAS = managed_model_key(ZAI_PLATFORM_ID, "glm-5.2")
 ZAI_MODEL_DISCOVERY_TIMEOUT = aiohttp.ClientTimeout(total=15, sock_connect=8, sock_read=10)
 
 
@@ -35,7 +35,18 @@ class ZaiModel:
         return f"{ZAI_PLATFORM_ID}/{self.alias_suffix}"
 
 
+# GLM-5.2 is served on z.ai's Anthropic-compatible endpoint under the plain id
+# "glm-5.2", which carries the full 1M-token context window. Verified empirically
+# 2026-06-15 against api.z.ai/api/anthropic: a request with 1,002,378 input
+# tokens succeeded while ~1.05M returned stop_reason="model_context_window_exceeded".
+# The documented "glm-5.2[1m]" suffix is NOT a valid model code here (returns
+# HTTP 400 "Unknown Model") — the plain id already grants 1M, so we use it and
+# set the real window. z.ai's /models listings expose no context field and omit
+# glm-5.2 entirely, so both the id and the size are curated.
+_GLM_5_2 = ZaiModel("glm-5.2", "glm-5.2", "GLM-5.2", max_context_size=1_000_000)
+
 ZAI_MODELS: tuple[ZaiModel, ...] = (
+    _GLM_5_2,
     ZaiModel("glm-5.1", "glm-5.1", "GLM-5.1", max_context_size=204_800),
     ZaiModel("glm-5", "glm-5", "GLM-5"),
     ZaiModel("glm-5-turbo", "glm-5-turbo", "GLM-5-Turbo"),
@@ -43,6 +54,26 @@ ZAI_MODELS: tuple[ZaiModel, ...] = (
     ZaiModel("glm-4.5-air", "glm-4.5-air", "GLM-4.5-Air", max_context_size=98_304),
 )
 
+# Curated models that must always be offered even when z.ai's /models endpoint
+# does not list them. GLM-5.2 is usable for chat but is absent from both the
+# Anthropic and OpenAI-compatible /models listings (verified 2026-06-15), so
+# without pinning it never reaches the model menu and a successful login or
+# periodic refresh would drop it. Discovered entries win for everything else.
+_PINNED_MODELS: tuple[ZaiModel, ...] = (_GLM_5_2,)
+
+
+def _with_pinned_models(models: tuple[ZaiModel, ...]) -> tuple[ZaiModel, ...]:
+    """Prepend curated pinned models the live catalog omitted, deduped by alias.
+
+    If z.ai later starts returning a pinned model (e.g. it adds "glm-5.2" to its
+    /models listing), the discovered entry already occupies that alias, so the
+    pin is dropped — the API-provided definition wins and the model appears once,
+    never twice. The pin only fills the gap while the endpoint omits it.
+    """
+    present = {model.alias for model in models}
+    missing = tuple(model for model in _PINNED_MODELS if model.alias not in present)
+    return missing + models
+
 
 def get_z_ai_api_key_from_env() -> str | None:
     value = os.getenv("ZAI_API_KEY")
@@ -163,6 +194,8 @@ def _apply_z_ai_config(
         api_key=api_key,
     )
 
+    models = _with_pinned_models(models)
+
     provider_keys = {ZAI_PROVIDER_KEY}
     for key, model in list(config.models.items()):
         if model.provider in provider_keys:
@@ -251,6 +284,7 @@ def apply_z_ai_models(config: Config, models: tuple[ZaiModel, ...]) -> bool:
 
     Preserves user preferences unless the selected Z AI model disappeared.
     """
+    models = _with_pinned_models(models)
     changed = False
     aliases: list[str] = []
     for model in models:

pythinker_code/cli/__init__.py

@@ -36,11 +36,11 @@ class SwitchToWeb(Exception):
         self.session_id = session_id
 
 
-class SwitchToVis(Exception):
-    """Switch to vis (tracing visualizer) interface."""
+class SwitchToDashboard(Exception):
+    """Switch to dashboard (tracing visualizer) interface."""
 
-    def __init__(self, session_id: str | None = None):
-        super().__init__("switch_to_vis")
+    def __init__(self, session_id: str | None = None) -> None:
+        super().__init__("switch_to_dashboard")
         self.session_id = session_id
 
 
@@ -1042,7 +1042,7 @@ def pythinker(
             except SwitchToWeb:
                 preserve_background_tasks = True
                 raise
-            except SwitchToVis:
+            except SwitchToDashboard:
                 preserve_background_tasks = True
                 raise
             finally:
@@ -1134,10 +1134,10 @@ def pythinker(
             await asyncio.to_thread(mutate_metadata, _mark_last)
 
     async def _reload_loop(session_id: str | None) -> tuple[str | None, int]:
-        """Run the main loop, handling Reload/SwitchToWeb/SwitchToVis.
+        """Run the main loop, handling Reload/SwitchToWeb/SwitchToDashboard.
 
         Returns:
-            (switch_target, exit_code) where switch_target is "web", "vis",
+            (switch_target, exit_code) where switch_target is "web", "dashboard",
             or None if the session ended normally.
         """
         last_session: Session | None = None
@@ -1182,19 +1182,19 @@ def pythinker(
                         if session is not None:
                             await _post_run(session, ExitCode.SUCCESS)
                     return "web", ExitCode.SUCCESS
-                except SwitchToVis as e:
+                except SwitchToDashboard as e:
                     if _latest_created_session is not None:
                         _latest_created_session.release_ownership()
                     if e.session_id is not None:
                         session = await Session.find(work_dir, e.session_id)
                         if session is not None:
                             await _post_run(session, ExitCode.SUCCESS)
-                    return "vis", ExitCode.SUCCESS
+                    return "dashboard", ExitCode.SUCCESS
             assert last_session is not None
             await _post_run(last_session, exit_code)
             last_session.release_ownership()
             return None, exit_code
-        except (SwitchToWeb, SwitchToVis):
+        except (SwitchToWeb, SwitchToDashboard):
             # Currently handled inside the loop (return), but re-raise explicitly
             # so the generic except below never treats them as unexpected errors.
             raise
@@ -1316,7 +1316,7 @@ def pythinker(
                 "Run with --debug for full traceback, or run pythinker export to share diagnostics."
             )
         raise typer.Exit(code=1) from exc
-    if switch_target in ("web", "vis"):
+    if switch_target in ("web", "dashboard"):
         from pythinker_code.utils.logging import restore_stderr
 
         restore_stderr()
@@ -1336,9 +1336,9 @@ def pythinker(
 
             run_web_server(open_browser=True)
         else:
-            from pythinker_code.vis.app import run_vis_server
+            from pythinker_code.dashboard.app import run_dashboard_server
 
-            run_vis_server(open_browser=True)
+            run_dashboard_server(open_browser=True)
     elif exit_code != ExitCode.SUCCESS:
         raise typer.Exit(code=exit_code)