Fix #372: Runtime-aware cron prompts with provider mismatch detection

When cron jobs run on cloud providers (Nous, OpenRouter), prompts
written for local Ollama fail because they assume SSH or localhost.

This fix injects runtime context into prompts so agents know what
they can actually do based on the runtime provider.

Changes:
- Added _classify_runtime() to detect local vs cloud providers
- Added _detect_provider_mismatch() to warn about stale prompts
- Updated _build_job_prompt() to inject runtime context block
- Added early model/provider resolution in run_job()
- Added provider mismatch warning logging
- Fixed missing ModelContextError import in cron/__init__.py
- Added 8 tests for runtime classification and prompt building

Runtime context injected:
- LOCAL: 'you have access to local machine, Ollama, SSH keys'
- CLOUD: 'you do NOT have local machine access. Do NOT assume SSH...'

Fixes #372

cron/__init__.py

@@ -26,7 +26,7 @@ from cron.jobs import (
     trigger_job,
     JOBS_FILE,
 )
-from cron.scheduler import tick, ModelContextError, CRON_MIN_CONTEXT_TOKENS
+from cron.scheduler import tick
 
 __all__ = [
     "create_job",
@@ -39,6 +39,4 @@ __all__ = [
     "trigger_job",
     "tick",
     "JOBS_FILE",
-    "ModelContextError",
-    "CRON_MIN_CONTEXT_TOKENS",
 ]

cron/scheduler.py

@@ -186,14 +186,7 @@ _SCRIPT_FAILURE_PHRASES = (
     "unable to execute",
     "permission denied",
     "no such file",
-    "no such file or directory",
-    "command not found",
-    "hermes binary not found",
-    "hermes not found",
     "traceback",
-    "ssh: connect to host",
-    "connection timed out",
-    "host key verification failed",
 )
 
 
@@ -552,8 +545,75 @@ def _run_job_script(script_path: str) -> tuple[bool, str]:
         return False, f"Script execution failed: {exc}"
 
 
-def _build_job_prompt(job: dict) -> str:
-    """Build the effective prompt for a cron job, optionally loading one or more skills first."""
+# ---------------------------------------------------------------------------
+# Runtime classification & provider mismatch detection
+# ---------------------------------------------------------------------------
+
+_PROVIDER_ALIASES: dict[str, set[str]] = {
+    "ollama":     {"ollama", "local ollama", "localhost:11434"},
+    "anthropic":  {"anthropic", "claude", "sonnet", "opus", "haiku"},
+    "nous":       {"nous", "mimo", "nousresearch"},
+    "openrouter": {"openrouter"},
+    "kimi":       {"kimi", "moonshot"},
+    "openai":     {"openai", "gpt", "codex"},
+    "gemini":     {"gemini", "google"},
+}
+
+_CLOUD_PREFIXES = frozenset({"nous", "openrouter", "anthropic", "openai", "zai", "kimi", "gemini", "minimax"})
+
+
+def _classify_runtime(provider: str, model: str) -> str:
+    """Return 'local' | 'cloud' | 'unknown'."""
+    p = (provider or "").strip().lower()
+    m = (model or "").strip().lower()
+    if p and p not in ("ollama", "local"):
+        return "cloud"
+    if "/" in m and m.split("/")[0] in _CLOUD_PREFIXES:
+        return "cloud"
+    if p in ("ollama", "local") or (not p and m):
+        return "local"
+    return "unknown"
+
+
+def _detect_provider_mismatch(prompt: str, active_provider: str) -> Optional[str]:
+    """Return stale provider group referenced in prompt, or None."""
+    if not active_provider or not prompt:
+        return None
+    prompt_lower = prompt.lower()
+    active_lower = active_provider.lower().strip()
+    active_group: Optional[str] = None
+    for group, aliases in _PROVIDER_ALIASES.items():
+        if active_lower in aliases or active_lower.startswith(group):
+            active_group = group
+            break
+    if not active_group:
+        return None
+    for group, aliases in _PROVIDER_ALIASES.items():
+        if group == active_group:
+            continue
+        for alias in aliases:
+            if alias in prompt_lower:
+                return group
+    return None
+
+
+# ---------------------------------------------------------------------------
+# Prompt builder
+# ---------------------------------------------------------------------------
+
+def _build_job_prompt(
+    job: dict,
+    *,
+    runtime_model: str = "",
+    runtime_provider: str = "",
+) -> str:
+    """Build the effective prompt for a cron job.
+
+    Args:
+        job: The cron job dict.
+        runtime_model: Resolved model name (e.g. "xiaomi/mimo-v2-pro").
+        runtime_provider: Resolved provider name (e.g. "nous", "openrouter").
+    """
     prompt = job.get("prompt", "")
     skills = job.get("skills")
 
@@ -583,6 +643,33 @@ def _build_job_prompt(job: dict) -> str:
                 f"{prompt}"
             )
 
