fix(logging): harden PromptLogger against unwritable log dir

Backport of the prompt_logger.py half of 4b87c36 (cherry-picked from
deploy/mcp) onto the branch that feeds hf-test.

4b87c36 fixed a prod MCP outage: PromptLogger.__init__ did an unguarded
mkdir on <script_dir>/logs/prompts. HF Spaces run the container as a
non-root user inside a root-owned WORKDIR and logs/ is gitignored, so it
raised PermissionError: '/app/logs' and failed every MCP build.

prompt_logger.py is SHARED code, so the app Spaces carried the same latent
bug — it just never fired there because only the MCP path constructed a
PromptLogger. This closes that gap: the log dir is resolved (module dir ->
temp -> memory-only) and every read/write degrades instead of raising.

The mcp_server.py half of 4b87c36 is deliberately NOT taken. It guards the
run-logger block added by 47edf58, which does not exist on this branch;
pulling it in would import an unrelated feature through a conflict
resolution. That guard stays on deploy/mcp where the code it protects lives.

Regression coverage: tests/test_prompt_logger_readonly.py (3 tests).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

prompt_logger.py

@@ -30,6 +30,8 @@ Usage:
 
 import os
 import json
+import sys
+import tempfile
 import time
 from datetime import datetime
 from pathlib import Path
@@ -44,25 +46,48 @@ class PromptLogger:
         self.entries: List[Dict] = []
         self.call_count = 0
 
-        # Create log directory
-        script_dir = Path(__file__).parent
-        self.log_dir = script_dir / "logs" / "prompts"
-        self.log_dir.mkdir(parents=True, exist_ok=True)
-        self.log_file = self.log_dir / f"{self.session_id}.md"
+        # Locate a writable log directory. This must NEVER raise: on HF Spaces
+        # the container runs as a non-root user inside a root-owned WORKDIR, so
+        # creating ./logs raises PermissionError and would otherwise kill the
+        # whole build. Fall back to the system temp dir, then to memory-only
+        # (log_file = None) — prompt logging is diagnostics, never load-bearing.
+        self.log_dir = None
+        self.log_file = None
+        candidates = [
+            Path(__file__).parent / "logs" / "prompts",
+            Path(tempfile.gettempdir()) / "demoprep" / "logs" / "prompts",
+        ]
+        for candidate in candidates:
+            try:
+                candidate.mkdir(parents=True, exist_ok=True)
+                self.log_dir = candidate
+                self.log_file = candidate / f"{self.session_id}.md"
+                break
+            except Exception as e:
+                print(f"[PromptLogger] Log dir {candidate} unusable: {e}", file=sys.stderr)
+        if self.log_file is None:
+            print("[PromptLogger] No writable log dir — prompt logging is memory-only.",
+                  file=sys.stderr)
 
         # Write header
         self._write_header()
 
     def _write_header(self):
-        """Write markdown header to log file."""
+        """Write markdown header to log file. Never raises."""
+        if self.log_file is None:
+            return
         header = f"""# Prompt Log — Session {self.session_id}
 **Started:** {datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
 
 ---
 
 """
-        with open(self.log_file, "w") as f:
-            f.write(header)
+        try:
+            with open(self.log_file, "w") as f:
+                f.write(header)
+        except Exception as e:
+            print(f"[PromptLogger] Header write failed, disabling file log: {e}", file=sys.stderr)
+            self.log_file = None
 
     def log_prompt(
         self,
@@ -126,7 +151,9 @@ class PromptLogger:
         )
 
     def _append_entry(self, entry: Dict):
-        """Append a formatted entry to the markdown log file."""
+        """Append a formatted entry to the markdown log file. Never raises."""
+        if self.log_file is None:
+            return
         n = entry["entry_num"]
         stage = entry["stage"]
         model = entry["model"]
@@ -185,8 +212,12 @@ class PromptLogger:
         lines.append("---")
         lines.append("")
 
