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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.6.6
+Version: 0.7.0
 Summary: A small terminal coding agent written in Python
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -22,13 +22,14 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: anthropic>=0.64.0
-Requires-Dist: code-symbol-index>=0.3.0
+Requires-Dist: code-symbol-index>=0.3.1
 Requires-Dist: json-repair
-Requires-Dist: fastmcp<4,>=3
+Requires-Dist: fastmcp-slim[client]<4,>=3
 Requires-Dist: openai>=2.37.0
 Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: rich>=13.0
 Requires-Dist: socksio>=1.0.0
+Requires-Dist: websockets>=15.0.1
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.4.0; extra == "dev"

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

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import argparse
+import codecs
 import difflib
 import asyncio
 import fnmatch
@@ -59,7 +60,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 from rich.rule import Rule
 
-__version__ = "0.6.6"
+__version__ = "0.7.0"
 
 Json = dict[str, Any]
 HTTP_USER_AGENT = "nanocode/" + __version__
@@ -236,6 +237,8 @@ class RuntimeSettings:
     check_updates: bool = True
     update_check_interval_hours: int = 24
     session_retention_days: int = 7
+    # Max read-only tool calls from one model batch to execute concurrently; 1 disables parallelism.
+    max_parallel_tools: int = 4
     mcp_selector: str = ""
     yolo: bool = False
     debug: bool = False
@@ -247,6 +250,7 @@ class RuntimeSettings:
             shell_timeout=Config.int(runtime, "shell_timeout", 60),
             max_steps=max(1, Config.int(runtime, "max_agent_steps", Config.int(runtime, "max_steps", 200))),
             max_context_tokens=max(1, Config.int(runtime, "max_context_tokens", DEFAULT_MAX_CONTEXT_TOKENS)),
+            max_parallel_tools=max(1, Config.int(runtime, "max_parallel_tools", 4)),
             check_updates=Config.bool(runtime, "check_updates", True),
             update_check_interval_hours=max(1, Config.int(runtime, "update_check_interval_hours", 24)),
             session_retention_days=max(0, Config.int(runtime, "session_retention_days", 7)),
@@ -357,6 +361,7 @@ data_dir = "~/.nanocode"
 shell_timeout = 60
 max_agent_steps = 200
 max_context_tokens = 128000
+max_parallel_tools = 4
 check_updates = true
 update_check_interval_hours = 24
 session_retention_days = 7
@@ -441,10 +446,43 @@ class ModelUsage:
         self.last_cached_prompt_tokens = cached_tokens
 
 
+@dataclass
+class PlanItem:
+    STATUSES: ClassVar[tuple[str, ...]] = ("todo", "doing", "done", "blocked")
+    SYMBOLS: ClassVar[dict[str, str]] = {"todo": " ", "doing": "~", "done": "x", "blocked": "-"}
+    LEGACY_MARKERS: ClassVar[dict[str, str]] = {" ": "todo", "~": "doing", "x": "done", "X": "done", "-": "blocked"}
+
+    status: str
+    text: str
+
+    @classmethod
+    def parse(cls, value: Any) -> "PlanItem | None":
+        if isinstance(value, cls):
+            status, text = value.status, value.text
+        elif isinstance(value, dict):
+            status = str(value.get("status") or "todo").strip().lower()
+            text = str(value.get("text") or "").strip()
+        else:
+            raw = str(value).strip()
+            match = re.fullmatch(r"\[( |x|X|~|-)\]\s+(.+)", raw)
+            status = cls.LEGACY_MARKERS[match.group(1)] if match else "todo"
+            text = match.group(2).strip() if match else raw
+        if not text:
+            return None
+        return cls(status if status in cls.STATUSES else "todo", text)
+
+    def to_json(self) -> Json:
+        return {"status": self.status, "text": self.text}
+
+    def row(self, *, status: bool = False, style: str = "text") -> str:
+        prefix = f"[{self.SYMBOLS[self.status]}] " if status and style == "symbol" else f"{self.status}: " if status else ""
+        return "- " + prefix + self.text
+
+
 @dataclass
 class AgentState:
     goal: str = ""
-    plan: list[str] = field(default_factory=list)
+    plan: list[PlanItem | Json | str] = field(default_factory=list)
     known: list[str] = field(default_factory=list)
     check: str = ""
     summary: str = ""
@@ -460,23 +498,23 @@ class AgentState:
     manual_model_retry_requested: bool = False
     model_retry_count: int = 0
 
-    @staticmethod
-    def plan_text(item: str) -> str:
-        return re.sub(r"^\[(?: |x|X|~|-)\]\s+", "", item.strip()).strip()
+    def __post_init__(self) -> None:
+        self.plan = self.plan_items(self.plan)
 
     @classmethod
-    def plan_rows_for(cls, items: list[str], *, status: bool = False) -> list[str]:
-        rows = [
-            f"- [{'~' if index == 0 else ' '}] {item}" if status else "- " + item
-            for index, item in enumerate(filter(None, (cls.plan_text(str(item)) for item in items)))
-        ]
-        return rows or ["- (empty)"]
+    def plan_items(cls, items: list[Any]) -> list[PlanItem]:
+        return [item for raw in items if (item := PlanItem.parse(raw))]
 
-    def plan_rows(self, *, status: bool = False) -> list[str]:
-        return self.plan_rows_for(self.plan, status=status)
+    @classmethod
+    def plan_rows_for(cls, items: list[Any], *, status: bool = False, style: str = "text") -> list[str]:
+        rows = [item.row(status=status, style=style) for item in cls.plan_items(items)]
+        return rows or ["- (empty)"]
 
-    def current_focus(self) -> str:
-        return next((text for item in self.plan if (text := self.plan_text(item))), "")
+    @classmethod
+    def focus_text(cls, items: list[Any]) -> str:
+        plan = cls.plan_items(items)
+        current = next((item for item in plan if item.status == "doing"), None) or next((item for item in plan if item.status != "done"), None)
+        return current.text if current else ""
 
     def apply(self, data: Json) -> None:
         for attr in ("goal", "summary", "check"):
@@ -485,12 +523,12 @@ class AgentState:
         for attr in ("plan", "known"):
             value = data.get(attr)
             if isinstance(value, list):
-                items = list(filter(None, (str(item).strip() for item in value)))
-                setattr(self, attr, [self.plan_text(item) for item in items] if attr == "plan" else items)
+                items = list(filter(None, (str(item).strip() for item in value))) if attr == "known" else self.plan_items(value)
+                setattr(self, attr, items)
 
     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(), "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
