nanocode-cli 0.3.27__tar.gz → 0.3.32__tar.gz

{nanocode_cli-0.3.27/nanocode_cli.egg-info → nanocode_cli-0.3.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.3.27
+Version: 0.3.32
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -119,7 +119,7 @@ USE AT YOUR OWN RISK.
 - Maintenance: `/clean`.
 - Exit: `/exit`, `/quit`.
 
-`/model` groups configured `available_models` first, then any extra models automatically discovered from the provider. In selectors, use `j`/`k` or arrow keys to move, `/keyword` to filter choices, Enter to select, and Esc to step back or cancel. `/model <model_name>` sets a model directly. Changing model also opens a reasoning effort selector: choose `off` to disable reasoning, or choose an effort to enable reasoning and set it. Use `/reason` to change reasoning without changing model.
+Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model <name>` and `/reason` are direct shortcuts.
 
 ## Configuration
 

{nanocode_cli-0.3.27 → nanocode_cli-0.3.32}/README.md

@@ -89,7 +89,7 @@ USE AT YOUR OWN RISK.
 - Maintenance: `/clean`.
 - Exit: `/exit`, `/quit`.
 
-`/model` groups configured `available_models` first, then any extra models automatically discovered from the provider. In selectors, use `j`/`k` or arrow keys to move, `/keyword` to filter choices, Enter to select, and Esc to step back or cancel. `/model <model_name>` sets a model directly. Changing model also opens a reasoning effort selector: choose `off` to disable reasoning, or choose an effort to enable reasoning and set it. Use `/reason` to change reasoning without changing model.
+Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model <name>` and `/reason` are direct shortcuts.
 
 ## Configuration
 

{nanocode_cli-0.3.27 → nanocode_cli-0.3.32}/nanocode.py

@@ -51,7 +51,7 @@ from prompt_toolkit.output.defaults import create_output
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.styles import Style
 
-__version__ = "0.3.27"
+__version__ = "0.3.32"
 HTTP_USER_AGENT = "nanocode/" + __version__
 
 
@@ -821,6 +821,12 @@ class RuntimeState:
     current_model_call_started_at: float = 0.0
     current_model_call_label: str = ""
     current_model_call_reasoning_label: str = ""
+    current_model_call_activity: str = ""
+    current_model_call_has_content: bool = False
+    current_model_call_streaming_chars: int = 0
+    last_model_call_rate: float = 0.0
+    status_notice: str = ""
+    status_notice_until: float = 0.0
     conversation: list[ConversationItem] = field(default_factory=list)
     user_rules: UserRules = field(default_factory=UserRules)
     range_fingerprints: RangeFingerprintStore = field(default_factory=RangeFingerprintStore)
@@ -1666,7 +1672,7 @@ class SearchTool(Tool):
     MAX_CONTEXT_LINES: ClassVar[int] = 30
     EFFECT: ClassVar[ToolEffect] = ToolEffect.READONLY
     DESCRIPTION: ClassVar[tuple[str, ...]] = (
-        "Case-insensitive regex search before Read; use A|B|C for alternatives.",
+        "Case-insensitive regex search before Read; use A|B|C for alternatives and \\n for multiline matches.",
         "For exact text, escape regex metacharacters like braces, parens, dots, stars, and brackets.",
         "Scope with path=FILE_OR_DIR, optionally filter with one glob=*.py, set context=N for 0..30 lines; omitted path defaults to current directory.",
         "Second positional arg is always path, third positional arg is always glob; with path=, extra leading positional args are joined as regex alternatives.",
@@ -1709,8 +1715,7 @@ class SearchTool(Tool):
         pattern = raw_pattern[3:] if raw_pattern.startswith("re:") else raw_pattern
         if not pattern:
             raise ToolCallArgError("pattern cannot be empty")
-        if "\n" in pattern:
-            raise ToolCallArgError("multiline regex is not supported; Search is line-oriented. Search each line separately or Read a nearby range.")
+        pattern = pattern.replace("\\n", "\n").replace("\\r", "\r")
         target_path_arg = "."
         glob_pattern = ""
         context_lines = cls.CONTEXT_LINES
@@ -1859,7 +1864,9 @@ class SearchTool(Tool):
                     yield path
 
     def _make_match(self, path: str, line_number: int, text: str) -> Match:
-        return self.Match(path=path, line_number=line_number, text=text[:300], context=self._read_match_context(path, line_number))
+        text = text.rstrip("\n")
+        preview = _shorten(" ".join(text.split()), 300) if "\n" in text or "\r" in text else text[:300]
+        return self.Match(path=path, line_number=line_number, text=preview, context=self._read_match_context(path, line_number))
 
     def _read_match_context(self, path: str, line_number: int) -> list[tuple[int, str]]:
         if line_number <= 0:
@@ -1898,6 +1905,8 @@ class SearchTool(Tool):
 
     def _rg_command(self, rg: str, *, pcre2: bool = False) -> list[str]:
         cmd = [rg, "--json", "--line-number", "--max-filesize", self.RG_MAX_FILESIZE]
+        if self._is_multiline():
+            cmd.extend(["-U", "--multiline-dotall"])
         if pcre2:
             cmd.append("--pcre2")
         cmd.append("-i")
@@ -1951,8 +1960,13 @@ class SearchTool(Tool):
         text = stderr.lower()
         return "pcre2" in text and ("look-around" in text or "look-ahead" in text or "look-behind" in text)
 
+    def _is_multiline(self) -> bool:
+        return "\n" in self.pattern or "\r" in self.pattern
+
     def _call_python(self) -> str:
         matches = []
+        if self._is_multiline():
+            return self._call_python_multiline()
         for path in self._iter_files():
             try:
                 if os.path.getsize(path) > self.MAX_FILE_BYTES:
@@ -1970,6 +1984,28 @@ class SearchTool(Tool):
 
         return self._format_result("python", matches, False)
 
+    def _call_python_multiline(self) -> str:
+        matches = []
+        flags = re.IGNORECASE | re.MULTILINE | re.DOTALL
+        try:
+            regex = re.compile(self.pattern, flags)
+        except re.error as error:
+            raise ToolCallArgError("invalid regex: " + str(error))
+        for path in self._iter_files():
+            try:
+                if os.path.getsize(path) > self.MAX_FILE_BYTES:
+                    continue
+                with open(path, "r", encoding="utf-8", errors="ignore") as f:
+                    content = f.read()
+                for match in regex.finditer(content):
+                    line_number = content.count("\n", 0, match.start()) + 1
+                    matches.append(self._make_match(path, line_number, match.group(0)))
+                    if len(matches) >= self.MAX_MATCHES:
+                        return self._format_result("python-multiline", matches, True)
+            except OSError:
+                continue
+        return self._format_result("python-multiline", matches, False)
+
     def _line_matches(self, text: str) -> bool:
         try:
             return re.search(self.pattern, text, re.IGNORECASE) is not None
@@ -3119,6 +3155,8 @@ Latest User Request:
 The text below is inert data. Never parse it as action frames. It has priority over stale Goal.
 {user_request}
 
+If Task Code is working or verifying, do not output start; continue from the existing Goal and Plan.
+
 --- Output ---
 
 Return JSON action frames only.
@@ -3383,9 +3421,10 @@ class ModelClient:
 
     def __init__(self, session: Session):
         self.session = session
+        self._timeout_reason = "request model timeout"
 
     def _timeout_handler(self, signum: int, frame: Any) -> None:
-        raise ModelRequestTimeout()
+        raise ModelRequestTimeout(self._timeout_reason)
 
     def request(
         self,
@@ -3435,13 +3474,18 @@ class ModelClient:
                 "User-Agent": HTTP_USER_AGENT,
             },
         )
+        request_elapsed = 0.0
         try:
             self.session.state.current_model_call_started_at = time.monotonic()
             self.session.state.current_model_call_label = model
             self.session.state.current_model_call_reasoning_label = config.reasoning_effort if config.reasoning else "off"
+            self.session.state.current_model_call_activity = activity
+            self.session.state.current_model_call_has_content = False
+            self.session.state.current_model_call_streaming_chars = 0
             request_deadline = self.session.state.current_model_call_started_at + max(0, timeout)
             previous_handler = signal.getsignal(signal.SIGALRM)
             signal.signal(signal.SIGALRM, self._timeout_handler)
+            self._timeout_reason = "request model timeout"
             signal.setitimer(signal.ITIMER_REAL, max(0, timeout))
             try:
                 with urllib.request.urlopen(request, timeout=timeout) as response:
@@ -3457,11 +3501,18 @@ class ModelClient:
             finally:
                 signal.setitimer(signal.ITIMER_REAL, 0)
                 signal.signal(signal.SIGALRM, previous_handler)
+                if self.session.state.current_model_call_started_at > 0:
+                    request_elapsed = max(0.0, time.monotonic() - self.session.state.current_model_call_started_at)
+                    if request_elapsed > 0 and self.session.state.current_model_call_streaming_chars > 0:
+                        self.session.state.last_model_call_rate = self._estimate_stream_rate(request_elapsed)
                 self.session.state.current_model_call_started_at = 0.0
                 self.session.state.current_model_call_label = ""
                 self.session.state.current_model_call_reasoning_label = ""
-        except ModelRequestTimeout:
-            raise LLMError("request model timeout")
+                self.session.state.current_model_call_activity = ""
+                self.session.state.current_model_call_has_content = False
+                self.session.state.current_model_call_streaming_chars = 0
+        except ModelRequestTimeout as error:
+            raise LLMError(str(error) or "request model timeout")
         except (socket.timeout, TimeoutError):
             raise LLMError("request model timeout")
         except urllib.error.HTTPError as error:
@@ -3480,7 +3531,7 @@ class ModelClient:
             except json.JSONDecodeError:
                 raise LLMError("API response is not JSON: " + _shorten(body))
 
-        self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None), config)
+        self._record_usage(_json_dict(result.get("usage") if isinstance(result, dict) else None), config, elapsed=request_elapsed)
         if not stream:
             content = self._message_content(result)
         if content is None:
