khala-cli 0.4.8 → 0.4.10

package/dist/chunk-2AMWQ7RB.mjs

@@ -0,0 +1,1127 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  DEFAULT_LISTENING_MODE,
+  decodeListeningMode
+} from "./chunk-4BP7V3OP.mjs";
+import {
+  advanceCursor,
+  isWakeEntry,
+  listChannels,
+  mentions,
+  readActivity,
+  readCursor,
+  readEntries,
+  unread,
+  wakesAgent
+} from "./chunk-OEV5DFLW.mjs";
+import {
+  SESSION_ID_PATTERN,
+  StateError,
+  ensureStateDir,
+  readJson,
+  readWatcherStatus,
+  sessionFiles,
+  stateRoot,
+  writeJsonAtomic
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  cancelAttempt,
+  confirmWakeText,
+  failAttempt,
+  readWakeState,
+  settleAttempts,
+  wakeLine,
+  withWakeLock
+} from "./chunk-ZSKLNZWZ.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/watch.ts
+init_define_KHALA_BUNDLE();
+import * as fs7 from "node:fs/promises";
+import { watch as watchDirectory } from "node:fs";
+import path6 from "node:path";
+import { randomUUID as randomUUID3 } from "node:crypto";
+
+// src/monitor-storage.ts
+init_define_KHALA_BUNDLE();
+import * as fs from "node:fs/promises";
+import { createHash, randomUUID } from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+function monitorStorageCandidates(files) {
+  const hash = createHash("sha256").update(path.resolve(files.dir)).digest("hex");
+  const uid = process.getuid?.() ?? os.userInfo().username;
+  return [files.dir, path.join(process.platform === "win32" ? os.tmpdir() : "/tmp", `khala-monitor-${uid}-${hash}`)];
+}
+async function monitorStorage(files) {
+  const probe = path.join(files.dir, `.monitor-probe-${randomUUID()}`);
+  try {
+    const handle = await fs.open(probe, "wx", 384);
+    await handle.close();
+    await fs.unlink(probe);
+    return files.dir;
+  } catch (error) {
+    if (!["EACCES", "EPERM", "EROFS"].includes(error.code ?? "")) throw error;
+  }
+  const dir = monitorStorageCandidates(files)[1];
+  await fs.mkdir(dir, { mode: 448 }).catch((error) => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  const stat3 = await fs.lstat(dir);
+  if (!stat3.isDirectory() || stat3.isSymbolicLink() || process.getuid && stat3.uid !== process.getuid() || process.platform !== "win32" && (stat3.mode & 63) !== 0) throw new Error("unsafe_monitor_directory");
+  return dir;
+}
+
+// src/mode.ts
+init_define_KHALA_BUNDLE();
+async function readListeningMode(files) {
+  const content = await readJson(files.mode);
+  const decoded = decodeListeningMode(typeof content === "object" && content !== null ? content.mode : void 0);
+  return decoded.ok ? decoded.value : DEFAULT_LISTENING_MODE;
+}
+async function applyListeningMode(files, next, meta, now = () => /* @__PURE__ */ new Date()) {
+  const previous = await readListeningMode(files);
+  if (previous === "async" && next !== "async") {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const { cursor, entries } = await unread(files);
+      if (await advanceCursor(files, cursor, entries) !== "conflict") break;
+      if (attempt === 1) throw new StateError("storage_failed");
+    }
+  }
+  await writeJsonAtomic(files.mode, { mode: next, ...meta, updatedAt: now().toISOString() });
+  return { previous, next };
+}
+
+// src/wake/shared/index.ts
+init_define_KHALA_BUNDLE();
+
+// src/wake/shared/settings.ts
+init_define_KHALA_BUNDLE();
+import * as fs2 from "node:fs/promises";
+import path2 from "node:path";
+import { randomBytes } from "node:crypto";
+async function readWakeSettings(root) {
+  try {
+    const value = JSON.parse(await fs2.readFile(path2.join(root, "wake-settings.json"), "utf8"));
+    const entries = (input) => {
+      if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+      return Object.fromEntries(Object.entries(input).filter(([, entry]) => entry && typeof entry === "object" && typeof entry.at === "string"));
+    };
+    return { consent: entries(value?.consent), off: entries(value?.off) };
+  } catch (error) {
+    if (error.code === "ENOENT") return { consent: {}, off: {} };
+    throw error;
+  }
+}
+async function writeWakeSettings(root, settings) {
+  await fs2.mkdir(root, { recursive: true, mode: 448 });
+  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, target2);
+  } finally {
+    await fs2.rm(temp, { force: true });
+  }
+}
+async function updateWakeSettings(root, update) {
+  await withWakeLock(root, "wake-settings.lock", async () => {
+    const settings = await readWakeSettings(root);
+    update(settings);
+    await writeWakeSettings(root, settings);
+  });
+}
+async function driverAllowed(root, harness, driver, optIn) {
+  const settings = await readWakeSettings(root);
+  const key = `${harness}/${driver}`;
+  return !Object.hasOwn(settings.off, key) && (!optIn || Object.hasOwn(settings.consent, key));
+}
+
+// src/wake/muse-monitor.ts
+init_define_KHALA_BUNDLE();
+import { createInterface } from "node:readline";
+import * as fs4 from "node:fs/promises";
+import os2 from "node:os";
+import path4 from "node:path";
+
+// src/install/cursor.ts
+init_define_KHALA_BUNDLE();
+
+// src/cursor.ts
+init_define_KHALA_BUNDLE();
+import { createHash as createHash2 } from "node:crypto";
+var CURSOR_WORKSPACE_ENV = "KHALA_CURSOR_WORKSPACE";
+var CURSOR_DEFAULT_SESSION = "cursor-default";
+function normalizeWorkspace(root) {
+  let value = root.trim();
+  if (!value || value.includes("${")) return null;
+  if (/^file:\/\//iu.test(value)) {
+    try {
+      value = decodeURIComponent(new URL(value).pathname);
+    } catch {
+      return null;
+    }
+  }
+  value = value.replaceAll("\\", "/");
+  if (/^\/[A-Za-z]:(?:\/|$)/u.test(value)) value = value.slice(1);
+  if (/^[A-Za-z]:(?:\/|$)/u.test(value)) value = value.toLowerCase();
+  value = value.replace(/\/+$/u, "");
+  if (/^[a-z]:$/u.test(value)) value += "/";
+  return value || null;
+}
+function cursorSessionId(root) {
+  const normalized = typeof root === "string" ? normalizeWorkspace(root) : null;
+  if (normalized === null) return CURSOR_DEFAULT_SESSION;
+  return `ws-${createHash2("sha256").update(normalized).digest("hex").slice(0, 32)}`;
+}
+
+// src/install/command.ts
+init_define_KHALA_BUNDLE();
+function nodeScriptCommand(platform, node, script) {
+  if (platform === "win32") return `node "${script.replaceAll("\\", "/")}"`;
+  const quote = (value) => /^[A-Za-z0-9_./:-]+$/u.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+  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";
+import path3 from "node:path";
+import { isDeepStrictEqual } from "node:util";
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var BOM = "\uFEFF";
+function formatJson(value, like) {
+  const body = like?.startsWith(BOM) ? like.slice(1) : like;
+  const indent = body?.match(/^([ \t]+)\S/mu)?.[1] ?? 2;
+  const newline = body?.includes("\r\n") ? "\r\n" : "\n";
+  const trailing = body === null || body === void 0 || /\n$/u.test(body) || body.trim() === "" ? newline : "";
+  return (like?.startsWith(BOM) ? BOM : "") + JSON.stringify(value, null, indent).replaceAll("\n", newline) + trailing;
+}
+function pruneCreated(value, original) {
+  if (!isObject(value)) return value;
+  const next = {};
+  for (const [key, child] of Object.entries(value)) {
+    const before = isObject(original) && Object.hasOwn(original, key) ? original[key] : void 0;
+    const pruned = pruneCreated(child, before);
+    const emptyContainer = Array.isArray(pruned) ? pruned.length === 0 : isObject(pruned) && Object.keys(pruned).length === 0;
+    if (emptyContainer && before === void 0) continue;
+    next[key] = pruned;
+  }
+  return next;
+}
+var jsonFormat = {
+  parse: (text) => text.trim() ? JSON.parse(text.replace(/^/u, "")) : {},
+  serialize: formatJson,
+  equal: isDeepStrictEqual,
+  empty: (value) => isObject(value) && Object.keys(value).length === 0,
+  prune: pruneCreated
+};
+var meaningfulLines = (text) => String(text).split(/\r?\n/u).map((line) => line.trimEnd()).filter(Boolean);
+var textFormat = {
+  parse: (text) => text,
+  serialize: (value) => String(value),
+  equal: (a, b) => isDeepStrictEqual(meaningfulLines(a), meaningfulLines(b)),
+  empty: (value) => meaningfulLines(value).length === 0
+};
+async function readManaged(file) {
+  try {
+    return { file, text: await fs3.readFile(file, "utf8") };
+  } catch (error) {
+    if (error.code === "ENOENT") return { file, text: null };
+    throw error;
+  }
+}
+var LEGACY_BACKUP = ".khala-bak";
+var ManagedFiles = class {
+  store;
+  constructor(stateDir) {
+    this.store = path3.join(stateDir, "install-originals.json");
+  }
+  async load() {
+    try {
+      const value = JSON.parse(await fs3.readFile(this.store, "utf8"));
+      return isObject(value) ? value : {};
+    } catch (error) {
+      if (error.code === "ENOENT") return {};
+      throw error;
+    }
+  }
+  async save(recordings) {
+    if (!Object.keys(recordings).length) {
+      await fs3.rm(this.store, { force: true });
+      return;
+    }
+    await fs3.mkdir(path3.dirname(this.store), { recursive: true, mode: 448 });
+    const temp = `${this.store}.${process.pid}.tmp`;
+    await fs3.writeFile(temp, JSON.stringify(recordings, null, 2) + "\n", { mode: 384 });
+    await fs3.rename(temp, this.store);
+  }
+  /** The recorded original: `undefined` when nothing is recorded, `null` when the file did not exist. */
+  async original(file) {
+    const recording = (await this.load())[path3.resolve(file)];
+    if (recording) return recording.existed ? Buffer.from(recording.bytes ?? "", "base64") : null;
+    const legacy = await readBytes(file + LEGACY_BACKUP);
+    return legacy ?? void 0;
+  }
+  /**
+   * Records the original once, before Khala's first change. An earlier installer's
+   * `.khala-bak` is adopted as the original (the file itself then holds Khala's output)
+   * and removed. A harness-specific legacy absence sentinel can pass `original: null`;
+   * the override still never replaces a previously saved recording.
+   */
+  async record(file, options) {
+    const key = path3.resolve(file);
+    const recordings = await this.load();
+    if (recordings[key]) return;
+    const legacy = await readBytes(file + LEGACY_BACKUP);
+    const current = options ? options.original : legacy ?? await readBytes(file);
+    recordings[key] = current === null ? { existed: false, createdDirs: await missingDirs(path3.dirname(key)) } : { existed: true, bytes: current.toString("base64"), createdDirs: [] };
+    await this.save(recordings);
+    if (legacy) await fs3.rm(file + LEGACY_BACKUP, { force: true });
+  }
+  /**
+   * Install: records every file's original first (so each knows which directories Khala
+   * creates), then writes each `text` that differs from the current content.
+   */
+  async write(entries) {
+    for (const { current } of entries) await this.record(current.file);
+    for (const { current, text, mode } of entries) {
+      if (text === current.text) continue;
+      await fs3.mkdir(path3.dirname(current.file), { recursive: true });
+      await fs3.writeFile(current.file, text, mode === void 0 ? void 0 : { mode });
+    }
+  }
+  /**
+   * Uninstall. `strip` receives the parsed current content and the parsed recorded original
+   * (`undefined` when the file did not exist or nothing is recorded) and returns the content
+   * without Khala's keys. Writes back the recorded bytes when the result is equal to them,
+   * deletes the file when it did not exist and nothing is left, and otherwise writes the
+   * stripped content. The recording is then dropped.
+   */
+  async restore(current, format, strip) {
+    const key = path3.resolve(current.file);
+    const recordings = await this.load();
+    const recording = recordings[key];
+    const original = await this.original(current.file);
+    if (current.text !== null) {
+      let originalValue;
+      let comparable = original !== void 0;
+      if (original) {
+        try {
+          originalValue = format.parse(original.toString("utf8"));
+        } catch {
+          comparable = false;
+        }
+      }
+      let value = strip(format.parse(current.text), originalValue);
+      if (comparable && format.prune) value = format.prune(value, originalValue);
+      if (comparable && original === null && format.empty(value)) {
+        await fs3.rm(current.file, { force: true });
+        for (const dir of recording?.createdDirs ?? []) await fs3.rmdir(dir).catch(() => void 0);
+      } else if (comparable && original && format.equal(value, originalValue)) {
+        if (!original.equals(Buffer.from(current.text, "utf8"))) await fs3.writeFile(current.file, original);
+      } else {
+        const text = format.serialize(value, current.text);
+        if (text !== current.text) await fs3.writeFile(current.file, text);
+      }
+    }
+    if (recording) {
+      delete recordings[key];
+      await this.save(recordings);
+    }
+    await fs3.rm(current.file + LEGACY_BACKUP, { force: true });
+  }
+};
+async function readBytes(file) {
+  try {
+    return await fs3.readFile(file);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+async function missingDirs(dir) {
+  const missing = [];
+  for (let at = dir; ; at = path3.dirname(at)) {
+    try {
+      await fs3.stat(at);
+      return missing;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    missing.push(at);
+    if (path3.dirname(at) === at) return missing;
+  }
+}
+
+// src/install/cursor.ts
+var CURSOR_HOOK_EVENTS = ["beforeSubmitPrompt", "postToolUse", "stop"];
+var HOOK_SUFFIX = " hook deliver --harness cursor";
+function cursorPaths({ platform, path: path7, home, env }, packageName = "khala-cli") {
+  const cursorDir = path7.join(home, ".cursor");
+  const windows = platform === "win32";
+  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: 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) {
+  return nodeScriptCommand(platform, node, script) + HOOK_SUFFIX;
+}
+function cursorMcpEntry(node, script) {
+  return {
+    type: "stdio",
+    command: node,
+    args: [script, "mcp", "--harness", "cursor"],
+    env: { [CURSOR_WORKSPACE_ENV]: "${workspaceFolder}" }
+  };
+}
+var isObject2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function isKhalaCursorServer(entry) {
+  if (!isObject2(entry) || !Array.isArray(entry.args)) return false;
+  const args = entry.args;
+  const at = args.indexOf("--harness");
+  return args.includes("mcp") && at !== -1 && args[at + 1] === "cursor";
+}
+function mergeCursorMcp(config, entry) {
+  if (!isObject2(config)) return { error: "invalid_config" };
+  const servers = config.mcpServers ?? {};
+  if (!isObject2(servers)) return { error: "invalid_config" };
+  if (Object.hasOwn(servers, "khala") && !isKhalaCursorServer(servers.khala)) return { error: "cursor_mcp_exists" };
+  const next = { ...servers };
+  delete next.khala;
+  if (entry) next.khala = entry;
+  return { config: { ...config, mcpServers: next } };
+}
+function mergeCursorHooks(config, command) {
+  if (!isObject2(config)) return { error: "invalid_config" };
+  const hooks = config.hooks ?? {};
+  if (!isObject2(hooks) || Object.values(hooks).some((list) => !Array.isArray(list) || list.some((item) => !isObject2(item)))) return { error: "invalid_config" };
+  const ours = (item) => typeof item.command === "string" && item.command.endsWith(HOOK_SUFFIX);
+  const next = {};
+  for (const [event, list] of Object.entries(hooks)) {
+    const kept = list.filter((item) => !ours(item));
+    if (kept.length) next[event] = kept;
+  }
+  if (command) {
+    for (const event of CURSOR_HOOK_EVENTS) next[event] = [...next[event] ?? [], { command, timeout: 10 }];
+  }
+  return { config: { version: 1, ...config, hooks: next } };
+}
+async function readJsonFile(file) {
+  const current = await readManaged(file);
+  try {
+    return { ...current, value: jsonFormat.parse(current.text ?? "") };
+  } catch {
+    return { ...current, value: void 0 };
+  }
+}
+async function installCursor(input) {
+  const { paths, uninstall, stdout, stderr } = input;
+  const mcp = await readJsonFile(paths.mcpFile);
+  const hooks = await readJsonFile(paths.hooksFile);
+  const command = cursorHookCommand(input.platform, input.node, paths.script);
+  const nextMcp = mergeCursorMcp(mcp.value, uninstall ? null : cursorMcpEntry(input.node, paths.script));
+  if ("error" in nextMcp) {
+    stderr(nextMcp.error === "cursor_mcp_exists" ? `khala: ${paths.mcpFile} already has a "khala" server that is not this CLI; remove it and run this again` : `khala: invalid JSON in ${paths.mcpFile}`);
+    return 1;
+  }
+  const nextHooks = mergeCursorHooks(hooks.value, uninstall ? null : command);
+  if ("error" in nextHooks) {
+    stderr(`khala: invalid JSON in ${paths.hooksFile}`);
+    return 1;
+  }
+  if (!uninstall && input.install && !input.install()) return 1;
+  const managed = new ManagedFiles(input.stateDir);
+  if (uninstall) {
+    await managed.restore(mcp, jsonFormat, (value) => mergeCursorMcp(value, null).config);
+    await managed.restore(hooks, jsonFormat, (value, original) => {
+      const { config } = mergeCursorHooks(value, null);
+      const hadVersion = isObject2(original) && Object.hasOwn(original, "version");
+      if (!hadVersion && isObject2(config.hooks) && !Object.keys(config.hooks).length) delete config.version;
+      return config;
+    });
+  } else {
+    await managed.write([
+      { current: mcp, text: formatJson(nextMcp.config, mcp.text) },
+      { current: hooks, text: formatJson(nextHooks.config, hooks.text) }
+    ]);
+  }
+  if (uninstall) {
+    stdout(`removed the Khala MCP server and hooks from ${paths.cursorDir}; delete ${paths.prefix} to remove the CLI`);
+  } else {
+    stdout(`configured ${paths.mcpFile} and ${paths.hooksFile}`);
+    stdout('restart Cursor (or toggle "khala" off and on in Settings > MCP), then check that khala shows its five tools');
+  }
+  return 0;
+}
+
+// src/wake/muse-monitor.ts
+var MUSE_WAKE_REQUEST = "muse-monitor-wake.json";
+var shellQuote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+function museCliPath(env = process.env) {
+  const home = env.HOME || env.USERPROFILE || os2.homedir();
+  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(), 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, 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 {
+    id: "monitor",
+    rung: 1,
+    optIn: false,
+    minIdleMs: 0,
+    deadlineMs: 3e4,
+    verification: "nonce",
+    startsActivity: true,
+    available: (ctx) => monitorArmed(ctx.files),
+    unavailableReason: () => "monitor_missing",
+    async verify(ctx) {
+      const proof = await museWakeProof(ctx.files, ctx.sessionId, ctx.env);
+      if (proof) await settleAttempts(ctx.files.dir, {
+        now: ctx.now,
+        activity: null,
+        promptText: proof.text,
+        verifiedAt: proof.at
+      });
+    },
+    async wake(ctx, line) {
+      const nonce = /\(k-([a-f0-9]{8})\)$/.exec(line)?.[1];
+      if (!nonce || wakeLine(nonce) !== line) throw new TypeError("invalid_monitor_wake_line");
+      if (ctx.signal.aborted || (await readActivity(ctx.files)).state !== "idle" || !await monitorArmed(ctx.files)) return "skipped";
+      const epoch = (await readActivity(ctx.files)).updatedAt;
+      for (const dir of monitorStorageCandidates(ctx.files)) {
+        if ((await readJson(path4.join(dir, "monitor-wake-observed.json")))?.epoch === epoch) return "skipped";
+      }
+      const owner = await monitorOwner(ctx.files);
+      if (!owner) return "skipped";
+      const journal = museJournalPath(ctx.sessionId, ctx.env);
+      let journalOffset = 0;
+      if (journal) {
+        try {
+          journalOffset = (await fs4.stat(journal)).size;
+        } catch (error) {
+          if (error.code !== "ENOENT") throw error;
+        }
+      }
+      await writeJsonAtomic(path4.join(ctx.files.dir, MUSE_WAKE_REQUEST), {
+        owner: owner.nonce,
+        line,
+        at: ctx.now,
+        deadline: ctx.now + 3e4,
+        journalOffset
+      });
+    }
+  };
+}
+function museJournalPath(sessionId, env) {
+  if (!/^[a-f0-9]{8}-[a-f0-9]{4}-7[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u.test(sessionId)) return void 0;
+  const created = new Date(Number.parseInt(sessionId.replaceAll("-", "").slice(0, 12), 16));
+  const date = [String(created.getFullYear()), String(created.getMonth() + 1).padStart(2, "0"), String(created.getDate()).padStart(2, "0")];
+  const home = env.HOME || env.USERPROFILE || os2.homedir();
+  const data = env.XDG_DATA_HOME && path4.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path4.join(home, ".local", "share");
+  return path4.join(data, "muse", "sessions", ...date, sessionId, "session.jsonl");
+}
+async function museStopWakeText(stdin, files, env) {
+  const input = JSON.parse(stdin);
+  if (input.hook_event_name !== "Stop" || typeof input.turn_id !== "string") return void 0;
+  return museWakeProof(files, input.session_id, env, input.turn_id);
+}
+async function museWakeProof(files, sessionId, env, turnId) {
+  const request = await readJson(path4.join(files.dir, MUSE_WAKE_REQUEST));
+  if (!request) return void 0;
+  const journal = museJournalPath(sessionId, env);
+  if (!journal) return void 0;
+  if (!Number.isSafeInteger(request.journalOffset) || request.journalOffset < 0) return void 0;
+  let handle;
+  try {
+    handle = await fs4.open(journal, "r");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw error;
+  }
+  const stream = handle.createReadStream({ start: request.journalOffset, encoding: "utf8", autoClose: false });
+  const reader = createInterface({ input: stream, crlfDelay: Infinity });
+  try {
+    for await (const line of reader) {
+      let record;
+      try {
+        record = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const event = record.payload?.event;
+      if (record.stream?.id === sessionId && record.payload_type === "runtime.session" && typeof record.payload?.run_id === "string" && (turnId === void 0 || record.payload.run_id === turnId) && event?.kind === "inbox_item_drained" && event.drain_target_run_stream?.id === record.payload.run_id && event.delivery_snapshot?.source?.source === "monitor_event" && event.delivery_snapshot.source.event_kind === "stdout_line" && event.delivery_snapshot.body === request.line && record.recorded_at / 1e3 >= request.at && record.recorded_at / 1e3 <= request.deadline) return { text: request.line, at: record.recorded_at / 1e3 };
+    }
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  } finally {
+    reader.close();
+    stream.destroy();
+    await handle.close();
+  }
+  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) => path6.join(dir, `monitor-${nonce}.json`);
+async function monitorOwner(files) {
+  const owners = [];
+  for (const dir of monitorStorageCandidates(files)) {
+    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;
+    if (lease.heartbeatAt !== void 0) {
+      const age = Date.now() - Date.parse(lease.heartbeatAt);
+      if (Number.isFinite(age) && age >= 0 && age < 6e4) owners.push(owner);
+      continue;
+    }
+    try {
+      process.kill(owner.pid, 0);
+      owners.push(owner);
+    } catch (error) {
+      if (error.code === "EPERM") owners.push(owner);
+    }
+  }
+  return owners.sort((a, b) => (b.startedAt ?? 0) - (a.startedAt ?? 0))[0];
+}
+async function monitorArmed(files) {
+  return !!await monitorOwner(files);
+}
+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 = 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;
+  let dirty = false;
+  let done = false;
+  let emittedRequest;
+  let code = 0;
+  let finish;
+  const finished = new Promise((resolve) => {
+    finish = resolve;
+  });
+  const stop = (exit = 0, reason = "stopped") => {
+    if (done) return;
+    done = true;
+    code = exit;
+    watcher?.close();
+    clearInterval(timer);
+    if (!qwen || exit !== 0) io.stderr?.(`khala watch: stopped (${reason}). Do not re-arm.`);
+    finish();
+  };
+  let lastHeartbeat = 0;
+  let exitReason = "disconnected";
+  const errorReason = (error) => {
+    const code2 = error.code;
+    if (code2 === "EROFS") return "monitor_storage_read_only";
+    if (code2 === "EACCES" || code2 === "EPERM") return "state_access_denied";
+    return error instanceof Error && error.message === "unsafe_monitor_directory" ? "unsafe_monitor_directory" : "state_unreadable";
+  };
+  const abort = () => stop();
+  try {
+    const status = await readWatcherStatus(files);
+    const initialSession = await readJson(files.session);
+    if (!["connected", "send_failed"].includes(status?.state ?? "") || !initialSession && !(await listChannels(files)).length) {
+      stop(2, status?.detail ?? status?.state ?? "session_missing");
+      return 2;
+    }
+    storage = await monitorStorage(files);
+    const storageDirs = /* @__PURE__ */ new Map([[files.dir, storage]]);
+    const observationDir = async (target2) => {
+      let dir = storageDirs.get(target2.dir);
+      if (!dir) {
+        dir = await monitorStorage(target2);
+        storageDirs.set(target2.dir, dir);
+      }
+      return dir;
+    };
+    const initialDelivered = /* @__PURE__ */ new Map();
+    const seedBaseline = async (target2, session) => {
+      initialDelivered.set(target2.dir, {
+        identity: JSON.stringify([session.roomId, session.userId]),
+        cursor: await readCursor(target2)
+      });
+    };
+    if (initialSession) await seedBaseline(files, initialSession);
+    for (const channel of await listChannels(files)) {
+      const session = await readJson(channel.files.session);
+      if (session) await seedBaseline(channel.files, session);
+    }
+    const evaluate = async () => {
+      const ownsSession = async () => {
+        const owner = await monitorOwner(files);
+        const status2 = await readWatcherStatus(files);
+        exitReason = owner?.nonce !== nonce ? "superseded" : status2?.detail ?? status2?.state ?? "status_missing";
+        return owner?.nonce === nonce && ["connected", "send_failed"].includes(status2?.state ?? "");
+      };
+      if (!await ownsSession()) {
+        stop(2, exitReason);
+        return;
+      }
+      if (Date.now() - lastHeartbeat >= 15e3) {
+        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 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(target2.dir)?.identity !== identity) {
+          await seedBaseline(target2, session);
+        }
+        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(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(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) => 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(target2.session)) === JSON.stringify(latestSession)) {
+          try {
+            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(target2.session)) throw error;
+          }
+        }
+      }
+      if (io.harness === "muse" && !done && await ownsSession()) {
+        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) {
+            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.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 = path6.join(storage, "monitor-wake-observed.json");
+            const observed = await readJson(dedupFile);
+            if (observed?.epoch === epoch) return;
+            await writeJsonAtomic(dedupFile, { epoch, line: request.line });
+            io.write(request.line + "\n");
+            emittedRequest = request.line;
+          }
+        }
+      }
+    };
+    const notify = () => {
+      if (done) return;
+      dirty = true;
+      if (running) return;
+      running = (async () => {
+        do {
+          dirty = false;
+          await evaluate();
+        } while (dirty && !done);
+      })().catch((error) => stop(3, errorReason(error))).finally(() => {
+        running = void 0;
+        if (dirty && !done) notify();
+      });
+    };
+    let published = false;
+    watcher = watchDirectory(files.dir, (_event, filename) => {
+      if (published && (filename === null || [MARKER, MUSE_WAKE_REQUEST, "inbox.jsonl", "cursor.json", "mode.json", "session.json", "status.json"].includes(String(filename)))) notify();
+    });
+    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(path6.join(storage, MARKER), { nonce, pid: process.pid, startedAt: Date.now() });
+    published = true;
+    timer = setInterval(notify, 100);
+    io.signal.addEventListener("abort", abort, { once: true });
+    if (io.signal.aborted) stop();
+    else notify();
+    await finished;
+    await running;
+    return code;
+  } catch (error) {
+    stop(3, errorReason(error));
+    return 3;
+  } finally {
+    clearInterval(timer);
+    watcher?.close();
+    io.signal.removeEventListener("abort", abort);
+    await fs7.unlink(leaseFile(storage, nonce)).catch((error) => {
+      if (!["ENOENT", "EACCES", "EROFS"].includes(error.code ?? "")) throw error;
+    });
+  }
+}
+var WATCH_USAGE = "usage: khala watch [--harness <id>] [--session <id>]";
+async function run(argv) {
+  if (argv.length === 1 && ["--help", "-h"].includes(argv[0])) {
+    console.log(WATCH_USAGE);
+    return 0;
+  }
+  const invalid = (reason) => {
+    console.error(`khala: ${reason}
+${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-TSK3HJEG.mjs");
+  const { adapterFor } = await import("./chunk-WZJ6DQJV.mjs");
+  const harness = resolveHarness(argv, process.env);
+  if (harness === "invalid" || !adapterFor(harness)?.codec) return invalid("invalid_harness");
+  const index = argv.indexOf("--session");
+  const id = index === -1 ? await resolveSessionId(harness, void 0, process.env) : argv[index + 1];
+  if (!id) return invalid("session_unknown");
+  if (!SESSION_ID_PATTERN.test(id)) return invalid("invalid_session_id");
+  const files = sessionFiles(harness, id, process.env);
+  const controller = new AbortController();
+  const stop = () => controller.abort();
+  process.once("SIGTERM", stop);
+  process.once("SIGINT", stop);
+  try {
+    return await watchSession(files, { write: (line) => {
+      process.stdout.write(line);
+    }, signal: controller.signal, harness, env: process.env, stderr: (line) => {
+      process.stderr.write(line + "\n");
+    } });
+  } finally {
+    process.removeListener("SIGTERM", stop);
+    process.removeListener("SIGINT", stop);
+  }
+}
+
+export {
+  readWakeSettings,
+  updateWakeSettings,
+  driverAllowed,
+  readListeningMode,
+  applyListeningMode,
+  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,
+  watchSession,
+  WATCH_USAGE,
+  run,
+  museCliPath,
+  museWatchCommand,
+  museMonitorInstruction,
+  createMuseMonitorDriver,
+  museStopWakeText
+};