@@ -769,7 +807,7 @@ class SessionSnapshotCodec:
     def state(state: AgentState) -> Json:
         return {
             "goal": state.goal,
-            "plan": state.plan,
+            "plan": [item.to_json() for item in AgentState.plan_items(state.plan)],
             "known": state.known,
             "check": state.check,
             "summary": state.summary,
@@ -1128,10 +1166,6 @@ class Session:
     def clean_expired_snapshots(self) -> int:
         return SessionSnapshotStore.clean_expired(self)
 
-    @classmethod
-    def _resolve_uid(cls, uid: str, data_dir: str = "~/.nanocode") -> str:
-        return SessionSnapshotStore.resolve_uid(uid, data_dir)
-
     @classmethod
     def load_snapshot(cls, uid: str, config: Config | None = None, settings: RuntimeSettings | None = None) -> "Session":
         return SessionSnapshotStore.load(uid, config=config, settings=settings)
@@ -1334,7 +1368,7 @@ class Tool:
 
 class ReadTool(Tool):
     NAME = "Read"
-    DESCRIPTION = "Read UTF-8 file line ranges; returns file stat, total lines, line:hash text, and updates FILE STATE."
+    DESCRIPTION = "Read UTF-8 file line ranges; returns file stat, total lines, anchor=line:hash(line_content) text, and updates FILE STATE."
     SIGNATURE = "Read(path,ranges=[[start,end],...]) or Read(files=[{path,ranges}]); lines are 0-based, end-exclusive"
     EXAMPLE = (
         'Read ranges. Example: {"path":"src/app.py","ranges":[[0,80],[120,180]]}',
@@ -1378,6 +1412,30 @@ class ReadTool(Tool):
     def line_hash(line: str) -> str:
         return Text.base36(int(hashlib.sha1(line.encode("utf-8")).hexdigest()[:6], 16)).rjust(5, "0")
 
+    @classmethod
+    def anchor(cls, index: int, line: str) -> str:
+        return f"{index}:{cls.line_hash(line)}"
+
+    @classmethod
+    def anchor_line(cls, index: int, line: str) -> str:
+        return f"anchor={cls.anchor(index, line)} | {line.rstrip(chr(10))}"
+
+    @staticmethod
+    def indexed_line_hash(line: str) -> str:
+        return hashlib.sha256(line.rstrip("\n").encode("utf-8")).hexdigest()[:8]
+
+    @staticmethod
+    def parse_anchor(value: str) -> tuple[int, str] | None:
+        text = value.split("|", 1)[0].strip()
+        if text.startswith("anchor="):
+            text = text.removeprefix("anchor=").strip()
+        match = re.fullmatch(r"(\d+):([0-9a-z]{5}|[0-9a-f]{8})", text)
+        return (int(match.group(1)), match.group(2).lower()) if match else None
+
+    @classmethod
+    def anchor_matches(cls, line: str, expected: str) -> bool:
+        return expected == cls.line_hash(line) or expected == cls.indexed_line_hash(line)
+
     def needs_confirmation(self) -> bool:
         return any(not self.session.in_cwd(path) for path, _ranges in self.targets())
 
@@ -1415,7 +1473,7 @@ class ReadTool(Tool):
             end = max(start, len(lines) if requested_end == 0 else min(len(lines), requested_end))
             out.append(f"<range>{start}:{end}</range>")
             out.append("<content hashline-numbered>")
-            out.append("".join(f"{i}:{self.line_hash(lines[i])}|{lines[i]}" for i in range(start, end)).rstrip("\n"))
+            out.extend(self.anchor_line(i, lines[i]) for i in range(start, end))
             out.append("</content>")
         out.append("</Read>")
         return "\n".join(out)
@@ -1644,7 +1702,7 @@ class FindTool(Tool):
 
 class SearchTool(Tool):
     NAME = "Search"
-    DESCRIPTION = "Search UTF-8 text files with case-insensitive regex; skips binary/hidden/gitignored files and returns path:line:hash matches."
+    DESCRIPTION = "Search UTF-8 text files with case-insensitive regex; skips binary/hidden/gitignored files and returns path anchor=line:hash matches."
     SIGNATURE = "Search(pattern,path?,glob?,context?) or Search(queries=[...]); pattern is regex, A|B|C is ok"
     EXAMPLE = (
         'Search source with context. Example: {"pattern":"class .*Tool","path":"src","glob":"*.py","context":2}',
@@ -1827,7 +1885,7 @@ class SearchTool(Tool):
         return rows
 
     def match_line(self, prefix: str, path: str, line_index: int, line: str) -> str:
-        return f"{prefix} {self.session.relpath(path)}:{line_index}:{ReadTool.line_hash(line)}|{line.rstrip()}"
+        return f"{prefix} {self.session.relpath(path)} {ReadTool.anchor_line(line_index, line)}"
 
 
 class CodeIndex:
@@ -2079,7 +2137,7 @@ class InspectCodeTool(Tool):
         if mode == "find":
             return csi.search(target, limit=limit or csi.DEFAULT_SEARCH_LIMIT, **common)
         if mode == "inspect":
-            return csi.inspect(target, limit=limit or csi.DEFAULT_PAGE_LIMIT, anchors=True, **common)
+            return csi.inspect(target, limit=limit or csi.DEFAULT_PAGE_LIMIT, anchors=True, anchor_format="explicit", **common)
         if mode == "refs":
             ref_kinds = options.get("ref_kind") or ("all" if options.get("all_kinds") else "behavioral")
             return csi.refs(target, limit=limit or csi.DEFAULT_MAX_REFERENCES, offset=int(options.get("offset") or 0), ref_kinds=ref_kinds, **common)
@@ -2319,7 +2377,7 @@ class EditTool(Tool):
                         out.append("...")
                         break
                     line = lines[index]
-                    out.append(f"{index}:{ReadTool.line_hash(line)}|{line.rstrip(chr(10))}")
+                    out.append(ReadTool.anchor_line(index, line))
                     shown_lines += 1
             out.append("</target>")
             if shown_lines >= 12:
@@ -2337,7 +2395,7 @@ class EditTool(Tool):
             shown = lines[start:end]
             if shown:
                 out.append("<content hashline-numbered>")
-                out.extend(f"{start + index}:{ReadTool.line_hash(line)}|{line.rstrip(chr(10))}" for index, line in enumerate(shown))
+                out.extend(ReadTool.anchor_line(start + index, line) for index, line in enumerate(shown))
                 out.append("</content>")
         return "\n".join(out)
 
@@ -2360,16 +2418,14 @@ class EditTool(Tool):
         return value.replace("\\r\\n", "\n").replace("\\n", "\n").replace("\\t", "\t") if "\n" not in value and "\\n" in value else value
 
     def resolve_anchor(self, lines: list[str], anchor: str) -> int:
-        match = re.fullmatch(r"(\d+):([0-9a-z]{5})", anchor.split("|", 1)[0].strip())
-        if not match:
-            raise ToolError('invalid anchor; use "line:hash" from Read or Search')
-        index = int(match.group(1))
+        parsed = ReadTool.parse_anchor(anchor)
+        if parsed is None:
+            raise ToolError('invalid anchor; use the "anchor=line:hash" value from Read, Search, or InspectCode')
+        index, expected = parsed
         if index >= len(lines):
             raise ToolError("anchor line out of range")
-        expected = match.group(2).lower()
-        actual = ReadTool.line_hash(lines[index])
-        if actual != expected:
-            current = f"{index}:{actual}|{lines[index].rstrip()}"
+        if not ReadTool.anchor_matches(lines[index], expected):
+            current = ReadTool.anchor_line(index, lines[index])
             raise ToolError(f"stale anchor {anchor}; current is {current}")
         return index
 
@@ -2427,6 +2483,9 @@ class BashTool(Tool):
     def stream_process(self, proc: subprocess.Popen[bytes]) -> str:
         stdout_parts: list[str] = []
         stderr_parts: list[str] = []
+        # Per-stream incremental decoders so a multibyte UTF-8 character split across two 4096-byte
+        # reads is decoded once it is complete, instead of being mangled into replacement chars.
+        self._decoders = {"stdout": codecs.getincrementaldecoder("utf-8")("replace"), "stderr": codecs.getincrementaldecoder("utf-8")("replace")}
         selector = selectors.DefaultSelector()
         selector.register(proc.stdout, selectors.EVENT_READ, "stdout")
         selector.register(proc.stderr, selectors.EVENT_READ, "stderr")
@@ -2469,6 +2528,13 @@ class BashTool(Tool):
             data = os.read(key.fileobj.fileno(), 4096)
         except OSError:
             data = b""
+        # final=True on EOF flushes any bytes still buffered in the decoder (e.g. a truncated
+        # trailing character) so they are not silently dropped.
+        text = self._decoders[key.data].decode(data, final=not data)
+        if text:
+            (stdout_parts if key.data == "stdout" else stderr_parts).append(text)
+            if self.live_output is not None:
+                self.live_output(str(key.data), text)
         if not data:
             try:
                 selector.unregister(key.fileobj)
@@ -2479,10 +2545,6 @@ class BashTool(Tool):
             except Exception:
                 pass
             return False
-        text = data.decode("utf-8", errors="replace")
-        (stdout_parts if key.data == "stdout" else stderr_parts).append(text)
-        if self.live_output is not None:
-            self.live_output(str(key.data), text)
         return True
 
     @staticmethod
@@ -2705,15 +2767,27 @@ class RecallTool(Tool):
 
 class NoteTool(Tool):
     NAME = "Note"
-    DESCRIPTION = "Maintain durable working notes; set_goal, replace_plan, and set_check replace current values, append_known appends, replace_known replaces all known facts."
+    DESCRIPTION = "Maintain durable working notes; set_goal, replace_plan, and set_check replace current values, append_known appends, replace_known replaces all known facts. Plan items are objects with status todo|doing|done|blocked and text."
     SIGNATURE = "Note(set_goal?, replace_plan?, append_known?, replace_known?, set_check?)"
-    EXAMPLE = ('Set memory. Example: {"set_goal":"ship parser fix","replace_plan":["inspect parser","patch bug"],"append_known":["tests use pytest"],"set_check":"pytest -q passed"}',)
+    EXAMPLE = (
+        'Set memory. Example: {"set_goal":"ship parser fix","replace_plan":[{"status":"doing","text":"inspect parser"},{"status":"todo","text":"patch bug"}],"append_known":["tests use pytest"],"set_check":"pytest -q passed"}',
+    )
     STORES_RESULT = False
 
     @classmethod
     def params_schema(cls) -> Json:
         strings = {"type": "array", "items": {"type": "string"}}
-        return {"type": "object", "properties": {"set_goal": {"type": "string"}, "replace_plan": strings, "append_known": strings, "replace_known": strings, "set_check": {"type": "string"}}, "additionalProperties": False}
+        plan_item = {
+            "type": "object",
+            "properties": {"status": {"type": "string", "enum": list(PlanItem.STATUSES)}, "text": {"type": "string"}},
+            "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"}},
+            "additionalProperties": False,
+        }
 
     @classmethod
     def payload_args(cls, payload: Json) -> list[Any]:
@@ -2738,8 +2812,14 @@ class NoteTool(Tool):
             changed.append("set_check")
         if "replace_plan" in data:
             if not isinstance(data["replace_plan"], list):
-                raise ToolError('Note replace_plan must be an array of strings, e.g. {"replace_plan":["inspect","patch"]}')
-            plan = [AgentState.plan_text(str(item)) for item in data["replace_plan"] if AgentState.plan_text(str(item))]
+                raise ToolError('Note replace_plan must be an array of plan items, e.g. {"replace_plan":[{"status":"doing","text":"inspect"}]}')
+            for item in data["replace_plan"]:
+                if isinstance(item, dict):
+                    if str(item.get("status") or "").strip().lower() not in PlanItem.STATUSES:
+                        raise ToolError("Note replace_plan status must be one of: " + ", ".join(PlanItem.STATUSES))
+                    if not str(item.get("text") or "").strip():
+                        raise ToolError("Note replace_plan text is required")
+            plan = AgentState.plan_items(data["replace_plan"])
             changed.append("replace_plan")
         if "append_known" in data:
             if not isinstance(data["append_known"], list):
@@ -2763,19 +2843,19 @@ class NoteTool(Tool):
         data = self.args[0] if self.args and isinstance(self.args[0], dict) else {}
         lines = []
         if goal := str(data.get("set_goal") or "").strip():
-            lines.append("set_goal -> " + Tool.compact(goal, 120))
+            lines.append("goal: " + Tool.compact(goal, 120))
         if check := str(data.get("set_check") or "").strip():
-            lines.append("set_check -> " + Tool.compact(check, 120))
+            lines.append("check: " + Tool.compact(check, 120))
         if isinstance(data.get("replace_plan"), list):
-            lines.extend(["replace_plan:", *(f"  {row}" for row in AgentState.plan_rows_for(data["replace_plan"], status=True) if row != "- (empty)")])
+            lines.extend(["plan:", *(f"  {row}" for row in AgentState.plan_rows_for(data["replace_plan"], status=True, style="symbol") if row != "- (empty)")])
         if isinstance(data.get("append_known"), list):
             known = [Tool.compact(item, 120) for item in data["append_known"] if str(item).strip() and str(item).strip() not in self.session.state.known]
             if known:
-                lines.extend(["append_known:", *(f"  + {item}" for item in known)])
+                lines.extend(["known:", *(f"  + {item}" for item in known)])
         if isinstance(data.get("replace_known"), list):
             known = [Tool.compact(item, 120) for item in data["replace_known"] if str(item).strip()]
             if known:
-                lines.extend(["replace_known:", *(f"  {item}" for item in known)])
+                lines.extend(["known:", *(f"  {item}" for item in known)])
         return ["\n".join(lines) or "{}"]
 
 
@@ -3031,6 +3111,9 @@ class ToolCall:
     id: str
     name: str
     args: list[Any]
+    # A malformed-argument error captured while parsing the call. Deferred so it surfaces as a
+    # tool result the model can correct from, instead of aborting the whole turn at parse time.
+    error: str = ""
 
 
 class ContextManager:
@@ -3147,7 +3230,7 @@ class ContextManager:
         index_usable = "yes" if index_status in {"synced", "ready", "stale"} else "no"
         rows = [
             "Goal: " + (self.session.state.goal or "(empty; use Note for multi-step work)"),
-            "Plan:\n" + "\n".join(self.session.state.plan_rows() or ["- (empty; use Note for a short plan)"]),
+            "Plan:\n" + "\n".join(AgentState.plan_rows_for(self.session.state.plan, status=True)),
             "Known:\n" + "\n".join("- " + item for item in self.session.state.known or ["(empty)"]),
             "Check: " + (self.session.state.check or "(empty)"),
             f"Code index: {index_status} (InspectCode usable: {index_usable})",
@@ -3213,9 +3296,9 @@ class ContextManager:
                     items.append(self.FileContextItem(order, 0, "clear", record.key, record.name, path, int(match.group(1)), int(match.group(2)), "", *stat))
                 for match in re.finditer(r"(?s)<content hashline-numbered>\n(.*?)\n</content>", body):
                     for line in match.group(1).splitlines():
-                        line_match = re.match(r"(\d+):[0-9a-z]{5}\|", line)
-                        if line_match:
-                            items.append(self.FileContextItem(order, 1, "line", record.key, record.name, path, int(line_match.group(1)), 0, line, *stat))
+                        parsed = ReadTool.parse_anchor(line)
+                        if parsed is not None:
+                            items.append(self.FileContextItem(order, 1, "line", record.key, record.name, path, parsed[0], 0, line, *stat))
         return items
 
     def file_count(self) -> int:
@@ -3238,8 +3321,8 @@ class ContextManager:
         if item.path not in current_lines:
             current_lines[item.path] = self.read_lines(item.path, wanted.get(item.path, set()))
         lines = current_lines[item.path]
-        hash_match = re.match(r"\d+:([0-9a-z]{5})\|", item.line)
-        return bool(lines is not None and hash_match and item.start in lines and ReadTool.line_hash(lines[item.start]) == hash_match.group(1))
+        parsed = ReadTool.parse_anchor(item.line)
+        return bool(lines is not None and parsed is not None and item.start in lines and ReadTool.anchor_matches(lines[item.start], parsed[1]))
 
     def render_file_lines(self, lines_by_path: dict[str, dict[int, tuple[str, str, str]]], omitted: dict[str, dict[str, int]]) -> str:
         def recent(path: str) -> int:
@@ -3251,7 +3334,9 @@ class ContextManager:
         paths = sorted((path for path in lines_by_path if lines_by_path[path]), key=lambda path: (-recent(path), path))
         code_edits = self.recent_code_edits()
         check_status = self.check_status(code_edits)
-        focus, actions, errors = self.session.state.current_focus(), self.recent_file_actions(), self.recent_tool_errors()
+        state = self.session.state
+        focus = state.focus_text(state.plan)
+        actions, errors = self.recent_file_actions(), self.recent_tool_errors()
         if not paths and not omitted and not focus and not actions and not code_edits and not check_status and not errors:
             return ""
         chunks = ["Read/Edit outputs update this section. Treat listed ranges as current file state."] if paths else []
@@ -3270,7 +3355,7 @@ class ContextManager:
         if errors:
             chunks.extend(["", "Recent tool errors:", *errors])
         if paths:
-            chunks.extend(["", "Content:", "Format: line:hash|text. Use line:hash as edit anchors."])
+            chunks.extend(["", "Content:", "Format: anchor=line:hash | text, where hash = hash(line_content). Use the full line:hash value as Edit anchors."])
             for path in paths:
                 for start, end, source, tool, segment_lines in self.segments(lines_by_path[path]):
                     chunks.append(f"@@ {path} {start}:{end} current source={source} tool={tool}")
@@ -3681,18 +3766,18 @@ class EditBatchPlan:
         return changes
 
     def resolve_anchor(self, state: FileState, anchor: str) -> int:
-        match = re.fullmatch(r"(\d+):([0-9a-z]{5})", anchor.split("|", 1)[0].strip())
-        if not match:
-            raise ToolError('invalid anchor; use "line:hash" from Read or Search')
-        index, expected = int(match.group(1)), match.group(2).lower()
-        if index < len(state.lines) and ReadTool.line_hash(state.lines[index].text) == expected:
+        parsed = ReadTool.parse_anchor(anchor)
+        if parsed is None:
+            raise ToolError('invalid anchor; use the "anchor=line:hash" value from Read, Search, or InspectCode')
+        index, expected = parsed
+        if index < len(state.lines) and ReadTool.anchor_matches(state.lines[index].text, expected):
             return index
-        if index < len(state.original) and ReadTool.line_hash(state.original[index]) == expected:
+        if index < len(state.original) and ReadTool.anchor_matches(state.original[index], expected):
             current = state.current_origin(index)
             if current is not None:
                 return current
             raise ToolError(f"stale anchor {anchor}; original line was changed in this batch")
-        current = f"{index}:{ReadTool.line_hash(state.lines[index].text)}|{state.lines[index].text.rstrip()}" if index < len(state.lines) else "out of range"
+        current = ReadTool.anchor_line(index, state.lines[index].text) if index < len(state.lines) else "out of range"
         raise ToolError(f"stale anchor {anchor}; current is {current}")
 
 
@@ -3715,6 +3800,7 @@ class MCPManager:
         self.server_skips: dict[str, str] = {}
         self.lock = threading.Lock()
         self.discovery_status: str = "stale"  # stale | discovering | ready | error
+        self.index_truncated: bool = False  # set by render_tools_index when even name-only overflows the cap
         self._configs_cache: list[MCPServerConfig] | None = None
         self._oauth_token_store = MCPFileTokenStore(self.session.data_path("mcp-oauth", "tokens.json"))
         self._loop: asyncio.AbstractEventLoop | None = None
@@ -3954,9 +4040,6 @@ class MCPManager:
             )
         return infos
 
-    def resource_info(self, server: str, uri: str) -> MCPResourceInfo | None:
-        return next((res for res in self.resources.get(server, []) if res.uri == uri), None)
-
     @staticmethod
     def tool_annotations(tool: Any) -> Json:
         annotations = getattr(tool, "annotations", None)
@@ -4388,19 +4471,71 @@ class MCPManager:
         return "\n".join(lines)
 
     def render_tools_index(self) -> str:
+        """Render the MCP tools block injected into every model turn (in the cached prefix).
+
+        The block is capped at INDEX_TOTAL_LIMIT so it cannot bloat each request. When it
+        would overflow we degrade by shedding *detail*, never *entities*: the model can
+        always re-fetch a dropped schema via `describe`, but it can never call a server or
+        tool it was never told exists. So we try progressively cheaper renderings and emit
+        the richest one that fits:
+
+            tier 1 "schema" — full per-tool JSON schemas inline (normal case)
+            tier 2 "args"   — schemas dropped, name + arg summary per tool
+            tier 3 "names"  — name-only, grouped per server
+            tier 4          — hard truncate (only at thousands of tools, where 16KB
+                              physically cannot hold them); server headers come first so
+                              the model still sees most servers exist.
+
+        Tiers 1–3 keep every enabled server and tool name visible. See _index_body for how
+        each detail level is rendered, and test_mcp.TestToolIndexBudget for the guarantees.
+        """
         configs = [c for c in self.parse_configs() if c.enabled]
         if not configs:
             return ""
 
-        lines: list[str] = []
-        lines.append("--- MCP TOOLS ---")
-        lines.append('Use MCP(action="call", server, tool, arguments) for external MCP server tools.')
-        lines.append('Use MCP(action="describe", server, tool) for the full schema when one is truncated below; the result stays in the conversation, so do not describe the same tool again once its schema is shown — just call it.')
-        lines.append('Use MCP(action="read_resource", server, uri) to read a listed resource (e.g. docs describing how to build a tool\'s arguments). Read relevant resources before calling.')
-        lines.append("Format: server.tool(req: type; opt: type) - description")
-        lines.append("        schema: <JSON Schema for the arguments object>")
-        lines.append("")
+        intro = [
+            "--- MCP TOOLS ---",
+            'Use MCP(action="call", server, tool, arguments) for external MCP server tools.',
+            'Use MCP(action="describe", server, tool) for the full schema when one is truncated below; the result stays in the conversation, so do not describe the same tool again once its schema is shown — just call it.',
+            'Use MCP(action="read_resource", server, uri) to read a listed resource (e.g. docs describing how to build a tool\'s arguments). Read relevant resources before calling.',
+            "Format: server.tool(req: type; opt: type) - description",
+            "        schema: <JSON Schema for the arguments object>",
+            "",
+        ]
 
+        # A note tells the model what was shed (and that describe recovers it) so it does not
+        # assume a tool is argument-less. Tier 1 ("schema") needs no note; tier 4 reuses the
+        # last (tier 3) text below.
+        notes = {
+            "args": ['Schemas omitted to fit; use MCP(action="describe", server, tool) for a tool\'s arguments.', ""],
+            "names": ['Only tool names shown to fit; use MCP(action="describe", server, tool) before calling.', ""],
+        }
+        for detail in ("schema", "args", "names"):
+            body = self._index_body(configs, detail=detail)
+            text = "\n".join(intro + notes.get(detail, []) + body)
+            if len(text) <= self.INDEX_TOTAL_LIMIT:
+                self.index_truncated = False
+                return text
+
+        # Tier 4: even name-only overflows, so some tools are dropped entirely (not just
+        # detail). Flag it so the CLI can warn the user — unlike tiers 1-3 these tools are
+        # not callable until the index fits (fewer servers, or consult /mcp tools).
+        self.index_truncated = True
+        return text[: self.INDEX_TOTAL_LIMIT - 10] + "\n... MCP tools truncated; use /mcp tools for full list."
+
+    def _index_body(self, configs: list["MCPServerConfig"], *, detail: str = "schema") -> list[str]:
+        """Render the per-server body lines of the tools index at one detail level.
+
+        detail controls how much of each tool is emitted (richest to cheapest):
+            "schema" — full line via _format_tool_line, including the inline JSON schema
+            "args"   — same line without the schema (name + arg summary + description)
+            "names"  — one "tools: a, b, c" line per server, names only
+
+        Every enabled server is represented regardless of detail: a connected server shows
+        its tools, an unconnected one (no tools/resources) is collected into a trailing
+        "not yet available" section so the model still knows it exists.
+        """
+        lines: list[str] = []
         pending: list[str] = []
         for config in configs:
             tools = self.tools.get(config.name, [])
@@ -4408,12 +4543,15 @@ class MCPManager:
             if not tools and not resources:
                 pending.append(f"- {config.name}: {self._pending_status(config.name)}")
                 continue
-            name_display = config.name.capitalize()
-            lines.append(f"[{config.name}] {name_display}")
-            for tool in tools:
-                line = self._format_tool_line(config.name, tool)
-                if line:
-                    lines.append(line)
+            lines.append(f"[{config.name}] {config.name.capitalize()}")
+            if detail == "names":
+                if tools:
+                    lines.append("tools: " + ", ".join(tool.name for tool in tools))
+            else:
+                for tool in tools:
+                    line = self._format_tool_line(config.name, tool, include_schema=detail == "schema")
+                    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.extend(self._format_resource_line(res) for res in resources)
@@ -4423,11 +4561,7 @@ class MCPManager:
             lines.append("Configured servers not yet available (they exist — do not assume otherwise):")
             lines.extend(pending)
             lines.append("")
-
-        text = "\n".join(lines)
-        if len(text) > self.INDEX_TOTAL_LIMIT:
-            text = text[: self.INDEX_TOTAL_LIMIT - 10] + "\n... MCP tools truncated; use /mcp tools for full list."
-        return text
+        return lines
 
     def server_issue(self, name: str) -> tuple[str, str] | None:
         """Classify a server's failure state as (kind, message); error takes precedence over skip."""
@@ -4503,7 +4637,7 @@ class MCPManager:
             lines.extend(self._format_resource_line(res) for res in resources)
         return "\n".join(lines)
 
-    def _format_tool_line(self, server: str, info: MCPToolInfo) -> str:
+    def _format_tool_line(self, server: str, info: MCPToolInfo, *, include_schema: bool = True) -> str:
         args_str = self._tool_args_summary(info)
         desc = (info.description or "").split("\n")[0].strip()
         desc = " ".join(desc.split())
@@ -4518,9 +4652,10 @@ class MCPManager:
         uris = self._extract_uris(info.description)
         if uris:
             line += "\n  refs (read with MCP action=\"read_resource\"): " + ", ".join(uris)
-        schema = self._schema_json(info.input_schema, self.INDEX_SCHEMA_LIMIT)
-        if schema:
-            line += f"\n  schema: {schema}"
+        if include_schema:
+            schema = self._schema_json(info.input_schema, self.INDEX_SCHEMA_LIMIT)
+            if schema:
+                line += f"\n  schema: {schema}"
         return line
 
     URI_PATTERN: ClassVar[re.Pattern] = re.compile(r"[a-zA-Z][a-zA-Z0-9+.\-]*://[^\s'\"<>)\]}]+")
@@ -4645,28 +4780,112 @@ class ToolRunner:
         self.question_fn: Callable[[QuestionSpec, str], str] | None = None
 
     def run(self, calls: list[ToolCall], batch_suffix: str = "") -> list[Json]:
-        messages = []
+        messages: list[Json] = []
+        # Shared, mutated across segments: `first` controls which display carries batch_suffix;
+        # `refused` short-circuits the rest of the batch once a confirmation is declined.
+        state = {"first": True, "refused": False}
         index = 0
-        first, refused = True, False
         while index < len(calls):
+            if state["refused"]:
+                messages.append(self.skip_message(calls[index]))
+                index += 1
+                continue
+            end = self.parallel_segment_end(calls, index)
+            if end - index >= 2 and self.session.settings.max_parallel_tools > 1:
+                messages.extend(self.run_parallel(calls[index:end], batch_suffix, state))
+                index = end
+                continue
             end = index + 1 if self.edit_barrier(calls[index]) else self.edit_segment_end(calls, index)
-            segment = calls[index:end]
-            plan = EditBatchPlan(self.session).build(segment) if not refused and any(call.name == "Edit" for call in segment) else EditBatchPlan(self.session)
-            for call in segment:
-                self.session.state.turn_tool_calls += 1
-                suffix = batch_suffix if first else ""
-                first = False
-                status, content = (
-                    ("skipped", self.tool_message(call, "", "Skipped: previous tool call was refused", failed=True))
-                    if refused
-                    else self.run_one(call, batch_suffix=suffix, planned_edit=plan.planned.get(call.id), plan_error=plan.errors.get(call.id, ""))
-                )
-                messages.append({"role": "tool", "tool_call_id": call.id, "content": content})
-                if status == "refused":
-                    refused = True
+            messages.extend(self.run_serial(calls[index:end], batch_suffix, state))
             index = end
         return messages
 
+    def skip_message(self, call: ToolCall) -> Json:
+        self.session.state.turn_tool_calls += 1
+        content = self.tool_message(call, "", "Skipped: previous tool call was refused", failed=True)
+        return {"role": "tool", "tool_call_id": call.id, "content": content}
+
+    def run_serial(self, segment: list[ToolCall], batch_suffix: str, state: dict[str, bool]) -> list[Json]:
+        messages: list[Json] = []
+        plan = EditBatchPlan(self.session).build(segment) if any(call.name == "Edit" for call in segment) else EditBatchPlan(self.session)
+        for call in segment:
+            self.session.state.turn_tool_calls += 1
+            suffix = batch_suffix if state["first"] else ""
+            state["first"] = False
+            status, content = self.run_one(call, batch_suffix=suffix, planned_edit=plan.planned.get(call.id), plan_error=plan.errors.get(call.id, ""))
+            messages.append({"role": "tool", "tool_call_id": call.id, "content": content})
+            if status == "refused":
+                state["refused"] = True
+        return messages
+
+    def run_parallel(self, segment: list[ToolCall], batch_suffix: str, state: dict[str, bool]) -> list[Json]:
+        # Run the pure tool.call() work concurrently, but apply all side effects (display, session
+        # bookkeeping, tool messages) on this thread in request order, so output and the results
+        # handed back to the model match the order the model issued the calls.
+        cap = max(1, self.session.settings.max_parallel_tools)
+        outcomes: list[tuple[str, str, str | None, float] | None] = [None] * len(segment)
+        with ThreadPoolExecutor(max_workers=min(len(segment), cap), thread_name_prefix="tool") as executor:
+            futures = {executor.submit(self.execute_readonly, call): position for position, call in enumerate(segment)}
+            for future in as_completed(futures):
+                outcomes[futures[future]] = future.result()
+        messages: list[Json] = []
+        for call, outcome in zip(segment, outcomes):
+            self.session.state.turn_tool_calls += 1
+            suffix = batch_suffix if state["first"] else ""
+            state["first"] = False
+            assert outcome is not None
+            content = self.finalize_outcome(call, outcome, batch_suffix=suffix)
+            messages.append({"role": "tool", "tool_call_id": call.id, "content": content})
+        return messages
+
+    def parallel_segment_end(self, calls: list[ToolCall], start: int) -> int:
+        end = start
+        while end < len(calls) and self.parallel_safe(calls[end]):
+            end += 1
+        return end
+
+    def parallel_safe(self, call: ToolCall) -> bool:
+        # A call may run concurrently only if it neither mutates state nor blocks on interactive
+        # input: read-only, auto-approved, non-interactive tools (Read/Search/Find/List/Recall/
+        # InspectCode, read-only Git, read-only MCP). Edit is coordinated serially by EditBatchPlan;
+        # Bash streams live output and mutates; Question blocks on the user.
+        tool_class = TOOL_REGISTRY.get(call.name)
+        if tool_class is None or call.name in {"Edit", "Question"} or tool_class is BashTool:
+            return False
+        try:
+            return not tool_class(self.session, call.args).needs_confirmation()
+        except Exception:
+            return False
+
+    def execute_readonly(self, call: ToolCall) -> tuple[str, str, str | None, float]:
+        # Pure execution for a parallel worker: returns (kind, output, display, elapsed) and performs
+        # no display or session writes (those happen in finalize_outcome on the main thread). Mirrors
+        # run_one's branches, minus confirmation (parallel_safe guarantees none is needed).
+        started = time.monotonic()
+        tool_class = TOOL_REGISTRY.get(call.name)
+        if tool_class is None:
+            return "reject", f"ToolError: unknown tool {call.name}", None, 0.0
+        tool = tool_class(self.session, call.args)
+        display = None
+        try:
+            display = self.short_call(call, tool.short_args())
+            if call.error:
+                raise ToolError(call.error)
+            output = tool.call()
+        except ToolError as error:
+            return "reject", f"ToolError: {error}", display, time.monotonic() - started
+        except Exception as error:
+            return "error", f"ToolError: {error}", display, time.monotonic() - started
+        return "ok", output, display, time.monotonic() - started
+
+    def finalize_outcome(self, call: ToolCall, outcome: tuple[str, str, str | None, float], batch_suffix: str = "") -> str:
+        kind, output, display, elapsed = outcome
+        if kind == "ok":
+            return self.finish(call, output, elapsed=elapsed, display=display, batch_suffix=batch_suffix)
+        if kind == "reject":
+            return self.reject(call, output, elapsed=elapsed, display=display, batch_suffix=batch_suffix)
+        return self.finish(call, output, failed=True, elapsed=elapsed, display=display, batch_suffix=batch_suffix)
+
     def edit_segment_end(self, calls: list[ToolCall], start: int) -> int:
         end = start
         while end < len(calls) and not self.edit_barrier(calls[end]):
@@ -4701,16 +4920,24 @@ class ToolRunner:
         tool = tool_class(self.session, call.args)
         if isinstance(tool, BashTool):
             tool.live_output = self.live_output
-        started, approved, display = time.monotonic(), False, None
+        started, approved, auto, display = time.monotonic(), False, False, None
         if isinstance(tool, QuestionTool):
             tool.question_fn = self.question_fn
         try:
             display = self.short_call(call, tool.short_args())
+            if call.error:
+                raise ToolError(call.error)
             if plan_error:
                 raise ToolError(plan_error)
             needs_confirmation = tool.needs_confirmation()
             if needs_confirmation and self.session.settings.yolo:
-                self.output_fn(self.approval_display(call, tool, "auto", batch_suffix=batch_suffix, planned_edit=planned_edit))
+                auto = True
+                pre = self.approval_display(call, tool, "auto", batch_suffix=batch_suffix, planned_edit=planned_edit)
+                # The "auto …" header duplicates the result line; only surface it when it carries a
+                # preview the result line won't repeat (e.g. an Edit diff). The auto-approval itself
+                # is recorded by the [auto] tag on the result line below.
+                if "\n" in pre:
+                    self.output_fn(pre)
             elif needs_confirmation:
                 confirmed, reason = self.confirm(call, tool, batch_suffix=batch_suffix, planned_edit=planned_edit)
                 if not confirmed:
@@ -4725,7 +4952,7 @@ class ToolRunner:
         except Exception as error:
             output = f"ToolError: {error}"
             return "failed", self.finish(call, output, failed=True, elapsed=time.monotonic() - started, display=display, batch_suffix=batch_suffix)
-        return "ok", self.finish(call, output, elapsed=time.monotonic() - started, approved=approved, display=display, batch_suffix=batch_suffix)
+        return "ok", self.finish(call, output, elapsed=time.monotonic() - started, approved=approved, auto=auto, display=display, batch_suffix=batch_suffix)
 
     def reject(self, call: ToolCall, output: str, *, elapsed: float | None = None, display: str | None = None, batch_suffix: str = "") -> str:
         if self.session.settings.debug:
@@ -4749,6 +4976,7 @@ class ToolRunner:
         failed: bool = False,
         elapsed: float | None = None,
         approved: bool = False,
+        auto: bool = False,
         display: str | None = None,
         store: bool = True,
         batch_suffix: str = "",
@@ -4763,7 +4991,7 @@ 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, 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:
@@ -4839,11 +5067,11 @@ 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, 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)
-        tag = " [refused]" if failed and "user refused" in output else " [failed]" if failed else " [approved]" if approved else ""
+        tag = " [refused]" if failed and "user refused" in output else " [failed]" if failed else " [approved]" if approved else " [auto]" if auto else ""
         line = self.with_batch_suffix("tool " + (display or self.short_call(call)) + ((" -> " + key) if key else "") + tag, batch_suffix)
         lines = [line]
         if failed:
