Initial commit: Conflict Checker

Cross-discipline design-contradiction checker for construction drawing
sets. Standalone tool broken out from Iron_Bid; a pipeline stage may
later fold back into Iron_Bid.

Pipeline: PDF->images -> per-sheet assertion extraction -> deterministic
clustering by location -> per-cluster reasoning -> report.
Includes CLI (cli/run_check.py) and web UI (backend/main.py).

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

backend/jobs.py

@@ -0,0 +1,166 @@
+"""
+jobs.py - Lightweight async job registry for conflict checks.
+
+A conflict check takes minutes, so the HTTP request must not block on it. Each
+upload becomes a job that runs on a background thread; the client gets a job_id
+immediately and can either poll GET /jobs/{id} or just close the page and wait
+for the completion email.
+
+State is in-memory (fine for a single-user tool); the report is also persisted
+to outputs/<job_id>/ so results survive a restart even though live status does
+not. No external queue/DB.
+"""
+
+import os
+import time
+import uuid
+import shutil
+import threading
+from typing import Dict, Optional
+
+from backend import config
+from backend.pipeline.runner import run_pipeline
+from backend.email_sender import send_conflict_report
+
+_jobs: Dict[str, Dict] = {}
+_lock = threading.Lock()
+
+
+def _set(job_id: str, **fields) -> None:
+    with _lock:
+        _jobs[job_id].update(fields)
+
+
+def create_job(pdf_path: str, source_filename: str, email: Optional[str] = None,
+               project_input: Optional[Dict] = None, text_local: bool = False) -> str:
+    """Register a job and kick off its background thread. Returns the job_id."""
+    job_id = uuid.uuid4().hex[:12]
+    with _lock:
+        _jobs[job_id] = {
+            "job_id": job_id,
+            "status": "queued",          # queued -> running -> done | error
+            "source": source_filename,
+            "email": email or None,
+            "project_input": project_input or {},
+            "text_local": text_local,
+            "stage": None,
+            "created_at": time.time(),
+            "finished_at": None,
+            "report": None,
+            "error": None,
+        }
+    threading.Thread(target=_run, args=(job_id, pdf_path, project_input, text_local),
+                     daemon=True).start()
+    return job_id
+
+
+def _run(job_id: str, pdf_path: str, project_input: Optional[Dict] = None,
+         text_local: bool = False) -> None:
+    out_dir = os.path.join(config.OUTPUT_DIR, job_id)
+    try:
+        _set(job_id, status="running")
+        # Keep a copy of the source PDF so its sheets can be viewed later.
+        os.makedirs(out_dir, exist_ok=True)
+        shutil.copy2(pdf_path, os.path.join(out_dir, "source.pdf"))
+        report = run_pipeline(
+            pdf_path,
+            out_dir=out_dir,
+            on_stage=lambda name: _set(job_id, stage=name),
+            project_input=project_input,
+            source_name=_jobs[job_id].get("source"),
+            text_local=text_local,
+        )
+        _set(job_id, status="done", report=report, finished_at=time.time(), stage=None)
+        _notify(job_id, report, out_dir)
+    except Exception as e:
+        print(f"[Jobs] Job {job_id} failed: {e}")
+        _set(job_id, status="error", error=str(e), finished_at=time.time())
+        _notify_error(job_id)
+    finally:
+        try:
+            os.remove(pdf_path)
+        except OSError:
+            pass
+
+
+def _notify(job_id: str, report: Dict, out_dir: str) -> None:
+    email = _jobs[job_id].get("email")
+    if not email:
+        return
+    results_url = f"{config.APP_BASE_URL.rstrip('/')}/?job={job_id}"
+    attachments = [
+        os.path.join(out_dir, "report.md"),
+        os.path.join(out_dir, "conflicts.json"),
+        os.path.join(out_dir, "validated_issues.json"),
+        os.path.join(out_dir, "rfis.json"),
+    ]
+    send_conflict_report(email, report, results_url=results_url, attachments=attachments)
+
+
+def _notify_error(job_id: str) -> None:
+    job = _jobs[job_id]
+    email = job.get("email")
+    if not email:
+        return
+    # Reuse the report mailer with a minimal error-shaped payload.
+    err_report = {
+        "source": job.get("source", ""),
+        "summary": {"conflicts_found": 0, "by_severity": {}, "disciplines": []},
+    }
+    try:
+        from backend.email_sender import _smtp_ready, _send
+        from email.message import EmailMessage
+        if not _smtp_ready():
+            print(f"[Email] SMTP not configured - skipping error notice to {email}")
+            return
+        msg = EmailMessage()
+        msg["Subject"] = f"Conflict Checker - {job.get('source','')} - run FAILED"
+        msg["From"] = config.SMTP_FROM or config.SMTP_USER
+        msg["To"] = email
+        msg.set_content(
+            "Your conflict check did not complete.\n\n"
+            f"Drawing set: {job.get('source','')}\n"
+            f"Error: {job.get('error','unknown')}\n\n"
+            "Generated by Conflict Checker"
+        )
+        _send(msg)
+    except Exception as e:
+        print(f"[Email] Failed to send error notice: {e}")
+
+
+def get_job(job_id: str) -> Optional[Dict]:
+    """Public job view. Includes the full report only when done.
+
+    Falls back to the on-disk conflicts.json when the job isn't in the
+    in-memory registry (e.g. after a server restart).
+    """
+    with _lock:
+        job = _jobs.get(job_id)
+        if job:
+            return dict(job)
+
+    # Try loading from disk
+    report_path = os.path.join(config.OUTPUT_DIR, job_id, "conflicts.json")
+    if not os.path.isfile(report_path):
+        return None
+    try:
+        import json
+        with open(report_path, encoding="utf-8") as f:
+            report = json.load(f)
+        source_pdf = os.path.join(config.OUTPUT_DIR, job_id, "source.pdf")
+        return {
+            "job_id":       job_id,
+            "status":       "done",
+            "source":       report.get("source", os.path.basename(report_path)),
+            "email":        None,
+            "project_input": report.get("project_input", {}),
+            "text_local":   report.get("summary", {}).get("text_backend") == "local",
+            "stage":        None,
+            "created_at":   os.path.getmtime(source_pdf) if os.path.isfile(source_pdf) else None,
+            "finished_at":  os.path.getmtime(report_path),
+            "report":       report,
+            "error":        None,
+        }
+    except Exception as e:
+        print(f"[Jobs] Failed to load job {job_id} from disk: {e}")
+        return None