khala-cli 0.4.9 → 0.4.10

package/dist/{chunk-FZEH2IXZ.mjs → chunk-PJKI7SRI.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-C2WEDMAF.mjs";
+import {
+  RESTORE_HISTORY_MAX_PAGES
+} from "./chunk-WUDXHF2Q.mjs";
+import "./chunk-HHEZVPRR.mjs";
 import {
   LISTENING_MODE_COMMAND_TYPE,
   LISTENING_MODE_MEMBER_KEY,
   memberListeningMode
-} from "./chunk-NGSYOVQ4.mjs";
+} from "./chunk-4BP7V3OP.mjs";
+import {
+  CHANNEL_EVENT_TYPE,
+  encodeChannelEvent,
+  memberRenameContent
+} from "./chunk-JKOJQTFT.mjs";
 import {
   StateError
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-PN25BUQ4.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-EVT2DWNZ.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-3E5DH3Y6.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-3E5DH3Y6.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,35 @@ 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));
+    },
     stop
   };
 }

package/dist/{chunk-NPSQNCOY.mjs → chunk-PN25BUQ4.mjs}

@@ -1,7 +1,7 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-EVT2DWNZ.mjs";
 
 // ../contracts/src/m1/harness.ts
 init_define_KHALA_BUNDLE();
@@ -18,8 +18,8 @@ var HARNESS_REGISTRY = [
   { id: "copilot", displayName: "Copilot CLI", modelName: "Copilot", logoKey: "copilot", steer: true, sync: true, idleWake: "opt-in", registered: true },
   { id: "vscode", displayName: "Copilot (VS Code)", modelName: "VSCode", logoKey: "copilot", steer: true, sync: true, idleWake: "opt-in", registered: true },
   { id: "gemini", displayName: "Gemini CLI", modelName: "Gemini", logoKey: "gemini", steer: true, sync: true, idleWake: "opt-in", registered: true },
-  // U29 establishes Antigravity capabilities after its spike.
-  { id: "antigravity", displayName: "Antigravity CLI", modelName: "Antigravity", logoKey: null, steer: false, sync: false, idleWake: "none", registered: true },
+  // Spike-backed capabilities; transport availability is reported per session.
+  { id: "antigravity", displayName: "Antigravity CLI", modelName: "Antigravity", logoKey: null, steer: true, sync: true, idleWake: "opt-in", registered: true },
   { id: "qwen", displayName: "Qwen Code", modelName: "Qwen", logoKey: "qwen", steer: true, sync: true, idleWake: "default", registered: true },
   { id: "muse", displayName: "Muse Code", modelName: "Muse", logoKey: null, steer: true, sync: true, idleWake: "default", registered: true },
   { id: "generic", displayName: "MCP agent", modelName: "Agent", logoKey: null, steer: false, sync: false, idleWake: "none", registered: true }
@@ -328,6 +328,14 @@ function cachedProcessReader(read = readProcess) {
     return result;
   };
 }
+async function readProcessArguments(pid) {
+  if (!validPid(pid) || process.platform !== "linux") return null;
+  try {
+    return (await readFile(`/proc/${pid}/cmdline`, "utf8")).split("\0").slice(0, -1);
+  } catch {
+    return null;
+  }
+}
 
 // src/state.ts
 var SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
