hexcli 2.10.0__tar.gz → 2.11.1__tar.gz

{hexcli-2.10.0 → hexcli-2.11.1}/.gitignore

@@ -60,3 +60,4 @@ dist/
 # Local-only notes: research surveys and working documents that are not user-facing.
 # Only the paper (docs/paper) and user-facing docs are committed (owner rule, 2026-09-14).
 docs/local/
+tools/local/

{hexcli-2.10.0 → hexcli-2.11.1}/CHANGELOG.md

@@ -6,6 +6,68 @@ the Hexagon NPU, not single-run anecdotes.
 
 ## Unreleased
 
+## 2.11.1 — 2026-09-14
+
+A patch release: nothing model-facing and nothing the launcher hands the
+server; code and documents nobody used are gone. Gate: every remaining
+suite green (27 suites, 739 tests; 29 suites and 798 tests before), smoke on a fresh server
+9/10 then 10/10 (the miss was factual-1, a no-tool knowledge answer that
+missed once in every arm today), CI green on main and the tag.
+
+- The prune. Nothing here was used: protocol v2 (`loop_v2.py`,
+  `shell_session.py`, the v2 parser and prompt in `protocol_v2.py`, its
+  suite, the `protocol` config key), which lost its A/B at 13/36 vs 22/35
+  and doubled every safety and file-tool change; the local escalation
+  ladder (no viable bigger model on this hardware) and the cloud
+  escalation path (never configured), with their six config keys, so "no
+  code leaves the machine" is now structural rather than a default; the
+  memory dreaming daemon, off since it fabricated hardware facts; the
+  unused brace scanner in the parser; the root `shellai.py` / `shellai.cmd`
+  shims. The SEARCH/REPLACE applier that `edit_file` uses moved out of
+  `protocol_v2.py` into `hexcli/editing.py` unchanged, with its tests in
+  `evals/test_editing.py`. Internal documents (the V2 plan and roadmap, the
+  levers memo, the backend study, ARCHITECTURE.md) and the study-only bench
+  probes are no longer tracked; they live in git-ignored `docs/local/` and
+  `tools/local/` (owner rule: only the paper and user-facing docs are
+  committed). `tools/backend_bench/` keeps `stall_rate.py` and its two
+  imports, which the release gate runs. About 3,300 lines and three suites
+  gone; every remaining suite green.
+
+## 2.11.0 — 2026-09-14
+
+A minor release: tool result text the model reads changed (`verify_syntax`
+reports its rung) and a new nudge was added. Gate: extended suite at 5 runs, seed 20260914, gate PASS after a 6-run recheck (five cases missed once, all 5/6 or better on recheck; run-level 156/205 vs 165/208, p=0.48); multi-turn at 3 runs on a fresh server with 0 invalid runs, no 3/3 case lost, uc3-t7 gained (38/48 vs 33/44, p=0.80); smoke 10/10; stall probe clean; CI green on main and the tag.
+
+- Claims need evidence. A finish that says it ran something, that it
+  works, that the buttons respond or that the tests pass, needs a run this
+  turn (run_code or run_command); reading the file back proves the bytes,
+  not the behaviour. The owner's 2026-09-13 calculator session made three
+  such claims after read_file, with nothing ever run and nothing wired.
+  One nudge names the claim and asks for a run or a plain statement that
+  it was not run; a second unbacked claim goes out with a dim "Nothing was
+  run this turn." under it. The tests-claim nudge is the same rule for one
+  phrase; this is the class.
+- `verify_syntax` is a ladder that reports the rung it reached. A page is
+  parsed and cross-referenced: handlers the markup calls must be functions
+  a script defines, ids the scripts look up must be elements the markup
+  has, buttons must be wired to something, and a script after `</body>` is
+  noted (the calculator: no handler on any button, an id no element had, a
+  function nothing called). Python is parsed and cross-referenced for
+  names it reads but never binds (a star import turns that off). JSON and
+  PowerShell say "parsed". A file with no checker is `NOT CHECKED`, never
+  `OK: skipped`, and says so, so the claim above cannot rest on it.
+- Two eval cases: `claims-1`, the calculator prompt graded on the page
+  being wired and the finish not claiming a run that never happened, and
+  `claims-2`, a Python edit-and-claim variant. The 2026-09-13 page is a
+  fixture.
+- The eval runner waits for the inference slot after a client timeout.
+  An abandoned request keeps the server's one slot until it finishes; the
+  next run queued behind it, timed out too, and took a whole scenario
+  down as invalid (uc3, 2026-09-13, twice). After a timed-out run the
+  runner probes until the backend answers again, up to ten minutes, and
+  the timeout no longer counts toward the abort streak once the slot is
+  back.
+
 ## 2.10.0 — 2026-09-14
 
 A minor release: the retry feedback the model reads changed. Gate: extended

