localcode 0.3.3__tar.gz → 0.3.5__tar.gz

{localcode-0.3.3/src/localcode.egg-info → localcode-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.3
+Version: 0.3.5
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.3 → localcode-0.3.5}/pyproject.toml

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

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/__init__.py

@@ -1,3 +1,3 @@
 __all__ = ["__version__"]
 
-__version__ = "0.3.3"
+__version__ = "0.3.5"

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/agent/loop.py

@@ -715,22 +715,22 @@ def run_agent_loop(
                     list(getattr(_tool_exec_state, "files_read", {}) or {}),
                     progress_ledger_budget_chars(_win_tokens),
                 )
-                if _ledger:
-                    model_messages = list(model_messages) + [
-                        {"role": "user", "content": _ledger}
-                    ]
             except Exception:
-                pass
-            # Inject the working-memory checklist (todo_write tool): the model
-            # always sees its own plan (done / in-progress / left) so it
-            # advances instead of repeating. Appended LAST, ephemeral, empty-safe.
+                _ledger = ""
+            # Working-memory checklist (todo_write): model sees its own plan.
+            _todo_note = ""
             try:
                 from ..tools.todo_write import render_todo_reminder
-                _todos = list(getattr(app.session, "todos", []) or [])
-                _todo_note = render_todo_reminder(_todos)
-                if _todo_note:
+                _todo_note = render_todo_reminder(list(getattr(app.session, "todos", []) or []))
+            except Exception:
+                _todo_note = ""
+            # Inject ledger + todo as ONE trailing SYSTEM message (not role:user
+            # — as a user turn the model re-greeted every round). Ephemeral.
+            try:
+                _ctx_block = "\n\n".join(b for b in (_ledger, _todo_note) if b)
+                if _ctx_block:
                     model_messages = list(model_messages) + [
-                        {"role": "user", "content": _todo_note}
+                        {"role": "system", "content": _ctx_block}
                     ]
             except Exception:
                 pass

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/agent/prompts.py

