khala-cli 0.4.8 → 0.4.10

package/dist/chunk-EVT2DWNZ.mjs

@@ -0,0 +1,58 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// <define:__KHALA_BUNDLE__>
+var define_KHALA_BUNDLE_default;
+var init_define_KHALA_BUNDLE = __esm({
+  "<define:__KHALA_BUNDLE__>"() {
+    define_KHALA_BUNDLE_default = { name: "khala-cli", version: "0.4.10" };
+  }
+});
+
+export {
+  __commonJS,
+  __export,
+  __toESM,
+  init_define_KHALA_BUNDLE,
+  define_KHALA_BUNDLE_default
+};

package/dist/chunk-FJVVSKZ3.mjs

@@ -0,0 +1,22 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  cancelAttempt,
+  confirmWakeText,
+  failAttempt,
+  readWakeState,
+  recordAttempt,
+  resetWakeDriver,
+  settleAttempts,
+  takeWakeDisableNotices
+} from "./chunk-ZSKLNZWZ.mjs";
+import "./chunk-EVT2DWNZ.mjs";
+export {
+  cancelAttempt,
+  confirmWakeText,
+  failAttempt,
+  readWakeState,
+  recordAttempt,
+  resetWakeDriver,
+  settleAttempts,
+  takeWakeDisableNotices
+};

package/dist/{chunk-APMWDF6B.mjs → chunk-G3NMB4PY.mjs}

@@ -1,9 +1,11 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
-  define_KHALA_BUNDLE_default
-} from "./chunk-7HBRFY3Z.mjs";
+  define_KHALA_BUNDLE_default,
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
 
 // src/bundle.ts
+init_define_KHALA_BUNDLE();
 var bundle = typeof define_KHALA_BUNDLE_default === "undefined" ? void 0 : define_KHALA_BUNDLE_default;
 
 export {

package/dist/chunk-HHEZVPRR.mjs

@@ -0,0 +1,7 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/events/member-rename.ts
+init_define_KHALA_BUNDLE();

package/dist/{chunk-54XFVSEC.mjs → chunk-JKOJQTFT.mjs}

@@ -5,16 +5,22 @@ import {
   fail,
   label,
   literal,
+  object,
   safeInteger,
   utcTimestamp,
   utf8Length,
   version
-} from "./chunk-NKX3SLS7.mjs";
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
 
 // ../contracts/src/m1/channel-event.ts
+init_define_KHALA_BUNDLE();
 var CHANNEL_EVENT_TYPE = "com.khala.event.v1";
 var CHANNEL_EVENT_STATUSES = ["info", "pending", "success", "failure", "attention"];
 var MAX_CHANNEL_EVENT_BYTES = 4096;
+var COORDINATION_KINDS = ["handoff", "handoff_ack", "verdict", "claim", "release", "note"];
 function record(input, path) {
   if (typeof input !== "object" || input === null || Array.isArray(input)) fail(path, "not_object");
   const prototype = Object.getPrototypeOf(input);
@@ -72,10 +78,66 @@ function decodeChannelEvent(raw) {
       ...r.has("url") ? { url: readUrl(r.field("url")) } : {},
       ...r.has("occurred_at") ? { occurred_at: utcTimestamp(r.field("occurred_at"), "occurred_at") } : {},
       ...r.has("source") ? { source: readSource(r.field("source")) } : {},
-      ...r.has("key") ? { key: nonempty(label(r.field("key"), "key", 200), "key") } : {}
+      ...r.has("key") ? { key: nonempty(label(r.field("key"), "key", 200), "key") } : {},
+      // Older senders may use these kind names without data: such events stay plain events.
+      ...r.has("data") && isCoordinationKind(kind) ? { data: readData(kind, r.field("data")) } : {}
     };
   }));
 }
