@melaya/runner 1.0.93 → 1.0.95

package/dist/assistantHost.py

@@ -95,6 +95,30 @@ if not isinstance(sys.stdout, _RedactingStdout):
     sys.stdout = _RedactingStdout(sys.stdout)
 
 
+_HITL_MODES = ("safe", "autonomous", "payments_only")
+
+
+def _apply_hitl_mode(mode: str | None) -> None:
+    """Set the assistant autonomy mode env AND mirror it into MEL_HITL_MODE.
+
+    The runner spawns this host with MEL_ASSISTANT_HITL_MODE (the assistant's
+    autonomy mode). The connector-write gate (lazy_registry._maybe_gate_write)
+    reads MEL_ASSISTANT_HITL_MODE, but phone.py._cmd — running INSIDE this same
+    host process — stamps the device command body from MEL_HITL_MODE. So we
+    MIRROR the assistant mode into MEL_HITL_MODE here, giving the phone tools
+    the operator's choice too. Called once at boot and again per turn (the TS
+    side passes an updated `hitl_mode` on each turn payload; absent ⇒ keep the
+    current/spawn value). Unknown / empty ⇒ "safe" (fail-safe)."""
+    if mode is None:
+        # Boot-time mirror: honour whatever the runner exported at spawn.
+        mode = os.environ.get("MEL_ASSISTANT_HITL_MODE", "safe")
+    normalized = (str(mode or "safe")).strip().lower()
+    if normalized not in _HITL_MODES:
+        normalized = "safe"
+    os.environ["MEL_ASSISTANT_HITL_MODE"] = normalized
+    os.environ["MEL_HITL_MODE"] = normalized
+
+
 def _emit(turn_id: str, kind: str, **fields) -> None:
     """Write one structured event line to stdout (flushed) for the runner to relay."""
     try:
@@ -205,13 +229,19 @@ def _build_agent():
         "TikTok). Opening the wrong app is a FAILED task, not a reasonable default. "
         "After the user authorizes the app, phone_list_apps reflects it immediately — "
         "re-check and open the REQUESTED app.\n"
-        "- You are FULLY AUTONOMOUS on the phone: NEVER ask the user a question, "
-        "never end your turn asking for confirmation or offering a choice — make the "
-        "reasonable decision and DO it (the ONE exception is the EXACT-APP rule above: "
-        "a missing app is a stop, not a substitution). If a feed is algorithmic, use "
-        "the app's own Search / Explore to find the right content yourself. Keep going "
-        "until the task is COMPLETE (e.g. all N comments posted) or you are genuinely "
-        "blocked; only then report what you did and what (if anything) is blocked.\n"
+        "- You are AUTONOMOUS on the phone: for routine choices, make the reasonable "
+        "decision and DO it — never stall the run by ENDING YOUR TURN to ask in chat. "
+        "But when you hit a GENUINE fork you cannot reasonably resolve on your own (which "
+        "of several accounts to act as, a truly ambiguous target, a risky irreversible "
+        "step), or you want a go/no-go before continuing a long task, call "
+        "phone_ask_user(question): it expands the Melaya tile ON THE PHONE into a reply "
+        "card and BLOCKS for the user's typed answer WITHOUT ending your turn, so the run "
+        "continues seamlessly the moment they reply. Use it SPARINGLY, for real decisions "
+        "only — not routine ones. The EXACT-APP rule still holds (a missing app is a stop, "
+        "not a substitution). If a feed is algorithmic, use the app's own Search / Explore "
+        "to find the right content yourself. Keep going until the task is COMPLETE (e.g. "
+        "all N comments posted) or you are genuinely blocked; only then report what you "
+        "did and what (if anything) is blocked.\n"
         if phone_enabled else ""
     )
     connector_rule = (
@@ -246,13 +276,16 @@ def _build_agent():
         model_name=model,
         provider=provider,
         api_key="",  # model.py resolves the provider's own creds (OAuth off disk / localhost)
-        # Phone tasks are many-step (each comment ≈ screen_tree→tap→type→post), so
-        # give them room like the device template (40); read-only Q&A needs few.
-        # Connector WRITE tasks are equally many-step (e.g. "message all my recent
-        # LinkedIn connections" = 1 list + N sends, each its own reasoning+HITL
-        # round), so they need the same headroom — 8 hit the cap mid-task and
-        # forced _summarizing() on a half-finished tool batch.
-        max_iters=40 if (phone_enabled or connector_services) else 8,
+        # Phone tasks that act on N items ("like + comment on 10 posts") take
+        # ~10-15 tool calls EACH (screen_tree→read→tap→type→post_comment→verify→
+        # swipe to the next), so a flat 40 capped a 10-post run at ~3 done and
+        # forced a mid-task stop — which also ends the turn and tears down the
+        # phone working-overlay, snapping the phone back to the Melaya app before
+        # the task is finished. Give phone runs real headroom (they are HITL-gated,
+        # so each write still needs the user's tap — cost stays bounded). Connector
+        # WRITE fan-outs (1 list + N sends, each its own reasoning+HITL round) keep
+        # the 40 that fits them; read-only Q&A needs very few.
+        max_iters=100 if phone_enabled else (40 if connector_services else 8),
         reliability=True,
         bounded_memory=True,
     )
