mobster-cli 0.4.3__py3-none-any.whl

mobile_agent/dry_run.py

@@ -0,0 +1,102 @@
+"""``mobster run --dry-run`` and ``"dryRun": true`` on POST /api/runs: what a task would do, read from its words alone.
+
+Nothing starts: no run, no journal entry, no phone, no model call, no count against a policy's daily cap. The plan
+names the apps the task would open, the outward acts its words ask for and whether Mobster would ask about each one
+under the person's permission mode and the project's policy, and the estimated cost. The screens are not listed:
+Mobster reads them from the phone as the task goes, and a dry run never touches it.
+"""
+
+import re
+
+from . import costs
+from .app_choice import infer_app
+from .permissions import gate as permission_gate
+from .permissions import policy as P
+from .permissions import project_policy
+from .task_policy import COMMIT_CONTROL, asked_part
+
+MAX_ACTS = 12
+_NOUN_BEFORE = re.compile(r"\b(?:the|a|an|best|my|your|its|top|new|each|every|one-line|last|\d+)\s*$", re.I)
+
+
+def _acts(goal):
+    """[(word, act)] the task's own words ask for, once each, in order; a prohibition ("don't send") asks for none."""
+    from .harness_api import commit_act
+    from .task_policy import PROHIBITION_SENTENCE
+    # "Draft a reply. Don't send anything." rules out every act of the kind it names.
+    ruled_out = {kind for sentence in PROHIBITION_SENTENCE.findall(goal) for found in COMMIT_CONTROL.finditer(sentence)
+                 for kind in project_policy.kinds_of("commit", commit_act("TAP", found.group(0), None, None))}
+    found, seen = [], set()
+    asked = asked_part(goal)
+    for match in COMMIT_CONTROL.finditer(asked):
+        if _NOUN_BEFORE.search(asked[:match.start()]):
+            continue  # "the best post", "needs a reply": the word names a thing
+        word = " ".join(match.group(0).casefold().split())
+        act = commit_act("TAP", word, None, None) or word
+        if act not in seen and not project_policy.kinds_of("commit", act) & ruled_out:
+            seen.add(act)
+            found.append((word, act))
+    return found[:MAX_ACTS]
+
+
+def _apps(goal, apps):
+    """The apps the task would open: the one its words name, then any other app it names."""
+    chosen = infer_app(goal, apps)
+    named = [app for app in sorted(apps, key=lambda a: -len(a["name"]))
+             if len(app["name"]) >= 4 and app is not chosen and re.search(
+                 rf"(?<![\w-]){re.escape(app['name'])}(?![\w-])", goal, re.I)]
+    return [app for app in [chosen, *named] if app]
+
+
+def plan(goal, *, apps, mode=P.DEFAULT_MODE, policy=None, profile=None, origin=None, estimator=None, now=None):
+    """The dry run of ``goal`` as JSON. ``apps``: the phone's apps (catalog shape). ``estimator(goal, names)``: the cost
+    range, default ``costs.smart_estimate``. Reads the policy's counts and never writes them."""
+    goal = " ".join(str(goal or "").replace("’", "'").split())
+    chosen = _apps(goal, apps)
+    names = [app["name"] for app in apps]
+    cost = (estimator or costs.smart_estimate)(goal, names)
+    mode = P.effective_mode(mode, None, origin)
+    bundle = chosen[0]["bundleId"] if chosen else ""
+    asks = []
+    for word, act in _acts(goal):
+        kinds = project_policy.kinds_of("commit", act)
+        by_mode = permission_gate.decision_for("commit", mode, existing=True) == "ask"
+        by_policy = policy.asks(kinds, bundle, profile, now=now) if policy is not None else None
+        if by_mode or by_policy:
+            asks.append({"act": act, "words": word, "kinds": sorted(kinds), "bundleId": bundle or None,
+                         "why": "your permission mode asks" if by_mode and not by_policy else by_policy,
+                         "by": "policy" if by_policy and not by_mode else "mode"})
+    return {"goal": goal, "dryRun": True, "sent": False, "apps": [{"id": a["id"], "name": a["name"],
+                                                                  "bundleId": a["bundleId"]} for a in chosen],
+            "permissionMode": mode, "asks": asks, "policy": _policy(policy),
+            "cost": {"lowUsd": cost.get("lowUsd"), "highUsd": cost.get("highUsd"), "model": cost.get("model"),
+                     "billing": cost.get("billing") or "api"},
+            "screens": "Mobster reads each screen from the phone as the task goes. A dry run never touches it."}
+
+
+def _policy(policy):
+    if policy is None:
+        return None
+    return {"file": str(policy.path) if policy.path else None, "rules": len(policy.rules), "error": policy.error}
+
+
+def lines(result):
+    """The plan as text for a terminal."""
+    out = [f"Dry run: {result['goal']}", "Nothing was sent to your iPhone."]
+    apps = ", ".join(a["name"] for a in result["apps"])
+    out.append(f"Apps it would open: {apps}." if apps else "It names no app, so it starts on the Home Screen.")
+    if result["asks"]:
+        out.append("It would ask before:")
+        out += [f"  {a['act']}: {a['why']}" for a in result["asks"]]
+    else:
+        out.append("It would ask about nothing its words name. Mobster still asks about any step that sends, buys, "
+                   "posts or deletes.")
+    cost = result["cost"]
+    if cost["billing"] == "plan":
+        out.append("Estimated cost: nothing per call, it runs on your plan.")
+    elif cost["lowUsd"] is not None:
+        out.append(f"Estimated cost: ${cost['lowUsd']:.2f} to ${cost['highUsd']:.2f}.")
+    if result["policy"] and result["policy"]["error"]:
+        out.append(f"Your project policy can't be read, so every act asks: {result['policy']['error']}")
+    out.append(result["screens"])
+    return out

mobile_agent/effect_ledger.py

@@ -0,0 +1,83 @@
+"""One run's ledger of side effects: one whose outcome is acknowledged or unknown is never sent again."""
+
+# Operations that can leave a durable effect on the device.
+PERSISTENT_OPERATIONS = frozenset({"TAP", "TYPE", "TYPE_SUBMIT", "SET_TEXT", "INCREMENT", "DECREMENT", "SUBMIT"})
+
+# Proven refusals and outcomes settle/resolve reconciled; any other outcome, unfamiliar ones too, blocks a replay.
+RELEASING_OUTCOMES = frozenset({
+    "not_dispatched",
+    "failed_pre_dispatch",
+    "observed_absent",  # a fresh look after an unknown outcome showed the action did not happen (settle)
+    "resolved",  # the same effect, sent again after that look or with the person's OK, came back answered
+})
+
+# A refusal before anything was sent. It releases a slot nothing was sent through, never one an earlier send holds.
+PRE_DISPATCH_REFUSALS = frozenset({"not_dispatched", "failed_pre_dispatch"})
+
+# Times a look showing nothing happened can release one unknown outcome; a retry unknown again stays held.
+RETRY_LIMIT = 1
+
+
+class EffectLedger:
+    def __init__(self):
+        self._effects = {}
+
+    @staticmethod
+    def _key(operation, target_id, text=None, effect=None):
+        if effect is not None:
+            return effect
+        return (operation, target_id, text)
+
+    def would_duplicate(self, operation, target_id, text=None, *, effect=None):
+        """Whether this effect was already attempted on this run with an acknowledged or unknown outcome."""
+        if operation not in PERSISTENT_OPERATIONS:
+            return False
+        record = self._effects.get(self._key(operation, target_id, text, effect))
+        return record is not None and record["outcome"] not in RELEASING_OUTCOMES
+
+    def record_outcome(self, operation, target_id, text=None, outcome="acknowledged", *,
+                       effect=None, context=None):
+        """Record a dispatch outcome: only a pre-dispatch refusal releases the slot; unknown is never retried."""
+        if operation not in PERSISTENT_OPERATIONS:
+            return
+        if not isinstance(outcome, str) or not outcome:
+            raise ValueError("Effect outcome must be a non-empty string")
+        key = self._key(operation, target_id, text, effect)
+        record = self._effects.get(key)
+        if (record is not None and outcome in PRE_DISPATCH_REFUSALS
+                and record["outcome"] not in RELEASING_OUTCOMES):
+            return  # a later refusal says nothing about the earlier attempt, which may have run
+        if record is None:
+            record = {"operation": operation, "target_id": target_id, "text": text}
+            self._effects[key] = record
+        record["outcome"] = outcome
+        if context is not None:
+            record["context"] = context
+
+    def lookup(self, operation, target_id, text=None, *, effect=None):
+        """A copy of this logical effect's record (operation, outcome, context...), or None."""
+        record = self._effects.get(self._key(operation, target_id, text, effect))
+        return dict(record) if record is not None else None
+
+    def held(self, match):
+        """Keys of the effects still held back (a blocking outcome) whose record ``match(key, record)`` accepts."""
+        return [key for key, record in self._effects.items()
+                if record["outcome"] not in RELEASING_OUTCOMES and match(key, dict(record))]
+
+    def settle(self, operation, target_id, text=None, *, effect=None, happened):
+        """Settle an unknown outcome from a look: happened holds it, not happened releases it RETRY_LIMIT times."""
+        record = self._effects.get(self._key(operation, target_id, text, effect))
+        if record is None or record["outcome"] != "unknown":
+            return record["outcome"] if record is not None else None
+        if happened:
+            record["outcome"] = "observed_change"
+        elif record.get("retries", 0) < RETRY_LIMIT:
+            record["outcome"] = "observed_absent"
+            record["retries"] = record.get("retries", 0) + 1
+        return record["outcome"]
+
+    def resolve(self, operation, target_id, text=None, *, effect=None):
+        """The same effect was sent again and came back answered: nothing is unknown, and its retries start over."""
+        record = self._effects.get(self._key(operation, target_id, text, effect))
+        if record is not None and record["outcome"] in ("unknown", "observed_absent"):
+            record["outcome"], record["retries"] = "resolved", 0

mobile_agent/engine_health.py

@@ -0,0 +1,378 @@
+"""One answer to "is the engine OK?": the state every surface shows. Its words and fix are a row of ``states.ROWS``."""
+
+import threading
+import time
+
+from .states import (
+    DOWN,
+    FROZEN,
+    HELPER_DOWN,
+    LIVE_OFF,
+    MODEL_UNAVAILABLE,
+    NO_PHONE,
+    READY,
+    RESTARTING,
+    ROWS,
+    SLOW,
+    STOPPING,
+    WAITING_FOR_PHONE,
+    fix_public,
+    row,
+    words,
+)
+
+# The state said first when several stand, most blocking first. A state not in the list never outranks one that is.
+PRIORITY = (STOPPING, MODEL_UNAVAILABLE, LIVE_OFF, NO_PHONE, HELPER_DOWN, WAITING_FOR_PHONE)
+
+TOPIC = "engine"
+EVENT = "engine_health"
+
+# Worst-case detection (device_manager.PROBE_TICK + PROBE_INTERVAL + wda_ready + PROBE_TIMEOUT + SAMPLE_S) must stay <=
+# NAMED_WITHIN_S; test_engine_health asserts it.
+SAMPLE_S = 1.0
+SLOW_AFTER_S = 3.0
+FROZEN_AFTER_S = 8.0
+NAMED_WITHIN_S = 10.0
+
+ACTION_UNKNOWN_STEP = ("An action was on its way when the phone went away. Mobster looks at the screen before it goes "
+                       "on and doesn't send that action again.")
+
+# The causes a helper log line or a phone state can name (runner_hints.RUNNER_HINTS).
+PHONE_CAUSES = frozenset(r.cause for r in ROWS if r.state == WAITING_FOR_PHONE and "app" in r.surfaces)
+TASK_WAIT_CAUSES = {"lock_screen": "locked", "passcode_keypad": "locked", "unplugged": "unplugged",
+                    "wifi_lost": "wifi_lost"}
+
+
+def task_wait(kind, phone=None):
+    """(need, sentence) for what a task waits on (``handoff_waiting``'s kind), or None for a kind that has no words."""
+    cause = TASK_WAIT_CAUSES.get(kind)
+    if cause is None:
+        return None
+    _message, step, need = words(WAITING_FOR_PHONE, cause, phone)
+    return need, step
+
+
+class Condition:
+    """One thing that is not as it should be."""
+
+    __slots__ = ("state", "cause", "message", "next_step", "need", "fix", "since", "device", "device_name", "task",
+                 "midrun", "action_unknown", "seconds")
+
+    def __init__(self, state, cause, *, since, phone=None, message=None, device=None, task=None, midrun=False,
+                 action_unknown=False, seconds=None):
+        self.state, self.cause, self.since = state, cause, since
+        self.message, self.next_step, self.need = words(state, cause, phone, message)
+        self.fix = row(cause).fix
+        if action_unknown:
+            self.next_step = f"{self.next_step} {ACTION_UNKNOWN_STEP}"
+        self.device, self.device_name = device, phone
+        self.task, self.midrun, self.action_unknown, self.seconds = task, midrun, action_unknown, seconds
+
+    def public(self):
+        value = {"state": self.state, "cause": self.cause, "message": self.message, "next_step": self.next_step,
+                 "fix": fix_public(self.fix), "since": self.since}
+        if self.need:
+            value["need"] = self.need
+        if self.device:
+            value["device"] = self.device
+        if self.device_name:
+            value["device_name"] = self.device_name
+        if self.task:
+            value.update(task=self.task, midrun=self.midrun)
+            if self.action_unknown:
+                value["action_unknown"] = True
+            if self.seconds:
+                value["wait_seconds"] = self.seconds
+        return value
+
+
+class EngineHealth:
+    """The newest condition of each source, the one to say first, and a publish when it changes."""
+
+    def __init__(self, clock=time.time, publish=None, boot=None):
+        self.clock = clock
+        self.publish = publish
+        self.boot = boot
+        self.lock = threading.Lock()
+        self.conditions = {}
+        self.sampled_at = None
+        self._said = None
+
+    def report(self, source, state, cause, *, phone=None, message=None, device=None, task=None, midrun=False,
+               action_unknown=False, seconds=None):
+        """``source`` is in this state now, for this cause. The same state and cause again keeps their ``since``."""
+        with self.lock:
+            found = self.conditions.get(source)
+            same = found is not None and (found.state, found.cause) == (state, cause)
+            self.conditions[source] = Condition(
+                state, cause, since=found.since if same else self.clock(), phone=phone, message=message,
+                device=device, task=task, midrun=midrun, action_unknown=action_unknown, seconds=seconds)
+        self._publish_if_changed()
+
+    def clear(self, source):
+        """``source`` is fine now."""
+        with self.lock:
+            self.conditions.pop(source, None)
+        self._publish_if_changed()
+
+    def clear_prefix(self, prefix, keep=()):
+        """Every source starting with ``prefix`` is fine now."""
+        with self.lock:
+            for source in [s for s in self.conditions if s.startswith(prefix) and s not in keep]:
+                del self.conditions[source]
+        self._publish_if_changed()
+
+    def sampled(self):
+        """The sampler finished a pass (its time is the snapshot's ``observed_at``)."""
+        with self.lock:
+            self.sampled_at = self.clock()
+
+    def _ordered(self):
+        rank = {state: index for index, state in enumerate(PRIORITY)}
+        return sorted(self.conditions.items(), key=lambda item: (rank.get(item[1].state, len(rank)), item[1].since,
+                                                                 item[0]))
+
+    def snapshot(self):
+        """The state to say first (``ready`` when nothing is wrong), with every standing issue and the liveness."""
+        with self.lock:
+            ordered = self._ordered()
+            now = self.clock()
+            observed = self.sampled_at if self.sampled_at is not None else now
+        if ordered:
+            first = ordered[0][1].public()
+        else:
+            first = {"state": READY, "cause": None, "message": "Ready.", "next_step": None,
+                     "fix": None, "since": observed}
+        return {**first, "observed_at": observed, "issues": [c.public() | {"source": s} for s, c in ordered],
+                "liveness": {"boot": self.boot, "sample_s": SAMPLE_S, "slow_after_s": SLOW_AFTER_S,
+                             "frozen_after_s": FROZEN_AFTER_S}}
+
+    def _publish_if_changed(self):
+        with self.lock:
+            said = tuple((s, c.state, c.cause, c.action_unknown) for s, c in self._ordered())
+            if said == self._said:
+                return
+            self._said = said
+        if callable(self.publish):
+            self.publish(TOPIC, {"event": EVENT, **self.snapshot()})
+
+
+def cause_of(snapshot, source):
+    """The cause ``source`` stands in in a snapshot (``phone:primary``, ``model``), or None when it is fine."""
+    return next((issue["cause"] for issue in snapshot.get("issues", ()) if issue.get("source") == source), None)
+
+
+def classify_phone(reading):
+    """(state, cause) for what a phone's helper and link say, or None when ready; a None fact is unknown,
+    never a reason."""
+    if reading.get("exposed"):
+        return HELPER_DOWN, "exposed"
+    if reading.get("expired"):
+        return HELPER_DOWN, "signature_expired"
+    if not reading.get("chosen"):
+        return NO_PHONE, "none_chosen"
+    if reading.get("wifi"):
+        if reading.get("wifi_lost"):
+            return WAITING_FOR_PHONE, "wifi_lost"
+    elif reading.get("usb") is False:
+        return WAITING_FOR_PHONE, "unplugged"
+    if not reading.get("built"):
+        return HELPER_DOWN, "not_built"
+    runner, hint = reading.get("runner"), reading.get("hint")
+    if runner == "running":
+        if reading.get("locked") is True:
+            return WAITING_FOR_PHONE, "locked"
+        if reading.get("responsive") is False:
+            return WAITING_FOR_PHONE, "not_responding"
+        return None
+    if reading.get("holding") == "unlock":
+        return WAITING_FOR_PHONE, "locked"
+    if hint in PHONE_CAUSES:
+        return WAITING_FOR_PHONE, hint
+    if runner == "failed":
+        return HELPER_DOWN, "failing"
+    if runner == "starting":
+        return WAITING_FOR_PHONE, "helper_restarting"
+    return HELPER_DOWN, "stopped"
+
+
+def classify_model(available, reason, credit_reasons=(), has_key=True):
+    """(state, cause, message) for whether Smart's model can run, or None when it can."""
+    if available:
+        return None
+    if not has_key:
+        return MODEL_UNAVAILABLE, "no_key", reason
+    return MODEL_UNAVAILABLE, "no_credit" if reason in credit_reasons else "key_rejected", reason
+
+
+def action_in_flight(events):
+    """Whether the newest decision of a run sent an action that has no result yet; an unreadable decision counts."""
+    done = {"frontier_action", "frontier_failed"}
+    results = 0
+    for event in reversed(events[-400:]):
+        name = event.get("event")
+        if name in done:
+            results += 1
+        elif name == "frontier_decision":
+            ops = event.get("ops")
+            if not isinstance(ops, list):
+                return True
+            acting = sum(op not in (None, "DONE", "BLOCKED", "WAIT") for op in ops)
+            return acting > results
+    return False
+
+
+def task_condition(run_id, wait, events, phone=None, device=None):
+    """The ``Condition`` arguments of a task waiting on the phone (``run.phone_wait``'s dict)."""
+    cause = TASK_WAIT_CAUSES.get(wait.get("kind"))
+    if cause is None:
+        return None
+    return dict(state=WAITING_FOR_PHONE, cause=cause, phone=phone, device=device, task=run_id,
+                midrun=wait.get("midrun") is True, action_unknown=wait.get("midrun") is True
+                and action_in_flight(events),
+                seconds=wait.get("seconds"))
+
+
+def from_silence(age_s=None, *, refused=False, boot=None, seen_boot=None, thresholds=None):
+    """The state a process that can't say it for itself is in, from the asker's side."""
+    slow, frozen = (thresholds or (SLOW_AFTER_S, FROZEN_AFTER_S))
+    if boot is not None and seen_boot is not None and boot != seen_boot:
+        state, cause = RESTARTING, "restarted"
+    elif refused:
+        state, cause = DOWN, "not_running"
+    elif age_s is None or age_s < slow:
+        return None
+    elif age_s < frozen:
+        state, cause = SLOW, "slow_answer"
+    else:
+        state, cause = FROZEN, "no_answer"
+    message, step, _need = words(state, cause)
+    return {"state": state, "cause": cause, "message": message, "next_step": step, "fix": fix_public(row(cause).fix)}
+
+
+def read_from_app(url=None, *, origin="cli", timeout=4.0, connect=None):
+    """The Mac app's engine state as an asker sees it: its snapshot, or what its silence is (``from_silence``: frozen
+    when it accepted the connection and never answered, down when the connection was refused). None when it can't be
+    asked (it refused the token). ``connect`` replaces ``Client.connect`` in tests."""
+    from .threads.client import Client, NoService, ServiceError
+    try:
+        return (connect or Client.connect)(url=url, origin=origin, timeout=timeout).status.get("engine")
+    except NoService as silent:
+        return from_silence(FROZEN_AFTER_S if silent.frozen else None, refused=not silent.frozen)
+    except ServiceError:
+        return None
+
+
+class Sampler:
+    """Reads a ``Runtime``'s detectors (model, live runs, phones, waiting tasks) into its ``EngineHealth``."""
+
+    def __init__(self, runtime, interval=SAMPLE_S):
+        self.runtime, self.interval = runtime, interval
+        self.stop = threading.Event()
+        self.thread = None
+        self.pass_lock = threading.Lock()
+
+    @property
+    def health(self):
+        return self.runtime.engine_health
+
+    def start(self):
+        if self.thread is None:
+            self.thread = threading.Thread(target=self._loop, name="mobster-engine-health", daemon=True)
+            self.thread.start()
+
+    def close(self):
+        self.stop.set()
+        if self.thread is not None and self.thread is not threading.current_thread():
+            self.thread.join(2.0)
+
+    def _loop(self):
+        while not self.stop.is_set():
+            self.sample()
+            self.stop.wait(self.interval)
+
+    def snapshot(self):
+        if self.thread is None or not self.thread.is_alive():
+            self.sample()
+        return self.health.snapshot()
+
+    def sample(self):
+        """One pass. A detector that raises leaves its source as it was and is logged:
+        a failed read never says ready."""
+        if not self.pass_lock.acquire(blocking=False):
+            return   # a pass is running (the thread's, or another asker's): its answer is the answer
+        try:
+            for part in (self._engine, self._model, self._phones, self._tasks):
+                try:
+                    part()
+                except Exception:  # noqa: BLE001 -- one detector's failure never hides the others
+                    from . import harness_api
+                    harness_api.log.exception("engine health: a detector failed")
+            self.health.sampled()
+        finally:
+            self.pass_lock.release()
+
+    def _set(self, source, found, **fields):
+        """Report ``found`` ((state, cause) or None) for ``source``."""
+        if found is None:
+            self.health.clear(source)
+        else:
+            self.health.report(source, found[0], found[1], **fields)
+
+    def _engine(self):
+        runtime = self.runtime
+        self._set("engine", (STOPPING, "closing") if runtime.closing else None)
+        self._set("live", None if getattr(runtime.config, "enable_live", True) else (LIVE_OFF, "disabled"))
+
+    def _model(self):
+        from . import engines
+        state = self.runtime.engines_status()[engines.SMART]
+        found = classify_model(state["available"], state["reason"], engines.CREDIT_REASONS,
+                               has_key=bool(engines.smart_key()) or self.runtime.scripted_models())
+        if found is None:
+            self.health.clear("model")
+        else:
+            self.health.report("model", found[0], found[1], message=found[2])
+
+    def _phones(self):
+        runtime = self.runtime
+        if runtime.pool is not None:
+            return   # a target with its own pool of phones says its own
+        fleet = getattr(runtime, "fleet", None)
+        seen = set()
+        primary_name = getattr(getattr(fleet, "primary", None), "name", None) or None
+        if runtime.manager is not None:
+            found = classify_phone(runtime.manager.engine_reading())
+        elif getattr(runtime.config, "wda_url", None):
+            found = None if runtime.target_status()["ready"] else (HELPER_DOWN, "not_answering")
+        else:
+            found = (NO_PHONE, "none_attached")
+        self._phone("phone:primary", found, primary_name, getattr(getattr(fleet, "primary", None), "id", None), seen)
+        for phone in list(getattr(fleet, "phones", {}).values()):
+            if phone.manager is not None:
+                found = classify_phone(phone.manager.engine_reading())
+            else:
+                found = None if phone.target_status()["ready"] else (HELPER_DOWN, "not_answering")
+            self._phone(f"phone:{phone.id}", found, phone.name, phone.id, seen)
+        self.health.clear_prefix("phone:", keep=seen)
+
+    def _phone(self, source, found, name, device, seen):
+        seen.add(source)
+        self._set(source, found, phone=name, device=device)
+
+    def _tasks(self):
+        from .run import phone_wait
+        seen = set()
+        for run in list(self.runtime.runs.values()):
+            if run.finished_at is not None:
+                continue
+            with run.condition:
+                events = list(run.events[-400:])
+            wait = phone_wait(events)
+            fields = task_condition(run.id, wait, events, run.device_name, run.device_id) if wait else None
+            if fields is None:
+                continue
+            source = f"task:{run.id}"
+            seen.add(source)
+            self.health.report(source, fields.pop("state"), fields.pop("cause"), **fields)
+        self.health.clear_prefix("task:", keep=seen)

mobile_agent/engine_hooks.py

@@ -0,0 +1,96 @@
+"""The harness's harness_api.EngineHooks: what the engine reaches in the full Mobster."""
+
+
+class Harness:
+    def __init__(self):
+        self.target_driver, self.cli, self.runtime_for = None, [], None
+
+    def model_routes(self):
+        from .ai_plans import providers
+        return providers
+
+    def key(self, provider, env):
+        from . import keys
+        return (keys.anthropic_key if provider == "anthropic" else keys.openai_key)(env)
+
+    def tool_policy(self, skills, *, run_context, driver, guard):
+        from .harness.tools import offered
+        return offered(skills, run_context=run_context, driver=driver, guard=guard)
+
+    def first_screen(self, driver, run_context):
+        from .harness.prewarm import take
+        return take(driver, run_context)
+
+    def private_rects(self, elements, bundle_id):
+        from .run_gif import private_rects
+        return private_rects(elements, bundle_id)
+
+    def long_report(self):
+        from .longform import report
+        return report
+
+    def wifi_attached(self, udid):
+        from .wireless import transport
+        value = transport.attached(udid)
+        return (False, None) if value is transport.NOT_WIFI else (True, value)
+
+    def wifi_lost(self, udid):
+        from .wireless import transport
+        return transport.lost(udid)
+
+    def wifi_may_reach(self, udid):
+        from .paths import user_data_dir
+        from .wireless import store, transport, transport_on
+        return transport_on() and transport.link(udid) is None and store.enabled(user_data_dir(), udid)
+
+    def usb_attached(self, udid):
+        from .mac_tools import usb_attached
+        return usb_attached(udid)
+
+    def devicectl_json(self, args, timeout):
+        from .wireless import devicectl
+        return devicectl.run_json(args, timeout)
+
+    def coredevice_locked(self, udid):
+        from .wireless import devicectl
+        return devicectl.read_lock_state(udid)
+
+    def coredevice_apps(self, udid, kind):
+        from .wireless import devicectl
+        return devicectl.read_apps(udid, kind)
+
+    def track_disabled(self, track, reason):
+        from . import tracks
+        tracks.disable(track, reason)
+
+    def hedge(self):
+        from . import hedge
+        return hedge
+
+    def skills(self):
+        from .skills import default_skills
+        return default_skills()
+
+    def app_catalog(self):
+        from .catalog import APPS
+        return APPS
+
+    def image_policy(self):
+        from . import image_policy
+        return image_policy
+
+    def frame_clock(self):
+        from .wda import frame_clock
+        return frame_clock
+
+    def ios_slice(self, snapshot, request, driver):
+        from .ios.guide import turn_slice
+        return turn_slice(snapshot, request, driver)
+
+    def screen_text(self):
+        from .screen_text import reader
+        return reader()
+
+    def pixel_screen(self):
+        from . import perception
+        return perception