+function isCoordinationKind(kind) {
+  return COORDINATION_KINDS.includes(kind);
+}
+var short = (input, path) => display(input, path, 256, 64);
+var reason = (input, path) => display(input, path, 800, 200);
+function readData(kind, input) {
+  const fields = {
+    handoff: ["ticket", "from", "to", "reason", "state"],
+    handoff_ack: ["ticket"],
+    verdict: ["pr", "verdict", "reason"],
+    claim: ["key"],
+    release: ["key"],
+    note: ["key", "value"]
+  }[kind];
+  const r = object(input, "data", fields);
+  const read = (key) => {
+    const value = r.field(key);
+    switch (key) {
+      case "pr": {
+        const pr = safeInteger(value, r.at(key));
+        if (pr === 0) fail(r.at(key), "invalid_value");
+        return pr;
+      }
+      case "verdict":
+        return literal(value, r.at(key), ["approved", "changes_requested"]);
+      case "reason":
+        return reason(value, r.at(key));
+      case "key":
+        return nonempty(label(value, r.at(key), 128), r.at(key));
+      // An empty value clears the note.
+      case "value":
+        return typeof value === "string" && value === "" ? "" : reason(value, r.at(key));
+      default:
+        return short(value, r.at(key));
+    }
+  };
+  return Object.fromEntries(fields.map((key) => [key, read(key)]));
+}
+function coordinationSummary(kind, d) {
+  switch (kind) {
+    case "handoff":
+      return `handoff ${d.ticket} ${d.from} \u2192 ${d.to} (${d.state}): ${d.reason}`;
+    case "handoff_ack":
+      return `handoff ${d.ticket} acknowledged`;
+    case "verdict":
+      return `PR #${d.pr} ${d.verdict === "approved" ? "approved" : "changes requested"}: ${d.reason}`;
+    case "claim":
+      return `claimed ${d.key}`;
+    case "release":
+      return `released ${d.key}`;
+    case "note":
+      return d.value === "" ? `note ${d.key} cleared` : `note ${d.key} = ${d.value}`;
+  }
+}
 function readSubject(input) {
   const r = record(input, "subject");
   let pr;
@@ -123,8 +185,23 @@ function formatChannelEventLine(content) {
 function encodeChannelEvent(input) {
   return safely(() => {
     const checked = decodeWith(() => {
-      record(input, "");
-      return { ...input, v: 1, body: "" };
+      const r = record(input, "");
+      const raw = input;
+      const kind = raw.kind;
+      if (typeof kind !== "string" || !isCoordinationKind(kind)) {
+        if (r.has("data")) fail("data", "invalid_value");
+        return { ...raw, v: 1, body: "" };
+      }
+      const data = readData(kind, r.field("data"));
+      const derived = coordinationSummary(kind, data);
+      return {
+        ...raw,
+        v: 1,
+        body: "",
+        data,
+        ...r.has("summary") ? {} : { summary: [...derived].length > 200 ? [...derived].slice(0, 199).join("") + "\u2026" : derived },
+        ...r.has("status") || kind !== "verdict" ? {} : { status: data.verdict === "approved" ? "success" : "attention" }
+      };
     });
     if (!checked.ok) return checked;
     const decoded = decodeChannelEvent(checked.value);
@@ -159,6 +236,26 @@ function statusFor(content) {
       return content.kind.startsWith("agent.attention.") && !content.kind.endsWith(".resolved") ? "attention" : "info";
   }
 }
+function foldCoordination(events) {
+  const handoffs = /* @__PURE__ */ new Map();
+  const claims = /* @__PURE__ */ new Map();
+  const notes = /* @__PURE__ */ new Map();
+  for (const { sender, by, at, content: { kind, data } } of events) {
+    if (!data) continue;
+    const s = (key) => String(data[key]);
+    if (kind === "handoff") {
+      handoffs.delete(s("ticket"));
+      handoffs.set(s("ticket"), { ticket: s("ticket"), from: s("from"), to: s("to"), reason: s("reason"), state: s("state"), by, at });
+    } else if (kind === "handoff_ack") handoffs.delete(s("ticket"));
+    else if (kind === "claim" && !claims.has(s("key"))) claims.set(s("key"), { key: s("key"), by, sender, at });
+    else if (kind === "release" && claims.get(s("key"))?.sender === sender) claims.delete(s("key"));
+    else if (kind === "note") {
+      notes.delete(s("key"));
+      if (s("value") !== "") notes.set(s("key"), s("value"));
+    }
+  }
+  return { openHandoffs: [...handoffs.values()], activeClaims: [...claims.values()], notes: Object.fromEntries(notes) };
+}
 
 export {
   CHANNEL_EVENT_TYPE,
@@ -166,5 +263,6 @@ export {
   formatChannelEventLine,
   encodeChannelEvent,
   memberRenameContent,
-  statusFor
+  statusFor,
+  foldCoordination
 };

package/dist/{chunk-ZJ4W7P33.mjs → chunk-NDMFD5IM.mjs}

@@ -14,22 +14,24 @@ import {
   decodeLocalSendResult,
   ensureHelper,
   localRoomPath
-} from "./chunk-2DHIAFEV.mjs";
-import "./chunk-5LIE5GUU.mjs";
-import "./chunk-APMWDF6B.mjs";
-import "./chunk-5GLTKWJ5.mjs";
+} from "./chunk-SRZTHCXP.mjs";
+import "./chunk-HHEZVPRR.mjs";
+import "./chunk-XR625T3I.mjs";
+import "./chunk-G3NMB4PY.mjs";
+import {
+  LISTENING_MODE_COMMAND_TYPE
+} from "./chunk-4BP7V3OP.mjs";
 import {
   CHANNEL_EVENT_TYPE,
   memberRenameContent
-} from "./chunk-54XFVSEC.mjs";
-import "./chunk-CBPLCCRZ.mjs";
+} from "./chunk-JKOJQTFT.mjs";
+import "./chunk-PN25BUQ4.mjs";
 import {
-  LISTENING_MODE_COMMAND_TYPE
-} from "./chunk-IQJQ4RF5.mjs";
-import "./chunk-NKX3SLS7.mjs";
-import "./chunk-7HBRFY3Z.mjs";
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
 
 // src/local/session.ts
+init_define_KHALA_BUNDLE();
 import { randomUUID } from "node:crypto";
 var LocalCallError = class extends Error {
   constructor(status, code) {
@@ -122,6 +124,7 @@ async function createLocalSession(creds, opts = {}) {
   let name;
   let invitedBy;
   let after = 0;
+  let joinedAt;
   function check(roomId) {
     if (stopped) throw new Error("session_stopped");
     if (roomId !== creds.roomId) throw new Error("unknown_room");
@@ -321,6 +324,7 @@ async function createLocalSession(creds, opts = {}) {
       joining ??= (async () => {
         const result = decoded(await withHelper(() => request("POST", "join", {})), decodeLocalJoined);
         after = result.seq;
+        joinedAt = result.ts;
         await me();
         const members = decoded(await withHelper(() => request("GET", "members?wire=2")), decodeLocalMembersResponse);
         check(roomId);
@@ -338,6 +342,7 @@ async function createLocalSession(creds, opts = {}) {
         joining = void 0;
       }
     },
+    joinedAt: (roomId) => roomId === creds.roomId ? joinedAt : void 0,
     async history(roomId, limit, before) {
       check(roomId);
       const page = decoded(await withHelper(() => request("GET", `messages?wire=2&limit=${limit}${before !== void 0 ? `&before=${encodeURIComponent(before)}` : ""}`)), decodeLocalHistoryPage);

package/dist/{chunk-VKQ3KUYO.mjs → chunk-OEV5DFLW.mjs}

@@ -1,4 +1,8 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  decodeChannelEvent,
+  formatChannelEventLine
+} from "./chunk-JKOJQTFT.mjs";
 import {
   StateError,
   channelFiles,
@@ -6,14 +10,57 @@ import {
   ensureStateDir,
   filesForDir,
   readJson,
-  readStatus,
   removeStateFile,
   stateKey,
   writeJsonAtomic,
   writeStateFile
-} from "./chunk-CBPLCCRZ.mjs";
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// 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;
+}
+function mentions(entry, name) {
+  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) {
+  return isWakeEntry(entry) && (mode !== "sync" || entry.senderKind !== "agent" || entry.mention === true || mentions(entry, you));
+}
 
 // src/inbox.ts
+init_define_KHALA_BUNDLE();
 import * as fs from "node:fs/promises";
 async function readEntries(files) {
   let content;
@@ -60,16 +107,18 @@ async function unread(files) {
 }
 async function unreadCounts(files) {
   const { entries } = await unread(files);
-  return { total: entries.length, messages: entries.filter((entry) => entry.kind === "message").length };
+  return { total: entries.length, messages: entries.filter((entry) => isWakeEntry(entry)).length };
 }
-async function advanceCursor(files, expected, delivered) {
+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 next = { lastDeliveredEventId: delivered[delivered.length - 1].eventId, deliveredCount: expected.deliveredCount + delivered.length };
+  const last = delivered[delivered.length - 1].eventId;
+  const shownEventId = shown ? last : current.shownEventId;
+  const next = { lastDeliveredEventId: last, deliveredCount: expected.deliveredCount + delivered.length, ...shownEventId ? { shownEventId } : {} };
   await writeJsonAtomic(files.cursor, next);
   return next;
 }
@@ -81,6 +130,7 @@ function unreadCount(dir) {
 }
 
 // src/channels.ts
+init_define_KHALA_BUNDLE();
 import * as fs2 from "node:fs/promises";
 import path from "node:path";
 function channelKey(roomId2) {
@@ -134,7 +184,7 @@ async function listChannels(files) {
   if (await exists(files.inbox)) {
     const id = await legacyRoomId(files);
     if (id) {
-      const status = await readStatus(files);
+      const status = await readJson(files.status);
       channels.push({ key: channelKey(id), roomId: id, ...typeof status?.channelName === "string" ? { channelName: status.channelName } : {}, files, legacy: true });
     }
   }
@@ -161,7 +211,7 @@ async function migrateLegacy(files) {
       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 readStatus(files);
+  const status = await readJson(files.status);
   const metadata = await readJson(path.join(nested.dir, "channel.json"));
   if (!metadata || roomId(metadata) !== id) {
     await writeStateFile(nested.dir, "channel.json", {
@@ -203,11 +253,23 @@ function resolveChannel(list, ref) {
 }
 
 // src/activity.ts
+init_define_KHALA_BUNDLE();
+import * as fs3 from "node:fs/promises";
 import path2 from "node:path";
 async function readActivity(files) {
   const activity = await readJson(path2.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(path2.join(files.dir, USAGE_LIMIT), { at: now().toISOString() });
+}
+async function clearUsageLimit(files) {
+  await fs3.rm(path2.join(files.dir, USAGE_LIMIT), { force: true });
+}
+async function usageLimited(dir) {
+  return await readJson(path2.join(dir, USAGE_LIMIT)) !== null;
+}
 async function writeActivity(files, state, now = () => /* @__PURE__ */ new Date()) {
   const activity = { state, updatedAt: now().toISOString() };
   await writeJsonAtomic(path2.join(files.dir, "activity.json"), activity);
@@ -215,6 +277,11 @@ async function writeActivity(files, state, now = () => /* @__PURE__ */ new Date(
 }
 
 export {
+  toEventInboxEntry,
+  createEventKeyFilter,
+  isWakeEntry,
+  mentions,
+  wakesAgent,
   readEntries,
   readCursor,
   unread,
@@ -226,5 +293,8 @@ export {
   migrateLegacy,
   resolveChannel,
   readActivity,
+  markUsageLimit,
+  clearUsageLimit,
+  usageLimited,
   writeActivity
 };

package/dist/chunk-OIZ4R5H7.mjs

@@ -0,0 +1,173 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  WAKE_HARNESSES,
+  wakeDrivers,
+  wakeStatus
+} from "./chunk-W6HM6F2U.mjs";
+import {
+  adapterFor,
+  registerAntigravityWake,
+  resolveSources
+} from "./chunk-5JSGA6OB.mjs";
+import {
+  CURSOR_DEFAULT_SESSION,
+  updateWakeSettings
+} from "./chunk-2AMWQ7RB.mjs";
+import {
+  SESSION_ID_PATTERN,
+  filesForDir,
+  stateRoot
+} from "./chunk-PN25BUQ4.mjs";
+import {
+  resetWakeDriver
+} from "./chunk-ZSKLNZWZ.mjs";
+import {
+  init_define_KHALA_BUNDLE
+} from "./chunk-EVT2DWNZ.mjs";
+
+// src/wake/cli.ts
+init_define_KHALA_BUNDLE();
+import * as fs from "node:fs/promises";
+import path from "node:path";
+var WAKE_USAGE = "usage: khala wake on|off|status|register [--driver <d>] [--harness <id>] [--json]";
+async function sessionIds(harness, env) {
+  try {
+    return (await fs.readdir(path.join(stateRoot(env), harness), { withFileTypes: true })).filter((entry) => entry.isDirectory() && SESSION_ID_PATTERN.test(entry.name)).map((entry) => entry.name);
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+async function setWake(harness, drivers, on, env) {
+  const root = stateRoot(env);
+  const at = (/* @__PURE__ */ new Date()).toISOString();
+  await updateWakeSettings(root, (settings) => {
+    for (const driver of drivers) {
+      const key = `${harness}/${driver}`;
+      if (on) {
+        settings.consent[key] = { at };
+        delete settings.off[key];
+      } else {
+        delete settings.consent[key];
+        settings.off[key] = { at };
+      }
+    }
+  });
+  if (on) for (const id of await sessionIds(harness, env)) {
+    for (const driver of drivers) {
+      const dir = filesForDir(path.join(root, harness, id)).dir;
+      await resetWakeDriver(dir, driver);
+      if (harness === "qwen" && driver === "socket") await fs.rm(path.join(dir, "qwen-receipt.json"), { force: true });
+    }
+  }
+}
+function consentLine(harness, drivers, on) {
+  if (harness === "antigravity" && on) return `Idle wake is on (${drivers.join(", ")}): native wake preserves drafts; terminal fallback requires an empty prompt. Wake and Sync continuation use billed model turns. Run \`khala wake off --harness antigravity\` to turn it off.`;
+  return on ? `Idle wake is on (${drivers.join(", ")}): Khala may send a fixed wake line into this agent's existing session when messages wait and ${harness === "muse" ? "the session is idle (through Muse\u2019s native monitor)" : "the prompt is empty"}. Run \`khala wake off --harness ${harness}\` to turn it off.` : `Idle wake is off for ${drivers.join(", ")}. Run \`khala wake on --harness ${harness}\` to turn it on.`;
+}
+async function currentSessionId(harness, env) {
+  const adapter = adapterFor(harness);
+  if (!adapter) return void 0;
+  const session = await resolveSources(adapter.sessionSources.filter((source) => source.kind !== "process"), void 0, env, { harness: adapter.id });
+  return session?.sessionId !== CURSOR_DEFAULT_SESSION ? session?.sessionId : void 0;
+}
+async function runWake(argv, deps = {}) {
+  const env = deps.env ?? process.env;
+  const out = deps.stdout ?? console.log;
+  const err = deps.stderr ?? console.error;
+  const [command, ...flags] = argv;
+  let harness;
+  let driver;
+  let json = false;
+  for (let i = 0; i < flags.length; i++) {
+    const flag = flags[i];
+    if (flag === "--json") json = true;
+    else if ((flag === "--harness" || flag === "--driver") && flags[i + 1] && !flags[i + 1].startsWith("--")) {
+      const value = flags[++i];
+      if (flag === "--harness") harness = value;
+      else driver = value;
+    } else {
+      err(WAKE_USAGE);
+      return 2;
+    }
+  }
+  if (command === "register") {
+    if (harness !== "antigravity" || driver || json) {
+      err(WAKE_USAGE);
+      return 2;
+    }
+    try {
+      await registerAntigravityWake(env);
+      out("Registered Antigravity native wake for this session.");
+      return 0;
+    } catch {
+      err("khala: Antigravity wake registration unavailable; run this command through the agent shell.");
+      return 1;
+    }
+  }
+  if (!["on", "off", "status"].includes(command ?? "")) {
+    err(WAKE_USAGE);
+    return 2;
+  }
+  if (harness && !WAKE_HARNESSES.includes(harness)) {
+    err(`Unknown harness ${harness}. Valid harnesses: ${WAKE_HARNESSES.join(", ")}`);
+    return 2;
+  }
+  const candidates = harness ? [harness] : WAKE_HARNESSES;
+  const valid = [...new Set(candidates.flatMap((id) => wakeDrivers(id).map((item) => item.id)))];
+  if (driver && !valid.includes(driver)) {
+    err(`Unknown driver ${driver}. Valid drivers: ${valid.join(", ") || "none"}`);
+    return 2;
+  }
+  if (!harness && command !== "status") {
+    for (const id of WAKE_HARNESSES) {
+      if (await currentSessionId(id, env) !== void 0) {
+        harness = id;
+        break;
+      }
+    }
+    if (!harness && driver) {
+      const matches = WAKE_HARNESSES.filter((id) => wakeDrivers(id).some((item) => item.id === driver));
+      if (matches.length === 1) harness = matches[0];
+    }
+    if (!harness) {
+      err(`Select --harness. Valid harnesses: ${WAKE_HARNESSES.join(", ")}`);
+      return 2;
+    }
+    if (driver && !wakeDrivers(harness).some((item) => item.id === driver)) {
+      err(`Unknown driver ${driver}. Valid drivers: ${wakeDrivers(harness).map((item) => item.id).join(", ") || "none"}`);
+      return 2;
+    }
+  }
+  const harnesses = harness ? [harness] : WAKE_HARNESSES;
+  if (command === "status") {
+    const rows = [];
+    for (const id of harnesses) {
+      const sessionId = await currentSessionId(id, env);
+      rows.push(...await wakeStatus(id, { env, ...sessionId ? { files: filesForDir(path.join(stateRoot(env), id, sessionId)), sessionId } : {} }));
+    }
+    const selected = driver ? rows.filter((row) => row.driver === driver) : rows;
+    out(json ? JSON.stringify(selected) : selected.map((row) => `${row.harness}	${row.driver}	${row.rung}	${row.state}	${row.reason}${row.remedy ? ` ${row.remedy}` : ""}${row.note ? ` ${row.note}` : ""}`).join("\n"));
+  } else {
+    const all = wakeDrivers(harness);
+    const selected = driver ? [driver] : command === "on" ? [all.find((item) => item.optIn)?.id ?? all[0]?.id].filter((id) => !!id) : all.map((item) => item.id);
+    if (!selected.length) {
+      err(`No wake drivers for ${harness}.`);
+      return 2;
+    }
+    await setWake(harness, selected, command === "on", env);
+    const message = consentLine(harness, selected, command === "on");
+    out(json ? JSON.stringify({ harness, drivers: selected, on: command === "on", message }) : message);
+  }
+  return 0;
+}
+var cli_default = runWake;
+
+export {
+  WAKE_USAGE,
+  sessionIds,
+  setWake,
+  consentLine,
+  runWake,
+  cli_default
+};