khala-cli 0.4.9 → 0.4.11

package/dist/{chunk-NGSYOVQ4.mjs → chunk-CXVANPY5.mjs}

@@ -5,10 +5,10 @@ import {
   object,
   readMatrixUserId,
   version
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-JNSB3E6C.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.mjs";
 
 // ../contracts/src/m1/listening-mode.ts
 init_define_KHALA_BUNDLE();

package/dist/chunk-CYINL2V3.mjs

@@ -0,0 +1,20 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  resolveHarness,
+  resolveSession,
+  resolveSessionId
+} from "./chunk-NE4S7N3R.mjs";
+import "./chunk-BVG7PJNZ.mjs";
+import "./chunk-4PUNVPC3.mjs";
+import "./chunk-NOKTVPSY.mjs";
+import "./chunk-CXVANPY5.mjs";
+import "./chunk-N6UYX3SY.mjs";
+import "./chunk-VWWI4S5A.mjs";
+import "./chunk-JNSB3E6C.mjs";
+import "./chunk-TVQ4MSEI.mjs";
+import "./chunk-LDW4HOQW.mjs";
+export {
+  resolveHarness,
+  resolveSession,
+  resolveSessionId
+};

package/dist/{chunk-KMLXOPBQ.mjs → chunk-E5QRD6W3.mjs}

@@ -1,16 +1,18 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   cancelAttempt,
+  confirmWakeText,
   failAttempt,
   readWakeState,
   recordAttempt,
   resetWakeDriver,
   settleAttempts,
   takeWakeDisableNotices
