refactor(agent): rename agent_cli to metadata_ops, strip temp debug logs

- Rename py/agent_cli/ -> py/metadata_ops/ (module was never agent-related)
- Rename tests/agent_cli/ -> tests/metadata_ops/
- Remove 9 low-value/debug INFO log points across agent_handlers.py,
  agent_service.py, llm_service.py, and metadata_ops/__init__.py
- Keep LLM raw response at DEBUG level for diagnostics
- Consolidate per-model progress + LLM result into single concise
  log line with basename instead of full path
- Update package/class/method docstrings to clarify this is a
  pipeline infrastructure, not a true agent loop

py/metadata_ops/__init__.py

@@ -1,4 +1,4 @@
-"""Agent CLI — thin in-process wrappers around LoRA Manager internal services.
+"""Metadata operations — thin in-process wrappers around LoRA Manager internal services.
 
 All functions are simple Python async functions that delegate to the
 appropriate internal service.  They use **relative imports** within the
@@ -7,15 +7,15 @@ risk of double import or circular dependencies.
 
 Usage (in-process, primary)::
 
-    from py.agent_cli import list_base_models, read_metadata
+    from py.metadata_ops import list_base_models, read_metadata
 
     models = await list_base_models()
     meta   = await read_metadata("/path/to/model.safetensors")
 
 Usage (subprocess, debugging / external)::
 
-    python -m py.agent_cli base-models list
-    python -m py.agent_cli metadata read /path/to/model.safetensors
+    python -m py.metadata_ops base-models list
+    python -m py.metadata_ops metadata read /path/to/model.safetensors
 """
 
 from __future__ import annotations
@@ -214,7 +214,6 @@ async def download_preview(
             )
             with open(output_path, "wb") as f:
                 f.write(optimized_data)
-            logger.info("Preview downloaded and optimised for %s", model_path)
             return output_path
         except Exception as exc:
             logger.warning("Preview optimisation failed, saving raw: %s", exc)
@@ -224,7 +223,6 @@ async def download_preview(
     try:
         ok, _ = await downloader.download_file(url, output_path, use_auth=False)
         if ok:
-            logger.info("Preview downloaded (fallback) for %s", model_path)
             return output_path
     except Exception as exc:
         logger.warning("Preview fallback download failed for %s: %s", model_path, exc)

py/metadata_ops/__main__.py

@@ -1,17 +1,12 @@
-"""Subprocess entry point for AgentCLI (debugging / external use).
+"""Subprocess entry point for ``metadata_ops`` (debugging / external use).
 
 Usage::
 
-    python -m py.agent_cli base-models list [--limit N]
-    python -m py.agent_cli metadata read <path>
-    python -m py.agent_cli metadata update <path> --json '{...}'
-    python -m py.agent_cli preview download <path> --url <url>
-    python -m py.agent_cli cache refresh <path>
-
-NOTE: This is an **optional** convenience wrapper.  The primary consumer of
-AgentCLI is the :mod:`AgentService` (in-process).  This entry point exists
-for manual debugging and future integration with subprocess-based agent
-frameworks.
+    python -m py.metadata_ops base-models list [--limit N]
+    python -m py.metadata_ops metadata read <path>
+    python -m py.metadata_ops metadata update <path> --json '{...}'
+    python -m py.metadata_ops preview download <path> --url <url>
+    python -m py.metadata_ops cache refresh <path>
 """
 
 from __future__ import annotations

py/routes/handlers/agent_handlers.py

@@ -99,12 +99,11 @@ class AgentHandler:
         # Launch execution in the background
         progress_reporter = AgentProgressReporter()
         logger.info(
-            "LLM enrichment '%s' starting for %d model(s) in background task",
+            "LLM enrichment '%s' starting for %d model(s)",
             skill_name, len(model_paths),
         )
 
         async def _run() -> None:
-            logger.info("Background task started for enrichment '%s'", skill_name)
             try:
                 result = await service.execute_skill(
                     skill_name=skill_name,
@@ -137,8 +136,7 @@ class AgentHandler:
                 )
 
         # Fire and forget — progress comes via WebSocket
