@melaya/runner 1.1.46 → 1.1.48

package/dist/assistantHost.py

@@ -230,21 +230,47 @@ class _RedactingStdout:
     def _scrub(self, s: str) -> str:
         return self._B64.sub(lambda m: f"<redacted base64 {len(m.group(0))} bytes>", s)
 
+    def _flush_transcript(self):
+        # Send any buffered agentscope transcript to STDERR (redacted). Keeping it
+        # off stdout means the runner's stdout channel carries ONLY `MELASSIST `
+        # protocol frames: a transcript print can never glue onto a frame and be
+        # dropped (the missing-delta / garbled-fragment bug), and frame parsing on
+        # the runner stays cheap — no multi-KB base64 transcript lines flooding its
+        # event loop (which was spiking lag and dropping the socket heartbeat).
+        if self._buf:
+            try:
+                sys.stderr.write(self._scrub(self._buf))
+            except Exception:
+                pass
+            self._buf = ""
+
     def write(self, s):
         try:
+            # A protocol frame is emitted in ONE write() call, whole and
+            # newline-terminated (see _emit). Route it to the REAL stdout byte for
+            # byte (no scrub — frames are short structured JSON), after flushing any
+            # pending partial transcript so nothing can glue onto it.
+            if s.startswith(_EVENT_PREFIX):
+                self._flush_transcript()
+                self._real.write(s)
+                self._real.flush()
+                return len(s)
+            # Everything else = agentscope's verbatim message transcript → stderr,
+            # line-buffered + base64-redacted, so it never pollutes the protocol.
             self._buf += s
             while "\n" in self._buf:
                 line, self._buf = self._buf.split("\n", 1)
-                self._real.write(self._scrub(line) + "\n")
+                try:
+                    sys.stderr.write(self._scrub(line) + "\n")
+                except Exception:
+                    pass
             return len(s)
         except Exception:
             return self._real.write(s)
 
     def flush(self):
         try:
-            if self._buf:
-                self._real.write(self._scrub(self._buf))
-                self._buf = ""
+            self._flush_transcript()
             self._real.flush()
         except Exception:
             pass
@@ -1177,6 +1203,7 @@ def _stdin_reader(q: "queue.Queue[str]") -> None:
 
 
 def main() -> int:
+    _boot_t0 = time.perf_counter()
     _log(f"booting (provider={os.environ.get('MEL_ASSISTANT_PROVIDER')})")
     # Wire OpenTelemetry → Melaya event relay so agentscope's @trace_llm actually
     # exports token spans to agents.spans — the SAME thing pipelines get via
@@ -1195,7 +1222,9 @@ def main() -> int:
     # in-process phone tools (phone.py._cmd) see it from turn one.
     _apply_hitl_mode(None)
     try:
+        _t_agent = time.perf_counter()
         agent = _build_agent()
+        _log(f"[timing] _build_agent {time.perf_counter() - _t_agent:.2f}s")
     except Exception as exc:
         _log("boot failed:\n" + traceback.format_exc())
         _emit("", "error", message="The assistant could not start on this runner. " + _turn_error_message(exc))
@@ -1218,7 +1247,7 @@ def main() -> int:
         _log("compaction hooks unavailable (non-fatal)")
 
     _emit("", "ready", memoryWatermark=_memory_watermark(agent), hostInstanceId=_HOST_ID, generation=_GENERATION, configHash=_config_hash())
-    _log("ready")
+    _log(f"[timing] ready — {time.perf_counter() - _boot_t0:.2f}s (main start → ready). Import cost = gap from process spawn to the 'booting' line above.")
 
     q: "queue.Queue[str]" = queue.Queue()
     threading.Thread(target=_stdin_reader, args=(q,), daemon=True).start()

package/dist/connection.js

@@ -14,7 +14,7 @@ import { io } from "socket.io-client";
 import chalk from "chalk";
 import ora from "ora";
 import { spawn } from "child_process";
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from "fs";
+import { writeFileSync, mkdirSync, existsSync, readFileSync, copyFileSync } from "fs";
 import { dirname, join } from "path";
 import { fileURLToPath } from "url";
 import { tmpdir, homedir } from "os";