-} from "./chunk-K7V7X6WU.mjs";
-import "./chunk-7R3EIDGR.mjs";
+} from "./chunk-TVQ4MSEI.mjs";
+import "./chunk-LDW4HOQW.mjs";
 export {
   cancelAttempt,
+  confirmWakeText,
   failAttempt,
   readWakeState,
   recordAttempt,

package/dist/{chunk-FO5GXCST.mjs → chunk-FGHPOKXG.mjs}

@@ -1,13 +1,13 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   KHALA_AGENT_VERSION
-} from "./chunk-ANSR4IAW.mjs";
+} from "./chunk-YIKJI26V.mjs";
 import {
   bundle
-} from "./chunk-3KDOTR54.mjs";
+} from "./chunk-NUQSDSVT.mjs";
 import {
   LISTENING_MODES
-} from "./chunk-NGSYOVQ4.mjs";
+} from "./chunk-CXVANPY5.mjs";
 import {
   HARNESS_REGISTRY,
   M1_LABEL_MAX_BYTES,
@@ -35,10 +35,10 @@ import {
   utcTimestamp,
   utf8Length,
   version
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-JNSB3E6C.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.mjs";
 
 // src/client.ts
 init_define_KHALA_BUNDLE();

package/dist/{chunk-FZEH2IXZ.mjs → chunk-GVZD4TLW.mjs}

@@ -1,26 +1,32 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
-import "./chunk-SSO5RFOX.mjs";
 import {
-  CHANNEL_EVENT_TYPE,
-  encodeChannelEvent,
-  memberRenameContent
-} from "./chunk-BV45NK7K.mjs";
+  retryUnexpired
+} from "./chunk-LNKI3CZO.mjs";
+import {
+  RESTORE_HISTORY_MAX_PAGES
+} from "./chunk-X3BAMHAR.mjs";
+import "./chunk-R5NDTJRA.mjs";
 import {
   LISTENING_MODE_COMMAND_TYPE,
   LISTENING_MODE_MEMBER_KEY,
   memberListeningMode
-} from "./chunk-NGSYOVQ4.mjs";
+} from "./chunk-CXVANPY5.mjs";
+import {
+  CHANNEL_EVENT_TYPE,
+  encodeChannelEvent,
+  memberRenameContent
+} from "./chunk-VWWI4S5A.mjs";
 import {
   StateError
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-JNSB3E6C.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.mjs";
 
 // src/matrix/session.ts
 init_define_KHALA_BUNDLE();
 import { randomUUID } from "node:crypto";
-import { createClient, ClientEvent, RoomEvent, MatrixEventEvent, SyncState, Direction, Method, EventType } from "matrix-js-sdk";
+import { createClient, ClientEvent, RoomEvent, MatrixEventEvent, SyncState, SetPresence, Direction, Method, EventType } from "matrix-js-sdk";
 function message(event) {
   const type = event.getType();
   const eventId = event.getId();
@@ -44,7 +50,7 @@ async function createAgentMatrixSession(creds, opts) {
   const started = Date.now();
   const rejoinTxnId = `khala.rejoin.${randomUUID()}`;
   const log = (line) => opts?.log?.(line);
-  const persistent = opts?.cryptoStore ? await (await import("./chunk-PAJ4JJPV.mjs")).openCryptoStore(opts.cryptoStore.dir, opts.cryptoStore.root, creds) : void 0;
+  const persistent = opts?.cryptoStore ? await (await import("./chunk-YDEZFVF7.mjs")).openCryptoStore(opts.cryptoStore.dir, opts.cryptoStore.root, creds) : void 0;
   const client = createClient({ ...persistent ? { store: persistent.sync } : {}, baseUrl: creds.homeserver, userId: creds.userId, accessToken: creds.accessToken, deviceId: creds.deviceId });
   const handlers = /* @__PURE__ */ new Set();
   const ended = /* @__PURE__ */ new Set();
@@ -52,13 +58,38 @@ async function createAgentMatrixSession(creds, opts) {
   const inviters = /* @__PURE__ */ new Map();
   const emitted = /* @__PURE__ */ new Set();
   const liveEvents = /* @__PURE__ */ new Set();
+  const undecryptableIds = new Map((persistent?.undecryptableEventIds ?? []).map((entry) => [entry.id, entry]));
+  let retrySave = Promise.resolve();
+  const saveRetries = () => {
+    const entries = [...undecryptableIds.values()];
+    retrySave = retrySave.then(() => persistent?.rememberUndecryptable(entries)).catch(() => log("decryption_retry_save_failed"));
+  };
+  const rememberDecryption = (event) => {
+    const id = event.getId();
+    if (stopped || !persistent || !id) return;
+    const failed = event.getType() === "m.room.encrypted" || event.isDecryptionFailure();
+    if (failed) {
+      if (undecryptableIds.has(id)) return;
+      undecryptableIds.set(id, { id, firstSeen: Date.now() });
+    } else if (!undecryptableIds.delete(id)) return;
+    if (undecryptableIds.size > 100) undecryptableIds.delete(undecryptableIds.keys().next().value);
+    saveRetries();
+  };
   const joinTimes = /* @__PURE__ */ new Map();
   const cancellations = /* @__PURE__ */ new Set();
   let joinedRoom;
   let stopped = false;
+  let presenceTimer;
+  let away;
+  const publishPresence = () => {
+    void client.setSyncPresence(away ? SetPresence.Offline : void 0);
+    void client.setPresence(away ? { presence: "offline", status_msg: away } : { presence: "online", status_msg: "" }).catch(() => log("presence_failed"));
+  };
   let recovering = persistent?.restored ?? false;
   const deliver = (event) => {
-    if (stopped || recovering || !liveEvents.has(event)) return;
+    if (stopped) return;
+    if (liveEvents.has(event)) rememberDecryption(event);
+    if (recovering || !liveEvents.has(event)) return;
     const command = event.getType() === LISTENING_MODE_COMMAND_TYPE && !event.isDecryptionFailure() && event.getId() && event.getRoomId() && event.getSender() ? { eventId: event.getId(), roomId: event.getRoomId(), sender: event.getSender(), ts: event.getTs(), content: event.getContent() } : void 0;
     const m = command ?? message(event);
     if (!m) {
@@ -96,7 +127,10 @@ async function createAgentMatrixSession(creds, opts) {
   const timeline = (event, _room, toStart, _removed, data) => {
     if (stopped || toStart || data?.liveEvent === false && !persistent?.restored) return;
     liveEvents.add(event);
-    void client.decryptEventIfNeeded(event).then(() => deliver(event), () => log("live_decryption_failed"));
+    void client.decryptEventIfNeeded(event).then(() => deliver(event), () => {
+      rememberDecryption(event);
+      log("live_decryption_failed");
+    });
   };
   const decrypted = (event) => deliver(event);
   const syncLog = (state, _previous, data) => {
@@ -167,6 +201,24 @@ async function createAgentMatrixSession(creds, opts) {
   const stopSession = async () => {
     if (stopped) return;
     stopped = true;
+    clearInterval(presenceTimer);
+    if (presenceTimer && !wipe) {
+      await Promise.race([
+        client.setPresence({ presence: "offline", status_msg: "session ended" }).catch(() => log("presence_failed")),
+        new Promise((resolve) => setTimeout(resolve, 3e3).unref())
+      ]);
+    }
+    await retrySave;
+    if (wipe) {
+      try {
+        await client.http.authedRequest(Method.Post, "/logout", void 0, {}, { localTimeoutMs: 5e3 });
+      } catch (error) {
+        if (matrixCode(error) !== "M_UNKNOWN_TOKEN" && !(typeof error === "object" && error !== null && "httpStatus" in error && error.httpStatus === 401)) {
+          log("discarded_device_logout_failed");
+          console.error("khala: discarded_device_logout_failed");
+        }
+      }
+    }
     if (wipe && persistent?.forgetIdentity) {
       try {
         await persistent.forgetIdentity();
@@ -236,8 +288,7 @@ async function createAgentMatrixSession(creds, opts) {
       await client.initRustCrypto(persistent ? { useIndexedDB: true, cryptoDatabasePrefix: persistent.prefix } : { useIndexedDB: false });
     } catch (error) {
       if (!persistent?.restored || error instanceof StateError && error.code === "unsafe_state_dir") throw error;
-      wipe = true;
-      throw new (await import("./chunk-PAJ4JJPV.mjs")).CryptoStoreCorruptError();
+      throw new (await import("./chunk-YDEZFVF7.mjs")).CryptoStoreCorruptError();
     }
     const crypto = client.getCrypto();
     if (!crypto) throw new Error("crypto_unavailable");
@@ -264,6 +315,9 @@ async function createAgentMatrixSession(creds, opts) {
     }, () => client.getSyncState() === SyncState.Prepared || client.getSyncState() === SyncState.Syncing, 3e4, "sync_timeout");
     await Promise.all([client.startClient({ initialSyncLimit: 30 }), prepared]);
     log(`session_ready_ms=${Date.now() - started}`);
+    publishPresence();
+    presenceTimer = setInterval(publishPresence, 6e4);
+    presenceTimer.unref();
   } catch (error) {
     await stop();
     throw error;
@@ -282,6 +336,7 @@ async function createAgentMatrixSession(creds, opts) {
   return {
     userId: creds.userId,
     ...persistent?.recovered ? { cryptoReset: true } : {},
+    ...persistent?.restored ? { recoversOnJoin: true } : {},
     onEnded(handler) {
       if (!stopped) ended.add(handler);
       return () => {
@@ -317,7 +372,6 @@ async function createAgentMatrixSession(creds, opts) {
     async join(roomId) {
       if (stopped) throw new Error("session_stopped");
       if (joinedRoom === roomId) return;
-      const rejoinedAt = Date.now();
       const membership = client.getRoom(roomId)?.getMyMembership();
       if (membership !== "join") {
         if (membership !== "invite") throw new Error("not_invited");
@@ -338,30 +392,80 @@ async function createAgentMatrixSession(creds, opts) {
         const content = { ...ownJoin.getContent(), membership: "join", "com.khala.invited_by": inviters.get(roomId) };
         await client.sendStateEvent(roomId, EventType.RoomMember, content, creds.userId);
       }
-      const joinedAt = persistent?.joinedAt ?? (membership === "join" ? rejoinedAt : ownJoin.getTs());
+      const joinedAt = persistent?.joinedAt ?? ownJoin.getTs();
       await persistent?.rememberJoin(joinedAt);
       joinTimes.set(roomId, joinedAt);
       if (persistent?.restored) {
+        let pruned = false;
+        for (const [id, entry] of [...undecryptableIds]) {
+          if (stopped) throw new Error("session_stopped");
+          if (!retryUnexpired(entry)) {
+            undecryptableIds.delete(id);
+            pruned = true;
+            continue;
+          }
+          try {
+            const raw = await client.fetchRoomEvent(roomId, id);
+            const event = client.getEventMapper()({ ...raw, room_id: roomId });
+            if (event.getTs() < joinedAt) {
+              undecryptableIds.delete(id);
+              pruned = true;
+              continue;
+            }
+            liveEvents.add(event);
+            await client.decryptEventIfNeeded(event).catch(() => log("recovery_decryption_failed"));
+            rememberDecryption(event);
+          } catch (error) {
+            const status = typeof error === "object" && error !== null && "httpStatus" in error ? error.httpStatus : void 0;
+            if (matrixCode(error) === "M_NOT_FOUND" || matrixCode(error) === "M_FORBIDDEN" || status === 404 || status === 403) {
+              undecryptableIds.delete(id);
+              pruned = true;
+            }
+            log("recovery_event_retry_failed");
+          }
+        }
+        if (pruned) saveRetries();
         let token = null;
         const seenTokens = /* @__PURE__ */ new Set();
+        let pages = 0;
+        let undecryptable = 0;
         for (; ; ) {
           if (stopped) throw new Error("session_stopped");
           const page = await client.createMessagesRequest(roomId, token, 100, Direction.Backward);
-          let reachedJoin = false;
+          pages++;
+          let reachedBoundary = false;
           for (const raw of page.chunk) {
             const event = client.getEventMapper()({ ...raw, room_id: roomId });
-            if (event.getTs() < joinedAt) {
-              reachedJoin = true;
-              continue;
+            if (opts?.restoreStopAtEventId && event.getId() === opts.restoreStopAtEventId || event.getTs() < joinedAt) {
+              reachedBoundary = true;
+              break;
             }
             liveEvents.add(event);
             await client.decryptEventIfNeeded(event).catch(() => log("recovery_decryption_failed"));
+            rememberDecryption(event);
+            if (event.getType() === "m.room.encrypted" || event.isDecryptionFailure()) {
+              undecryptable++;
+              liveEvents.delete(event);
+            }
+          }
+          if (reachedBoundary || page.chunk.length === 0 || !page.end) break;
+          if (pages >= RESTORE_HISTORY_MAX_PAGES) {
+            const count = `restore_catchup_truncated pages=${pages}`;
+            if (opts?.log) log(count);
+            else process.stderr.write(`${count}
+`);
+            break;
           }
-          if (reachedJoin || page.chunk.length === 0 || !page.end) break;
           if (seenTokens.has(page.end)) throw new Error("recovery_pagination_stalled");
           seenTokens.add(page.end);
           token = page.end;
         }
+        if (undecryptable > 0) {
+          const count = `history_undecryptable=${undecryptable}`;
+          if (opts?.log) log(count);
+          else process.stderr.write(`${count}
+`);
+        }
       }
       recovering = false;
       if (!joinedRoom) client.on(RoomEvent.MyMembership, membershipEnded);
@@ -370,7 +474,8 @@ async function createAgentMatrixSession(creds, opts) {
         if (event.getRoomId() === roomId) deliver(event);
       }
     },
-    async history(roomId, limit, before) {
+    joinedAt: (roomId) => joinTimes.get(roomId),
+    async history(roomId, limit, before, options) {
       if (stopped) throw new Error("session_stopped");
       let token = null;
       if (before !== void 0) {
@@ -380,16 +485,26 @@ async function createAgentMatrixSession(creds, opts) {
       const res = await guarded(roomId, () => client.createMessagesRequest(roomId, token, limit, Direction.Backward));
       const messages = [];
       let undecryptable = 0;
+      let oldest;
+      let oldestTs;
+      let reachedBoundary = false;
       for (const raw of res.chunk) {
         const event = client.getEventMapper()({ ...raw, room_id: roomId });
+        oldest = event.getId();
+        oldestTs = Math.min(oldestTs ?? event.getTs(), event.getTs());
+        if (options?.stopAtEventId && oldest === options.stopAtEventId) {
+          reachedBoundary = true;
+          break;
+        }
         try {
           await client.decryptEventIfNeeded(event);
         } catch {
         }
+        rememberDecryption(event);
         if (event.getType() === "m.room.encrypted" || event.isDecryptionFailure()) {
           undecryptable++;
           const eventId = event.getId(), sender = event.getSender();
-          if (eventId && sender && eventId !== before) {
+          if (options?.includeUnavailable !== false && eventId && sender && eventId !== before) {
             const body = "[Encrypted message unavailable: this device does not have its key. Keys may not have been shared for messages sent before joining or while this agent was offline.]";
             messages.push({
               eventId,
@@ -406,10 +521,16 @@ async function createAgentMatrixSession(creds, opts) {
         const m = message(event);
         if (m && m.eventId !== before) messages.push(m);
       }
-      log(`history_undecryptable=${undecryptable}`);
+      const count = `history_undecryptable=${undecryptable}`;
+      log(count);
+      if (options?.includeUnavailable === false && undecryptable > 0 && !opts?.log) process.stderr.write(`${count}
+`);
       messages.reverse();
-      const oldest = messages[0];
-      return typeof res.end === "string" && oldest ? { messages, nextBefore: oldest.eventId } : { messages };
+      return {
+        messages,
+        ...typeof res.end === "string" && oldest ? { nextBefore: oldest } : {},
+        ...options?.includeUnavailable === false || options?.stopAtEventId ? { ...oldestTs === void 0 ? {} : { oldestTs }, reachedBoundary } : {}
+      };
     },
     async send(roomId, text) {
       if (stopped) throw new Error("session_stopped");
@@ -428,6 +549,39 @@ async function createAgentMatrixSession(creds, opts) {
       const value = joinedRoom && client.getRoom(joinedRoom)?.currentState.getStateEvents("m.room.member", userId)?.getContent().displayname;
       return typeof value === "string" && value.length > 0 ? value : void 0;
     },
+    members(roomId) {
+      return (client.getRoom(roomId)?.getJoinedMembers() ?? []).filter((member) => member.userId !== creds.userId).map((member) => {
+        const user = client.getUser(member.userId);
+        const event = user?.events.presence;
+        if (!user || !event) return { name: member.name, presence: "unknown" };
+        if (user.presence !== "offline") return { name: member.name, presence: "online" };
+        const reason = event.getContent().status_msg;
+        return {
+          name: member.name,
+          presence: "away",
+          since: new Date(user.lastPresenceTs - (user.lastActiveAgo ?? 0)).toISOString(),
+          ...typeof reason === "string" && reason ? { reason: reason.slice(0, 80) } : {}
+        };
+      });
+    },
+    seenBy(roomId, eventId) {
+      const room = client.getRoom(roomId);
+      if (!room?.findEventById(eventId)) return [];
+      return room.getJoinedMembers().filter((member) => member.userId !== creds.userId && room.hasUserReadEvent(member.userId, eventId)).map((member) => member.name);
+    },
+    setAway(reason) {
+      if (reason === away) return;
+      away = reason;
+      if (presenceTimer && !stopped) publishPresence();
+    },
+    async markRead(roomId, eventId) {
+      if (stopped) throw new Error("session_stopped");
+      await guarded(roomId, () => client.setRoomReadMarkersHttpRequest(roomId, eventId, eventId));
+    },
+    async setTyping(roomId, typing) {
+      if (stopped) return;
+      await client.sendTyping(roomId, typing, 3e4);
+    },
     stop
   };
 }

package/dist/{chunk-V4F3SYKW.mjs → chunk-H2L5GQ5W.mjs}

@@ -1,25 +1,30 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   sessionStartWakeChannels
-} from "./chunk-TEFOQXBK.mjs";
+} from "./chunk-MAIMFERG.mjs";
 import {
   adapterFor
-} from "./chunk-ITFD3JZS.mjs";
-import "./chunk-QKWEZXR3.mjs";
+} from "./chunk-BVG7PJNZ.mjs";
+import "./chunk-4PUNVPC3.mjs";
 import {
-  driverAllowed
-} from "./chunk-NIX5F4LT.mjs";
-import "./chunk-NGSYOVQ4.mjs";
-import "./chunk-TANCKTDK.mjs";
+  driverAllowed,
+  readListeningMode
+} from "./chunk-NOKTVPSY.mjs";
+import "./chunk-CXVANPY5.mjs";
+import {
+  wakesAgent
+} from "./chunk-N6UYX3SY.mjs";
+import "./chunk-VWWI4S5A.mjs";
 import {
   filesForDir,
+  readJson,
   resolveStateDir,
   stateRoot
-} from "./chunk-NPSQNCOY.mjs";
-import "./chunk-K7V7X6WU.mjs";
+} from "./chunk-JNSB3E6C.mjs";
+import "./chunk-TVQ4MSEI.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.mjs";
 
 // hooks/claude-wake.ts
 init_define_KHALA_BUNDLE();
@@ -30,7 +35,7 @@ import { setTimeout as sleep } from "node:timers/promises";
 var NOTICE = "Khala: new channel messages. They arrive in the next hook context.\n";
 var DEADLINE_MS = 24 * 60 * 60 * 1e3;
 var POLL_MS = 500;
-async function readJson(file) {
+async function readJson2(file) {
   try {
     return JSON.parse(await fs.readFile(file, "utf8"));
   } catch (error) {
@@ -39,7 +44,10 @@ async function readJson(file) {
   }
 }
 async function unreadChannelMessages(dir) {
-  const cursor = await readJson(path.join(dir, "cursor.json"));
+  const files = filesForDir(dir);
+  const mode = await readListeningMode(files);
+  const you = (await readJson(files.status))?.displayName;
+  const cursor = await readJson2(path.join(dir, "cursor.json"));
   const delivered = cursor && (cursor.lastDeliveredEventId === null || typeof cursor.lastDeliveredEventId === "string") && Number.isSafeInteger(cursor.deliveredCount) && typeof cursor.deliveredCount === "number" && cursor.deliveredCount >= 0 ? cursor.deliveredCount : 0;
   let content;
   try {
@@ -57,7 +65,7 @@ async function unreadChannelMessages(dir) {
       continue;
     }
     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)) continue;
-    if (index++ >= delivered && entry.kind === "message") messages++;
+    if (index++ >= delivered && wakesAgent(entry, mode, you)) messages++;
   }
   return messages;
 }
@@ -72,7 +80,7 @@ async function unreadMessages(dir) {
   }
   let messages = 0;
   for (const directory of directories) {
-    if ((await readJson(path.join(directory, "mode.json")))?.mode === "async") continue;
+    if ((await readJson2(path.join(directory, "mode.json")))?.mode === "async") continue;
     messages += await unreadChannelMessages(directory);
   }
   return messages;
@@ -128,16 +136,16 @@ async function watch(stdin, _argv, io = { stderr: process.stderr, env: process.e
     };
     const deadline = started.getTime() + testDuration(io.env.KHALA_WAKE_TEST_DEADLINE_MS, DEADLINE_MS);
     const poll = testDuration(io.env.KHALA_WAKE_TEST_POLL_MS, POLL_MS);
-    const owns = async () => (await readJson(owner))?.nonce === nonce;
+    const owns = async () => (await readJson2(owner))?.nonce === nonce;
     const idle = async () => {
-      const activity = await readJson(path.join(dir, "activity.json"));
+      const activity = await readJson2(path.join(dir, "activity.json"));
       return activity?.state === "idle" && typeof activity.updatedAt === "string" && Number.isFinite(Date.parse(activity.updatedAt));
     };
     const unread = async () => {
       if (input.hook_event_name !== "SessionStart") return unreadMessages(dir);
       let messages = 0;
       for (const channel of await sessionStartWakeChannels(filesForDir(dir), io.env)) {
-        if (channel.connected && (await readJson(channel.files.mode))?.mode !== "async") messages += await unreadChannelMessages(channel.files.dir);
+        if (channel.connected && (await readJson2(channel.files.mode))?.mode !== "async") messages += await unreadChannelMessages(channel.files.dir);
       }
       return messages;
     };