@@ -5051,6 +5279,7 @@ class ModelClient:
 Compact the nanocode working context.
 Return one JSON object only. No markdown, prose, code fences, or comments.
 Use keys: summary, goal, plan, known, check.
+Plan must be an array of objects: {"status":"todo|doing|done|blocked","text":"..."}.
 Rewrite recent conversation briefly inside summary.
 Keep only durable facts needed to continue; preserve file paths, symbols, constraints, and tr.N keys.
 """.strip()
@@ -5195,7 +5424,9 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
                 continue
             function = raw.get("function") if isinstance(raw.get("function"), dict) else {}
             try:
-                payload = json.loads(str(function.get("arguments") or "{}"))
+                # strict=False: tool-call argument strings often contain literal newlines
+                # (e.g. a multi-line git commit message), which are not valid JSON otherwise.
+                payload = json.loads(str(function.get("arguments") or "{}"), strict=False)
             except json.JSONDecodeError:
                 payload = {}
             blocks.append(
@@ -5235,7 +5466,7 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
                 call_id = str(self.message_field(block, "id") or uuid.uuid4().hex)
                 arguments = json.dumps(payload, ensure_ascii=False, separators=(",", ":"))
                 tool_calls.append({"id": call_id, "type": "function", "function": {"name": name, "arguments": arguments}})
-                calls.append(ToolCall(id=call_id, name=name, args=self.tool_payload(name, payload)))
+                calls.append(self.tool_call(call_id, name, payload))
         text = "".join(text_parts)
         assistant: Json = {"role": "assistant", "content": text or None}
         if tool_calls:
@@ -5298,11 +5529,13 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
         calls = []
         for raw in getattr(message, "tool_calls", None) or []:
             try:
-                payload = json.loads(raw.function.arguments or "{}")
+                # strict=False so literal newlines in argument strings (e.g. a multi-line
+                # git commit message) parse instead of dropping the call's args.
+                payload = json.loads(raw.function.arguments or "{}", strict=False)
             except json.JSONDecodeError:
                 calls.append(ToolCall(id=raw.id, name=raw.function.name, args=[]))
                 continue
-            calls.append(ToolCall(id=raw.id, name=raw.function.name, args=self.tool_payload(raw.function.name, payload)))
+            calls.append(self.tool_call(raw.id, raw.function.name, payload))
         return calls
 
     @staticmethod
@@ -5311,6 +5544,16 @@ Keep only durable facts needed to continue; preserve file paths, symbols, constr
             return tool.payload_args(payload)
         return [payload]
 
+    @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
+        # error on the call so it is replayed as a tool result during execution, letting the model
+        # self-correct, rather than escaping to abort the entire agent turn.
+        try:
+            return ToolCall(id=call_id, name=name, args=cls.tool_payload(name, payload))
+        except ToolError as error:
+            return ToolCall(id=call_id, name=name, args=[], error=str(error))
+
 
 class Agent:
     SYSTEM_PROMPT = """\