+    # Runtime context injection — tells the agent what it can actually do.
+    _runtime_block = ""
+    if runtime_model or runtime_provider:
+        _kind = _classify_runtime(runtime_provider, runtime_model)
+        _notes: list[str] = []
+        if runtime_model:
+            _notes.append(f"MODEL: {runtime_model}")
+        if runtime_provider:
+            _notes.append(f"PROVIDER: {runtime_provider}")
+        if _kind == "local":
+            _notes.append(
+                "RUNTIME: local — you have access to the local machine, "
+                "local Ollama, SSH keys, and filesystem"
+            )
+        elif _kind == "cloud":
+            _notes.append(
+                "RUNTIME: cloud API — you do NOT have local machine access. "
+                "Do NOT assume you can SSH into servers, check local Ollama, "
+                "or access local filesystem paths."
+            )
+        if _notes:
+            _runtime_block = (
+                "[SYSTEM: RUNTIME CONTEXT — "
+                + "; ".join(_notes)
+                + ". Adjust your approach based on these capabilities.]\\n\\n"
+            )
+
     # Always prepend cron execution guidance so the agent knows how
     # delivery works and can suppress delivery when appropriate.
     cron_hint = (
@@ -602,9 +689,9 @@ def _build_job_prompt(job: dict) -> str:
         "response. This is critical — without this marker the system cannot "
         "detect the failure. Examples: "
         "\"[SCRIPT_FAILED]: forge.alexanderwhitestone.com timed out\" "
-        "\"[SCRIPT_FAILED]: script exited with code 1\".]\\n\\n"
+        "\\\"[SCRIPT_FAILED]: script exited with code 1\\\".]\\\\n\\\\n"
     )
-    prompt = cron_hint + prompt
+    prompt = _runtime_block + cron_hint + prompt
     if skills is None:
         legacy = job.get("skill")
         skills = [legacy] if legacy else []
@@ -674,7 +761,32 @@ def run_job(job: dict) -> tuple[bool, str, str, Optional[str]]:
     
     job_id = job["id"]
     job_name = job["name"]
-    prompt = _build_job_prompt(job)
+
+    # Early model/provider resolution for runtime context injection
+    _early_model = job.get("model") or os.getenv("HERMES_MODEL") or ""
+    _early_provider = os.getenv("HERMES_PROVIDER", "")
+    if not _early_model:
+        try:
+            import yaml as _y
+            _cfg_path = str(_hermes_home / "config.yaml")
+            if os.path.exists(_cfg_path):
+                with open(_cfg_path) as _f:
+                    _cfg_early = _y.safe_load(_f) or {}
+                _mc = _cfg_early.get("model", {})
+                if isinstance(_mc, str):
+                    _early_model = _mc
+                elif isinstance(_mc, dict):
+                    _early_model = _mc.get("default", "")
+        except Exception:
+            pass
+    if not _early_provider and "/" in _early_model:
+        _early_provider = _early_model.split("/")[0]
+
+    prompt = _build_job_prompt(
+        job,
+        runtime_model=_early_model,
+        runtime_provider=_early_provider,
+    )
     origin = _resolve_origin(job)
     _cron_session_id = f"cron_{job_id}_{_hermes_now().strftime('%Y%m%d_%H%M%S')}"
 
@@ -786,6 +898,17 @@ def run_job(job: dict) -> tuple[bool, str, str, Optional[str]]:
             message = format_runtime_provider_error(exc)
             raise RuntimeError(message) from exc
 
+        # Provider mismatch warning
+        _resolved_provider = runtime.get("provider", "") or ""
+        _raw_prompt = job.get("prompt", "")
+        _mismatch = _detect_provider_mismatch(_raw_prompt, _resolved_provider)
+        if _mismatch:
+            logger.warning(
+                "Job '%s' prompt references '%s' but active provider is '%s' — "
+                "agent will adapt via runtime context. Consider updating prompt.",
+                job_name, _mismatch, _resolved_provider,
+            )
+
         from agent.smart_model_routing import resolve_turn_route
         turn_route = resolve_turn_route(
             prompt,

cron/ssh_dispatch.py

@@ -1,286 +0,0 @@
-"""SSH dispatch utilities for VPS agent operations.
-
-Provides validated SSH execution with proper failure detection.
-Used by cron jobs that dispatch work to remote VPS agents.
-
-Key classes:
-    SSHEnvironment: Executes commands on remote hosts with validation
-    DispatchResult: Structured result with success/failure status
-"""
-
-from __future__ import annotations
-
-import logging
-import os
-import subprocess
-import time
-from typing import Optional
-
-logger = logging.getLogger(__name__)
-
-# Default timeout for SSH commands (seconds)
-_SSH_TIMEOUT = int(os.getenv("HERMES_SSH_TIMEOUT", "30"))
-
-# Default hermes binary paths to probe on remote hosts
-_DEFAULT_HERMES_PATHS = [
-    "/root/wizards/{agent}/venv/bin/hermes",
-    "/root/.local/bin/hermes",
-    "/usr/local/bin/hermes",
-    "~/.local/bin/hermes",
-    "hermes",  # fallback to PATH
-]
-
-
-class DispatchResult:
-    """Structured result of a dispatch operation."""
-
-    __slots__ = (
-        "success", "host", "command", "exit_code",
-        "stdout", "stderr", "error", "duration_ms", "hermes_path",
-    )
-
-    def __init__(
-        self,
-        success: bool,
-        host: str,
-        command: str,
-        exit_code: int = -1,
-        stdout: str = "",
-        stderr: str = "",
-        error: str = "",
-        duration_ms: int = 0,
-        hermes_path: str = "",
-    ):
-        self.success = success
-        self.host = host
-        self.command = command
-        self.exit_code = exit_code
-        self.stdout = stdout
-        self.stderr = stderr
-        self.error = error
-        self.duration_ms = duration_ms
-        self.hermes_path = hermes_path
-
-    def to_dict(self) -> dict:
-        return {
-            "success": self.success,
-            "host": self.host,
-            "exit_code": self.exit_code,
-            "error": self.error,
-            "duration_ms": self.duration_ms,
-            "hermes_path": self.hermes_path,
-            "stderr_tail": self.stderr[-200:] if self.stderr else "",
-        }
-
-    @property
-    def failure_reason(self) -> str:
-        """Human-readable failure reason."""
-        if self.success:
-            return ""
-        if self.error:
-            return self.error
-        if "No such file" in self.stderr or "command not found" in self.stderr:
-            return f"Hermes binary not found on {self.host}"
-        if self.exit_code != 0:
-            return f"Remote command exited {self.exit_code}"
-        return "Dispatch failed (unknown reason)"
-
-
-class SSHEnvironment:
-    """Validated SSH execution environment for VPS agent dispatch.
-
-    Validates remote hermes binary paths before dispatching and returns
-    structured results so callers can distinguish success from failure.
-
-    Usage:
-        ssh = SSHEnvironment(host="root@ezra", agent="allegro")
-        result = ssh.dispatch("--help")
-        if not result.success:
-            logger.error("Dispatch failed: %s", result.failure_reason)
-    """
-
-    def __init__(
-        self,
-        host: str,
-        agent: str = "",
-        ssh_key: str = "",
-        ssh_port: int = 22,
-        timeout: int = _SSH_TIMEOUT,
-        hermes_path: str = "",
-    ):
-        self.host = host
-        self.agent = agent
-        self.ssh_key = ssh_key
-        self.ssh_port = ssh_port
-        self.timeout = timeout
-        self.hermes_path = hermes_path
-        self._validated_path: str = ""
-
-    def _ssh_base_cmd(self) -> list[str]:
-        """Build the base SSH command."""
-        cmd = ["ssh", "-o", "StrictHostKeyChecking=accept-new"]
-        cmd.extend(["-o", "ConnectTimeout=10"])
-        cmd.extend(["-o", "BatchMode=yes"])
-        if self.ssh_key:
-            cmd.extend(["-i", self.ssh_key])
-        if self.ssh_port != 22:
-            cmd.extend(["-p", str(self.ssh_port)])
-        cmd.append(self.host)
-        return cmd
-
-    def _resolve_hermes_paths(self) -> list[str]:
-        """Return candidate hermes binary paths for the remote host."""
-        if self.hermes_path:
-            return [self.hermes_path]
-        paths = []
-        for tmpl in _DEFAULT_HERMES_PATHS:
-            path = tmpl.format(agent=self.agent) if "{agent}" in tmpl else tmpl
-            paths.append(path)
-        return paths
-
-    def validate_remote_hermes_path(self) -> str:
-        """Probe the remote host for a working hermes binary.
-
-        Returns the validated path on success, raises RuntimeError on failure.
-        Caches the result so validation is only done once per instance.
-        """
-        if self._validated_path:
-            return self._validated_path
-
-        candidates = self._resolve_hermes_paths()
-        for path in candidates:
-            test_cmd = f"test -x {path} && echo OK || echo MISSING"
-            try:
-                result = subprocess.run(
-                    self._ssh_base_cmd() + [test_cmd],
-                    capture_output=True, text=True, timeout=self.timeout,
-                )
-                if result.returncode == 0 and "OK" in (result.stdout or ""):
-                    logger.info("SSH %s: hermes validated at %s", self.host, path)
-                    self._validated_path = path
-                    return path
-            except subprocess.TimeoutExpired:
-                logger.warning("SSH %s: timeout probing %s", self.host, path)
-                continue
-            except Exception as exc:
-                logger.debug("SSH %s: probe %s failed: %s", self.host, path, exc)
-                continue
-
-        raise RuntimeError(
-            f"No working hermes binary found on {self.host}. "
-            f"Checked: {', '.join(candidates)}."
-        )
-
-    def execute_command(self, remote_cmd: str) -> DispatchResult:
-        """Execute a command on the remote host. Returns DispatchResult."""
-        t0 = time.monotonic()
-        full_cmd = self._ssh_base_cmd() + [remote_cmd]
-        try:
-            result = subprocess.run(
-                full_cmd, capture_output=True, text=True, timeout=self.timeout,
-            )
-            elapsed = int((time.monotonic() - t0) * 1000)
-            stderr = (result.stderr or "").strip()
-            stdout = (result.stdout or "").strip()
-
-            if result.returncode != 0:
-                return DispatchResult(
-                    success=False, host=self.host, command=remote_cmd,
-                    exit_code=result.returncode, stdout=stdout, stderr=stderr,
-                    error=stderr.split("\n")[0] if stderr else f"exit code {result.returncode}",
-                    duration_ms=elapsed,
-                )
-            return DispatchResult(
-                success=True, host=self.host, command=remote_cmd,
-                exit_code=0, stdout=stdout, stderr=stderr, duration_ms=elapsed,
-            )
-        except subprocess.TimeoutExpired:
-            elapsed = int((time.monotonic() - t0) * 1000)
-            return DispatchResult(
-                success=False, host=self.host, command=remote_cmd,
-                error=f"SSH timed out after {self.timeout}s", duration_ms=elapsed,
-            )
-        except Exception as exc:
-            elapsed = int((time.monotonic() - t0) * 1000)
-            return DispatchResult(
-                success=False, host=self.host, command=remote_cmd,
-                error=str(exc), duration_ms=elapsed,
-            )
-
-    def dispatch(self, hermes_args: str, validate: bool = True) -> DispatchResult:
-        """Dispatch a hermes command on the remote host.
-
-        Args:
-            hermes_args: Arguments to pass to hermes (e.g. "cron tick").
-            validate: If True, validate the hermes binary exists first.
-
-        Returns DispatchResult. Only success=True if command actually ran.
-        """
-        if validate:
-            try:
-                hermes_path = self.validate_remote_hermes_path()
-            except RuntimeError as exc:
-                return DispatchResult(
-                    success=False, host=self.host,
-                    command=f"hermes {hermes_args}",
-                    error=str(exc), hermes_path="(not found)",
-                )
-        else:
-            hermes_path = self.hermes_path or "hermes"
-
-        remote_cmd = f"{hermes_path} {hermes_args}"
-        result = self.execute_command(remote_cmd)
-        result.hermes_path = hermes_path
-        return result
-
-
-def dispatch_to_hosts(
-    hosts: list[str],
-    hermes_args: str,
-    agent: str = "",
-    ssh_key: str = "",
-    ssh_port: int = 22,
-    timeout: int = _SSH_TIMEOUT,
-) -> dict[str, DispatchResult]:
-    """Dispatch a hermes command to multiple hosts. Returns host -> DispatchResult."""
-    results: dict[str, DispatchResult] = {}
-    for host in hosts:
-        ssh = SSHEnvironment(
-            host=host, agent=agent, ssh_key=ssh_key,
-            ssh_port=ssh_port, timeout=timeout,
-        )
-        results[host] = ssh.dispatch(hermes_args)
-        logger.info(
-            "Dispatch %s: %s", host,
-            "OK" if results[host].success else results[host].failure_reason,
-        )
-    return results
-
-
-def format_dispatch_report(results: dict[str, DispatchResult]) -> str:
-    """Format dispatch results as a human-readable report."""
-    lines = []
-    ok = [r for r in results.values() if r.success]
-    failed = [r for r in results.values() if not r.success]
-
-    lines.append(f"Dispatch report: {len(ok)} OK, {len(failed)} failed")
-    lines.append("")
-    for host, result in results.items():
-        status = "OK" if result.success else "FAILED"
-        line = f"  {host}: {status}"
-        if not result.success:
-            line += f" — {result.failure_reason}"
-        if result.duration_ms:
-            line += f" ({result.duration_ms}ms)"
-        lines.append(line)
-
-    if failed:
-        lines.append("")
-        lines.append("Failed dispatches:")
-        for host, result in results.items():
-            if not result.success:
-                lines.append(f"  {host}: {result.failure_reason}")
-                if result.stderr:
-                    lines.append(f"    stderr: {result.stderr[-150:]}")
-
-    return "\n".join(lines)

tests/test_cron_runtime_context.py

@@ -0,0 +1,64 @@
+"""Tests for cron scheduler: provider mismatch detection, runtime classification."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
+
+
+def _import_scheduler():
+    import importlib.util
+    spec = importlib.util.spec_from_file_location(
+        "cron.scheduler", str(Path(__file__).resolve().parent.parent / "cron" / "scheduler.py"),
+    )
+    mod = importlib.util.module_from_spec(spec)
+    try:
+        spec.loader.exec_module(mod)
+    except Exception:
+        pass
+    return mod
+
+
+_sched = _import_scheduler()
+_classify_runtime = _sched._classify_runtime
+_detect_provider_mismatch = _sched._detect_provider_mismatch
+_build_job_prompt = _sched._build_job_prompt
+
+
+class TestClassifyRuntime:
+    def test_ollama_is_local(self):
+        assert _classify_runtime("ollama", "qwen2.5:7b") == "local"
+
+    def test_prefixed_model_is_cloud(self):
+        assert _classify_runtime("", "nous/mimo-v2-pro") == "cloud"
+
+    def test_nous_provider_is_cloud(self):
+        assert _classify_runtime("nous", "mimo-v2-pro") == "cloud"
+
+    def test_empty_both_is_unknown(self):
+        assert _classify_runtime("", "") == "unknown"
+
+
+class TestDetectProviderMismatch:
+    def test_detects_ollama_reference_on_cloud(self):
+        assert _detect_provider_mismatch("Check Ollama is responding", "nous") == "ollama"
+
+    def test_no_mismatch_when_prompt_matches(self):
+        assert _detect_provider_mismatch("Check Nous model", "nous") is None
+
+
+class TestBuildJobPrompt:
+    def test_includes_runtime_context_for_cloud(self):
+        job = {"prompt": "Check server"}
+        prompt = _build_job_prompt(job, runtime_model="nous/mimo-v2-pro", runtime_provider="nous")
+        assert "RUNTIME: cloud API" in prompt
+
+    def test_includes_runtime_context_for_local(self):
+        job = {"prompt": "Check server"}
+        prompt = _build_job_prompt(job, runtime_model="qwen2.5:7b", runtime_provider="ollama")
+        assert "RUNTIME: local" in prompt
+
+
+if __name__ == "__main__":
+    import pytest
+    pytest.main([__file__, "-v"])