@@ -55,6 +55,20 @@ try {
 }
 catch { /* dev tree layout differs — non-fatal */ }
 const activeAssistants = new Map();
+// Line prefix the assistant host uses to frame protocol events on stdout
+// (mirror of assistantHost.py `_EVENT_PREFIX`). Everything else on stdout is
+// raw agentscope transcript (now routed to stderr host-side, but we still parse
+// defensively in case a frame arrives glued to a raw print).
+const _EVENT_PREFIX = "MELASSIST ";
+// Warm pool (size 1): a fully-booted host held in reserve, ready to be ADOPTED
+// by the next new session whose config+generation match — skipping the ~7s cold
+// boot (import + build_agent). Pure optimization: any mismatch or unhealthy
+// spare falls through to a normal fresh boot, so it can never break a session.
+let warmSpare = null;
+// The (env, config, generation) to prewarm the next spare with — learned from
+// the most recent real assistant_start so the spare matches the user's actual
+// usage. null until the first real boot teaches us a config.
+let warmSpareSeed = null;
 // PR4: sid-keyed boot reservation. The guard-then-spawn in runner:assistant_start
 // has an async gap (ensureSharedModules / ensurePythonEnv awaits) between the
 // activeAssistants.has() check and the .set(). A second assistant_start in that
@@ -1293,6 +1307,172 @@ export async function connect(opts) {
     // codex / ollama / lmstudio: assistant_start boots a long-lived host,
     // assistant_turn feeds one user message, and the host streams events back as
     // runner:assistant_event frames the server relays into the browser SSE.
+    // ── Warm-pool: spawn + wire an assistant host ────────────────────────────
+    // Used for a REAL session boot (forward=true) AND for a pooled spare
+    // (forward=false → the host's frames are suppressed until adoption re-points
+    // session.sid + flips forward). Reading session.sid/forward (not a captured
+    // constant) is what lets one process be adopted by a later sid. The `error`
+    // listener is registered UNCONDITIONALLY here — the old code nested it inside
+    // `exit`, so a spawn 'error' (which never fires 'exit') had no listener and
+    // took down the whole runner.
+    const launchAssistantHost = (a) => {
+        const proc = spawn(a.pythonPath, ["-u", a.stagedHost], { cwd: a.workDir, env: a.env, stdio: ["pipe", "pipe", "pipe"] });
+        const session = {
+            proc, sid: a.sid, forward: a.forward, ready: false, lastActivity: Date.now(),
+            stdoutBuf: "", generation: a.generation, memoryWatermark: 0, hostInstanceId: "", configHash: "", stderrTail: [],
+        };
+        console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant ${a.forward ? "session" : "spare"} ${a.sid.slice(0, 12)}… (${a.providerLabel})`));
+        proc.stdout?.on("data", (data) => {
+            session.lastActivity = Date.now();
+            session.stdoutBuf += data.toString();
+            let idx;
+            while ((idx = session.stdoutBuf.indexOf("\n")) >= 0) {
+                const line = session.stdoutBuf.slice(0, idx);
+                session.stdoutBuf = session.stdoutBuf.slice(idx + 1);
+                const t = line.trim();
+                // A protocol frame can arrive GLUED to a preceding raw print that had no
+                // trailing newline (agentscope prints the agent transcript to the same
+                // stdout), e.g. `Assistant: GotMELASSIST {"kind":"delta",…}`. Find the
+                // prefix ANYWHERE in the line, not just at the start, or that delta is
+                // dropped as raw output (the missing-deltas / garbled-fragment bug).
+                const mi = t.indexOf(_EVENT_PREFIX);
+                if (mi >= 0) {
+                    if (mi > 0 && opts.verbose)
+                        console.log(chalk.gray(`  [assistant-stdout] ${t.slice(0, mi)}`));
+                    try {
+                        const parsed = JSON.parse(t.slice(mi + _EVENT_PREFIX.length));
+                        if (typeof parsed?.memoryWatermark === "number")
+                            session.memoryWatermark = parsed.memoryWatermark;
+                        if (parsed?.kind === "ready") {
+                            if (typeof parsed.hostInstanceId === "string")
+                                session.hostInstanceId = parsed.hostInstanceId;
+                            if (typeof parsed.configHash === "string")
+                                session.configHash = parsed.configHash;
+                            session.ready = true;
+                            parsed.protocol = ASSISTANT_PROTOCOL_VERSION;
+                        }
+                        // A spare's frames are NOT forwarded (no session yet); adoption flips
+                        // session.forward and re-emits `ready` with the real sid.
+                        if (session.forward)
+                            socket.emit("runner:assistant_event", { sessionId: session.sid, ...parsed });
+                    }
+                    catch {
+                        // The literal "MELASSIST " appeared inside raw text (not a real frame)
+                        // — the JSON tail won't parse; treat the whole line as raw output.
+                        if (t && opts.verbose)
+                            console.log(chalk.gray(`  [assistant-stdout] ${t}`));
+                    }
+                }
+                else if (t && opts.verbose) {
+                    console.log(chalk.gray(`  [assistant-stdout] ${t}`));
+                }
+            }
+        });
+        proc.stderr?.on("data", (data) => {
+            for (const ln of data.toString().split("\n")) {
+                const t = ln.trimEnd();
+                if (!t)
+                    continue;
+                if (opts.verbose)
+                    console.log(chalk.gray(`  [assistant-stderr] ${t}`));
+                session.stderrTail.push(t);
+                if (session.stderrTail.length > 40)
+                    session.stderrTail.shift();
+            }
+        });
+        proc.on("error", (err) => {
+            if (warmSpare === session)
+                warmSpare = null;
+            if (activeAssistants.get(session.sid) === session)
+                activeAssistants.delete(session.sid);
+            bootingAssistants.delete(session.sid);
+            if (!session.forward) {
+                if (opts.verbose)
+                    console.log(chalk.gray(`  [prewarm] spare spawn error: ${err?.message || err}`));
+                return;
+            }
+            browserBridge?.teardownRunsForSession(session.sid, "assistant_spawn_error").catch(() => { });
+            socket.emit("runner:assistant_event", { sessionId: session.sid, turnId: "", kind: "error", message: `assistant host spawn failed: ${err?.message || err}` });
+        });
+        proc.on("exit", (code) => {
+            if (warmSpare === session)
+                warmSpare = null;
+            const weOwned = activeAssistants.get(session.sid) === session;
+            if (weOwned)
+                activeAssistants.delete(session.sid);
+            if (weOwned)
+                browserBridge?.teardownRunsForSession(session.sid, `assistant_exit:${code}`).catch(() => { });
+            if (!session.forward) {
+                if (opts.verbose)
+                    console.log(chalk.gray(`  ■ Assistant spare exited (${code}) pre-adoption`));
+                return;
+            }
+            if (session.killed) {
+                console.log(chalk.gray(`  ■ Assistant host ${session.sid.slice(0, 10)}… replaced (config drift, exit ${code})`));
+                return;
+            }
+            const detail = code !== 0 && session.stderrTail.length ? session.stderrTail.slice(-12).join("\n") : "";
+            socket.emit("runner:assistant_event", { sessionId: session.sid, turnId: "", kind: "session_closed", code, detail });
+            console.log(chalk.gray(`  ■ Assistant session ${session.sid.slice(0, 10)}… closed (exit ${code})`));
+        });
+        return session;
+    };
+    // Prewarm ONE spare from the most-recent real config so the next matching new
+    // session adopts it and skips the ~7s cold boot. Best-effort, ≤1 spare, kills a
+    // stale spare (config changed) first, self-destructs after 10 min if unused.
+    // Off by default: the adoption MECHANISM is proven, but a CLI-session provider
+    // (claude_code/codex keep a per-user CLI/OAuth session) can contend when a
+    // spare runs a turn alongside a live host — needs per-provider validation
+    // before it's on for everyone. Set MEL_ASSISTANT_WARM_POOL=1 to enable.
+    const WARM_POOL_ENABLED = process.env.MEL_ASSISTANT_WARM_POOL === "1";
+    let _prewarmInFlight = false;
+    const schedulePrewarm = () => {
+        if (!WARM_POOL_ENABLED || !warmSpareSeed || _prewarmInFlight)
+            return;
+        if (warmSpare) {
+            if (warmSpare.configHash && warmSpare.configHash !== warmSpareSeed.configHash) {
+                try {
+                    warmSpare.proc.kill();
+                }
+                catch { /* gone */ }
+                warmSpare = null;
+            }
+            else {
+                return;
+            }
+        }
+        _prewarmInFlight = true;
+        try {
+            const seed = warmSpareSeed;
+            const stamp = String(Date.now());
+            const wd = join(seed.workDirBase, `melaya-assistant-spare-${stamp}`);
+            mkdirSync(wd, { recursive: true });
+            const staged = join(wd, "assistantHost.py");
+            copyFileSync(seed.hostScript, staged);
+            // Keep seed.env's MEL_RUN_ID (`assistant:<userId>`, per-user, shared by all
+            // of a user's sessions) so an adopted spare's run context / tracing / phone
+            // arm plumbing matches the session that adopts it — overriding it to a
+            // spare-specific id broke turn execution on adoption.
+            const spareEnv = { ...seed.env };
+            const spare = launchAssistantHost({ env: spareEnv, pythonPath: seed.pythonPath, workDir: wd, stagedHost: staged, sid: `__spare__:${stamp}`, generation: seed.generation, forward: false, providerLabel: "prewarm" });
+            warmSpare = spare;
+            const t = setTimeout(() => { if (warmSpare === spare && !spare.forward) {
+                try {
+                    spare.proc.kill();
+                }
+                catch { /* gone */ }
+                warmSpare = null;
+            } }, 10 * 60_000);
+            t.unref?.();
+        }
+        catch (e) {
+            if (opts.verbose)
+                console.log(chalk.gray(`  [prewarm] launch failed: ${e?.message || e}`));
+        }
+        finally {
+            _prewarmInFlight = false;
+        }
+    };
     socket.on("runner:assistant_start", async (payload) => {
         const sid = String(payload.sessionId || "");
         if (!sid)
@@ -1328,6 +1508,25 @@ export async function connect(opts) {
                 return;
             }
         }
+        // Warm-pool ADOPTION (fast path). A fully-booted spare with the SAME config
+        // AND generation is waiting — re-point it to this sid and report ready
+        // immediately, skipping the ~7s cold boot (import + build_agent). Fail-safe:
+        // exact match of a READY, un-killed spare ONLY; anything else falls straight
+        // through to the fresh-boot path below, so the pool can never break a session.
+        if (!activeAssistants.has(sid) && !bootingAssistants.has(sid)
+            && warmSpare && warmSpare.ready && !warmSpare.killed && expectedConfig
+            && warmSpare.configHash === expectedConfig && warmSpare.generation === generation) {
+            const spare = warmSpare;
+            warmSpare = null;
+            spare.sid = sid;
+            spare.forward = true;
+            spare.lastActivity = Date.now();
+            activeAssistants.set(sid, spare);
+            console.log(chalk.green(`  ◆ Assistant ${sid.slice(0, 10)}… adopted warm spare — cold boot skipped`));
+            emitEv({ kind: "ready", memoryWatermark: spare.memoryWatermark || 0, generation: spare.generation, hostInstanceId: spare.hostInstanceId, configHash: spare.configHash, protocol: ASSISTANT_PROTOCOL_VERSION });
+            schedulePrewarm(); // refill the pool for the next session
+            return;
+        }
         // A boot is already in flight for this sid (concurrent start / server restart
         // mid-boot). Drop this duplicate — the in-flight boot will emit `ready`.
         if (bootingAssistants.has(sid))
@@ -1454,101 +1653,16 @@ export async function connect(opts) {
                 // Per-user creds (incl. MELAYA_API_KEY + the selected connectors' env).
                 ...(payload.credentials || {}),
             };
-            const proc = spawn(envResult.pythonPath, ["-u", stagedHost], { cwd: workDir, env, stdio: ["pipe", "pipe", "pipe"] });
-            // hostInstanceId + configHash are filled from the host's OWN `ready` frame
-            // (assistantHost.py _HOST_ID / _config_hash) as it boots — authoritative and
-            // server-aligned. Start empty; the stdout parser captures them.
-            const session = { proc, lastActivity: Date.now(), stdoutBuf: "", generation, memoryWatermark: 0, hostInstanceId: "", configHash: "" };
-            activeAssistants.set(sid, session);
-            console.log(chalk.hex("#7c6ff0")(`  ◆ Assistant session ${sid.slice(0, 10)}… (${payload.provider})`));
-            proc.stdout?.on("data", (data) => {
-                // ANY host output means the turn is actively working — refresh the idle
-                // clock. Without this, lastActivity was set ONLY at turn start (assistant_turn),
-                // so a SINGLE long turn (a phone task is one turn with ~100 tool calls streaming
-                // for >15 min) was reaped mid-action by the idle sweep despite continuous
-                // activity ("idle-swept" while properly working). Now only a genuinely silent
-                // host (no output for ASSISTANT_IDLE_MS) is swept.
-                session.lastActivity = Date.now();
-                session.stdoutBuf += data.toString();
-                let idx;
-                while ((idx = session.stdoutBuf.indexOf("\n")) >= 0) {
-                    const line = session.stdoutBuf.slice(0, idx);
-                    session.stdoutBuf = session.stdoutBuf.slice(idx + 1);
-                    const t = line.trim();
-                    if (t.startsWith("MELASSIST ")) {
-                        try {
-                            const parsed = JSON.parse(t.slice("MELASSIST ".length));
-                            // Track the host's latest memory watermark (ready / rehydrated
-                            // frames report it) so a re-`start` of the live host reports a
-                            // truthful watermark and the server skips a needless rehydrate.
-                            if (typeof parsed?.memoryWatermark === "number")
-                                session.memoryWatermark = parsed.memoryWatermark;
-                            // CAPTURE the host's authoritative identity off its `ready` frame
-                            // (_HOST_ID / _config_hash) so the live-host ready path can re-report
-                            // them without the host re-emitting; ADD only the wire protocol.
-                            if (parsed?.kind === "ready") {
-                                if (typeof parsed.hostInstanceId === "string")
-                                    session.hostInstanceId = parsed.hostInstanceId;
-                                if (typeof parsed.configHash === "string")
-                                    session.configHash = parsed.configHash;
-                                parsed.protocol = ASSISTANT_PROTOCOL_VERSION;
-                            }
-                            socket.emit("runner:assistant_event", { sessionId: sid, ...parsed });
-                        }
-                        catch { /* skip malformed */ }
-                    }
-                    else if (t && opts.verbose) {
-                        console.log(chalk.gray(`  [assistant-stdout] ${t}`));
-                    }
-                }
-            });
-            const stderrTail = [];
-            proc.stderr?.on("data", (data) => {
-                for (const ln of data.toString().split("\n")) {
-                    const t = ln.trimEnd();
-                    if (!t)
-                        continue;
-                    if (opts.verbose)
-                        console.log(chalk.gray(`  [assistant-stderr] ${t}`));
-                    stderrTail.push(t);
-                    if (stderrTail.length > 40)
-                        stderrTail.shift();
-                }
-            });
-            proc.on("exit", (code) => {
-                // Only evict if WE are still the registered host. A config-drift reboot
-                // (e.g. the user added a connector) kills this host and spawns a REPLACEMENT
-                // under the same sid; if this late exit deleted the map entry blindly it
-                // would orphan the newcomer and make the next turn "session_not_found".
-                proc.on("error", (err) => {
-                    // A spawn that fails (python deleted post-check, EACCES/AV) emits "error"
-                    // and never "exit"; with no listener this took down the WHOLE runner.
-                    if (activeAssistants.get(sid) === session)
-                        activeAssistants.delete(sid);
-                    bootingAssistants.delete(sid);
-                    browserBridge?.teardownRunsForSession(sid, "assistant_spawn_error").catch(() => { });
-                    socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", kind: "error", message: `assistant host spawn failed: ${err?.message || err}` });
-                });
-                const weOwned = activeAssistants.get(sid) === session;
-                if (weOwned)
-                    activeAssistants.delete(sid);
-                // Tear down any per-turn bridge runs this host leaked (a turn that never
-                // sent `done` before the host exited/crashed) so its lease + enforceOnPage
-                // handlers don't linger on the user's open tab. Only if a replacement
-                // host hasn't already taken over the sid.
-                if (weOwned)
-                    browserBridge?.teardownRunsForSession(sid, `assistant_exit:${code}`).catch(() => { });
-                // A host we INTENTIONALLY killed for a config-drift reboot must NOT emit
-                // session_closed — that frame would fail the fresh boot's ready waiter
-                // (the server can't pre-mark it superseded here, the kill is runner-side).
-                if (session.killed) {
-                    console.log(chalk.gray(`  ■ Assistant host ${sid.slice(0, 10)}… replaced (config drift, exit ${code})`));
-                    return;
-                }
-                const detail = code !== 0 && stderrTail.length ? stderrTail.slice(-12).join("\n") : "";
-                socket.emit("runner:assistant_event", { sessionId: sid, turnId: "", kind: "session_closed", code, detail });
-                console.log(chalk.gray(`  ■ Assistant session ${sid.slice(0, 10)}… closed (exit ${code})`));
+            const session = launchAssistantHost({
+                env, pythonPath: envResult.pythonPath, workDir, stagedHost,
+                sid, generation, forward: true, providerLabel: String(payload.provider || ""),
             });
+            activeAssistants.set(sid, session);
+            // Teach the pool this exact (env, config, generation) so it prewarms a
+            // matching spare for the NEXT new session — which then adopts it and skips
+            // the cold boot (see the ADOPTION fast path + schedulePrewarm above).
+            warmSpareSeed = { env, configHash: expectedConfig, generation, pythonPath: envResult.pythonPath, workDirBase: tmpdir(), hostScript };
+            schedulePrewarm();
         }
         catch (e) {
             emitEv({ kind: "error", message: `assistant start failed: ${e?.message || e}` });

package/dist/pythonEnv.js

@@ -15,6 +15,7 @@ import { createHash } from "crypto";
 import { join } from "path";
 import { homedir, platform } from "os";
 import chalk from "chalk";
+import { localUvPath } from "./uvBootstrap.js";
 const CACHE_DIR = join(homedir(), ".melaya-runner");
 const VENV_DIR = join(CACHE_DIR, "venv");
 const VENV_MARK = join(CACHE_DIR, "venv-version.txt");
@@ -151,13 +152,18 @@ const PIP_DEPS = [
     // ── Template-validation sweep deps (2026-07-06) — tools that hard-error
     // "pip install X" on the runner without these, observed in live runs:
     // yt-dlp        — youtube_search_channel / youtube_get_transcript (1221 YouTube Intel)
-    // sentence-transformers — build_knowledge_from_text embedder (1221)
     // flights       — flight_price_alert / flight_search live Google Flights ("fli" import; 1261/1265)
     // pymupdf4llm   — pdf_to_text markdown extraction (1227 PDF Contract Analyser)
     "yt-dlp",
-    "sentence-transformers",
     "flights",
     "pymupdf4llm",
+    // sentence-transformers REMOVED 2026-09-09 — it pulls torch (~2GB), which
+    // dominated the venv install/reinstall for EVERY runner, yet only
+    // build_knowledge_from_text (+ guarded fallbacks in rag/memory_search/aiml)
+    // uses it, and DocsTab local RAG embedding runs on OLLAMA/LM-Studio
+    // (localRagIngest.py), not sentence-transformers. All import sites are
+    // try/except-guarded, so the niche tool degrades to a "pip install
+    // sentence-transformers" message instead of shipping 2GB to everyone.
     // ── Vector RAG (retrieval mode) ────────────────────────────────────────
     // ollama — Python client used by agentscope.embedding.OllamaTextEmbedding.
     //   Talks to localhost:11434 (the user's local Ollama daemon) to embed
@@ -215,12 +221,74 @@ const PIP_DEPS = [
     "asyncpg",
     "PyMySQL",
     "cryptography",
+    // ── Cloud-infra connector SDKs (shared/tools/{aws,route53,alibaba,gcp}.py) ──
+    // These modules LAZY-import their SDK inside the tool call, so the toolkit
+    // builds + creds.test passes GREEN without them — then the FIRST real tool
+    // call ModuleNotFoundErrors on the runner (AWS/Alibaba incident 2026-08-16;
+    // Alibaba re-hit 2026-09-09). They ship in requirements.lock (the cloud image)
+    // but MUST be mirrored HERE too — the runner venv installs from THIS list, not
+    // the lock. Surfaced by the runner dep audit (packages/runner/scripts/
+    // audit_runner_deps.py); keep the pins in step with requirements.lock.
+    // PURE-PYTHON WHEELS ONLY here: never add a dep that needs a system binary
+    // (libzbar / cairo+pango / tesseract / …) — a wheel-less dep fails the WHOLE
+    // venv bootstrap and bricks the runner; leave those lazy-guarded in the tool.
+    "boto3==1.42.42", // aws.py + route53.py
+    "alibabacloud-tea-openapi==0.4.5", // alibaba.py — generic Tea OpenAPI client
+    "alibabacloud-tea-util==0.3.15", // alibaba.py
+    "alibabacloud-openapi-util==0.2.4", // alibaba.py (pip resolves the rest of the Tea closure)
+    "google-api-python-client==2.198.0", // gcp.py — googleapiclient.discovery
+    "google-auth-httplib2==0.4.1", // gcp.py — AuthorizedHttp (pulls httplib2 + google-auth)
+    // ── Additional shared-tool deps (SOFT gaps from audit_runner_deps.py 2026-09-09)
+    // All lazy-imported inside the tool AND pure-python wheels, so they do NOT slow
+    // spawn (module import stays light) — only the one-time venv install. Without
+    // them the tool degrades with a "pip install X" message; cheap + common enough
+    // to ship. DELIBERATELY EXCLUDED (stay lazy-guarded, never in PIP_DEPS): the
+    // system-binary deps opencv/cv2, weasyprint (cairo+pango), pytesseract
+    // (tesseract), pyzbar (libzbar) — a wheel-less dep fails the whole venv
+    // bootstrap; and web3 / fastapi (heavy tree / odd for a tool runner).
+    "redis", // crew_blackout_watcher / crew_halts / hitl_middleware
+    "youtube-transcript-api", // youtube_tools
+    "icalendar", // ics_tools
+    "Unidecode", // translation_tools (imports as `unidecode`)
+    "pdfplumber", // core (PDF text extraction)
+    "segno", // qr_tools (QR generation)
+    "PyGithub", // github tool (imports as `github`)
+    "python-gitlab", // github tool (imports as `gitlab`)
+    "pandas-ta", // alphavantage_tools (TA indicators; pandas already present)
+    "python-telegram-bot", // messaging (bot-API rich path; pulls httpx, already present)
+    "aiomysql", // database (async MySQL; sync PyMySQL already present)
 ];
 export function venvPython() {
     return platform() === "win32"
         ? join(VENV_DIR, "Scripts", "python.exe")
         : join(VENV_DIR, "bin", "python");
 }
+/** Prefer the runner-managed uv (localUvPath), else uv on PATH, else null.
+ *  uv installs far faster than pip (parallel downloads + a SAFE content-
+ *  addressed, per-hash-validated cache), turning the "1-2 min" venv reinstall on
+ *  a deps/version change into seconds. Pure lookup — never downloads uv here
+ *  (the pip fallback covers uv's absence, so the venv build can't be blocked). */
+function _resolveUvBin() {
+    try {
+        const p = localUvPath();
+        if (existsSync(p))
+            return p;
+    }
+    catch { /* ignore */ }
+    const bin = platform() === "win32" ? "uv.exe" : "uv";
+    const sep = platform() === "win32" ? ";" : ":";
+    for (const dir of (process.env.PATH || "").split(sep)) {
+        if (!dir)
+            continue;
+        try {
+            const cand = join(dir, bin);
+            if (existsSync(cand))
+                return cand;
+        }
+        catch { /* ignore */ }
+    }
+    return null;
+}
 // ── certifi CA-bundle path resolution + cache ────────────────────────────
 // Set as SSL_CERT_FILE + REQUESTS_CA_BUNDLE when spawning pipeline Python
 // so that ANY HTTPS-using tool (gmail_send, slack_post_text, anthropic /
@@ -488,15 +556,37 @@ async function _ensurePythonEnvImpl(systemPython, expectedVersion, onProgress =
     // only *.py files (no pyproject.toml), so PYTHONPATH-based import is
     // the only path. The cached agentscope source under
     // ~/.melaya-runner/agentscope/ resolves via PYTHONPATH at spawn time.
-    onProgress(`installing ${PIP_DEPS.length} python deps (anthropic, openai, opentelemetry, …) — first run can take 1-2 min`);
-    const acode = await runProc(venvPython(), 
-    // --no-cache-dir: skip pip's on-disk HTTP/wheel cache. It silences the
-    // "Cache entry deserialization failed, entry ignored" warning flood (stale
-    // entries left by other Python versions in the shared user cache) and, more
-    // importantly, guarantees a corrupt cached wheel can never install a subtly
-    // broken package into a fresh runner venv. Costs a re-download on rebuild,
-    // which is rare (only on a deps change or a manual clear).
-    ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], onProgress);
+    // Prefer uv when available (the runner ships it — localUvPath — or provisions
+    // it for managed CPython). uv is ~10-100x faster than pip: parallel downloads,
+    // a resolver written in Rust, and a content-addressed cache that is validated
+    // per wheel hash — so unlike pip's SHARED, cross-Python-version cache (the very
+    // reason the pip path below passes --no-cache-dir) uv's cache can never install
+    // a corrupt wheel. We therefore get caching AND safety, which turns the "1-2
+    // min" reinstall on a deps/version change into seconds. UV_SYSTEM_CERTS mirrors
+    // pip's --use-feature=truststore (verify TLS against the OS trust store — vital
+    // behind intercepting proxies / AV, else CERTIFICATE_VERIFY_FAILED). Any uv
+    // failure falls straight back to the proven pip path so the venv build is never
+    // blocked by a uv edge case.
+    const _uvBin = _resolveUvBin();
+    let acode;
+    if (_uvBin) {
+        onProgress(`installing ${PIP_DEPS.length} python deps via uv (fast; cached reinstalls take seconds)`);
+        acode = await runProc(_uvBin, ["pip", "install", "--python", venvPython(), "--quiet", ...PIP_DEPS], onProgress, { UV_SYSTEM_CERTS: "1" });
+        if (acode !== 0) {
+            onProgress("uv install failed — falling back to pip (--no-cache-dir)");
+            acode = await runProc(venvPython(), ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], onProgress);
+        }
+    }
+    else {
+        onProgress(`installing ${PIP_DEPS.length} python deps (anthropic, openai, opentelemetry, …) — first run can take 1-2 min`);
+        // --no-cache-dir: skip pip's on-disk HTTP/wheel cache. It silences the
+        // "Cache entry deserialization failed, entry ignored" warning flood (stale
+        // entries left by other Python versions in the shared user cache) and, more
+        // importantly, guarantees a corrupt cached wheel can never install a subtly
+        // broken package into a fresh runner venv. Costs a re-download on rebuild,
+        // which is rare (only on a deps change or a manual clear).
+        acode = await runProc(venvPython(), ["-m", "pip", "install", "--use-feature=truststore", "--no-cache-dir", "--quiet", "--disable-pip-version-check", ...PIP_DEPS], onProgress);
+    }
     if (acode !== 0) {
         return {
             ok: false,

package/package.json

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