jobctrl 0.4.0__tar.gz → 0.4.1__tar.gz

{jobctrl-0.4.0 → jobctrl-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: jobctrl
-Version: 0.4.0
+Version: 0.4.1
 Summary: AI-powered end-to-end job application pipeline
 Project-URL: Homepage, https://github.com/ebarti/JobCtrl
 Project-URL: Repository, https://github.com/ebarti/JobCtrl
@@ -49,7 +49,7 @@ Requires-Dist: pytest-timeout<3,>=2.4; extra == 'dev'
 Requires-Dist: pytest-xdist<4,>=3.8; extra == 'dev'
 Requires-Dist: pytest>=7.0; extra == 'dev'
 Requires-Dist: python-docx<2,>=1.2; extra == 'dev'
-Requires-Dist: ruff==0.17.1; extra == 'dev'
+Requires-Dist: ruff==0.17.3; extra == 'dev'
 Provides-Extra: providers
 Requires-Dist: claude-agent-sdk==0.2.121; extra == 'providers'
 Requires-Dist: google-antigravity==0.1.2; extra == 'providers'

{jobctrl-0.4.0 → jobctrl-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jobctrl"
-version = "0.4.0"
+version = "0.4.1"
 description = "AI-powered end-to-end job application pipeline"
 readme = "README.md"
 license = "AGPL-3.0-only"
@@ -65,7 +65,7 @@ dev = [
     "pytest-timeout>=2.4,<3",
     "pytest-xdist>=3.8,<4",
     "python-docx>=1.2,<2",
-    "ruff==0.17.1",
+    "ruff==0.17.3",
 ]
 providers = [
     "claude-agent-sdk==0.2.121",

{jobctrl-0.4.0 → jobctrl-0.4.1}/scripts/search_unit_concurrency_assessment.py

@@ -188,7 +188,7 @@ def _config(
         "locations": [{"label": "remote", "location": FIXED_LOCATION, "remote": True}],
         "defaults": {
             "results_per_site": results_per_site,
-            "hours_old": 72,
+            "hours_old": None,
             "country_indeed": "usa",
         },
         "location": {

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/__init__.py

@@ -1,3 +1,3 @@
 """JobCtrl — AI-powered end-to-end job application pipeline."""
 
-__version__ = "0.4.0"
+__version__ = "0.4.1"

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/actions.py

@@ -24,6 +24,7 @@ from jobctrl.workflow_specs import (
     build_apply_workflow_spec,
     build_profile_import_workflow_spec,
     build_run_stage_workflow_spec,
+    reject_discover_preview,
     start_workflow_spec_and_wait_sync,
     workflow_result_to_dict,
 )
@@ -97,6 +98,22 @@ def run_local_action(request: LocalActionRequest) -> LocalActionResult:
             error=f"Unknown action stage: {request.stage}",
         )
 
+    try:
+        reject_discover_preview([request.stage], dry_run=request.dry_run)
+    except ValueError as exc:
+        return LocalActionResult(
+            ok=False,
+            action_id=action_id,
+            stage=request.stage,
+            status="failed",
+            started_at=started_at,
+            finished_at=utc_now(),
+            duration_ms=int((perf_counter() - start) * 1000),
+            job_url=request.job_url,
+            dry_run=request.dry_run,
+            error=str(exc),
+        )
+
     apply_job_id: str | None = None
     try:
         _bootstrap_runtime()

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/apply/launcher.py

@@ -2772,7 +2772,7 @@ def reset_failed() -> int:
         try:
             reset_retry_stages(
                 conn, [(str(job_id), "apply")], tenant_id=tenant_id,
-                reset_attempts=True, only_failed=True, _allow_apply_only=True,
+                reset_attempts=True, only_failed=True,
             )
             count += 1
         except ValueError as exc:

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/cli.py

@@ -29,6 +29,7 @@ from jobctrl.workflow_specs import (
     build_apply_workflow_spec,
     build_compensation_refresh_workflow_spec,
     build_run_stage_workflow_spec,
+    reject_discover_preview,
     start_workflow_spec_and_wait_sync,
     workflow_result_to_dict,
 )
@@ -286,9 +287,12 @@ def _write_env_updates(path: Path, updates: dict[str, str], *, dry_run: bool, qu
         if not quiet:
             console.print(f"[yellow]Would update {path}:[/yellow] {', '.join(sorted(updates))}")
         return
-    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
-    path.write_text(_env_file_updates(path, updates), encoding="utf-8")
-    path.chmod(0o600)
+    from jobctrl.config import config_file_lock
+
+    # Coordinate the read/merge/write with the init wizard's file updates.
+    with config_file_lock(path=path):
+        path.write_text(_env_file_updates(path, updates), encoding="utf-8")
+        path.chmod(0o600)
     for key, value in updates.items():
         import os
 
@@ -730,6 +734,14 @@ def _render_run_timeline(run: dict, limit: int = 8) -> Panel | None:
     )
 
 
+def _check_discover_preview(stages: list[str], *, dry_run: bool) -> None:
+    try:
+        reject_discover_preview(stages, dry_run=dry_run)
+    except ValueError as exc:
+        console.print(f"[red]Error:[/red] {exc}")
+        raise typer.Exit(code=2) from exc
+
+
 def _run_stage_command(
     stage: str,
     *,
@@ -744,6 +756,7 @@ def _run_stage_command(
     tailor_judge_model: str | None = None,
 ) -> None:
     """Run a single pipeline stage through the shared orchestrator."""
+    _check_discover_preview([stage], dry_run=dry_run)
     _bootstrap()
 
     _check_tier2_stage(stage)
@@ -991,8 +1004,13 @@ def action(
 def init() -> None:
     """Run the first-time setup wizard (profile, resume, search config)."""
     from jobctrl.wizard.init import run_wizard
+    from jobctrl.domain.errors import ConfigurationError
 
-    run_wizard()
+    try:
+        run_wizard()
+    except ConfigurationError as exc:
+        console.print(f"[red]Setup stopped:[/red] {exc}")
+        raise typer.Exit(code=1) from exc
 
 
 @app.command()
@@ -1355,9 +1373,9 @@ def run(
     ),
 ) -> None:
     """Run one or more pipeline stages in order."""
-    _bootstrap()
-
     stage_list = stages if stages else ["all"]
+    _check_discover_preview(stage_list, dry_run=dry_run)
+    _bootstrap()
 
     # Validate stage names
     for s in stage_list:
@@ -2131,6 +2149,9 @@ def retry(
         raise typer.Exit(code=1)
 
     console.print(f"[green]Reset {stage} for retry:[/green] {job_url}")
+    if job_url.retailor_required:
+        console.print("Approved materials remain available. Use explicit re-tailor to create a replacement.")
+        return
     if run_after:
         if stage == "apply":
             identity = SqliteJobIdentityResolver(get_connection()).resolve_current_by_posting_url(

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/config.py

@@ -469,11 +469,14 @@ def load_discovery_control_settings() -> dict:
     if search_cfg is None:
         search_cfg = _default_discovery_search_config()
     effective = effective_discovery_search_config(search_cfg)
-    # Legacy JSON may contain numeric tier strings. Comparisons in provider
-    # planning use integers; normalize the execution copy, not the saved row.
+    # Legacy JSON may contain numeric strings. Normalize only the execution
+    # copy so planning and adapter capability checks keep the stored bytes.
     for query in effective.get("queries", []):
         if "tier" in query:
             query["tier"] = int(query["tier"])
+    for key in ("results_per_site", "hours_old", "distance"):
+        if key in effective.get("defaults", {}):
+            effective["defaults"][key] = int(effective["defaults"][key])
     return effective
 
 
@@ -542,18 +545,31 @@ def load_discovery_automation_settings() -> dict[str, object]:
 def save_discovery_automation_settings(
     *,
     auto_apply: bool,
-    apply_approval_required: bool,
+    apply_approval_required: bool | None,
+    expected_automation: Mapping[str, object] | None = None,
+    initialize_approval_default: bool = False,
 ) -> None:
     """Persist Apply automation choices with the SQLite-owned Discovery settings."""
     def update(search_cfg: dict) -> dict:
         raw_automation = search_cfg.get("automation")
         automation = dict(raw_automation) if isinstance(raw_automation, dict) else {}
-        automation.update(
-            {
-                "auto_apply": bool(auto_apply),
-                "apply_approval_required": bool(apply_approval_required),
-            }
-        )
+        updates = {"auto_apply": bool(auto_apply)}
+        if apply_approval_required is not None:
+            updates["apply_approval_required"] = bool(apply_approval_required)
+        if expected_automation is not None and any(
+            (key in automation, automation.get(key))
+            != (key in expected_automation, expected_automation.get(key))
+            for key in updates
+        ):
+            from jobctrl.domain.errors import ConfigurationError
+
+            raise ConfigurationError(
+                "Apply automation changed while setup was awaiting your choice. "
+                "Your Apply settings were not changed; retry jobctrl init."
+            )
+        if initialize_approval_default:
+            automation.setdefault("apply_approval_required", True)
+        automation.update(updates)
         search_cfg["automation"] = automation
         return search_cfg
 
@@ -657,7 +673,9 @@ def _read_discovery_search_config(
     return loaded
 
 
-def _update_discovery_search_config(update: Callable[[dict], dict]) -> None:
+def _update_discovery_search_config(
+    update: Callable[[dict], dict], *, first_use_update: Callable[[dict], dict] | None = None,
+) -> None:
     """Validate and update under the same write lock, preserving invalid rows."""
     try:
         DB_PATH.lstat()
@@ -674,7 +692,48 @@ def _update_discovery_search_config(update: Callable[[dict], dict]) -> None:
         conn.row_factory = sqlite3.Row
         conn.execute("BEGIN IMMEDIATE")
         current = _read_discovery_search_config(conn)
-        next_config = update(current or _default_discovery_search_config())
+        current_config = current or _default_discovery_search_config()
+        previous_config = json.loads(json.dumps(current_config))
+        current_boards = resolve_jobspy_boards(current_config, warn=False)
+        current_hours = current_config.get("defaults", {}).get("hours_old", 72)
+        current_hours = int(current_hours) if current_hours is not None else None
+        updater = first_use_update if current is None and first_use_update is not None else update
+        next_config = updater(current_config)
+        next_boards = resolve_jobspy_boards(next_config, warn=False)
+        next_hours = next_config.get("defaults", {}).get("hours_old", 72)
+        next_hours = int(next_hours) if next_hours is not None else None
+        selection_changed = previous_config.get("location_labels") != next_config.get("location_labels")
+        changed_boards = next_boards if next_hours != current_hours or selection_changed else [
+            board for board in next_boards if board not in current_boards
+        ]
+        from jobctrl.domain.profile.search_targets import legacy_remote_target_rows
+
+        old_legacy = legacy_remote_target_rows(previous_config.get("locations"))
+        new_legacy = legacy_remote_target_rows(next_config.get("locations"))
+        if changed_boards or old_legacy != new_legacy:
+            row = conn.execute(
+                "SELECT experience_target_locations, experience_target_work_models FROM candidate_profiles "
+                "WHERE tenant_id = ? AND profile_id = ?",
+                (str(LOCAL_TENANT), "default"),
+            ).fetchone()
+            from jobctrl.domain.discovery.remote_search import validate_target_row
+            from jobctrl.domain.profile.search_targets import active_target_rows, guarded_target_rows, has_profile_target_rows
+
+            rows = new_legacy
+            profile_overrides = False
+            if row is not None:
+                locations, models = row["experience_target_locations"], row["experience_target_work_models"]
+                if not isinstance(locations, str) or not isinstance(models, str):
+                    raise InvalidSavedSearchError("Saved Candidate Profile targets")
+                profile_overrides = has_profile_target_rows(locations, models)
+                if profile_overrides:
+                    rows = guarded_target_rows(locations, models)
+            for location, choices, label in active_target_rows(rows, next_config):
+                boards = next_boards if not profile_overrides and (location, choices, label) not in old_legacy else changed_boards
+                if boards:
+                    validate_target_row(
+                        location=location, choices=choices, sites=tuple(boards), hours_old=next_hours
+                    )
         _ensure_discovery_settings_table(conn)
         now = datetime_utc_now()
         conn.execute(

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/discovery/jobspy.py

@@ -20,6 +20,7 @@ from jobctrl import config
 from jobctrl.database import get_connection, init_db
 from jobctrl.domain.discovery import Employer, JobMetadata, PostingUrl, SearchStrategy, Source
 from jobctrl.domain.discovery.execution import DiscoveryExecutionRef
+from jobctrl.domain.discovery.remote_search import RemoteSearchConfigurationError, validate_remote_search_scope
 from jobctrl.domain.discovery.search_units import (
     DiscoverySearchSpec,
     DiscoverySearchUnit,
@@ -1093,7 +1094,7 @@ def _run_one_search(
     label = f'''"{s["query"]}" in {s["location"]} {("(remote)" if s.get("remote") else "")}'''
     if "tier" in s:
         label += f" [tier {s['tier']}]"
-    gd_location = glassdoor_map.get(s["location"], s["location"].split(",")[0])
+    gd_location = glassdoor_map.get(s["location"], s["location"].split(",")[0]) if s["location"] else ""
     has_glassdoor = "glassdoor" in sites
     other_sites = [si for si in sites if si != "glassdoor"]
     all_dfs = []
@@ -1322,6 +1323,19 @@ def _configured_searches(
     ]
 
 
+def validate_remote_search_config(search_cfg: dict, sites: list[str]) -> None:
+    """Preflight the exact selected rows and boards before starting a crawl."""
+    defaults = search_cfg.get("defaults") or {}
+    searches = _configured_searches(
+        search_cfg, tiers=search_cfg.get("tiers"), locations=search_cfg.get("location_labels"),
+    )
+    for search in searches:
+        validate_remote_search_scope(
+            sites, location=str(search["location"]), remote_only=bool(search.get("remote")),
+            hours_old=defaults.get("hours_old", 72),
+        )
+
+
 def _durable_search_specs(
     search_cfg: dict,
     *,
@@ -1339,6 +1353,11 @@ def _durable_search_specs(
     glassdoor_map = search_cfg.get("glassdoor_location_map", {})
     specs: list[DiscoverySearchSpec] = []
     for search in searches:
+        # A location-free non-Remote row cannot form a search unit at all.
+        # Board-specific limitations are handled per unit below.
+        validate_remote_search_scope(
+            (), location=str(search["location"]), remote_only=bool(search.get("remote")), hours_old=hours_old,
+        )
         common = {
             "query": str(search["query"]),
             "target_location": str(search["location"]),
@@ -1350,7 +1369,7 @@ def _durable_search_specs(
         for site in sites:
             target_location = str(search["location"])
             provider_location = target_location
-            if site == "glassdoor":
+            if site == "glassdoor" and target_location:
                 provider_location = str(glassdoor_map.get(target_location, target_location.split(",")[0]))
             specs.append(
                 DiscoverySearchSpec(
@@ -1729,19 +1748,20 @@ def _durable_full_crawl(
     persisted_linkedin_detail = any(
         unit.spec.sites == ("linkedin",) and unit.spec.linkedin_fetch_description for unit in existing_units
     )
-    specs = _durable_search_specs(
-        search_cfg,
-        tiers=tiers,
-        locations=locations,
-        sites=sites,
-        results_per_site=results_per_site,
-        hours_old=hours_old,
-        linkedin_fetch_description=persisted_linkedin_detail,
-    )
     if result_budget is not None and existing_units:
         # Live disable/quarantine controls reduce the frozen source allowance;
         # they must not rewrite provider request/checkpoint identities on retry.
         specs = [unit.spec for unit in existing_units]
+    else:
+        specs = _durable_search_specs(
+            search_cfg,
+            tiers=tiers,
+            locations=locations,
+            sites=sites,
+            results_per_site=results_per_site,
+            hours_old=hours_old,
+            linkedin_fetch_description=persisted_linkedin_detail,
+        )
     repository.plan_units(discovery_execution, specs)
     proxy_config = parse_proxy(proxy) if proxy else None
     proxies = [proxy_config.jobspy] if proxy_config else None
@@ -1810,10 +1830,23 @@ def _durable_full_crawl(
             emit_progress(unit, "JobStreaming discovery canceled")
             raise DiscoveryCancelled("JobStreaming discovery canceled")
 
+        try:
+            validate_remote_search_scope(
+                unit.spec.sites, location=unit.spec.target_location,
+                remote_only=unit.spec.remote_only, hours_old=unit.spec.hours_old,
+            )
+        except RemoteSearchConfigurationError:
+            repository.record_failure(
+                lease, error_code=f"{unit.spec.sites[0]}:unsupported_remote_search",
+                error_type="RemoteSearchConfigurationError", retryable=False, reset_checkpoint=False,
+            )
+            emit_progress(repository.get_unit(discovery_execution, lease.unit_id), "Board search rejected")
+            continue
+
         invocations = sum(
             (1 + candidate.recovery_count)
             for candidate in repository.list_units(discovery_execution)
-            if candidate.lease_attempt > 0
+            if candidate.lease_attempt > 0 and candidate.last_error_type != "RemoteSearchConfigurationError"
         )
         if invocations > BROAD_BOARD_LEAD_POLICY.max_requests_per_run:
             repository.mark_skipped(lease)
@@ -2077,21 +2110,44 @@ def _durable_full_crawl(
     failed_units = [unit for unit in units if unit.state == "failed"]
     completed_units = [unit for unit in units if unit.state == "completed"]
     canceled_units = [unit for unit in units if unit.state == "canceled"]
+    unsupported_reasons: list[str] = []
+    unsupported_source_ids: set[str] = set()
+    for unit in units:
+        if unit.last_error_type == "UnsupportedRemoteSearch":
+            reason = (
+                f"{', '.join(unit.spec.sites)} cannot apply the selected Remote search filters. "
+                "Remove the board from this search or adjust the target and lookback."
+            )
+            if reason not in unsupported_reasons:
+                unsupported_reasons.append(reason)
+            unsupported_source_ids.update(_jobspy_source_id(site) for site in unit.spec.sites)
+        try:
+            validate_remote_search_scope(
+                unit.spec.sites, location=unit.spec.target_location,
+                remote_only=unit.spec.remote_only, hours_old=unit.spec.hours_old,
+            )
+        except RemoteSearchConfigurationError as exc:
+            if str(exc) not in unsupported_reasons:
+                unsupported_reasons.append(str(exc))
+            unsupported_source_ids.update(_jobspy_source_id(site) for site in unit.spec.sites)
     if canceled_units:
         raise DiscoveryCancelled("JobStreaming discovery canceled")
     if failed_units and not completed_units and counts["accepted"] == 0:
+        if unsupported_reasons:
+            raise RemoteSearchConfigurationError(" ".join(unsupported_reasons))
         raise RuntimeError(f"JobStreaming failed for all {len(failed_units)} search unit(s)")
 
     db_total = int(conn.execute("SELECT COUNT(*) FROM jobs").fetchone()[0])
     admitted_new = sum(count for source, count in result_budget.counts().items() if source.startswith("jobspy:")) if result_budget is not None else counts["new"]
+    failed_source_ids = sorted(set(_failed_jobstreaming_source_ids(units)) | unsupported_source_ids)
     result = {
         "total": counts["accepted"] + max(admitted_new - counts["new"], 0),
         "raw_total": repository.execution_provider_job_count(discovery_execution),
         "new": admitted_new,
         "existing": counts["existing"],
-        "errors": len(_failed_jobstreaming_source_ids(units)),
+        "errors": len(failed_source_ids),
         "failed_queries": len(failed_units),
-        "failed_source_ids": _failed_jobstreaming_source_ids(units),
+        "failed_source_ids": failed_source_ids,
         "filtered": repository.execution_filtered_count(discovery_execution),
         "db_total": db_total,
         "queries": sum(unit.state in {"completed", "skipped", "failed"} for unit in units),
@@ -2099,6 +2155,8 @@ def _durable_full_crawl(
         "recovered_units": sum(unit.recovered for unit in units),
         "skipped_units": sum(unit.state == "skipped" for unit in units),
     }
+    if unsupported_reasons:
+        result["unsupported_remote_error"] = " ".join(unsupported_reasons)
     emit_progress(None, "JobStreaming discovery complete")
     return result
 
@@ -2145,6 +2203,9 @@ def run_discovery(
     tiers = cfg.get("tiers")
     locations = cfg.get("location_labels")
 
+    if discovery_execution is None:
+        validate_remote_search_config(cfg, sites)
+
     if discovery_execution is not None:
         if activity_attempt is None or activity_attempt < 1:
             raise ValueError("activity_attempt is required for resumable discovery")

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/discovery/smartextract.py

@@ -50,6 +50,7 @@ from jobctrl.infrastructure.discovery.live_browser import (
     LiveBrowserResult,
     LiveChromeDiscoveryClient,
     PoliteLiveChromeHttpClient,
+    trusted_live_browser_url,
     prefer_live_browser,
 )
 from jobctrl.infrastructure.discovery.production_wiring import DurableJobEventPublisher
@@ -1556,6 +1557,8 @@ def _run_all(
         return target.get("source_id") or f"smart_extract:{slug or 'site'}"
 
     def _browser_client_for_target(target: dict) -> PoliteLiveChromeHttpClient | None:
+        if not trusted_live_browser_url(str(target.get("url") or "")):
+            return None
         if id(target) in selected_clients:
             return selected_clients[id(target)]
         if discovery_execution is None:

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/discovery/workflow.py

@@ -104,6 +104,7 @@ _AUTOMATIC_COMPENSATION_REFRESH_PATCH = "discover-automatic-compensation-refresh
 _COMPENSATION_MODEL_BUDGET_PATCH = "discover-compensation-model-budget-v1"
 _SOURCE_RESULT_BUDGET_PATCH = "discover-source-result-budget-v1"
 _TERMINAL_ENRICHMENT_HANDOFF_PATCH = "discover-terminal-enrichment-handoff-v1"
+_UNSUPPORTED_REMOTE_FAILURE_PATCH = "discover-unsupported-remote-failure-v1"
 
 
 @workflow.defn(name="DiscoverWorkflow")
@@ -205,6 +206,7 @@ class DiscoverWorkflow:
         completed: list[str] = []
         failed: list[str] = []
         failures: list[str] = []
+        unsupported_remote_failures: list[str] = []
         # Score-as-you-discover uses the durable job commit as its handoff
         # boundary. One execution-scoped enrichment activity polls while source
         # activities are still producing jobs and hands each successful job to
@@ -249,6 +251,8 @@ class DiscoverWorkflow:
                     failed.append(family)
                     if failure is not None:
                         failures.append(failure)
+                        if status == "unsupported_remote":
+                            unsupported_remote_failures.append(failure)
             if batch_completed:
                 streaming_pass_ordinal += 1
                 await self._stream_family_preparation(
@@ -329,6 +333,29 @@ class DiscoverWorkflow:
                 raise CancelledError() from exc
             preparation_error = exc
 
+        # A pre-upgrade plan can reach a source activity without the new
+        # planning preflight. Finish healthy-family work before reporting the
+        # rejected board scope, rather than letting a peer's success hide it.
+        if unsupported_remote_failures:
+            failure = "; ".join(failures)
+            if enrichment_failure is not None:
+                failure += f"; enrichment also failed: {enrichment_failure}"
+            if preparation_error is not None:
+                prep_cause = str(preparation_error.cause) if preparation_error.cause else str(preparation_error)
+                failure += f"; preparation also failed: {prep_cause}"
+            return DiscoverWorkflowResult(
+                families_completed=completed,
+                families_failed=failed,
+                preparation_started=preparation_started,
+                enrichment_status=enrichment_status,
+                enrichment_site_errors=enrichment_site_errors,
+                compensation_refresh_status=compensation_refresh_status,
+                compensation_estimates_written=compensation_estimates_written,
+                compensation_refresh_warnings=compensation_refresh_warnings,
+                failure=failure,
+                error_code="unsupported_remote_search",
+            )
+
         all_families_failed = bool(failed) and not completed
         if all_families_failed:
             return DiscoverWorkflowResult(
@@ -384,7 +411,7 @@ class DiscoverWorkflow:
         """Run one family's source crawl; return ``(family, status, failure)``.
 
         Never raises: it folds every outcome into a status
-        (``"ok"``/``"failed"``/``"canceled"``) so ``asyncio.gather`` over a
+        (``"ok"``/``"failed"``/``"unsupported_remote"``/``"canceled"``) so ``asyncio.gather`` over a
         parallel batch always completes and the caller folds results in a
         deterministic, submission-order pass. Cancellation is surfaced as
         ``"canceled"`` and re-raised by the caller so it fans out to the whole
@@ -416,6 +443,11 @@ class DiscoverWorkflow:
         except ActivityError as exc:
             if _activity_error_was_cancelled(exc):
                 return (family, "canceled", None)
+            if (
+                _activity_error_code(exc) == "unsupported_remote_search"
+                and workflow.patched(_UNSUPPORTED_REMOTE_FAILURE_PATCH)
+            ):
+                return (family, "unsupported_remote", f"{family}: {exc.cause if exc.cause else exc}")
             return (family, "failed", f"{family}: {exc.cause if exc.cause else exc}")
         return (family, "ok", None)
 

jobctrl-0.4.1/src/jobctrl/domain/discovery/remote_search.py

@@ -0,0 +1,56 @@
+"""Literal capability checks for the pinned broad-board adapters."""
+
+from jobctrl.domain.errors import ConfigurationError
+
+
+class RemoteSearchConfigurationError(ConfigurationError):
+    """A requested board cannot preserve a selected Remote search scope."""
+
+    code = "unsupported_remote_search"
+
+
+def validate_remote_search_scope(
+    sites: tuple[str, ...] | list[str], *, location: str, remote_only: bool, hours_old: int | None,
+) -> None:
+    """Reject combinations the pinned adapters cannot apply without broadening."""
+    if not remote_only and not location:
+        raise RemoteSearchConfigurationError(
+            "A Hybrid or On-site search needs a location. Add a location or choose only Remote for that row."
+        )
+    if not remote_only:
+        return
+    selected = set(sites)
+    if "indeed" in selected and hours_old:
+        raise RemoteSearchConfigurationError(
+            "Indeed cannot combine Remote with the selected lookback. "
+            "Remove Indeed from this search or choose a non-Remote target."
+        )
+    if "glassdoor" in selected and location:
+        raise RemoteSearchConfigurationError(
+            "Glassdoor cannot combine Remote with a selected location. "
+            "Remove Glassdoor from this search or use a location-free Remote target."
+        )
+    day_limited = sorted(selected & {"glassdoor", "zip_recruiter"})
+    if day_limited and hours_old and hours_old % 24:
+        raise RemoteSearchConfigurationError(
+            f"{', '.join(day_limited)} can apply a Remote lookback only in whole days. "
+            "Choose a lookback in multiples of 24 hours or remove the board from this search."
+        )
+    unsupported = sorted(selected & {"bayt", "bdjobs"})
+    if unsupported:
+        raise RemoteSearchConfigurationError(
+            f"{', '.join(unsupported)} cannot apply a Remote filter. Remove the board from this search."
+        )
+
+
+def validate_target_row(
+    sites: tuple[str, ...] | list[str], *, location: str, choices: tuple[str, ...], hours_old: int | None,
+) -> None:
+    """Validate every requested work-model flag without dropping row counterparts."""
+    from jobctrl.domain.taxonomy import SEMANTIC_TAXONOMY
+
+    work_model = SEMANTIC_TAXONOMY["workModel"]
+    if not location and {"hybrid", work_model["hybrid"], "onsite", work_model["onsite"]}.intersection(choices):
+        validate_remote_search_scope(sites, location="", remote_only=False, hours_old=hours_old)
+    if {"remote", work_model["remote"]}.intersection(choices):
+        validate_remote_search_scope(sites, location=location, remote_only=True, hours_old=hours_old)

{jobctrl-0.4.0 → jobctrl-0.4.1}/src/jobctrl/domain/discovery/search_units.py

@@ -55,12 +55,20 @@ class DiscoverySearchSpec:
     def __post_init__(self) -> None:
         for field_name, value in (
             ("query", self.query),
-            ("provider_location", self.provider_location),
-            ("target_location", self.target_location),
             ("country_indeed", self.country_indeed),
         ):
             if not isinstance(value, str) or not value.strip():
                 raise ValueError(f"{field_name} must be a non-empty string")
+        # An empty location is a literal location-free Remote request, not a
+        # default geography. Keep both sides empty so no mapping widens it.
+        for field_name, value in (
+            ("provider_location", self.provider_location),
+            ("target_location", self.target_location),
+        ):
+            if not isinstance(value, str) or (not value.strip() and not (value == "" and self.remote_only)):
+                raise ValueError(f"{field_name} must be a non-empty string unless remote-only")
+        if (self.provider_location == "") != (self.target_location == ""):
+            raise ValueError("location-free searches must not invent a provider or target location")
         if not self.sites:
             raise ValueError("sites must contain at least one board")
         if len(set(self.sites)) != len(self.sites):