@@ -5324,6 +5567,12 @@ TOOLS:
 - State/external: Recall retrieves tr.N outputs; Note maintains goal/plan/known/check; MCP calls configured external tools.
 - Restraint: Before calling "Question", make progress with other tools first; only ask when genuinely blocked, and batch related questions into one call.
 
+GUIDE:
+- THINK BEFORE CODING: briefly state your approach before acting; surface important assumptions, ambiguity, and tradeoffs.
+- SIMPLICITY FIRST: implement the smallest non-speculative solution.
+- SURGICAL CHANGES: touch only lines that trace to the request; clean up only your own orphans.
+- GOAL-DRIVEN EXECUTION: define success criteria and loop until verified or blocked.
+
 FLOW:
 - Act when clear; keep using tools until done, or return a final answer.
 - Batch tool calls when practical.
@@ -5452,6 +5701,7 @@ class CommandCompleter(Completer):
         "runtime.yolo",
         "runtime.max_agent_steps",
         "runtime.max_context_tokens",
+        "runtime.max_parallel_tools",
         "runtime.shell_timeout",
         "runtime.check_updates",
     )
@@ -5564,7 +5814,7 @@ class UiPrinter:
             return self.tool_segments(text)
         if text.startswith("approve ") or text.startswith("auto "):
             return self.approval_segments(text)
