@melaya/runner 1.0.94 → 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:
@@ -450,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:
@@ -482,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.94",
+  "version": "1.0.95",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,