@@ -3525,16 +3576,24 @@ class ModelClient:
                 continue
             if not first_content_seen:
                 first_content_seen = True
+                self.session.state.current_model_call_has_content = True
                 self._arm_stream_timeout(request_deadline=request_deadline, first_content_seen=True, first_token_timeout=first_token_timeout)
             parts.append(content)
+            self.session.state.current_model_call_streaming_chars += len(content)
         return "".join(parts), usage
 
+    def _estimate_stream_rate(self, elapsed: float) -> float:
+        return self.session.state.current_model_call_streaming_chars / 4 / elapsed if elapsed > 0 else 0.0
+
     def _arm_stream_timeout(self, *, request_deadline: float, first_content_seen: bool, first_token_timeout: int | None) -> None:
         remaining = request_deadline - time.monotonic()
         if remaining <= 0:
-            raise ModelRequestTimeout()
+            raise ModelRequestTimeout("request model timeout")
+        self._timeout_reason = "request model timeout"
         if not first_content_seen and first_token_timeout is not None and first_token_timeout > 0:
-            remaining = min(remaining, first_token_timeout)
+            if first_token_timeout < remaining:
+                remaining = first_token_timeout
+                self._timeout_reason = "request first token timeout"
         signal.setitimer(signal.ITIMER_REAL, remaining)
 
     def _write_debug_prompt(self, *, activity: str, messages: list[Json]) -> str:
