localcode 0.3.27__tar.gz → 0.3.28__tar.gz

{localcode-0.3.27/src/localcode.egg-info → localcode-0.3.28}/PKG-INFO

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

{localcode-0.3.27 → localcode-0.3.28}/pyproject.toml

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

{localcode-0.3.27 → localcode-0.3.28}/src/localcode/agent/context.py

@@ -721,12 +721,25 @@ def _microcompact_for_prompt_budget(messages: list[dict], *, target_bytes: int =
         return messages
 
     system_count = 1 if messages and messages[0].get("role") == "system" else 0
+    # NEVER compact away the task statement. The first real user message (not
+    # a synthetic "SYSTEM:" nudge) anchors the entire turn: summarizing it into
+    # a one-line ledger made the model literally ask "what is the actual task?"
+    # mid-build and re-derive the goal from directory names (observed live on a
+    # long agentic build). Keep it VERBATIM at the head, always — the reference
+    # harnesses' compaction likewise carries the original request forward.
+    head_count = system_count
+    for i in range(system_count, len(messages)):
+        m = messages[i]
+        if m.get("role") == "user" and isinstance(m.get("content"), str) \
+                and not m["content"].startswith("SYSTEM:"):
+            head_count = i + 1
+            break
     best = messages
     # Tighten the protocol-safe suffix until the serialized prompt fits. A
     # fixed 12-message tail can itself contain several complete source files.
     for tail_size in (12, 10, 8, 6, 4):
-        boundary = max(system_count, len(messages) - tail_size)
-        while boundary > system_count:
+        boundary = max(head_count, len(messages) - tail_size)
+        while boundary > head_count:
             if messages[boundary].get("role") == "tool":
                 boundary -= 1
                 continue
@@ -735,13 +748,13 @@ def _microcompact_for_prompt_budget(messages: list[dict], *, target_bytes: int =
                 boundary -= 1
                 continue
             break
-        if boundary <= system_count:
+        if boundary <= head_count:
             continue
-        old = messages[system_count:boundary]
+        old = messages[head_count:boundary]
         recent = messages[boundary:]
         summary = _compact_history_summary(old)
         candidate = [
-            *messages[:system_count],
+            *messages[:head_count],
             {"role": "user", "content": summary},
             {"role": "assistant", "content": "Continuing with the summarized prior work."},
             *recent,

{localcode-0.3.27 → localcode-0.3.28}/src/localcode/app.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from dataclasses import replace
 import logging
+import re
 from pathlib import Path
 
 from rich.console import Console
@@ -60,6 +61,19 @@ _FOLLOWUP_CHAT_ONLY = {
 
 _CODING_TASK_KINDS = {"new_app", "existing_app_edit", "run_or_launch"}
 
+# Any slash-joined token that isn't a URL scheme ("://") — "~/x", "./x", "..",
+# "/Users/…", or "some/dir". Used to detect that the user chose a location
+# themselves, in which case the $HOME build anchor must NOT re-pin repo_root.
+_EXPLICIT_PATH_RE = re.compile(r"(?<!:)(?:~|\.{1,2})?/[\w.\-]+|[\w.\-]+/[\w.\-]+(?!//)")
+
+
+def _prompt_names_explicit_path(user_text: str) -> bool:
+    """True when the user's request mentions a concrete filesystem path."""
+    text = (user_text or "")
+    # Strip URLs first so "https://foo.com/bar" doesn't read as a path.
+    text = re.sub(r"\w+://\S+", " ", text)
+    return bool(_EXPLICIT_PATH_RE.search(text))
+
 
 def _canonical_project_dir_has_files(repo_root: Path, slug: str) -> bool:
     """True when a creation task's canonical project directory already exists.
@@ -530,11 +544,20 @@ class LocalCodeApp:
         # BEFORE any tool call, so the model builds in one place and the harness
         # (launcher/verify/context) follows it. Only fires in the degenerate
         # $HOME case; a normal in-project launch is untouched.
+        #
+        # NEVER anchor when the user's prompt names a filesystem path: they've
+        # chosen the location themselves, and re-pinning repo_root to an empty
+        # $HOME/<slug> makes every RELATIVE path resolve against the empty
+        # anchor while the model builds at the user's absolute path — observed
+        # live as "Glob(src/utils/*) → empty → 'the file wasn't persisted'" and
+        # a rebuild-from-scratch spiral. False positives here are safe (we just
+        # fall back to unanchored-at-$HOME, the pre-0.3.26 behavior).
         _anchored_resume = False
         if (
             self.repo_root_is_home
             and goal_state.goal_type == "build_app"
             and goal_state.task_kind == "new_app"
+            and not _prompt_names_explicit_path(user_text)
         ):
             _anchored_resume = self._anchor_home_build_root(goal_state.task_slug)
         if (

{localcode-0.3.27 → localcode-0.3.28}/src/localcode/auto_compact.py

@@ -112,9 +112,27 @@ def auto_compact(messages: list[dict], max_chars: int,
     if len(conversation) <= keep_recent:
         return messages, ""
 
+    # NEVER summarize away the task statement. The most recent real user
+    # message (not a synthetic "SYSTEM:" nudge) is the active task; folding it
+    # into the summary made the model ask "what is the actual task?" mid-build
+    # and re-derive the goal from directory names (observed live). Pin it
+    # verbatim: if it falls in the to-be-summarized region, lift it out and
+    # re-append it just before the recent tail.
+    task_msg = None
+    task_idx = None
+    for i in range(len(conversation) - 1, -1, -1):
+        m = conversation[i]
+        if m.get("role") == "user" and isinstance(m.get("content"), str) \
+                and not m["content"].startswith("SYSTEM:"):
+            task_msg, task_idx = m, i
+            break
+
     # Split into old (to summarize) and recent (to keep)
     old = conversation[:-keep_recent]
     recent = conversation[-keep_recent:]
+    pin_task = task_msg is not None and task_idx < len(conversation) - keep_recent
+    if pin_task:
+        old = [m for i, m in enumerate(conversation[:-keep_recent]) if i != task_idx]
 
     summary_text = _build_summary(old)
 
@@ -136,6 +154,10 @@ def auto_compact(messages: list[dict], max_chars: int,
     if system_msg:
         compacted.append(system_msg)
     compacted.append({"role": "system", "content": memo})
+    if pin_task:
+        # The active task statement, verbatim, right after the memo — the model
+        # must always be able to re-read WHAT it was asked to do.
+        compacted.append(task_msg)
     compacted.extend(recent)
 
     return compacted, summary_text

{localcode-0.3.27 → localcode-0.3.28}/src/localcode/runtime.py

@@ -1337,6 +1337,50 @@ class LocalCodeRuntimeGateway(_DiffusionMixin):
         num_predict: int | None = None,
         recovery_mode: str = "",
         stream_policy: str = "",
+    ) -> Iterator[dict[str, Any]]:
+        """In-flight guard wrapper around the real streaming generator.
+
+        Holds ServerManager's request-in-flight count for the stream's whole
+        lifetime so the idle-suspend watchdog can never shut the server down
+        under an active request. Without this, a long round (10+ min decode —
+        routine for a 30B+ model on local hardware, and prompt-eval of a big
+        context emits no chunks at all) counted as "idle": observed live as
+        `idle_suspend idle_s=612` killing the server mid-build, cascading into
+        back-to-back 35 GB weight reloads and a dead session.
+        """
+        _sm = None
+        try:
+            from .server_manager import ServerManager as _SM
+            _sm = _SM.get()
+            _sm.request_started()
+        except Exception:
+            _sm = None
+        try:
+            yield from self._stream_chat_events_inner(
+                messages,
+                tools=tools,
+                think=think,
+                num_ctx=num_ctx,
+                num_predict=num_predict,
+                recovery_mode=recovery_mode,
+                stream_policy=stream_policy,
+            )
+        finally:
+            if _sm is not None:
+                try:
+                    _sm.request_finished()
+                except Exception:
+                    pass
+
+    def _stream_chat_events_inner(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+        think: bool = False,
+        num_ctx: int | None = None,
+        num_predict: int | None = None,
+        recovery_mode: str = "",
+        stream_policy: str = "",
     ) -> Iterator[dict[str, Any]]:
         # Diffusion models (architecture="diffusion_gemma") cannot be
         # served by llama-server — they generate via the one-shot

{localcode-0.3.27 → localcode-0.3.28}/src/localcode/server_manager.py

@@ -321,6 +321,25 @@ class ServerManager:
         import time as _t
         self._last_activity_ts = _t.time()
 
+    def request_started(self) -> None:
+        """Mark a chat request in flight. The idle watchdog must NEVER
+        suspend the server while a request is live: a single long agentic
+        round (a 10+ minute decode is routine for a 30B+ model on local
+        hardware) used to count as "idle" because activity was only marked at
+        request START — observed live as `idle_suspend idle_s=612` firing
+        mid-build, shutting the server down under an active stream and
+        cascading into back-to-back reloads (35 GB of weights each) and a dead
+        session. Pair with request_finished() in a finally block."""
+        with self._lock:
+            self._inflight = getattr(self, "_inflight", 0) + 1
+        self.mark_activity()
+
+    def request_finished(self) -> None:
+        """Mark a chat request complete (see request_started)."""
+        with self._lock:
+            self._inflight = max(0, getattr(self, "_inflight", 0) - 1)
+        self.mark_activity()
+
     def set_idle_timeout(self, seconds: float) -> None:
         """Update the idle auto-suspend window. 0 disables suspend."""
         self._idle_timeout_s = max(0.0, float(seconds))
@@ -336,6 +355,11 @@ class ServerManager:
                     continue
                 if self._last_activity_ts == 0.0:
                     continue
+                # A live request is never idle, no matter how long its decode
+                # runs. This is the primary guard; the streaming path also
+                # marks activity per chunk as a belt-and-braces backstop.
+                if getattr(self, "_inflight", 0) > 0:
+                    continue
                 idle = _t.time() - self._last_activity_ts
                 if idle >= self._idle_timeout_s:
                     _lifecycle_log(

{localcode-0.3.27 → localcode-0.3.28/src/localcode.egg-info}/PKG-INFO

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

{localcode-0.3.27 → localcode-0.3.28}/src/localcode.egg-info/SOURCES.txt

@@ -962,6 +962,7 @@ tests/test_run_json.py
 tests/test_runtime.py
 tests/test_subproc_env.py
 tests/test_syntax_check.py
+tests/test_task_statement_pinning.py
 tests/test_thermal.py
 tests/test_toolkit.py
 tests/test_tui_input.py

{localcode-0.3.27 → localcode-0.3.28}/tests/test_agent_event_regressions.py

@@ -1040,7 +1040,11 @@ def test_prepare_model_messages_microcompacts_large_turn_history() -> None:
     compacted = _prepare_model_messages(messages)
 
     assert len(compacted) < len(messages)
-    assert "Earlier context summarized" in compacted[1]["content"]
+    # The FIRST real user message (the task statement) is pinned verbatim at
+    # the head — losing it made the model ask "what is the actual task?" mid-
+    # build. The summary follows it.
+    assert compacted[1]["role"] == "user" and compacted[1]["content"] == "request 0"
+    assert "Earlier context summarized" in compacted[2]["content"]
     assert compacted[-1]["role"] == "tool"
 
 

localcode-0.3.28/tests/test_task_statement_pinning.py

@@ -0,0 +1,64 @@
+"""Regression: compaction must never lose the user's task statement.
+
+Observed live on a long agentic build: after compaction the model said
+"I need to understand what the actual task is — it seems like building an
+Anki clone based on the directory name". The original request had been
+summarized into a one-line ledger. Both compactors must carry the task
+statement forward VERBATIM.
+"""
+from localcode.agent.context import _microcompact_for_prompt_budget
+from localcode.auto_compact import auto_compact
+from localcode.app import _prompt_names_explicit_path
+
+TASK = "Build me a local-first Anki clone as a single-page web app with FSRS scheduling"
+
+
+def _long_history(task_first: bool = True) -> list[dict]:
+    msgs: list[dict] = [{"role": "system", "content": "You are LocalCode."}]
+    if task_first:
+        msgs.append({"role": "user", "content": TASK})
+    for i in range(30):
+        msgs.append({"role": "assistant", "content": "", "tool_calls": [
+            {"id": f"c{i}", "type": "function",
+             "function": {"name": "write_file", "arguments": f'{{"path": "src/f{i}.ts", "content": "{"x" * 3000}"}}'}}
+        ]})
+        msgs.append({"role": "tool", "tool_call_id": f"c{i}", "content": f"wrote src/f{i}.ts"})
+    return msgs
+
+
+def test_microcompact_keeps_task_statement_verbatim() -> None:
+    msgs = _long_history()
+    out = _microcompact_for_prompt_budget(msgs, target_bytes=8_000)
+    assert len(out) < len(msgs)  # it actually compacted
+    contents = [str(m.get("content", "")) for m in out]
+    assert any(TASK in c for c in contents), "task statement was compacted away"
+    # And it must be the verbatim user message, not a summary mention.
+    assert any(m.get("role") == "user" and m.get("content") == TASK for m in out)
+
+
+def test_auto_compact_keeps_task_statement_verbatim() -> None:
+    msgs = _long_history()
+    out, summary = auto_compact(msgs, max_chars=10_000, keep_recent=6)
+    assert len(out) < len(msgs)
+    assert any(m.get("role") == "user" and m.get("content") == TASK for m in out), \
+        "auto_compact summarized away the active task statement"
+
+
+def test_auto_compact_task_in_recent_tail_not_duplicated() -> None:
+    # When the task statement is already inside the kept-recent tail, it must
+    # not be duplicated at the head.
+    msgs = _long_history(task_first=False)
+    msgs.append({"role": "user", "content": TASK})
+    msgs.append({"role": "assistant", "content": "on it"})
+    out, _ = auto_compact(msgs, max_chars=10_000, keep_recent=6)
+    assert sum(1 for m in out if m.get("content") == TASK) == 1
+
+
+def test_prompt_path_detection_guards_home_anchor() -> None:
+    # User names a location → anchor must not fire.
+    assert _prompt_names_explicit_path("build it in ~/Desktop/Github/localcode_test/Anki")
+    assert _prompt_names_explicit_path("put the app in ./projects/anki")
+    assert _prompt_names_explicit_path("use /Users/me/dev as the target")
+    # No location named → anchor may fire. URLs are not paths.
+    assert not _prompt_names_explicit_path("build me an anki clone as a web app")
+    assert not _prompt_names_explicit_path("fetch https://example.com/docs and build from spec")