-        with open(self.log_file, "a") as f:
-            f.write("\n".join(lines))
+        try:
+            with open(self.log_file, "a") as f:
+                f.write("\n".join(lines))
+        except Exception as e:
+            print(f"[PromptLogger] Entry write failed, disabling file log: {e}", file=sys.stderr)
+            self.log_file = None
 
     def get_summary(self) -> str:
         """Return a text summary of all prompts logged this session."""
@@ -229,12 +260,14 @@ class PromptLogger:
         lines.append(
             f"**Totals:** {total_tokens_in} tokens in, {total_tokens_out} tokens out, {total_duration}ms"
         )
-        lines.append(f"**Log file:** `{self.log_file}`")
+        lines.append(f"**Log file:** `{self.log_file or 'memory-only (no writable log dir)'}`")
 
         return "\n".join(lines)
 
     def get_full_log(self) -> str:
         """Return the full markdown log file contents for display in Gradio."""
+        if self.log_file is None:
+            return "Prompt log is memory-only (no writable log dir) — see summary."
         try:
             return self.log_file.read_text()
         except Exception:

tests/test_prompt_logger_readonly.py

@@ -0,0 +1,66 @@
+"""
+Regression tests for PromptLogger under an unwritable log directory.
+
+Outage 2026-08-25: HF Spaces run the container as a non-root user inside a
+root-owned WORKDIR, so `<script_dir>/logs` cannot be created. PromptLogger's
+unguarded mkdir raised PermissionError, which propagated out of
+_create_run_loggers() and failed EVERY MCP build.
+
+Prompt logging is diagnostics — it must degrade, never take a build down.
+"""
+
+from pathlib import Path
+
+import pytest
+
+from prompt_logger import PromptLogger
+
+
+def test_unwritable_primary_dir_falls_back(monkeypatch, tmp_path):
+    """mkdir denied on the module dir -> falls back to temp, still logs to a file."""
+    real_mkdir = Path.mkdir
+    blocked = Path(__file__).parent.parent / "logs"
+
+    def selective_mkdir(self, *args, **kwargs):
+        if str(self).startswith(str(blocked)):
+            raise PermissionError(f"[Errno 13] Permission denied: '{self}'")
+        return real_mkdir(self, *args, **kwargs)
+
+    monkeypatch.setattr(Path, "mkdir", selective_mkdir)
+
+    logger = PromptLogger(session_id="fallback_test")
+    assert logger.log_file is not None
+    assert str(blocked) not in str(logger.log_file)
+    # Logging still works end to end
+    logger.log_prompt(stage="ddl", model="m",
+                      messages=[{"role": "user", "content": "hi"}],
+                      response_text="ok")
+    assert len(logger.entries) == 1
+
+
+def test_no_writable_dir_degrades_to_memory(monkeypatch):
+    """mkdir denied everywhere -> memory-only, and nothing raises."""
+    def always_denied(self, *args, **kwargs):
+        raise PermissionError("denied everywhere")
+
+    monkeypatch.setattr(Path, "mkdir", always_denied)
+
+    logger = PromptLogger(session_id="memory_only_test")
+    assert logger.log_file is None
+    # Every public path must stay non-fatal
+    logger.log_prompt(stage="ddl", model="m",
+                      messages=[{"role": "user", "content": "hi"}],
+                      response_text="ok")
+    assert len(logger.entries) == 1
+    assert "memory-only" in logger.get_full_log()
+    assert "Log file:" in logger.get_summary()
+
+
+def test_construction_never_raises_on_oserror(monkeypatch):
+    """Any OSError from mkdir (not just PermissionError) must be survivable."""
+    def raise_oserror(self, *args, **kwargs):
+        raise OSError("read-only file system")
+
+    monkeypatch.setattr(Path, "mkdir", raise_oserror)
+    logger = PromptLogger(session_id="oserror_test")  # must not raise
+    assert logger.log_file is None