@@ -3565,8 +3624,11 @@ class ModelClient:
     def _parse_model_content(self, content: str) -> Json:
         text = content.strip()
         text = self._strip_leaked_think_tags(text)
+        text = self._strip_leaked_tool_code(text)
         text = self._strip_json_fence(text)
+        text = self._strip_fence_marker_lines(text)
         text = self._strip_leaked_think_tags(text)
+        text = self._strip_leaked_tool_code(text)
         if not self._has_action_frame_end(text):
             actions, error = self._parse_unmarked_actions(text)
             if actions:
@@ -3644,6 +3706,7 @@ class ModelClient:
         if isinstance(value, dict):
             if "actions" in value:
                 return self._actions_from_json_value(value.get("actions"))
+            self._normalize_tool_type(value)
             if not _json_str(value.get("type")):
                 return [], "action missing type"
             return [value], ""
@@ -3653,12 +3716,20 @@ class ModelClient:
                 action = _json_dict(raw)
                 if not action:
                     return [], "array item " + str(index) + ": expected JSON object action"
+                self._normalize_tool_type(action)
                 if not _json_str(action.get("type")):
                     return [], "array item " + str(index) + ": action missing type"
                 actions.append(action)
             return actions, ""
         return [], "expected JSON object action"
 
+    def _normalize_tool_type(self, action: Json) -> None:
+        action_type = _json_str(action.get("type"))
+        tool_name = next((name for name in TOOL_REGISTRY if name.lower() == action_type.lower()), "") if action_type else ""
+        if tool_name:
+            action["type"] = "tool"
+            action.setdefault("name", tool_name)
+
     def _parse_unmarked_actions(self, text: str) -> tuple[list[Json], str]:
         actions: list[Json] = []
         decoder = json.JSONDecoder()