{hexcli-2.10.0 → hexcli-2.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.10.0
+Version: 2.11.1
 Summary: Local Hexagon NPU terminal agent for Snapdragon X Elite Windows ARM64
 Project-URL: Homepage, https://github.com/NathanL15/Hex-CLI
 Project-URL: Repository, https://github.com/NathanL15/Hex-CLI
@@ -353,7 +353,7 @@ Restart the NPU server before each suite. After an hour or two of steady
 use it starts returning errors for everything, which looks like a model
 regression. The runner detects this and marks those runs invalid.
 
-`ARCHITECTURE.md` describes the module layout. `docs/V2_PLAN.md` has the
+`CLAUDE.md` describes the module layout. The paper in `docs/paper/` has the
 hardware measurements, the eval method, and the reasoning behind each
 safety layer. `RELEASING.md` covers how a release is cut.
 

{hexcli-2.10.0 → hexcli-2.11.1}/README.md

@@ -326,7 +326,7 @@ Restart the NPU server before each suite. After an hour or two of steady
 use it starts returning errors for everything, which looks like a model
 regression. The runner detects this and marks those runs invalid.
 
-`ARCHITECTURE.md` describes the module layout. `docs/V2_PLAN.md` has the
+`CLAUDE.md` describes the module layout. The paper in `docs/paper/` has the
 hardware measurements, the eval method, and the reasoning behind each
 safety layer. `RELEASING.md` covers how a release is cut.
 

{hexcli-2.10.0 → hexcli-2.11.1}/hexcli/__init__.py

@@ -3,4 +3,4 @@
 # The one place the version is written. pyproject.toml reads it (hatch
 # dynamic version), agent.VERSION re-exports it, and CI refuses a release
 # tag that does not match it.
-__version__ = "2.10.0"
+__version__ = "2.11.1"

{hexcli-2.10.0 → hexcli-2.11.1}/hexcli/agent.py

@@ -28,10 +28,8 @@ from hexcli import (
     compaction,
     diffview,
     distribution,
-    escalate,
     http_client,
     llm,
-    local_escalation,
     lockfile,
     memory,
     network,
@@ -381,7 +379,6 @@ is_small_talk = parsing.is_small_talk
 local_meta_response = parsing.local_meta_response
 strip_thinking = parsing.strip_thinking
 parse_json_object = parsing.parse_json_object
-_iter_json_objects = parsing._iter_json_objects
 parse_agent_action = parsing.parse_agent_action
 _looks_like_botched_action = parsing._looks_like_botched_action
 
@@ -444,23 +441,6 @@ def set_active_config(config: dict[str, Any] | None) -> None:
 
 
 
-# One escalation server per (model, bind) for the process lifetime — spawning
-# a fresh 4.6 GB bundle load per consult would make escalation useless.
-_ESCALATORS: dict[str, local_escalation.LocalEscalator] = {}
-
-
-def _get_escalator(config: dict[str, Any]) -> local_escalation.LocalEscalator | None:
-    model = str(config.get("escalation_local_model", "") or "")
-    if not model:
-        return None
-    key = f"{model}@{config.get('escalation_local_bind', '127.0.0.1:11436')}"
-    esc = _ESCALATORS.get(key)
-    if esc is None:
-        esc = local_escalation.LocalEscalator(config)
-        _ESCALATORS[key] = esc
-    return esc if esc.enabled else None
-
-
 class AutopilotProbe:
     """Optional instrumentation hook for run_autopilot, used by evals/ to
     observe the production agent loop without reimplementing it. Every
@@ -1120,14 +1100,6 @@ def _run_autopilot_turn(
 
     _sync_context_window(config)
 
-    if str(config.get("protocol", "v1")).lower() == "v2":
-        from . import loop_v2
-        _CURRENT_SESSION_ID = str(uuid4())
-        return loop_v2.run(
-            config, history, query, shell_exe,
-            session=session, turn=turn, probe=probe,
-        )
-
     # Fresh UUID for this agent loop: lets the npurun server detect
     # continuation turns (messages only appended) and skip reset_dialog(),
     # so Genie re-prefills only the new tokens via SentenceCode::Rewind.
@@ -1193,6 +1165,9 @@ def _run_autopilot_turn(
     _tests_requested = _asks_to_run_tests(query)
     _tests_nudge_used = False
     _run_targets: list[str] = []
+    _ran_anything = False          # any run_code / run_command this turn: the evidence a behaviour claim needs
+    _claim_nudge_used = False
+    _unbacked_claim = False
     # The last test run's failure output (None once a run passes), so a
     # finish right after a failing run can be sent back once more.
     _last_test_failure: str | None = None
@@ -1200,33 +1175,6 @@ def _run_autopilot_turn(
     # Local escalation (docs/V2_PLAN.md §4 ladder): consult the bigger local
     # model at hard moments. At most one consult per turn; every failure path
     # degrades to the pre-escalation behaviour.
-    _escalator = _get_escalator(config)
-    _escalation_used = False
-    _turn_events: list[str] = []
-
-    def _consult_and_inject(problem: str, raw_response: str) -> bool:
-        """Ask the local escalation model for advice and inject it as the next
-        user message. Returns True when advice was injected."""
-        nonlocal _escalation_used
-        if _escalator is None or _escalation_used:
-            return False
-        cprint("\n  Consulting the escalation model.", C.DIM, file=sys.stderr)
-        advice = _escalator.consult(
-            local_escalation.build_situation(query, _turn_events, problem))
-        if not advice:
-            return False
-        _escalation_used = True
-        if raw_response:
-            messages.append({"role": "assistant", "content": strip_thinking(raw_response)})
-        messages.append({
-            "role": "user",
-            "content": (
-                "A senior engineer reviewed the situation and advises:\n"
-                f"{advice}\n"
-                "Apply this advice now using the tools. Respond with JSON only."
-            ),
-        })
-        return True
 
     for step in range(max_steps):
         step_label = "thinking" if step == 0 else f"step {step + 1}/{max_steps}"
@@ -1338,25 +1286,21 @@ def _run_autopilot_turn(
                 messages.append({"role": "assistant", "content": strip_thinking(raw)})
                 messages.append({"role": "user", "content": _retest_nudge_text(_last_test_failure)})
                 continue
-            # Escalation trigger B — the verification nudge was ignored: the
-            # model finished a second time without checking its own mutation.
-            if (_unverified_mutation and _verify_nudge_used
-                    and config.get("require_verification", True)
-                    and _consult_and_inject(
-                        "The agent modified a file but is finishing WITHOUT verifying "
-                        "the change, even after being asked to verify.", raw)):
-                continue
-            # Escalation trigger C — prose instead of action: the task asks
-            # for a file change, nothing was mutated, and the finish is not a
-            # clarifying question (questions are the CORRECT outcome for
-            # ambiguous requests — never escalate those).
-            if (local_escalation.looks_like_edit_request(query)
-                    and not local_escalation.turn_mutated(tools_used)
-                    and not msg.rstrip().endswith("?")
-                    and _consult_and_inject(
-                        "The task asks for a file change, but the agent is finishing "
-                        f"without having modified any file. Its answer was: {msg[:300]}", raw)):
-                continue
+            # Claims need evidence. "Ran it successfully", "the buttons now
+            # respond", "tests pass": a behaviour claim in the finish needs
+            # a run this turn; reading a file back proves the bytes, not the
+            # behaviour (the calculator session, 2026-09-13: three such
+            # claims, nothing ever run, nothing wired). One nudge: run it, or
+            # say plainly that it was not run. A second unbacked claim goes
+            # out with a one-line notice under it, so the user knows.
+            claim = _behaviour_claim(msg)
+            if (claim and not _ran_anything and config.get("require_verification", True)):
+                if not _claim_nudge_used:
+                    _claim_nudge_used = True
+                    messages.append({"role": "assistant", "content": strip_thinking(raw)})
+                    messages.append({"role": "user", "content": _claim_nudge_text(claim)})
+                    continue
+                _unbacked_claim = True
             # Nudge once if the model refused to use tools
             if (step == 0 and not direct_stage
                     and any(phrase in msg.lower() for phrase in REFUSAL_PHRASES)):
@@ -1367,6 +1311,8 @@ def _run_autopilot_turn(
                 })
                 continue
             result = msg or last_tool_output or "Done."
+            if _unbacked_claim:
+                ui.cprint("  Nothing was run this turn.", C.DIM)
             memory.maybe_index_turn(config, query, tools_used, touched_paths, outcome="completed")
             if session:
                 _record_undo_snapshots(session, _turn_snapshots)
@@ -1398,6 +1344,7 @@ def _run_autopilot_turn(
             touched_paths.append(str(tool_path))
         if tool_name in ("run_code", "run_command") and isinstance(action.get("args"), dict):
             _run_targets.append(str(action["args"].get("path") or action["args"].get("command") or ""))
+            _ran_anything = True
 
         # Capture file state before first mutation so /undo can restore it.
         if tool_name in {"edit_file", "write_file", "append_file"} and tool_path:
@@ -1458,7 +1405,6 @@ def _run_autopilot_turn(
                 pass
 
         last_tool_output = tool_output
-        _turn_events.append(f"{tool_name}: {tool_output[:220]}")
         if _run_targets and tool_name in ("run_code", "run_command") and _ran_tests(_run_targets[-1:]):
             _last_test_failure = _test_failure_tail(tool_output)
         _is_error = tool_output.lstrip().startswith("Error:")
@@ -1483,28 +1429,10 @@ def _run_autopilot_turn(
                          and all(err for _t, _tgt, err, _out in _loop_tracker)
                          and len({(t, tgt) for t, tgt, _e, _out in _loop_tracker}) == 1)
         if _identical_trip or _failure_trip:
-            # Escalation trigger A — the loop detector: consult the local
-            # model BEFORE giving up (the cloud path stays as the fallback).
-            if _consult_and_inject(
-                    f"The agent repeated the same failing call 3 times: {tool_name} "
-                    f"kept returning:\n{tool_output[:400]}", raw):
-                _loop_tracker.clear()
-                continue
             what = f"{tool_name} returned the same result" if _identical_trip else f"{tool_name} failed"
             if not _in_delegate:   # a sub-agent's stop is its own result, not the turn's
                 cprint(f"\n  ⚠ Stopped: {what} three times in a row.", C.BYELLOW)
                 _mark_turn_stopped("loop")
-            if escalate.get_api_key(config):
-                # Same non-interactive hazard as the safety confirms: this sits in
-                # the autopilot path, so an unattended run must not stall here.
-                escalated = ui.confirm_or_deny("  Escalate to the cloud model? [y/N] ")
-                if escalated:
-                    tool_seq = [entry[0] for entry in _loop_tracker]
-                    suggestion = escalate.escalate(config, messages, tool_seq)
-                    print()
-                    cprint("  Cloud suggestion", C.BOLD)
-                    print(suggestion)
-                    print()
             memory.maybe_index_turn(config, query, tools_used, touched_paths, outcome="error_loop")
             if session:
                 _record_undo_snapshots(session, _turn_snapshots)
@@ -1685,6 +1613,30 @@ _RUN_TESTS_RE = re.compile(
 )
 
 
+_BEHAVIOUR_CLAIM_RE = re.compile(
+    r"\b(ran (?:it|the [a-z]+|successfully)(?: successfully)?|runs (?:correctly|fine|successfully|as expected)|"
+    r"(?:it|this|that|everything|the [a-z]+) (?:now |all )?works\b|works (?:as expected|correctly|now|fine)|"
+    r"(?:it|this|that|everything|the [a-z]+) is (?:now )?working(?: correctly| as expected)?|"
+    r"(?:buttons?|it|the app|the page|the script) (?:now )?responds?|"
+    r"calculates? correctly|opens? correctly|executed successfully|"
+    r"tests? (?:pass|passed|passing|succeed)|all tests pass|verified (?:that )?it (?:works|runs)|"
+    r"confirmed (?:that )?it (?:works|runs))\b", re.IGNORECASE)
+
+
+def _behaviour_claim(message: str) -> str:
+    """The first behaviour claim in a finish message, or ''. Deliberately a
+    list of ways to say "I ran it and it works", not a list of verbs: "the
+    function returns the sum" is a description, "it works" is a claim."""
+    m = _BEHAVIOUR_CLAIM_RE.search(message or "")
+    return m.group(0) if m else ""
+
+
+def _claim_nudge_text(claim: str) -> str:
+    return (f"You said \"{claim}\" but nothing was run this turn. Run it with run_code or "
+            "run_command and report what you observed, or say plainly that it was not run. "
+            "Respond with JSON only.")
+
+
 def _asks_to_run_tests(query: str) -> bool:
     """True when the request itself asks for the tests to be run."""
     return bool(_RUN_TESTS_RE.search(query or ""))

{hexcli-2.10.0 → hexcli-2.11.1}/hexcli/compaction.py

@@ -8,7 +8,7 @@ The deterministic merge-aware compactor, the LLM summarizer behind explicit
 Cross-cutting names (call_llm, build_autopilot_prompt, estimate_tokens,
 sync_session_store, the token estimator, and compact_history itself when
 auto-compact fires it) are resolved through the agent module AT CALL TIME —
-the same idiom loop_v2 uses — so every existing sa.<name> patch site keeps
+the same idiom the loop uses — so every existing sa.<name> patch site keeps
 intercepting. Module-local calls stay module-local only when nothing patches
 them.
 

{hexcli-2.10.0 → hexcli-2.11.1}/hexcli/config.py

@@ -78,22 +78,11 @@ DEFAULT_CONFIG: dict[str, Any] = {
     "chat_log_enabled": True,
     "chat_log_dir": "",
     "memory_enabled": True,
-    # The dreaming consolidation daemon is OFF by default: measured 2026-08-16
-    # writing the same five fabricated machine "facts" (wrong CPU, wrong RAM,
-    # an invented temperature) into memory_rules.md every idle cycle, which
-    # workspace_snapshot then injected as "Prior knowledge" — locking the
-    # model's hardware confabulations in permanently. V2X_ROADMAP already
-    # ruled it ships only with a quality eval; the eval now exists and it
-    # failed it. Re-enable only with new evidence.
-    "memory_dreaming": False,
     "autopilot_confirm_destructive": True,
     # Sensitive-data command gate (ssh keys, credential stores, security
     # files, obfuscated execution). Separate from the destructive flag so
     # injection defense holds even when destructive confirms are disabled.
     "autopilot_confirm_sensitive": True,
-    # Agent protocol: "v1" (JSON action loop) or "v2" (native tool-call format,
-    # payload-block edits, persistent shell — see docs/V2_PLAN.md §5).
-    "protocol": "v1",
     # Auto-compact is deterministic (no LLM call) by default: summarising via
     # the same model that is already at its context cliff produced unverified
     # summaries and cost a full extra re-prefill. Set true to restore the
@@ -102,21 +91,11 @@ DEFAULT_CONFIG: dict[str, Any] = {
     # Override the derived history budget (tokens). Empty = derive from the
     # measured system-prompt size.
     "context_warn_tokens": 0,
-    # Local escalation ladder (docs/V2_PLAN.md §4): name of a bigger local
-    # npurun model to consult at hard moments (loop trips, ignored
-    # verification, prose-instead-of-edit). Empty = disabled. The server is
-    # spawned lazily on the bind address below and reused for the session.
-    "escalation_local_model": "",
-    "escalation_local_bind": "127.0.0.1:11436",
-    "escalation_max_output_tokens": 900,
-    "escalation_timeout_seconds": 240,
     "ollama": {"host": "http://127.0.0.1:11434"},
     "openai_compatible": {
         "base_url": "http://127.0.0.1:8000/v1",
         "api_key": "local",
     },
-    "anthropic_api_key": "",
-    "escalation_model": "claude-haiku-4-5-20251001",
 }
 
 
@@ -187,18 +166,10 @@ _CONFIG_SETTABLE: dict[str, str] = {
     "chat_log_enabled":               "bool",
     "chat_log_dir":                   "str",
     "memory_enabled":                 "bool",
-    "memory_dreaming":                "bool",
     "autopilot_confirm_destructive":  "bool",
     "autopilot_confirm_sensitive":    "bool",
-    "protocol":                       "str",
     "auto_compact_uses_llm":          "bool",
     "context_warn_tokens":            "int",
-    "escalation_local_model":         "str",
-    "escalation_local_bind":          "str",
-    "escalation_max_output_tokens":   "int",
-    "escalation_timeout_seconds":     "int",
-    "anthropic_api_key":              "str",
-    "escalation_model":               "str",
 }