-        if text.startswith(("goal ->", "goal:", "plan:", "known:")):
+        if text.startswith(("goal:", "check:", "plan:", "known:")):
             return self.memory_segments(text)
         if text.startswith("+ "):
             return [("ansibrightblack", "+ "), ("ansiwhite", text[2:] + "\n")]
@@ -5603,10 +5853,16 @@ class UiPrinter:
     def memory_segments(self, text: str) -> list[tuple[str, str]]:
         segments = []
         for line in text.splitlines() or [""]:
-            if line.startswith(("goal ->", "goal:")):
+            if line.startswith(("goal:", "check:")):
                 segments.append(("ansimagenta", line))
             elif line in {"summary:", "plan:", "known:"}:
                 segments.append(("ansicyan", line))
+            elif line.lstrip().startswith("- [x]"):
+                segments.append(("ansigreen", line))
+            elif line.lstrip().startswith("- [~]"):
+                segments.append(("ansiyellow", line))
+            elif line.lstrip().startswith("- [-]"):
+                segments.append(("ansired", line))
             elif line.lstrip().startswith("+ "):
                 segments.append(("ansigreen", line))
             else:
@@ -5856,17 +6112,10 @@ class StatusBar:
         while not self.stop_event.is_set():
             self.output.write_raw("\r")
             self.output.erase_end_of_line()