@@ -3669,8 +3740,8 @@ class ModelClient:
         if index < len(text) and text[index] != "{":
             if text[index] == "[":
                 try:
-                    value, index = decoder.raw_decode(text, index)
-                except json.JSONDecodeError as error:
+                    value, index = self._decode_json_array_text(text, index)
+                except (json.JSONDecodeError, ValueError) as error:
                     return [], str(error)
                 parsed, error = self._actions_from_json_value(value)
                 if error:
@@ -3682,12 +3753,15 @@ class ModelClient:
                 return parsed, ""
             action_start = text.find("{", index)
             if action_start < 0:
+                progress = self._plain_progress_text(text[index:])
+                if progress:
+                    return [{"type": "progress", "text": progress}], ""
                 try:
                     decoder.raw_decode(text, index)
                 except json.JSONDecodeError as error:
                     return [], str(error)
                 return [], "expected JSON object action"
-            prefix = _shorten(" ".join(text[:action_start].split()), 500)
+            prefix = self._progress_text(text[:action_start])
             index = action_start
         while True:
             while index < len(text) and text[index].isspace():
@@ -3699,6 +3773,14 @@ class ModelClient:
             try:
                 value, index = decoder.raw_decode(text, index)
             except json.JSONDecodeError as error:
+                if actions:
+                    return [], str(error)
+                if self._should_repair_json_decode_error(str(error), text):
+                    repaired, repair_error = self._repair_single_json_action(text)
+                    if not repair_error:
+                        if prefix:
+                            repaired.insert(0, {"type": "progress", "text": prefix})
+                        return repaired, ""
                 return [], str(error)
             parsed, error = self._actions_from_json_value(value)
             if error:
@@ -3708,6 +3790,71 @@ class ModelClient:
                 index += 1
             if index < len(text) and text[index] == ",":
                 index += 1
+                continue
+            if index < len(text) and text[index] != "{":
+                next_action = text.find("{", index)
+                if next_action < 0:
+                    if self._should_repair_trailing_json_text(text[index:]):
+                        repaired, error = self._repair_single_json_action(text)
+                        if not error:
+                            return repaired, ""
+                    return [], "unexpected text after JSON action"
+                progress = self._progress_text(text[index:next_action])
+                if progress:
+                    actions.append({"type": "progress", "text": progress})
+                index = next_action
+
+    def _progress_text(self, text: str) -> str:
+        text = re.sub(r"```[a-zA-Z0-9_-]*", "", text)
+        text = text.replace("```", "")
+        return _shorten(" ".join(text.split()), 500)
+
+    def _plain_progress_text(self, text: str) -> str:
+        progress = self._progress_text(text)
+        if not progress or "{" in progress or "}" in progress:
+            return ""
+        starters = (
+            "let me ",
+            "i need ",
+            "i will ",
+            "i'll ",
+            "now ",
+            "next ",
+            "我需要",
+            "让我",
+            "我会",
+            "现在",
+            "接下来",
+        )
+        return progress if progress.lower().startswith(starters) else ""
+
+    def _decode_json_array_text(self, text: str, index: int) -> tuple[JsonValue, int]:
+        decoder = json.JSONDecoder()
+        value, end = decoder.raw_decode(text, index)
+        cursor = end
+        while cursor < len(text) and text[cursor].isspace():
+            cursor += 1
+        if cursor >= len(text):
+            return value, cursor
+        value = json_repair.loads(text[index:])
+        if not isinstance(value, list):
+            raise ValueError("expected JSON action array")
+        return value, len(text)
+
+    def _repair_single_json_action(self, text: str) -> tuple[list[Json], str]:
+        try:
+            value = json_repair.loads(text)
+        except Exception as error:
+            return [], str(error)
+        if isinstance(value, list):
+            return [], "unexpected text after JSON action"
+        return self._actions_from_json_value(value)
+
+    def _should_repair_json_decode_error(self, error: str, text: str) -> bool:
+        return "Invalid control character" in error or re.fullmatch(r".*[}\]]\s*[}\]]+\s*", text, re.DOTALL) is not None
+
+    def _should_repair_trailing_json_text(self, text: str) -> bool:
+        return re.fullmatch(r"\s*[}\]]+\s*", text) is not None
 
     def _has_action_frame_end(self, line: str) -> bool:
         return self.ACTION_FRAME_END_SPLIT_PATTERN.search(line) is not None
