khala-cli 0.4.9 → 0.4.11

package/dist/{chunk-3R6HFSLL.mjs → chunk-NN5RHU6C.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-HZH74L5T.mjs";
 import {
   adapterFor,
   createCopilotCodec,
   recordHookSession
-} from "./chunk-ITFD3JZS.mjs";
+} from "./chunk-BVG7PJNZ.mjs";
 import {
   capturePane
-} from "./chunk-QKWEZXR3.mjs";
+} from "./chunk-4PUNVPC3.mjs";
 import {
   readListeningMode
-} from "./chunk-NIX5F4LT.mjs";
-import "./chunk-NGSYOVQ4.mjs";
+} from "./chunk-NOKTVPSY.mjs";
+import "./chunk-CXVANPY5.mjs";
 import {
   advanceCursor,
+  clearUsageLimit,
+  isWakeEntry,
   listChannels,
+  markUsageLimit,
   readActivity,
   unread,
+  wakesAgent,
   writeActivity
-} from "./chunk-TANCKTDK.mjs";
+} from "./chunk-N6UYX3SY.mjs";
+import "./chunk-VWWI4S5A.mjs";
 import {
   StateError,
   TERMINAL_SESSION_DETAILS,
   readJson,
   readStatus,
   sessionFiles
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-JNSB3E6C.mjs";
 import {
   settleAttempts
-} from "./chunk-K7V7X6WU.mjs";
+} from "./chunk-TVQ4MSEI.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-LDW4HOQW.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");