-            print_formatted_text(FormattedText(self.active_fragments()), output=self.output, end="", flush=True)
+            print_formatted_text(FormattedText(self.display_fragments(active=True)), output=self.output, end="", flush=True)
             self.rendered = True
             self.stop_event.wait(self.INTERVAL)
 
-    def refresh_retry_state(self) -> None:
-        count = self.session.state.model_retry_count
-        if count == self.seen_retry_count:
-            return
-        self.seen_retry_count = count
-        self.retry_notice_until = time.monotonic() + 2.0
-
     def model_elapsed(self) -> float:
         return max(0.0, time.monotonic() - started) if (started := self.session.state.current_model_call_started_at) > 0 else 0.0
 
@@ -5877,11 +6126,13 @@ class StatusBar:
             self.output.flush()
             self.rendered = False
 
-    def idle_fragments(self) -> list[tuple[str, str]]:
-        return self.fragments(0.0, sweep=False, show_elapsed=False)
-
-    def active_fragments(self) -> list[tuple[str, str]]:
-        self.refresh_retry_state()
+    def display_fragments(self, *, active: bool) -> list[tuple[str, str]]:
+        if not active:
+            return self.fragments(0.0, sweep=False, show_elapsed=False)
+        count = self.session.state.model_retry_count
+        if count != self.seen_retry_count:
+            self.seen_retry_count = count
+            self.retry_notice_until = time.monotonic() + 2.0
         elapsed = max(0.0, time.monotonic() - self.started_at) if self.started_at else 0.0
         return self.fragments(elapsed, sweep=True, show_elapsed=True)
 