@@ -3722,6 +3869,9 @@ class ModelClient:
             lines = lines[:-1]
         return "\n".join(lines).strip()
 
+    def _strip_fence_marker_lines(self, text: str) -> str:
+        return re.sub(r"(?m)^\s*```[a-zA-Z0-9_-]*\s*$\n?", "", text).strip()
+
     def _strip_leaked_think_tags(self, text: str) -> str:
         text = text.strip()
         while text.startswith("</think>"):
@@ -3735,6 +3885,9 @@ class ModelClient:
                 text = text[len("</think>") :].lstrip()
         return text
 
+    def _strip_leaked_tool_code(self, text: str) -> str:
+        return re.sub(r"<tool_code>.*?</tool_code>", "", text, flags=re.DOTALL).strip()
+
     def _invalid_model_response(self, content: str, reason: str = "expected one JSON object matching the Output JSON schema") -> Json:
         guidance = ""
         if self._strip_leaked_think_tags(content.strip()).startswith("<tool_call>"):
@@ -3768,10 +3921,12 @@ class ModelClient:
         }
         return "API response missing message content: " + json.dumps(details, ensure_ascii=False)
 
-    def _record_usage(self, usage: Json, config: ProviderConfig) -> None:
+    def _record_usage(self, usage: Json, config: ProviderConfig, *, elapsed: float = 0.0) -> None:
         prompt_tokens = self._json_int(usage.get("prompt_tokens"))
         completion_tokens = self._json_int(usage.get("completion_tokens"))
         total_tokens = self._json_int(usage.get("total_tokens"))
+        if completion_tokens > 0 and elapsed > 0:
+            self.session.state.last_model_call_rate = completion_tokens / elapsed
         self.session.state.last_prompt_tokens = prompt_tokens
         self.session.state.last_completion_tokens = completion_tokens
         self.session.state.last_total_tokens = total_tokens
@@ -4743,7 +4898,6 @@ class Agent:
     KEPT_TOOL_RESULT_CHARS: ClassVar[int] = 96_000
     RECENT_TOOL_CALL_SUMMARIES: ClassVar[int] = 40
     PENDING_OBSERVE_RESULTS: ClassVar[int] = 8
-    PENDING_OBSERVE_CHAR_RATIO: ClassVar[float] = 0.4
     PENDING_OBSERVE_TOOL_TURNS: ClassVar[int] = 2
     PLAN_MODE_GIT_READONLY: ClassVar[frozenset[str]] = GIT_READONLY_COMMANDS
 
@@ -4766,6 +4920,7 @@ class Agent:
         self.failed_tool_call_count = 0
         self.agent_feedback_errors: list[str] = []
         self.observe_feedback_errors: list[str] = []
+        self.task_alignment_required = False
         self.mode = AgentMode.ACT
 
     def build_user_prompt(self) -> str:
@@ -4793,12 +4948,14 @@ class Agent:
                 self.session.state.turn_model_calls += 1
                 return self.model_client.request(system_prompt, user_prompt, activity=activity)
             except LLMError as error:
-                if str(error) != "request model timeout" or attempt >= len(self.MODEL_TIMEOUT_RETRY_DELAYS):
+                timeout_reason = str(error)
+                if timeout_reason not in ("request model timeout", "request first token timeout") or attempt >= len(self.MODEL_TIMEOUT_RETRY_DELAYS):
                     raise
                 delay = self.MODEL_TIMEOUT_RETRY_DELAYS[attempt]
+                self._set_status_notice("err:first_token" if timeout_reason == "request first token timeout" else "err:timeout")
                 if on_message is not None and self.session.settings.debug:
                     on_message(
-                        "Retrying: request model timeout; retry "
+                        "Retrying: " + timeout_reason + "; retry "
                         + str(attempt + 1)
                         + "/"
                         + str(len(self.MODEL_TIMEOUT_RETRY_DELAYS))
@@ -4809,6 +4966,10 @@ class Agent:
                 time.sleep(delay)
         raise LLMError("request model timeout")
 
+    def _set_status_notice(self, text: str, ttl: float = 5.0) -> None:
+        self.session.state.status_notice = text
+        self.session.state.status_notice_until = time.monotonic() + ttl
+
     def compact_history(self) -> int:
         return self.compactor.compact()
 
@@ -4834,6 +4995,7 @@ class Agent:
                 format_error = _json_str(response.get("_format_error"))
                 if format_error:
                     consecutive_format_errors += 1
+                    self._set_status_notice("err:format")
                     remember_error = self._remember_observe_error if self.mode == AgentMode.OBSERVE else self._remember_agent_error
                     remember_error(
                         self._format_gate_user_message("Error: model returned invalid output", format_error) + " Rule: return valid JSON action frames only."
@@ -4919,6 +5081,8 @@ class Agent:
     def _report_gate(self, on_message: MessageCallback | None, message: str, debug_message: str) -> None:
         if on_message is None:
             return
+        if message.startswith(("Retrying:", "Continuing:")) and self.session.state.status_notice_until <= time.monotonic():
+            self._set_status_notice("err:gate")
         if self.session.settings.debug:
             on_message(debug_message)
             return
@@ -4945,13 +5109,15 @@ class Agent:
         if self.mode == AgentMode.OBSERVE:
             system_prompt = self.prompt_builder.system_prompt(AGENT_OBSERVE_SYSTEM_PROMPT, tools=())
             user_prompt = self.build_observe_prompt()
+            activity = "observe"
         else:
             system_prompt = self.prompt_builder.system_prompt(
                 AGENT_PLAN_SYSTEM_PROMPT if self.session.settings.plan_mode else None,
                 tools=PLAN_MODE_TOOLS if self.session.settings.plan_mode else None,
             )
             user_prompt = self.build_user_prompt()
-        response = self.request(system_prompt, user_prompt, activity="agent", on_message=on_message)
+            activity = "agent"
+        response = self.request(system_prompt, user_prompt, activity=activity, on_message=on_message)
         if _json_str(response.get("_format_error")):
             return response
         invalid_response = self._validate_action_response(response)
@@ -5039,8 +5205,6 @@ class Agent:
             return True
         if len(pending) >= self.PENDING_OBSERVE_RESULTS:
             return True
-        if len("\n\n".join(pending)) >= int(self.RECENT_TOOL_CALL_CHARS * self.PENDING_OBSERVE_CHAR_RATIO):
-            return True
         return self.runtime.consecutive_tool_turns >= self.PENDING_OBSERVE_TOOL_TURNS
 
     def _tool_failure_needs_observe(self, execution: ToolCallExecution) -> bool:
@@ -5297,29 +5461,6 @@ class Agent:
         conflict = sorted((forgotten & protected) - released)
         return "active hypothesis source: " + ", ".join(conflict) if conflict else ""
 
-    def _plan_shape_error(self, actions: list[Json]) -> str:
-        plan = [PlanItem(text=item.text, status=item.status, id=item.id, context=item.context) for item in self.blackboard.plan]
-        changed = False
-        for action in actions:
-            action_type = _json_str(action.get("type"))
-            if action_type == "start":
-                items = self._plan_items_from_json(action.get("plan"))
-                if items:
-                    plan = items
-                    changed = True
-            elif action_type == "plan":
-                items = self._plan_items_from_json(action.get("items"))
-                if action.get("mode") != "patch":
-                    if items:
-                        plan = items
-                        changed = True
-                    continue
-                changed = self.state_updater._apply_plan_patches(plan, action.get("items")) or changed
-        doing = [item for item in plan if item.status == PlanStatus.DOING]
-        if changed and len(doing) > 1:
-            return "multiple doing plan items: " + self._format_plan_gate_items(doing)
-        return ""
-
     def _plan_items_from_json(self, value: JsonValue) -> list[PlanItem]:
         return [item for item in (self.state_updater._plan_item_from_json(raw) for raw in _json_list(value)) if item]
 
@@ -5427,15 +5568,6 @@ class Agent:
                 "ToolResult_Gate: " + forget_hypothesis_error + ".",
             )
             return True
-        plan_shape_error = self._plan_shape_error(ctx.actions)
-        if plan_shape_error:
-            self._remember_agent_error("Error: Plan is invalid: " + plan_shape_error + ". Rule: at most one Plan item may be doing.")
-            self._report_gate(
-                on_message,
-                "Retrying: keep only one plan item doing.",
-                "Plan_Gate: " + plan_shape_error + ".",
-            )
-            return True
         repeated_tool_retry_error = self._repeated_tool_retry_error(ctx.tool_calls)
         if repeated_tool_retry_error:
             self._remember_agent_error(
@@ -5458,6 +5590,24 @@ class Agent:
                 "PlanMode_Gate: " + plan_mode_tool_error + ".",
             )
             return True
+        if (
+            self.blackboard.task_code == TaskCode.NEW
+            and self.task_alignment_required
+            and (ctx.tool_calls or ctx.pending_verify_requested)
+            and not ctx.has_goal_action
+            and not ctx.has_plan_action
+            and not ctx.has_user_rule_action
+        ):
+            self._remember_agent_error(
+                "Error: previous task context is still present. Rule: before work, emit start if the latest request changes the task; "
+                "if continuing, update or confirm the plan first."
+            )
+            self._report_gate(
+                on_message,
+                "Retrying: align this request with the task before work.",
+                "GoalPlan_Gate: work before task alignment with previous task context.",
+            )
+            return True
         if self.blackboard.task_code != TaskCode.NEW and any(_json_str(action.get("type")) == "start" for action in ctx.actions):
             self._remember_agent_error(
                 "Error: repeated start is invalid after the current task is active. Rule: follow Current Task Code and continue with plan/tool/verify/goal."
@@ -5732,15 +5882,6 @@ class Agent:
                 "ToolResult_Gate: " + forget_hypothesis_error + ".",
             )
             return AgentRunResult()
-        plan_shape_error = self._plan_shape_error(ctx.actions)
-        if plan_shape_error:
-            self._remember_observe_error("Error: Plan is invalid: " + plan_shape_error + ". Rule: at most one Plan item may be doing.")
-            self._report_gate(
-                on_message,
-                "Retrying: keep only one plan item doing.",
-                "Plan_Gate: " + plan_shape_error + ".",
-            )
-            return AgentRunResult()
         if any(_json_str(action.get("type")) == "verify" and _json_str(action.get("status")) == "pending" for action in ctx.actions):
             self._remember_observe_error("Error: cannot request new verification before observing latest results. Rule: keep or forget latest results first.")
             self._report_gate(
@@ -5948,10 +6089,16 @@ class Agent:
         self.mode = AgentMode.ACT
         self.session.state.turn_tool_calls = 0
         self.session.state.turn_model_calls = 0
+        old_goal = self.blackboard.goal
+        old_task_context = bool(self.blackboard.goal or self.blackboard.plan or self.blackboard.hypotheses)
         self.blackboard.user_input = user_input
         previous_task_done = self.blackboard.task_code == TaskCode.DONE
         if previous_task_done:
             self.blackboard.work_mode = WorkMode.NORMAL
+        # Keep previous task state at a new user turn so short follow-ups like
+        # "continue" can resume. The first response must align with it before work
+        # when the new request does not match the previous goal.
+        self.task_alignment_required = old_task_context and self._task_text_key(user_input) != self._task_text_key(old_goal)
         self.blackboard.task_code = TaskCode.NEW
         self.blackboard.goal_reached = False
         self.blackboard.verification_required = False
@@ -5974,6 +6121,9 @@ class Agent:
             on_step_limit=lambda: (_ for _ in ()).throw(LLMError("agent step limit reached")),
         )
 
+    def _task_text_key(self, text: str) -> str:
+        return re.sub(r"\s+", " ", text).strip(" \t\r\n。.;；").lower()
+
     def handle_response(
         self,
         response: Json,
@@ -6642,14 +6792,35 @@ class StatusBar:
         context = str(len(session.state.conversation)) + "/" + str(session.settings.compact_at)
         last_tokens = _format_count(session.state.last_total_tokens)
         session_tokens = _format_count(session.state.session_total_tokens)
-        tokens = "last:" + last_tokens + " session:" + session_tokens
-        parts = [model + " (" + reasoning + ")" + modes, "ctx:" + context, "tools:" + str(session.state.turn_tool_calls), "tok:" + tokens]
+        rate = session.state.last_model_call_rate
+        token_summary = "last:" + last_tokens + " sess:" + session_tokens
+        parts = [model + " (" + reasoning + ")" + modes, "ctx:" + context, "tool:" + str(session.state.turn_tool_calls), "tok:" + token_summary]
         if show_elapsed:
-            parts.append(f"{turn_elapsed:.1f}s")
+            parts.append(f"turn:{turn_elapsed:.1f}s")
         if session.state.current_model_call_started_at > 0:
-            parts.append("calling(" + str(session.state.turn_model_calls) + "):" + f"{max(0.0, now - session.state.current_model_call_started_at):.1f}s")
+            activity = self._activity_label(session.state.current_model_call_activity)
+            if session.state.current_model_call_has_content:
+                activity += "*"
+            elapsed = max(0.0, now - session.state.current_model_call_started_at)
+            if session.state.current_model_call_has_content and elapsed > 0:
+                rate = session.state.current_model_call_streaming_chars / 4 / elapsed
+            parts.append(
+                activity
+                + "("
+                + str(session.state.turn_model_calls)
+                + "):"
+                + f"{elapsed:.1f}s"
+            )
+        if rate > 0:
+            parts[3] += " " + _format_count(int(rate)) + "t/s"
+        if session.state.status_notice and session.state.status_notice_until > now:
+            parts.append(session.state.status_notice)
         return " | ".join(parts)
 
+    @staticmethod
+    def _activity_label(activity: str) -> str:
+        return {"compact": "compacting", "observe": "observing"}.get(activity, "working")
+
     def _sweep_fragments(self, text: str, now: float) -> list[tuple[str, str]]:
         if not text:
             return [("", "")]

{nanocode_cli-0.3.27 → nanocode_cli-0.3.32/nanocode_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.3.27
+Version: 0.3.32
 Summary: A lightweight terminal-based AI coding assistant
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -119,7 +119,7 @@ USE AT YOUR OWN RISK.
 - Maintenance: `/clean`.
 - Exit: `/exit`, `/quit`.
 
-`/model` groups configured `available_models` first, then any extra models automatically discovered from the provider. In selectors, use `j`/`k` or arrow keys to move, `/keyword` to filter choices, Enter to select, and Esc to step back or cancel. `/model <model_name>` sets a model directly. Changing model also opens a reasoning effort selector: choose `off` to disable reasoning, or choose an effort to enable reasoning and set it. Use `/reason` to change reasoning without changing model.
+Selectors support `j`/`k`, arrows, `/keyword`, Enter, and Esc. `/model` lists configured models before discovered ones, then prompts for reasoning; `/model <name>` and `/reason` are direct shortcuts.
 
 ## Configuration
 

{nanocode_cli-0.3.27 → nanocode_cli-0.3.32}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.3.27"
+version = "0.3.32"
 description = "A lightweight terminal-based AI coding assistant"
 readme = "README.md"
 requires-python = ">=3.11"