@@ -441,6 +474,9 @@ def _stdin_reader(q: "queue.Queue[str]") -> None:
 
 def main() -> int:
     _log(f"booting (provider={os.environ.get('MEL_ASSISTANT_PROVIDER')})")
+    # Mirror the spawn-time assistant autonomy mode into MEL_HITL_MODE so the
+    # in-process phone tools (phone.py._cmd) see it from turn one.
+    _apply_hitl_mode(None)
     try:
         agent = _build_agent()
     except Exception as exc:
@@ -473,6 +509,13 @@ def main() -> int:
             continue
         turn_id = str(req.get("turnId") or "")
         message = str(req.get("message") or "")
+        # Per-turn autonomy mode: the TS side carries an updated `hitl_mode`
+        # on runner:assistant_turn so a mid-session flip takes effect next
+        # turn. Absent ⇒ keep the current (spawn / previous-turn) mode. The
+        # connector gate + phone tools read the env at call-time, so setting
+        # it here (before _run_turn) is enough — no agent rebuild needed.
+        if "hitl_mode" in req:
+            _apply_hitl_mode(req.get("hitl_mode"))
         if not message:
             _emit(turn_id, "done")
             continue

package/dist/connection.js

@@ -907,6 +907,21 @@ export async function connect(opts) {
                 MEL_ASSISTANT_CONNECTORS: Array.isArray(payload.connectors) ? payload.connectors.join(",") : "",
                 // Gate write connector-tools behind the in-chat approval card (fail-safe).
                 MEL_ASSISTANT_CONNECTOR_HITL: Array.isArray(payload.connectors) && payload.connectors.length ? "1" : "",
+                // HITL autonomy mode ("safe" | "autonomous" | "payments_only"). The host
+                // reads this at start; each turn's frame can flip it (see assistant_turn).
+                // Fail-safe: unknown ⇒ "safe".
+                MEL_ASSISTANT_HITL_MODE: (payload.hitlMode === "autonomous" || payload.hitlMode === "payments_only") ? payload.hitlMode : "safe",
+                // Run context for phone-driving assistant turns. The assistant host has
+                // no pipeline MEL_RUN_ID, so without this phone.py._cmd omits `run_id`,
+                // the server's arm block (phone.ts, `if (runId)`) never fires, and the
+                // device never receives `hitlMode` — Autonomous still shows publish
+                // cards on the runner-assistant surface. Use the SAME stable
+                // `assistant:{userId}` runId the cloud assistant path uses (sid is
+                // `userId:conversationId`) so the arm / kill / active-run plumbing stays
+                // consistent across surfaces. assistantHost mirrors MEL_ASSISTANT_HITL_MODE
+                // → MEL_HITL_MODE so phone.py stamps the mode on the command body.
+                MEL_RUN_ID: `assistant:${sid.split(":")[0]}`,
+                MEL_PIPELINE_NAME: "Melaya · Assistant",
                 // Luma browser bridge (same injection as pipeline runs, line ~431): lets
                 // shared/tools/luma.py route /event/register through Playwright and bypass
                 // Cloudflare's write rule. Reads keep using aiohttp. Empty when no signed-in
@@ -970,8 +985,12 @@ export async function connect(opts) {
             return;
         }
         s.lastActivity = Date.now();
+        // Per-turn hitl_mode: the host applies it to os.environ["MEL_ASSISTANT_HITL_MODE"]
+        // (mirrored to MEL_HITL_MODE) BEFORE running the turn, so a mid-session flip
+        // takes effect on the very next message. Fail-safe: unknown ⇒ "safe".
+        const hitlMode = (payload.hitlMode === "autonomous" || payload.hitlMode === "payments_only") ? payload.hitlMode : "safe";
         try {
-            s.proc.stdin?.write(JSON.stringify({ turnId: payload.turnId, message: payload.message }) + "\n");
+            s.proc.stdin?.write(JSON.stringify({ turnId: payload.turnId, message: payload.message, hitl_mode: hitlMode }) + "\n");
         }
         catch (e) {
             socket.emit("runner:assistant_event", { sessionId: payload.sessionId, turnId: payload.turnId, kind: "error", message: `turn write failed: ${e?.message || e}` });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@melaya/runner",
-  "version": "1.0.93",
+  "version": "1.0.95",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,