@@ -5928,7 +6179,8 @@ class StatusBar:
         if show_elapsed and self.session.pending_user_inputs:
             parts.append(("+" + str(len(self.session.pending_user_inputs)), "warn"))
         if show_elapsed:
-            parts.append((self.duration(elapsed), "runtime"))
+            minutes, rest = divmod(int(elapsed), 60)
+            parts.append((f"{elapsed:.1f}s" if elapsed < 60 else f"{minutes}m{rest:02d}s", "runtime"))
             if self.retry_notice_until > time.monotonic():
                 parts.append(("retrying", "warn"))
             elif self.model_elapsed() >= self.stress_after():
@@ -5993,16 +6245,14 @@ class StatusBar:
             return f"mcp {loaded}/{total}{spinner}"
         if status == "error":
             return "mcp err"
-        return f"mcp {len(self.session.mcp.tools)}" if status == "ready" else ""
+        if status != "ready":
+            return ""
+        # "!" flags that the tools index overflowed the cap and some tools are hidden.
+        return f"mcp {len(self.session.mcp.tools)}{'!' if self.session.mcp.index_truncated else ''}"
 
     def stress_after(self) -> float:
         return max(30.0, self.session.config.provider.timeout * 0.5)
 
-    @staticmethod
-    def duration(seconds: float) -> str:
-        minutes, rest = divmod(int(seconds), 60)
-        return f"{seconds:.1f}s" if seconds < 60 else f"{minutes}m{rest:02d}s"
-
 
 class CommandLoop:
     # Commands safe to run from the background queue-input thread while the agent works: read-only
@@ -6307,7 +6557,7 @@ Tools:
         if not self.session.resumed:
             return
         self.session.resumed = False
-        messages = [message for message in self.session.messages if self.should_render_resumed_message(message)]
+        messages = [message for message in self.session.messages if not SessionSnapshotCodec.is_internal_message(message) and message.get("role") != "tool"]
         if not messages:
             return
         self.emit(f"Restored session: {self.session.uid}")
@@ -6315,15 +6565,6 @@ Tools:
         for message in messages:
             tool_record_index = self.render_transcript_message(message, tool_record_index)
 
-    @staticmethod
-    def is_resume_marker(message: Json) -> bool:
-        return SessionSnapshotCodec.is_internal_message(message)
-
-    def should_render_resumed_message(self, message: Json) -> bool:
-        if self.is_resume_marker(message):
-            return False
-        return message.get("role") != "tool"
-
     def render_transcript_message(self, message: Json, tool_record_index: int = 0) -> int:
         role = str(message.get("role") or "")
         content = str(message.get("content") or "").strip()
@@ -6359,10 +6600,18 @@ Tools:
             return None
         arguments = function.get("arguments")
         try:
-            payload = json.loads(arguments) if isinstance(arguments, str) else (arguments or {})
+            # strict=False tolerates literal newlines in argument strings (e.g. multi-line
+            # git commit messages) that would otherwise be rejected as invalid JSON.
+            payload = json.loads(arguments, strict=False) if isinstance(arguments, str) else (arguments or {})
         except json.JSONDecodeError:
             payload = {}
-        return ToolCall(id=str(raw.get("id") or ""), name=name, args=ModelClient.tool_payload(name, payload))
+        try:
+            args = ModelClient.tool_payload(name, payload)
+        except ToolError:
+            # A malformed historical call (e.g. tool args that fail validation) must not crash
+            # the resume; render it without parsed args.
+            args = [payload] if payload else []
+        return ToolCall(id=str(raw.get("id") or ""), name=name, args=args)
 
     def transcript_tool_record(self, call: ToolCall, tool_record_index: int) -> tuple[ToolResultRecord | None, int]:
         tool_class = TOOL_REGISTRY.get(call.name)