@@ -512,7 +520,7 @@ async function readWatcherStatus(files, read = readProcess, now = () => /* @__PU
   return writer && writer.startTime !== owner?.startTime ? { ...status, state: "disconnected", detail: "process_exited" } : status;
 }
 async function writeStateFile(dir, name, value) {
-  if (!["join.json", "session.json", "cursor.json", "status.json", "mode.json", "rejoin.json", "channel.json", "resume.json"].includes(name)) throw new StateError("storage_failed");
+  if (!["join.json", "session.json", "cursor.json", "status.json", "mode.json", "rejoin.json", "channel.json", "resume.json", "fold.json"].includes(name)) throw new StateError("storage_failed");
   await writeJsonAtomic(path.join(dir, name), name === "status.json" ? await ownStatus(value) : value);
 }
 function readStateFile(dir, name) {
@@ -565,6 +573,7 @@ export {
   ancestors,
   nearestNonShellAncestor,
   cachedProcessReader,
+  readProcessArguments,
   SESSION_ID_PATTERN,
   StateError,
   stateRoot,

package/dist/{chunk-3R6HFSLL.mjs → chunk-QDPJ4VT2.mjs}

@@ -1,43 +1,44 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
-import {
-  isWakeEntry
-} from "./chunk-47XNLAJG.mjs";
-import "./chunk-BV45NK7K.mjs";
 import {
   wakeDisableNotice
-} from "./chunk-XUCWSYVS.mjs";
+} from "./chunk-W6HM6F2U.mjs";
 import {
   adapterFor,
   createCopilotCodec,
   recordHookSession
-} from "./chunk-ITFD3JZS.mjs";
+} from "./chunk-5JSGA6OB.mjs";
 import {
   capturePane
-} from "./chunk-QKWEZXR3.mjs";
+} from "./chunk-6AQVW5W7.mjs";
 import {
   readListeningMode
-} from "./chunk-NIX5F4LT.mjs";
-import "./chunk-NGSYOVQ4.mjs";
+} from "./chunk-2AMWQ7RB.mjs";
+import "./chunk-4BP7V3OP.mjs";
 import {
   advanceCursor,
+  clearUsageLimit,
+  isWakeEntry,
   listChannels,
+  markUsageLimit,
   readActivity,
   unread,
+  wakesAgent,
   writeActivity
-} from "./chunk-TANCKTDK.mjs";
+} from "./chunk-OEV5DFLW.mjs";
+import "./chunk-JKOJQTFT.mjs";
 import {
   StateError,
   TERMINAL_SESSION_DETAILS,
   readJson,
   readStatus,
   sessionFiles
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-PN25BUQ4.mjs";
 import {
   settleAttempts
-} from "./chunk-K7V7X6WU.mjs";
+} from "./chunk-ZSKLNZWZ.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-EVT2DWNZ.mjs";
 
 // hooks/deliver.ts
 init_define_KHALA_BUNDLE();
@@ -53,26 +54,36 @@ import * as fs from "node:fs/promises";
 import { constants } from "node:fs";
 var MAX_TAIL_BYTES = 64 * 1024;
 var MARKERS = /* @__PURE__ */ new Set(["[Request interrupted by user]", "[Request interrupted by user for tool use]"]);
-async function claudeTranscriptInterrupted(transcriptPath, activityAt) {
-  if (!transcriptPath) return false;
+async function tailLines(transcriptPath) {
+  if (!transcriptPath) return [];
   let handle;
   try {
     handle = await fs.open(transcriptPath, constants.O_RDONLY | constants.O_NONBLOCK);
     const stat2 = await handle.stat();
-    if (!stat2.isFile()) return false;
+    if (!stat2.isFile()) return [];
     const length = Math.min(stat2.size, MAX_TAIL_BYTES);
     const start = stat2.size - length;
     const buffer = Buffer.alloc(length);
     const { bytesRead } = await handle.read(buffer, 0, length, start);
-    if (bytesRead !== length) return false;
+    if (bytesRead !== length) return [];
     let tail = buffer.toString("utf8");
     if (start > 0) {
       const newline = tail.indexOf("\n");
-      if (newline < 0) return false;
+      if (newline < 0) return [];
       tail = tail.slice(newline + 1);
     }
-    const lines = tail.split("\n").filter((line) => line.trim() !== "");
-    if (!lines.length) return false;
+    return tail.split("\n").filter((line) => line.trim() !== "");
+  } catch {
+    return [];
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+async function claudeTranscriptInterrupted(transcriptPath, activityAt) {
+  const lines = await tailLines(transcriptPath);
+  if (!lines.length) return false;
+  try {
     const entry = JSON.parse(lines.at(-1));
     if (entry?.type !== "user" || entry.message?.role !== "user" || typeof entry.timestamp !== "string" || !(Date.parse(entry.timestamp) > Date.parse(activityAt))) return false;
     const content = entry.message.content;
@@ -80,11 +91,24 @@ async function claudeTranscriptInterrupted(transcriptPath, activityAt) {
     return Array.isArray(content) && content.length === 1 && content[0]?.type === "text" && typeof content[0].text === "string" && MARKERS.has(content[0].text);
   } catch {
     return false;
-  } finally {
-    await handle?.close().catch(() => {
-    });
   }
 }
+async function claudeTranscriptVersion(transcriptPath) {
+  for (const line of (await tailLines(transcriptPath)).reverse()) {
+    try {
+      const version = JSON.parse(line)?.version;
+      if (typeof version === "string" && /^\d+\.\d+\.\d+$/.test(version)) return version;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function versionAtLeast(version, floor) {
+  if (version === void 0) return false;
+  const a = version.split(".").map(Number), b = floor.split(".").map(Number);
+  for (let i = 0; i < b.length; i++) if ((a[i] ?? 0) !== b[i]) return (a[i] ?? 0) > b[i];
+  return true;
+}
 
 // src/harness/deliver-core.ts
 var MAX_FRAME_BYTES = 64 * 1024;
@@ -162,7 +186,8 @@ function selectFrames(groups, budget = MAX_FRAME_BYTES) {
   }
   return selected;
 }
-async function channelFrames(files, steerOnly, requireWake, io) {
+async function channelFrames(files, steerOnly, requireWake, io, quiet, shown) {
+  const wakes = (group) => group.consumed.some((entry) => quiet ? wakesAgent(entry, group.mode, group.you) : isWakeEntry(entry));
   const groups = [];
   for (const channel of await listChannels(files)) {
     const mode = await readListeningMode(channel.files);
@@ -171,6 +196,7 @@ async function channelFrames(files, steerOnly, requireWake, io) {
     groups.push({
       channel: { ...channel, ...status?.channelName !== void 0 ? { channelName: status.channelName } : {} },
       ...pending,
+      mode,
       you: typeof status?.displayName === "string" ? status.displayName : void 0
     });
   }
@@ -179,16 +205,16 @@ async function channelFrames(files, steerOnly, requireWake, io) {
   const reserved = selected.reduce((sum, group) => sum + Buffer.byteLength(group.frame), 0) + Math.max(0, selected.length - 1);
   let spare = MAX_FRAME_BYTES - reserved;
   const order = selected.map((group, index) => ({ group, index }));
-  if (requireWake) order.sort((a, b) => Number(b.group.consumed.some(isWakeEntry)) - Number(a.group.consumed.some(isWakeEntry)));
+  if (requireWake) order.sort((a, b) => Number(wakes(b.group)) - Number(wakes(a.group)));
   let hasWake = false;
   const failures = [];
   for (const { group, index } of order) {
-    if (requireWake && !hasWake && !group.consumed.some(isWakeEntry)) continue;
+    if (requireWake && !hasWake && !wakes(group)) continue;
     try {
       let current = group;
       for (let attempt = 0; attempt < 2; attempt++) {
-        if (!current.frame || requireWake && !hasWake && !current.consumed.some(isWakeEntry)) break;
-        if (await advanceCursor(current.channel.files, current.cursor, current.consumed) === "conflict") {
+        if (!current.frame || requireWake && !hasWake && !wakes(current)) break;
+        if (await advanceCursor(current.channel.files, current.cursor, current.consumed, shown) === "conflict") {
           if (attempt === 0) {
             const pending = await unread(current.channel.files);
             const retry = selectFrame(
@@ -204,7 +230,7 @@ async function channelFrames(files, steerOnly, requireWake, io) {
         }
         spare += Buffer.byteLength(group.frame) - Buffer.byteLength(current.frame);
         emitted.set(index, current.frame);
-        hasWake ||= current.consumed.some(isWakeEntry);
+        hasWake ||= wakes(current);
         break;
       }
     } catch (error) {
@@ -241,7 +267,7 @@ async function deliverCore(stdin, adapter, io) {
   if (!codec) return 0;
   const input = codec.parse(stdin);
   let output = codec.noop(input?.event);
-  if (input && (input.event === "prompt" || input.event === "start") && input.sessionId && adapter.sessionSources.some((source) => source.kind === "hook-map")) {
+  if (input && (input.event === "prompt" || input.event === "start" || adapter.id === "opencode" && input.event === "stop") && input.sessionId && adapter.sessionSources.some((source) => source.kind === "hook-map")) {
     try {
       await recordHookSession(adapter.id, input.sessionId, io.env, { now: io.now, ...io.pid !== void 0 ? { pid: io.pid } : {}, ...io.readProcess ? { readProcess: io.readProcess } : {}, ...input.workspace !== void 0 ? { workspace: input.workspace } : {} });
     } catch (error) {
@@ -257,6 +283,18 @@ async function deliverCore(stdin, adapter, io) {
     }
     if (files) {
       try {
+        if (input.event === "limit") {
+          await markUsageLimit(files, io.now);
+          return 0;
+        }
+        if (input.event === "tool" || input.event === "stop") await clearUsageLimit(files);
+        if (adapter.verifyWake) {
+          try {
+            await adapter.verifyWake(stdin, files, io.now().getTime());
+          } catch {
+            diagnostic(io, "wake_verification_failed");
+          }
+        }
         if (adapter.emptyPrompt && (input.event === "start" || input.event === "prompt")) {
           try {
             await capturePane(files, io.env, {
@@ -288,18 +326,21 @@ async function deliverCore(stdin, adapter, io) {
         }
         if (input.event !== "start") {
           let steerOnly = input.event === "tool";
-          if (input.event === "prompt") {
-            const activity = await readActivity(files);
-            steerOnly = adapter.id === "claude" && activity.state === "busy" && Date.parse(activity.updatedAt) !== 0 && io.now().getTime() - Date.parse(activity.updatedAt) < CLAUDE_STALE_BUSY_MS && !await claudeTranscriptInterrupted(input.transcriptPath, activity.updatedAt);
+          if (adapter.hookPromptText || input.event === "prompt") {
             try {
               await settleAttempts(files.dir, {
                 now: io.now().getTime(),
-                activity,
-                promptText: input.promptText ?? ""
+                activity: await readActivity(files),
+                promptText: adapter.hookPromptText ? await adapter.hookPromptText(input, files) : input.promptText ?? "",
+                deferVerification: Boolean(adapter.hookPromptText)
               });
             } catch {
               diagnostic(io, "wake_verification_failed");
             }
+          }
+          if (input.event === "prompt") {
+            const activity = await readActivity(files);
+            steerOnly = adapter.id === "claude" && activity.state === "busy" && Date.parse(activity.updatedAt) !== 0 && io.now().getTime() - Date.parse(activity.updatedAt) < CLAUDE_STALE_BUSY_MS && !await claudeTranscriptInterrupted(input.transcriptPath, activity.updatedAt);
             await writeActivity(files, "busy", io.now);
           }
           if (adapter.id === "claude" && input.event === "tool" && (await readActivity(files)).state === "busy") await writeActivity(files, "busy", io.now);
@@ -316,16 +357,21 @@ async function deliverCore(stdin, adapter, io) {
                 return 0;
               }
             }
+            const stopContext = input.event === "stop" && codec.stopContextFloor !== void 0 && versionAtLeast(await claudeTranscriptVersion(input.transcriptPath), codec.stopContextFloor);
             const frame = await channelFrames(
               files,
               steerOnly,
               input.event !== "prompt" || !codec.promptDeliversWithoutWake,
-              io
+              io,
+              input.event === "stop",
+              // Stop shows the frame only as verified Claude context; every other Stop is a fixed nudge,
+              // which consumes the batch without showing it and so earns no read receipt.
+              input.event !== "stop" || stopContext
             );
             if (frame) {
               if (!wake) await writeActivity(files, "busy", io.now);
               const notice = await wakeDisableNotice(files.dir);
-              output = (wake ? wake + "\n" : "") + codec.render(input.event, frame + (notice ? "\n" + notice : ""));
+              output = (wake ? wake + "\n" : "") + codec.render(input.event, frame + (notice ? "\n" + notice : ""), stopContext);
             } else if (input.event === "stop") await writeActivity(files, "idle", io.now);
           }
         }
@@ -357,7 +403,15 @@ async function deliver(stdin, argv, io = {
   let env = io.env;
   const museRoots = argv.length === 6 && argv[0] === "--harness" && argv[1] === "muse" && argv[2] === "--state-home" && argv[4] === "--data-home" && path.isAbsolute(argv[3]) && path.isAbsolute(argv[5]);
   if (museRoots) env = { ...env, XDG_STATE_HOME: argv[3], XDG_DATA_HOME: argv[5] };
-  let adapter = (argv.length === 2 || museRoots || argv.length === 4 && argv[1] === "copilot" && argv[2] === "--event") && argv[0] === "--harness" ? adapterFor(argv[1]) : void 0;
+  const antigravityEvent = argv.length === 4 && argv[0] === "--harness" && argv[1] === "antigravity" && argv[2] === "--event" && ["PreInvocation", "Stop"].includes(argv[3]) ? argv[3] : void 0;
+  let adapter = (argv.length === 2 || museRoots || antigravityEvent || argv.length === 4 && argv[1] === "copilot" && argv[2] === "--event") && argv[0] === "--harness" ? adapterFor(argv[1]) : void 0;
+  if (antigravityEvent) {
+    try {
+      stdin = JSON.stringify({ ...JSON.parse(stdin), khalaHookEvent: antigravityEvent });
+    } catch {
+      stdin = "{}";
+    }
+  }
   if (adapter?.id === "copilot" && argv.length === 4) adapter = { ...adapter, codec: createCopilotCodec(argv[3]) };
   if (!adapter?.codec) {
     diagnostic(io, "invalid_harness");