khala-cli 0.4.18 → 0.4.19

package/dist/{chunk-JXV5S7FC.mjs → chunk-WOHXD3RS.mjs}

@@ -1,31 +1,27 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   DEFAULT_LISTENING_MODE,
-  decodeListeningMode
-} from "./chunk-EBKZETYL.mjs";
-import {
-  advanceCursor,
-  isWakeEntry,
-  listChannels,
-  markNudged,
-  mentions,
-  readActivity,
-  readCursor,
-  readEntries,
-  unread,
-  wakeStart,
-  wakesAgent
-} from "./chunk-LNDZI73C.mjs";
+  decodeChannelEvent,
+  decodeListeningMode,
+  formatChannelEventLine,
+  wakesOn
+} from "./chunk-ME3G775Q.mjs";
 import {
   SESSION_ID_PATTERN,
   StateError,
+  channelFiles,
+  channelsDir,
   ensureStateDir,
+  filesForDir,
   readJson,
   readWatcherStatus,
+  removeStateFile,
   sessionFiles,
+  stateKey,
   stateRoot,
-  writeJsonAtomic
-} from "./chunk-4IOLQB34.mjs";
+  writeJsonAtomic,
+  writeStateFile
+} from "./chunk-YN334EWZ.mjs";
 import {
   cancelAttempt,
   confirmWakeText,
@@ -34,16 +30,16 @@ import {
   settleAttempts,
   wakeLine,
   withWakeLock
-} from "./chunk-LOGBYBPA.mjs";
+} from "./chunk-OFLK3DF2.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-QYVSNP2P.mjs";
+} from "./chunk-NDII2VEP.mjs";
 
 // src/watch.ts
 init_define_KHALA_BUNDLE();
-import * as fs7 from "node:fs/promises";
+import * as fs10 from "node:fs/promises";
 import { watch as watchDirectory } from "node:fs";
-import path7 from "node:path";
+import path9 from "node:path";
 import { randomUUID as randomUUID3 } from "node:crypto";
 
 // src/monitor-storage.ts
@@ -76,6 +72,137 @@ async function monitorStorage(files) {
   return dir;
 }
 
+// src/inbox.ts
+init_define_KHALA_BUNDLE();
+import * as fs2 from "node:fs/promises";
+
+// src/events/receive.ts
+init_define_KHALA_BUNDLE();
+function toEventInboxEntry(base, rawContent, you) {
+  const decoded = decodeChannelEvent(rawContent);
+  if (!decoded.ok) return null;
+  const content = decoded.value;
+  const to = content.kind === "handoff" ? String(content.data?.to ?? "").replace(/^@/u, "").toLowerCase() : "";
+  return {
+    entry: {
+      ...base,
+      kind: "event",
+      body: formatChannelEventLine(content) + (content.url ? " " + content.url : ""),
+      eventKind: content.kind,
+      ...content.data ? { data: content.data } : {},
+      ...to && to === you?.toLowerCase() ? { mention: true } : {}
+    },
+    ...content.key !== void 0 ? { key: content.key } : {}
+  };
+}
+function createEventKeyFilter() {
+  const seen = /* @__PURE__ */ new Set();
+  return (key) => {
+    if (key === void 0) return true;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  };
+}
+function isWakeEntry(entry) {
+  return entry.kind === "message" || entry.mention === true;
+}
+var agentGroupMention = /(?<![\p{L}\p{N}_@])@(?:channel|agents)(?![\p{L}\p{N}_])/iu;
+function mentions(entry, name) {
+  if (entry.kind === "message" && entry.senderKind !== "agent" && agentGroupMention.test(entry.body)) return true;
+  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 wakesAgent(entry, mode, you) {
+  if (!isWakeEntry(entry)) return false;
+  return wakesOn(mode ?? "steer", entry.mention === true || mentions(entry, you), entry.senderKind === "agent");
+}
+
+// src/inbox.ts
+async function readEntries(files) {
+  let content;
+  try {
+    content = await fs2.readFile(files.inbox, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw new StateError("storage_failed");
+  }
+  const entries = [];
+  for (const line of content.split("\n").slice(0, -1)) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry && ["eventId", "roomId", "ts", "sender", "senderLabel", "body"].every((key) => typeof entry[key] === "string") && ["human", "agent", "unknown"].includes(entry.senderKind) && ["message", "event"].includes(entry.kind)) entries.push(entry);
+    } catch {
+    }
+  }
+  return entries;
+}
+async function appendEntries(files, entries) {
+  const seen = new Set((await readEntries(files)).map((entry) => entry.eventId));
+  const fresh = entries.filter((entry) => {
+    if (seen.has(entry.eventId)) return false;
+    seen.add(entry.eventId);
+    return true;
+  });
+  if (fresh.length) {
+    try {
+      await fs2.appendFile(files.inbox, fresh.map((entry) => JSON.stringify(entry) + "\n").join(""), { mode: 384, flag: "a" });
+    } catch {
+      throw new StateError("storage_failed");
+    }
+  }
+  return fresh;
+}
+async function readCursor(files) {
+  const cursor = await readJson(files.cursor);
+  return cursor && (cursor.lastDeliveredEventId === null || typeof cursor.lastDeliveredEventId === "string") && Number.isSafeInteger(cursor.deliveredCount) && cursor.deliveredCount >= 0 ? cursor : { lastDeliveredEventId: null, deliveredCount: 0 };
+}
+async function unread(files) {
+  const cursor = await readCursor(files);
+  const entries = await readEntries(files);
+  return { entries: entries.slice(cursor.deliveredCount), cursor };
+}
+function wakeStart(cursor) {
+  return Math.max(cursor.deliveredCount, Number.isSafeInteger(cursor.nudgedCount) ? cursor.nudgedCount : 0);
+}
+async function unwoken(files) {
+  return (await readEntries(files)).slice(wakeStart(await readCursor(files)));
+}
+async function markNudged(files, expected, count) {
+  const current = await readCursor(files);
+  if (current.deliveredCount !== expected.deliveredCount || current.lastDeliveredEventId !== expected.lastDeliveredEventId) return;
+  await writeJsonAtomic(files.cursor, { ...current, nudgedCount: count });
+}
+async function unreadCounts(files) {
+  const { entries } = await unread(files);
+  return { total: entries.length, messages: entries.filter((entry) => isWakeEntry(entry)).length };
+}
+async function advanceCursor(files, expected, delivered, shown = false) {
+  const current = await readCursor(files);
+  if (current.deliveredCount !== expected.deliveredCount || current.lastDeliveredEventId !== expected.lastDeliveredEventId) return "conflict";
+  if (!delivered.length) return expected;
+  const entries = await readEntries(files);
+  const slice = entries.slice(expected.deliveredCount, expected.deliveredCount + delivered.length);
+  if (slice.length !== delivered.length || slice.some((entry, index) => entry.eventId !== delivered[index]?.eventId)) return "conflict";
+  const last = delivered[delivered.length - 1].eventId;
+  const shownEventId = shown ? last : current.shownEventId;
+  const next = {
+    lastDeliveredEventId: last,
+    deliveredCount: expected.deliveredCount + delivered.length,
+    ...shownEventId ? { shownEventId } : {},
+    ...wakeStart(current) > expected.deliveredCount + delivered.length ? { nudgedCount: current.nudgedCount } : {}
+  };
+  await writeJsonAtomic(files.cursor, next);
+  return next;
+}
+async function appendInbox(dir, entry) {
+  return (await appendEntries(filesForDir(dir), [entry])).length === 1;
+}
+function unreadCount(dir) {
+  return unreadCounts(filesForDir(dir));
+}
+
 // src/mode.ts
 init_define_KHALA_BUNDLE();
 import path2 from "node:path";