@@ -6386,6 +6635,11 @@ Tools:
         notice = self.mcp_error_notice()
         if notice:
             self.emit(notice)
+        # render once so index_truncated reflects the freshly discovered tools, then warn if
+        # 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.")
 
     def mcp_error_notice(self) -> str:
         errors = [
@@ -6426,7 +6680,7 @@ Tools:
 
     def status_window(self, *, active: bool = False) -> Window:
         return Window(
-            FormattedTextControl(self.status_bar.active_fragments if active else self.status_bar.idle_fragments, style="class:bottom-toolbar.text"),
+            FormattedTextControl(lambda: self.status_bar.display_fragments(active=active), style="class:bottom-toolbar.text"),
             style="class:bottom-toolbar",
             height=1,
             dont_extend_height=True,
@@ -7003,16 +7257,6 @@ Tools:
             self.emit(result + "\n")
         return result
 
-    def select_model(self, choices: tuple[str, ...]) -> str | object | None:
-        current = self.session.config.provider.model
-        labels = {label: label for label in self.MODEL_LABELS if label in choices}
-        labels.update({current: current + " (current)"} if current in choices else {})
-        return self.select_choice("Model", choices, labels=labels, current=current, disabled=self.MODEL_LABELS)
-
-    def select_provider(self, choices: tuple[str, ...]) -> str | object | None:
-        current = self.session.config.active_provider
-        return self.select_choice("Provider", choices, labels={current: current + " (current)"}, current=current)
-
     def select_reasoning(self) -> str | object | None:
         current = self.session.config.provider.reasoning
         labels = {"off": "off - disable reasoning"}
@@ -7072,7 +7316,7 @@ 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:", *state.plan_rows(status=True), "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:
@@ -7097,6 +7341,7 @@ Tools:
                 f"runtime.shell_timeout: {self.session.settings.shell_timeout}",
                 f"runtime.max_agent_steps: {self.session.settings.max_steps}",
                 f"runtime.max_context_tokens: {self.session.settings.max_context_tokens}",
+                f"runtime.max_parallel_tools: {self.session.settings.max_parallel_tools}",
                 f"runtime.check_updates: {'on' if self.session.settings.check_updates else 'off'}",
                 f"runtime.update_check_interval_hours: {self.session.settings.update_check_interval_hours}",
                 f"runtime.session_retention_days: {self.session.settings.session_retention_days}",
@@ -7181,13 +7426,12 @@ Tools:
         if parts:
             return self.set_provider(parts[0])
         choices = tuple(sorted(self.session.config.providers))
+        summary = "provider: " + self.session.config.active_provider + "\nproviders: " + ", ".join(choices)
         if len(choices) <= 1:
-            return self.provider_summary()
-        choice = self.select_provider(choices)
-        return self.set_provider(choice) if isinstance(choice, str) else ("No change" if choice is SELECTION_BACK else self.provider_summary())
-
-    def provider_summary(self) -> str:
-        return "provider: " + self.session.config.active_provider + "\nproviders: " + ", ".join(sorted(self.session.config.providers))
+            return summary
+        current = self.session.config.active_provider
+        choice = self.select_choice("Provider", choices, labels={current: current + " (current)"}, current=current)
+        return self.set_provider(choice) if isinstance(choice, str) else ("No change" if choice is SELECTION_BACK else summary)
 
     def set_provider(self, name: str) -> str:
         if name not in self.session.config.providers:
@@ -7202,11 +7446,22 @@ Tools:
         if parts:
             result = self.set_model(parts[0])
             return "No change" if result is SELECTION_BACK else str(result)
-        choices = self.model_choices()
+        provider = self.session.config.provider
+        configured = tuple(dict.fromkeys(provider.available_models))
+        remote = tuple(model for model in self.remote_models(provider) if model not in configured)
+        choices: list[str] = []
+        if configured:
+            choices.extend((self.MODEL_CONFIGURED_LABEL, *configured))
+        if remote:
+            choices.extend((self.MODEL_DISCOVERED_LABEL, *remote))
+        choices = tuple(choices)
         if not choices:
             return "Current provider.model is " + (self.session.config.provider.model or "(empty)")
         while True:
-            choice = self.select_model(choices)
+            current = self.session.config.provider.model
+            labels = {label: label for label in self.MODEL_LABELS if label in choices}
+            labels.update({current: current + " (current)"} if current in choices else {})
+            choice = self.select_choice("Model", choices, labels=labels, current=current, disabled=self.MODEL_LABELS)
             if choice is SELECTION_BACK:
                 return "No change"
             if not isinstance(choice, str):
@@ -7218,17 +7473,6 @@ Tools:
                 continue
             return str(result)
 
-    def model_choices(self) -> tuple[str, ...]:
-        provider = self.session.config.provider
-        configured = tuple(dict.fromkeys(provider.available_models))
-        remote = tuple(model for model in self.remote_models(provider) if model not in configured)
-        choices: list[str] = []
-        if configured:
-            choices.extend((self.MODEL_CONFIGURED_LABEL, *configured))
-        if remote:
-            choices.extend((self.MODEL_DISCOVERED_LABEL, *remote))
-        return tuple(choices)
-
     def remote_models(self, provider: ProviderConfig) -> tuple[str, ...]:
         if not provider.url or not provider.key:
             return ()
@@ -7308,6 +7552,8 @@ Tools:
                 runtime.max_context_tokens = max(1, int(value))
             elif key == "runtime.shell_timeout":
                 runtime.shell_timeout = max(1, int(value))
+            elif key == "runtime.max_parallel_tools":
+                runtime.max_parallel_tools = max(1, int(value))
             else:
                 return "Unknown config key: " + key
         except (ConfigError, ValueError):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nanocode-cli
-Version: 0.6.6
+Version: 0.7.0
 Summary: A small terminal coding agent written in Python
 Author-email: hit9 <hit9@icloud.com>
 License-Expression: BSD-3-Clause
@@ -22,13 +22,14 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: anthropic>=0.64.0
-Requires-Dist: code-symbol-index>=0.3.0
+Requires-Dist: code-symbol-index>=0.3.1
 Requires-Dist: json-repair
-Requires-Dist: fastmcp<4,>=3
+Requires-Dist: fastmcp-slim[client]<4,>=3
 Requires-Dist: openai>=2.37.0
 Requires-Dist: prompt-toolkit>=3.0
 Requires-Dist: rich>=13.0
 Requires-Dist: socksio>=1.0.0
+Requires-Dist: websockets>=15.0.1
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: ruff>=0.4.0; extra == "dev"

{nanocode_cli-0.6.6 → nanocode_cli-0.7.0}/nanocode_cli.egg-info/requires.txt

@@ -1,11 +1,12 @@
 anthropic>=0.64.0
-code-symbol-index>=0.3.0
+code-symbol-index>=0.3.1
 json-repair
-fastmcp<4,>=3
+fastmcp-slim[client]<4,>=3
 openai>=2.37.0
 prompt-toolkit>=3.0
 rich>=13.0
 socksio>=1.0.0
+websockets>=15.0.1
 
 [dev]
 pytest>=8.0

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "nanocode-cli"
-version = "0.6.6"
+version = "0.7.0"
 description = "A small terminal coding agent written in Python"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -28,13 +28,14 @@ classifiers = [
 ]
 dependencies = [
     "anthropic>=0.64.0",
-    "code-symbol-index>=0.3.0",
+    "code-symbol-index>=0.3.1",
     "json-repair",
-    "fastmcp>=3,<4",
+    "fastmcp-slim[client]>=3,<4",
     "openai>=2.37.0",
     "prompt-toolkit>=3.0",
     "rich>=13.0",
     "socksio>=1.0.0",
+    "websockets>=15.0.1",
 ]
 
 [project.urls]