khala-cli 0.4.9 → 0.4.11

package/dist/{chunk-NIX5F4LT.mjs → chunk-NOKTVPSY.mjs}

@@ -2,40 +2,47 @@ import { createRequire as __khalaCreateRequire } from 'node:module'; const requi
 import {
   DEFAULT_LISTENING_MODE,
   decodeListeningMode
-} from "./chunk-NGSYOVQ4.mjs";
+} from "./chunk-CXVANPY5.mjs";
 import {
   advanceCursor,
+  isWakeEntry,
   listChannels,
+  mentions,
   readActivity,
   readCursor,
   readEntries,
-  unread
-} from "./chunk-TANCKTDK.mjs";
+  unread,
+  wakesAgent
+} from "./chunk-N6UYX3SY.mjs";
 import {
   SESSION_ID_PATTERN,
   StateError,
+  ensureStateDir,
   readJson,
   readWatcherStatus,
   sessionFiles,
   stateRoot,
   writeJsonAtomic
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-JNSB3E6C.mjs";
 import {
+  cancelAttempt,
+  confirmWakeText,
+  failAttempt,
   readWakeState,
   settleAttempts,
   wakeLine,
   withWakeLock
-} from "./chunk-K7V7X6WU.mjs";
+} from "./chunk-TVQ4MSEI.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.mjs";
 
 // src/watch.ts
 init_define_KHALA_BUNDLE();
-import * as fs5 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 import { watch as watchDirectory } from "node:fs";
-import path5 from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
+import path6 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/monitor-storage.ts
 init_define_KHALA_BUNDLE();
