nanocode-cli 0.7.0__tar.gz → 0.7.2__tar.gz

{nanocode_cli-0.7.0/nanocode_cli.egg-info → nanocode_cli-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.7.0
+Version: 0.7.2
 Summary: A small terminal coding agent written in Python
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause

{nanocode_cli-0.7.0 → nanocode_cli-0.7.2}/nanocode.py

@@ -4,6 +4,8 @@ from __future__ import annotations
 
 import argparse
 import codecs
+import contextlib
+import copy
 import difflib
 import asyncio
 import fnmatch
@@ -12,6 +14,7 @@ import json
 import logging
 import os
 import platform
+import random
 import re
 import selectors
 import shlex
@@ -60,7 +63,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 from rich.rule import Rule
 
-__version__ = "0.7.0"
+__version__ = "0.7.2"
 
 Json = dict[str, Any]
 HTTP_USER_AGENT = "nanocode/" + __version__
@@ -77,8 +80,9 @@ REASONING_LEVELS = ("minimal", "low", "medium", "high", "xhigh")
 REASONING_CHOICES = ("off", *REASONING_LEVELS)
 CHAT_REASONING_CHOICES = ("auto", "off", "reasoning", "reasoning_effort", "thinking", "enable_thinking")
 ANTHROPIC_DEFAULT_MAX_TOKENS = 16_384
+DEEPSEEK_DEFAULT_MAX_TOKENS = 32_768
 CHAT_REASONING_EFFORT_VALUES: dict[str, dict[str, str | int]] = {
-    "thinking": {"minimal": "high", "low": "high", "medium": "high", "high": "high", "xhigh": "max"},
+    "thinking": {"minimal": "high", "low": "high", "medium": "high", "high": "max", "xhigh": "max"},
     "enable_thinking": {"minimal": 256, "low": 1024, "medium": 4096, "high": 8192, "xhigh": 16384},
 }
 SELECTION_BACK = object()
@@ -139,10 +143,10 @@ class ProviderConfig:
         ("thinking", ("deepseek-v4",)),
     )
     PROFILES: ClassVar[dict[str, dict[str, Any]]] = {
-        "api.openai.com": {"chat_reasoning_rules": (("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),)},
+        "api.openai.com": {"chat_reasoning_rules": (("reasoning_effort", ("o1", "o3", "o4", "gpt-5")),), "strict_tools": True},
         "openrouter.ai": {"chat_reasoning": "reasoning"},
         "opencode.ai": {"api_rules": (("anthropic", ("claude-", "qwen3.")),), "chat_reasoning_rules": (("reasoning", ("deepseek-v4",)),)},
-        "api.deepseek.com": {"chat_reasoning": "thinking"},
+        "api.deepseek.com": {"chat_reasoning": "thinking", "max_tokens": DEEPSEEK_DEFAULT_MAX_TOKENS, "prompt_cache_key": False, "strict_tools": True, "strict_beta": True},
         "dashscope.aliyuncs.com": {"chat_reasoning_rules": ALIYUN_CHAT_REASONING_RULES},
         "dashscope-intl.aliyuncs.com": {"chat_reasoning_rules": ALIYUN_CHAT_REASONING_RULES},
         "dashscope-us.aliyuncs.com": {"chat_reasoning_rules": ALIYUN_CHAT_REASONING_RULES},
@@ -155,6 +159,8 @@ class ProviderConfig:
     prompt_cache_key: str = "auto"
     available_models: tuple[str, ...] = ()
     temperature: float | None = None
+    max_tokens: int = 0
+    strict_tools: bool = False
     reasoning: str = "medium"
     chat_reasoning: str = "auto"
     timeout: int = 180
@@ -180,20 +186,30 @@ class ProviderConfig:
             prompt_cache_key=prompt_cache_key,
             available_models=Config.str_tuple(data, "available_models"),
             temperature=Config.float(data, "temperature", None),
+            max_tokens=max(0, Config.int(data, "max_tokens", 0)),
+            strict_tools=Config.bool(data, "strict_tools", False),
             reasoning=reasoning,
             chat_reasoning=chat_reasoning,
             timeout=Config.int(data, "timeout", 180),
         )
 
-    def base_url(self) -> str:
+    def _stripped_url(self) -> str:
         url = self.url.rstrip("/")
         for suffix in ("/chat/completions", "/responses", "/messages"):
             if url.endswith(suffix):
                 return url[: -len(suffix)]
         return url
 
+    def base_url(self) -> str:
+        url = self._stripped_url()
+        # Strict tool calling is a beta feature on some hosts (DeepSeek); route to /beta only
+        # when strict is actually active, so non-strict users stay on the stable endpoint.
+        if self.resolved_strict_tools() and (self.PROFILES.get(self.host()) or {}).get("strict_beta") and not url.endswith("/beta"):
+            url = url + "/beta"
+        return url
+
     def host(self) -> str:
-        return (urlparse(self.base_url()).hostname or "").lower()
+        return (urlparse(self._stripped_url()).hostname or "").lower()
 
     def resolved_chat_reasoning(self) -> str:
         return self.profile_value(self.chat_reasoning, "off", "chat_reasoning", "chat_reasoning_rules")
@@ -216,6 +232,25 @@ class ProviderConfig:
     def reasoning_effort(self) -> str:
         return self.reasoning if self.reasoning in REASONING_LEVELS else "medium"
 
+    def resolved_max_tokens(self) -> int:
+        if self.max_tokens > 0:
+            return self.max_tokens
+        # No global default: generic OpenAI-compatible providers keep their own server-side cap.
+        # Only profiles that opt in (e.g. DeepSeek thinking mode) get an explicit ceiling.
+        return int((self.PROFILES.get(self.host()) or {}).get("max_tokens", 0))
+
+    def supports_prompt_cache_key(self) -> bool:
+        # Default on for unknown OpenAI-compatible hosts (status quo); profiles opt out
+        # (e.g. DeepSeek caches automatically by prefix and ignores the key).
+        return bool((self.PROFILES.get(self.host()) or {}).get("prompt_cache_key", True))
+
+    def supports_strict_tools(self) -> bool:
+        return bool((self.PROFILES.get(self.host()) or {}).get("strict_tools"))
+
+    def resolved_strict_tools(self) -> bool:
+        # Only emit strict schemas on the chat path of a host known to support strict mode.
+        return self.strict_tools and self.supports_strict_tools() and self.resolved_api() == "chat"
+
     @staticmethod
     def clean_prompt_cache_key(value: str) -> str:
         value = value.strip()
@@ -242,6 +277,7 @@ class RuntimeSettings:
     mcp_selector: str = ""
     yolo: bool = False
     debug: bool = False
+    tips: bool = True
 
     @classmethod
     def from_dict(cls, data: Json, *, yolo: bool = False, debug: bool = False, mcp_selector: str = "") -> "RuntimeSettings":
@@ -257,6 +293,7 @@ class RuntimeSettings:
             mcp_selector=mcp_selector,
             yolo=yolo or Config.bool(runtime, "yolo", False),
             debug=debug or Config.bool(runtime, "debug", False),
+            tips=Config.bool(runtime, "tips", True),
         )
 
 
@@ -350,6 +387,8 @@ api = "auto"
 prompt_cache_key = "auto"
 # available_models = ["gpt-5", "gpt-5-mini"]
 # temperature = 0.2
+# max_tokens = 16384
+# strict_tools = false  # constrain tool-call args to the schema (OpenAI / DeepSeek beta)
 reasoning = "medium"
 # chat_reasoning = "auto"
 timeout = 180
@@ -366,6 +405,7 @@ check_updates = true
 update_check_interval_hours = 24
 session_retention_days = 7
 yolo = false
+tips = true
 
 # [mcp.example]
 # url = "https://example.com/mcp"
@@ -490,6 +530,7 @@ class AgentState:
     code_index_error: str = ""
     code_index_notice: str = ""
     code_index_refreshing: bool = False
+    code_index_checking: bool = False
     context_percent: int = 0
     turn_step: int = 0
     turn_tool_calls: int = 0
@@ -528,7 +569,9 @@ class AgentState:
 
     def format(self) -> str:
         known = ["- " + item for item in self.known] or ["- (empty)"]
-        return "\n".join(["Goal: " + (self.goal or "(empty)"), "Plan:", *self.plan_rows_for(self.plan), "Known:", *known, "Check: " + (self.check or "(empty)")])
+        return "\n".join(
+            ["Goal: " + (self.goal or "(empty)"), "Plan:", *self.plan_rows_for(self.plan), "Known:", *known, "Check: " + (self.check or "(empty)")]
+        )
 
 
 @dataclass
@@ -915,16 +958,12 @@ class SessionSnapshotCodec:
     @staticmethod
     def tool_records(data: list[Json]) -> list[ToolResultRecord]:
         return [
-            ToolResultRecord(key=rec["key"], name=rec["name"], args=rec.get("args", []), output=rec.get("output", ""), note=rec.get("note", ""))
-            for rec in data
+            ToolResultRecord(key=rec["key"], name=rec["name"], args=rec.get("args", []), output=rec.get("output", ""), note=rec.get("note", "")) for rec in data
         ]
 
     @staticmethod
     def tool_errors(data: list[Json]) -> list[ToolErrorRecord]:
-        return [
-            ToolErrorRecord(key=err["key"], name=err["name"], args=err.get("args", []), error=err.get("error", ""))
-            for err in data
-        ]
+        return [ToolErrorRecord(key=err["key"], name=err["name"], args=err.get("args", []), error=err.get("error", "")) for err in data]
 
 
 class SessionSnapshotStore:
@@ -1246,6 +1285,59 @@ class UpdateChecker:
         )
 
 
+def strict_tool_schema(schema: Json) -> Json:
+    """Rewrite a JSON Schema to satisfy strict function-calling (OpenAI / DeepSeek beta):
+    every object property becomes required (genuine optionals turned nullable),
+    additionalProperties is forced false, and unsupported keywords are dropped."""
+
+    def transform(node: Any) -> Any:
+        if isinstance(node, list):
+            return [transform(item) for item in node]
+        if not isinstance(node, dict):
+            return node
+        node = {key: transform(value) for key, value in node.items() if key not in ("minItems", "maxItems", "minLength", "maxLength")}
+        if isinstance(node.get("properties"), dict):
+            required = set(node.get("required") or [])
+            for key, sub in node["properties"].items():
+                if key not in required and isinstance(sub, dict):
+                    node["properties"][key] = nullable(sub)
+            node["required"] = list(node["properties"].keys())
+            node["additionalProperties"] = False
+        return node
+
+    # Strict validators only allow scalar types in a `type` union; object/array nullability
+    # must be expressed with anyOf instead (e.g. {"anyOf": [<array schema>, {"type": "null"}]}).
+    scalars = ("string", "number", "integer", "boolean")
+
+    def nullable(sub: Json) -> Json:
+        kind = sub.get("type")
+        if isinstance(kind, str) and kind in scalars:
+            sub["type"] = [kind, "null"]
+        elif isinstance(kind, list) and all(item in (*scalars, "null") for item in kind):
+            if "null" not in kind:
+                sub["type"] = [*kind, "null"]
+        else:
+            return {"anyOf": [sub, {"type": "null"}]}
+        # An enum must accept null too, otherwise strict validation rejects the "omitted" value.
+        if isinstance(sub.get("enum"), list) and None not in sub["enum"]:
+            sub["enum"] = [*sub["enum"], None]
+        return sub
+
+    return transform(copy.deepcopy(schema))
+
+
+def strictifiable(schema: Any) -> bool:
+    """False if the schema contains a free-form object (an `object` with no `properties`),
+    which strict function calling cannot represent — such tools fall back to non-strict."""
+    if isinstance(schema, dict):
+        if schema.get("type") == "object" and "properties" not in schema:
+            return False
+        return all(strictifiable(value) for value in schema.values())
+    if isinstance(schema, list):
+        return all(strictifiable(item) for item in schema)
+    return True
+
+
 class Tool:
     NAME: ClassVar[str] = ""
     DESCRIPTION: ClassVar[str] = ""
@@ -1261,9 +1353,13 @@ class Tool:
         self.args = args
 
     @classmethod
-    def schema(cls) -> Json:
+    def schema(cls, strict: bool = False) -> Json:
         description = "\n".join([cls.DESCRIPTION, "Signature: " + cls.SIGNATURE, *(("- " + item) for item in cls.EXAMPLE if item)])
-        return {"type": "function", "function": {"name": cls.NAME, "description": description, "parameters": cls.params_schema()}}
+        function: Json = {"name": cls.NAME, "description": description, "parameters": cls.params_schema()}
+        if strict and strictifiable(function["parameters"]):
+            function["parameters"] = strict_tool_schema(function["parameters"])
+            function["strict"] = True
+        return {"type": "function", "function": function}
 
     @classmethod
     def params_schema(cls) -> Json:
@@ -1379,7 +1475,10 @@ class ReadTool(Tool):
     def arg_schema(cls) -> Json:
         return {
             "type": "object",
-            "properties": {"path": {"type": "string"}, "ranges": {"type": "array", "minItems": 1, "items": cls.RANGE_SCHEMA}},
+            "properties": {
+                "path": {"type": "string", "description": "File path to read"},
+                "ranges": {"type": "array", "minItems": 1, "items": cls.RANGE_SCHEMA, "description": "Line ranges [[start,end],...], 0-based and end-exclusive; omit to read the whole file"},
+            },
             "required": ["path"],
             "additionalProperties": False,
         }
@@ -1389,9 +1488,9 @@ class ReadTool(Tool):
         return {
             "type": "object",
             "properties": {
-                "path": {"type": "string"},
-                "ranges": {"type": "array", "items": cls.RANGE_SCHEMA, "minItems": 1},
-                "files": {"type": "array", "items": cls.arg_schema(), "minItems": 1},
+                "path": {"type": "string", "description": "File path to read (single-file form)"},
+                "ranges": {"type": "array", "items": cls.RANGE_SCHEMA, "minItems": 1, "description": "Line ranges [[start,end],...], 0-based and end-exclusive; omit to read the whole file"},
+                "files": {"type": "array", "items": cls.arg_schema(), "minItems": 1, "description": "Batch form: list of {path, ranges} to read several files in one call"},
             },
             "additionalProperties": False,
         }
@@ -1489,7 +1588,7 @@ class LineCountTool(Tool):
     def params_schema(cls) -> Json:
         return {
             "type": "object",
-            "properties": {"paths": {"type": "array", "items": {"type": "string"}, "minItems": 1}},
+            "properties": {"paths": {"type": "array", "items": {"type": "string"}, "minItems": 1, "description": "File paths to count lines for"}},
             "required": ["paths"],
             "additionalProperties": False,
         }
@@ -1534,7 +1633,15 @@ class ListTool(Tool):
 
     @classmethod
     def params_schema(cls) -> Json:
-        return {"type": "object", "properties": {"path": {"type": "string"}, "glob": {"type": "string"}}, "required": ["path"], "additionalProperties": False}
+        return {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Directory to list"},
+                "glob": {"type": "string", "description": "Optional glob filtering child names (non-recursive), e.g. test_*.py"},
+            },
+            "required": ["path"],
+            "additionalProperties": False,
+        }
 
     @classmethod
     def payload_args(cls, payload: Json) -> list[Any]:
@@ -1599,10 +1706,10 @@ class FindTool(Tool):
         return {
             "type": "object",
             "properties": {
-                "name": {"type": "string"},
-                "path": {"type": "string"},
-                "type": {"type": "string", "enum": ["file", "dir", "any"]},
-                "limit": {"type": "integer", "minimum": 1, "maximum": cls.MAX_LIMIT},
+                "name": {"type": "string", "description": "Glob or exact name to match, e.g. *.py or migrations"},
+                "path": {"type": "string", "description": "Directory to search under; defaults to repo root"},
+                "type": {"type": "string", "enum": ["file", "dir", "any"], "description": "Match files, dirs, or any; default file"},
+                "limit": {"type": "integer", "minimum": 1, "maximum": cls.MAX_LIMIT, "description": f"Max results, 1..{cls.MAX_LIMIT}; default 100"},
             },
             "required": ["name"],
             "additionalProperties": False,
@@ -1611,7 +1718,7 @@ class FindTool(Tool):
     @classmethod
     def params_schema(cls) -> Json:
         props = dict(cls.arg_schema()["properties"])
-        props["queries"] = {"type": "array", "items": cls.arg_schema(), "minItems": 1}
+        props["queries"] = {"type": "array", "items": cls.arg_schema(), "minItems": 1, "description": "Batch form: list of find queries to run in one call"}
         return {"type": "object", "properties": props, "additionalProperties": False}
 
     @classmethod
@@ -1717,10 +1824,10 @@ class SearchTool(Tool):
         return {
             "type": "object",
             "properties": {
-                "pattern": {"type": "string"},
-                "path": {"type": "string"},
-                "glob": {"type": "string"},
-                "context": {"type": "integer", "minimum": 0, "maximum": cls.MAX_CONTEXT},
+                "pattern": {"type": "string", "description": "Case-insensitive regex; alternation A|B|C is allowed"},
+                "path": {"type": "string", "description": "File or directory to search under; defaults to repo root"},
+                "glob": {"type": "string", "description": "Optional glob limiting which files are searched, e.g. *.py"},
+                "context": {"type": "integer", "minimum": 0, "maximum": cls.MAX_CONTEXT, "description": f"Context lines around each match, 0..{cls.MAX_CONTEXT}"},
             },
             "required": ["pattern"],
             "additionalProperties": False,
@@ -1729,7 +1836,7 @@ class SearchTool(Tool):
     @classmethod
     def params_schema(cls) -> Json:
         props = dict(cls.arg_schema()["properties"])
-        props["queries"] = {"type": "array", "items": cls.arg_schema(), "minItems": 1}
+        props["queries"] = {"type": "array", "items": cls.arg_schema(), "minItems": 1, "description": "Batch form: list of search queries to run in one call"}
         return {"type": "object", "properties": props, "additionalProperties": False}
 
     @classmethod
@@ -2001,6 +2108,25 @@ class CodeIndex:
             return ""
         return self.update([self.session.resolve_path(path) for path in files])
 
+    def update_pending_async(self) -> None:
+        """Run the working-tree check (and any auto-update) off the UI critical path.
+
+        ``update_pending`` does a ``check=True`` scan that walks/hashes the tree — slow on
+        large repos. Running it inline blocks answer emission and /status, so spawn it in a
+        daemon thread. Guarded so only one scan/update runs at a time.
+        """
+        if self.session.state.code_index_checking or self.session.state.code_index_refreshing:
+            return
+        self.session.state.code_index_checking = True
+
+        def run() -> None:
+            try:
+                self.update_pending()
+            finally:
+                self.session.state.code_index_checking = False
+
+        threading.Thread(target=run, daemon=True).start()
+
     def refresh_existing_async(self) -> bool:
         if self.session.state.code_index_refreshing:
             return False
@@ -2055,18 +2181,18 @@ class InspectCodeTool(Tool):
     @classmethod
     def params_schema(cls) -> Json:
         props = {
-            "mode": {"type": "string", "enum": list(cls.MODES)},
-            "target": {"type": "string"},
-            "limit": {"type": "integer", "minimum": 1, "maximum": cls.MAX_OUTLINE_LIMIT},
-            "kind": {"type": "string"},
-            "path": {"type": "string"},
-            "symbol": {"type": "string"},
-            "exact_only": {"type": "boolean"},
-            "depth": {"type": "integer", "minimum": 1, "maximum": cls.MAX_DEPTH},
-            "offset": {"type": "integer", "minimum": 0},
-            "all_kinds": {"type": "boolean"},
-            "ref_kind": {"type": "string"},
-            "loose": {"type": "boolean"},
+            "mode": {"type": "string", "enum": list(cls.MODES), "description": "Query type: find|inspect|outline|refs|impls|callers|callees"},
+            "target": {"type": "string", "description": "Symbol name (find/inspect/refs/impls/callers/callees) or file path (outline)"},
+            "limit": {"type": "integer", "minimum": 1, "maximum": cls.MAX_OUTLINE_LIMIT, "description": "Max results"},
+            "kind": {"type": "string", "description": "Restrict to a symbol kind, e.g. function, class, method"},
+            "path": {"type": "string", "description": "Restrict the search to this file or directory"},
+            "symbol": {"type": "string", "description": "Disambiguate target when multiple symbols share a name"},
+            "exact_only": {"type": "boolean", "description": "Match the target name exactly instead of fuzzily"},
+            "depth": {"type": "integer", "minimum": 1, "maximum": cls.MAX_DEPTH, "description": "Call-chain depth for callers/callees"},
+            "offset": {"type": "integer", "minimum": 0, "description": "Pagination offset for refs/impls"},
+            "all_kinds": {"type": "boolean", "description": "Include all reference kinds, not just behavioral ones (refs)"},
+            "ref_kind": {"type": "string", "description": "Restrict refs to a specific reference kind"},
+            "loose": {"type": "boolean", "description": "Loosen call-chain matching (callees)"},
         }
         return {"type": "object", "properties": props, "required": ["mode", "target"], "additionalProperties": False}
 
@@ -2190,13 +2316,23 @@ class EditTool(Tool):
     def params_schema(cls) -> Json:
         edit = {
             "type": "object",
-            "properties": {key: {"type": "string"} for key in ("op", "start", "end", "content", "old", "new")},
+            "properties": {
+                "op": {"type": "string", "description": "create|replace|delete|insert_before|insert_after|replace_all"},
+                "start": {"type": "string", "description": "Start anchor line:hash (inclusive) for replace/delete/insert"},
+                "end": {"type": "string", "description": "End anchor line:hash (inclusive) for replace/delete"},
+                "content": {"type": "string", "description": "New text for create/replace/insert"},
+                "old": {"type": "string", "description": "Text to find for replace_all"},
+                "new": {"type": "string", "description": "Replacement text for replace_all"},
+            },
             "required": ["op"],
             "additionalProperties": False,
         }
         return {
             "type": "object",
-            "properties": {"path": {"type": "string"}, "edits": {"type": "array", "items": edit, "minItems": 1}},
+            "properties": {
+                "path": {"type": "string", "description": "File to create or patch"},
+                "edits": {"type": "array", "items": edit, "minItems": 1, "description": "Ordered edit operations to apply"},
+            },
             "required": ["path", "edits"],
             "additionalProperties": False,
         }
@@ -2445,7 +2581,7 @@ class BashTool(Tool):
     def params_schema(cls) -> Json:
         return {
             "type": "object",
-            "properties": {"command": {"type": "string", "minLength": 1, "pattern": "^.*\\S.*$"}},
+            "properties": {"command": {"type": "string", "minLength": 1, "pattern": "^.*\\S.*$", "description": "Bash command to run in the workspace; filter noisy output with head/tail/rg"}},
             "required": ["command"],
             "additionalProperties": False,
         }
@@ -2565,7 +2701,9 @@ class BashTool(Tool):
 
 class GitTool(Tool):
     NAME = "Git"
-    DESCRIPTION = 'Run git with explicit argv (default: cwd from Environment; use cwd= for other directories). For add, pass explicit file paths; broad add is rejected.'
+    DESCRIPTION = (
+        "Run git with explicit argv (default: cwd from Environment; use cwd= for other directories). For add, pass explicit file paths; broad add is rejected."
+    )
     SIGNATURE = "Git(argv=[command,...], cwd?)"
     EXAMPLE = (
         'Status. Example: {"argv":["status","--short"]}',
@@ -2580,7 +2718,10 @@ class GitTool(Tool):
     def params_schema(cls) -> Json:
         return {
             "type": "object",
-            "properties": {"cwd": {"type": "string"}, "argv": {"type": "array", "items": {"type": "string", "minLength": 1}, "minItems": 1}},
+            "properties": {
+                "cwd": {"type": "string", "description": "Working directory for the git command; defaults to repo root"},
+                "argv": {"type": "array", "items": {"type": "string", "minLength": 1}, "minItems": 1, "description": "Git command and args as a list, e.g. [\"status\",\"--short\"]"},
+            },
             "required": ["argv"],
             "additionalProperties": False,
         }
@@ -2589,11 +2730,7 @@ class GitTool(Tool):
     def payload_args(cls, payload: Json) -> list[Any]:
         argv = payload.get("argv")
         if not isinstance(argv, list) or not argv:
-            raise ToolError(
-                "Git requires a non-empty 'argv' list. "
-                'Signature: Git(argv=[command,...], cwd?)  '
-                'Example: {"argv":["status","--short"]}'
-            )
+            raise ToolError('Git requires a non-empty \'argv\' list. Signature: Git(argv=[command,...], cwd?)  Example: {"argv":["status","--short"]}')
         argv = [str(a) for a in argv]
         return [("cwd=" + str(payload["cwd"])), *argv] if payload.get("cwd") else argv
 
@@ -2695,8 +2832,8 @@ class RecallTool(Tool):
         return {
             "type": "object",
             "properties": {
-                "keys": {"type": "array", "items": {"type": "string", "pattern": "^tr\\.\\d+$"}, "minItems": 1},
-                "ranges": {"type": "array", "items": cls.RANGE_SCHEMA, "minItems": 1},
+                "keys": {"type": "array", "items": {"type": "string", "pattern": "^tr\\.\\d+$"}, "minItems": 1, "description": "Stored result keys to recall, e.g. [\"tr.3\",\"tr.5\"]"},
+                "ranges": {"type": "array", "items": cls.RANGE_SCHEMA, "minItems": 1, "description": "Optional 0-based [start,end] output-line slices to limit recalled context"},
             },
             "required": ["keys"],
             "additionalProperties": False,
@@ -2776,16 +2913,24 @@ class NoteTool(Tool):
 
     @classmethod
     def params_schema(cls) -> Json:
-        strings = {"type": "array", "items": {"type": "string"}}
         plan_item = {
             "type": "object",
-            "properties": {"status": {"type": "string", "enum": list(PlanItem.STATUSES)}, "text": {"type": "string"}},
+            "properties": {
+                "status": {"type": "string", "enum": list(PlanItem.STATUSES), "description": "todo|doing|done|blocked"},
+                "text": {"type": "string", "description": "Plan step description"},
+            },
             "required": ["status", "text"],
             "additionalProperties": False,
         }
         return {
             "type": "object",
-            "properties": {"set_goal": {"type": "string"}, "replace_plan": {"type": "array", "items": plan_item}, "append_known": strings, "replace_known": strings, "set_check": {"type": "string"}},
+            "properties": {
+                "set_goal": {"type": "string", "description": "Replace the current goal"},
+                "replace_plan": {"type": "array", "items": plan_item, "description": "Replace the plan with these status/text items"},
+                "append_known": {"type": "array", "items": {"type": "string"}, "description": "Append these facts to known"},
+                "replace_known": {"type": "array", "items": {"type": "string"}, "description": "Replace all known facts with these"},
+                "set_check": {"type": "string", "description": "Replace the success/verification criteria"},
+            },
             "additionalProperties": False,
         }
 
@@ -2872,7 +3017,7 @@ class QuestionSpec:
 class QuestionTool(Tool):
     NAME = "Question"
     DESCRIPTION = "Ask the user one or more questions (asked in sequence) and wait for their answers. Use when intent is genuinely ambiguous, a choice affects the codebase's external shape (module layout, public API, naming), or you need prioritization; prefer offering choices with previews, and optionally a recommended index when one option is clearly best. Do NOT ask about trivial internal details or anything determinable from context (Read/InspectCode/Bash) or already specified; if a reasonable default exists, proceed."
-    SIGNATURE = 'Question(questions=[{question, choices?, previews?, recommended?}, ...])'
+    SIGNATURE = "Question(questions=[{question, choices?, previews?, recommended?}, ...])"
     EXAMPLE = (
         'One question, recommending a choice. Example: {"questions":[{"question":"Which approach?","choices":["Refactor","Rewrite"],"previews":["Extract module +87 -12","Rewrite from scratch"],"recommended":0}]}',
         'Batch related questions. Example: {"questions":[{"question":"Target runtime?","choices":["Node","Deno"]},{"question":"Name the module?"}]}',
@@ -2971,6 +3116,7 @@ class QuestionTool(Tool):
         label = Tool.compact(first, 80)
         return [label + (f" (+{len(questions) - 1} more)" if len(questions) > 1 else "")]
 
+
 class MCPTool(Tool):
     NAME = "MCP"
     DESCRIPTION = "Call/describe external MCP server tools, and list/read MCP resources"
@@ -3085,9 +3231,10 @@ class MCPTool(Tool):
             return mcp.read_resource(server, str(payload.get("uri") or ""))
         raise ToolError(
             f"unknown MCP action {action!r}. Valid actions: {', '.join(self.ACTIONS)}. "
-            f"To invoke a remote tool named {action!r}, use action=\"call\", tool={action!r}."
+            f'To invoke a remote tool named {action!r}, use action="call", tool={action!r}.'
         )
 
+
 TOOLS: tuple[type[Tool], ...] = (
     MCPTool,
     ReadTool,
@@ -3121,8 +3268,7 @@ class ContextManager:
     COMPACT_RECENT_MESSAGES: ClassVar[int] = 8
     MCP_DESCRIBE_BLOCK: ClassVar[re.Pattern] = re.compile(r"<MCPDescribe server=(\".*?\") tool=(\".*?\")>.*?</MCPDescribe>", re.DOTALL)
     CODE_EXTENSIONS: ClassVar[set[str]] = set(
-        ".c .cc .cpp .cxx .css .go .h .hpp .html .java .js .json .jsx .kt .lua .php .py .rb .rs .scss .sh .sql "
-        ".swift .toml .ts .tsx .vue .yaml .yml".split()
+        ".c .cc .cpp .cxx .css .go .h .hpp .html .java .js .json .jsx .kt .lua .php .py .rb .rs .scss .sh .sql .swift .toml .ts .tsx .vue .yaml .yml".split()
     )
     CODE_FILENAMES: ClassVar[set[str]] = {"CMakeLists.txt", "Dockerfile", "Makefile", "go.mod", "package.json", "pyproject.toml"}
 
@@ -4091,6 +4237,33 @@ class MCPManager:
     def run_async(self, coroutine: Any) -> Any:
         return asyncio.run_coroutine_threadsafe(coroutine, self._async_loop()).result()
 
+    def close(self) -> None:
+        # Stop and join the background loop before the interpreter tears down its
+        # default executors. Otherwise an in-flight client cleanup (HTTP session
+        # termination, DNS via run_in_executor) races the concurrent.futures atexit
+        # shutdown and prints "cannot schedule new futures after shutdown".
+        with self._loop_lock:
+            loop = self._loop
+            thread = self._loop_thread
+            self._loop = None
+            self._loop_thread = None
+        if loop is None or thread is None:
+            return
+
+        async def _shutdown() -> None:
+            pending = [t for t in asyncio.all_tasks(loop) if t is not asyncio.current_task()]
+            for task in pending:
+                task.cancel()
+            for task in pending:
+                with contextlib.suppress(BaseException):
+                    await task
+
+        if loop.is_running():
+            with contextlib.suppress(BaseException):
+                asyncio.run_coroutine_threadsafe(_shutdown(), loop).result(timeout=5)
+            loop.call_soon_threadsafe(loop.stop)
+        thread.join(timeout=5)
+
     def oauth_client(self, config: MCPServerConfig, *, interactive: bool = False, notify: Callable[[str], None] | None = None) -> Any:
         from fastmcp.client.auth import OAuth
 
@@ -4185,7 +4358,9 @@ class MCPManager:
 
         try:
             result = self.run_async(
-                self._call_oauth_tool(config, headers, tool_name, arguments) if config.auth == "oauth" else self._call_tool(config, headers, tool_name, arguments)
+                self._call_oauth_tool(config, headers, tool_name, arguments)
+                if config.auth == "oauth"
+                else self._call_tool(config, headers, tool_name, arguments)
             )
         except Exception as e:
             raise ToolError("MCP call failed: " + self.error_text(e))
@@ -4226,9 +4401,7 @@ class MCPManager:
             raise ToolError("MCP read_resource requires a uri")
         config, headers = self._resource_preamble(server)
         try:
-            result = self.run_async(
-                self._read_oauth_resource(config, headers, uri) if config.auth == "oauth" else self._read_resource(config, headers, uri)
-            )
+            result = self.run_async(self._read_oauth_resource(config, headers, uri) if config.auth == "oauth" else self._read_resource(config, headers, uri))
         except Exception as e:
             raise ToolError("MCP resource read failed: " + self.error_text(e))
         text = self.normalize_resource(result)
@@ -4346,7 +4519,9 @@ class MCPManager:
         from fastmcp.client.transports import StreamableHttpTransport
 
         timeout = self.discovery_timeout()
-        async with Client(StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout) as client:
+        async with Client(
+            StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout
+        ) as client:
             return await asyncio.wait_for(client.list_resources(), timeout=timeout)
 
     async def _read_resource(self, config: MCPServerConfig, headers: dict[str, str], uri: str) -> Any:
@@ -4361,7 +4536,9 @@ class MCPManager:
         from fastmcp.client.transports import StreamableHttpTransport
 
         timeout = self.call_timeout()
-        async with Client(StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout) as client:
+        async with Client(
+            StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout
+        ) as client:
             return await asyncio.wait_for(client.read_resource(uri), timeout=timeout)
 
     async def _call_oauth_tool(self, config: MCPServerConfig, headers: dict[str, str], name: str, arguments: Json) -> Any:
@@ -4369,7 +4546,9 @@ class MCPManager:
         from fastmcp.client.transports import StreamableHttpTransport
 
         timeout = self.call_timeout()
-        async with Client(StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout) as client:
+        async with Client(
+            StreamableHttpTransport(config.url, headers=headers), auth=self.oauth_client(config), timeout=timeout, init_timeout=timeout
+        ) as client:
             return await asyncio.wait_for(client.call_tool(name, arguments), timeout=timeout)
 
     def login_server(self, name: str, notify: Callable[[str], None] | None = None) -> str:
@@ -4553,7 +4732,7 @@ class MCPManager:
                     if line:
                         lines.append(line)
             if resources:
-                lines.append(f"resources ({len(resources)}) — read with MCP(action=\"read_resource\", server={json.dumps(config.name)}, uri=...):")
+                lines.append(f'resources ({len(resources)}) — read with MCP(action="read_resource", server={json.dumps(config.name)}, uri=...):')
                 lines.extend(self._format_resource_line(res) for res in resources)
             lines.append("")
 
@@ -4633,7 +4812,7 @@ class MCPManager:
                 lines.append(line)
         resources = self.resources.get(server, [])
         if resources:
-            lines.append(f"resources ({len(resources)}) — read with MCP(action=\"read_resource\", server={json.dumps(server)}, uri=...):")
+            lines.append(f'resources ({len(resources)}) — read with MCP(action="read_resource", server={json.dumps(server)}, uri=...):')
             lines.extend(self._format_resource_line(res) for res in resources)
         return "\n".join(lines)
 
@@ -4651,7 +4830,7 @@ class MCPManager:
         # truncated above, so surface any resource-like URIs it mentions explicitly.
         uris = self._extract_uris(info.description)
         if uris:
-            line += "\n  refs (read with MCP action=\"read_resource\"): " + ", ".join(uris)
+            line += '\n  refs (read with MCP action="read_resource"): ' + ", ".join(uris)
         if include_schema:
             schema = self._schema_json(info.input_schema, self.INDEX_SCHEMA_LIMIT)
             if schema:
@@ -4760,13 +4939,24 @@ class MCPManager:
             if config.env_http_headers:
                 for header_name in config.env_http_headers:
                     auth.append("env_header(" + header_name + ")")
-            lines.append("| `" + self.markdown_cell(config.name) + "` | " + self.markdown_cell(status) + " | " + self.markdown_cell(tools or "-") + " | " + self.markdown_cell(", ".join(auth) or "-") + " |")
+            lines.append(
+                "| `"
+                + self.markdown_cell(config.name)
+                + "` | "
+                + self.markdown_cell(status)
+                + " | "
+                + self.markdown_cell(tools or "-")
+                + " | "
+                + self.markdown_cell(", ".join(auth) or "-")
+                + " |"
+            )
         return "\n".join(lines) if len(lines) > 2 else "(no MCP servers configured)"
 
     @staticmethod
     def markdown_cell(text: str) -> str:
         return Text.clean(str(text)).replace("\n", " ").replace("|", "\\|")
 
+
 class ToolRunner:
     def __init__(self, session: Session, context: ContextManager, input_fn=input, output_fn=print):
         self.session = session
@@ -4776,7 +4966,7 @@ class ToolRunner:
         self.preview_fn: Callable[[str], bool] | None = None
         self.preview_full_fn: Callable[[str], None] | None = None
         self.live_output: Callable[[str, str], None] | None = None
-        self.live_start: Callable[[], None] | None = None
+        self.live_start: Callable[[str], None] | None = None
         self.question_fn: Callable[[QuestionSpec, str], str] | None = None
 
     def run(self, calls: list[ToolCall], batch_suffix: str = "") -> list[Json]:
@@ -4945,7 +5135,7 @@ class ToolRunner:
                     return "refused", self.finish(call, output, failed=True, elapsed=time.monotonic() - started, display=display, batch_suffix=batch_suffix)
                 approved = True
             if isinstance(tool, BashTool) and self.live_start is not None:
-                self.live_start()
+                self.live_start(str(call.args[0]) if call.args else "")
             output = planned_edit.call(tool) if planned_edit and isinstance(tool, EditTool) else tool.call()
         except ToolError as error:
             return "failed", self.reject(call, f"ToolError: {error}", elapsed=time.monotonic() - started, display=display, batch_suffix=batch_suffix)
@@ -4991,7 +5181,9 @@ class ToolRunner:
             self.session.record_tool_error(key or "-", call.name, call.args, output)
         elif key:
             self.update_code_index(call, output)
-        self.output_fn(self.finish_display(call, key, output, failed=failed, approved=approved, auto=auto, display=display, batch_suffix=batch_suffix, elapsed=elapsed))
+        self.output_fn(
+            self.finish_display(call, key, output, failed=failed, approved=approved, auto=auto, display=display, batch_suffix=batch_suffix, elapsed=elapsed)
+        )
         return self.tool_message(call, key, output, failed=failed, display=display)
 
     def tool_message(self, call: ToolCall, key: str, output: str, *, failed: bool = False, display: str | None = None) -> str:
@@ -5067,7 +5259,17 @@ class ToolRunner:
         return "\n".join(["  preview", *("  " + line for line in lines)])
 
     def finish_display(
-        self, call: ToolCall, key: str, output: str, *, failed: bool, approved: bool = False, auto: bool = False, display: str | None = None, batch_suffix: str = "", elapsed: float | None = None
+        self,
+        call: ToolCall,
+        key: str,
+        output: str,
+        *,
+        failed: bool,
+        approved: bool = False,
+        auto: bool = False,
+        display: str | None = None,
+        batch_suffix: str = "",
+        elapsed: float | None = None,
     ) -> str:
         if call.name == "Note" and not failed and display:
             return self.with_batch_suffix(display.removeprefix("Note ").strip(), batch_suffix)
@@ -5208,7 +5410,7 @@ class ModelClient:
         provider = self.session.config.provider
         if missing := self.session.missing_config():
             raise ModelError("missing config: " + ", ".join(missing))
-        tools = [tool.schema() for tool in TOOL_REGISTRY.values()]
+        tools = [tool.schema(provider.resolved_strict_tools()) for tool in TOOL_REGISTRY.values()]
         for attempt in range(MODEL_REQUEST_RETRIES + 1):
             self.session.state.current_model_call_started_at = time.monotonic()
             try:
@@ -5249,6 +5451,8 @@ class ModelClient:
         messages = Text.value(messages)
         provider = self.session.config.provider
         params: Json = {"model": provider.model, "messages": messages, "stream": False}
+        if (max_tokens := provider.resolved_max_tokens()) > 0:
+            params["max_tokens"] = max_tokens
         if tools:
             params["tools"] = tools
             params["tool_choice"] = "auto"
@@ -5339,6 +5543,8 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
             return ""
         if configured != "auto":
             return configured
+        if not provider.supports_prompt_cache_key():
+            return ""
         payload = {
             "api": provider.resolved_api(),
             "cwd": self.session.cwd,
@@ -5474,11 +5680,12 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
         return assistant, calls, text
 
     def apply_provider_params(self, params: Json, provider: ProviderConfig) -> None:
-        if provider.temperature is not None:
-            params["temperature"] = provider.temperature
         chat_reasoning = provider.resolved_chat_reasoning()
         reasoning_enabled = provider.reasoning != "off"
         effort = provider.reasoning_effort()
+        # Native thinking modes (DeepSeek, Qwen) ignore or reject temperature while thinking is on.
+        if provider.temperature is not None and not (reasoning_enabled and chat_reasoning in ("thinking", "enable_thinking")):
+            params["temperature"] = provider.temperature
         extra: Json = {}
         if reasoning_enabled and chat_reasoning == "reasoning":
             extra["reasoning"] = {"effort": effort}
@@ -5538,12 +5745,22 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
             calls.append(self.tool_call(raw.id, raw.function.name, payload))
         return calls
 
-    @staticmethod
-    def tool_payload(name: str, payload: Any) -> list[Any]:
+    @classmethod
+    def tool_payload(cls, name: str, payload: Any) -> list[Any]:
         if isinstance(payload, dict) and (tool := TOOL_REGISTRY.get(name)):
-            return tool.payload_args(payload)
+            # Strict schemas express optional params as nullable, so the model may send explicit
+            # null for an omitted argument. In every nanocode tool null means "absent", so drop it.
+            return tool.payload_args(cls.drop_nulls(payload))
         return [payload]
 
+    @classmethod
+    def drop_nulls(cls, value: Any) -> Any:
+        if isinstance(value, dict):
+            return {key: cls.drop_nulls(item) for key, item in value.items() if item is not None}
+        if isinstance(value, list):
+            return [cls.drop_nulls(item) for item in value]
+        return value
+
     @classmethod
     def tool_call(cls, call_id: str, name: str, payload: Any) -> ToolCall:
         # payload_args may reject malformed arguments (e.g. Git with an empty argv). Capture that
@@ -5587,7 +5804,8 @@ FILE STATE:
 - Read and Edit refresh FILE STATE; after Edit, trust the edited range.
 
 FINAL:
-- Default to a few lines; scale to the task. Lead with the result; no preamble or recap.
+- Be concise by default: answer in as few lines as the task allows (often 1-3), and stop. Lead with the result; no preamble, recap, or filler.
+- Do not over-explain, enumerate options, or add background unless the user asks for detail, a walkthrough, or "why". Match length to what was requested; only go long when the user requests it or the task genuinely requires it.
 - Concise markdown in the user's language; note changed files and checks run (or not run).\
 """
 
@@ -5684,6 +5902,7 @@ class CommandCompleter(Completer):
         "/reason",
         "/set",
         "/yolo",
+        "/strict",
         "/exit",
         "/quit",
     )
@@ -5697,6 +5916,8 @@ class CommandCompleter(Completer):
         "provider.chat_reasoning",
         "provider.available_models",
         "provider.temperature",
+        "provider.max_tokens",
+        "provider.strict_tools",
         "provider.timeout",
         "runtime.yolo",
         "runtime.max_agent_steps",
@@ -5704,6 +5925,7 @@ class CommandCompleter(Completer):
         "runtime.max_parallel_tools",
         "runtime.shell_timeout",
         "runtime.check_updates",
+        "runtime.tips",
     )
     SET_VALUES = {
         "provider.api": PROVIDER_API_CHOICES,
@@ -5711,8 +5933,10 @@ class CommandCompleter(Completer):
         "provider.reasoning": REASONING_CHOICES,
         "provider.chat_reasoning": CHAT_REASONING_CHOICES,
         "provider.temperature": ("off",),
+        "provider.strict_tools": ("on", "off", "true", "false"),
         "runtime.yolo": ("on", "off", "true", "false"),
         "runtime.check_updates": ("on", "off", "true", "false"),
+        "runtime.tips": ("on", "off", "true", "false"),
     }
 
     def __init__(
@@ -5822,10 +6046,21 @@ class UiPrinter:
             return [("ansibrightblack", text + "\n")]
         if text.startswith("nanocode "):
             return [("ansicyan", text + "\n")]
+        if text.startswith("tip: "):
+            return self.tip_segments(text[len("tip: "):])
         if text.startswith("Error:") or text.startswith("ConfigError:") or text.startswith("Unknown command:"):
             return [("ansired", text + "\n")]
         return [("ansiwhite", line + "\n") for line in text.splitlines() or [""]]
 
+    def tip_segments(self, text: str) -> list[tuple[str, str]]:
+        # Muted hint line with a labeled marker; `code` spans are highlighted so commands stand out.
+        segments: list[tuple[str, str]] = [("ansibrightblack", "  "), ("ansiyellow", "💡 tip "), ("ansibrightblack", "· ")]
+        for index, part in enumerate(text.split("`")):
+            if part:
+                segments.append(("ansicyan" if index % 2 else "ansibrightblack", part))
+        segments.append(("", "\n"))
+        return segments
+
     def tool_segments(self, text: str) -> list[tuple[str, str]]:
         segments = []
         for line in text.splitlines() or [""]:
@@ -5949,31 +6184,73 @@ class UiPrinter:
                 at_start = part.endswith("\n")
         return indented
 
+
 class BashLivePreview:
     HEIGHT: ClassVar[int] = 6
     MAX_CHARS: ClassVar[int] = 8000
+    # Heartbeat tick so the elapsed timer advances even while a command produces no output
+    # (e.g. quiet long-runners or `... | tail` that buffers until EOF), so the terminal never
+    # looks frozen during a blocking command.
+    TICK: ClassVar[float] = 0.1
 
     def __init__(self):
         self.output = create_output(sys.stderr)
         self.active = False
         self.rendered_lines = 0
         self.text = ""
+        self.command = ""
+        self.started_at = 0.0
+        self.lock = threading.Lock()
+        self.timer: threading.Thread | None = None
 
-    def start(self) -> None:
+    def start(self, command: str = "") -> None:
         if not sys.stderr.isatty():
             return
-        self.active, self.rendered_lines, self.text = True, 0, ""
+        with self.lock:
+            self.active, self.rendered_lines, self.text = True, 0, ""
+            self.command = " ".join(command.split())
+            self.started_at = time.monotonic()
+            self.render()
+        self.timer = threading.Thread(target=self.tick, daemon=True)
+        self.timer.start()
+
+    def tick(self) -> None:
+        while True:
+            time.sleep(self.TICK)
+            with self.lock:
+                if not self.active:
+                    return
+                self.render()
 
     def update(self, text: str) -> None:
-        if not self.active:
-            return
-        self.text = (self.text + text)[-self.MAX_CHARS :]
-        self.render()
+        with self.lock:
+            if not self.active:
+                return
+            self.text = (self.text + text)[-self.MAX_CHARS :]
+            self.render()
 
     def finish(self) -> None:
-        if not self.active:
+        with self.lock:
+            if not self.active:
+                return
+            self.active = False
+        timer = self.timer
+        if timer is not None:
+            timer.join()
+        with self.lock:
+            self.clear()
+            self.rendered_lines, self.text = 0, ""
+
+    def clear(self) -> None:
+        if not self.rendered_lines:
             return
-        self.active, self.rendered_lines = False, 0
+        self.output.write_raw(f"\x1b[{self.rendered_lines}A")
+        for _ in range(self.rendered_lines):
+            self.output.write_raw("\r")
+            self.output.erase_end_of_line()
+            self.output.write_raw("\n")
+        self.output.write_raw(f"\x1b[{self.rendered_lines}A")
+        self.output.flush()
 
     def render(self) -> None:
         if not self.active:
@@ -5996,11 +6273,26 @@ class BashLivePreview:
         self.output.flush()
         self.rendered_lines = len(lines)
 
+    def elapsed_label(self) -> str:
+        elapsed = max(0.0, time.monotonic() - self.started_at) if self.started_at else 0.0
+        if elapsed < 60:
+            return f"{elapsed:.1f}s"
+        minutes, rest = divmod(int(elapsed), 60)
+        return f"{minutes}m{rest:02d}s"
+
     def frame_lines(self) -> list[str]:
         width = max(20, shutil.get_terminal_size((120, 20)).columns)
         body = [line.expandtabs(4) for line in self.text.replace("\r", "\n").splitlines()[-self.HEIGHT :]]
-        limit = width - 2
-        return ["  output", *("  " + (line if len(line) <= limit else line[: max(0, limit - 3)] + "...") for line in body)] if body else []
+        label = self.elapsed_label()
+        # `limit` leaves a column of slack so a full-width line cannot auto-wrap and desync the
+        # cursor-up math in render().
+        limit = width - 3
+        clip = lambda line: line if len(line) <= limit else line[: max(0, limit - 3)] + "..."
+        # Always emit a header (the running command + a live elapsed timer) so the frame is visible
+        # even before any output arrives and the user can see what is executing.
+        status = f"output · {label}" if body else f"running… {label}"
+        header = [clip("  $ " + self.command)] if self.command else []
+        return [*header, "  " + status, *("  " + clip(line) for line in body)]
 
 
 class ModelRetryShortcut:
@@ -6267,6 +6559,46 @@ class CommandLoop:
         "logout": (1, 1, "Usage: /mcp logout <server>\nExample: /mcp logout myOAuthServer"),
         "refresh": (0, 1, "Usage: /mcp refresh [server]"),
     }
+    # (predicate, tip): predicate gates a tip to contexts where it is actually useful.
+    ALWAYS = staticmethod(lambda s: True)
+    TIPS: ClassVar[tuple[tuple[Callable[["Session"], bool], str], ...]] = (
+        # Sessions & input
+        (ALWAYS, "Resume your last session anytime with `nanocode --resume`."),
+        (ALWAYS, "Keep typing while the agent works — your input is picked up at the next step."),
+        (ALWAYS, "Press Ctrl+C to cancel the current input or interrupt a running turn."),
+        (ALWAYS, "Search your input history with Ctrl+R."),
+        (ALWAYS, "Tab completes commands, file paths, and mentions."),
+        # Context & memory
+        (ALWAYS, "`/compact` summarizes a long conversation to reclaim context."),
+        (ALWAYS, "`/memory` shows the agent's current goal, plan, and known facts."),
+        (ALWAYS, "`/status` shows token usage, context %, and prompt-cache hit rate."),
+        (ALWAYS, "Stable context is kept early so the prompt cache is reused — cheaper, faster turns."),
+        # Model & reasoning
+        (ALWAYS, "`/model` switches model and `/reason` sets reasoning effort on the fly."),
+        (ALWAYS, "`/set provider.reasoning high` digs deeper on hard tasks; `off` is fastest."),
+        (ALWAYS, "`/set provider.max_tokens N` caps the model's output length."),
+        (ALWAYS, "`/api` shows or switches the API protocol (auto / chat / anthropic)."),
+        (lambda s: len(s.config.providers) > 1, "`/provider` switches between your configured providers."),
+        (lambda s: s.config.provider.supports_strict_tools(), "`/strict` constrains tool-call arguments to each tool's schema (OpenAI / DeepSeek)."),
+        # Tools & navigation
+        (ALWAYS, "`/index` manages the code symbol index for fast symbol navigation."),
+        (ALWAYS, "`/yolo` skips tool confirmations when you want to move fast."),
+        (ALWAYS, "`/set runtime.max_parallel_tools N` tunes how many reads run at once."),
+        (lambda s: bool(s.config.mcp), "Mention an MCP tool inline with `@server.tool` to pull in its schema."),
+        (lambda s: bool(s.config.mcp), "`/mcp` manages servers; `/mcp login NAME` starts an OAuth flow."),
+        # Config & setup
+        (ALWAYS, "`/config` opens your config; `/set KEY VALUE` changes settings live."),
+        (ALWAYS, "Scaffold a fresh config with `nanocode --init-config`."),
+        (ALWAYS, "Launch with `--yolo` to skip confirmations, or `--debug` to record request traces."),
+        (ALWAYS, "Filter MCP servers at launch with `--mcp \"name*,!exclude\"`."),
+        (ALWAYS, "Silence these hints with `/set runtime.tips off`."),
+    )
+
+    def startup_tip(self) -> str:
+        if not self.session.settings.tips:
+            return ""
+        eligible = [tip for predicate, tip in self.TIPS if predicate(self.session)]
+        return random.choice(eligible) if eligible else ""
     MCP_HELP = "Try /mcp, /mcp tools [server], /mcp login <server>, /mcp logout <server>, /mcp refresh [server]"
 
     HELP = """Commands:
@@ -6283,6 +6615,7 @@ class CommandLoop:
   /reason            Select reasoning effort.
   /set KEY VALUE     Set provider.* and runtime.*.
   /yolo              Toggle tool confirmations.
+  /strict            Toggle strict tool-call schemas (OpenAI / DeepSeek).
   /mcp               Show MCP server status.
   /mcp tools [NAME]   List MCP tools.
   /mcp login NAME     Start OAuth login for a server.
@@ -6484,7 +6817,6 @@ Tools:
         while self.queue_input_active.is_set() and time.monotonic() < deadline:
             time.sleep(0.01)
 
-
     def drain_queued_input(self) -> str:
         """Return queued user input, or empty string if nothing queued."""
         texts = []
@@ -6495,8 +6827,11 @@ Tools:
             texts.append(self.queue_input_text)
         self.queue_input_text = ""
         return "\n".join(texts)
+
     def run(self) -> int:
         self.emit(f"nanocode {__version__}. /help for commands.")
+        if tip := self.startup_tip():
+            self.emit("tip: " + tip)
         self.session.clean_expired_snapshots()
         self.render_resumed_session()
         CodeIndex(self.session).refresh_existing_async()
@@ -6546,7 +6881,7 @@ Tools:
                     watcher.join(timeout=1.0)
                 self.queue_input_paused.clear()
                 self.session.state.manual_model_retry_requested = False
-                CodeIndex(self.session).update_pending()
+                CodeIndex(self.session).update_pending_async()
                 self.status_bar.stop()
             elapsed = time.monotonic() - started
             self.ui.emit_answer(answer)
@@ -6639,14 +6974,12 @@ Tools:
         # the index is too large to fit even as name-only (some tools are hidden from the model).
         self.session.mcp.render_tools_index()
         if self.session.mcp.index_truncated:
-            self.emit("mcp: tools index exceeds the size budget; some tools are hidden from the model. Reduce enabled servers or run /mcp tools to see the full list.")
+            self.emit(
+                "mcp: tools index exceeds the size budget; some tools are hidden from the model. Reduce enabled servers or run /mcp tools to see the full list."
+            )
 
     def mcp_error_notice(self) -> str:
-        errors = [
-            (name, error)
-            for name, error in sorted(self.session.mcp.server_errors.items())
-            if error and not error.startswith("oauth login required")
-        ]
+        errors = [(name, error) for name, error in sorted(self.session.mcp.server_errors.items()) if error and not error.startswith("oauth login required")]
         if not errors:
             return ""
         shown = errors if self.session.settings.debug else errors[:3]
@@ -6924,7 +7257,7 @@ Tools:
         sys.stdout.flush()
         self.transient_tool_lines = 0
 
-    def tool_live_start(self) -> None:
+    def tool_live_start(self, command: str = "") -> None:
         if not self.ui.color:
             return
         self.live_queue_paused = self.interactive_input and not self.queue_input_paused.is_set()
@@ -6933,7 +7266,7 @@ Tools:
         self.live_status_paused = self.status_bar.is_running()
         if self.live_status_paused:
             self.status_bar.stop()
-        self.live_preview.start()
+        self.live_preview.start(command)
 
     def tool_live_output(self, _stream: str, text: str) -> None:
         if not self.ui.color:
@@ -6979,6 +7312,7 @@ Tools:
             "/reason": self.reason,
             "/set": self.set_value,
             "/yolo": self.yolo,
+            "/strict": self.strict,
             "/mcp": self.mcp_command,
         }
         handler = handlers.get(name)
@@ -7239,7 +7573,11 @@ Tools:
         previews = spec.previews
         preview_map = {c: previews[i] for i, c in enumerate(choices) if previews and i < len(previews) and previews[i]}
         result = self.choice_application(
-            "Select:", tuple(choices), labels, current, set(),
+            "Select:",
+            tuple(choices),
+            labels,
+            current,
+            set(),
             preview_fn=lambda choice: preview_map.get(choice, ""),
             free_text=True,
         )
@@ -7270,7 +7608,9 @@ Tools:
         usage = self.session.usage
         provider = self.session.config.provider
         self.agent.context.update_percent(self.agent.context.model_messages(self.agent.SYSTEM_PROMPT))
-        index_status, index_message = CodeIndex(self.session).status(check=True)
+        index = CodeIndex(self.session)
+        index_status, index_message = index.status(check=False)
+        index.update_pending_async()
         if self.session.state.code_index_refreshing:
             index_status, index_message = self.session.state.code_index_notice or "syncing", ""
         elif self.session.state.code_index_error:
@@ -7316,7 +7656,15 @@ Tools:
         state = self.session.state
         known = ["- " + item for item in state.known] or ["- (empty)"]
         return "\n".join(
-            ["goal: " + (state.goal or "(empty)"), "summary:", state.summary or "(empty)", "plan:", *AgentState.plan_rows_for(state.plan, status=True, style="symbol"), "known:", *known]
+            [
+                "goal: " + (state.goal or "(empty)"),
+                "summary:",
+                state.summary or "(empty)",
+                "plan:",
+                *AgentState.plan_rows_for(state.plan, status=True, style="symbol"),
+                "known:",
+                *known,
+            ]
         )
 
     def config(self, args: str) -> str:
@@ -7336,6 +7684,8 @@ Tools:
                 f"provider.resolved_chat_reasoning: {provider.resolved_chat_reasoning()}",
                 f"provider.chat_reasoning: {provider.chat_reasoning}",
                 f"provider.temperature: {provider.temperature if provider.temperature is not None else '(off)'}",
+                f"provider.max_tokens: {provider.max_tokens or ('(resolved ' + str(provider.resolved_max_tokens() or 'server default') + ')')}",
+                f"provider.strict_tools: {provider.strict_tools} (active {provider.resolved_strict_tools()})",
                 f"provider.timeout: {provider.timeout}",
                 f"paths.data_dir: {self.session.data_path()}",
                 f"runtime.shell_timeout: {self.session.settings.shell_timeout}",
@@ -7518,6 +7868,16 @@ Tools:
         self.session.settings.yolo = not self.session.settings.yolo
         return "yolo: " + ("on" if self.session.settings.yolo else "off")
 
+    def strict(self, args: str) -> str:
+        if args:
+            return "Usage: /strict"
+        provider = self.session.config.provider
+        provider.strict_tools = not provider.strict_tools
+        state = "on" if provider.strict_tools else "off"
+        if provider.strict_tools and not provider.resolved_strict_tools():
+            return f"strict_tools: {state} (inactive: {provider.host() or 'this provider'} does not support strict tool calling)"
+        return f"strict_tools: {state}"
+
     def set_value(self, args: str) -> str:
         key, _, value = args.partition(" ")
         if not key or not value:
@@ -7538,6 +7898,10 @@ Tools:
                 provider.available_models = tuple(item.strip() for item in value.split(",") if item.strip())
             elif key == "provider.temperature":
                 provider.temperature = None if value == "off" else float(value)
+            elif key == "provider.max_tokens":
+                provider.max_tokens = max(0, int(value))
+            elif key == "provider.strict_tools":
+                provider.strict_tools = Config.bool({key: value}, key)
             elif key == "provider.timeout":
                 provider.timeout = max(1, int(value))
             elif key == "runtime.yolo":
@@ -7554,6 +7918,8 @@ Tools:
                 runtime.shell_timeout = max(1, int(value))
             elif key == "runtime.max_parallel_tools":
                 runtime.max_parallel_tools = max(1, int(value))
+            elif key == "runtime.tips":
+                runtime.tips = Config.bool({key: value}, key)
             else:
                 return "Unknown config key: " + key
         except (ConfigError, ValueError):
@@ -7568,8 +7934,7 @@ def main(argv: list[str] | None = None) -> int:
     parser.add_argument("--yolo", action="store_true", help="Skip confirmations for mutating tools")
     parser.add_argument("--debug", action="store_true", help="Enable debug mode")
     parser.add_argument("--mcp", default="", help='Filter MCP servers, e.g. "orion*,!orionEval", "all", or "none"')
-    parser.add_argument("--resume", default="", nargs="?", const="latest",
-                        help='Resume a session by UID, or "latest"/"last" for most recent')
+    parser.add_argument("--resume", default="", nargs="?", const="latest", help='Resume a session by UID, or "latest"/"last" for most recent')
     parser.add_argument("-v", "--version", action="store_true", help="Show version")
     args = parser.parse_args(argv)
     if args.version:
@@ -7589,7 +7954,11 @@ def main(argv: list[str] | None = None) -> int:
             )
         else:
             session = Session.from_config_file(path=args.config, yolo=args.yolo, debug=args.debug, mcp_selector=args.mcp)
-        return CommandLoop(Agent(session)).run()
+        try:
+            return CommandLoop(Agent(session)).run()
+        finally:
+            if session.mcp is not None:
+                session.mcp.close()
     except ConfigError as error:
         print("ConfigError: " + str(error), file=sys.stderr)
         return 2

{nanocode_cli-0.7.0 → nanocode_cli-0.7.2/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.7.0
+Version: 0.7.2
 Summary: A small terminal coding agent written in Python
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause

{nanocode_cli-0.7.0 → nanocode_cli-0.7.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.7.0"
+version = "0.7.2"
 description = "A small terminal coding agent written in Python"
 readme = "README.md"
 requires-python = ">=3.11"