localcode 0.3.61__tar.gz → 0.3.63__tar.gz

{localcode-0.3.61/src/localcode.egg-info → localcode-0.3.63}/PKG-INFO

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

{localcode-0.3.61 → localcode-0.3.63}/pyproject.toml

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

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/__init__.py

@@ -8,4 +8,4 @@ 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.61"
+    __version__ = "0.3.63"

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/agent/helpers.py

@@ -510,15 +510,6 @@ def _execute_tool_result(app: "LocalCodeApp", name: str, args: dict, out: "Outpu
             facts={"tool": name, "ok": False, "plan_mode_blocked": True},
         )
 
-    try:
-        hook = getattr(app, "hooks", None)
-        decision = hook.on_pre_tool_use(name, args) if hook is not None else None
-        if decision is not None and decision.blocked:
-            reason = decision.error or decision.output or "pre-tool hook blocked"
-            return ToolResult(text=f"REJECTED: {reason}", ok=False, facts={"tool": name, "ok": False, "hook_blocked": True})
-    except Exception:
-        pass
-
     # Lint-gate: for source-file writes/edits, snapshot the file before the
     # tool runs so we can auto-revert on syntax-break. Motivation: the model
     # at 2-bit quant has been observed to delete import statements during
@@ -567,19 +558,8 @@ def _execute_tool_result(app: "LocalCodeApp", name: str, args: dict, out: "Outpu
         result = _tools_dispatch_result(name, ToolContext(app=app, out=out), args)
     except Exception as e:
         text = f"Error in {name}: {type(e).__name__}: {e}"
-        try:
-            if getattr(app, "hooks", None) is not None:
-                app.hooks.on_post_tool_use(name, args, text, error=True)
-        except Exception:
-            pass
         return ToolResult(text=text, ok=False, facts={"tool": name, "ok": False, "error_type": type(e).__name__})
 
-    try:
-        if getattr(app, "hooks", None) is not None:
-            app.hooks.on_post_tool_use(name, args, result.text, error=not result.ok)
-    except Exception:
-        pass
-
     if target_path is not None and target_path.exists() and target_path.suffix == ".py":
         # Python: ast.parse is cheap and authoritative.
         import ast as _ast
@@ -596,12 +576,6 @@ def _execute_tool_result(app: "LocalCodeApp", name: str, args: dict, out: "Outpu
                 "user explicitly asked."
             )
             return ToolResult(text=text, ok=False, facts={"tool": name, "ok": False, "path": str(target_path), "reverted": True})
-    if name in _lint_tools:
-        try:
-            if getattr(app, "hooks", None) is not None:
-                app.hooks.on_post_edit(str(args.get("path", "")), result.text, error=not result.ok)
-        except Exception:
-            pass
     return result
 
 

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/agent/loop.py

@@ -784,15 +784,9 @@ def run_agent_loop(
                     f"Compacting conversation (≈{estimate_tokens(messages)} tokens "
                     f"of {ctx_tokens} context → summary)..."
                 )
-                _before_compact_count = len(messages)
                 messages[:] = compact(
                     messages, app.engine, context_window=ctx_tokens, ram_gb=_ram_gb
                 )
-                try:
-                    if getattr(app, "hooks", None) is not None:
-                        app.hooks.on_post_compaction(_before_compact_count, len(messages))
-                except Exception:
-                    pass
         except Exception as _compact_err:
             # Never let compaction failure kill the agent loop — continue
             # with the unchanged messages and let the user see the error.

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/agent/turn_finalization.py

@@ -70,15 +70,6 @@ def finalize_turn(
     """Emit turn_end and persist task/session state."""
     blocked_reason = final_text if loop_exit_reason == "blocked_question" else ""
     completion_status, task_status = status_for_exit(loop_exit_reason)
-    try:
-        hook = getattr(app, "hooks", None)
-        if hook is not None:
-            hook_result = hook.on_pre_completion(final_text, completion_status)
-            if hook_result.blocked:
-                completion_status, task_status = "stopped_early", "failed"
-                blocked_reason = hook_result.error or hook_result.output or "pre-completion hook blocked"
-    except Exception as exc:
-        _emit_finalization_error(turn_id, "pre_completion_hook", exc)
     try:
         from ..events import emit
 

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/app.py

@@ -38,7 +38,6 @@ from .history import HistoryDB
 from .verification import guess_verify_command, run_verification
 from .auto_compact import compact_if_needed
 from .autonomy import AutonomyLevel, apply_autonomy_to_permissions, get_policy
-from .hooks import HookRunner
 from .snapshots import SnapshotStore, create_snapshot
 from .turn_diff import TurnDiffTracker, print_turn_diff
 from .agent.goal import infer_goal_state
@@ -219,15 +218,12 @@ class LocalCodeApp:
         self.history = HistoryDB()  # unified SQLite history
         self.embedding_search = EmbeddingSearch(str(self.repo_root))
         self.perms = PermissionManager()  # tool permissions
-        self.hooks = HookRunner(str(self.repo_root), self.session.session_id, self.runtime_model)
         self.snapshot_store = SnapshotStore()
         self.turn_tracker = TurnDiffTracker(self.repo_root)
         # Apply autonomy mode
         autonomy_level = os.environ.get("LOCALCODE_AUTONOMY", "auto_edit")
         self._autonomy = AutonomyLevel(autonomy_level) if autonomy_level in ("suggest", "auto_edit", "full_auto") else AutonomyLevel.AUTO_EDIT
         apply_autonomy_to_permissions(self.perms, get_policy(self._autonomy))
-        # Run session start hook
-        self.hooks.on_session_start()
         self._spec_executor = SpeculativeExecutor(self.toolkit.execute_tool_calls)
         self._memory = self._load_memory()
         # Per-session notebook directory — a disk-backed "working memory"
@@ -498,11 +494,6 @@ class LocalCodeApp:
             provider=self.config.runtime.provider,
         )
 
-        # Lifecycle hook: user prompt submit
-        hook_result = self.hooks.on_user_prompt_submit(user_text)
-        if hook_result.blocked:
-            self.console.print(f"[dim]  Hook blocked prompt: {hook_result.error or hook_result.output}[/]")
-            return
         # Start turn tracking
         self.turn_tracker.start_turn(watched_files=self.session.pinned_files)
         _turn_start = time.time()

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/bootstrap.py

@@ -47,6 +47,16 @@ _DOWNLOAD_QUEUE: list[str] = []
 # ModelChoice after waiting in the queue.
 _DOWNLOAD_CHOICES: dict[str, object] = {}
 
+# model_key -> cancel Event. Set by cancel_download; polled by the parallel
+# downloader (and the hub progress hook) so an in-flight transfer aborts
+# promptly instead of running to completion after the user backs out.
+_DOWNLOAD_CANCEL: dict[str, "threading.Event"] = {}
+
+
+class DownloadCancelled(Exception):
+    """Raised inside the download machinery when a cancel Event fires, so the
+    aborted transfer is not reported as a network failure."""
+
 # Max concurrent ACTIVE downloads (status == "downloading"). The rest sit
 # in _DOWNLOAD_QUEUE with status "queued" until a slot frees.
 _MAX_ACTIVE_DOWNLOADS = 2
@@ -418,7 +428,8 @@ def get_model_path(preferred_filename: str | None = None) -> Path | None:
 
 
 def _download_parallel(url: str, dest: Path, num_threads: int = 16,
-                       on_progress: Callable[[str], None] | None = None) -> None:
+                       on_progress: Callable[[str], None] | None = None,
+                       cancel_event: "threading.Event | None" = None) -> None:
     """Download a large file using parallel HTTP range requests.
 
     Falls back to single-threaded if the server doesn't support ranges.
@@ -466,13 +477,25 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
 
     part = dest.with_name(dest.name + ".part")
 
+    if cancel_event is not None and cancel_event.is_set():
+        part.unlink(missing_ok=True)
+        raise DownloadCancelled()
+
     if not total_size or not accepts_ranges:
-        # Fallback: single-threaded
+        # Fallback: single-threaded. The reporthook doubles as the cancel
+        # poll — urlretrieve calls it every block, so raising there stops the
+        # transfer promptly (urlretrieve cleans up its own temp on the raise).
         def _report(block_num, block_size, _total):
+            if cancel_event is not None and cancel_event.is_set():
+                raise DownloadCancelled()
             if on_progress and total_size > 0:
                 done = min(block_num * block_size, total_size)
                 on_progress(f"Downloading: {done // (1024*1024)}/{total_size // (1024*1024)} MB ({done * 100 // total_size}%)")
-        urllib.request.urlretrieve(url, str(part), reporthook=_report)  # no ssl_ctx for urlretrieve
+        try:
+            urllib.request.urlretrieve(url, str(part), reporthook=_report)  # no ssl_ctx for urlretrieve
+        except DownloadCancelled:
+            part.unlink(missing_ok=True)
+            raise
         part.replace(dest)
         return
 
@@ -499,6 +522,11 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
                 with open(part, "r+b") as f:
                     f.seek(start)
                     while True:
+                        # Poll the cancel Event between reads so a cancelled
+                        # download stops writing within one 8MB buffer instead
+                        # of running the chunk to completion.
+                        if cancel_event is not None and cancel_event.is_set():
+                            return
                         data = resp.read(buf_size)
                         if not data:
                             break
@@ -541,6 +569,13 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
     progress_stop.set()
     progress_thread.join(timeout=1)
 
+    # Cancelled mid-flight: the chunk threads have already returned, so just
+    # drop the pre-allocated partial and report the abort. Checked before the
+    # error list so a cancel never surfaces as a chunk RuntimeError.
+    if cancel_event is not None and cancel_event.is_set():
+        part.unlink(missing_ok=True)
+        raise DownloadCancelled()
+
     if errors:
         part.unlink(missing_ok=True)
         raise RuntimeError("; ".join(errors))
@@ -551,6 +586,7 @@ def _download_parallel(url: str, dest: Path, num_threads: int = 16,
 def download_model(
     choice=None,
     on_progress: Callable[[str], None] | None = None,
+    cancel_event: "threading.Event | None" = None,
 ) -> tuple[bool, str]:
     """Download a GGUF model selected from `models_catalog.CHOICES`.
 