@@ -127,17 +254,164 @@ async function applyListeningMode(files, next, meta, now = () => /* @__PURE__ */
   return { previous, next };
 }
 
+// src/channels.ts
+init_define_KHALA_BUNDLE();
+import * as fs3 from "node:fs/promises";
+import path3 from "node:path";
+function channelKey(roomId2) {
+  return stateKey(roomId2);
+}
+async function exists(file) {
+  try {
+    await fs3.lstat(file);
+    return true;
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw new StateError("storage_failed");
+  }
+}
+function roomId(value) {
+  if (value && typeof value === "object" && "roomId" in value && typeof value.roomId === "string" && value.roomId.length) return value.roomId;
+  return void 0;
+}
+async function legacyRoomId(files) {
+  const saved = roomId(await readJson(files.session));
+  if (saved) return saved;
+  let content;
+  try {
+    content = await fs3.readFile(files.inbox, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return void 0;
+    throw new StateError("storage_failed");
+  }
+  try {
+    return roomId(JSON.parse(content.split("\n")[0]));
+  } catch {
+    return void 0;
+  }
+}
+async function listChannels(files) {
+  await ensureStateDir(files.dir);
+  const channels = [];
+  const dir = channelsDir(files);
+  if (await exists(dir)) {
+    await ensureStateDir(dir);
+    for (const key of await fs3.readdir(dir)) {
+      if (!/^[a-f0-9]{24}$/.test(key)) continue;
+      const nested = filesForDir(path3.join(dir, key));
+      await ensureStateDir(nested.dir);
+      const metadata = await readJson(path3.join(nested.dir, "channel.json"));
+      const id = roomId(metadata);
+      if (!id || channelKey(id) !== key) continue;
+      channels.push({ key, roomId: id, ...typeof metadata?.channelName === "string" ? { channelName: metadata.channelName } : {}, files: nested, legacy: false });
+    }
+  }
+  if (await exists(files.inbox)) {
+    const id = await legacyRoomId(files);
+    if (id) {
+      const status = await readJson(files.status);
+      channels.push({ key: channelKey(id), roomId: id, ...typeof status?.channelName === "string" ? { channelName: status.channelName } : {}, files, legacy: true });
+    }
+  }
+  return channels.sort((a, b) => (a.channelName ?? "").localeCompare(b.channelName ?? "") || a.roomId.localeCompare(b.roomId));
+}
+async function migrateLegacy(files) {
+  await ensureStateDir(files.dir);
+  const names = ["cursor.json", "mode.json", "inbox.jsonl"];
+  const present = await Promise.all(names.map((name) => exists(path3.join(files.dir, name))));
+  if (!present.some(Boolean)) return "none";
+  const id = await legacyRoomId(files);
+  if (!id) {
+    for (const name of names) await removeStateFile(files.dir, name);
+    return "discarded";
+  }
+  const nested = channelFiles(files, id);
+  await ensureStateDir(nested.dir);
+  const destinationInbox = await exists(nested.inbox);
+  if (!destinationInbox && present[0] && await exists(nested.cursor)) {
+    const [legacyCursor, channelCursor] = await Promise.all([readCursor(files), readCursor(nested)]);
+    if (legacyCursor.deliveredCount !== channelCursor.deliveredCount || legacyCursor.lastDeliveredEventId !== channelCursor.lastDeliveredEventId) {
+      const safe = legacyCursor.deliveredCount < channelCursor.deliveredCount ? legacyCursor : channelCursor;
+      await writeStateFile(nested.dir, "cursor.json", safe);
+      console.warn(`Khala cursor migration: conflicting cursors for ${id}; using earlier position ${safe.deliveredCount} to avoid skipping messages (legacy=${legacyCursor.deliveredCount}, channel=${channelCursor.deliveredCount}).`);
+    }
+  }
+  const status = await readJson(files.status);
+  const metadata = await readJson(path3.join(nested.dir, "channel.json"));
+  if (!metadata || roomId(metadata) !== id) {
+    await writeStateFile(nested.dir, "channel.json", {
+      roomId: id,
+      ...typeof status?.channelName === "string" ? { channelName: status.channelName } : {},
+      joinedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  if (destinationInbox) {
+    if (present[2]) await appendEntries(nested, (await unread(files)).entries);
+    for (const name of ["inbox.jsonl", "cursor.json", "mode.json"]) await removeStateFile(files.dir, name);
+    return "moved";
+  }
+  for (const name of names) {
+    if (await exists(path3.join(nested.dir, name))) {
+      await removeStateFile(files.dir, name);
+      continue;
+    }
+    try {
+      await fs3.rename(path3.join(files.dir, name), path3.join(nested.dir, name));
+    } catch (error) {
+      if (error.code !== "ENOENT") throw new StateError("storage_failed");
+    }
+  }
+  return "moved";
+}
+function resolveChannel(list, ref) {
+  const channels = list.map((item) => ({ channel: item.channelName ?? item.roomId, roomId: item.roomId }));
+  if (ref === void 0) {
+    if (list.length === 1) return { ok: true, channel: list[0] };
+    return { ok: false, code: list.length ? "channel_required" : "channel_unknown", channels };
+  }
+  const exact = list.find((item) => item.roomId === ref);
+  if (exact) return { ok: true, channel: exact };
+  const normalized = ref.replace(/^#/, "").toLowerCase();
+  const matches = list.filter((item) => item.channelName?.replace(/^#/, "").toLowerCase() === normalized);
+  if (matches.length === 1) return { ok: true, channel: matches[0] };
+  return { ok: false, code: matches.length ? "channel_ambiguous" : "channel_unknown", channels };
+}
+
+// src/activity.ts
+init_define_KHALA_BUNDLE();
+import * as fs4 from "node:fs/promises";
+import path4 from "node:path";
+async function readActivity(files) {
+  const activity = await readJson(path4.join(files.dir, "activity.json"));
+  return activity && ["idle", "busy"].includes(activity.state) && typeof activity.updatedAt === "string" && Number.isFinite(Date.parse(activity.updatedAt)) ? activity : { state: "busy", updatedAt: (/* @__PURE__ */ new Date(0)).toISOString() };
+}
+var USAGE_LIMIT = "usage-limit.json";
+async function markUsageLimit(files, now = () => /* @__PURE__ */ new Date()) {
+  await writeJsonAtomic(path4.join(files.dir, USAGE_LIMIT), { at: now().toISOString() });
+}
+async function clearUsageLimit(files) {
+  await fs4.rm(path4.join(files.dir, USAGE_LIMIT), { force: true });
+}
+async function usageLimited(dir) {
+  return await readJson(path4.join(dir, USAGE_LIMIT)) !== null;
+}
+async function writeActivity(files, state, now = () => /* @__PURE__ */ new Date()) {
+  const activity = { state, updatedAt: now().toISOString() };
+  await writeJsonAtomic(path4.join(files.dir, "activity.json"), activity);
+  return activity;
+}
+
 // 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 path3 from "node:path";
+import * as fs5 from "node:fs/promises";
+import path5 from "node:path";
 import { randomBytes } from "node:crypto";
 async function readWakeSettings(root) {
   try {
-    const value = JSON.parse(await fs2.readFile(path3.join(root, "wake-settings.json"), "utf8"));
+    const value = JSON.parse(await fs5.readFile(path5.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"));
@@ -149,14 +423,14 @@ async function readWakeSettings(root) {
   }
 }
 async function writeWakeSettings(root, settings) {
-  await fs2.mkdir(root, { recursive: true, mode: 448 });
-  const target2 = path3.join(root, "wake-settings.json");
+  await fs5.mkdir(root, { recursive: true, mode: 448 });
+  const target2 = path5.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);
+    await fs5.writeFile(temp, JSON.stringify(settings), { mode: 384 });
+    await fs5.rename(temp, target2);
   } finally {
-    await fs2.rm(temp, { force: true });
+    await fs5.rm(temp, { force: true });
   }
 }
 async function updateWakeSettings(root, update) {
@@ -175,9 +449,9 @@ async function driverAllowed(root, harness, driver, optIn) {
 // src/wake/muse-monitor.ts
 init_define_KHALA_BUNDLE();
 import { createInterface } from "node:readline";
-import * as fs4 from "node:fs/promises";
+import * as fs7 from "node:fs/promises";
 import os2 from "node:os";
-import path5 from "node:path";
+import path7 from "node:path";
 
 // src/install/cursor.ts
 init_define_KHALA_BUNDLE();
@@ -220,12 +494,12 @@ function nodeScriptCommand(platform, node, script) {
 
 // src/install/launcher.ts
 init_define_KHALA_BUNDLE();
-function installedLauncher(platform, path8, home, env) {
+function installedLauncher(platform, path10, home, env) {
   const windows = platform === "win32";
   const candidate = windows ? env.LOCALAPPDATA : env.XDG_DATA_HOME;
-  const dataHome = candidate && path8.isAbsolute(candidate) ? candidate : windows ? path8.join(home, "AppData", "Local") : path8.join(home, ".local", "share");
-  const prefix = path8.join(dataHome, "khala", "npm");
-  return { prefix, bin: windows ? path8.join(prefix, "khala.cmd") : path8.join(prefix, "bin", "khala") };
+  const dataHome = candidate && path10.isAbsolute(candidate) ? candidate : windows ? path10.join(home, "AppData", "Local") : path10.join(home, ".local", "share");
+  const prefix = path10.join(dataHome, "khala", "npm");
+  return { prefix, bin: windows ? path10.join(prefix, "khala.cmd") : path10.join(prefix, "bin", "khala") };
 }
 function launcherShellQuote(platform, bin) {
   return platform === "win32" ? `"${bin}"` : `'${bin.replaceAll("'", `'\\''`)}'`;
@@ -233,8 +507,8 @@ function launcherShellQuote(platform, bin) {
 
 // src/install/managed-file.ts
 init_define_KHALA_BUNDLE();
-import * as fs3 from "node:fs/promises";
-import path4 from "node:path";
+import * as fs6 from "node:fs/promises";
+import path6 from "node:path";
 import { isDeepStrictEqual } from "node:util";
 var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var BOM = "\uFEFF";
@@ -273,7 +547,7 @@ var textFormat = {
 };
 async function readManaged(file) {
   try {
-    return { file, text: await fs3.readFile(file, "utf8") };
+    return { file, text: await fs6.readFile(file, "utf8") };
   } catch (error) {
     if (error.code === "ENOENT") return { file, text: null };
     throw error;
@@ -283,11 +557,11 @@ var LEGACY_BACKUP = ".khala-bak";
 var ManagedFiles = class {
   store;
   constructor(stateDir) {
-    this.store = path4.join(stateDir, "install-originals.json");
+    this.store = path6.join(stateDir, "install-originals.json");
   }
   async load() {
     try {
-      const value = JSON.parse(await fs3.readFile(this.store, "utf8"));
+      const value = JSON.parse(await fs6.readFile(this.store, "utf8"));
       return isObject(value) ? value : {};
     } catch (error) {
       if (error.code === "ENOENT") return {};
@@ -296,17 +570,17 @@ var ManagedFiles = class {
   }
   async save(recordings) {
     if (!Object.keys(recordings).length) {
-      await fs3.rm(this.store, { force: true });
+      await fs6.rm(this.store, { force: true });
       return;
     }
-    await fs3.mkdir(path4.dirname(this.store), { recursive: true, mode: 448 });
+    await fs6.mkdir(path6.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);
+    await fs6.writeFile(temp, JSON.stringify(recordings, null, 2) + "\n", { mode: 384 });
+    await fs6.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())[path4.resolve(file)];
+    const recording = (await this.load())[path6.resolve(file)];
     if (recording) return recording.existed ? Buffer.from(recording.bytes ?? "", "base64") : null;
     const legacy = await readBytes(file + LEGACY_BACKUP);
     return legacy ?? void 0;
@@ -318,14 +592,14 @@ var ManagedFiles = class {
    * the override still never replaces a previously saved recording.
    */
   async record(file, options) {
-    const key = path4.resolve(file);
+    const key = path6.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(path4.dirname(key)) } : { existed: true, bytes: current.toString("base64"), createdDirs: [] };
+    recordings[key] = current === null ? { existed: false, createdDirs: await missingDirs(path6.dirname(key)) } : { existed: true, bytes: current.toString("base64"), createdDirs: [] };
     await this.save(recordings);
-    if (legacy) await fs3.rm(file + LEGACY_BACKUP, { force: true });
+    if (legacy) await fs6.rm(file + LEGACY_BACKUP, { force: true });
   }
   /**
    * Install: records every file's original first (so each knows which directories Khala
@@ -335,8 +609,8 @@ var ManagedFiles = class {
     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(path4.dirname(current.file), { recursive: true });
-      await fs3.writeFile(current.file, text, mode === void 0 ? void 0 : { mode });
+      await fs6.mkdir(path6.dirname(current.file), { recursive: true });
+      await fs6.writeFile(current.file, text, mode === void 0 ? void 0 : { mode });
     }
   }
   /**
@@ -347,7 +621,7 @@ var ManagedFiles = class {
    * stripped content. The recording is then dropped.
    */
   async restore(current, format, strip) {
-    const key = path4.resolve(current.file);
+    const key = path6.resolve(current.file);
     const recordings = await this.load();
     const recording = recordings[key];
     const original = await this.original(current.file);
@@ -364,25 +638,25 @@ var ManagedFiles = class {
       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);
+        await fs6.rm(current.file, { force: true });
+        for (const dir of recording?.createdDirs ?? []) await fs6.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);
+        if (!original.equals(Buffer.from(current.text, "utf8"))) await fs6.writeFile(current.file, original);
       } else {
         const text = format.serialize(value, current.text);
-        if (text !== current.text) await fs3.writeFile(current.file, text);
+        if (text !== current.text) await fs6.writeFile(current.file, text);
       }
     }
     if (recording) {
       delete recordings[key];
       await this.save(recordings);
     }
-    await fs3.rm(current.file + LEGACY_BACKUP, { force: true });
+    await fs6.rm(current.file + LEGACY_BACKUP, { force: true });
   }
 };
 async function readBytes(file) {
   try {
-    return await fs3.readFile(file);
+    return await fs6.readFile(file);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -390,32 +664,32 @@ async function readBytes(file) {
 }
 async function missingDirs(dir) {
   const missing = [];
-  for (let at = dir; ; at = path4.dirname(at)) {
+  for (let at = dir; ; at = path6.dirname(at)) {
     try {
-      await fs3.stat(at);
+      await fs6.stat(at);
       return missing;
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
     missing.push(at);
-    if (path4.dirname(at) === at) return missing;
+    if (path6.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: path8, home, env }, packageName = "khala-cli") {
-  const cursorDir = path8.join(home, ".cursor");
+function cursorPaths({ platform, path: path10, home, env }, packageName = "khala-cli") {
+  const cursorDir = path10.join(home, ".cursor");
   const windows = platform === "win32";
-  const { prefix } = installedLauncher(platform, path8, home, env);
-  const modules = windows ? path8.join(prefix, "node_modules") : path8.join(prefix, "lib", "node_modules");
+  const { prefix } = installedLauncher(platform, path10, home, env);
+  const modules = windows ? path10.join(prefix, "node_modules") : path10.join(prefix, "lib", "node_modules");
   return {
     cursorDir,
     prefix,
-    mcpFile: path8.join(cursorDir, "mcp.json"),
-    hooksFile: path8.join(cursorDir, "hooks.json"),
-    script: path8.join(modules, ...packageName.split("/"), "dist", "khala.mjs")
+    mcpFile: path10.join(cursorDir, "mcp.json"),
+    hooksFile: path10.join(cursorDir, "hooks.json"),
+    script: path10.join(modules, ...packageName.split("/"), "dist", "khala.mjs")
   };
 }
 function cursorHookCommand(platform, node, script) {
@@ -514,8 +788,8 @@ 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: path5, home, env });
-  return process.platform === "win32" ? path5.join(prefix, "khala.cmd") : path5.join(prefix, "bin", "khala");
+  const { prefix } = cursorPaths({ platform: process.platform, path: path7, home, env });
+  return process.platform === "win32" ? path7.join(prefix, "khala.cmd") : path7.join(prefix, "bin", "khala");
 }
 function museWatchCommand(sessionId, bin = museCliPath(), platform = process.platform) {
   const quote = platform === "win32" ? (value) => `'${value.replaceAll("'", "''")}'` : shellQuote;
@@ -550,7 +824,7 @@ function createMuseMonitorDriver() {
       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(path5.join(dir, "monitor-wake-observed.json")))?.epoch === epoch) return "skipped";
+        if ((await readJson(path7.join(dir, "monitor-wake-observed.json")))?.epoch === epoch) return "skipped";
       }
       const owner = await monitorOwner(ctx.files);
       if (!owner) return "skipped";
@@ -558,12 +832,12 @@ function createMuseMonitorDriver() {
       let journalOffset = 0;
       if (journal) {
         try {
-          journalOffset = (await fs4.stat(journal)).size;
+          journalOffset = (await fs7.stat(journal)).size;
         } catch (error) {
           if (error.code !== "ENOENT") throw error;
         }
       }
-      await writeJsonAtomic(path5.join(ctx.files.dir, MUSE_WAKE_REQUEST), {
+      await writeJsonAtomic(path7.join(ctx.files.dir, MUSE_WAKE_REQUEST), {
         owner: owner.nonce,
         line,
         at: ctx.now,
@@ -578,8 +852,8 @@ function museJournalPath(sessionId, env) {
   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 && path5.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path5.join(home, ".local", "share");
-  return path5.join(data, "muse", "sessions", ...date, sessionId, "session.jsonl");
+  const data = env.XDG_DATA_HOME && path7.isAbsolute(env.XDG_DATA_HOME) ? env.XDG_DATA_HOME : path7.join(home, ".local", "share");
+  return path7.join(data, "muse", "sessions", ...date, sessionId, "session.jsonl");
 }
 async function museStopWakeText(stdin, files, env) {
   const input = JSON.parse(stdin);
@@ -587,14 +861,14 @@ async function museStopWakeText(stdin, files, env) {
   return museWakeProof(files, input.session_id, env, input.turn_id);
 }
 async function museWakeProof(files, sessionId, env, turnId) {
-  const request = await readJson(path5.join(files.dir, MUSE_WAKE_REQUEST));
+  const request = await readJson(path7.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");
+    handle = await fs7.open(journal, "r");
   } catch (error) {
     if (error.code === "ENOENT") return void 0;
     throw error;
@@ -624,17 +898,17 @@ async function museWakeProof(files, sessionId, env, turnId) {
 
 // src/wake/qwen-socket.ts
 init_define_KHALA_BUNDLE();
-import * as fs6 from "node:fs/promises";
+import * as fs9 from "node:fs/promises";
 import net from "node:net";
 import os3 from "node:os";
-import path6 from "node:path";
+import path8 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";
+import * as fs8 from "node:fs/promises";
 async function qwenNotification(filePath) {
-  const file = await fs5.open(filePath, "r");
+  const file = await fs8.open(filePath, "r");
   let text;
   try {
     const stat3 = await file.stat();
@@ -666,23 +940,23 @@ async function verifyQwenTranscript(dir, filePath, now) {
 }
 
 // src/wake/qwen-socket.ts
-var qwenHome = (env) => env.QWEN_HOME ? path6.resolve(env.QWEN_HOME) : path6.join(env.HOME ?? os3.homedir(), ".qwen");
+var qwenHome = (env) => env.QWEN_HOME ? path8.resolve(env.QWEN_HOME) : path8.join(env.HOME ?? os3.homedir(), ".qwen");
 async function qwenInboundAllowed(env, workspace = env.PWD ?? process.cwd()) {
-  for (const file of [path6.join(qwenHome(env), "settings.json"), path6.join(workspace, ".qwen", "settings.json")]) {
+  for (const file of [path8.join(qwenHome(env), "settings.json"), path8.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) => path6.join(stateRoot(env), "qwen", "controller.json");
+var qwenControllerFile = (env) => path8.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 = path6.join(qwenHome(env), "sessions");
-    for (const file of await fs6.readdir(dir)) {
+    const dir = path8.join(qwenHome(env), "sessions");
+    for (const file of await fs9.readdir(dir)) {
       if (!/^\d+\.json$/u.test(file)) continue;
-      const record = await readJson(path6.join(dir, file));
+      const record = await readJson(path8.join(dir, file));
       if (record?.ipcPath === socket && typeof record.sessionId === "string" && SESSION_ID_PATTERN.test(record.sessionId)) return record.sessionId;
     }
   } catch {
@@ -694,7 +968,7 @@ async function target(env) {
   if (!sessionId) return void 0;
   try {
     const file = qwenControllerFile(env);
-    const stat3 = await fs6.lstat(file);
+    const stat3 = await fs9.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;
@@ -719,10 +993,10 @@ function qwenFrames(target2, line, from, replyToken, msgId) {
 }
 async function sendQwenWake(target2, line, signal, options = {}) {
   if (signal.aborted) return "failed";
-  const dir = await fs6.mkdtemp(path6.join(options.runtimeDir ?? os3.tmpdir(), "khala-qw-"));
-  const from = path6.join(dir, "r.sock");
+  const dir = await fs9.mkdtemp(path8.join(options.runtimeDir ?? os3.tmpdir(), "khala-qw-"));
+  const from = path8.join(dir, "r.sock");
   if (Buffer.byteLength(from) > 103) {
-    await fs6.rm(dir, { recursive: true, force: true });
+    await fs9.rm(dir, { recursive: true, force: true });
     return "failed";
   }
   const replyToken = randomBytes2(32).toString("hex");
@@ -778,7 +1052,7 @@ async function sendQwenWake(target2, line, signal, options = {}) {
       server.once("error", reject);
       server.listen(from, resolve);
     });
-    await fs6.chmod(from, 384);
+    await fs9.chmod(from, 384);
     if (signal.aborted) return "failed";
     sender = net.createConnection(target2.socket);
     sender.on("error", () => finish("failed"));
@@ -794,20 +1068,20 @@ async function sendQwenWake(target2, line, signal, options = {}) {
     sender?.destroy();
     for (const socket of peers) socket.destroy();
     await new Promise((resolve) => server.close(() => resolve()));
-    await fs6.rm(dir, { recursive: true, force: true });
+    await fs9.rm(dir, { recursive: true, force: true });
   }
 }
 function createQwenSocketDriver(deps = {}) {
   const resolve = deps.resolve ?? target;
   const policy = async (env) => {
-    const config = await readJson(path6.join(qwenHome(env), "settings.json"));
+    const config = await readJson(path8.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(path6.join(ctx.files.dir, "qwen-receipt.json"));
+    const receipt = await readJson(path8.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";
@@ -821,15 +1095,15 @@ function createQwenSocketDriver(deps = {}) {
     deadlineMs: 3e4,
     verification: "transcript",
     async verify(ctx) {
-      const journal = await readJson(path6.join(ctx.files.dir, "wake-journal.json"));
-      const receipt = await readJson(path6.join(ctx.files.dir, "qwen-receipt.json"));
+      const journal = await readJson(path8.join(ctx.files.dir, "wake-journal.json"));
+      const receipt = await readJson(path8.join(ctx.files.dir, "qwen-receipt.json"));
       if (!journal?.attempts?.some((attempt) => attempt.driver === "socket") && receipt?.status !== "held") return;
-      const transcript = await readJson(path6.join(ctx.files.dir, "qwen-transcript.json"));
+      const transcript = await readJson(path8.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(path6.join(ctx.files.dir, "qwen-receipt.json"), { status: "delivered" });
+          await writeJsonAtomic(path8.join(ctx.files.dir, "qwen-receipt.json"), { status: "delivered" });
         }
       } catch {
       }
@@ -843,7 +1117,7 @@ function createQwenSocketDriver(deps = {}) {
       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(path6.join(ctx.files.dir, "qwen-receipt.json"), { status, nonce });
+      await writeJsonAtomic(path8.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);
     }
@@ -853,12 +1127,13 @@ function createQwenSocketDriver(deps = {}) {
 // src/watch.ts
 var MARKER = "monitor.json";
 var OBSERVATION = "monitor-cursor.json";
+var TICK_MS = 2e3;
 var NONCE_PATTERN = /^[a-f0-9-]{36}$/;
-var leaseFile = (dir, nonce) => path7.join(dir, `monitor-${nonce}.json`);
+var leaseFile = (dir, nonce) => path9.join(dir, `monitor-${nonce}.json`);
 async function monitorOwner(files) {
   const owners = [];
   for (const dir of monitorStorageCandidates(files)) {
-    const owner = await readJson(path7.join(dir, MARKER));
+    const owner = await readJson(path9.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;
@@ -892,7 +1167,7 @@ async function watchSession(files, io) {
     const wake = await readWakeSettings(stateRoot(env));
     return await qwenInboundAllowed(env) && !wake.off["qwen/socket"] && !wake.off["qwen/background-shell"];
   };
-  let watcher;
+  const watchers = [];
   let timer;
   let running;
   let dirty = false;
@@ -907,7 +1182,7 @@ async function watchSession(files, io) {
     if (done) return;
     done = true;
     code = exit;
-    watcher?.close();
+    for (const w of watchers) w.close();
     clearInterval(timer);
     if (!qwen || exit !== 0) io.stderr?.(`khala watch: stopped (${reason}). Do not re-arm.`);
     finish();
@@ -977,7 +1252,7 @@ async function watchSession(files, io) {
         }
         const mode = await readListeningMode(target2);
         const entries = await readEntries(target2);
-        const observed = await readJson(path7.join(await observationDir(target2), OBSERVATION));
+        const observed = await readJson(path9.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;
@@ -1003,7 +1278,7 @@ async function watchSession(files, io) {
         }
         if (position !== entries.length && !done && await ownsSession() && JSON.stringify(await readJson(target2.session)) === JSON.stringify(latestSession)) {
           try {
-            await writeJsonAtomic(path7.join(await observationDir(target2), OBSERVATION), {
+            await writeJsonAtomic(path9.join(await observationDir(target2), OBSERVATION), {
               userId: session.userId,
               roomId: session.roomId,
               count: entries.length,
@@ -1015,7 +1290,7 @@ async function watchSession(files, io) {
         }
       }
       if (io.harness === "muse" && !done && await ownsSession()) {
-        const request = await readJson(path7.join(files.dir, MUSE_WAKE_REQUEST));
+        const request = await readJson(path9.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") {
@@ -1033,7 +1308,7 @@ async function watchSession(files, io) {
           const activity = await readActivity(files);
           if (eligible && await ownsSession() && activity.state === "idle") {
             const epoch = activity.updatedAt;
-            const dedupFile = path7.join(storage, "monitor-wake-observed.json");
+            const dedupFile = path9.join(storage, "monitor-wake-observed.json");
             const observed = await readJson(dedupFile);
             if (observed?.epoch === epoch) return;
             await writeJsonAtomic(dedupFile, { epoch, line: request.line });
@@ -1058,15 +1333,16 @@ async function watchSession(files, io) {
       });
     };
     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)));
+    const onChange = (_event, filename) => {
+      if (published && (filename === null || [MARKER, MUSE_WAKE_REQUEST, "inbox.jsonl", "cursor.json", "mode.json", "session.json", "status.json", "activity.json"].includes(path9.basename(String(filename))))) notify();
+    };
+    watchers.push(watchDirectory(files.dir, onChange), watchDirectory(files.dir, { recursive: true }, onChange));
+    for (const w of watchers) w.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(path7.join(storage, MARKER), { nonce, pid: process.pid, startedAt: Date.now() });
+    await writeJsonAtomic(path9.join(storage, MARKER), { nonce, pid: process.pid, startedAt: Date.now() });
     published = true;
-    timer = setInterval(notify, 100);
+    timer = setInterval(notify, TICK_MS);
     io.signal.addEventListener("abort", abort, { once: true });
     if (io.signal.aborted) stop();
     else notify();
@@ -1078,13 +1354,17 @@ async function watchSession(files, io) {
     return 3;
   } finally {
     clearInterval(timer);
-    watcher?.close();
+    for (const w of watchers) w.close();
     io.signal.removeEventListener("abort", abort);
-    await fs7.unlink(leaseFile(storage, nonce)).catch((error) => {
+    await fs10.unlink(leaseFile(storage, nonce)).catch((error) => {
       if (!["ENOENT", "EACCES", "EROFS"].includes(error.code ?? "")) throw error;
     });
   }
 }
+function claudeWatchCommand(sessionId, env) {
+  const root = env.CLAUDE_PLUGIN_ROOT;
+  return `${root ? `'${path9.join(root, "bin", "khala").replaceAll("'", "'\\''")}'` : "khala"} watch --harness claude --session ${sessionId}`;
+}
 var WATCH_USAGE = "usage: khala watch [--harness <id>] [--session <id>]";
 async function run(argv) {
   if (argv.length === 1 && ["--help", "-h"].includes(argv[0])) {
@@ -1097,8 +1377,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-AU2FBBUY.mjs");
-  const { adapterFor } = await import("./chunk-KXLGRISD.mjs");
+  const { resolveHarness, resolveSessionId } = await import("./chunk-LZXXWDKB.mjs");
+  const { adapterFor } = await import("./chunk-IH5ALDEX.mjs");
   const harness = resolveHarness(argv, process.env);
   if (harness === "invalid" || !adapterFor(harness)?.codec) return invalid("invalid_harness");
   const index = argv.indexOf("--session");
@@ -1123,9 +1403,29 @@ ${WATCH_USAGE}`);
 }
 
 export {
-  readWakeSettings,
-  updateWakeSettings,
-  driverAllowed,
+  toEventInboxEntry,
+  createEventKeyFilter,
+  isWakeEntry,
+  mentions,
+  wakesAgent,
+  readEntries,
+  readCursor,
+  unread,
+  wakeStart,
+  unwoken,
+  markNudged,
+  advanceCursor,
+  appendInbox,
+  unreadCount,
+  channelKey,
+  listChannels,
+  migrateLegacy,
+  resolveChannel,
+  readActivity,
+  markUsageLimit,
+  clearUsageLimit,
+  usageLimited,
+  writeActivity,
   readModeState,
   delegateChannel,
   isDelegated,
@@ -1133,9 +1433,13 @@ export {
   applyArchived,
   ATTENTION,
   applyListeningMode,
+  readWakeSettings,
+  updateWakeSettings,
+  driverAllowed,
   CURSOR_WORKSPACE_ENV,
   CURSOR_DEFAULT_SESSION,
   cursorSessionId,
+  nodeScriptCommand,
   installedLauncher,
   launcherShellQuote,
   formatJson,
@@ -1143,23 +1447,23 @@ export {
   textFormat,
   readManaged,
   ManagedFiles,
+  cursorPaths,
+  installCursor,
+  museCliPath,
+  museWatchCommand,
+  museMonitorInstruction,
+  createMuseMonitorDriver,
+  museStopWakeText,
   verifyQwenTranscript,
   qwenHome,
   qwenInboundAllowed,
   qwenControllerFile,
   qwenSession,
   createQwenSocketDriver,
-  nodeScriptCommand,
-  cursorPaths,
-  installCursor,
   monitorOwner,
   monitorArmed,
   watchSession,
+  claudeWatchCommand,
   WATCH_USAGE,
-  run,
-  museCliPath,
-  museWatchCommand,
-  museMonitorInstruction,
-  createMuseMonitorDriver,
-  museStopWakeText
+  run
 };