localcode 0.3.35__tar.gz → 0.3.37__tar.gz

{localcode-0.3.35/src/localcode.egg-info → localcode-0.3.37}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.35
+Version: 0.3.37
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0
@@ -70,7 +70,7 @@ Dynamic: license-file
 ## Install
 
 ```bash
-pip install localcode
+pip install localcode      # or: uv pip install localcode
 ```
 
 ## Run
@@ -80,8 +80,6 @@ cd your-project
 localcode
 ```
 
-That's it. First launch builds the inference server and downloads the model (~5 min, one time). After that, startup is ~15 seconds.
-
 ## Docs
 
 Docs are published at [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/).
@@ -119,11 +117,15 @@ LocalCode is early software. Hardware support is expected to broaden, but only t
 
 | Mac | Memory | Status | Notes |
 | --- | ---: | --- | --- |
-| M4 MacBook | 16 GB | Tested | Primary development and validation machine |
+| M5 Apple Silicon | up to 128 GB | Tested | Primary development machine (M5 Max) |
+| M4 MacBook | 16 GB | Tested | Validated at the 16 GB floor |
 | M1/M2/M3 Apple Silicon | 16 GB+ | Not yet tested | Expected to work, but needs validation |
 | M4 Apple Silicon | 24 GB+ | Not yet tested | Expected to support larger contexts, but needs validation |
 | Intel Mac | Any | Not supported | LocalCode targets Apple Silicon |
 
+> Linux installs and runs in CI for development, but Apple Silicon is the
+> supported target — the Metal-accelerated inference path is Mac-only.
+
 ## Models
 
 On launch, LocalCode recommends the best model for **your Mac's RAM** — there's no fixed default. You can pick any of these (or a different quant) in the model picker.

{localcode-0.3.35 → localcode-0.3.37}/README.md

@@ -23,7 +23,7 @@
 ## Install
 
 ```bash
-pip install localcode
+pip install localcode      # or: uv pip install localcode
 ```
 
 ## Run
@@ -33,8 +33,6 @@ cd your-project
 localcode
 ```
 