@@ -110,11 +117,11 @@ async function readWakeSettings(root) {
 }
 async function writeWakeSettings(root, settings) {
   await fs2.mkdir(root, { recursive: true, mode: 448 });
-  const target = path2.join(root, "wake-settings.json");
-  const temp = `${target}.${randomBytes(8).toString("hex")}.tmp`;
+  const target2 = path2.join(root, "wake-settings.json");
+  const temp = `${target2}.${randomBytes(8).toString("hex")}.tmp`;
   try {
     await fs2.writeFile(temp, JSON.stringify(settings), { mode: 384 });
-    await fs2.rename(temp, target);
+    await fs2.rename(temp, target2);
   } finally {
     await fs2.rm(temp, { force: true });
   }
@@ -178,6 +185,19 @@ function nodeScriptCommand(platform, node, script) {
   return `${quote(node)} ${quote(script)}`;
 }
 
+// src/install/launcher.ts
+init_define_KHALA_BUNDLE();
+function installedLauncher(platform, path7, home, env) {
+  const windows = platform === "win32";
+  const candidate = windows ? env.LOCALAPPDATA : env.XDG_DATA_HOME;
+  const dataHome = candidate && path7.isAbsolute(candidate) ? candidate : windows ? path7.join(home, "AppData", "Local") : path7.join(home, ".local", "share");
+  const prefix = path7.join(dataHome, "khala", "npm");
+  return { prefix, bin: windows ? path7.join(prefix, "khala.cmd") : path7.join(prefix, "bin", "khala") };
+}
+function launcherShellQuote(platform, bin) {
+  return platform === "win32" ? `"${bin}"` : `'${bin.replaceAll("'", `'\\''`)}'`;
+}
+
 // src/install/managed-file.ts
 init_define_KHALA_BUNDLE();
 import * as fs3 from "node:fs/promises";
@@ -352,18 +372,17 @@ async function missingDirs(dir) {
 // src/install/cursor.ts
 var CURSOR_HOOK_EVENTS = ["beforeSubmitPrompt", "postToolUse", "stop"];
 var HOOK_SUFFIX = " hook deliver --harness cursor";
-function cursorPaths({ platform, path: path6, home, env }, packageName = "khala-cli") {
-  const cursorDir = path6.join(home, ".cursor");
+function cursorPaths({ platform, path: path7, home, env }, packageName = "khala-cli") {
+  const cursorDir = path7.join(home, ".cursor");
   const windows = platform === "win32";
-  const dataHome = windows ? env.LOCALAPPDATA && path6.isAbsolute(env.LOCALAPPDATA) ? env.LOCALAPPDATA : path6.join(home, "AppData", "Local") : env.XDG_DATA_HOME && path6.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path6.join(home, ".local", "share");
-  const prefix = path6.join(dataHome, "khala", "npm");
-  const modules = windows ? path6.join(prefix, "node_modules") : path6.join(prefix, "lib", "node_modules");
+  const { prefix } = installedLauncher(platform, path7, home, env);
+  const modules = windows ? path7.join(prefix, "node_modules") : path7.join(prefix, "lib", "node_modules");
   return {
     cursorDir,
     prefix,
-    mcpFile: path6.join(cursorDir, "mcp.json"),
-    hooksFile: path6.join(cursorDir, "hooks.json"),
-    script: path6.join(modules, ...packageName.split("/"), "dist", "khala.mjs")
+    mcpFile: path7.join(cursorDir, "mcp.json"),
+    hooksFile: path7.join(cursorDir, "hooks.json"),
+    script: path7.join(modules, ...packageName.split("/"), "dist", "khala.mjs")
   };
 }
 function cursorHookCommand(platform, node, script) {
@@ -465,11 +484,12 @@ function museCliPath(env = process.env) {
   const { prefix } = cursorPaths({ platform: process.platform, path: path4, home, env });
   return process.platform === "win32" ? path4.join(prefix, "khala.cmd") : path4.join(prefix, "bin", "khala");
 }
-function museWatchCommand(sessionId, bin = museCliPath()) {
-  return `${shellQuote(bin)} watch --harness muse --session ${shellQuote(sessionId ?? "<current session id from khala_status>")}`;
+function museWatchCommand(sessionId, bin = museCliPath(), platform = process.platform) {
+  const quote = platform === "win32" ? (value) => `'${value.replaceAll("'", "''")}'` : shellQuote;
+  return `${platform === "win32" ? "& " : ""}${quote(bin)} watch --harness muse --session ${quote(sessionId ?? "<current session id from khala_status>")}`;
 }
 function museMonitorInstruction(sessionId, command = museWatchCommand(sessionId)) {
-  return `start Muse's monitor tool with command ${JSON.stringify(command)}, persistent: true, wake_delay_ms: 0, show_lines: true. Always pass the current session id explicitly; the monitor shell does not inherit MUSE_SESSION_ID. Keep one monitor per session; If it prints "Do not re-arm", report the reason and do not restart it. Notifications are wake notices; use khala_read for channel content. Never run the watcher as a foreground shell command.`;
+  return `start Muse's monitor tool with command ${JSON.stringify(command)}, persistent: true, wake_delay_ms: 0, show_lines: true. Always pass the current session id explicitly; the monitor shell does not inherit MUSE_SESSION_ID. Keep one monitor per session; If it prints "Do not re-arm", report the reason and do not restart it. Notifications are wake notices, not channel messages. Do not call khala_read or reply to the wake notice; Khala hooks supply the <khala-channel-messages> frame. End the turn so the Stop hook can deliver the frame in sync mode; in steer mode it can arrive after a tool. Use khala_read only for history or owner-requested manual reads; if you already replied to a message from history, do not reply again when the same message appears in a hook frame. Never run the watcher as a foreground shell command.`;
 }
 function createMuseMonitorDriver() {
   return {
@@ -569,15 +589,243 @@ async function museWakeProof(files, sessionId, env, turnId) {
   return void 0;
 }
 
+// src/wake/qwen-socket.ts
+init_define_KHALA_BUNDLE();
+import * as fs6 from "node:fs/promises";
+import net from "node:net";
+import os3 from "node:os";
+import path5 from "node:path";
+import { randomBytes as randomBytes2, randomUUID as randomUUID2 } from "node:crypto";
+
+// src/wake/qwen-transcript.ts
+init_define_KHALA_BUNDLE();
+import * as fs5 from "node:fs/promises";
+async function qwenNotification(filePath) {
+  const file = await fs5.open(filePath, "r");
+  let text;
+  try {
+    const stat3 = await file.stat();
+    const start = Math.max(0, stat3.size - 1024 * 1024);
+    const buffer = Buffer.alloc(Math.min(stat3.size, 1024 * 1024));
+    const { bytesRead } = await file.read(buffer, 0, buffer.length, start);
+    text = buffer.subarray(0, bytesRead).toString("utf8");
+    if (start) text = text.slice(text.indexOf("\n") + 1);
+  } finally {
+    await file.close();
+  }
+  const notifications = [];
+  for (const line of text.trimEnd().split("\n").reverse()) {
+    let entry;
+    try {
+      entry = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (entry?.type !== "user" || entry.provenance !== "system" || entry.subtype !== "notification" || entry.deliveredTurn !== true || entry.message?.role !== "user" || !Array.isArray(entry.message.parts)) continue;
+    notifications.push(entry.message.parts.filter((part) => typeof part?.text === "string").map((part) => part.text).join("\n"));
+  }
+  return notifications.length ? notifications.join("\n") : void 0;
+}
+async function verifyQwenTranscript(dir, filePath, now) {
+  const text = await qwenNotification(filePath);
+  if (text !== void 0) await confirmWakeText(dir, "socket", text, now);
+  return text;
+}
+
+// src/wake/qwen-socket.ts
+var qwenHome = (env) => env.QWEN_HOME ? path5.resolve(env.QWEN_HOME) : path5.join(env.HOME ?? os3.homedir(), ".qwen");
+async function qwenInboundAllowed(env, workspace = env.PWD ?? process.cwd()) {
+  for (const file of [path5.join(qwenHome(env), "settings.json"), path5.join(workspace, ".qwen", "settings.json")]) {
+    const config = await readJson(file);
+    if (["hold", "refuse"].includes(config?.agents?.crossSessionInbound ?? "") || config?.agents?.crossSessionMessaging === false) return false;
+  }
+  return true;
+}
+var qwenControllerFile = (env) => path5.join(stateRoot(env), "qwen", "controller.json");
+async function qwenSession(env) {
+  const socket = env.QWEN_CODE_MESSAGING_SOCKET;
+  if (!socket) return void 0;
+  try {
+    const dir = path5.join(qwenHome(env), "sessions");
+    for (const file of await fs6.readdir(dir)) {
+      if (!/^\d+\.json$/u.test(file)) continue;
+      const record = await readJson(path5.join(dir, file));
+      if (record?.ipcPath === socket && typeof record.sessionId === "string" && SESSION_ID_PATTERN.test(record.sessionId)) return record.sessionId;
+    }
+  } catch {
+  }
+  return void 0;
+}
+async function target(env) {
+  const sessionId = await qwenSession(env);
+  if (!sessionId) return void 0;
+  try {
+    const file = qwenControllerFile(env);
+    const stat3 = await fs6.lstat(file);
+    if (!stat3.isFile() || (stat3.mode & 63) !== 0) return void 0;
+    const credential = await readJson(file);
+    if (!credential?.token || !/^qpc_[0-9a-f]{64}$/u.test(credential.token)) return void 0;
+    return { socket: env.QWEN_CODE_MESSAGING_SOCKET, sessionId, token: credential.token };
+  } catch {
+    return void 0;
+  }
+}
+function qwenFrames(target2, line, from, replyToken, msgId) {
+  return JSON.stringify({ msgV: 1, type: "auth", token: target2.token }) + "\n" + JSON.stringify({
+    msgV: 1,
+    msgId,
+    type: "user",
+    from,
+    replyToken,
+    fromName: "khala",
+    fromMode: "prompting",
+    toSessionId: target2.sessionId,
+    priority: "next",
+    message: { role: "user", content: line }
+  }) + "\n";
+}
+async function sendQwenWake(target2, line, signal, options = {}) {
+  if (signal.aborted) return "failed";
+  const dir = await fs6.mkdtemp(path5.join(options.runtimeDir ?? os3.tmpdir(), "khala-qw-"));
+  const from = path5.join(dir, "r.sock");
+  if (Buffer.byteLength(from) > 103) {
+    await fs6.rm(dir, { recursive: true, force: true });
+    return "failed";
+  }
+  const replyToken = randomBytes2(32).toString("hex");
+  const msgId = randomUUID2();
+  const peers = /* @__PURE__ */ new Set();
+  let sender;
+  let finish;
+  const result = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const aborted = () => finish("failed");
+  const server = net.createServer((socket) => {
+    peers.add(socket);
+    socket.on("close", () => peers.delete(socket));
+    socket.on("error", () => {
+    });
+    let buffer = "", authenticated = false;
+    socket.setEncoding("utf8");
+    socket.on("data", (chunk) => {
+      buffer += chunk;
+      if (buffer.length > 64 * 1024) {
+        socket.destroy();
+        return;
+      }
+      let at;
+      while ((at = buffer.indexOf("\n")) >= 0) {
+        const text = buffer.slice(0, at);
+        buffer = buffer.slice(at + 1);
+        let frame;
+        try {
+          frame = JSON.parse(text);
+        } catch {
+          socket.destroy();
+          return;
+        }
+        if (!authenticated) {
+          authenticated = frame?.msgV === 1 && frame.type === "auth" && frame.token === replyToken;
+          if (!authenticated) {
+            socket.destroy();
+            return;
+          }
+        } else if (frame?.msgV === 1 && frame.type === "control" && frame.action === "delivery_status" && frame.origMsgId === msgId && ["delivered", "held", "refused", "denied", "expired", "misaddressed", "dropped"].includes(frame.status)) {
+          finish(frame.status);
+        }
+      }
+    });
+  });
+  server.on("error", () => finish("failed"));
+  signal.addEventListener("abort", aborted, { once: true });
+  const timer = setTimeout(() => finish("failed"), options.timeoutMs ?? 5e3);
+  try {
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(from, resolve);
+    });
+    await fs6.chmod(from, 384);
+    if (signal.aborted) return "failed";
+    sender = net.createConnection(target2.socket);
+    sender.on("error", () => finish("failed"));
+    sender.on("connect", () => {
+      sender.end(qwenFrames(target2, line, from, replyToken, msgId));
+    });
+    return await result;
+  } catch {
+    return "failed";
+  } finally {
+    clearTimeout(timer);
+    signal.removeEventListener("abort", aborted);
+    sender?.destroy();
+    for (const socket of peers) socket.destroy();
+    await new Promise((resolve) => server.close(() => resolve()));
+    await fs6.rm(dir, { recursive: true, force: true });
+  }
+}
+function createQwenSocketDriver(deps = {}) {
+  const resolve = deps.resolve ?? target;
+  const policy = async (env) => {
+    const config = await readJson(path5.join(qwenHome(env), "settings.json"));
+    return config?.agents;
+  };
+  const reason = async (ctx) => {
+    const config = await policy(ctx.env);
+    if (config?.crossSessionInbound === "hold") return "qwen_held";
+    if ((deps.platform ?? process.platform) === "win32") return "windows";
+    const receipt = await readJson(path5.join(ctx.files.dir, "qwen-receipt.json"));
+    if (receipt?.status === "held" && config?.crossSessionInbound !== "accept") return "qwen_held";
+    if (config?.crossSessionMessaging === false || config?.crossSessionInbound === "refuse") return "qwen_refused";
+    if (!deps.resolve && !ctx.env.QWEN_CODE_MESSAGING_SOCKET) return "qwen_session_missing";
+    return await resolve(ctx.env) ? void 0 : "qwen_socket_missing";
+  };
+  return {
+    id: "socket",
+    rung: 1,
+    optIn: false,
+    minIdleMs: 0,
+    deadlineMs: 3e4,
+    verification: "transcript",
+    async verify(ctx) {
+      const journal = await readJson(path5.join(ctx.files.dir, "wake-journal.json"));
+      const receipt = await readJson(path5.join(ctx.files.dir, "qwen-receipt.json"));
+      if (!journal?.attempts?.some((attempt) => attempt.driver === "socket") && receipt?.status !== "held") return;
+      const transcript = await readJson(path5.join(ctx.files.dir, "qwen-transcript.json"));
+      if (!transcript?.path) return;
+      try {
+        const text = await verifyQwenTranscript(ctx.files.dir, transcript.path, ctx.now);
+        if (receipt?.status === "held" && receipt.nonce && text?.includes(`(k-${receipt.nonce})`)) {
+          await writeJsonAtomic(path5.join(ctx.files.dir, "qwen-receipt.json"), { status: "delivered" });
+        }
+      } catch {
+      }
+    },
+    available: async (ctx) => !await reason(ctx),
+    unavailableReason: reason,
+    async wake(ctx, line) {
+      if (ctx.signal.aborted || await reason(ctx)) return "skipped";
+      const destination = await resolve(ctx.env);
+      if (!destination || destination.sessionId !== ctx.sessionId) return "skipped";
+      const status = await (deps.send ?? sendQwenWake)(destination, line, ctx.signal);
+      await ensureStateDir(ctx.files.dir);
+      const nonce = line.match(/\(k-([0-9a-f]{8})\)$/u)?.[1];
+      await writeJsonAtomic(path5.join(ctx.files.dir, "qwen-receipt.json"), { status, nonce });
+      if (nonce && status === "held") await cancelAttempt(ctx.files.dir, nonce);
+      else if (nonce && status !== "delivered") await failAttempt(ctx.files.dir, nonce, ctx.now);
+    }
+  };
+}
+
 // src/watch.ts
 var MARKER = "monitor.json";
 var OBSERVATION = "monitor-cursor.json";
 var NONCE_PATTERN = /^[a-f0-9-]{36}$/;
-var leaseFile = (dir, nonce) => path5.join(dir, `monitor-${nonce}.json`);
+var leaseFile = (dir, nonce) => path6.join(dir, `monitor-${nonce}.json`);
 async function monitorOwner(files) {
   const owners = [];
   for (const dir of monitorStorageCandidates(files)) {
-    const owner = await readJson(path5.join(dir, MARKER));
+    const owner = await readJson(path6.join(dir, MARKER));
     if (!owner || !Number.isSafeInteger(owner.pid) || owner.pid <= 0 || typeof owner.nonce !== "string" || !NONCE_PATTERN.test(owner.nonce)) continue;
     const lease = await readJson(leaseFile(dir, owner.nonce));
     if (lease?.nonce !== owner.nonce) continue;
@@ -598,17 +846,19 @@ async function monitorOwner(files) {
 async function monitorArmed(files) {
   return !!await monitorOwner(files);
 }
-function mentions(entry, name) {
-  if (!name) return false;
-  const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  return new RegExp(`(?<![\\p{L}\\p{N}_])@?${escaped}(?![\\p{L}\\p{N}_])`, "iu").test(entry.body);
-}
 function channelLabel(name) {
   return Array.from(name.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, " ").trim()).slice(0, 80).join("");
 }
 async function watchSession(files, io) {
-  const nonce = randomUUID2();
+  const nonce = randomUUID3();
   let storage = files.dir;
+  const env = io.env ?? process.env;
+  const qwen = io.harness === "qwen";
+  const wakeAllowed = async () => {
+    if (!qwen) return true;
+    const wake = await readWakeSettings(stateRoot(env));
+    return await qwenInboundAllowed(env) && !wake.off["qwen/socket"] && !wake.off["qwen/background-shell"];
+  };
   let watcher;
   let timer;
   let running;
@@ -626,7 +876,7 @@ async function watchSession(files, io) {
     code = exit;
     watcher?.close();
     clearInterval(timer);
-    io.stderr?.(`khala watch: stopped (${reason}). Do not re-arm.`);
+    if (!qwen || exit !== 0) io.stderr?.(`khala watch: stopped (${reason}). Do not re-arm.`);
     finish();
   };
   let lastHeartbeat = 0;
@@ -647,19 +897,19 @@ async function watchSession(files, io) {
     }
     storage = await monitorStorage(files);
     const storageDirs = /* @__PURE__ */ new Map([[files.dir, storage]]);
-    const observationDir = async (target) => {
-      let dir = storageDirs.get(target.dir);
+    const observationDir = async (target2) => {
+      let dir = storageDirs.get(target2.dir);
       if (!dir) {
-        dir = await monitorStorage(target);
-        storageDirs.set(target.dir, dir);
+        dir = await monitorStorage(target2);
+        storageDirs.set(target2.dir, dir);
       }
       return dir;
     };
     const initialDelivered = /* @__PURE__ */ new Map();
-    const seedBaseline = async (target, session) => {
-      initialDelivered.set(target.dir, {
+    const seedBaseline = async (target2, session) => {
+      initialDelivered.set(target2.dir, {
         identity: JSON.stringify([session.roomId, session.userId]),
-        cursor: await readCursor(target)
+        cursor: await readCursor(target2)
       });
     };
     if (initialSession) await seedBaseline(files, initialSession);
@@ -682,68 +932,75 @@ async function watchSession(files, io) {
         lastHeartbeat = Date.now();
         await writeJsonAtomic(leaseFile(storage, nonce), { nonce, pid: process.pid, heartbeatAt: new Date(lastHeartbeat).toISOString() });
       }
+      if (!await wakeAllowed()) return;
       for (const channel of await listChannels(files)) {
-        const target = channel.files;
-        const session = await readJson(target.session);
-        const status2 = await readWatcherStatus(target);
+        const target2 = channel.files;
+        const session = await readJson(target2.session);
+        const status2 = await readWatcherStatus(target2);
         if (!session || session.roomId !== channel.roomId || typeof session.userId !== "string" || !["connected", "send_failed"].includes(status2?.state ?? "")) continue;
         const identity = JSON.stringify([session.roomId, session.userId]);
-        if (initialDelivered.get(target.dir)?.identity !== identity) {
-          await seedBaseline(target, session);
+        if (initialDelivered.get(target2.dir)?.identity !== identity) {
+          await seedBaseline(target2, session);
         }
-        const mode = await readListeningMode(target);
-        const entries = await readEntries(target);
-        const observed = await readJson(path5.join(await observationDir(target), OBSERVATION));
+        const mode = await readListeningMode(target2);
+        const entries = await readEntries(target2);
+        const observed = await readJson(path6.join(await observationDir(target2), OBSERVATION));
         const position = observed?.userId === session.userId && observed?.roomId === session.roomId && Number.isSafeInteger(observed.count) && observed.count >= 0 && observed.count <= entries.length && (observed.count === 0 || entries[observed.count - 1]?.eventId === observed.lastEventId) ? observed.count : 0;
-        const baseline = initialDelivered.get(target.dir).cursor;
+        const baseline = initialDelivered.get(target2.dir).cursor;
         const initialCount = baseline.deliveredCount === 0 || entries[baseline.deliveredCount - 1]?.eventId === baseline.lastDeliveredEventId ? baseline.deliveredCount : 0;
         const fresh = entries.slice(Math.max(initialCount, position));
-        const latestMode = await readListeningMode(target);
-        const latestSession = await readJson(target.session);
-        const latestStatus = await readWatcherStatus(target);
+        const latestMode = await readListeningMode(target2);
+        const latestSession = await readJson(target2.session);
+        const latestStatus = await readWatcherStatus(target2);
         if (!await ownsSession()) {
           stop(2, exitReason);
           return;
         }
+        if (!await wakeAllowed()) return;
         if (latestSession?.userId !== session.userId || latestSession?.roomId !== session.roomId || !["connected", "send_failed"].includes(latestStatus?.state ?? "")) continue;
-        const messages = fresh.filter((entry) => entry.kind === "message" && entry.sender !== session.userId && entry.roomId === session.roomId);
-        if (io.harness !== "muse" && !done && mode !== "async" && latestMode !== "async" && messages.length) {
+        const messages = fresh.filter((entry) => isWakeEntry(entry) && entry.sender !== session.userId && entry.roomId === session.roomId);
+        if (io.harness !== "muse" && !done && mode !== "async" && latestMode !== "async" && messages.some((entry) => wakesAgent(entry, latestMode, latestStatus?.displayName))) {
           const count = messages.filter((entry) => mentions(entry, latestStatus?.displayName)).length;
           io.write(`khala: ${messages.length} new message${messages.length === 1 ? "" : "s"} in #${channelLabel(latestStatus?.channelName ?? channel.channelName ?? "channel")} (${count} mentions you)
 `);
+          if (qwen) {
+            stop();
+            return;
+          }
         }
-        if (position !== entries.length && !done && await ownsSession() && JSON.stringify(await readJson(target.session)) === JSON.stringify(latestSession)) {
+        if (position !== entries.length && !done && await ownsSession() && JSON.stringify(await readJson(target2.session)) === JSON.stringify(latestSession)) {
           try {
-            await writeJsonAtomic(path5.join(await observationDir(target), OBSERVATION), {
+            await writeJsonAtomic(path6.join(await observationDir(target2), OBSERVATION), {
               userId: session.userId,
               roomId: session.roomId,
               count: entries.length,
               lastEventId: entries.at(-1)?.eventId ?? null
             });
           } catch (error) {
-            if (await readJson(target.session)) throw error;
+            if (await readJson(target2.session)) throw error;
           }
         }
       }
       if (io.harness === "muse" && !done && await ownsSession()) {
-        const request = await readJson(path5.join(files.dir, MUSE_WAKE_REQUEST));
+        const request = await readJson(path6.join(files.dir, MUSE_WAKE_REQUEST));
         const now = (io.now ?? Date.now)();
         const wakeNonce = typeof request?.line === "string" ? /\(k-([a-f0-9]{8})\)$/.exec(request.line)?.[1] : void 0;
         if (request?.owner === nonce && wakeNonce && wakeLine(wakeNonce) === request.line && request.line !== emittedRequest && now >= request.at && now < request.deadline && await driverAllowed(stateRoot(io.env ?? process.env), "muse", "monitor", false) && !(await readWakeState(files.dir)).monitor?.disabled && (await readActivity(files)).state === "idle") {
           const channels = await listChannels(files);
           let eligible = false;
           for (const channel of channels) {
-            if (await readListeningMode(channel.files) === "async") continue;
+            const channelMode = await readListeningMode(channel.files);
+            if (channelMode === "async") continue;
             const session = await readJson(channel.files.session);
             const status2 = await readWatcherStatus(channel.files);
             if (!["connected", "send_failed"].includes(status2?.state ?? "")) continue;
             const cursor = await readCursor(channel.files);
-            eligible ||= (await readEntries(channel.files)).slice(cursor.deliveredCount).some((entry) => entry.kind === "message" && entry.sender !== session?.userId);
+            eligible ||= (await readEntries(channel.files)).slice(cursor.deliveredCount).some((entry) => entry.sender !== session?.userId && wakesAgent(entry, channelMode, status2?.displayName));
           }
           const activity = await readActivity(files);
           if (eligible && await ownsSession() && activity.state === "idle") {
             const epoch = activity.updatedAt;
-            const dedupFile = path5.join(storage, "monitor-wake-observed.json");
+            const dedupFile = path6.join(storage, "monitor-wake-observed.json");
             const observed = await readJson(dedupFile);
             if (observed?.epoch === epoch) return;
             await writeJsonAtomic(dedupFile, { epoch, line: request.line });
@@ -774,7 +1031,7 @@ async function watchSession(files, io) {
     watcher.on("error", (error) => stop(3, errorReason(error)));
     lastHeartbeat = Date.now();
     await writeJsonAtomic(leaseFile(storage, nonce), { nonce, pid: process.pid, heartbeatAt: new Date(lastHeartbeat).toISOString() });
-    await writeJsonAtomic(path5.join(storage, MARKER), { nonce, pid: process.pid, startedAt: Date.now() });
+    await writeJsonAtomic(path6.join(storage, MARKER), { nonce, pid: process.pid, startedAt: Date.now() });
     published = true;
     timer = setInterval(notify, 100);
     io.signal.addEventListener("abort", abort, { once: true });
@@ -790,7 +1047,7 @@ async function watchSession(files, io) {
     clearInterval(timer);
     watcher?.close();
     io.signal.removeEventListener("abort", abort);
-    await fs5.unlink(leaseFile(storage, nonce)).catch((error) => {
+    await fs7.unlink(leaseFile(storage, nonce)).catch((error) => {
       if (!["ENOENT", "EACCES", "EROFS"].includes(error.code ?? "")) throw error;
     });
   }
@@ -807,8 +1064,8 @@ ${WATCH_USAGE}`);
     return 1;
   };
   if (argv.length !== 0 && !(argv.length === 2 && ["--session", "--harness"].includes(argv[0])) && !(argv.length === 4 && argv[0] === "--harness" && argv[2] === "--session")) return invalid("invalid_arguments");
-  const { resolveHarness, resolveSessionId } = await import("./chunk-LBT47HLZ.mjs");
-  const { adapterFor } = await import("./chunk-XBQDIKB5.mjs");
+  const { resolveHarness, resolveSessionId } = await import("./chunk-CYINL2V3.mjs");
+  const { adapterFor } = await import("./chunk-AQX2OYEF.mjs");
   const harness = resolveHarness(argv, process.env);
   if (harness === "invalid" || !adapterFor(harness)?.codec) return invalid("invalid_harness");
   const index = argv.indexOf("--session");
@@ -823,7 +1080,7 @@ ${WATCH_USAGE}`);
   try {
     return await watchSession(files, { write: (line) => {
       process.stdout.write(line);
-    }, signal: controller.signal, harness, stderr: (line) => {
+    }, signal: controller.signal, harness, env: process.env, stderr: (line) => {
       process.stderr.write(line + "\n");
     } });
   } finally {
@@ -841,17 +1098,24 @@ export {
   CURSOR_WORKSPACE_ENV,
   CURSOR_DEFAULT_SESSION,
   cursorSessionId,
+  installedLauncher,
+  launcherShellQuote,
   formatJson,
   jsonFormat,
   textFormat,
   readManaged,
   ManagedFiles,
+  verifyQwenTranscript,
+  qwenHome,
+  qwenInboundAllowed,
+  qwenControllerFile,
+  qwenSession,
+  createQwenSocketDriver,
   nodeScriptCommand,
   cursorPaths,
   installCursor,
   monitorOwner,
   monitorArmed,
-  mentions,
   watchSession,
   WATCH_USAGE,
   run,

package/dist/{chunk-3KDOTR54.mjs → chunk-NUQSDSVT.mjs}

@@ -2,7 +2,7 @@ import { createRequire as __khalaCreateRequire } from 'node:module'; const requi
 import {
   define_KHALA_BUNDLE_default,
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.mjs";
 
 // src/bundle.ts
 init_define_KHALA_BUNDLE();