@@ -621,6 +657,9 @@ def download_model(
     last_err_category = "unknown"
     backoffs = [0, 2, 5]  # seconds; 3 attempts total
     for attempt, delay in enumerate(backoffs, start=1):
+        # Bail before spending a retry (or its backoff sleep) if cancelled.
+        if cancel_event is not None and cancel_event.is_set():
+            return False, "cancelled"
         if delay:
             if on_progress:
                 on_progress(f"Retry {attempt}/{len(backoffs)} in {delay}s...")
@@ -629,11 +668,13 @@ def download_model(
         # Fast path: huggingface_hub (hf_xet Rust backend on Xet repos).
         # Resumes via the hub's built-in partial-download handling.
         try:
-            if _try_hub_download(choice, model_file, on_progress):
+            if _try_hub_download(choice, model_file, on_progress, cancel_event):
                 ok, reason = _verify_download_integrity(choice, model_file)
                 if not ok:
                     return False, reason
                 return True, str(model_file)
+        except DownloadCancelled:
+            return False, "cancelled"
         except Exception as e:
             last_err = e
             last_err_category = _classify_download_error(e)
@@ -646,11 +687,16 @@ def download_model(
                 )
         # Slow path: tuned urllib parallel downloader.
         try:
-            _download_parallel(url, model_file, num_threads=32, on_progress=on_progress)
+            _download_parallel(
+                url, model_file, num_threads=32,
+                on_progress=on_progress, cancel_event=cancel_event,
+            )
             ok, reason = _verify_download_integrity(choice, model_file)
             if not ok:
                 return False, reason
             return True, str(model_file)
+        except DownloadCancelled:
+            return False, "cancelled"
         except Exception as e:
             last_err = e
             last_err_category = _classify_download_error(e)
@@ -803,14 +849,22 @@ def _maybe_start_next() -> None:
 def _run_download(key: str, choice) -> None:
     """Daemon worker — runs download_model OUTSIDE the lock during I/O."""
     on_progress = lambda line: _apply_progress(key, line)
+    with _DOWNLOAD_LOCK:
+        cancel_event = _DOWNLOAD_CANCEL.get(key)
     try:
-        ok, result = download_model(choice, on_progress=on_progress)
+        ok, result = download_model(
+            choice, on_progress=on_progress, cancel_event=cancel_event
+        )
     except Exception as exc:  # pragma: no cover - defensive; download_model traps its own
         ok, result = False, str(exc)
     try:
         with _DOWNLOAD_LOCK:
             entry = _DOWNLOADS.get(key)
-            if entry is not None:
+            # A cancelled download has already had its entry dropped by
+            # cancel_download; don't resurrect it as "failed".
+            if entry is not None and not (
+                cancel_event is not None and cancel_event.is_set()
+            ):
                 if ok:
                     entry["status"] = "done"
                     entry["progress_pct"] = 100
@@ -859,11 +913,66 @@ def start_background_download(choice) -> str:
             "error": None,
         }
         _DOWNLOAD_CHOICES[key] = choice
+        # Fresh (cleared) cancel Event per download; cancel_download sets it.
+        _DOWNLOAD_CANCEL[key] = threading.Event()
         _DOWNLOAD_QUEUE.append(key)
         _maybe_start_next()
     return key
 
 
+def _delete_partial_files(choice) -> None:
+    """Remove any on-disk bytes for `choice` after a cancel: the final file and
+    the `.part` working file the parallel downloader pre-allocates. A half-
+    written .gguf at the final name would pass the size check on a later run and
+    then fail cryptically inside llama-server, so we delete it outright rather
+    than trust `_is_complete_download` to catch it."""
+    try:
+        dest = Path(choice.local_path)
+    except Exception:
+        return
+    for p in (dest, dest.with_name(dest.name + ".part")):
+        try:
+            p.unlink(missing_ok=True)
+        except Exception:
+            # Best effort — a locked/absent file must never crash the cancel.
+            pass
+
+
+def cancel_download(key: str) -> bool:
+    """Cancel an in-flight (or queued) background download and delete its
+    partial file. Returns True iff there was something to cancel.
+
+    Sets the download's cancel Event (so the worker thread aborts promptly),
+    drops the registry/queue entry so the row reverts to "not downloaded",
+    then removes the partial bytes from disk. Safe to call when nothing is
+    downloading (returns False) and safe to call twice.
+    """
+    with _DOWNLOAD_LOCK:
+        event = _DOWNLOAD_CANCEL.get(key)
+        entry = _DOWNLOADS.get(key)
+        choice = _DOWNLOAD_CHOICES.get(key)
+        # Only queued/downloading entries are cancellable; a done/failed entry
+        # (or no entry at all) means there's nothing in flight to stop.
+        active = entry is not None and entry["status"] in ("queued", "downloading")
+        if event is not None:
+            event.set()
+        if key in _DOWNLOAD_QUEUE:
+            _DOWNLOAD_QUEUE.remove(key)
+        _DOWNLOADS.pop(key, None)
+        _DOWNLOAD_CHOICES.pop(key, None)
+        _DOWNLOAD_CANCEL.pop(key, None)
+    if not active:
+        return False
+    # Disk I/O happens OUTSIDE the lock. Deleting only when the entry was
+    # actually in flight protects a just-completed file from being removed.
+    if choice is not None:
+        _delete_partial_files(choice)
+    # A freed slot may let a queued download start now.
+    with _DOWNLOAD_LOCK:
+        _maybe_start_next()
+    return True
+
+
 def download_status(key: str) -> dict | None:
     """Return a shallow copy of the registry entry for `key`, or None."""
     with _DOWNLOAD_LOCK:
@@ -956,7 +1065,7 @@ def _is_mmproj_complete(p: Path, choice) -> bool:
     return size >= int(expected * 0.9)
 
 
-def _make_progress_tqdm(on_progress: Callable[[str], None]):
+def _make_progress_tqdm(on_progress: Callable[[str], None], cancel_event=None):
     """Build a tqdm subclass that forwards download progress to the UI.
 
     huggingface_hub drives BOTH of its backends — hf_xet (Rust, parallel
@@ -978,6 +1087,11 @@ def _make_progress_tqdm(on_progress: Callable[[str], None]):
             self._lc_last_emit = 0.0
 
         def update(self, n=1):
+            # Cancelling raises out of the hub's write loop — update() is the
+            # one hook driven on every downloaded byte for both backends, so it
+            # is the promptest place to abort the hub path.
+            if cancel_event is not None and cancel_event.is_set():
+                raise DownloadCancelled()
             self._lc_done += int(n or 0)
             now = time.monotonic()
             if now - self._lc_last_emit >= 0.5:
@@ -1003,7 +1117,8 @@ def _make_progress_tqdm(on_progress: Callable[[str], None]):
     return _ProgressTqdm
 
 
-def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | None) -> bool:
+def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | None,
+                      cancel_event=None) -> bool:
     """Try to download via huggingface_hub's resumable HTTP downloader.
 
     The hf_xet backend is deliberately disabled (`HF_HUB_DISABLE_XET=1`
@@ -1020,8 +1135,12 @@ def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | N
         from huggingface_hub import hf_hub_download
     except ImportError:
         return False
+    if cancel_event is not None and cancel_event.is_set():
+        raise DownloadCancelled()
     if on_progress:
         on_progress(f"Downloading {choice.filename} (HuggingFace, accelerated)...")
+    # Always route through our tqdm so the cancel poll fires even when there is
+    # no on_progress sink (the update() hook is what aborts the hub stream).
     downloaded_path = hf_hub_download(
         repo_id=choice.hf_repo,
         filename=choice.filename,
@@ -1030,7 +1149,7 @@ def _try_hub_download(choice, dest: Path, on_progress: Callable[[str], None] | N
         # under the same filename visible instead of silent.
         revision=getattr(choice, "revision", None) or "main",
         local_dir=str(dest.parent),
-        tqdm_class=_make_progress_tqdm(on_progress) if on_progress else None,
+        tqdm_class=_make_progress_tqdm(on_progress or (lambda _l: None), cancel_event),
     )
     # huggingface_hub may write to a slightly different filename inside
     # local_dir; symlink/rename to our expected dest.

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/config.py

@@ -55,14 +55,7 @@ max_retries = 3
 max_rounds = 0
 thinking_budget_tokens = 0
 
-[search]
-provider = "duckduckgo"
-google_api_key = ""
-google_cx = ""
-brave_api_key = ""
-serpapi_api_key = ""
-
-# [browser] and [voice] sections removed during T0.9 purge.
+# [search], [browser] and [voice] sections removed during T0.9 purge.
 
 [ui]
 show_debug = false
@@ -149,13 +142,9 @@ class RuntimeConfig:
     max_retries: int = 3
 
 
-@dataclass
-class SearchConfig:
-    provider: str = "duckduckgo"
-    google_api_key: str = ""
-    google_cx: str = ""
-    brave_api_key: str = ""
-    serpapi_api_key: str = ""
+# SearchConfig removed — the Google/Brave/SerpAPI web-search path was dead
+# (the agent's web_search tool uses DuckDuckGo directly) and its config keys
+# did nothing.
 
 
 # BrowserConfig / VoiceConfig removed during T0.9 — no UI path fed the
@@ -200,7 +189,6 @@ class TelemetryConfig:
 @dataclass
 class AppConfig:
     runtime: RuntimeConfig
-    search: SearchConfig
     ui: UIConfig
     safety: SafetyConfig = None  # type: ignore[assignment]
     logging: LoggingConfig = None  # type: ignore[assignment]
@@ -225,9 +213,8 @@ def get_home_dir() -> Path:
 def ensure_home_dirs() -> Path:
     """Create `~/.localcode/` and its children, owner-only (0700).
 
-    This tree holds `config.toml` (google / brave / serpapi API keys),
-    `history.db` (every prompt and response), saved sessions and the
-    lexical index. None of it should be readable by other accounts on
+    This tree holds `config.toml`, `history.db` (every prompt and response),
+    saved sessions and the lexical index. None of it should be readable by other accounts on
     the machine, so both the root and each child are created 0700 and
     the root's mode is re-asserted on every call (cheap, and it repairs
     a directory created 0755 by an older version).
@@ -299,13 +286,7 @@ def save_config(config: AppConfig) -> Path:
         f"max_context_chars = {config.runtime.max_context_chars}\n"
         f"request_timeout_seconds = {config.runtime.request_timeout_seconds}\n"
         f"max_retries = {config.runtime.max_retries}\n\n"
-        "[search]\n"
-        f'provider = {_toml_str(config.search.provider)}\n'
-        f'google_api_key = {_toml_str(config.search.google_api_key)}\n'
-        f'google_cx = {_toml_str(config.search.google_cx)}\n'
-        f'brave_api_key = {_toml_str(config.search.brave_api_key)}\n'
-        f'serpapi_api_key = "{config.search.serpapi_api_key}"\n\n'
-        # [browser] / [voice] sections removed during T0.9 purge.
+        # [search] / [browser] / [voice] sections removed during T0.9 purge.
         "[ui]\n"
         f"show_debug = {'true' if config.ui.show_debug else 'false'}\n"
         f'thinking_mode = {_toml_str(config.ui.thinking_mode)}\n'
@@ -333,9 +314,9 @@ def save_config(config: AppConfig) -> Path:
     # final rename.
     with _SAVE_LOCK:
         tmp = path.with_name(f".{path.name}.tmp{os.getpid()}")
-        # config.toml carries google / brave / serpapi API keys. Write the
-        # temp file 0600 BEFORE the rename so the final file is never
-        # world-readable, not even for the instant between rename and chmod.
+        # config.toml can hold sensitive settings. Write the temp file 0600
+        # BEFORE the rename so the final file is never world-readable, not even
+        # for the instant between rename and chmod.
         write_private(tmp, content)
         os.replace(tmp, path)
         chmod_quiet(path, 0o600)
@@ -347,8 +328,8 @@ def load_config() -> AppConfig:
     path = get_config_path()
     if not path.exists():
         init_config_file()
-    # Repair an install from before config.toml was written 0600: this file
-    # holds google / brave / serpapi API keys and was created world-readable.
+    # Repair an install from before config.toml was written 0600: it may have
+    # been created world-readable.
     chmod_quiet(path, 0o600)
     # A config file that fails to parse (hand-edited, or written by an old
     # save_config that didn't escape string values) must not crash launch —
@@ -361,8 +342,7 @@ def load_config() -> AppConfig:
         except Exception:
             data = {}
     runtime_data = data.get("runtime", {})
-    search_data = data.get("search", {})
-    # browser / voice sections removed during T0.9 purge
+    # search / browser / voice sections removed during T0.9 purge
     ui_data = data.get("ui", {})
     runtime = RuntimeConfig(
         provider=os.environ.get("LOCALCODE_PROVIDER", runtime_data.get("provider", "llama_cpp")),
@@ -425,14 +405,7 @@ def load_config() -> AppConfig:
         request_timeout_seconds=int(os.environ.get("LOCALCODE_REQUEST_TIMEOUT_SECONDS", runtime_data.get("request_timeout_seconds", 120))),
         max_retries=int(os.environ.get("LOCALCODE_MAX_RETRIES", runtime_data.get("max_retries", 2))),
     )
-    search = SearchConfig(
-        provider=os.environ.get("LOCALCODE_SEARCH_PROVIDER", search_data.get("provider", "duckduckgo")),
-        google_api_key=os.environ.get("LOCALCODE_GOOGLE_API_KEY", search_data.get("google_api_key", "")),
-        google_cx=os.environ.get("LOCALCODE_GOOGLE_CX", search_data.get("google_cx", "")),
-        brave_api_key=os.environ.get("LOCALCODE_BRAVE_API_KEY", search_data.get("brave_api_key", "")),
-        serpapi_api_key=os.environ.get("LOCALCODE_SERPAPI_API_KEY", search_data.get("serpapi_api_key", "")),
-    )
-    # browser / voice config loaders removed during T0.9 purge.
+    # search / browser / voice config loaders removed during T0.9 purge.
     ui = UIConfig(
         show_debug=str(os.environ.get("LOCALCODE_SHOW_DEBUG", ui_data.get("show_debug", False))).lower() in {"1", "true", "yes", "on"},
         thinking_mode=os.environ.get("LOCALCODE_THINKING_MODE", ui_data.get("thinking_mode", "summary")),
@@ -473,7 +446,7 @@ def load_config() -> AppConfig:
         if not runtime.base_url or "11434" in runtime.base_url:
             runtime.base_url = "http://localhost:8081"
 
-    config = AppConfig(runtime=runtime, search=search,
+    config = AppConfig(runtime=runtime,
                        ui=ui, safety=safety, logging=logging_cfg,
                        telemetry=telemetry_cfg)
 

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/errors.py

@@ -97,9 +97,6 @@ _REGISTRY: list[ErrorCode] = [
               cause="model"),
     ErrorCode("E2110", "Tool denied by permission policy",
               "The user (or session policy) declined this tool call.", cause="user"),
-    ErrorCode("E2111", "Tool blocked by hook",
-              "A configured hook in ~/.localcode/hooks.toml refused the tool call.",
-              cause="user"),
 
     # E3xxx — Runtime / model
     ErrorCode("E3101", "The model stopped responding too early",

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/toolkit.py

@@ -940,14 +940,7 @@ class LocalCodeToolkit:
     # ── Web search implementations ───────────────────────────────────────
 
     def _web_search(self, query: str, max_results: int = 5) -> str:
-        provider = self.config.search.provider.lower()
-        if provider == "google":
-            return self._google_search(query, max_results)
-        if provider == "brave":
-            return self._brave_search(query, max_results)
-        if provider == "serpapi":
-            return self._serpapi_search(query, max_results)
-        # Default: try DuckDuckGo, fall back to scraping if needed
+        # Try DuckDuckGo, fall back to scraping if needed.
         result = self._duckduckgo_search(query, max_results)
         if result == "No results found." or "Search error" in result:
             # Fallback: try bash curl to get a quick answer
@@ -1017,46 +1010,6 @@ class LocalCodeToolkit:
             return f"Search error: {exc}"
         return "\n\n".join(results) if results else "No results found."
 
-    def _google_search(self, query: str, max_results: int = 5) -> str:
-        if not self.config.search.google_api_key or not self.config.search.google_cx:
-            return "Google search not configured. Set LOCALCODE_GOOGLE_API_KEY and LOCALCODE_GOOGLE_CX."
-        response = httpx.get(
-            "https://www.googleapis.com/customsearch/v1",
-            params={"key": self.config.search.google_api_key, "cx": self.config.search.google_cx, "q": query, "num": max_results},
-            timeout=20.0,
-        )
-        response.raise_for_status()
-        items = response.json().get("items", [])
-        results = [f"{item.get('title', '')}\n{item.get('snippet', '')}\n{item.get('link', '')}" for item in items]
-        return "\n\n".join(results) if results else "No results found."
-
-    def _brave_search(self, query: str, max_results: int = 5) -> str:
-        if not self.config.search.brave_api_key:
-            return "Brave search not configured. Set LOCALCODE_BRAVE_API_KEY."
-        response = httpx.get(
-            "https://api.search.brave.com/res/v1/web/search",
-            params={"q": query, "count": max_results},
-            headers={"X-Subscription-Token": self.config.search.brave_api_key},
-            timeout=20.0,
-        )
-        response.raise_for_status()
-        results_data = response.json().get("web", {}).get("results", [])
-        results = [f"{item.get('title', '')}\n{item.get('description', '')}\n{item.get('url', '')}" for item in results_data]
-        return "\n\n".join(results) if results else "No results found."
-
-    def _serpapi_search(self, query: str, max_results: int = 5) -> str:
-        if not self.config.search.serpapi_api_key:
-            return "SerpAPI not configured. Set LOCALCODE_SERPAPI_API_KEY."
-        response = httpx.get(
-            "https://serpapi.com/search.json",
-            params={"engine": "google", "q": query, "api_key": self.config.search.serpapi_api_key, "num": max_results},
-            timeout=20.0,
-        )
-        response.raise_for_status()
-        items = response.json().get("organic_results", [])
-        results = [f"{item.get('title', '')}\n{item.get('snippet', '')}\n{item.get('link', '')}" for item in items]
-        return "\n\n".join(results) if results else "No results found."
-
     # ── Plugin & MCP ─────────────────────────────────────────────────────
 
     def _register_plugin_tools(self) -> None:
@@ -1273,17 +1226,7 @@ class LocalCodeToolkit:
             client.close()
 
     def search_status(self) -> tuple[str, str]:
-        provider = self.config.search.provider.lower()
-        if provider == "google":
-            ok = bool(self.config.search.google_api_key and self.config.search.google_cx)
-            return provider, "configured" if ok else "missing_api_key_or_cx"
-        if provider == "brave":
-            ok = bool(self.config.search.brave_api_key)
-            return provider, "configured" if ok else "missing_api_key"
-        if provider == "serpapi":
-            ok = bool(self.config.search.serpapi_api_key)
-            return provider, "configured" if ok else "missing_api_key"
-        return provider, "configured"
+        return "duckduckgo", "configured"
 
     def diagnostics(self) -> list[str]:
         rows: list[str] = []

{localcode-0.3.61 → localcode-0.3.63}/src/localcode/tui/app.py

@@ -238,10 +238,9 @@ class LocalCodeTUI(App):
                 # Even if config load fails (truly fresh install),
                 # build a minimal default so the screen has SOMETHING
                 # to read.
-                from ..config import AppConfig, RuntimeConfig, SearchConfig, UIConfig, SafetyConfig, LoggingConfig
+                from ..config import AppConfig, RuntimeConfig, UIConfig, SafetyConfig, LoggingConfig
                 self.config = AppConfig(
                     runtime=RuntimeConfig(),
-                    search=SearchConfig(),
                     ui=UIConfig(),
                     safety=SafetyConfig(),
                     logging=LoggingConfig(),