-That's it. First launch builds the inference server and downloads the model (~5 min, one time). After that, startup is ~15 seconds.
-
 ## Docs
 
 Docs are published at [mjwsolo.github.io/localcode](https://mjwsolo.github.io/localcode/).
@@ -72,11 +70,15 @@ LocalCode is early software. Hardware support is expected to broaden, but only t
 
 | Mac | Memory | Status | Notes |
 | --- | ---: | --- | --- |
-| M4 MacBook | 16 GB | Tested | Primary development and validation machine |
+| M5 Apple Silicon | up to 128 GB | Tested | Primary development machine (M5 Max) |
+| M4 MacBook | 16 GB | Tested | Validated at the 16 GB floor |
 | M1/M2/M3 Apple Silicon | 16 GB+ | Not yet tested | Expected to work, but needs validation |
 | M4 Apple Silicon | 24 GB+ | Not yet tested | Expected to support larger contexts, but needs validation |
 | Intel Mac | Any | Not supported | LocalCode targets Apple Silicon |
 
+> Linux installs and runs in CI for development, but Apple Silicon is the
+> supported target — the Metal-accelerated inference path is Mac-only.
+
 ## Models
 
 On launch, LocalCode recommends the best model for **your Mac's RAM** — there's no fixed default. You can pick any of these (or a different quant) in the model picker.

{localcode-0.3.35 → localcode-0.3.37}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "localcode"
-version = "0.3.35"
+version = "0.3.37"
 description = "High-performance AI coding on consumer hardware."
 readme = "README.md"
 requires-python = ">=3.10"

localcode-0.3.37/src/localcode/__init__.py

@@ -0,0 +1,11 @@
+__all__ = ["__version__"]
+
+# Read the version from installed package metadata so it can never drift from
+# pyproject.toml (it was hardcoded and went ~12 releases stale). Falls back to a
+# hardcoded value only when running from a source tree that isn't installed.
+from importlib.metadata import PackageNotFoundError, version as _pkg_version
+
+try:
+    __version__ = _pkg_version("localcode")
+except PackageNotFoundError:  # not installed (e.g. raw source checkout)
+    __version__ = "0.3.37"

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/agent/loop.py

@@ -85,6 +85,8 @@ from .recovery import (
 )
 from .tool_orchestration import prefetch_parallel_tool_calls
 from .streaming import finish_thinking_display, stream_model_round
+from .round_policy import NextRoundPolicy
+from .recovery_controller import content_length_recovery
 from .tool_execution import (
     _HARD_STOP_THRESHOLD,
     ToolExecutionState,
@@ -438,9 +440,10 @@ def run_agent_loop(
     _todo_stuck_count = 0
     _last_todo_remaining = 10**9
     _edit_recovery_nudges = 0
-    # Set when a round aborts on a detected reasoning loop; forces the very next
-    # round to decode with thinking off so the retry escapes the attractor.
-    _force_no_think_next_round = False
+    _next_round_policy: NextRoundPolicy | None = None
+    _content_length_recoveries = 0
+    _content_recovery_active = False
+    _MAX_CONTENT_LENGTH_RECOVERIES = 3
     _MAX_CONSECUTIVE_CORRECTIONS = 2
     _generic_correction_nudges = 0
     # Fires at most once per turn when an identical failing call crosses the
@@ -699,9 +702,11 @@ def run_agent_loop(
     # `itertools.count()` gives an unbounded loop; positive
     # MAX_ROUNDS still works for eval / batch use cases.
     import itertools as _itertools
+    _configured_max_rounds = max(0, int(getattr(app.config.runtime, "max_rounds", 0) or 0))
+    _effective_max_rounds = _configured_max_rounds or MAX_ROUNDS
     _round_iter = (
         () if _deterministic_launch_done else
-        _itertools.count() if MAX_ROUNDS <= 0 else range(MAX_ROUNDS)
+        _itertools.count() if _effective_max_rounds <= 0 else range(_effective_max_rounds)
     )
     for round_num in _round_iter:
         # Cancel check — user typed "stop" while the turn was running.
@@ -800,16 +805,23 @@ def run_agent_loop(
             task_stage=round_task_stage,
             user_text=user_text,
         )
-        # Cycle-breaker: the PREVIOUS round degenerated into a reasoning loop and
-        # aborted. Retrying with the reasoning channel still on re-enters the same
-        # attractor (same prompt, same samplers, same template) — a text nudge
-        # alone doesn't change the decode. So force this one retry to decode with
-        # thinking OFF, which actually changes the generation path and lets the
-        # model emit a tool call. This is fault recovery, not a reinterpretation
-        # of the user's `on` setting: normal rounds keep thinking.
-        if _force_no_think_next_round:
-            round_use_thinking = False
-            _force_no_think_next_round = False
+        from ..reasoning_capabilities import reasoning_capabilities
+        _reasoning_caps = reasoning_capabilities(
+            str(getattr(app.config.runtime, "model", "")),
+            str(getattr(app.config.runtime, "provider", "llama_cpp")),
+        )
+        _requested_thinking = bool(round_use_thinking)
+        round_use_thinking = bool(round_use_thinking and _reasoning_caps.supported)
+        # Single source of truth for this round's decode mode. Normal rounds
+        # carry the round's own thinking decision; a recovery round scheduled by
+        # the PREVIOUS round (a reasoning-loop abort) carries use_thinking=False,
+        # which decodes without the reasoning channel and breaks the attractor.
+        # A text nudge alone re-enters the same attractor (same prompt/samplers/
+        # template) — changing the decode is what actually escapes it. Fault
+        # recovery only; it does not reinterpret the user's `on` setting.
+        _round_policy = _next_round_policy or NextRoundPolicy(round_use_thinking)
+        _next_round_policy = None
+        round_use_thinking = _round_policy.use_thinking
         try:
             _ctx_chars = None
             try:
@@ -902,6 +914,14 @@ def run_agent_loop(
                     ]
             except Exception:
                 pass
+            from ..compaction import normalize_tool_protocol, protocol_errors
+            normalize_tool_protocol(model_messages)
+            _protocol_errors = protocol_errors(model_messages)
+            if _protocol_errors:
+                raise ValueError(
+                    "invalid tool transcript before generation: "
+                    + "; ".join(_protocol_errors[:5])
+                )
             round_tool_schemas = schemas_for_goal(
                 _goal_state.goal_type,
                 user_text,
@@ -930,10 +950,27 @@ def run_agent_loop(
                         len(str(m.get("content") or "")) for m in model_messages
                     ),
                     use_thinking=bool(round_use_thinking),
+                    requested_thinking=_requested_thinking,
+                    effective_thinking=bool(round_use_thinking),
+                    reasoning_family=_reasoning_caps.family,
+                    reasoning_control=_reasoning_caps.control.value,
+                    thinking_budget_tokens=int(
+                        getattr(app.config.runtime, "thinking_budget_tokens", 0) or 0
+                    ),
+                    recovery_reason=_round_policy.recovery_reason,
+                    recovery_attempt=_round_policy.recovery_attempt,
                     max_output_tokens=int(MAX_OUTPUT_TOKENS),
                     tool_schema_count=len(round_tool_schemas),
                     tool_schemas=round_tool_names,
                 )
+                _emit_round(
+                    "generation_started",
+                    turn_id=_turn_id,
+                    round_idx=round_num,
+                    requested_thinking=_requested_thinking,
+                    effective_thinking=bool(round_use_thinking),
+                    reasoning_family=_reasoning_caps.family,
+                )
             except Exception:
                 pass
             _stream_result = stream_model_round(
@@ -977,6 +1014,29 @@ def run_agent_loop(
                 _stream_result.total_tokens
                 or ((_stream_result.prompt_tokens or 0) + (_stream_result.completion_tokens or 0))
             )
+            if _round_policy.recovery_reason and not _stream_result.thinking_abort:
+                try:
+                    from ..events import emit as _emit_recovered
+                    _emit_recovered(
+                        "recovery_completed",
+                        reason=_round_policy.recovery_reason,
+                        attempt=_round_policy.recovery_attempt,
+                        finish_reason=_stream_result.finish_reason,
+                    )
+                except Exception:
+                    pass
+            if _content_recovery_active and _stream_result.finish_reason != "length":
+                try:
+                    from ..events import emit as _emit_content_recovered
+                    _emit_content_recovered(
+                        "recovery_completed",
+                        reason="max_output_tokens",
+                        attempts=_content_length_recoveries,
+                        finish_reason=_stream_result.finish_reason,
+                    )
+                except Exception:
+                    pass
+                _content_recovery_active = False
         except KeyboardInterrupt:
             out.print_info("Interrupted.")
             _loop_exit_reason = "stream_interrupt"
@@ -1010,7 +1070,14 @@ def run_agent_loop(
                 # the SAME round with thinking off (consumed at the top of the
                 # loop), which changes the generation path and breaks the loop.
                 _thinking_loop_recoveries += 1
-                _force_no_think_next_round = True
+                _next_round_policy = _round_policy.recover_without_thinking("reasoning_loop")
+                try:
+                    from ..events import emit as _emit_recovery
+                    _emit_recovery("generation_aborted", reason="reasoning_loop", round_idx=round_num)
+                    _emit_recovery("recovery_scheduled", reason="reasoning_loop", mode="no_thinking",
+                                   attempt=_thinking_loop_recoveries)
+                except Exception:
+                    pass
                 out.notice(
                     "Model reasoning started repeating itself — retrying this "
                     "step without deep reasoning so it acts instead of looping."
@@ -1149,6 +1216,47 @@ def run_agent_loop(
         except Exception:
             pass
 
+        # Claude-style bounded continuation for ordinary content truncation.
+        # Keep valid visible content, but ask the model to resume directly from
+        # the cutoff without recap. Partial tool calls are handled separately
+        # below and are always discarded rather than executed.
+        if (
+            _round_finish_reason == "length"
+            and not tool_calls
+            and not _round_pending_tool_count
+        ):
+            _length_decision = content_length_recovery(
+                _content_length_recoveries, _MAX_CONTENT_LENGTH_RECOVERIES
+            )
+            if _length_decision.action == "retry":
+                _content_length_recoveries = _length_decision.attempt
+                _content_recovery_active = True
+                # This fragment is valid user-visible output. Preserve it in
+                # the turn result before continuing; only partial tool calls
+                # are discarded.
+                if content:
+                    full_response.append(content)
+                messages.append({
+                    "role": "user",
+                    "content": _length_decision.message,
+                })
+                _ephemeral_nudge_indices.append(len(messages) - 1)
+                try:
+                    from ..events import emit as _emit_continue
+                    _emit_continue("recovery_scheduled", reason="max_output_tokens",
+                                   mode="continue_from_cutoff", attempt=_content_length_recoveries)
+                except Exception:
+                    pass
+                continue
+            try:
+                from ..events import emit as _emit_exhausted
+                _emit_exhausted("recovery_exhausted", reason="max_output_tokens",
+                                attempts=_content_length_recoveries)
+            except Exception:
+                pass
+            _loop_exit_reason = "max_output_recovery_exhausted"
+            break
+
         if _same_round_signature_count >= 5:
             try:
                 from ..events import emit as _emit_same_signature_loop
@@ -2414,8 +2522,8 @@ def run_agent_loop(
         # (i.e. `range(MAX_ROUNDS)` was consumed without a `break`).
         # When MAX_ROUNDS<=0 we use `itertools.count()` which never
         # exhausts, so this branch only fires for a positive cap.
-        if MAX_ROUNDS > 0:
-            out.print_info(f"Reached max rounds ({MAX_ROUNDS})")
+        if _effective_max_rounds > 0:
+            out.print_info(f"Reached max rounds ({_effective_max_rounds})")
             _loop_exit_reason = "max_rounds"
 
     # Fallback: if we somehow exited without setting a reason, mark

localcode-0.3.37/src/localcode/agent/recovery_controller.py

@@ -0,0 +1,25 @@
+"""Bounded model-generation recovery decisions, separate from loop plumbing."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+__all__ = ["RecoveryDecision", "content_length_recovery"]
+
+
+@dataclass(frozen=True)
+class RecoveryDecision:
+    action: str
+    reason: str
+    attempt: int
+    message: str = ""
+
+
+def content_length_recovery(attempts: int, cap: int = 3) -> RecoveryDecision:
+    if attempts < cap:
+        return RecoveryDecision(
+            "retry", "max_output_tokens", attempts + 1,
+            "SYSTEM: The previous response ended at the output limit. "
+            "Continue directly from the exact cutoff. Do not recap, repeat "
+            "completed text, or restart the answer.",
+        )
+    return RecoveryDecision("exhaust", "max_output_tokens", attempts)

localcode-0.3.37/src/localcode/agent/round_policy.py

@@ -0,0 +1,23 @@
+"""Explicit policy snapshot for the next model round (Pi-style transition)."""
+from __future__ import annotations
+
+from dataclasses import dataclass, replace
+
+__all__ = ["NextRoundPolicy"]
+
+
+@dataclass(frozen=True)
+class NextRoundPolicy:
+    use_thinking: bool
+    recovery_reason: str = ""
+    recovery_attempt: int = 0
+    commit_response: bool = True
+
+    def recover_without_thinking(self, reason: str) -> "NextRoundPolicy":
+        return replace(
+            self,
+            use_thinking=False,
+            recovery_reason=reason,
+            recovery_attempt=self.recovery_attempt + 1,
+            commit_response=False,
+        )

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/compaction.py

@@ -113,6 +113,51 @@ def estimate_tokens(messages: list[dict[str, Any]]) -> int:
     return total_chars // _CHARS_PER_TOKEN
 
 
+def protocol_errors(messages: list[dict[str, Any]]) -> list[str]:
+    """Return tool-call/tool-result trajectory violations in transcript order."""
+    pending: set[str] = set()
+    errors: list[str] = []
+    for index, message in enumerate(messages):
+        if message.get("role") == "assistant":
+            for call in message.get("tool_calls") or []:
+                call_id = str(call.get("id") or "")
+                if not call_id:
+                    errors.append(f"assistant[{index}] has a tool call without an id")
+                else:
+                    pending.add(call_id)
+        elif message.get("role") == "tool":
+            call_id = str(message.get("tool_call_id") or "")
+            if call_id not in pending:
+                errors.append(f"tool[{index}] has no preceding call: {call_id}")
+            else:
+                pending.remove(call_id)
+    errors.extend(f"tool call has no result: {call_id}" for call_id in sorted(pending))
+    return errors
+
+
+def normalize_tool_protocol(messages: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Fill legacy/malformed missing tool IDs deterministically in place."""
+    awaiting: list[str] = []
+    serial = 0
+    for message in messages:
+        if message.get("role") == "assistant":
+            for call in message.get("tool_calls") or []:
+                call_id = str(call.get("id") or "")
+                if not call_id:
+                    serial += 1
+                    call_id = f"localcode_call_{serial}"
+                    call["id"] = call_id
+                awaiting.append(call_id)
+        elif message.get("role") == "tool":
+            call_id = str(message.get("tool_call_id") or "")
+            if not call_id and awaiting:
+                call_id = awaiting[0]
+                message["tool_call_id"] = call_id
+            if call_id in awaiting:
+                awaiting.remove(call_id)
+    return messages
+
+
 def _compact_fraction() -> float:
     """The fraction of the usable window at which auto-compaction fires.
 
@@ -290,4 +335,7 @@ def compact(
     compacted: list[dict[str, Any]] = list(sys_msgs)
     compacted.append({"role": "system", "content": memo})
     compacted.extend(keep)
+    normalize_tool_protocol(compacted)
+    if protocol_errors(compacted):
+        return messages
     return compacted

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/config.py

@@ -50,6 +50,8 @@ temperature = 1.0
 max_context_chars = 200000
 request_timeout_seconds = 600
 max_retries = 3
+max_rounds = 0
+thinking_budget_tokens = 0
 
 [search]
 provider = "duckduckgo"
@@ -96,6 +98,8 @@ class RuntimeConfig:
     adaptive_execution: bool = False
     escalation_enabled: bool = False
     low_overhead_mode: bool = True
+    max_rounds: int = 0  # 0 = unlimited interactive loop; positive for batch/eval
+    thinking_budget_tokens: int = 0  # 0 = catalog default; negative disables
     laptop_26b_runtime_mode: str = "turbo"
     internal_thinking_mode: str = "off"
     quant_preset: str = "balanced"
@@ -227,6 +231,8 @@ def save_config(config: AppConfig) -> Path:
         f"adaptive_execution = {'true' if config.runtime.adaptive_execution else 'false'}\n"
         f"escalation_enabled = {'true' if config.runtime.escalation_enabled else 'false'}\n"
         f"low_overhead_mode = {'true' if config.runtime.low_overhead_mode else 'false'}\n"
+        f"max_rounds = {config.runtime.max_rounds}\n"
+        f"thinking_budget_tokens = {config.runtime.thinking_budget_tokens}\n"
         f'laptop_26b_runtime_mode = "{config.runtime.laptop_26b_runtime_mode}"\n'
         f'internal_thinking_mode = "{config.runtime.internal_thinking_mode}"\n'
         f'quant_preset = "{config.runtime.quant_preset}"\n'
@@ -313,6 +319,8 @@ def load_config() -> AppConfig:
         adaptive_execution=str(os.environ.get("LOCALCODE_ADAPTIVE_EXECUTION", runtime_data.get("adaptive_execution", True))).lower() in {"1", "true", "yes", "on"},
         escalation_enabled=str(os.environ.get("LOCALCODE_ESCALATION_ENABLED", runtime_data.get("escalation_enabled", True))).lower() in {"1", "true", "yes", "on"},
         low_overhead_mode=str(os.environ.get("LOCALCODE_LOW_OVERHEAD_MODE", runtime_data.get("low_overhead_mode", False))).lower() in {"1", "true", "yes", "on"},
+        max_rounds=max(0, int(os.environ.get("LOCALCODE_MAX_ROUNDS", runtime_data.get("max_rounds", runtime_data.get("max_turns", 0))))),
+        thinking_budget_tokens=int(os.environ.get("LOCALCODE_THINKING_BUDGET", runtime_data.get("thinking_budget_tokens", 0))),
         laptop_26b_runtime_mode=os.environ.get("LOCALCODE_LAPTOP_26B_RUNTIME_MODE", runtime_data.get("laptop_26b_runtime_mode", "auto")),
         internal_thinking_mode=os.environ.get("LOCALCODE_INTERNAL_THINKING_MODE", runtime_data.get("internal_thinking_mode", "off")),
         quant_preset=os.environ.get("LOCALCODE_QUANT_PRESET", runtime_data.get("quant_preset", "balanced")),
@@ -447,6 +455,10 @@ def _apply_project_config(config: AppConfig, project_root: Path | None = None) -
         config.runtime.laptop_26b_runtime_mode = str(rt["laptop_26b_runtime_mode"]).strip() or "auto"
     if "internal_thinking_mode" in rt:
         config.runtime.internal_thinking_mode = str(rt["internal_thinking_mode"]).strip() or "off"
+    if "max_rounds" in rt:
+        config.runtime.max_rounds = max(0, int(rt["max_rounds"]))
+    if "thinking_budget_tokens" in rt:
+        config.runtime.thinking_budget_tokens = int(rt["thinking_budget_tokens"])
     if "planner_hints_enabled" in rt:
         config.runtime.planner_hints_enabled = str(rt["planner_hints_enabled"]).lower() in {"1", "true", "yes", "on"}
 

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/entrypoint.py

@@ -128,6 +128,12 @@ def build_parser() -> argparse.ArgumentParser:
                           "pair with LOCALCODE_SERVER_FLAVOR=vanilla)")
     run.add_argument("--timeout", type=int, default=0,
                      help="abort after N seconds (0 = no limit)")
+    run.add_argument("--max-rounds", type=int, default=None,
+                     help="maximum model/tool rounds (0 = unlimited)")
+    run.add_argument("--thinking", choices=["off", "auto", "on"], default=None,
+                     help="hidden-reasoning policy for this run")
+    run.add_argument("--thinking-budget", type=int, default=None,
+                     help="reasoning-token budget (0 = model default, negative = disable)")
     run.add_argument("--quiet", action="store_true",
                      help="suppress streamed agent output; print only the final answer")
     run.add_argument("--json", action="store_true",
@@ -351,6 +357,14 @@ def main(argv: list[str] | None = None) -> None:
         console.print(f"\n{'[green]✓[/]' if ok else '[yellow]⚠[/]'} {msg}")
         sys.exit(0 if ok else 1)
     if args.command == "run":
+        if args.max_rounds is not None:
+            if args.max_rounds < 0:
+                parser.error("--max-rounds must be 0 or greater")
+            config.runtime.max_rounds = args.max_rounds
+        if args.thinking is not None:
+            config.runtime.internal_thinking_mode = args.thinking
+        if args.thinking_budget is not None:
+            config.runtime.thinking_budget_tokens = args.thinking_budget
         sys.exit(_run_headless(config, args, console))
 
     # --preview-screen: visual-test a screen in isolation. Mocks the

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/events.py

@@ -159,10 +159,15 @@ EVENT_BUCKETS: dict[str, str] = {
     # model behavior
     "thinking_abort":         "model",
     "model_loop_detected":    "model",
+    "generation_started":     "model",
+    "generation_aborted":     "model",
     # recovery
     "auto_nudge":             "recovery",
     "compaction":             "recovery",
     "server_reconnect":       "recovery",
+    "recovery_scheduled":     "recovery",
+    "recovery_completed":     "recovery",
+    "recovery_exhausted":     "recovery",
     # error
     "error":                  "error",
 }

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/headless_json.py

@@ -44,6 +44,7 @@ class JsonlEmitter:
         self.prompt_tokens = 0
         self.completion_tokens = 0
         self.total_tokens = 0
+        self.last_turn_end: dict[str, Any] = {}
 
     def _write(self, obj: dict[str, Any]) -> None:
         # Single line, no pretty-printing — each line must be one valid
@@ -67,6 +68,8 @@ class JsonlEmitter:
             self.prompt_tokens += _as_int(payload.get("prompt_tokens"))
             self.completion_tokens += _as_int(payload.get("completion_tokens"))
             self.total_tokens += _as_int(payload.get("total_tokens"))
+        elif event_type == "turn_end":
+            self.last_turn_end = dict(payload)
         record: dict[str, Any] = {"type": event_type}
         record.update(payload)
         self._write(record)
@@ -199,7 +202,12 @@ def run_headless_json(config, args) -> int:
         except Exception:
             pass
 
-    return _emit_result("ok", 0, "completed", result_text or "")
+    turn_end = emitter.last_turn_end
+    completion = str(turn_end.get("completion_status") or "")
+    reason = str(turn_end.get("loop_exit_reason") or "completed")
+    if completion and completion != "completed":
+        return _emit_result("incomplete", 1, reason, result_text or "")
+    return _emit_result("ok", 0, reason, result_text or "")
 
 
 def open_clean_stdout() -> TextIO:

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/models_catalog.py

@@ -78,6 +78,10 @@ class ModelChoice:
     # any entry left unpinned downloads exactly as before.
     revision: str = "main"
     sha256: str | None = None
+    reasoning_control: str = "chat_template"
+    reasoning_budget_tokens: int = 8192
+    preserves_reasoning: bool = True
+    supports_parallel_tools: bool = False
 
     @property
     def hf_url(self) -> str:
@@ -133,7 +137,7 @@ class ModelChoice:
         hidden-reasoning stream to toggle (the status bar shows `n/a`); every
         other catalog arch supports it. Derived from the architecture.
         """
-        return not str(self.architecture or "").lower().startswith("diffusion")
+        return self.reasoning_control != "none"
 
     @property
     def supports_audio_in(self) -> bool:
@@ -267,6 +271,8 @@ CHOICES: list[ModelChoice] = [
             "Apache 2.0. GGUF Q4_K_M is ~15.7 GiB, so treat as a 32 GB+ unified-memory pick until "
             "this stack has measured load/runtime behavior. No LocalCode HumanEval number yet."
         ),
+        reasoning_control="none",
+        reasoning_budget_tokens=0,
     ),
     ModelChoice(
         key="north-mini-code",
@@ -285,6 +291,7 @@ CHOICES: list[ModelChoice] = [
             "on first use (one-time, ~5-12 min) and serves it with stock flags. "
             "Apache 2.0. ~17.9 GiB; recommend 32 GB+ unified memory."
         ),
+        reasoning_budget_tokens=0,
     ),
     ModelChoice(
         key="gemma-q8",

{localcode-0.3.35 → localcode-0.3.37}/src/localcode/output.py

@@ -285,8 +285,11 @@ class OutputManager:
         self._stop_indicator()
         lines = result.strip().splitlines()
         if error:
+            # A tool returning an error is normal, recoverable agentic operation
+            # (the model reads it and adjusts) — render it calm amber, NOT alarm
+            # red. Red is reserved for a terminal, turn-ending failure (set_error).
             for line in lines[:5]:
-                sys.stdout.write(f"\033[31m  └ {line[:90]}\033[0m\n")
+                sys.stdout.write(f"\033[33m  └ {line[:90]}\033[0m\n")
         elif lines:
             max_lines = 8
             for i, line in enumerate(lines[:max_lines]):

localcode-0.3.37/src/localcode/protocol/__init__.py

@@ -0,0 +1,56 @@
+"""LocalCode public automation protocol.
+
+The single, versioned, dependency-light definition of the `localcode run --json`
+event stream. Both the native `eval/` harness and the Harbor plugin consume
+LocalCode through this package — neither maintains its own JSONL parser or
+failure taxonomy (integration plan §7.2.1). Standard library only, so any
+consumer can import it without pulling in LocalCode's full dependency tree.
+
+Typical use:
+
+    from localcode.protocol import parse_stream, outcome_from_parse
+
+    parsed = parse_stream(process.stdout)      # incremental, memory-bounded
+    outcome = outcome_from_parse(parsed)       # normalized RunOutcome
+    if outcome.clean_finish:                    # LocalCode's loop finished...
+        ...                                     # ...verifier still decides pass/fail
+"""
+from __future__ import annotations
+
+from .events import (
+    SCHEMA_MAJOR,
+    SCHEMA_MINOR,
+    SCHEMA_VERSION,
+    Event,
+    SchemaVersion,
+    UnsupportedSchemaError,
+)
+from .jsonl import ParseProblem, ParseResult, iter_events, parse_stream
+from .outcomes import (
+    FailureCategory,
+    RunOutcome,
+    normalize_reason,
+    outcome_from_parse,
+    redact,
+)
+
+__all__ = [
+    # schema
+    "SCHEMA_MAJOR",
+    "SCHEMA_MINOR",
+    "SCHEMA_VERSION",
+    "SchemaVersion",
+    "UnsupportedSchemaError",
+    # events + parsing
+    "Event",
+    "ParseProblem",
+    "ParseResult",
+    "parse_stream",
+    "iter_events",
+    # outcomes
+    "FailureCategory",
+    "RunOutcome",
+    "normalize_reason",
+    "outcome_from_parse",
+    "redact",
+]