@@ -164,9 +164,12 @@ def model_identity_line(model: str) -> str:
     # to its training priors otherwise answers "I'm Gemma by Google". So: lead
     # with LocalCode, disclose the model only on request.
     return (
-        f"You are LocalCode — that is your name and how you refer to yourself in "
-        f"conversation (say \"I'm LocalCode\", never lead with the model name). "
-        f"Do NOT volunteer the underlying model in greetings or ordinary replies. "
+        f"Your name is LocalCode (never lead with the underlying model name). "
+        f"Do NOT introduce or re-introduce yourself. Never begin a message with "
+        f"\"I'm LocalCode\", a greeting, or a restatement of what you're doing — "
+        f"the user already knows who you are and what the task is. Just continue "
+        f"the work: take the next action directly. Only state your name if the "
+        f"user explicitly asks who you are. "
         f"The model currently powering you is \"{friendly}\"; report it as EXACTLY "
         f"\"{friendly}\" — and only — when the user specifically asks which "
         f"model / version / quant you are, or asks to name something (a file, "

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/agent/recovery.py

@@ -365,36 +365,36 @@ def churn_nudge_for(signal: ChurnSignal) -> str:
     Names the concrete subject (file path / command) + count so the model
     sees what it's thrashing on, then tells it the ONE thing to do instead.
     """
+    # NOTE: these are FORWARD-ONLY imperatives. They deliberately contain NO
+    # self-referential loop language ("you're going in circles", "you've
+    # rewritten X N times", "thrashing", "stop planning"). A small model
+    # parrots whatever we inject: injecting "you're going in circles" as a
+    # user-role message makes it reply "You're right, I've been going in
+    # circles" — which then sits in its own context and self-conditions the
+    # loop deeper (arXiv:2509.09677). So we tell it the NEXT concrete action
+    # and nothing about the failure it just had.
     if signal.mode is ChurnMode.FILE_REWRITE:
         return (
-            f"SYSTEM: You've rewritten {signal.subject} {signal.count} times "
-            "this turn. Stop rewriting it. Read the ACTUAL error output from "
-            "the last failure, identify the specific line/cause, and make ONE "
-            "targeted edit_file change to fix that — do not overwrite the whole "
-            "file again."
+            f"SYSTEM: {signal.subject} is written — move on to the next file. "
+            "If it has a specific error, make ONE targeted edit_file change to "
+            "the exact line; otherwise create the next file the task needs."
         )
     if signal.mode is ChurnMode.COMMAND_FAILURE:
         return (
-            f"SYSTEM: `{signal.subject}` has failed {signal.count} times this "
-            "turn. Re-running it will not help. Read its error output line by "
-            "line, fix the ROOT CAUSE (a missing dependency, a syntax error in "
-            "a config/source file, a wrong path), and only then run it again."
+            f"SYSTEM: `{signal.subject}` won't succeed as-is. Read its error "
+            "output, fix the root cause (missing dependency, a syntax error in a "
+            "config/source file, a wrong path) with an edit, then run it once."
         )
     if signal.mode is ChurnMode.PLANNING_SPIN:
         return (
-            "SYSTEM: You've spent several rounds planning and re-deriving the "
-            "same approach without changing a single file or running a build. "
-            "You've planned enough. Take ONE concrete action NOW: create or "
-            "edit the most important file for the next step, then build/run to "
-            "verify it. Do not restate the plan — execute the first step of it."
+            "SYSTEM: Take the next concrete action now — create or edit the next "
+            "file the task needs, then run the build to verify. Write code, not "
+            "a plan."
         )
     # INVESTIGATION_SPIN
     return (
-        "SYSTEM: Several rounds of reading/listing/searching without WRITING "
-        "anything — you're going in circles. STOP exploring. If the task is to "
-        "build something, create the target file and write real code THIS round "
-        "with write_file/edit_file; do NOT read, ls, find, cat, or grep again. "
-        "Leftover files on disk are NOT your progress (may be an unrelated run) — "
-        "only files YOU write count. If you truly lack info only the user has, "
-        "ask ONE focused question; otherwise start writing now."
+        "SYSTEM: Take a concrete action now — create the next file the task "
+        "needs and write real code with write_file/edit_file. Files already on "
+        "disk that you did not create are not part of your task. If you truly "
+        "lack information only the user has, ask ONE focused question."
     )

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/memory_guard.py

@@ -209,3 +209,61 @@ def recommended_jetsam_limit_mb() -> int:
         total_mb = 16 * 1024
     reserve = 3500 if total_mb < 24 * 1024 else 6000
     return max(2048, total_mb - reserve)
+
+
+def should_disable_metal_residency(model_path: str, ctx_size: int) -> bool:
+    """Whether to set GGML_METAL_NO_RESIDENCY=1 for this launch.
+
+    Root cause of the recurring mid-stream SIGKILL (-9, no crash report, tens
+    of GB of system RAM still free): on Apple Silicon, llama.cpp's Metal
+    residency sets keep the model weights + KV cache + compute buffers WIRED
+    for ~3 minutes (ggml-metal-device.m). During a long generation the wired
+    total grows, and when a decode-step spike crosses the GPU's
+    `recommendedMaxWorkingSetSize` (~75% of RAM — a hard ceiling independent of
+    free system RAM), the kernel kills the process outright. This is the exact
+    bug class in ggml-org/llama.cpp#16646 on the same M4 Max / 128 GB hardware.
+
+    Setting GGML_METAL_NO_RESIDENCY=1 makes those buffers EVICTABLE instead of
+    wired, so the OS pages under pressure rather than killing — turning a hard
+    crash into (at worst) mild slowdown, and only when actually near the cap.
+
+    Gated to at-risk launches so the common small-context fast path is
+    untouched: large context (>=128K, where KV + compute-buffer growth is the
+    trigger) OR a model whose weights alone are a large fraction of the wired
+    cap. No user action, no sudo — we control the spawn env.
+    """
+    try:
+        r = subprocess.run(["sysctl", "-n", "hw.memsize"],
+                           capture_output=True, text=True, timeout=2)
+        total_mb = int(r.stdout.strip()) // (1024 * 1024)
+    except Exception:
+        return False
+    # Metal's wired ceiling is ~75% of physical RAM.
+    wired_cap_mb = int(total_mb * 0.75)
+    if ctx_size >= 131072:
+        return True
+    try:
+        import os as _os
+        model_mb = _os.path.getsize(model_path) // (1024 * 1024)
+    except Exception:
+        model_mb = 0
+    # Weights alone over ~55% of the wired cap → KV + compute will breach it.
+    return model_mb > int(wired_cap_mb * 0.55)
+
+
+def metal_residency_env(model_path: str, cmd: list) -> dict:
+    """Return {GGML_METAL_NO_RESIDENCY: '1'} when this launch is at risk of the
+    wired-cap SIGKILL, else {}. macOS-only; parses --ctx-size from the command.
+    """
+    import sys as _sys
+    if _sys.platform != "darwin":
+        return {}
+    ctx = 0
+    for i, tok in enumerate(cmd):
+        if tok == "--ctx-size" and i + 1 < len(cmd):
+            try:
+                ctx = int(cmd[i + 1])
+            except Exception:
+                ctx = 0
+            break
+    return {"GGML_METAL_NO_RESIDENCY": "1"} if should_disable_metal_residency(model_path, ctx) else {}

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/runtime.py

@@ -168,6 +168,21 @@ def _log_disconnect_context(stage: str, error: Any, *, mid_stream: bool = False)
     diag["stage"] = stage
     diag["mid_stream"] = mid_stream
     diag["error"] = err_str[:500]
+    # Capture the SERVER's own last words. llama-server prints the real cause
+    # (ggml/Metal allocation failure, GGML_ASSERT, OOM) to server.log right
+    # before it dies; without this we only see httpx's "connection dropped"
+    # and are left guessing. The tail is the actual diagnosis.
+    _server_tail = ""
+    try:
+        from .paths import global_state_dir
+        _lp = global_state_dir() / "server.log"
+        if _lp.exists():
+            _lines = _lp.read_text(errors="replace").splitlines()
+            _server_tail = "\n".join(_lines[-15:])[-1500:]
+    except Exception:
+        _server_tail = ""
+    if _server_tail:
+        diag["server_log_tail"] = _server_tail
     try:
         from .server_manager import _lifecycle_log as _ll
         _ll("server_disconnect", **diag)
@@ -186,6 +201,8 @@ def _log_disconnect_context(stage: str, error: Any, *, mid_stream: bool = False)
                 f"pressure_kill={diag.get('pressure_kill')} "
                 f"running={diag.get('running')} mid_stream={mid_stream} "
                 f"free_mb={diag.get('free_mb')} error={err_str[:300]}\n"
+                + (f"  server.log tail:\n    "
+                   + _server_tail.replace("\n", "\n    ") + "\n" if _server_tail else "")
             )
     except Exception:
         pass
@@ -2064,6 +2081,25 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             # revert this hunk and accept occasional rephrase as a
             # model property of Qwen3.6 IQ2_M.
             payload["repeat_penalty"] = 1.05
+            # Forward the EOS-NEUTRAL anti-loop samplers that were previously
+            # computed into `opts` and then DROPPED (they only went to the dead
+            # ollama-shaped payload below). DRY penalises repeated N-GRAMS —
+            # not single tokens — so unlike repeat_penalty it does NOT suppress
+            # the EOS/sentence-end tokens that caused the 2026-04-29 paraphrase
+            # regression; min_p trims the low-probability tail that token-
+            # collapse loops feed on. llama-server has DRY OFF by default, so
+            # NOT forwarding these is a real root cause of the repeat-collapse
+            # loops. We deliberately do NOT re-add the aggressive repeat_penalty
+            # /top_k/top_p bundle (that was the regression). A/B back to
+            # temperature-only with LOCALCODE_SAMPLER_MINIMAL=1.
+            import os as _os
+            if _os.environ.get("LOCALCODE_SAMPLER_MINIMAL") != "1":
+                payload["dry_multiplier"] = opts["dry_multiplier"]
+                payload["dry_base"] = opts["dry_base"]
+                payload["dry_allowed_length"] = opts["dry_allowed_length"]
+                payload["dry_penalty_last_n"] = opts["dry_penalty_last_n"]
+                if opts.get("min_p", 0):
+                    payload["min_p"] = opts["min_p"]
             if "num_predict" in opts:
                 _np = opts["num_predict"]
                 # llama-server treats max_tokens=-1 as "use default", which on
@@ -2080,8 +2116,11 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
             # outbound chat-completions payload so we can verify DRY is
             # actually being forwarded. Set LOCALCODE_DEBUG_SAMPLERS=1
             # to enable. Self-disables after one log to keep noise down.
-            import os, logging
-            if os.environ.get("LOCALCODE_DEBUG_SAMPLERS") == "1" and not getattr(self, "_logged_samplers", False):
+            import logging
+            # Always log the ACTUAL forwarded samplers once per session (was
+            # opt-in) so we can correlate looping with the real server config —
+            # the "control this better" record. Cheap: fires exactly once.
+            if not getattr(self, "_logged_samplers", False):
                 sampler_keys = (
                     "temperature", "top_p", "top_k", "min_p",
                     "repeat_penalty", "repeat_last_n",

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/server_manager.py

@@ -71,12 +71,9 @@ from .paths import (
     lifecycle_log_path,
 )
 
-# PID file stays GLOBAL — only one llama-server runs on the machine
-# (single port, single GPU memory budget). When you `cd` between
-# projects mid-session, the running server stays serving you. The
-# per-project lifecycle log records a fresh `server_started` entry
-# on next launch from the new project. See paths.py for the full
-# global-vs-project split rationale.
+# PID file stays GLOBAL — only one llama-server runs per machine (single port,
+# single GPU budget), so it keeps serving you when you `cd` between projects.
+# See paths.py for the global-vs-project split rationale.
 PID_FILE = server_pid_file()
 DEFAULT_PORT = 8081
 # Preferred-range scan (8081-8099) before falling through to an OS-assigned
@@ -177,13 +174,9 @@ def _rewrite_port_arg(cmd: list[str], port: int) -> list[str]:
 
 STUCK_SERVER_MARKER = stuck_server_marker_path()
 
-# Persistent (append-only) lifecycle log for every server start, stop,
-# pressure-kill, and recovery event. Distinct from the per-session
-# `~/.local/share/localcode/server.log` (which the setup screen
-# overwrites with `open(..., "w")` on every launch and so loses
-# inter-session context). Per-project (lives at
-# `<project_root>/.localcode/lifecycle.log`) so each project has its
-# own diagnostic timeline.
+# Persistent (append-only) lifecycle log for every server start/stop/kill/
+# recovery event. Per-project (`<project_root>/.localcode/lifecycle.log`) so
+# each project keeps its own diagnostic timeline across sessions.
 LIFECYCLE_LOG = lifecycle_log_path()
 
 
@@ -306,12 +299,10 @@ class ServerManager:
         self._lock = threading.Lock()
         self._last_exit_code: Optional[int] = None  # disconnect diagnostics
         self._last_death_was_pressure: bool = False
-        # Idle auto-suspend: track wall-clock of the most recent chat
-        # activity. A background watchdog thread shuts the server down
-        # after `_idle_timeout_s` seconds of inactivity to stop the GPU
-        # from cooking the laptop while the user is reading replies.
-        # The next chat call transparently respawns via _restart_server.
-        # 0 disables; default 10 min. Override with env LOCALCODE_IDLE_SUSPEND_S.
+        # Idle auto-suspend: a watchdog shuts the server down after
+        # `_idle_timeout_s` of inactivity (stops the GPU cooking the laptop
+        # while the user reads); the next chat call respawns via
+        # _restart_server. 0 disables; default 10 min. Env: LOCALCODE_IDLE_SUSPEND_S.
         import os as _os
         try:
             self._idle_timeout_s: float = float(
@@ -400,12 +391,9 @@ class ServerManager:
             had_prior = self._process is not None
             _prev_model = self._model_path  # capture before shutdown clears it
             self._shutdown_locked()
-            # Wait for the OLD server's memory to actually release before
-            # spawning the new one: the kernel may take 1-3 s to free wired
-            # Metal memory after the child reaps, and spawning the new ~10 GB
-            # server in that window double-commits and trips the pressure
-            # monitor on a 16 GB Mac. Best-effort — targets ~11 GB free, times
-            # out at 8 s, and proceeds anyway (refusing would be worse).
+            # Wait for the OLD server's memory to release before spawning the
+            # new one (kernel takes 1-3 s to free wired Metal memory; spawning
+            # into that window double-commits). Best-effort: ~11 GB target, 8 s.
             if had_prior:
                 # Only a genuine model change is "model_switch"; a same-model
                 # relaunch (crash/disconnect recovery) is "server_restart".
@@ -430,20 +418,44 @@ class ServerManager:
             # AGX driver may read the env at first Metal touch — setting it in
             # the parent env before spawn is the belt-and-suspenders approach.
             env.setdefault("AGX_RELAX_CDM_CTXSTORE_TIMEOUT", "1")
+            # Disable Metal residency sets on at-risk launches → prevents the wired-cap SIGKILL.
+            try:
+                from .memory_guard import metal_residency_env
+                _renv = metal_residency_env(str(model_path), cmd)
+                if _renv:
+                    env.update(_renv)
+                    _lifecycle_log("metal_no_residency", model=str(model_path))
+            except Exception:
+                pass
+            # Capture the server's OWN stdout/stderr to server.log (this runtime
+            # path used to send both to /dev/null, discarding llama-server's
+            # final ggml/Metal error on the recurring -9). Append per-spawn.
+            log_fh = None
+            try:
+                from .paths import global_state_dir
+                log_fh = open(global_state_dir() / "server.log", "a", buffering=1)
+                log_fh.write(f"\n===== llama-server spawn (port {port}) =====\n")
+            except Exception:
+                log_fh = None
+            try:  # close any prior spawn's handle before replacing it
+                if getattr(self, "_log_fh", None) is not None:
+                    self._log_fh.close()
+            except Exception:
+                pass
+            self._log_fh = log_fh
             self._process = subprocess.Popen(
                 cmd,
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.DEVNULL,
+                stdout=(log_fh or subprocess.DEVNULL),
+                stderr=subprocess.STDOUT if log_fh else subprocess.DEVNULL,
                 start_new_session=True,  # process group leader → killpg works
                 env=env,
             )
             self._model_path = model_path
             self._port = port
 
-            # Layer 1: kernel-enforced memory ceiling via jetsam. If
-            # llama-server tries to wire more than the budget allows,
-            # macOS kernel kills it BEFORE the vm_fault wait-chain can
-            # form. This is the hard backstop — sanctioned Apple API.
+            # Layer 1: kernel-enforced memory ceiling via jetsam — the hard
+            # backstop (sanctioned Apple API) that kills llama-server before it
+            # can push the system over the edge.
             try:
                 from .memory_guard import (
                     set_jetsam_highwater, recommended_jetsam_limit_mb,
@@ -454,11 +466,10 @@ class ServerManager:
             except Exception:
                 pass
 
-            # Layer 2: userspace memory-pressure monitor. Polls
-            # kern.memorystatus_vm_pressure_level every 500 ms; on WARN
-            # transition, SIGTERMs our server before the kernel stalls.
-            # Complementary to the jetsam ceiling — acts on system-wide
-            # pressure (everything else swelling) not just our own RSS.
+            # Layer 2: userspace pressure monitor — polls
+            # kern.memorystatus_vm_pressure_level every 500 ms and SIGTERMs our
+            # server on WARN. Complements the jetsam ceiling (acts on system-
+            # wide pressure, not just our own RSS).
             try:
                 self._pressure_thread = start_pressure_monitor(
                     self._process,
@@ -467,14 +478,8 @@ class ServerManager:
             except Exception:
                 self._pressure_thread = None
             self._write_pid_file(self._process.pid)
-            # Log the FULL command we launched with so future debugging
-            # can answer "what flags was the server using during this
-            # session?" — needed because subtle flags like
-            # `--lookup-cache-dynamic` or `--spec-type ngram-mod` cause
-            # repetition pathologies that look like model bugs but are
-            # actually decode-time speculative-cache feedback loops.
-            # Truncated to 4000 chars to keep the event small; that's
-            # enough for ~80 args.
+            # Log the FULL launch command (which flags was the server using?);
+            # truncated to 4000 chars (~80 args) to keep the event small.
             _flags_str = " ".join(str(c) for c in cmd)[:4000]
             _lifecycle_log("server_started", pid=self._process.pid, port=port,
                            model=Path(model_path).name,
@@ -695,10 +700,8 @@ class ServerManager:
         _lifecycle_log("pressure_kill", level=level, pid=killed_pid,
                        guard="memory_pressure", exit_code=self._last_exit_code,
                        free_mb=_system_free_memory_mb())
-        # Clear internal state so subsequent code paths see "no server
-        # running" rather than a phantom Popen handle. Safe to do from
-        # the pressure-monitor thread because `_process` reads/writes
-        # are atomic in CPython for the assignment.
+        # Clear internal state so callers see "no server" not a phantom Popen.
+        # Safe from the pressure-monitor thread (assignment is atomic in CPython).
         self._process = None
         self._model_path = None
 

{localcode-0.3.3 → localcode-0.3.5}/src/localcode/tools/write_file.py

@@ -173,6 +173,19 @@ def execute(ctx: ToolContext, args: dict) -> str:
     # catches the data.py-style "model copies in-memory stub back into
     # write_file" disaster, which was the one case where rejecting
     # was load-bearing.
+    # Log the EXACT content the model sent (post-JSON-parse) so a "the file is
+    # corrupted / write_file isn't writing what I sent" report is provable from
+    # logs in one grep, instead of a mystery. Best-effort, capped, append-only.
+    try:
+        from ..paths import global_state_dir
+        _wl = global_state_dir() / "write_content.log"
+        with open(_wl, "a", encoding="utf-8", errors="replace") as _fh:
+            _fh.write(f"\n===== write_file {args['path']} ({len(content)} chars) =====\n")
+            _fh.write(content[:20000])
+            _fh.write("\n")
+    except Exception:
+        pass
+
     existed = path.is_file()
     # Capture the prior content so an in-place rewrite renders as a diff card
     # (like edit_file/multi_edit), not a bare "Rewrote (N lines)" one-liner.

{localcode-0.3.3 → localcode-0.3.5/src/localcode.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: localcode
-Version: 0.3.3
+Version: 0.3.5
 Summary: High-performance AI coding on consumer hardware.
 Author: LocalCode contributors
 License-Expression: Apache-2.0

{localcode-0.3.3 → localcode-0.3.5}/tests/test_churn_detection.py

@@ -80,8 +80,10 @@ def test_investigation_spin_outranks_planning_spin():
 def test_planning_spin_nudge_is_actionable():
     sig = detect_churn({}, {}, 0, planning_streak=CHURN_PLANNING_STREAK_LIMIT)
     text = churn_nudge_for(sig)
-    assert "planned enough" in text.lower()
-    assert "concrete action" in text.lower() or "execute" in text.lower()
+    # Forward-only imperative: tells it the next action, with NO echo-able
+    # self-critical loop language ("planned enough") a small model would parrot.
+    assert "concrete action" in text.lower() or "write code" in text.lower()
+    assert "planned enough" not in text.lower() and "circles" not in text.lower()
 
 
 def test_command_failure_takes_precedence_over_file_rewrite():