divapply 0.4.2__py3-none-any.whl

divapply/apply/launcher.py

@@ -0,0 +1,1404 @@
+"""Apply orchestration: acquire jobs, spawn Claude Code sessions, track results.
+
+This is the main entry point for the apply pipeline. It pulls jobs from
+the database, launches Chrome + Claude Code for each one, parses the
+result, and updates the database. Supports parallel workers via --workers.
+"""
+
+import atexit
+import json
+import logging
+import os
+import platform
+import re
+import shlex
+import signal
+import subprocess
+import sys
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+from pathlib import Path
+
+from rich.console import Console
+from rich.live import Live
+
+from divapply import config
+from divapply.database import get_connection
+from divapply.apply import chrome, dashboard, prompt as prompt_mod
+from divapply.apply.chrome import (
+    launch_chrome, cleanup_worker, kill_all_chrome,
+    reset_worker_dir, cleanup_on_exit, _kill_process_tree,
+    setup_worker_profile,
+    BASE_CDP_PORT,
+)
+from divapply.apply.dashboard import (
+    init_worker, update_state, add_event, get_state,
+    render_full, get_totals,
+)
+
+logger = logging.getLogger(__name__)
+
+# Blocked sites loaded from config/sites.yaml
+def _load_blocked():
+    from divapply.config import load_blocked_sites
+    return load_blocked_sites()
+
+# How often to poll the DB when the queue is empty (seconds)
+POLL_INTERVAL = config.DEFAULTS["poll_interval"]
+
+# Thread-safe shutdown coordination
+_stop_event = threading.Event()
+
+# Track active Claude Code processes for skip (Ctrl+C) handling
+_claude_procs: dict[int, subprocess.Popen] = {}
+_claude_lock = threading.Lock()
+
+# Register cleanup on exit
+atexit.register(cleanup_on_exit)
+if platform.system() != "Windows":
+    signal.signal(signal.SIGTERM, lambda *_: sys.exit(0))
+
+
+# ---------------------------------------------------------------------------
+# MCP config
+# ---------------------------------------------------------------------------
+
+def _make_mcp_config(
+    cdp_port: int,
+    browser: str = "firefox",
+    worker_profile_dir: Path | None = None,
+    headless: bool = False,
+) -> dict:
+    """Build MCP config dict for a specific browser configuration."""
+    playwright_args = ["@playwright/mcp@0.0.70"]
+    if browser == "chrome":
+        playwright_args.extend([
+            f"--cdp-endpoint=http://localhost:{cdp_port}",
+            f"--viewport-size={config.DEFAULTS['viewport']}",
+        ])
+    else:
+        playwright_args.extend([
+            f"--browser={browser}",
+            f"--viewport-size={config.DEFAULTS['viewport']}",
+        ])
+        if worker_profile_dir is not None:
+            playwright_args.append(f"--user-data-dir={worker_profile_dir}")
+        if headless:
+            playwright_args.append("--headless")
+
+    return {
+        "mcpServers": {
+            "playwright": {
+                "command": "npx",
+                "args": playwright_args,
+            },
+            "gmail": {
+                "command": "npx",
+                "args": ["-y", "@gongrzhe/server-gmail-autoauth-mcp"],
+            },
+        }
+    }
+
+
+# ---------------------------------------------------------------------------
+# Database operations
+# ---------------------------------------------------------------------------
+
+def acquire_job(target_url: str | None = None, min_score: int = 7,
+                worker_id: int = 0) -> dict | None:
+    """Atomically acquire the next job to apply to.
+
+    Args:
+        target_url: Apply to a specific URL instead of picking from queue.
+        min_score: Minimum fit_score threshold.
+        worker_id: Worker claiming this job (for tracking).
+
+    Returns:
+        Job dict or None if the queue is empty.
+    """
+    conn = get_connection()
+    # Load blocked sites BEFORE acquiring the DB lock to avoid file I/O inside transaction
+    blocked_sites, blocked_patterns = _load_blocked()
+    try:
+        conn.execute("BEGIN IMMEDIATE")
+
+        if target_url:
+            like = f"%{target_url.split('?')[0].rstrip('/')}%"
+            row = conn.execute("""
+                SELECT url, title, site, application_url, tailored_resume_path,
+                       fit_score, location, full_description, cover_letter_path
+                FROM jobs
+                WHERE (url = ? OR application_url = ? OR application_url LIKE ? OR url LIKE ?)
+                  AND tailored_resume_path IS NOT NULL
+                  AND (apply_status IS NULL OR apply_status != 'in_progress')
+                LIMIT 1
+            """, (target_url, target_url, like, like)).fetchone()
+        else:
+            # Build parameterized filters to avoid SQL injection
+            params: list = [min_score]
+            site_clause = ""
+            if blocked_sites:
+                placeholders = ",".join("?" * len(blocked_sites))
+                site_clause = f"AND site NOT IN ({placeholders})"
+                params.extend(blocked_sites)
+            url_clauses = ""
+            if blocked_patterns:
+                url_clauses = " ".join(f"AND url NOT LIKE ?" for _ in blocked_patterns)
+                params.extend(blocked_patterns)
+            row = conn.execute(f"""
+                SELECT url, title, site, application_url, tailored_resume_path,
+                       fit_score, location, full_description, cover_letter_path
+                FROM jobs
+                WHERE tailored_resume_path IS NOT NULL
+                  AND (apply_status IS NULL OR apply_status = 'failed')
+                  AND (apply_attempts IS NULL OR apply_attempts < ?)
+                  AND fit_score >= ?
+                  {site_clause}
+                  {url_clauses}
+                ORDER BY fit_score DESC, url
+                LIMIT 1
+            """, [config.DEFAULTS["max_apply_attempts"]] + params).fetchone()
+
+        if not row:
+            conn.rollback()
+            return None
+
+        # Skip manual ATS sites (unsolvable CAPTCHAs)
+        from divapply.config import is_manual_ats
+        apply_url = row["application_url"] or row["url"]
+        if is_manual_ats(apply_url):
+            conn.execute(
+                "UPDATE jobs SET apply_status = 'manual', apply_error = 'manual ATS' WHERE url = ?",
+                (row["url"],),
+            )
+            conn.commit()
+            logger.info("Skipping manual ATS: %s", row["url"][:80])
+            return None
+
+        now = datetime.now(timezone.utc).isoformat()
+        conn.execute("""
+            UPDATE jobs SET apply_status = 'in_progress',
+                           agent_id = ?,
+                           last_attempted_at = ?
+            WHERE url = ?
+        """, (f"worker-{worker_id}", now, row["url"]))
+        conn.commit()
+
+        return dict(row)
+    except Exception:
+        conn.rollback()
+        raise
+
+
+def mark_result(url: str, status: str, error: str | None = None,
+                permanent: bool = False, duration_ms: int | None = None,
+                task_id: str | None = None) -> None:
+    """Update a job's apply status in the database."""
+    conn = get_connection()
+    now = datetime.now(timezone.utc).isoformat()
+    if status == "applied":
+        conn.execute("""
+            UPDATE jobs SET apply_status = 'applied', applied_at = ?,
+                           apply_error = NULL, agent_id = NULL,
+                           apply_duration_ms = ?, apply_task_id = ?
+            WHERE url = ?
+        """, (now, duration_ms, task_id, url))
+    else:
+        if permanent:
+            conn.execute("""
+                UPDATE jobs SET apply_status = ?, apply_error = ?,
+                               apply_attempts = 99, agent_id = NULL,
+                               apply_duration_ms = ?, apply_task_id = ?
+                WHERE url = ?
+            """, (status, error or "unknown", duration_ms, task_id, url))
+        else:
+            conn.execute("""
+                UPDATE jobs SET apply_status = ?, apply_error = ?,
+                               apply_attempts = COALESCE(apply_attempts, 0) + 1,
+                               agent_id = NULL,
+                               apply_duration_ms = ?, apply_task_id = ?
+                WHERE url = ?
+            """, (status, error or "unknown", duration_ms, task_id, url))
+    conn.commit()
+
+
+def release_lock(url: str) -> None:
+    """Release the in_progress lock without changing status."""
+    conn = get_connection()
+    conn.execute(
+        "UPDATE jobs SET apply_status = NULL, agent_id = NULL WHERE url = ? AND apply_status = 'in_progress'",
+        (url,),
+    )
+    conn.commit()
+
+
+# ---------------------------------------------------------------------------
+# Utility modes (--gen, --mark-applied, --mark-failed, --reset-failed)
+# ---------------------------------------------------------------------------
+
+def gen_prompt(target_url: str, min_score: int = 7,
+               model: str = "sonnet", worker_id: int = 0) -> Path | None:
+    """Generate a prompt file and print the Claude CLI command for manual debugging.
+
+    Returns:
+        Path to the generated prompt file, or None if no job found.
+    """
+    job = acquire_job(target_url=target_url, min_score=min_score, worker_id=worker_id)
+    if not job:
+        return None
+
+    # Read resume text
+    resume_path = job.get("tailored_resume_path")
+    txt_path = Path(resume_path).with_suffix(".txt") if resume_path else None
+    resume_text = ""
+    if txt_path and txt_path.exists():
+        resume_text = txt_path.read_text(encoding="utf-8")
+
+    prompt = prompt_mod.build_prompt(job=job, tailored_resume=resume_text)
+
+    # Release the lock so the job stays available
+    release_lock(job["url"])
+
+    # Write prompt file
+    config.ensure_dirs()
+    site_slug = (job.get("site") or "unknown")[:20].replace(" ", "_")
+    prompt_file = config.LOG_DIR / f"prompt_{site_slug}_{job['title'][:30].replace(' ', '_')}.txt"
+    prompt_file.write_text(prompt, encoding="utf-8")
+
+    # Write MCP config for reference
+    port = BASE_CDP_PORT + worker_id
+    mcp_path = config.APP_DIR / f".mcp-apply-{worker_id}.json"
+    mcp_path.write_text(json.dumps(_make_mcp_config(port)), encoding="utf-8")
+
+    return prompt_file
+
+
+def mark_job(url: str, status: str, reason: str | None = None) -> None:
+    """Manually mark a job's apply status in the database.
+
+    Args:
+        url: Job URL to mark.
+        status: Either 'applied' or 'failed'.
+        reason: Failure reason (only for status='failed').
+    """
+    conn = get_connection()
+    now = datetime.now(timezone.utc).isoformat()
+    if status == "applied":
+        conn.execute("""
+            UPDATE jobs SET apply_status = 'applied', applied_at = ?,
+                           apply_error = NULL, agent_id = NULL
+            WHERE url = ?
+        """, (now, url))
+    else:
+        conn.execute("""
+            UPDATE jobs SET apply_status = 'failed', apply_error = ?,
+                           apply_attempts = 99, agent_id = NULL
+            WHERE url = ?
+        """, (reason or "manual", url))
+    conn.commit()
+
+
+def reset_failed() -> int:
+    """Reset all failed jobs so they can be retried.
+
+    Returns:
+        Number of jobs reset.
+    """
+    conn = get_connection()
+    cursor = conn.execute("""
+        UPDATE jobs SET apply_status = NULL, apply_error = NULL,
+                       apply_attempts = 0, agent_id = NULL
+        WHERE apply_status = 'failed'
+          OR (apply_status IS NOT NULL AND apply_status != 'applied'
+              AND apply_status != 'in_progress')
+    """)
+    conn.commit()
+    return cursor.rowcount
+
+
+# ---------------------------------------------------------------------------
+# Per-job execution
+# ---------------------------------------------------------------------------
+
+def run_job(job: dict, port: int, worker_id: int = 0,
+            model: str = "sonnet", dry_run: bool = False) -> tuple[str, int]:
+    """Spawn a Claude Code session for one job application.
+
+    Returns:
+        Tuple of (status_string, duration_ms). Status is one of:
+        'applied', 'expired', 'captcha', 'login_issue',
+        'failed:reason', or 'skipped'.
+    """
+    # Read tailored resume text
+    resume_path = job.get("tailored_resume_path")
+    txt_path = Path(resume_path).with_suffix(".txt") if resume_path else None
+    resume_text = ""
+    if txt_path and txt_path.exists():
+        resume_text = txt_path.read_text(encoding="utf-8")
+
+    # Build the prompt
+    agent_prompt = prompt_mod.build_prompt(
+        job=job,
+        tailored_resume=resume_text,
+        dry_run=dry_run,
+    )
+
+    # Write per-worker MCP config
+    mcp_config_path = config.APP_DIR / f".mcp-apply-{worker_id}.json"
+    mcp_config_path.write_text(json.dumps(_make_mcp_config(port)), encoding="utf-8")
+
+    # Build claude command
+    cmd = [
+        "claude",
+        "--model", model,
+        "-p",
+        "--max-turns", "150",
+        "--mcp-config", str(mcp_config_path),
+        "--permission-mode", "bypassPermissions",
+        "--no-session-persistence",
+        "--disallowedTools", (
+            "mcp__gmail__draft_email,mcp__gmail__modify_email,"
+            "mcp__gmail__delete_email,mcp__gmail__download_attachment,"
+            "mcp__gmail__batch_modify_emails,mcp__gmail__batch_delete_emails,"
+            "mcp__gmail__create_label,mcp__gmail__update_label,"
+            "mcp__gmail__delete_label,mcp__gmail__get_or_create_label,"
+            "mcp__gmail__list_email_labels,mcp__gmail__create_filter,"
+            "mcp__gmail__list_filters,mcp__gmail__get_filter,"
+            "mcp__gmail__delete_filter"
+        ),
+        "--output-format", "stream-json",
+        "--verbose", "-",
+    ]
+
+    env = os.environ.copy()
+    env.pop("CLAUDECODE", None)
+    env.pop("CLAUDE_CODE_ENTRYPOINT", None)
+
+    worker_dir = reset_worker_dir(worker_id)
+
+    update_state(worker_id, status="applying", job_title=job["title"],
+                 company=job.get("site", ""), score=job.get("fit_score", 0),
+                 start_time=time.time(), actions=0, last_action="starting")
+    add_event(f"[W{worker_id}] Starting: {job['title'][:40]} @ {job.get('site', '')}")
+
+    worker_log = config.LOG_DIR / f"worker-{worker_id}.log"
+    ts_header = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    log_header = (
+        f"\n{'=' * 60}\n"
+        f"[{ts_header}] {job['title']} @ {job.get('site', '')}\n"
+        f"URL: {job.get('application_url') or job['url']}\n"
+        f"Score: {job.get('fit_score', 'N/A')}/10\n"
+        f"{'=' * 60}\n"
+    )
+
+    start = time.time()
+    stats: dict = {}
+    proc = None
+
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=env,
+            cwd=str(worker_dir),
+        )
+        with _claude_lock:
+            _claude_procs[worker_id] = proc
+
+        proc.stdin.write(agent_prompt)
+        proc.stdin.close()
+
+        text_parts: list[str] = []
+        with open(worker_log, "a", encoding="utf-8") as lf:
+            lf.write(log_header)
+
+            for line in proc.stdout:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    msg = json.loads(line)
+                    msg_type = msg.get("type")
+                    if msg_type == "assistant":
+                        for block in msg.get("message", {}).get("content", []):
+                            bt = block.get("type")
+                            if bt == "text":
+                                text_parts.append(block["text"])
+                                lf.write(block["text"] + "\n")
+                            elif bt == "tool_use":
+                                name = (
+                                    block.get("name", "")
+                                    .replace("mcp__playwright__", "")
+                                    .replace("mcp__gmail__", "gmail:")
+                                )
+                                inp = block.get("input", {})
+                                if "url" in inp:
+                                    desc = f"{name} {inp['url'][:60]}"
+                                elif "ref" in inp:
+                                    desc = f"{name} {inp.get('element', inp.get('text', ''))}"[:50]
+                                elif "fields" in inp:
+                                    desc = f"{name} ({len(inp['fields'])} fields)"
+                                elif "paths" in inp:
+                                    desc = f"{name} upload"
+                                else:
+                                    desc = name
+
+                                lf.write(f"  >> {desc}\n")
+                                ws = get_state(worker_id)
+                                cur_actions = ws.actions if ws else 0
+                                update_state(worker_id,
+                                             actions=cur_actions + 1,
+                                             last_action=desc[:35])
+                    elif msg_type == "result":
+                        stats = {
+                            "input_tokens": msg.get("usage", {}).get("input_tokens", 0),
+                            "output_tokens": msg.get("usage", {}).get("output_tokens", 0),
+                            "cache_read": msg.get("usage", {}).get("cache_read_input_tokens", 0),
+                            "cache_create": msg.get("usage", {}).get("cache_creation_input_tokens", 0),
+                            "cost_usd": msg.get("total_cost_usd", 0),
+                            "turns": msg.get("num_turns", 0),
+                        }
+                        text_parts.append(msg.get("result", ""))
+                except json.JSONDecodeError:
+                    text_parts.append(line)
+                    lf.write(line + "\n")
+
+        proc.wait(timeout=300)
+        returncode = proc.returncode
+        proc = None
+
+        if returncode and returncode < 0:
+            return "skipped", int((time.time() - start) * 1000)
+
+        output = "\n".join(text_parts)
+        elapsed = int(time.time() - start)
+        duration_ms = int((time.time() - start) * 1000)
+
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        job_log = config.LOG_DIR / f"claude_{ts}_w{worker_id}_{job.get('site', 'unknown')[:20]}.txt"
+        job_log.write_text(output, encoding="utf-8")
+
+        if stats:
+            cost = stats.get("cost_usd", 0)
+            ws = get_state(worker_id)
+            prev_cost = ws.total_cost if ws else 0.0
+            update_state(worker_id, total_cost=prev_cost + cost)
+
+        def _clean_reason(s: str) -> str:
+            return re.sub(r'[*`"]+$', '', s).strip()
+
+        for result_status in ["APPLIED", "EXPIRED", "CAPTCHA", "LOGIN_ISSUE"]:
+            if f"RESULT:{result_status}" in output:
+                add_event(f"[W{worker_id}] {result_status} ({elapsed}s): {job['title'][:30]}")
+                update_state(worker_id, status=result_status.lower(),
+                             last_action=f"{result_status} ({elapsed}s)")
+                return result_status.lower(), duration_ms
+
+        # Fuzzy success detection: agent confirmed submission in narrative but omitted RESULT:APPLIED
+        # Require strong confirmation phrases (not just "confirmation" which is too vague)
+        _output_lower = output.lower()
+        _fuzzy_success = any(phrase in _output_lower for phrase in [
+            "application submitted", "successfully submitted", "application has been submitted",
+            "your application was submitted", "application was received",
+            "application is submitted", "submitted successfully",
+            "application number", "reference number",
+        ])
+        _fuzzy_fail_context = any(phrase in _output_lower for phrase in [
+            "result:failed", "not_eligible", "login_issue", "captcha",
+            "could not submit", "unable to submit", "failed to submit",
+            "was not submitted", "not able to submit", "cannot submit",
+            "i was unable", "i could not",
+        ])
+        if _fuzzy_success and not _fuzzy_fail_context:
+            add_event(f"[W{worker_id}] APPLIED (fuzzy) ({elapsed}s): {job['title'][:30]}")
+            update_state(worker_id, status="applied", last_action=f"APPLIED-fuzzy ({elapsed}s)")
+            return "applied", duration_ms
+
+        if "RESULT:FAILED" in output:
+            for out_line in output.split("\n"):
+                if "RESULT:FAILED" in out_line:
+                    parts = out_line.split("RESULT:FAILED:", 1)
+                    reason = parts[1].strip() if len(parts) > 1 and parts[1].strip() else "unknown"
+                    reason = _clean_reason(reason)
+                    PROMOTE_TO_STATUS = {"captcha", "expired", "login_issue"}
+                    if reason in PROMOTE_TO_STATUS:
+                        add_event(f"[W{worker_id}] {reason.upper()} ({elapsed}s): {job['title'][:30]}")
+                        update_state(worker_id, status=reason,
+                                     last_action=f"{reason.upper()} ({elapsed}s)")
+                        return reason, duration_ms
+                    add_event(f"[W{worker_id}] FAILED ({elapsed}s): {reason[:30]}")
+                    update_state(worker_id, status="failed",
+                                 last_action=f"FAILED: {reason[:25]}")
+                    return f"failed:{reason}", duration_ms
+            return "failed:unknown", duration_ms
+
+        add_event(f"[W{worker_id}] NO RESULT ({elapsed}s)")
+        update_state(worker_id, status="failed", last_action=f"no result ({elapsed}s)")
+        return "failed:no_result_line", duration_ms
+
+    except subprocess.TimeoutExpired:
+        duration_ms = int((time.time() - start) * 1000)
+        elapsed = int(time.time() - start)
+        add_event(f"[W{worker_id}] TIMEOUT ({elapsed}s)")
+        update_state(worker_id, status="failed", last_action=f"TIMEOUT ({elapsed}s)")
+        return "failed:timeout", duration_ms
+    except Exception as e:
+        duration_ms = int((time.time() - start) * 1000)
+        add_event(f"[W{worker_id}] ERROR: {str(e)[:40]}")
+        update_state(worker_id, status="failed", last_action=f"ERROR: {str(e)[:25]}")
+        return f"failed:{str(e)[:100]}", duration_ms
+    finally:
+        with _claude_lock:
+            _claude_procs.pop(worker_id, None)
+        if proc is not None and proc.poll() is None:
+            _kill_process_tree(proc.pid)
+
+
+# ---------------------------------------------------------------------------
+# Permanent failure classification
+# ---------------------------------------------------------------------------
+
+PERMANENT_FAILURES: set[str] = {
+    "expired", "captcha", "login_issue",
+    "not_eligible_location", "not_eligible_salary",
+    "already_applied", "account_required",
+    "not_a_job_application", "unsafe_permissions",
+    "unsafe_verification", "sso_required",
+    "site_blocked", "cloudflare_blocked", "blocked_by_cloudflare",
+}
+
+PERMANENT_PREFIXES: tuple[str, ...] = ("site_blocked", "cloudflare", "blocked_by")
+
+
+def _is_permanent_failure(result: str) -> bool:
+    """Determine if a failure should never be retried."""
+    reason = result.split(":", 1)[-1] if ":" in result else result
+    return (
+        result in PERMANENT_FAILURES
+        or reason in PERMANENT_FAILURES
+        or any(reason.startswith(p) for p in PERMANENT_PREFIXES)
+    )
+
+
+# ---------------------------------------------------------------------------
+# Worker loop
+# ---------------------------------------------------------------------------
+
+def worker_loop(worker_id: int = 0, limit: int = 1,
+                target_url: str | None = None,
+                min_score: int = 7, headless: bool = False,
+                model: str = "sonnet", dry_run: bool = False) -> tuple[int, int]:
+    """Run jobs sequentially until limit is reached or queue is empty.
+
+    Args:
+        worker_id: Numeric worker identifier.
+        limit: Max jobs to process (0 = continuous).
+        target_url: Apply to a specific URL.
+        min_score: Minimum fit_score threshold.
+        headless: Run Chrome headless.
+        model: Claude model name.
+        dry_run: Don't click Submit.
+
+    Returns:
+        Tuple of (applied_count, failed_count).
+    """
+    applied = 0
+    failed = 0
+    continuous = limit == 0
+    jobs_done = 0
+    empty_polls = 0
+    port = BASE_CDP_PORT + worker_id
+
+    while not _stop_event.is_set():
+        if not continuous and jobs_done >= limit:
+            break
+
+        update_state(worker_id, status="idle", job_title="", company="",
+                     last_action="waiting for job", actions=0)
+
+        job = acquire_job(target_url=target_url, min_score=min_score,
+                          worker_id=worker_id)
+        if not job:
+            if not continuous:
+                add_event(f"[W{worker_id}] Queue empty")
+                update_state(worker_id, status="done", last_action="queue empty")
+                break
+            empty_polls += 1
+            update_state(worker_id, status="idle",
+                         last_action=f"polling ({empty_polls})")
+            if empty_polls == 1:
+                add_event(f"[W{worker_id}] Queue empty, polling every {POLL_INTERVAL}s...")
+            # Use Event.wait for interruptible sleep
+            if _stop_event.wait(timeout=POLL_INTERVAL):
+                break  # Stop was requested during wait
+            continue
+
+        empty_polls = 0
+
+        chrome_proc = None
+        try:
+            add_event(f"[W{worker_id}] Launching Chrome...")
+            chrome_proc = launch_chrome(worker_id, port=port, headless=headless)
+
+            result, duration_ms = run_job(job, port=port, worker_id=worker_id,
+                                            model=model, dry_run=dry_run)
+
+            if result == "skipped":
+                release_lock(job["url"])
+                add_event(f"[W{worker_id}] Skipped: {job['title'][:30]}")
+                continue
+            elif result == "applied":
+                mark_result(job["url"], "applied", duration_ms=duration_ms)
+                applied += 1
+                update_state(worker_id, jobs_applied=applied,
+                             jobs_done=applied + failed)
+            else:
+                reason = result.split(":", 1)[-1] if ":" in result else result
+                mark_result(job["url"], "failed", reason,
+                            permanent=_is_permanent_failure(result),
+                            duration_ms=duration_ms)
+                failed += 1
+                update_state(worker_id, jobs_failed=failed,
+                             jobs_done=applied + failed)
+
+        except KeyboardInterrupt:
+            release_lock(job["url"])
+            if _stop_event.is_set():
+                break
+            add_event(f"[W{worker_id}] Job skipped (Ctrl+C)")
+            continue
+        except Exception as e:
+            logger.exception("Worker %d launcher error", worker_id)
+            add_event(f"[W{worker_id}] Launcher error: {str(e)[:40]}")
+            release_lock(job["url"])
+            failed += 1
+            update_state(worker_id, jobs_failed=failed)
+        finally:
+            if chrome_proc:
+                cleanup_worker(worker_id, chrome_proc)
+
+        jobs_done += 1
+        if target_url:
+            break
+
+    update_state(worker_id, status="done", last_action="finished")
+    return applied, failed
+
+
+# ---------------------------------------------------------------------------
+# Main entry point (called from cli.py)
+# ---------------------------------------------------------------------------
+
+def main(limit: int = 1, target_url: str | None = None,
+         min_score: int = 7, headless: bool = False, model: str = "sonnet",
+         dry_run: bool = False, continuous: bool = False,
+         poll_interval: int = 60, workers: int = 1) -> None:
+    """Launch the apply pipeline.
+
+    Args:
+        limit: Max jobs to apply to (0 or with continuous=True means run forever).
+        target_url: Apply to a specific URL.
+        min_score: Minimum fit_score threshold.
+        headless: Run Chrome in headless mode.
+        model: Claude model name.
+        dry_run: Don't click Submit.
+        continuous: Run forever, polling for new jobs.
+        poll_interval: Seconds between DB polls when queue is empty.
+        workers: Number of parallel workers (default 1).
+    """
+    global POLL_INTERVAL
+    POLL_INTERVAL = poll_interval
+    _stop_event.clear()
+
+    config.ensure_dirs()
+    console = Console()
+
+    if continuous:
+        effective_limit = 0
+        mode_label = "continuous"
+    else:
+        effective_limit = limit
+        mode_label = f"{limit} jobs"
+
+    # Initialize dashboard for all workers
+    for i in range(workers):
+        init_worker(i)
+
+    worker_label = f"{workers} worker{'s' if workers > 1 else ''}"
+    console.print(f"Launching apply pipeline ({mode_label}, {worker_label}, poll every {POLL_INTERVAL}s)...")
+    console.print("[dim]Ctrl+C = skip current job(s) | Ctrl+C x2 = stop[/dim]")
+
+    # Double Ctrl+C handler
+    _ctrl_c_count = 0
+
+    def _sigint_handler(sig, frame):
+        nonlocal _ctrl_c_count
+        _ctrl_c_count += 1
+        if _ctrl_c_count == 1:
+            console.print("\n[yellow]Skipping current job(s)... (Ctrl+C again to STOP)[/yellow]")
+            # Kill all active Claude processes to skip current jobs
+            with _claude_lock:
+                for wid, cproc in list(_claude_procs.items()):
+                    if cproc.poll() is None:
+                        _kill_process_tree(cproc.pid)
+        else:
+            console.print("\n[red bold]STOPPING[/red bold]")
+            _stop_event.set()
+            with _claude_lock:
+                for wid, cproc in list(_claude_procs.items()):
+                    if cproc.poll() is None:
+                        _kill_process_tree(cproc.pid)
+            kill_all_chrome()
+            raise KeyboardInterrupt
+
+    signal.signal(signal.SIGINT, _sigint_handler)
+
+    try:
+        with Live(render_full(), console=console, refresh_per_second=2) as live:
+            # Daemon thread for display refresh only (no business logic)
+            _dashboard_stop = threading.Event()
+
+            def _refresh():
+                while not _dashboard_stop.is_set():
+                    live.update(render_full())
+                    time.sleep(0.5)
+
+            refresh_thread = threading.Thread(target=_refresh, daemon=True)
+            refresh_thread.start()
+
+            if workers == 1:
+                # Single worker — run directly in main thread
+                total_applied, total_failed = worker_loop(
+                    worker_id=0,
+                    limit=effective_limit,
+                    target_url=target_url,
+                    min_score=min_score,
+                    headless=headless,
+                    model=model,
+                    dry_run=dry_run,
+                )
+            else:
+                # Multi-worker — distribute limit across workers
+                if effective_limit:
+                    base = effective_limit // workers
+                    extra = effective_limit % workers
+                    limits = [base + (1 if i < extra else 0)
+                              for i in range(workers)]
+                else:
+                    limits = [0] * workers  # continuous mode
+
+                with ThreadPoolExecutor(max_workers=workers,
+                                        thread_name_prefix="apply-worker") as executor:
+                    futures = {
+                        executor.submit(
+                            worker_loop,
+                            worker_id=i,
+                            limit=limits[i],
+                            target_url=target_url,
+                            min_score=min_score,
+                            headless=headless,
+                            model=model,
+                            dry_run=dry_run,
+                        ): i
+                        for i in range(workers)
+                    }
+
+                    results: list[tuple[int, int]] = []
+                    for future in as_completed(futures):
+                        wid = futures[future]
+                        try:
+                            results.append(future.result())
+                        except Exception:
+                            logger.exception("Worker %d crashed", wid)
+                            results.append((0, 0))
+
+                total_applied = sum(r[0] for r in results)
+                total_failed = sum(r[1] for r in results)
+
+            _dashboard_stop.set()
+            refresh_thread.join(timeout=2)
+            live.update(render_full())
+
+        totals = get_totals()
+        console.print(
+            f"\n[bold]Done: {total_applied} applied, {total_failed} failed "
+            f"(${totals['cost']:.3f})[/bold]"
+        )
+        console.print(f"Logs: {config.LOG_DIR}")
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        _stop_event.set()
+        kill_all_chrome()
+
+
+def _clean_result_reason(text: str) -> str:
+    return re.sub(r'[*`"]+$', "", text).strip()
+
+
+def _extract_result(output: str, worker_id: int, job: dict, duration_ms: int) -> tuple[str, int]:
+    elapsed = max(1, duration_ms // 1000)
+
+    for result_status in ["APPLIED", "EXPIRED", "CAPTCHA", "LOGIN_ISSUE"]:
+        if f"RESULT:{result_status}" in output:
+            add_event(f"[W{worker_id}] {result_status} ({elapsed}s): {job['title'][:30]}")
+            update_state(worker_id, status=result_status.lower(),
+                         last_action=f"{result_status} ({elapsed}s)")
+            return result_status.lower(), duration_ms
+
+    output_lower = output.lower()
+    fuzzy_success = any(phrase in output_lower for phrase in [
+        "application submitted", "successfully submitted", "application has been submitted",
+        "your application was submitted", "application was received",
+        "application is submitted", "submitted successfully",
+        "application number", "reference number",
+    ])
+    fuzzy_fail_context = any(phrase in output_lower for phrase in [
+        "result:failed", "not_eligible", "login_issue", "captcha",
+        "could not submit", "unable to submit", "failed to submit",
+        "was not submitted", "not able to submit", "cannot submit",
+        "i was unable", "i could not",
+    ])
+    if fuzzy_success and not fuzzy_fail_context:
+        add_event(f"[W{worker_id}] APPLIED (fuzzy) ({elapsed}s): {job['title'][:30]}")
+        update_state(worker_id, status="applied", last_action=f"APPLIED-fuzzy ({elapsed}s)")
+        return "applied", duration_ms
+
+    if "RESULT:FAILED" in output:
+        for out_line in output.splitlines():
+            if "RESULT:FAILED" not in out_line:
+                continue
+            parts = out_line.split("RESULT:FAILED:", 1)
+            reason = parts[1].strip() if len(parts) > 1 and parts[1].strip() else "unknown"
+            reason = _clean_result_reason(reason)
+            if reason in {"captcha", "expired", "login_issue"}:
+                add_event(f"[W{worker_id}] {reason.upper()} ({elapsed}s): {job['title'][:30]}")
+                update_state(worker_id, status=reason, last_action=f"{reason.upper()} ({elapsed}s)")
+                return reason, duration_ms
+            add_event(f"[W{worker_id}] FAILED ({elapsed}s): {reason[:30]}")
+            update_state(worker_id, status="failed", last_action=f"FAILED: {reason[:25]}")
+            return f"failed:{reason}", duration_ms
+        return "failed:unknown", duration_ms
+
+    add_event(f"[W{worker_id}] NO RESULT ({elapsed}s)")
+    update_state(worker_id, status="failed", last_action=f"no result ({elapsed}s)")
+    return "failed:no_result_line", duration_ms
+
+
+def _build_agent_command(
+    backend: str,
+    model: str,
+    mcp_config_path: Path,
+    prompt_file: Path,
+) -> list[str]:
+    import shlex
+
+    if backend == "claude":
+        return [
+            "claude",
+            "--model", model,
+            "-p",
+            "--max-turns", "150",
+            "--mcp-config", str(mcp_config_path),
+            "--permission-mode", "bypassPermissions",
+            "--no-session-persistence",
+            "--disallowedTools", (
+                "mcp__gmail__draft_email,mcp__gmail__modify_email,"
+                "mcp__gmail__delete_email,mcp__gmail__download_attachment,"
+                "mcp__gmail__batch_modify_emails,mcp__gmail__batch_delete_emails,"
+                "mcp__gmail__create_label,mcp__gmail__update_label,"
+                "mcp__gmail__delete_label,mcp__gmail__get_or_create_label,"
+                "mcp__gmail__list_email_labels,mcp__gmail__create_filter,"
+                "mcp__gmail__list_filters,mcp__gmail__get_filter,"
+                "mcp__gmail__delete_filter"
+            ),
+            "--output-format", "stream-json",
+            "--verbose", "-",
+        ]
+
+    raw_config = json.loads(mcp_config_path.read_text(encoding="utf-8"))
+    servers = raw_config.get("mcpServers", {})
+    codex_args = [
+        "codex",
+        "exec",
+        "--model",
+        model,
+        "--full-auto",
+        "--skip-git-repo-check",
+    ]
+
+    if (
+        os.environ.get("DIVAPPLY_CODEX_OSS", "").strip().lower() in {"1", "true", "yes", "on"}
+        or ":" in model
+    ):
+        codex_args.append("--oss")
+
+    for server_name, server_cfg in servers.items():
+        prefix = f"mcp_servers.{server_name}"
+        if "command" in server_cfg:
+            codex_args.extend(["-c", f'{prefix}.command={json.dumps(server_cfg["command"])}'])
+        if "args" in server_cfg:
+            codex_args.extend(["-c", f"{prefix}.args={json.dumps(server_cfg['args'])}"])
+        if "env" in server_cfg:
+            codex_args.extend(["-c", f"{prefix}.env={json.dumps(server_cfg['env'])}"])
+        codex_args.extend(["-c", f"{prefix}.enabled=true"])
+        if server_name == "playwright":
+            codex_args.extend(["-c", f"{prefix}.required=true"])
+
+    template = os.environ.get("DIVAPPLY_CODEX_CMD", "").strip()
+    if template:
+        rendered = template.format(
+            model=model,
+            mcp_config=mcp_config_path,
+            prompt_file=prompt_file,
+        )
+        return shlex.split(rendered, posix=False)
+
+    return codex_args
+
+
+def get_manual_command(backend: str, model: str, prompt_file: Path, mcp_path: Path) -> str:
+    """Return a copy-pasteable manual debug command."""
+    if backend == "claude":
+        return (
+            f"claude --model {model} -p --mcp-config {mcp_path} "
+            f"--permission-mode bypassPermissions < {prompt_file}"
+        )
+    cmd = _build_agent_command(backend, model, mcp_path, prompt_file)
+    return " ".join(shlex.quote(part) for part in cmd) + f" < {shlex.quote(str(prompt_file))}"
+
+
+def gen_prompt(target_url: str, min_score: int = 7,
+               model: str = "gpt-5.4-mini", worker_id: int = 0,
+               backend: str | None = None, browser: str = "firefox",
+               headless: bool = False) -> Path | None:
+    """Generate a prompt file for manual debugging."""
+    job = acquire_job(target_url=target_url, min_score=min_score, worker_id=worker_id)
+    if not job:
+        return None
+
+    resume_path = job.get("tailored_resume_path")
+    txt_path = Path(resume_path).with_suffix(".txt") if resume_path else None
+    resume_text = ""
+    if txt_path and txt_path.exists():
+        resume_text = txt_path.read_text(encoding="utf-8")
+
+    prompt = prompt_mod.build_prompt(job=job, tailored_resume=resume_text)
+    release_lock(job["url"])
+
+    config.ensure_dirs()
+    site_slug = (job.get("site") or "unknown")[:20].replace(" ", "_")
+    prompt_file = config.LOG_DIR / f"prompt_{site_slug}_{job['title'][:30].replace(' ', '_')}.txt"
+    prompt_file.write_text(prompt, encoding="utf-8")
+
+    port = BASE_CDP_PORT + worker_id
+    worker_profile_dir = setup_worker_profile(worker_id, browser)
+    mcp_path = config.APP_DIR / f".mcp-apply-{worker_id}.json"
+    mcp_path.write_text(
+        json.dumps(
+            _make_mcp_config(
+                port,
+                browser=browser,
+                worker_profile_dir=worker_profile_dir,
+                headless=headless,
+            )
+        ),
+        encoding="utf-8",
+    )
+    return prompt_file
+
+
+def run_job(job: dict, port: int, worker_id: int = 0,
+            model: str = "gpt-5.4-mini", backend: str = "codex",
+            browser: str = "firefox", dry_run: bool = False,
+            headless: bool = False) -> tuple[str, int]:
+    """Run one auto-apply job through the selected backend."""
+    resume_path = job.get("tailored_resume_path")
+    txt_path = Path(resume_path).with_suffix(".txt") if resume_path else None
+    resume_text = ""
+    if txt_path and txt_path.exists():
+        resume_text = txt_path.read_text(encoding="utf-8")
+
+    agent_prompt = prompt_mod.build_prompt(
+        job=job,
+        tailored_resume=resume_text,
+        dry_run=dry_run,
+    )
+
+    worker_profile_dir = setup_worker_profile(worker_id, browser)
+    mcp_config_path = config.APP_DIR / f".mcp-apply-{worker_id}.json"
+    mcp_config_path.write_text(
+        json.dumps(
+            _make_mcp_config(
+                port,
+                browser=browser,
+                worker_profile_dir=worker_profile_dir,
+                headless=headless,
+            )
+        ),
+        encoding="utf-8",
+    )
+
+    worker_dir = reset_worker_dir(worker_id)
+    prompt_file = worker_dir / "apply_prompt.txt"
+    prompt_file.write_text(agent_prompt, encoding="utf-8")
+    cmd = _build_agent_command(backend, model, mcp_config_path, prompt_file)
+
+    env = os.environ.copy()
+    env.pop("CLAUDECODE", None)
+    env.pop("CLAUDE_CODE_ENTRYPOINT", None)
+
+    update_state(worker_id, status="applying", job_title=job["title"],
+                 company=job.get("site", ""), score=job.get("fit_score", 0),
+                 start_time=time.time(), actions=0, last_action=f"{backend} starting")
+    add_event(
+        f"[W{worker_id}] Starting via {backend}/{browser}: {job['title'][:40]} @ {job.get('site', '')}"
+    )
+
+    worker_log = config.LOG_DIR / f"worker-{worker_id}.log"
+    ts_header = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    log_header = (
+        f"\n{'=' * 60}\n"
+        f"[{ts_header}] {job['title']} @ {job.get('site', '')}\n"
+        f"Backend: {backend}\n"
+        f"Browser: {browser}\n"
+        f"URL: {job.get('application_url') or job['url']}\n"
+        f"Score: {job.get('fit_score', 'N/A')}/10\n"
+        f"{'=' * 60}\n"
+    )
+
+    start = time.time()
+    proc = None
+    text_parts: list[str] = []
+    stats: dict = {}
+
+    try:
+        proc = subprocess.Popen(
+            cmd,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            encoding="utf-8",
+            errors="replace",
+            env=env,
+            cwd=str(worker_dir),
+        )
+        with _claude_lock:
+            _claude_procs[worker_id] = proc
+
+        if proc.stdin:
+            proc.stdin.write(agent_prompt)
+            proc.stdin.close()
+
+        with open(worker_log, "a", encoding="utf-8") as lf:
+            lf.write(log_header)
+            for raw_line in proc.stdout or []:
+                line = raw_line.strip()
+                if not line:
+                    continue
+                if backend == "claude":
+                    try:
+                        msg = json.loads(line)
+                    except json.JSONDecodeError:
+                        msg = None
+                    if msg:
+                        msg_type = msg.get("type")
+                        if msg_type == "assistant":
+                            for block in msg.get("message", {}).get("content", []):
+                                if block.get("type") == "text":
+                                    text = block["text"]
+                                    text_parts.append(text)
+                                    lf.write(text + "\n")
+                                elif block.get("type") == "tool_use":
+                                    name = (
+                                        block.get("name", "")
+                                        .replace("mcp__playwright__", "")
+                                        .replace("mcp__gmail__", "gmail:")
+                                    )
+                                    lf.write(f"  >> {name}\n")
+                                    ws = get_state(worker_id)
+                                    cur_actions = ws.actions if ws else 0
+                                    update_state(worker_id, actions=cur_actions + 1, last_action=name[:35])
+                            continue
+                        if msg_type == "result":
+                            stats = {
+                                "cost_usd": msg.get("total_cost_usd", 0),
+                                "turns": msg.get("num_turns", 0),
+                            }
+                            result_text = msg.get("result", "")
+                            text_parts.append(result_text)
+                            lf.write(result_text + "\n")
+                            continue
+                text_parts.append(line)
+                lf.write(line + "\n")
+                update_state(worker_id, last_action=line[:35])
+
+        proc.wait(timeout=config.DEFAULTS["apply_timeout"])
+        returncode = proc.returncode
+        proc = None
+
+        duration_ms = int((time.time() - start) * 1000)
+        if returncode and returncode < 0:
+            return "skipped", duration_ms
+
+        output = "\n".join(text_parts)
+        ts = datetime.now().strftime("%Y%m%d_%H%M%S")
+        job_log = config.LOG_DIR / f"apply_agent_{backend}_{ts}_w{worker_id}_{job.get('site', 'unknown')[:20]}.txt"
+        job_log.write_text(output, encoding="utf-8")
+
+        if stats:
+            cost = stats.get("cost_usd", 0)
+            ws = get_state(worker_id)
+            prev_cost = ws.total_cost if ws else 0.0
+            update_state(worker_id, total_cost=prev_cost + cost)
+
+        return _extract_result(output, worker_id, job, duration_ms)
+
+    except subprocess.TimeoutExpired:
+        duration_ms = int((time.time() - start) * 1000)
+        elapsed = max(1, duration_ms // 1000)
+        add_event(f"[W{worker_id}] TIMEOUT ({elapsed}s)")
+        update_state(worker_id, status="failed", last_action=f"TIMEOUT ({elapsed}s)")
+        return "failed:timeout", duration_ms
+    except Exception as e:
+        duration_ms = int((time.time() - start) * 1000)
+        add_event(f"[W{worker_id}] ERROR: {str(e)[:40]}")
+        update_state(worker_id, status="failed", last_action=f"ERROR: {str(e)[:25]}")
+        return f"failed:{str(e)[:100]}", duration_ms
+    finally:
+        with _claude_lock:
+            _claude_procs.pop(worker_id, None)
+        if proc is not None and proc.poll() is None:
+            _kill_process_tree(proc.pid)
+
+
+def worker_loop(worker_id: int = 0, limit: int = 1,
+                target_url: str | None = None,
+                min_score: int = 7, headless: bool = False,
+                model: str = "gpt-5.4-mini", backend: str = "codex",
+                browser: str = "firefox",
+                dry_run: bool = False) -> tuple[int, int]:
+    """Run jobs sequentially until limit is reached or queue is empty."""
+    applied = 0
+    failed = 0
+    continuous = limit == 0
+    jobs_done = 0
+    empty_polls = 0
+    port = BASE_CDP_PORT + worker_id
+
+    while not _stop_event.is_set():
+        if not continuous and jobs_done >= limit:
+            break
+
+        update_state(worker_id, status="idle", job_title="", company="",
+                     last_action="waiting for job", actions=0)
+
+        job = acquire_job(target_url=target_url, min_score=min_score, worker_id=worker_id)
+        if not job:
+            if not continuous:
+                add_event(f"[W{worker_id}] Queue empty")
+                update_state(worker_id, status="done", last_action="queue empty")
+                break
+            empty_polls += 1
+            update_state(worker_id, status="idle", last_action=f"polling ({empty_polls})")
+            if empty_polls == 1:
+                add_event(f"[W{worker_id}] Queue empty, polling every {POLL_INTERVAL}s...")
+            if _stop_event.wait(timeout=POLL_INTERVAL):
+                break
+            continue
+
+        empty_polls = 0
+        chrome_proc = None
+        try:
+            if browser == "chrome":
+                add_event(f"[W{worker_id}] Launching Chrome...")
+                chrome_proc = launch_chrome(worker_id, port=port, headless=headless)
+            else:
+                add_event(f"[W{worker_id}] Preparing {browser} profile...")
+            result, duration_ms = run_job(
+                job,
+                port=port,
+                worker_id=worker_id,
+                model=model,
+                backend=backend,
+                browser=browser,
+                dry_run=dry_run,
+                headless=headless,
+            )
+
+            if result == "skipped":
+                release_lock(job["url"])
+                add_event(f"[W{worker_id}] Skipped: {job['title'][:30]}")
+                continue
+            if result == "applied":
+                mark_result(job["url"], "applied", duration_ms=duration_ms)
+                applied += 1
+                update_state(worker_id, jobs_applied=applied, jobs_done=applied + failed)
+            else:
+                reason = result.split(":", 1)[-1] if ":" in result else result
+                mark_result(job["url"], "failed", reason,
+                            permanent=_is_permanent_failure(result),
+                            duration_ms=duration_ms)
+                failed += 1
+                update_state(worker_id, jobs_failed=failed, jobs_done=applied + failed)
+        except KeyboardInterrupt:
+            release_lock(job["url"])
+            if _stop_event.is_set():
+                break
+            add_event(f"[W{worker_id}] Job skipped (Ctrl+C)")
+            continue
+        except Exception as e:
+            logger.exception("Worker %d launcher error", worker_id)
+            add_event(f"[W{worker_id}] Launcher error: {str(e)[:40]}")
+            release_lock(job["url"])
+            failed += 1
+            update_state(worker_id, jobs_failed=failed)
+        finally:
+            if chrome_proc:
+                cleanup_worker(worker_id, chrome_proc)
+
+        jobs_done += 1
+        if target_url:
+            break
+
+    update_state(worker_id, status="done", last_action="finished")
+    return applied, failed
+
+
+def main(limit: int = 1, target_url: str | None = None,
+         min_score: int = 7, headless: bool = False,
+         model: str = "gpt-5.4-mini", backend: str = "codex",
+         browser: str = "firefox",
+         dry_run: bool = False, continuous: bool = False,
+         poll_interval: int = 60, workers: int = 1) -> None:
+    """Launch the apply pipeline."""
+    global POLL_INTERVAL
+    POLL_INTERVAL = poll_interval
+    _stop_event.clear()
+
+    config.ensure_dirs()
+    console = Console()
+
+    effective_limit = 0 if continuous else limit
+    mode_label = "continuous" if continuous else f"{limit} jobs"
+
+    for i in range(workers):
+        init_worker(i)
+
+    worker_label = f"{workers} worker{'s' if workers > 1 else ''}"
+    console.print(
+        f"Launching apply pipeline ({mode_label}, {worker_label}, "
+        f"backend={backend}, browser={browser}, poll every {POLL_INTERVAL}s)..."
+    )
+    console.print("[dim]Ctrl+C = skip current job(s) | Ctrl+C x2 = stop[/dim]")
+
+    ctrl_c_count = 0
+
+    def _sigint_handler(sig, frame):
+        nonlocal ctrl_c_count
+        ctrl_c_count += 1
+        if ctrl_c_count == 1:
+            console.print("\n[yellow]Skipping current job(s)... (Ctrl+C again to STOP)[/yellow]")
+            with _claude_lock:
+                for cproc in list(_claude_procs.values()):
+                    if cproc.poll() is None:
+                        _kill_process_tree(cproc.pid)
+        else:
+            console.print("\n[red bold]STOPPING[/red bold]")
+            _stop_event.set()
+            with _claude_lock:
+                for cproc in list(_claude_procs.values()):
+                    if cproc.poll() is None:
+                        _kill_process_tree(cproc.pid)
+            kill_all_chrome()
+            raise KeyboardInterrupt
+
+    signal.signal(signal.SIGINT, _sigint_handler)
+
+    try:
+        with Live(render_full(), console=console, refresh_per_second=2) as live:
+            dashboard_stop = threading.Event()
+
+            def _refresh():
+                while not dashboard_stop.is_set():
+                    live.update(render_full())
+                    time.sleep(0.5)
+
+            refresh_thread = threading.Thread(target=_refresh, daemon=True)
+            refresh_thread.start()
+
+            if workers == 1:
+                total_applied, total_failed = worker_loop(
+                    worker_id=0,
+                    limit=effective_limit,
+                    target_url=target_url,
+                    min_score=min_score,
+                    headless=headless,
+                    model=model,
+                    backend=backend,
+                    browser=browser,
+                    dry_run=dry_run,
+                )
+            else:
+                if effective_limit:
+                    base = effective_limit // workers
+                    extra = effective_limit % workers
+                    limits = [base + (1 if i < extra else 0) for i in range(workers)]
+                else:
+                    limits = [0] * workers
+
+                with ThreadPoolExecutor(max_workers=workers, thread_name_prefix="apply-worker") as executor:
+                    futures = {
+                        executor.submit(
+                            worker_loop,
+                            worker_id=i,
+                            limit=limits[i],
+                            target_url=target_url,
+                            min_score=min_score,
+                            headless=headless,
+                            model=model,
+                            backend=backend,
+                            browser=browser,
+                            dry_run=dry_run,
+                        ): i
+                        for i in range(workers)
+                    }
+
+                    results: list[tuple[int, int]] = []
+                    for future in as_completed(futures):
+                        wid = futures[future]
+                        try:
+                            results.append(future.result())
+                        except Exception:
+                            logger.exception("Worker %d crashed", wid)
+                            results.append((0, 0))
+
+                total_applied = sum(r[0] for r in results)
+                total_failed = sum(r[1] for r in results)
+
+            dashboard_stop.set()
+            refresh_thread.join(timeout=2)
+            live.update(render_full())
+
+        totals = get_totals()
+        console.print(
+            f"\n[bold]Done: {total_applied} applied, {total_failed} failed "
+            f"(${totals['cost']:.3f})[/bold]"
+        )
+        console.print(f"Logs: {config.LOG_DIR}")
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        _stop_event.set()
+        kill_all_chrome()
+