@melaya/runner 1.0.94 → 1.0.96

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:
@@ -213,7 +237,10 @@ def _build_agent():
         "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, "
+        "only — not routine ones. Do NOT call phone_ask_user to cope with repeated tool "
+        "ERRORS or because you feel stuck/struggling — that is a failure to REPORT, not a "
+        "decision for the user; stop and report what failed instead. Only ask for a genuine "
+        "who/which fork. 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 "
@@ -450,6 +477,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 +512,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

@@ -77,11 +77,42 @@ export async function connect(opts) {
             const localVersion = getLocalSharedVersion();
             if (!localVersion)
                 return; // nothing cached yet — let assistant_start do it
-            const { ensurePythonEnv } = await import("./pythonEnv.js");
-            await ensurePythonEnv(opts.pythonPath, localVersion, (m) => { if (opts.verbose)
+            const { ensurePythonEnv, getCertBundlePath } = await import("./pythonEnv.js");
+            const envResult = await ensurePythonEnv(opts.pythonPath, localVersion, (m) => { if (opts.verbose)
                 console.log(chalk.gray(`  [assistant prewarm] ${m}`)); });
             if (opts.verbose)
                 console.log(chalk.gray("  [assistant prewarm] ready"));
+            // ALSO pre-import the heavy Python stack so the first real run/chat
+            // doesn't pay the ~6s cold `import shared.runtime.registry`. Spawn it
+            // detached + fire-and-forget with the SAME PYTHONPATH/env a real
+            // pipeline spawn uses (see the runner:run handler below) so `shared.*`
+            // resolves; this heats the OS file cache + bytecode. Never blocks
+            // connect, never throws — swallow everything. Only when a shared
+            // bundle exists locally (mirror the ensurePythonEnv guard above).
+            if (envResult.ok) {
+                try {
+                    const sharedDir = getSharedDir();
+                    if (existsSync(sharedDir)) {
+                        const certBundle = getCertBundlePath();
+                        const warmEnv = {
+                            ...process.env,
+                            PYTHONPATH: sharedDir,
+                            PYTHONIOENCODING: "utf-8",
+                            PYTHONUTF8: "1",
+                            ...(certBundle ? { SSL_CERT_FILE: certBundle, REQUESTS_CA_BUNDLE: certBundle } : {}),
+                        };
+                        const warmChild = spawn(envResult.pythonPath, ["-c", "import shared.runtime.registry"], { env: warmEnv, stdio: "ignore" });
+                        warmChild.on("error", () => { });
+                        warmChild.on("exit", (code) => {
+                            if (code === 0 && opts.verbose) {
+                                console.log(chalk.gray("  [assistant prewarm] import-warmed"));
+                            }
+                        });
+                        warmChild.unref();
+                    }
+                }
+                catch { /* fire-and-forget — never throw */ }
+            }
         }
         catch (e) {
             if (opts.verbose)
@@ -907,6 +938,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 +1016,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.96",
   "description": "Run Melaya AI pipelines locally with your own LM Studio or Ollama models",
   "license": "UNLICENSED",
   "private": false,