clawmux 0.3.10 → 0.3.12

package/dist/cli.cjs

@@ -15597,8 +15597,8 @@ async function defaultParseResponse(client, props) {
     const mediaType = contentType?.split(";")[0]?.trim();
     const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json");
     if (isJSON) {
-      const contentLength = response.headers.get("content-length");
-      if (contentLength === "0") {
+      const contentLength2 = response.headers.get("content-length");
+      if (contentLength2 === "0") {
         return;
       }
       const json = await response.json();
@@ -21884,8 +21884,8 @@ async function defaultParseResponse2(client, props) {
     const mediaType = contentType?.split(";")[0]?.trim();
     const isJSON = mediaType?.includes("application/json") || mediaType?.endsWith("+json");
     if (isJSON) {
-      const contentLength = response.headers.get("content-length");
-      if (contentLength === "0") {
+      const contentLength2 = response.headers.get("content-length");
+      if (contentLength2 === "0") {
         return;
       }
       const json = await response.json();
@@ -34508,7 +34508,7 @@ async function consumeBody(data) {
     throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
   }
 }
-var import_node_stream, import_node_util, import_node_buffer, pipeline2, INTERNALS, clone = (instance, highWaterMark) => {
+var import_node_stream, import_node_util, import_node_buffer, pipeline, INTERNALS, clone = (instance, highWaterMark) => {
   let p1;
   let p2;
   let { body } = instance[INTERNALS];
@@ -34569,7 +34569,7 @@ var import_node_stream, import_node_util, import_node_buffer, pipeline2, INTERNA
   if (body === null) {
     dest.end();
   } else {
-    await pipeline2(body, dest);
+    await pipeline(body, dest);
   }
 };
 var init_body = __esm(() => {
@@ -34581,7 +34581,7 @@ var init_body = __esm(() => {
   import_node_stream = __toESM(require("node:stream"));
   import_node_util = require("node:util");
   import_node_buffer = require("node:buffer");
-  pipeline2 = import_node_util.promisify(import_node_stream.default.pipeline);
+  pipeline = import_node_util.promisify(import_node_stream.default.pipeline);
   INTERNALS = Symbol("Body internals");
   Body.prototype.buffer = import_node_util.deprecate(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
   Object.defineProperties(Body.prototype, {
@@ -57734,8 +57734,8 @@ async function defaultParseResponse3(client, props) {
     const mediaType = (_a4 = contentType === null || contentType === undefined ? undefined : contentType.split(";")[0]) === null || _a4 === undefined ? undefined : _a4.trim();
     const isJSON = (mediaType === null || mediaType === undefined ? undefined : mediaType.includes("application/json")) || (mediaType === null || mediaType === undefined ? undefined : mediaType.endsWith("+json"));
     if (isJSON) {
-      const contentLength = response.headers.get("content-length");
-      if (contentLength === "0") {
+      const contentLength2 = response.headers.get("content-length");
+      if (contentLength2 === "0") {
         return;
       }
       const json = await response.json();
@@ -112220,7 +112220,7 @@ var import_node_child_process = require("node:child_process");
 var import_node_os2 = require("node:os");
 
 // src/proxy/router.ts
-var VERSION = process.env.npm_package_version ?? "0.3.10";
+var VERSION = process.env.npm_package_version ?? "0.3.12";
 function jsonResponse(body, status = 200) {
   return new Response(JSON.stringify(body), {
     status,
@@ -112429,6 +112429,12 @@ var import_promises2 = require("node:fs/promises");
 var import_node_path = require("node:path");
 
 // src/config/defaults.ts
+var ESCALATION_DEFAULTS = {
+  activeThresholdMs: 300000,
+  maxLifetimeMs: 7200000,
+  fingerprintRootCount: 5,
+  enabled: true
+};
 var DEFAULT_CONFIG = {
   compression: {
     threshold: 0.75,
@@ -112441,7 +112447,8 @@ var DEFAULT_CONFIG = {
       MEDIUM: "",
       HEAVY: ""
     },
-    contextWindows: {}
+    contextWindows: {},
+    escalation: ESCALATION_DEFAULTS
   },
   server: {
     port: 3456,
@@ -112462,7 +112469,13 @@ function applyDefaults(partial) {
         MEDIUM: partial.routing.models.MEDIUM ?? defaults.routing.models.MEDIUM,
         HEAVY: partial.routing.models.HEAVY ?? defaults.routing.models.HEAVY
       },
-      contextWindows: { ...defaults.routing.contextWindows, ...partial.routing.contextWindows }
+      contextWindows: { ...defaults.routing.contextWindows, ...partial.routing.contextWindows },
+      escalation: {
+        activeThresholdMs: partial.routing.escalation?.activeThresholdMs ?? ESCALATION_DEFAULTS.activeThresholdMs,
+        maxLifetimeMs: partial.routing.escalation?.maxLifetimeMs ?? ESCALATION_DEFAULTS.maxLifetimeMs,
+        fingerprintRootCount: partial.routing.escalation?.fingerprintRootCount ?? ESCALATION_DEFAULTS.fingerprintRootCount,
+        enabled: partial.routing.escalation?.enabled !== undefined ? partial.routing.escalation.enabled : ESCALATION_DEFAULTS.enabled
+      }
     },
     server: {
       port: partial.server?.port ?? defaults.server.port,
@@ -112564,6 +112577,39 @@ function validateConfig(raw) {
       }
     }
   }
+  if (routing.escalation !== undefined) {
+    if (!isObject(routing.escalation)) {
+      errors.push("routing.escalation: must be an object");
+    } else {
+      const esc = routing.escalation;
+      if (esc.activeThresholdMs !== undefined) {
+        if (typeof esc.activeThresholdMs !== "number") {
+          errors.push(`routing.escalation.activeThresholdMs: must be a number, got ${typeof esc.activeThresholdMs}`);
+        } else if (esc.activeThresholdMs <= 0) {
+          errors.push(`routing.escalation.activeThresholdMs: must be a positive number, got ${esc.activeThresholdMs}`);
+        }
+      }
+      if (esc.maxLifetimeMs !== undefined) {
+        if (typeof esc.maxLifetimeMs !== "number") {
+          errors.push(`routing.escalation.maxLifetimeMs: must be a number, got ${typeof esc.maxLifetimeMs}`);
+        } else if (esc.maxLifetimeMs <= 0) {
+          errors.push(`routing.escalation.maxLifetimeMs: must be a positive number, got ${esc.maxLifetimeMs}`);
+        }
+      }
+      if (esc.fingerprintRootCount !== undefined) {
+        if (typeof esc.fingerprintRootCount !== "number") {
+          errors.push(`routing.escalation.fingerprintRootCount: must be a number, got ${typeof esc.fingerprintRootCount}`);
+        } else if (!Number.isInteger(esc.fingerprintRootCount) || esc.fingerprintRootCount < 1) {
+          errors.push(`routing.escalation.fingerprintRootCount: must be an integer >= 1, got ${esc.fingerprintRootCount}`);
+        }
+      }
+      if (esc.enabled !== undefined) {
+        if (typeof esc.enabled !== "boolean") {
+          errors.push(`routing.escalation.enabled: must be a boolean, got ${typeof esc.enabled}`);
+        }
+      }
+    }
+  }
   const server = obj.server !== undefined && isObject(obj.server) ? obj.server : null;
   if (server !== null && server.port !== undefined) {
     checkOptionalNumberRange(errors, "server.port", server.port, 1024, 65535);
@@ -114974,404 +115020,305 @@ function buildSyntheticHttpResponse(parsed, adapter) {
   });
 }
 
-// src/routing/local-classifier.ts
-var import_transformers = require("@huggingface/transformers");
-var CAT_L = "L";
-var CAT_M = "M";
-var CAT_H = "H";
-var CAT_Q = "Q";
-var TIER_MAP = {
-  L: "LIGHT",
-  M: "MEDIUM",
-  H: "HEAVY"
-};
-var MODEL_ID = "Xenova/multilingual-e5-small";
-var E5_PREFIX = "query: ";
-var BATCH_SIZE = 32;
-var TRAINING_LIGHT = [
-  "안녕하세요",
-  "안녕",
-  "안녕히 가세요",
-  "안녕히 계세요",
-  "반갑습니다",
-  "잘 지내시죠",
-  "오랜만이에요",
-  "고마워",
-  "감사합니다",
-  "고맙습니다",
-  "네 고마워요",
-  "정말 감사합니다",
-  "도와줘서 고마워",
-  "네",
-  "예",
-  "아니요",
-  "좋아요",
-  "알겠습니다",
-  "확인했습니다",
-  "그래요",
-  "맞아요",
-  "아 네",
-  "Python이 뭐야?",
-  "JavaScript가 뭐야?",
-  "오늘 날씨 어때?",
-  "지금 몇 시야?",
-  "이거 뭐야?",
-  "TypeScript가 뭐예요?",
-  "API가 뭐야?",
-  "HTML이 뭐야?",
-  "CSS가 뭐야?",
-  "Hello",
-  "Hi",
-  "Hey there",
-  "Good morning",
-  "Good afternoon",
-  "How are you",
-  "What's up",
-  "Thanks",
-  "Thank you",
-  "Got it",
-  "OK",
-  "Sounds good",
-  "I see",
-  "Understood",
-  "Great thanks",
-  "What is Python?",
-  "What time is it?",
-  "What's the weather?",
-  "Who is Einstein?",
-  "Where is Seoul?",
-  "How old are you?",
-  "yes",
-  "no",
-  "maybe",
-  "sure",
-  "please",
-  "done",
-  "ok",
-  "cool",
-  "nice",
-  "awesome"
-];
-var TRAINING_MEDIUM = [
-  "Write a quicksort function in TypeScript",
-  "Implement a binary search tree with insert and delete",
-  "Create a REST API endpoint for user authentication",
-  "Write a function to merge two sorted arrays",
-  "Implement a linked list in Python",
-  "Write a unit test for the calculator module",
-  "Create a simple Express.js middleware for logging",
-  "Write a regex to validate email addresses",
-  "Implement a LRU cache with get and put operations",
-  "Create a React component for a todo list",
-  "Write a SQL query to join two tables",
-  "Implement a basic JWT authentication flow",
-  "Write a function to parse CSV files",
-  "Create a simple WebSocket server",
-  "Implement bubble sort in Java",
-  "Write a Python script to read a JSON file",
-  "Create a Docker compose file for a web app",
-  "Write a Git pre-commit hook",
-  "REST API에 로그인 엔드포인트 추가해줘",
-  "이 함수에 에러 핸들링 추가해줘",
-  "TypeScript로 이벤트 이미터 만들어줘",
-  "데이터베이스 마이그레이션 스크립트 작성해줘",
-  "React 컴포넌트에 상태 관리 추가해줘",
-  "Express 라우터에 CORS 미들웨어 추가해줘",
-  "테스트 코드 작성해줘",
-  "이 코드 리팩토링해줘",
-  "Explain the difference between let and const in JavaScript",
-  "What's the difference between SQL and NoSQL databases",
-  "Explain how async await works in Python",
-  "Describe the MVC architecture pattern",
-  "Explain what Docker containers are",
-  "REST와 GraphQL의 차이점을 설명해줘",
-  "이벤트 루프가 어떻게 동작하는지 설명해줘",
-  "클로저가 뭐야? 설명해줘",
-  "Set up a Node.js project with TypeScript and ESLint",
-  "Create a basic CI/CD pipeline using GitHub Actions",
-  "Configure Nginx as a reverse proxy for a Node.js app",
-  `이 함수를 리팩토링해줘:
-function processUsers(data) {
-  var result = [];
-  for (var i = 0; i < data.length; i++) {
-    if (data[i].active == true && data[i].age > 18) {
-      var name = data[i].firstName + ' ' + data[i].lastName;
-      var obj = { name: name, email: data[i].email, role: data[i].isAdmin ? 'admin' : 'user' };
-      if (data[i].department !== null && data[i].department !== undefined) {
-        obj.department = data[i].department.name;
-        obj.manager = data[i].department.manager ? data[i].department.manager.name : 'N/A';
-      }
-      result.push(obj);
-    }
-  }
-  result.sort(function(a, b) { return a.name > b.name ? 1 : -1; });
-  return result;
-}`,
-  `Refactor this code to use modern JavaScript:
-function getItems(list) {
-  var items = [];
-  for (var i = 0; i < list.length; i++) {
-    if (list[i].active === true) {
-      items.push(list[i].name);
+// src/routing/signal-detector.ts
+var ESCALATE_SIGNAL = "===CLAWMUX_ESCALATE===";
+
+class SignalDetector {
+  buffer = "";
+  detected = false;
+  pending = [];
+  feed(char) {
+    if (this.pending.length > 0) {
+      return this.pending.shift();
+    }
+    if (this.detected) {
+      return { type: "signal_detected" };
+    }
+    if (this.buffer.length === 0) {
+      if (char !== "=") {
+        return { type: "passthrough", text: char };
+      }
+      this.buffer = char;
+      return { type: "buffering" };
+    }
+    const candidate = this.buffer + char;
+    if (candidate === ESCALATE_SIGNAL) {
+      this.detected = true;
+      this.buffer = "";
+      return { type: "signal_detected" };
+    }
+    if (ESCALATE_SIGNAL.startsWith(candidate)) {
+      this.buffer = candidate;
+      return { type: "buffering" };
     }
+    this.buffer = "";
+    this.pending.push({ type: "passthrough", text: char });
+    return { type: "passthrough", text: candidate.slice(0, -1) };
   }
-  return items;
-}`
-];
-var TRAINING_HEAVY = [
-  "Design a distributed consensus algorithm for a multi-region database with strong consistency and Byzantine fault tolerance",
-  "Explain the theoretical foundations of quantum computing and how quantum entanglement can be used for cryptographic key distribution",
-  "Analyze the trade-offs between eventual consistency and strong consistency in distributed systems, including CAP theorem implications",
-  "Design a fault-tolerant microservices architecture for a real-time trading platform handling millions of transactions per second",
-  "Propose a novel approach to solving the traveling salesman problem that improves upon current approximation algorithms",
-  "Design a machine learning pipeline for real-time fraud detection in financial transactions with sub-millisecond latency requirements",
-  "Compare and contrast different consensus protocols (Paxos, Raft, PBFT) and recommend the best one for a blockchain-based supply chain system",
-  "Architect a system that can handle 10 million concurrent WebSocket connections with horizontal scaling",
-  "Design a real-time data streaming architecture combining Kafka, Flink, and a time-series database for IoT sensor data",
-  "메모리 릭이 발생하는데 프로파일러에서 이벤트 루프 블로킹과 GC 지연이 동시에 나타나. 마이크로서비스 간 gRPC 연결 풀링도 의심되는 상황인데 원인 분석 방법을 단계별로 설명해줘",
-  "대규모 분산 시스템에서 파티션 톨런스와 일관성을 동시에 보장하는 방법을 설계해줘",
-  "실시간 추천 시스템을 위한 아키텍처를 설계해줘. 1초 이내에 개인화된 추천을 제공해야 해",
-  "카프카 기반 이벤트 드리븐 아키텍처에서 순서 보장과 정확히 한 번 처리를 어떻게 보장할 수 있을까?",
-  "마이크로서비스 간의 분산 트랜잭션을 사가 패턴으로 구현하는 방법을 단계별로 설명해줘",
-  "Debug a memory leak in a production Node.js application where the heap grows indefinitely but garbage collection logs show normal behavior",
-  "Investigate why our Kubernetes pods are being OOMKilled despite having memory limits set to 4GB and actual usage reported as 2GB",
-  "Find the root cause of intermittent 500ms latency spikes in our PostgreSQL queries that happen every 15 minutes",
-  "Design a multi-tenant SaaS platform with shared infrastructure but isolated data, supporting custom domains and white-labeling",
-  "Implement a distributed task scheduler that guarantees at-least-once execution with idempotency support across multiple data centers"
-];
-var TRAINING_Q = [
-  "아까 그거 다시 해줘",
-  "그거 좀 더 자세히 설명해줘",
-  "아까 말한 거 그대로 해줘",
-  "이거 수정해줘",
-  "저거 어디 있지",
-  "그거 어떻게 됐어",
-  "위에꺼 다시 한번",
-  "그거 그대로 해줘",
-  "아까 한 거 다시",
-  "그 코드 다시 보여줘",
-  "저번에 한 거 기억나?",
-  "그 부분 수정해줘",
-  "Do that again",
-  "What about the thing we discussed earlier",
-  "Show me that again",
-  "Can you fix that",
-  "Change it like I said before",
-  "Continue from where we left off",
-  "That thing from earlier, do it again",
-  "Remember what we were working on",
-  "Go back to the previous one",
-  "Make it like the other one",
-  "The same thing but different",
-  "Update the one from before",
-  "그거 해줘",
-  "이거 해줘",
-  "저거 어때",
-  "How about this one",
-  "What about that",
-  "Try the other approach",
-  "Use the one I mentioned",
-  "Fix the issue",
-  "그냥 그거",
-  "이건 어때",
-  "Make it better",
-  "Change it",
-  "이거 수정해"
-];
-var Q_PATTERNS = [
-  /^(아까|그거|저거|이거|그|위에|아래|저번|이전|전에).*(다시|해줘|해|보여|설명|수정|변경|삭제|추가|해봐)/,
-  /^(그거|저거|이거|그|이|저)(만|만큼|대로|처럼|같이)?\s*(해줘|해|놔|둬|봐|어때|어떻게)/,
-  /^(그거|저거|이거)\s*$/,
-  /(아까|저번에|전에|위에서|앞에서|이전에).*(그|그거|그것|그때|했던|말한)/,
-  /^(이거|저거|그거)(\s*.*)?$/
-];
-var DEICTIC_WORDS = new Set(["그거", "저거", "이거", "그것", "이것", "저것", "아까", "저번"]);
-function matchesQPattern(text) {
-  const trimmed = text.trim();
-  for (const pattern of Q_PATTERNS) {
-    if (pattern.test(trimmed))
-      return true;
+  feedChunk(chunk) {
+    const out = [];
+    for (let i = 0;i < chunk.length; i++) {
+      out.push(this.feed(chunk[i]));
+      while (this.pending.length > 0) {
+        out.push(this.pending.shift());
+      }
+    }
+    return out;
   }
-  if (trimmed.length < 20) {
-    for (const word of DEICTIC_WORDS) {
-      if (trimmed.includes(word))
-        return true;
+  flush() {
+    if (this.buffer.length === 0)
+      return null;
+    const text = this.buffer;
+    this.buffer = "";
+    return text;
+  }
+  reset() {
+    this.buffer = "";
+    this.detected = false;
+    this.pending.length = 0;
+  }
+  get isBuffering() {
+    return this.buffer.length > 0;
+  }
+}
+
+// src/routing/escalation-memory.ts
+function djb2Hash(text) {
+  let hash = 5381;
+  for (let i = 0;i < text.length; i++) {
+    hash = (hash << 5) + hash ^ text.charCodeAt(i);
+  }
+  return (hash >>> 0).toString(16);
+}
+function extractText(content) {
+  if (typeof content === "string") {
+    return content.slice(0, 200);
+  }
+  let concatenated = "";
+  for (const block of content) {
+    if (block.type === "text" && block.text !== undefined) {
+      concatenated += block.text;
     }
   }
-  return false;
+  return concatenated.slice(0, 200);
 }
-var CODE_PATTERN = /[{}();]|function |const |let |var |class |import |export |=>|\bdef \b|\bfn\b/;
-var TECH_TERMS = /\b(implement|create|design|architect|debug|refactor|migrate|deploy|build|write|develop)\b/i;
-function isLikelyLight(text) {
-  const trimmed = text.trim();
-  if (trimmed.length <= 20 && !CODE_PATTERN.test(trimmed) && !TECH_TERMS.test(trimmed)) {
-    return true;
+function contentLength(content) {
+  if (typeof content === "string") {
+    return content.length;
   }
-  return false;
+  return extractText(content).length;
 }
-var extractorPromise = null;
-function getExtractor() {
-  if (!extractorPromise) {
-    const dtype = process.env.CLAWMUX_EMBEDDING_DTYPE ?? "fp16";
-    console.log(`[clawmux] Loading embedding model (dtype=${dtype})...`);
-    extractorPromise = import_transformers.pipeline("feature-extraction", MODEL_ID, { dtype }).then((pipe) => {
-      console.log("[clawmux] Embedding model loaded");
-      return pipe;
+
+class EscalationMemory {
+  config;
+  store;
+  constructor(config) {
+    this.config = config;
+    this.store = new Map;
+  }
+  fingerprint(messages) {
+    const count = this.config.fingerprintRootCount;
+    const segments = [];
+    for (let i = 0;i < count; i++) {
+      const msg = messages[i];
+      if (msg === undefined) {
+        segments.push("::");
+        continue;
+      }
+      const text = extractText(msg.content);
+      const len = contentLength(msg.content);
+      segments.push(`${msg.role}:${String(len)}:${djb2Hash(text)}`);
+    }
+    return segments.join("|");
+  }
+  lookup(messages, nowMs) {
+    this.evict(nowMs);
+    return this.store.get(this.fingerprint(messages)) ?? null;
+  }
+  record(messages, tier, nowMs) {
+    const now = nowMs ?? Date.now();
+    const fp = this.fingerprint(messages);
+    const existing = this.store.get(fp);
+    if (existing !== undefined && existing.tier === "HEAVY" && tier === "MEDIUM") {
+      existing.lastActivityAt = now;
+      return;
+    }
+    this.store.set(fp, {
+      tier,
+      firstEscalatedAt: existing?.firstEscalatedAt ?? now,
+      lastActivityAt: now
     });
   }
-  return extractorPromise;
-}
-var centroidsPromise = null;
-async function computeMeanEmbedding(texts) {
-  const extractor = await getExtractor();
-  const allEmbeddings = [];
-  for (let i = 0;i < texts.length; i += BATCH_SIZE) {
-    const batch = texts.slice(i, i + BATCH_SIZE).map((t) => E5_PREFIX + t);
-    const output = await extractor(batch, { pooling: "mean", normalize: true });
-    const list = output.tolist();
-    for (const emb of list) {
-      allEmbeddings.push(emb);
+  touch(messages, nowMs) {
+    const now = nowMs ?? Date.now();
+    const record = this.store.get(this.fingerprint(messages));
+    if (record !== undefined) {
+      record.lastActivityAt = now;
     }
   }
-  if (allEmbeddings.length === 0)
-    return [];
-  const dim = allEmbeddings[0].length;
-  const mean = new Array(dim).fill(0);
-  for (const emb of allEmbeddings) {
-    for (let j = 0;j < dim; j++) {
-      mean[j] += emb[j] / allEmbeddings.length;
-    }
-  }
-  const magnitude = Math.sqrt(mean.reduce((sum, v) => sum + v * v, 0));
-  if (magnitude > 0) {
-    for (let j = 0;j < dim; j++)
-      mean[j] /= magnitude;
-  }
-  return mean;
-}
-function getCentroids() {
-  if (!centroidsPromise) {
-    centroidsPromise = (async () => {
-      console.log("[clawmux] Computing category centroids...");
-      const [cL, cM, cH, cQ] = await Promise.all([
-        computeMeanEmbedding(TRAINING_LIGHT),
-        computeMeanEmbedding(TRAINING_MEDIUM),
-        computeMeanEmbedding(TRAINING_HEAVY),
-        computeMeanEmbedding(TRAINING_Q)
-      ]);
-      console.log(`[clawmux] Centroids ready: L=${TRAINING_LIGHT.length} M=${TRAINING_MEDIUM.length} ` + `H=${TRAINING_HEAVY.length} Q=${TRAINING_Q.length} samples`);
-      return { [CAT_L]: cL, [CAT_M]: cM, [CAT_H]: cH, [CAT_Q]: cQ };
-    })();
+  evict(nowMs) {
+    const now = nowMs ?? Date.now();
+    let evicted = 0;
+    for (const [fp, record] of this.store) {
+      const inactive = now - record.lastActivityAt > this.config.activeThresholdMs;
+      const expired = now - record.firstEscalatedAt > this.config.maxLifetimeMs;
+      if (inactive || expired) {
+        this.store.delete(fp);
+        evicted++;
+      }
+    }
+    return evicted;
+  }
+  clear() {
+    this.store.clear();
+  }
+  get size() {
+    return this.store.size;
   }
-  return centroidsPromise;
 }
-function cosineSimilarity(a, b) {
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-  for (let i = 0;i < a.length; i++) {
-    dot += a[i] * b[i];
-    magA += a[i] * a[i];
-    magB += b[i] * b[i];
+
+// src/routing/instruction-injector.ts
+var INJECT_FOR_TIERS = new Set(["LIGHT"]);
+var ESCALATION_INSTRUCTION = `If you cannot handle this request fully (due to complexity, missing context, or capability limits), output EXACTLY the following marker with no other text on that line: ${ESCALATE_SIGNAL}
+Do not explain. Do not ask permission. Just emit the marker and stop.`;
+function injectEscalationInstruction(messages) {
+  if (messages.length === 0) {
+    return [{ role: "system", content: ESCALATION_INSTRUCTION }];
+  }
+  const first = messages[0];
+  const rest = messages.slice(1).map((m) => ({ ...m }));
+  if (first.role !== "system") {
+    return [
+      { role: "system", content: ESCALATION_INSTRUCTION },
+      { ...first },
+      ...rest
+    ];
   }
-  const denom = Math.sqrt(magA) * Math.sqrt(magB);
-  return denom > 0 ? dot / denom : 0;
+  if (typeof first.content === "string") {
+    return [
+      { role: "system", content: first.content + `
+
+` + ESCALATION_INSTRUCTION },
+      ...rest
+    ];
+  }
+  return [
+    {
+      role: "system",
+      content: [...first.content, { type: "text", text: ESCALATION_INSTRUCTION }]
+    },
+    ...rest
+  ];
 }
-async function classifyLocal(messages, config) {
-  const userText = extractLastUserText(messages);
-  if (!userText) {
-    return {
-      tier: "MEDIUM",
-      confidence: 0,
-      reasoning: "No user message found",
-      error: "No user message found in request"
-    };
-  }
-  const centroids = await getCentroids();
-  const extractor = await getExtractor();
-  const output = await extractor([E5_PREFIX + userText], { pooling: "mean", normalize: true });
-  const inputEmb = output.tolist()[0];
-  let bestCat = CAT_M;
-  let bestSim = -Infinity;
-  for (const [cat, centroid] of Object.entries(centroids)) {
-    const sim = cosineSimilarity(inputEmb, centroid);
-    if (sim > bestSim) {
-      bestSim = sim;
-      bestCat = cat;
-    }
-  }
-  if (isLikelyLight(userText) && bestCat !== CAT_Q) {
-    bestCat = CAT_L;
-    bestSim = Math.max(bestSim, 0.7);
-  }
-  const heuristicQ = matchesQPattern(userText);
-  if (bestCat === CAT_Q || heuristicQ) {
-    const contextText = buildContextText(messages, userText, config?.contextMessages ?? 10);
-    const ctxOutput = await extractor([E5_PREFIX + contextText], { pooling: "mean", normalize: true });
-    const contextEmb = ctxOutput.tolist()[0];
-    let reBestCat = CAT_M;
-    let reBestSim = -Infinity;
-    for (const [cat, centroid] of Object.entries(centroids)) {
-      if (cat === CAT_Q)
-        continue;
-      const sim = cosineSimilarity(contextEmb, centroid);
-      if (sim > reBestSim) {
-        reBestSim = sim;
-        reBestCat = cat;
-      }
+
+// src/routing/signal-router.ts
+var NEXT_TIER = {
+  LIGHT: "MEDIUM",
+  MEDIUM: "HEAVY",
+  HEAVY: null
+};
+
+class SignalRouter {
+  _memory;
+  _enabled;
+  constructor(config) {
+    this._memory = new EscalationMemory(config.escalation);
+    this._enabled = config.enabled;
+  }
+  selectInitialTier(messages, nowMs) {
+    if (!this._enabled)
+      return "MEDIUM";
+    const record = this._memory.lookup(messages, nowMs);
+    if (record !== null)
+      return record.tier;
+    return "LIGHT";
+  }
+  shouldInjectInstruction(tier) {
+    return this._enabled && INJECT_FOR_TIERS.has(tier);
+  }
+  injectInstructionIfNeeded(tier, messages) {
+    if (this.shouldInjectInstruction(tier)) {
+      return injectEscalationInstruction(messages);
     }
-    const tier2 = TIER_MAP[reBestCat] ?? "MEDIUM";
-    return {
-      tier: tier2,
-      confidence: reBestSim,
-      reasoning: `Re-classified with context (initial: Q, heuristic: ${heuristicQ})`
-    };
+    return messages;
+  }
+  createSignalDetector() {
+    return new SignalDetector;
+  }
+  handleEscalation(_messages, fromTier) {
+    return NEXT_TIER[fromTier];
+  }
+  recordSuccessfulEscalation(messages, tier, nowMs) {
+    this._memory.record(messages, tier, nowMs);
+  }
+  touchActivity(messages, nowMs) {
+    this._memory.touch(messages, nowMs);
+  }
+  get memory() {
+    return this._memory;
+  }
+  get enabled() {
+    return this._enabled;
   }
-  const tier = TIER_MAP[bestCat] ?? "MEDIUM";
-  return { tier, confidence: bestSim };
 }
-function extractLastUserText(messages) {
-  for (let i = messages.length - 1;i >= 0; i--) {
-    const msg = messages[i];
-    if (msg.role !== "user")
+
+// src/proxy/signal-detecting-stream.ts
+function createSignalDetectionState() {
+  return { signalDetected: false, preSignalText: "" };
+}
+async function* detectSignalInStream(stream, detector, state, onSignal) {
+  let signaled = false;
+  for await (const event of stream) {
+    if (signaled) {
+      if (event.type === "done" || event.type === "error") {
+        yield event;
+      }
       continue;
-    if (typeof msg.content === "string") {
-      return msg.content;
     }
-    if (Array.isArray(msg.content)) {
-      const parts = [];
-      for (const block of msg.content) {
-        if (block.type === "text" && block.text) {
-          parts.push(block.text);
+    if (event.type === "text_delta" && typeof event.delta === "string") {
+      const results = detector.feedChunk(event.delta);
+      let confirmedText = "";
+      for (const r of results) {
+        if (r.type === "passthrough") {
+          state.preSignalText += r.text;
+          confirmedText += r.text;
+        } else if (r.type === "signal_detected") {
+          signaled = true;
+          state.signalDetected = true;
+          onSignal();
+        }
+      }
+      if (signaled) {
+        if (confirmedText.length > 0) {
+          yield {
+            ...event,
+            delta: confirmedText
+          };
         }
+        continue;
+      }
+      if (confirmedText.length > 0) {
+        yield {
+          ...event,
+          delta: confirmedText
+        };
       }
-      if (parts.length > 0)
-        return parts.join(" ");
-    }
-  }
-  return;
-}
-function buildContextText(allMessages, currentText, contextCount) {
-  const relevantMessages = allMessages.filter((m) => m.role === "user" || m.role === "assistant");
-  const lastN = relevantMessages.slice(-contextCount);
-  const parts = [];
-  for (const msg of lastN) {
-    let text;
-    if (typeof msg.content === "string") {
-      text = msg.content;
-    } else if (Array.isArray(msg.content)) {
-      text = msg.content.filter((b) => b.type === "text" && b.text).map((b) => b.text).join(" ");
-    } else {
       continue;
     }
-    parts.push(`[${msg.role}]: ${text}`);
-  }
-  const lastPart = parts[parts.length - 1];
-  if (!lastPart || !lastPart.includes(currentText)) {
-    parts.push(`[user]: ${currentText}`);
+    if (event.type === "done" || event.type === "error") {
+      const flushed = detector.flush();
+      if (flushed !== null) {
+        state.preSignalText += flushed;
+        yield {
+          type: "text_delta",
+          contentIndex: 0,
+          delta: flushed,
+          partial: event.type === "done" ? event.message : event.error
+        };
+      }
+    }
+    yield event;
   }
-  return parts.join(`
-`);
 }
 
 // src/openclaw/auth-resolver.ts
@@ -115674,7 +115621,7 @@ function isStreamContentType(contentType) {
 }
 
 // src/compression/session-store.ts
-function djb2Hash(str) {
+function djb2Hash2(str) {
   let hash = 5381;
   for (let i = 0;i < str.length; i++) {
     hash = (hash << 5) + hash + str.charCodeAt(i) | 0;
@@ -115686,7 +115633,7 @@ function generateSessionId(messages) {
   if (!firstUserMessage)
     return "empty-session";
   const content = typeof firstUserMessage.content === "string" ? firstUserMessage.content : JSON.stringify(firstUserMessage.content);
-  return `session-${djb2Hash(content)}`;
+  return `session-${djb2Hash2(content)}`;
 }
 function createSessionStore(maxSessions = 500) {
   const store = new Map;
@@ -120558,7 +120505,7 @@ function computeRetryDelay(response, attempt, baseDelayMs, maxDelayMs) {
   const jitter = Math.random() * 300;
   return Math.min(baseDelayMs * 2 ** attempt + jitter, maxDelayMs);
 }
-async function handleApiRequest(req, body, apiType, config, openclawConfig, authProfiles, compressionMiddleware) {
+async function handleApiRequest(req, body, apiType, config, openclawConfig, authProfiles, compressionMiddleware, signalRouter) {
   const adapter = getAdapter(apiType);
   if (!adapter) {
     return jsonErrorResponse(`Unknown API type: ${apiType}`, 500);
@@ -120591,12 +120538,11 @@ async function handleApiRequest(req, body, apiType, config, openclawConfig, auth
     }
   }
   const messages = effectiveParsed.messages;
-  const classification = await classifyLocal(messages);
+  const initialTier = signalRouter.selectInitialTier(messages);
   const decision = {
-    tier: classification.tier,
-    model: config.routing.models[classification.tier],
-    confidence: classification.confidence,
-    overrideReason: classification.reasoning
+    tier: initialTier,
+    model: config.routing.models[initialTier],
+    confidence: 1
   };
   const lookup = findProviderForModel(decision.model, openclawConfig);
   let providerName;
@@ -120640,67 +120586,90 @@ async function handleApiRequest(req, body, apiType, config, openclawConfig, auth
   const piEligible = piEnabled && PI_CLIENT_APIS.has(apiType) && targetApiType !== "ollama" && targetApiType !== "bedrock-converse-stream";
   if (piEligible) {
     try {
-      const model = buildPiAiModel(providerName, actualModelId, openclawConfig);
-      const piContext = buildPiContext(effectiveParsed);
-      applyCodexSystemPromptFallback(piContext, targetApiType);
-      const piOptions = buildPiOptions(effectiveParsed, authInfo, providerName);
       const lastUserMsg2 = [...parsed.messages].reverse().find((m2) => m2.role === "user");
       const msgText2 = typeof lastUserMsg2?.content === "string" ? lastUserMsg2.content : Array.isArray(lastUserMsg2?.content) ? lastUserMsg2.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ") : "";
       const preview2 = msgText2.replace(/\s+/g, " ").trim().slice(0, 100);
-      console.log(`[clawmux] [llm] ${decision.tier} → ${decision.model} | conf=${classification.confidence.toFixed(2)} | pi-ai (${apiType})${preview2 ? ` | "${preview2}${msgText2.length > 100 ? "…" : ""}"` : ""}`);
       if (compressionMiddleware) {
         compressionMiddleware.afterResponse(parsed);
       }
-      const piStreamHandle = stream(model, piContext, piOptions);
       const wantsStream = effectiveParsed.stream === true;
-      if (apiType === "anthropic-messages") {
+      let currentTier = initialTier;
+      const MAX_ESCALATION_ATTEMPTS = 3;
+      for (let attempt = 0;attempt < MAX_ESCALATION_ATTEMPTS; attempt++) {
+        const currentModel = config.routing.models[currentTier];
+        const currentActualModelId = currentModel.split("/").slice(1).join("/");
+        const currentProviderName = findProviderForModel(currentModel, openclawConfig)?.providerName ?? providerName;
+        const currentAuth = resolveApiKey(currentProviderName, openclawConfig, authProfiles);
+        if (!currentAuth) {
+          return jsonErrorResponse(`No auth credentials found for provider: ${currentProviderName}`, 502);
+        }
+        const currentAuthInfo = {
+          apiKey: currentAuth.apiKey,
+          headerName: currentAuth.headerName,
+          headerValue: currentAuth.headerValue,
+          awsAccessKeyId: currentAuth.awsAccessKeyId,
+          awsSecretKey: currentAuth.awsSecretKey,
+          awsSessionToken: currentAuth.awsSessionToken,
+          awsRegion: currentAuth.awsRegion,
+          accountId: currentAuth.accountId
+        };
+        const model = buildPiAiModel(currentProviderName, currentActualModelId, openclawConfig);
+        const injectedMessages = signalRouter.injectInstructionIfNeeded(currentTier, messages);
+        const injectedParsed = {
+          ...effectiveParsed,
+          messages: injectedMessages,
+          rawBody: adapter.modifyMessages(effectiveParsed.rawBody, injectedMessages)
+        };
+        const piContext = buildPiContext(injectedParsed);
+        applyCodexSystemPromptFallback(piContext, targetApiType);
+        const shouldDetect = signalRouter.enabled && NEXT_TIER[currentTier] !== null;
+        const abortCtrl = new AbortController;
+        const piOptions = buildPiOptions(injectedParsed, currentAuthInfo, currentProviderName, abortCtrl.signal);
+        console.log(`[clawmux] [llm] ${currentTier} → ${currentModel} | attempt=${attempt + 1} | pi-ai (${apiType})${preview2 ? ` | "${preview2}${msgText2.length > 100 ? "…" : ""}"` : ""}`);
+        const piStreamHandle = stream(model, piContext, piOptions);
+        if (!shouldDetect) {
+          return await yieldPiAiResponse(piStreamHandle, apiType, wantsStream);
+        }
+        const detector = signalRouter.createSignalDetector();
+        const detectionState = createSignalDetectionState();
         if (wantsStream) {
-          return new Response(piStreamToAnthropicSse(piStreamHandle), {
+          const signalGen = detectSignalInStream(piStreamHandle, detector, detectionState, () => {});
+          const sseBody = piStreamToAnthropicSseFromGenerator(signalGen);
+          const response = new Response(sseBody, {
             status: 200,
             headers: { "content-type": "text/event-stream" }
           });
-        }
-        const json = await piStreamToAnthropicJson(piStreamHandle);
-        return new Response(JSON.stringify(json), {
-          status: 200,
-          headers: { "content-type": "application/json" }
-        });
-      }
-      if (apiType === "openai-completions") {
-        if (wantsStream) {
-          return new Response(piStreamToOpenAiCompletionsSse(piStreamHandle), {
-            status: 200,
-            headers: { "content-type": "text/event-stream" }
+          response.clone().text().then(() => {
+            if (detectionState.signalDetected) {
+              abortCtrl.abort();
+              const nextTier = signalRouter.handleEscalation(messages, currentTier);
+              if (nextTier !== null) {
+                console.log(`[clawmux] [escalation] ${currentTier} → ${nextTier} (signal detected)`);
+                currentTier = nextTier;
+                return;
+              }
+            }
+            signalRouter.touchActivity(messages);
+            if (attempt > 0) {
+              signalRouter.recordSuccessfulEscalation(messages, currentTier);
+            }
           });
+          return response;
         }
-        const json = await piStreamToOpenAiCompletionsJson(piStreamHandle);
-        return new Response(JSON.stringify(json), {
-          status: 200,
-          headers: { "content-type": "application/json" }
-        });
-      }
-      if (apiType === "openai-responses") {
-        if (wantsStream) {
-          return new Response(piStreamToOpenAiResponsesSse(piStreamHandle), {
-            status: 200,
-            headers: { "content-type": "text/event-stream" }
-          });
+        const fullText = await collectPiStreamText(piStreamHandle, detector, detectionState);
+        if (detectionState.signalDetected) {
+          const nextTier = signalRouter.handleEscalation(messages, currentTier);
+          if (nextTier !== null) {
+            console.log(`[clawmux] [escalation] ${currentTier} → ${nextTier} (signal detected in non-streaming)`);
+            currentTier = nextTier;
+            continue;
+          }
         }
-        const json = await piStreamToOpenAiResponsesJson(piStreamHandle);
-        return new Response(JSON.stringify(json), {
-          status: 200,
-          headers: { "content-type": "application/json" }
-        });
-      }
-      if (apiType === "google-generative-ai") {
-        if (wantsStream) {
-          return new Response(piStreamToGoogleSse(piStreamHandle), {
-            status: 200,
-            headers: { "content-type": "text/event-stream" }
-          });
+        signalRouter.touchActivity(messages);
+        if (attempt > 0) {
+          signalRouter.recordSuccessfulEscalation(messages, currentTier);
         }
-        const json = await piStreamToGoogleJson(piStreamHandle);
-        return new Response(JSON.stringify(json), {
+        return new Response(JSON.stringify(fullText), {
           status: 200,
           headers: { "content-type": "application/json" }
         });
@@ -120729,7 +120698,7 @@ async function handleApiRequest(req, body, apiType, config, openclawConfig, auth
   const lastUserMsg = [...parsed.messages].reverse().find((m2) => m2.role === "user");
   const msgText = typeof lastUserMsg?.content === "string" ? lastUserMsg.content : Array.isArray(lastUserMsg?.content) ? lastUserMsg.content.filter((b) => b.type === "text").map((b) => b.text ?? "").join(" ") : "";
   const preview = msgText.replace(/\s+/g, " ").trim().slice(0, 100);
-  console.log(`[clawmux] [llm] ${decision.tier} → ${decision.model} | conf=${classification.confidence.toFixed(2)}${classification.reasoning ? ` | ${classification.reasoning}` : ""}${preview ? ` | "${preview}${msgText.length > 100 ? "…" : ""}"` : ""}`);
+  console.log(`[clawmux] [llm] ${decision.tier} → ${decision.model} | legacy${preview ? ` | "${preview}${msgText.length > 100 ? "…" : ""}"` : ""}`);
   if (compressionMiddleware && upstreamResponse.ok) {
     compressionMiddleware.afterResponse(parsed);
   }
@@ -120891,6 +120860,220 @@ function createResolvedCompressionMiddleware(config, openclawConfig, authProfile
     statsTracker
   });
 }
+async function yieldPiAiResponse(piStreamHandle, apiType, wantsStream) {
+  if (apiType === "anthropic-messages") {
+    if (wantsStream) {
+      return new Response(piStreamToAnthropicSse(piStreamHandle), {
+        status: 200,
+        headers: { "content-type": "text/event-stream" }
+      });
+    }
+    const json = await piStreamToAnthropicJson(piStreamHandle);
+    return new Response(JSON.stringify(json), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  }
+  if (apiType === "openai-completions") {
+    if (wantsStream) {
+      return new Response(piStreamToOpenAiCompletionsSse(piStreamHandle), {
+        status: 200,
+        headers: { "content-type": "text/event-stream" }
+      });
+    }
+    const json = await piStreamToOpenAiCompletionsJson(piStreamHandle);
+    return new Response(JSON.stringify(json), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  }
+  if (apiType === "openai-responses") {
+    if (wantsStream) {
+      return new Response(piStreamToOpenAiResponsesSse(piStreamHandle), {
+        status: 200,
+        headers: { "content-type": "text/event-stream" }
+      });
+    }
+    const json = await piStreamToOpenAiResponsesJson(piStreamHandle);
+    return new Response(JSON.stringify(json), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  }
+  if (apiType === "google-generative-ai") {
+    if (wantsStream) {
+      return new Response(piStreamToGoogleSse(piStreamHandle), {
+        status: 200,
+        headers: { "content-type": "text/event-stream" }
+      });
+    }
+    const json = await piStreamToGoogleJson(piStreamHandle);
+    return new Response(JSON.stringify(json), {
+      status: 200,
+      headers: { "content-type": "application/json" }
+    });
+  }
+  throw new Error(`Unsupported pi-ai apiType: ${apiType}`);
+}
+function piStreamToAnthropicSseFromGenerator(gen) {
+  const encoder6 = new TextEncoder;
+  function sseFrame2(event, data) {
+    return encoder6.encode(`event: ${event}
+data: ${JSON.stringify(data)}
+
+`);
+  }
+  return new ReadableStream({
+    async start(controller) {
+      try {
+        let messageStarted = false;
+        const openBlocks = new Map;
+        const ensureMessageStart = (model) => {
+          if (messageStarted)
+            return;
+          messageStarted = true;
+          controller.enqueue(sseFrame2("message_start", {
+            type: "message_start",
+            message: {
+              id: "msg_" + Date.now().toString(36),
+              type: "message",
+              role: "assistant",
+              content: [],
+              model,
+              stop_reason: null,
+              stop_sequence: null,
+              usage: { input_tokens: 0, output_tokens: 0 }
+            }
+          }));
+        };
+        for await (const event of gen) {
+          if (event.type === "start") {
+            ensureMessageStart(event.partial.model || "");
+          } else if (event.type === "text_start") {
+            ensureMessageStart(event.partial.model || "");
+            openBlocks.set(event.contentIndex, "text");
+            controller.enqueue(sseFrame2("content_block_start", {
+              type: "content_block_start",
+              index: event.contentIndex,
+              content_block: { type: "text", text: "" }
+            }));
+          } else if (event.type === "text_delta") {
+            if (openBlocks.get(event.contentIndex) !== "text") {
+              ensureMessageStart(event.partial.model || "");
+              openBlocks.set(event.contentIndex, "text");
+              controller.enqueue(sseFrame2("content_block_start", {
+                type: "content_block_start",
+                index: event.contentIndex,
+                content_block: { type: "text", text: "" }
+              }));
+            }
+            controller.enqueue(sseFrame2("content_block_delta", {
+              type: "content_block_delta",
+              index: event.contentIndex,
+              delta: { type: "text_delta", text: event.delta }
+            }));
+          } else if (event.type === "text_end") {
+            if (openBlocks.get(event.contentIndex) === "text") {
+              controller.enqueue(sseFrame2("content_block_stop", {
+                type: "content_block_stop",
+                index: event.contentIndex
+              }));
+              openBlocks.delete(event.contentIndex);
+            }
+          } else if (event.type === "done") {
+            for (const [idx] of openBlocks) {
+              controller.enqueue(sseFrame2("content_block_stop", {
+                type: "content_block_stop",
+                index: idx
+              }));
+            }
+            openBlocks.clear();
+            controller.enqueue(sseFrame2("message_delta", {
+              type: "message_delta",
+              delta: { stop_reason: "end_turn", stop_sequence: null },
+              usage: { output_tokens: event.message.usage?.output ?? 0 }
+            }));
+            controller.enqueue(sseFrame2("message_stop", { type: "message_stop" }));
+          } else if (event.type === "error") {
+            for (const [idx] of openBlocks) {
+              controller.enqueue(sseFrame2("content_block_stop", {
+                type: "content_block_stop",
+                index: idx
+              }));
+            }
+            openBlocks.clear();
+            controller.enqueue(sseFrame2("error", {
+              type: "error",
+              error: {
+                type: "api_error",
+                message: event.error?.errorMessage ?? "Unknown error"
+              }
+            }));
+          }
+        }
+        controller.close();
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        controller.enqueue(sseFrame2("error", {
+          type: "error",
+          error: { type: "api_error", message: msg }
+        }));
+        controller.close();
+      }
+    }
+  });
+}
+async function collectPiStreamText(piStreamHandle, detector, state) {
+  const msg = await piStreamHandle.result();
+  const fullText = msg.content.filter((c) => c.type === "text").map((c) => c.text).join("");
+  const results = detector.feedChunk(fullText);
+  for (const r2 of results) {
+    if (r2.type === "signal_detected") {
+      state.signalDetected = true;
+      break;
+    }
+  }
+  detector.flush();
+  const STOP_REASON_MAP2 = {
+    stop: "end_turn",
+    length: "max_tokens",
+    toolUse: "tool_use",
+    error: "end_turn",
+    aborted: "end_turn"
+  };
+  const blocks = [];
+  for (const c of msg.content) {
+    if (c.type === "text") {
+      blocks.push({ type: "text", text: c.text });
+    } else if (c.type === "thinking") {
+      blocks.push({
+        type: "thinking",
+        thinking: c.thinking,
+        ...c.thinkingSignature ? { signature: c.thinkingSignature } : {}
+      });
+    } else if (c.type === "toolCall") {
+      blocks.push({
+        type: "tool_use",
+        id: c.id,
+        name: c.name,
+        input: c.arguments ?? {}
+      });
+    }
+  }
+  return {
+    id: "msg_" + Date.now().toString(36),
+    type: "message",
+    role: "assistant",
+    content: blocks,
+    model: msg.model || "",
+    stop_reason: STOP_REASON_MAP2[msg.stopReason] ?? "end_turn",
+    stop_sequence: null,
+    usage: {
+      input_tokens: msg.usage?.input ?? 0,
+      output_tokens: msg.usage?.output ?? 0
+    }
+  };
+}
 var ROUTE_MAPPINGS = [
   { apiType: "anthropic-messages", key: "/v1/messages" },
   { apiType: "openai-completions", key: "/v1/chat/completions" },
@@ -120900,8 +121083,17 @@ var ROUTE_MAPPINGS = [
   { apiType: "bedrock-converse-stream", key: "/model/*/converse-stream" }
 ];
 function setupPipelineRoutes(config, openclawConfig, authProfiles, compressionMiddleware) {
+  const escalationConfig = config.routing.escalation;
+  const signalRouter = new SignalRouter({
+    escalation: {
+      activeThresholdMs: escalationConfig?.activeThresholdMs ?? 300000,
+      maxLifetimeMs: escalationConfig?.maxLifetimeMs ?? 7200000,
+      fingerprintRootCount: escalationConfig?.fingerprintRootCount ?? 5
+    },
+    enabled: escalationConfig?.enabled ?? true
+  });
   for (const mapping of ROUTE_MAPPINGS) {
-    setRouteHandler(mapping.key, (req, body) => handleApiRequest(req, body, mapping.apiType, config, openclawConfig, authProfiles, compressionMiddleware));
+    setRouteHandler(mapping.key, (req, body) => handleApiRequest(req, body, mapping.apiType, config, openclawConfig, authProfiles, compressionMiddleware, signalRouter));
   }
 }
 
@@ -121066,15 +121258,24 @@ function detectInstallMethod() {
     return "npm";
   }
 }
+function resolveBinPath(command) {
+  try {
+    return import_node_child_process.execSync(`which ${command}`, { encoding: "utf-8" }).trim();
+  } catch {
+    return command;
+  }
+}
 function resolveClawmuxBin() {
   try {
     const bin = import_node_child_process.execSync("which clawmux", { encoding: "utf-8" }).trim();
     if (bin.includes("/tmp/") || bin.includes("bunx-") || bin.includes("npx-")) {
-      return detectInstallMethod() === "bun" ? "bunx clawmux" : "npx clawmux";
+      const runtime = detectInstallMethod();
+      return runtime === "bun" ? `${resolveBinPath("bunx")} clawmux` : `${resolveBinPath("npx")} clawmux`;
     }
     return bin;
   } catch {
-    return detectInstallMethod() === "bun" ? "bunx clawmux" : "npx clawmux";
+    const runtime = detectInstallMethod();
+    return runtime === "bun" ? `${resolveBinPath("bunx")} clawmux` : `${resolveBinPath("npx")} clawmux`;
   }
 }
 function getHomeDir3() {
@@ -121085,6 +121286,14 @@ var SYSTEMD_PATH = import_node_path7.join(SYSTEMD_DIR, `${SERVICE_NAME}.service`
 var LAUNCHD_DIR = import_node_path7.join(getHomeDir3(), "Library", "LaunchAgents");
 var LAUNCHD_PATH = import_node_path7.join(LAUNCHD_DIR, `com.${SERVICE_NAME}.plist`);
 function buildSystemdUnit(bin, port, workDir) {
+  const userPaths = [
+    import_node_path7.join(getHomeDir3(), ".bun", "bin"),
+    import_node_path7.join(getHomeDir3(), ".local", "bin"),
+    import_node_path7.join(getHomeDir3(), ".npm-global", "bin"),
+    "/usr/local/bin",
+    "/usr/bin",
+    "/bin"
+  ].join(":");
   return `[Unit]
 Description=ClawMux - Smart model routing proxy
 After=network.target
@@ -121096,6 +121305,7 @@ WorkingDirectory=${workDir}
 Restart=on-failure
 RestartSec=5
 Environment=CLAWMUX_PORT=${port}
+Environment=PATH=${userPaths}
 
 [Install]
 WantedBy=default.target