-        task = asyncio.create_task(_run())
-        logger.info("LLM enrichment '%s' background task created (id=%s)", skill_name, task)
+        asyncio.create_task(_run())
 
         return web.json_response(
             {

py/services/agent/__init__.py

@@ -1,8 +1,12 @@
-"""Agent-powered skill system for LoRA Manager.
+"""LLM-powered metadata enrichment pipeline infrastructure.
 
-This package provides the orchestration layer for LLM/agent-powered features.
+This package provides the orchestration layer for LLM-powered features.
 Skills define *what* to do (prompt template).  The :class:`AgentService`
 handles *how* (LLM calls, context gathering, validation, progress).
+
+NOTE: The current implementation is a code-driven pipeline, not a true
+agent loop.  Future agent orchestration (LLM-driven tool selection) will
+live alongside this package with its own namespace.
 """
 
 from __future__ import annotations

py/services/agent/agent_service.py

@@ -1,16 +1,17 @@
-"""Agent orchestration service.
+"""Pipeline orchestration service.
 
-The :class:`AgentService` coordinates skill execution:
+The :class:`AgentService` coordinates LLM-powered pipeline execution:
 
-1. Look up the skill in :class:`SkillRegistry`
-2. Validate input against the skill's ``input_schema``
-3. Prepare context via :mod:`~py.agent_cli` (read metadata, list base models, fetch HF README)
+1. Look up the pipeline definition in :class:`SkillRegistry`
+2. Validate input against its ``input_schema``
+3. Prepare context via :mod:`~py.metadata_ops` (read metadata, list base models, fetch HF README)
 4. If ``llm_required``: call :class:`LLMService` with the rendered prompt
-5. Post-process via :class:`PostProcessor` (delegates I/O to :mod:`~py.agent_cli`)
+5. Post-process via :class:`PostProcessor` (delegates I/O to :mod:`~py.metadata_ops`)
 6. Broadcast progress and completion via :class:`WebSocketManager`
 
-Skills define *what* to do (prompt template).  The AgentService handles *how*
-(LLM calls, context gathering, validation, progress).
+Pipeline definitions (*skills*) describe *what* to do (prompt template).
+The AgentService handles *how* (LLM calls, context gathering, validation,
+progress).
 """
 
 from __future__ import annotations
@@ -202,11 +203,11 @@ class AgentService:
         input_data: Dict[str, Any],
         progress_callback: Optional[AgentProgressReporter] = None,
     ) -> SkillResult:
-        """Execute an agent skill.
+        """Execute a pipeline (skill) on the given models.
 
         Args:
-            skill_name: Name of the skill to execute
-            input_data: Input validated against the skill's ``input_schema``
+            skill_name: Name of the pipeline to execute
+            input_data: Input validated against the pipeline's ``input_schema``
             progress_callback: Optional WebSocket progress reporter
 
         Returns:
@@ -214,7 +215,6 @@ class AgentService:
         """
 
         registry = await self._ensure_registry()
-        logger.info("execute_skill '%s': looking up skill", skill_name)
         skill = registry.get_skill(skill_name)
         if skill is None:
             return SkillResult(
@@ -246,7 +246,6 @@ class AgentService:
         errors: List[str] = []
         post_processor = PostProcessor()
 
-        logger.info("execute_skill '%s': starting with %d model(s)", skill_name, total)
         await self._emit_progress(
             progress_callback, skill_name, status="started",
             total=total, processed=0, success=0,
@@ -256,13 +255,14 @@ class AgentService:
         llm_configured = llm.is_configured() if skill.llm_required else True
 
         for model_path in model_paths:
+            model_filename = os.path.basename(model_path)
             logger.info(
-                "execute_skill '%s': processing model %d/%d: %s",
-                skill_name, processed + 1, total, model_path,
+                "[%s] [%d/%d] %s",
+                skill_name, processed + 1, total, model_filename,
             )
             updated_data: Dict[str, Any] = {}
             try:
-                from ...agent_cli import read_metadata
+                from ...metadata_ops import read_metadata
                 metadata = await read_metadata(model_path)
 
                 prompt_vars: Dict[str, Any] = {"model_path": model_path}
@@ -275,10 +275,6 @@ class AgentService:
                 if skill.llm_required and llm_configured:
                     prompt_template = registry.load_prompt(skill_name)
                     rendered = _render_prompt(prompt_template, prompt_vars)
-                    logger.info(
-                        "execute_skill '%s': LLM call for %s (prompt=%d chars)",
-                        skill_name, model_path, len(rendered),
-                    )
                     llm_response = await llm.chat_completion_json(
                         system_prompt=prompt_vars.get(
                             "system_prompt",
@@ -286,6 +282,13 @@ class AgentService:
                         ),
                         user_prompt=rendered,
                     )
+                    if llm_response:
+                        logger.info(
+                            "[%s] [%d/%d] %s → base_model=%s confidence=%s",
+                            skill_name, processed + 1, total, model_filename,
+                            (llm_response.get("base_model") or "?")[:50],
+                            llm_response.get("confidence", "?"),
+                        )
 
                 model_result = await post_processor.process(
                     skill_name=skill_name,
@@ -329,7 +332,6 @@ class AgentService:
             summary=f"Processed {processed}/{total} models, {success_count} succeeded",
         )
 
-        logger.info("execute_skill '%s': done — %s", skill_name, result.summary)
         await self._emit_progress(
             progress_callback, skill_name, status="completed",
             total=total, processed=processed, success=success_count,
@@ -366,7 +368,7 @@ class AgentService:
         base models, loads user priority tags, and returns a dict that maps to
         ``{{variable}}`` placeholders in ``prompt.md``.
         """
-        from ...agent_cli import identify_model_type, list_base_models
+        from ...metadata_ops import identify_model_type, list_base_models
         from ..settings_manager import SettingsManager
 
         context: Dict[str, Any] = {
@@ -411,10 +413,6 @@ class AgentService:
                 cleaned = clean_readme_for_llm(readme) if readme else ""
             context["readme_content"] = cleaned if cleaned else "(README not available)"
             context["readme_content_full"] = readme or ""
-            logger.info(
-                "Cleaned README for %s (%d chars): ---BEGIN---\n%s\n---END---",
-                repo, len(cleaned), cleaned[:800] if cleaned else "(empty)",
-            )
 
         try:
             raw_models = await list_base_models()

py/services/agent/post_processor.py

@@ -1,11 +1,11 @@
 """Post-processing engine for skill pipeline outputs.
 
 The :class:`PostProcessor` takes the LLM's structured JSON output and applies
-it to a model's on-disk metadata via the :mod:`~py.agent_cli` functions.
+it to a model's on-disk metadata via the :mod:`~py.metadata_ops` functions.
 
 It handles all the skill-specific business logic — conditions, transformations,
 and orchestration of multiple side-effects (write metadata, download preview,
-refresh cache).  All actual I/O is delegated to :mod:`~py.agent_cli`.
+refresh cache).  All actual I/O is delegated to :mod:`~py.metadata_ops`.
 """
 
 from __future__ import annotations
@@ -30,7 +30,7 @@ class PostProcessor:
             skill_name="enrich_hf_metadata",
             model_path="/path/to/model.safetensors",
             llm_output={...},
-            metadata={...},    # from agent_cli.read_metadata()
+            metadata={...},    # from metadata_ops.read_metadata()
         )
     """
 
@@ -73,7 +73,7 @@ class PostProcessor:
         metadata: Dict[str, Any],
         readme_content: str = "",
     ) -> Dict[str, Any]:
-        from ...agent_cli import (
+        from ...metadata_ops import (
             apply_metadata_updates,
             download_preview,
             refresh_cache,

py/services/llm_service.py

@@ -521,15 +521,9 @@ class LLMService:
 
         try:
             parsed = json.loads(result["content"])
-            logger.info(
-                "LLM response base_model=%s tags=%s confidence=%s",
-                parsed.get("base_model", "?")[:50],
-                parsed.get("tags", []),
-                parsed.get("confidence", "?"),
-            )
-            logger.info(
+            logger.debug(
                 "LLM raw content: %s",
-                (result.get("content") or "")[:1200],
+                json.dumps(parsed, ensure_ascii=False)[:2000],
             )
             return parsed
         except (json.JSONDecodeError, TypeError) as exc: