@oneciel-ai/claude-any 0.1.63 → 0.1.65

package/README.md

@@ -23,11 +23,19 @@
 >
 > Provider, model, base URL, API key, streaming behavior, and LLM options are all selected from a console menu **before** Claude Code starts. Claude Code itself runs untouched with all of its native tooling, slash commands, and workflows.
 
-## Today's Top 3 Benefits
-
-1. **Plan Mode works on non-Anthropic models** — Claude Any keeps Claude Code's Plan Mode usable even when the upstream provider is NVIDIA hosted, Ollama Cloud, local Ollama, vLLM, or NIM.
-2. **Advisor review with a bigger model** — pick a long-context Advisor Model at launch, then use `/advisor` inside Claude Code to review the current task, blockers, and next concrete action.
-3. **Free-model RPM limits feel smoother** — router-side RPM pacing uses the natural time spent reading files and running tools, so NVIDIA hosted free models can stay within per-minute limits with less visible waiting.
+## Today's Top 3 Benefits
+
+### 2026-05-14
+
+1. **Plan Mode loop recovery is semantic, not hard-coded** — unchanged `Read` results are now converted with the previous authoritative observation and current Plan Mode state, so Claude Code can move to `ExitPlanMode` or the next real step instead of rereading the same slice.
+2. **Remote test router mode is easier to expose** — set `CLAUDE_ANY_ROUTER_BIND_HOST=0.0.0.0` when you intentionally want to test the router from another machine, while Claude Code still talks to the safe local client base.
+3. **Cleaner router transcripts for third-party models** — attachment-only metadata, historical no-op tool results, and orphan tool results are normalized before reaching Ollama, Ollama Cloud, NVIDIA hosted, vLLM, or NIM.
+
+### 2026-05-13
+
+1. **Plan Mode works on non-Anthropic models** — Claude Any keeps Claude Code's Plan Mode usable even when the upstream provider is NVIDIA hosted, Ollama Cloud, local Ollama, vLLM, or NIM.
+2. **Advisor review with a bigger model** — pick a long-context Advisor Model at launch, then use `/advisor` inside Claude Code to review the current task, blockers, and next concrete action.
+3. **Free-model RPM limits feel smoother** — router-side RPM pacing uses the natural time spent reading files and running tools, so NVIDIA hosted free models can stay within per-minute limits with less visible waiting.
 
 ### Demo
 
@@ -48,7 +56,7 @@ arguments through unchanged.
 
 Credits: One Ciel LLC
 
-Current version: `0.1.63`
+Current version: `0.1.65`
 
 ## Why This Exists
 
@@ -130,7 +138,7 @@ CLAUDE_ANY_SKIP_MENU=1 claude-any -p "Summarize this repository." --output-forma
 Configure every launch option with flags:
 
 ```sh
-claude-any --ca-provider nvidia-hosted --ca-base-url https://integrate.api.nvidia.com/v1 --ca-model z-ai/glm-4.7 --ca-advisor-model deepseek-ai/deepseek-v4-pro --ca-api-key-env NVIDIA_API_KEY --ca-max-output-tokens 4096 --ca-context-window 65536 --ca-request-timeout-ms 300000 --ca-rate-limit-rpm 40 --ca-rate-limit-status on --ca-no-update-check -p "Reply with OK only." --output-format text
+claude-any --ca-provider nvidia-hosted --ca-base-url https://integrate.api.nvidia.com/v1 --ca-model z-ai/glm-4.7 --ca-advisor-model deepseek-ai/deepseek-v4-pro --ca-api-key-env NVIDIA_API_KEY --ca-max-output-tokens 4096 --ca-context-window 65536 --ca-request-timeout-ms 120000 --ca-rate-limit-rpm 40 --ca-rate-limit-status on --ca-no-update-check -p "Reply with OK only." --output-format text
 ```
 
 Or put the same values in environment variables:
@@ -144,7 +152,7 @@ export CLAUDE_ANY_ADVISOR_MODEL=deepseek-ai/deepseek-v4-pro
 export CLAUDE_ANY_API_KEY_ENV=NVIDIA_API_KEY
 export CLAUDE_ANY_MAX_OUTPUT_TOKENS=4096
 export CLAUDE_ANY_CONTEXT_WINDOW=65536
-export CLAUDE_ANY_REQUEST_TIMEOUT_MS=300000
+export CLAUDE_ANY_REQUEST_TIMEOUT_MS=120000
 export CLAUDE_ANY_RATE_LIMIT_RPM=40
 export CLAUDE_ANY_RATE_LIMIT_STATUS=on
 claude-any -p "Reply with OK only." --output-format text
@@ -385,6 +393,28 @@ steps under that larger model's supervision.
 
 ## Changelog
 
+### 0.1.65
+
+- **Plan Mode unchanged-Read loop recovery**: router conversion now preserves the
+  previous successful `Read` result for unchanged/no-op reads, exposes the
+  current Plan Mode state to third-party models, and avoids arbitrary retry
+  thresholds.
+- **Cleaner third-party transcripts**: attachment-only metadata, historical
+  no-op tool results, and orphan tool results are normalized before reaching
+  Ollama, Ollama Cloud, NVIDIA hosted, vLLM, or NIM.
+- **Remote router test binding**: `CLAUDE_ANY_ROUTER_BIND_HOST=0.0.0.0` can be
+  used for intentional remote testing while Claude Code keeps using the local
+  client base URL.
+
+### 0.1.64
+
+- **Model-aware native auto-compact**: claude-any now injects
+  `CLAUDE_CODE_AUTO_COMPACT_WINDOW` at launch using the selected provider/model
+  context window, including the cached Ollama/Ollama Cloud model catalog. Smaller
+  custom models now let Claude Code's native auto-compact trigger against their
+  real context budget instead of falling back to Claude Code's generic 200K
+  assumption.
+
 ### 0.1.63
 
 - **Plan Mode stop guard**: when a non-Anthropic model is already in Plan Mode
@@ -420,7 +450,7 @@ steps under that larger model's supervision.
 
 - **Dynamic timeout help**: the LLM options panel now describes
   `request_timeout_ms` using the currently selected value instead of always
-  showing the old `300000 ms = 5 minutes` example.
+  showing a hard-coded timeout example.
 
 ### 0.1.49
 
@@ -549,8 +579,7 @@ steps under that larger model's supervision.
 
 ### 0.1.31
 
-- **5-minute default upstream timeout**: existing saved 10/30-minute defaults
-  are migrated to 300000 ms so gateway stalls fail faster.
+- **2-minute default upstream timeout**: existing saved longer bundled defaults are migrated to 120000 ms so gateway stalls fail faster.
 - **Localized gateway retries**: 502/503/504 and socket timeout responses are
   retried automatically, with retry progress shown in the selected UI language.
 

package/claude-any-tool-guard.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 import json
 import os
 import re
-import hashlib
 import sys
 import time
 from pathlib import Path
@@ -13,6 +12,42 @@ from typing import Any
 
 NON_NATIVE_PROVIDERS = {"ollama", "ollama-cloud", "vllm", "nvidia-hosted", "self-hosted-nim"}
 TASK_STATUS = {"pending", "in_progress", "completed", "deleted"}
+TASK_STATUS_ALIASES = {
+    "active": "in_progress",
+    "assigned": "in_progress",
+    "current": "in_progress",
+    "doing": "in_progress",
+    "inprogress": "in_progress",
+    "in_progress": "in_progress",
+    "in-progress": "in_progress",
+    "in progress": "in_progress",
+    "ongoing": "in_progress",
+    "processing": "in_progress",
+    "running": "in_progress",
+    "started": "in_progress",
+    "working": "in_progress",
+    "complete": "completed",
+    "completed": "completed",
+    "done": "completed",
+    "finished": "completed",
+    "resolved": "completed",
+    "success": "completed",
+    "closed": "completed",
+    "open": "pending",
+    "pending": "pending",
+    "queued": "pending",
+    "todo": "pending",
+    "to_do": "pending",
+    "to-do": "pending",
+    "waiting": "pending",
+    "cancel": "deleted",
+    "cancelled": "deleted",
+    "canceled": "deleted",
+    "delete": "deleted",
+    "deleted": "deleted",
+    "remove": "deleted",
+    "removed": "deleted",
+}
 DESCRIPTION_OK = {"Bash", "TaskCreate", "TaskUpdate"}
 DROP_DESCRIPTION = {"Read", "Write", "Edit", "MultiEdit", "Glob", "Grep", "LS"}
 BASH_KEYS = {"command", "description", "timeout", "run_in_background"}
@@ -24,7 +59,17 @@ GLOB_KEYS = {"pattern", "path"}
 GREP_KEYS = {"pattern", "path", "glob", "type", "output_mode", "-A", "-B", "-C", "head_limit", "multiline"}
 LS_KEYS = {"path", "ignore"}
 TASKLIST_KEYS: set[str] = set()
-TASKUPDATE_KEYS = {"taskId", "status"}
+TASKUPDATE_KEYS = {
+    "taskId",
+    "subject",
+    "description",
+    "activeForm",
+    "status",
+    "addBlocks",
+    "addBlockedBy",
+    "owner",
+    "metadata",
+}
 STRICT_KEYS = {
     "Bash": BASH_KEYS,
     "Read": READ_KEYS,
@@ -45,7 +90,7 @@ REQUIRED_KEYS = {
     "MultiEdit": {"file_path", "edits"},
     "Glob": {"pattern"},
     "Grep": {"pattern"},
-    "TaskUpdate": {"taskId", "status"},
+    "TaskUpdate": {"taskId"},
 }
 TOOL_HINTS = {
     "Bash": "Use Bash with command, description, timeout, and run_in_background only.",
@@ -55,7 +100,7 @@ TOOL_HINTS = {
     "MultiEdit": "Use MultiEdit with file_path and edits only.",
     "Glob": "Use Glob with pattern and optional path only.",
     "Grep": "Use Grep with pattern, path, glob, type, output_mode, context, head_limit, or multiline only.",
-    "TaskUpdate": "Use TaskUpdate with taskId and status.",
+    "TaskUpdate": "Use TaskUpdate with taskId and optional status pending, in_progress, completed, or deleted.",
 }
 PLAN_GUARD_MARKER = "[claude-any-plan-guard]"
 
@@ -421,37 +466,6 @@ def should_block_plan_stop(transcript_path: str | None) -> tuple[bool, str]:
     return True, reason
 
 
-def stop_block_count_path(session_id: str) -> Path:
-    return cache_dir() / f"stop-block-{session_id or 'unknown'}.json"
-
-
-def increment_stop_block_count(session_id: str | None, text: str) -> int:
-    path = stop_block_count_path(session_id or "unknown")
-    key = hashlib.sha256(text.strip().encode("utf-8", errors="ignore")).hexdigest()[:16]
-    try:
-        data = json.loads(path.read_text(encoding="utf-8")) if path.exists() else {}
-        if not isinstance(data, dict):
-            data = {}
-    except Exception:
-        data = {}
-    count = int(data.get(key) or 0) + 1
-    data[key] = count
-    tmp = path.with_suffix(".tmp")
-    tmp.write_text(json.dumps(data, ensure_ascii=False) + "\n", encoding="utf-8")
-    tmp.replace(path)
-    return count
-
-
-def reset_stop_block_count(session_id: str | None) -> None:
-    if not session_id:
-        return
-    path = stop_block_count_path(session_id)
-    try:
-        path.unlink(missing_ok=True)
-    except Exception:
-        pass
-
-
 def handle_stop(event: dict[str, Any]) -> int:
     log_json_event(event)
     if str(event.get("hook_event_name") or "") == "SubagentStop":
@@ -462,14 +476,11 @@ def handle_stop(event: dict[str, Any]) -> int:
     if active():
         should_block, reason = should_block_plan_stop(transcript_path)
         if should_block:
-            count = increment_stop_block_count(session_id, reason)
-            if count <= 3:
-                out = {"decision": "block", "reason": reason, "suppressOutput": True}
-                log_json_event(event, out)
-                log_event(f"Stop guard blocked plan idle session={session_id} count={count} transcript={transcript_path}")
-                emit(out)
-                return 0
-            log_event(f"Stop guard allowed repeated plan idle session={session_id} count={count} transcript={transcript_path}")
+            out = {"decision": "block", "reason": reason, "suppressOutput": True}
+            log_json_event(event, out)
+            log_event(f"Stop guard blocked plan idle session={session_id} transcript={transcript_path}")
+            emit(out)
+            return 0
     log_event(f"Stop guard observed session={session_id}")
     return 0
 
@@ -478,12 +489,19 @@ def normalize_aliases(tool: str, tool_input: dict[str, Any]) -> tuple[dict[str,
     updated = dict(tool_input)
     changed: list[str] = []
 
+    def present(value: Any) -> bool:
+        if value is None:
+            return False
+        if isinstance(value, str):
+            return bool(value.strip())
+        return True
+
     def alias(target: str, *names: str) -> None:
-        if target in updated:
+        if present(updated.get(target)):
             return
         for name in names:
             value = updated.get(name)
-            if value not in (None, ""):
+            if present(value):
                 updated[target] = value
                 changed.append(f"{name}->{target}")
                 return
@@ -500,9 +518,36 @@ def normalize_aliases(tool: str, tool_input: dict[str, Any]) -> tuple[dict[str,
         alias("path", "file_path", "directory")
     elif tool == "TaskUpdate":
         alias("taskId", "task_id", "id")
+        status = normalize_task_status(updated.get("status"))
+        if status and updated.get("status") != status:
+            before = updated.get("status")
+            updated["status"] = status
+            changed.append(f"status:{before}->{status}")
+        for key in ("addBlocks", "addBlockedBy"):
+            value = updated.get(key)
+            if isinstance(value, str) and value.strip():
+                updated[key] = [value.strip()]
+                changed.append(f"{key}:string->array")
+        metadata = updated.get("metadata")
+        if metadata is not None and not isinstance(metadata, dict):
+            updated.pop("metadata", None)
+            changed.append("metadata dropped")
     return updated, changed
 
 
+def normalize_task_status(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    normalized = re.sub(r"[\s\-]+", "_", text.lower())
+    normalized = re.sub(r"[^a-z0-9_]", "", normalized)
+    if normalized in TASK_STATUS:
+        return normalized
+    return TASK_STATUS_ALIASES.get(text.lower()) or TASK_STATUS_ALIASES.get(normalized)
+
+
 def missing_required_keys(tool: str, tool_input: dict[str, Any]) -> list[str]:
     required = REQUIRED_KEYS.get(tool, set())
     missing: list[str] = []
@@ -533,7 +578,6 @@ def handle_pre_tool(event: dict[str, Any]) -> None:
     if tool.startswith("mcp__"):
         return
     log_json_event(event)
-    reset_stop_block_count(str(event.get("session_id") or ""))
     raw = event.get("tool_input")
     if not isinstance(raw, dict):
         pre_deny(
@@ -561,9 +605,11 @@ def handle_pre_tool(event: dict[str, Any]) -> None:
                 )
                 return
 
+    updated, dropped, changed = strip_unknown_keys(tool, raw)
+
     if tool == "TaskUpdate":
-        task_id = raw.get("taskId")
-        status = raw.get("status")
+        task_id = updated.get("taskId")
+        status = updated.get("status")
         if not isinstance(task_id, str) or not task_id.strip():
             tasks = known_tasks(str(event.get("session_id") or ""))
             known = ", ".join(f"{tid} ({info.get('subject')})" for tid, info in sorted(tasks.items())[:8] if isinstance(info, dict))
@@ -572,14 +618,13 @@ def handle_pre_tool(event: dict[str, Any]) -> None:
                 context += f" Known task ids for this session: {known}."
             pre_deny("TaskUpdate requires parameter taskId.", context)
             return
-        if not isinstance(status, str) or status not in TASK_STATUS:
+        if status is not None and (not isinstance(status, str) or status not in TASK_STATUS):
             pre_deny(
                 "TaskUpdate status must be one of pending, in_progress, completed, or deleted.",
                 "Regenerate TaskUpdate with a valid status enum and preserve the taskId.",
             )
             return
 
-    updated, dropped, changed = strip_unknown_keys(tool, raw)
     missing = missing_required_keys(tool, updated)
     if missing:
         log_event(f"PreToolUse denied tool={tool} missing={missing} keys={list(raw.keys())}")
@@ -593,7 +638,7 @@ def handle_pre_tool(event: dict[str, Any]) -> None:
         if dropped:
             reason_parts.append(f"removed unsupported parameter(s): {', '.join(dropped)}")
         if changed:
-            reason_parts.append(f"normalized parameter name(s): {', '.join(changed)}")
+            reason_parts.append(f"normalized parameter/value(s): {', '.join(changed)}")
         reason = "; ".join(reason_parts)
         log_event(f"PreToolUse sanitized tool={tool} dropped={dropped} changed={changed} keys={list(raw.keys())}")
         pre_allow(