khala-cli 0.4.9 → 0.4.10

package/dist/{chunk-ITFD3JZS.mjs → chunk-5JSGA6OB.mjs}

@@ -1,25 +1,31 @@
 import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
 import {
   readPane
-} from "./chunk-QKWEZXR3.mjs";
+} from "./chunk-6AQVW5W7.mjs";
 import {
   CURSOR_DEFAULT_SESSION,
   CURSOR_WORKSPACE_ENV,
   createMuseMonitorDriver,
+  createQwenSocketDriver,
   cursorSessionId,
   driverAllowed,
   museCliPath,
   museMonitorInstruction,
   museStopWakeText,
   museWatchCommand,
-  readListeningMode
-} from "./chunk-NIX5F4LT.mjs";
+  qwenInboundAllowed,
+  qwenSession,
+  readListeningMode,
+  readWakeSettings,
+  verifyQwenTranscript
+} from "./chunk-2AMWQ7RB.mjs";
 import {
   listChannels,
   readActivity,
   readCursor,
-  unread
-} from "./chunk-TANCKTDK.mjs";
+  unread,
+  wakesAgent
+} from "./chunk-OEV5DFLW.mjs";
 import {
   HARNESS_REGISTRY,
   SESSION_ID_PATTERN,
@@ -27,25 +33,29 @@ import {
   ensureStateDir,
   isHarnessId,
   nearestNonShellAncestor,
+  openSessionDir,
   readJson,
   readProcess,
+  readProcessArguments,
   stateRoot,
   walkAncestors,
   writeJsonAtomic
-} from "./chunk-NPSQNCOY.mjs";
+} from "./chunk-PN25BUQ4.mjs";
 import {
+  CODEX_IDLE_WAKE_NOTICE,
   cancelAttempt,
   failAttempt,
   newNonce,
   readWakeState,
   recordAttempt,
+  resetWakeDriver,
   settleAttempts,
   wakeLine,
   withWakeLock
-} from "./chunk-K7V7X6WU.mjs";
+} from "./chunk-ZSKLNZWZ.mjs";
 import {
   init_define_KHALA_BUNDLE
-} from "./chunk-7R3EIDGR.mjs";
+} from "./chunk-EVT2DWNZ.mjs";
 
 // src/harness/index.ts
 init_define_KHALA_BUNDLE();
@@ -55,7 +65,14 @@ init_define_KHALA_BUNDLE();
 
 // src/harness/codecs/claude-style.ts
 init_define_KHALA_BUNDLE();
-var events = { SessionStart: "start", UserPromptSubmit: "prompt", PostToolUse: "tool", Stop: "stop" };
+
+// src/harness/adapter.ts
+init_define_KHALA_BUNDLE();
+var STOP_NUDGE = "Khala: channel messages are waiting. Call khala_read.";
+
+// src/harness/codecs/claude-style.ts
+var events = { SessionStart: "start", UserPromptSubmit: "prompt", PostToolUse: "tool", Stop: "stop", StopFailure: "limit" };
+var LIMIT_ERRORS = ["rate_limit", "billing_error"];
 var names = { prompt: "UserPromptSubmit", tool: "PostToolUse", stop: "Stop" };
 var claudeStyleCodec = {
   promptDeliversWithoutWake: true,
@@ -64,7 +81,7 @@ var claudeStyleCodec = {
   parse(stdin) {
     try {
       const input = JSON.parse(stdin);
-      if (!input || typeof input.session_id !== "string" || typeof input.hook_event_name !== "string" || !Object.hasOwn(events, input.hook_event_name) || input.stop_hook_active !== void 0 && typeof input.stop_hook_active !== "boolean") return null;
+      if (!input || typeof input.session_id !== "string" || typeof input.hook_event_name !== "string" || !Object.hasOwn(events, input.hook_event_name) || input.stop_hook_active !== void 0 && typeof input.stop_hook_active !== "boolean" || input.hook_event_name === "StopFailure" && !LIMIT_ERRORS.includes(input.error)) return null;
       return {
         sessionId: input.session_id,
         event: events[input.hook_event_name],
@@ -78,10 +95,11 @@ var claudeStyleCodec = {
     }
   },
   noop: () => "",
-  render(kind, frame) {
-    return JSON.stringify(kind === "stop" ? { decision: "block", reason: frame } : { hookSpecificOutput: { hookEventName: names[kind], additionalContext: frame } }) + "\n";
+  render(kind, frame, stopContext = false) {
+    return JSON.stringify(kind === "stop" && !stopContext ? { decision: "block", reason: STOP_NUDGE } : { hookSpecificOutput: { hookEventName: names[kind], additionalContext: frame } }) + "\n";
   }
 };
+var claudeCodec = { ...claudeStyleCodec, stopContextFloor: "2.1.307" };
 
 // src/wake/terminal/driver.ts
 init_define_KHALA_BUNDLE();
@@ -145,7 +163,7 @@ var runTerminalCommand = async (command, argv, env, signal) => {
   const { stdout } = await exec(command, [...argv], { env, signal, timeout: 5e3, maxBuffer: 1024 * 1024, shell: false });
   return stdout;
 };
-async function ownsTerminal(pid, tty, env, signal, run = runTerminalCommand, platform = process.platform) {
+async function ownsTerminal(pid, tty, env, signal, run2 = runTerminalCommand, platform = process.platform) {
   if (!Number.isSafeInteger(pid) || pid <= 0 || !/^\/dev\/(?:pts\/\d+|tty[^\s/]+)$/.test(tty)) return false;
   try {
     if (platform === "linux") {
@@ -160,7 +178,7 @@ async function ownsTerminal(pid, tty, env, signal, run = runTerminalCommand, pla
       return ttyNr !== 0 && ttyNr === encoded && pgid > 0 && pgid === tpgid;
     }
     if (platform === "darwin") {
-      const output = await run("ps", ["-o", "tty=,pgid=,tpgid=", "-p", String(pid)], { ...env, LC_ALL: "C" }, signal);
+      const output = await run2("ps", ["-o", "tty=,pgid=,tpgid=", "-p", String(pid)], { ...env, LC_ALL: "C" }, signal);
       const match = /^\s*(\S+)\s+(\d+)\s+(\d+)\s*$/.exec(output);
       return !!match && `/dev/${match[1]}` === tty && Number(match[2]) > 0 && match[2] === match[3];
     }
@@ -174,8 +192,8 @@ init_define_KHALA_BUNDLE();
 function tmuxArgv(pane, argv) {
   return [...pane.socket ? ["-S", pane.socket] : [], ...argv];
 }
-async function inspectTmux(pane, run, env, signal, readProcess2) {
-  const query = await run("tmux", tmuxArgv(pane, [
+async function inspectTmux(pane, run2, env, signal, readProcess2) {
+  const query = await run2("tmux", tmuxArgv(pane, [
     "display-message",
     "-p",
     "-t",
@@ -187,7 +205,7 @@ async function inspectTmux(pane, run, env, signal, readProcess2) {
   const pid = Number(fields[0]), cursorX = Number(fields[3]), cursorY = Number(fields[4]);
   if (!Number.isSafeInteger(pid) || pid <= 0 || !Number.isSafeInteger(cursorX) || cursorX < 0 || !Number.isSafeInteger(cursorY) || cursorY < 0 || !fields[5]) return null;
   if (pid !== pane.agentPid && !(await ancestors(pane.agentPid, readProcess2)).some((parent) => parent.pid === pid)) return null;
-  const line = await run("tmux", tmuxArgv(pane, [
+  const line = await run2("tmux", tmuxArgv(pane, [
     "capture-pane",
     "-p",
     "-e",
@@ -200,21 +218,21 @@ async function inspectTmux(pane, run, env, signal, readProcess2) {
   ]), env, signal);
   return { tty: fields[5], cursorX, cursorY, line };
 }
-async function sendTmux(pane, text, enter, run, env, signal) {
-  await run("tmux", tmuxArgv(pane, ["send-keys", "-t", pane.paneId, ...enter ? ["Enter"] : ["-l", text]]), env, signal);
+async function sendTmux(pane, text, enter, run2, env, signal) {
+  await run2("tmux", tmuxArgv(pane, ["send-keys", "-t", pane.paneId, ...enter ? ["Enter"] : ["-l", text]]), env, signal);
 }
 
 // src/wake/terminal/wezterm.ts
 init_define_KHALA_BUNDLE();
-async function inspectWezterm(pane, run, env, signal) {
-  const rows = JSON.parse(await run("wezterm", ["cli", "list", "--format", "json"], env, signal));
+async function inspectWezterm(pane, run2, env, signal) {
+  const rows = JSON.parse(await run2("wezterm", ["cli", "list", "--format", "json"], env, signal));
   if (!Array.isArray(rows)) return { reason: "wezterm_pane_missing" };
   const row = rows.find((value) => value && typeof value === "object" && String(value.pane_id) === pane.paneId);
   if (!row) return { reason: "wezterm_pane_missing" };
   if (typeof row.tty_name !== "string" || !row.tty_name) return { reason: "wezterm_tty_unavailable" };
   if (!Number.isSafeInteger(row.cursor_x) || row.cursor_x < 0 || !Number.isSafeInteger(row.cursor_y) || row.cursor_y < 0)
     return { reason: "wezterm_cursor_unavailable" };
-  const line = await run("wezterm", [
+  const line = await run2("wezterm", [
     "cli",
     "get-text",
     "--pane-id",
@@ -228,8 +246,67 @@ async function inspectWezterm(pane, run, env, signal) {
   const captured = line.replace(/\r\n(?:\x1b(?:\[[0-9;:]*m|\(B))*\n$/, "").replace(/\x1b\(B/g, "");
   return { view: { tty: row.tty_name, cursorX: row.cursor_x, cursorY: row.cursor_y, line: captured } };
 }
-async function sendWezterm(pane, text, enter, run, env, signal) {
-  await run("wezterm", ["cli", "send-text", "--pane-id", pane.paneId, "--no-paste", enter ? "\r" : text], env, signal);
+async function sendWezterm(pane, text, enter, run2, env, signal) {
+  await run2("wezterm", ["cli", "send-text", "--pane-id", pane.paneId, "--no-paste", enter ? "\r" : text], env, signal);
+}
+
+// src/wake/terminal/kitty.ts
+init_define_KHALA_BUNDLE();
+function kittyArgv(pane, args) {
+  if (!pane.socket?.startsWith("unix:") || pane.socket.length <= 5 || pane.socket.includes("\0")) throw new Error("kitty_unix_socket_required");
+  return ["@", "--to", pane.socket, ...args];
+}
+async function inspectKitty(pane, run2, env, signal, read) {
+  try {
+    const windows = JSON.parse(await run2("kitten", kittyArgv(pane, ["ls"]), env, signal));
+    const matches = windows.flatMap((os2) => os2.tabs.flatMap((tab) => tab.windows)).filter((window) => String(window.id) === pane.paneId);
+    if (matches.length !== 1) return { reason: "kitty_window_missing" };
+    const foreground = matches[0].foreground_processes;
+    if (!Array.isArray(foreground) || foreground.length === 0) return { reason: "kitty_foreground_unavailable" };
+    for (const process2 of foreground) {
+      if (!Number.isSafeInteger(process2.pid) || process2.pid <= 0 || process2.pid !== pane.agentPid && !(await ancestors(process2.pid, read)).some((parent) => parent.pid === pane.agentPid)) return { reason: "kitty_window_not_owned" };
+    }
+    const ttyName = (await run2("ps", ["-o", "tty=", "-p", String(foreground[0].pid)], { ...env, LC_ALL: "C" }, signal)).trim();
+    if (!/^(?:pts\/\d+|tty[^\s/]+)$/.test(ttyName)) return { reason: "kitty_tty_unavailable" };
+    const screen = await run2("kitten", kittyArgv(pane, ["get-text", "--match", `id:${pane.paneId}`, "--extent", "screen", "--ansi", "--add-cursor"]), env, signal);
+    const cursor2 = /\x1b\[\?25[hl]\x1b\[(\d+);(\d+)H(?:\x1b\[\?12[hl]|\x1b\[[1-6] q)\n?$/.exec(screen);
+    if (!cursor2) return { reason: "kitty_cursor_unavailable" };
+    const cursorY = Number(cursor2[1]) - 1, cursorX = Number(cursor2[2]) - 1;
+    const rows = screen.slice(0, cursor2.index).split("\n");
+    if (!Number.isSafeInteger(cursorX) || cursorX < 0 || !Number.isSafeInteger(cursorY) || cursorY < 0 || cursorY >= rows.length)
+      return { reason: "kitty_cursor_unavailable" };
+    const styling = rows.slice(0, cursorY).join("\n").match(/\x1b\[[0-9;:]*m/g)?.join("") ?? "";
+    return { view: { tty: `/dev/${ttyName}`, cursorX, cursorY, line: styling + rows[cursorY] } };
+  } catch (error) {
+    return { reason: error instanceof Error && error.message === "kitty_unix_socket_required" ? error.message : "kitty_probe_failed" };
+  }
+}
+async function sendKitty(pane, text, enter, run2, env, signal) {
+  await run2("kitten", kittyArgv(pane, ["send-text", "--match", `id:${pane.paneId}`, "--", enter ? "\\r" : text.replace(/\\/g, "\\\\")]), env, signal);
+}
+
+// src/wake/terminal/iterm2.ts
+init_define_KHALA_BUNDLE();
+import { fileURLToPath } from "node:url";
+function iterm2ScriptPath() {
+  return fileURLToPath(new URL("./iterm2_send.py", import.meta.url));
+}
+async function inspectIterm2(pane, run2, env, signal) {
+  try {
+    const view = JSON.parse(await run2("python3", [iterm2ScriptPath(), pane.paneId], env, signal));
+    if (view.reason) return { reason: view.reason };
+    if (typeof view.tty !== "string" || !/^\/dev\/tty[^\s/]+$/.test(view.tty)) return { reason: "iterm2_tty_unavailable" };
+    if (typeof view.line !== "string" || !Number.isSafeInteger(view.cursorX) || view.cursorX < 0 || !Number.isSafeInteger(view.cursorY) || view.cursorY < 0) return { reason: "iterm2_cursor_unavailable" };
+    return { view };
+  } catch {
+    return { reason: "iterm2_python_api_unavailable" };
+  }
+}
+async function sendIterm2(pane, text, enter, run2, env, signal, expected) {
+  if (!expected) return "skipped";
+  const result = JSON.parse(await run2("python3", [iterm2ScriptPath(), pane.paneId, enter ? "\r" : text, JSON.stringify(expected)], env, signal));
+  if (result.status === "not_empty") return "skipped";
+  if (result.status !== "sent") throw new Error("iterm2_send_failed");
 }
 
 // src/wake/terminal/driver.ts
@@ -237,7 +314,7 @@ function promptPrefix(captured, cursorColumn) {
   return captured.replace(/\x1b\[[0-9;]*m/g, "").replace(/\r?\n$/, "").slice(0, cursorColumn).padEnd(cursorColumn, " ");
 }
 function createTerminalWakeDriver(guard, deps = {}) {
-  const run = deps.run ?? runTerminalCommand;
+  const run2 = deps.run ?? runTerminalCommand;
   const read = deps.readProcess ?? readProcess;
   const platform = deps.platform ?? process.platform;
   const probe = async (ctx, empty, cleanup = false) => {
@@ -247,15 +324,16 @@ function createTerminalWakeDriver(guard, deps = {}) {
     if (!cleanup && !await driverAllowed(stateRoot(ctx.env), ctx.harness, "terminal", true)) return { reason: "terminal_consent_required" };
     if (!cleanup && (await readWakeState(ctx.files.dir)).terminal?.disabled) return { reason: "nonce_timeout" };
     const pane = await readPane(ctx.files);
-    if (!pane) return { reason: ctx.harness === "codex" && (ctx.env.TMUX || ctx.env.WEZTERM_PANE) ? "terminal_capture_pending_prompt" : "no remote-control API" };
+    if (!pane) return { reason: ctx.env.ITERM_SESSION_ID && !/^w\d+t\d+p\d+:[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i.test(ctx.env.ITERM_SESSION_ID) ? "iterm2_session_id_invalid" : ctx.harness === "codex" && (ctx.env.TMUX || ctx.env.WEZTERM_PANE || ctx.env.KITTY_WINDOW_ID || ctx.env.ITERM_SESSION_ID) ? "terminal_capture_pending_prompt" : ctx.env.ITERM_SESSION_ID ? "iterm2_session_id_invalid" : "no remote-control API" };
     const activity = await readActivity(ctx.files);
     if (!cleanup && (activity.state !== "idle" || ctx.now - Date.parse(activity.updatedAt) < 3e4)) return { reason: "terminal_not_idle" };
     const agent = await read(pane.agentPid);
     if (!agent || pane.agentStartTime !== void 0 && pane.agentStartTime !== agent.startTime) return { reason: "terminal_agent_exited" };
-    const inspection = pane.kind === "tmux" ? { view: await inspectTmux(pane, run, ctx.env, ctx.signal, read) ?? void 0 } : await inspectWezterm(pane, run, ctx.env, ctx.signal);
+    if (pane.kind === "iterm2" && platform !== "darwin") return { reason: "iterm2_requires_macos" };
+    const inspection = pane.kind === "tmux" ? { view: await inspectTmux(pane, run2, ctx.env, ctx.signal, read) ?? void 0 } : pane.kind === "kitty" ? await inspectKitty(pane, run2, ctx.env, ctx.signal, read) : pane.kind === "iterm2" ? await inspectIterm2(pane, run2, ctx.env, ctx.signal) : await inspectWezterm(pane, run2, ctx.env, ctx.signal);
     const view = inspection.view;
     if (!view) return { reason: inspection.reason ?? "terminal_pane_unsafe" };
-    if (!await (deps.ownsTerminal ?? ownsTerminal)(pane.agentPid, view.tty, ctx.env, ctx.signal, run, platform))
+    if (!await (deps.ownsTerminal ?? ownsTerminal)(pane.agentPid, view.tty, ctx.env, ctx.signal, run2, platform))
       return { reason: "terminal_pane_not_owned" };
     if (empty && !isEmptyPrompt(view.line, view.cursorX, guard)) return { reason: "terminal_prompt_not_empty" };
     return { pane, view };
@@ -284,8 +362,8 @@ function createTerminalWakeDriver(guard, deps = {}) {
       if (!ready.pane || ctx.signal.aborted) return "skipped";
       const beforeSend = await readActivity(ctx.files);
       if (beforeSend.state !== "idle" || beforeSend.updatedAt !== activity.updatedAt) return "skipped";
-      const send = ready.pane.kind === "tmux" ? sendTmux : sendWezterm;
-      await send(ready.pane, line, false, run, ctx.env, ctx.signal);
+      const send = ready.pane.kind === "tmux" ? sendTmux : ready.pane.kind === "kitty" ? sendKitty : ready.pane.kind === "iterm2" ? sendIterm2 : sendWezterm;
+      if (await send(ready.pane, line, false, run2, ctx.env, ctx.signal, ready.view) === "skipped") return "skipped";
       const sameComposer = (final2) => {
         if (!final2.pane || !final2.view || final2.pane.agentPid !== ready.pane.agentPid || final2.pane.agentStartTime !== ready.pane.agentStartTime || final2.pane.capturedAt !== ready.pane.capturedAt || final2.view.tty !== ready.view.tty || final2.pane.kind !== ready.pane.kind || final2.pane.paneId !== ready.pane.paneId || final2.pane.socket !== ready.pane.socket) return false;
         const text = final2.view.line.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \r\n]+$/, "");
@@ -296,7 +374,7 @@ function createTerminalWakeDriver(guard, deps = {}) {
         const current2 = await safeProbe(cleanupCtx, false, true);
         if (!sameComposer(current2)) return;
         if (current2.pane.kind === "tmux") {
-          await run("tmux", tmuxArgv(current2.pane, [
+          await run2("tmux", tmuxArgv(current2.pane, [
             "send-keys",
             "-t",
             current2.pane.paneId,
@@ -305,7 +383,7 @@ function createTerminalWakeDriver(guard, deps = {}) {
             "BSpace"
           ]), ctx.env, cleanupCtx.signal);
         } else {
-          await sendWezterm(current2.pane, "\x7F".repeat(line.length), false, run, ctx.env, cleanupCtx.signal);
+          await send(current2.pane, "\x7F".repeat(line.length), false, run2, ctx.env, cleanupCtx.signal, current2.view);
         }
       };
       try {
@@ -328,7 +406,13 @@ function createTerminalWakeDriver(guard, deps = {}) {
         }
         return;
       }
-      await send(final.pane, line, true, run, ctx.env, ctx.signal);
+      if (await send(final.pane, line, true, run2, ctx.env, ctx.signal, final.view) === "skipped") {
+        try {
+          await cleanup();
+        } finally {
+          await failAttempt(ctx.files.dir, nonce, ctx.now + 500);
+        }
+      }
     }
   };
 }
@@ -354,7 +438,7 @@ var emptyPrompt = { pattern: /^❯[\u00a0 ]?(Try ".*")?$/u, cursorColumn: 2 };
 var claude = {
   id: "claude",
   sessionSources: [{ kind: "env", resolve: (_meta, env) => env.CLAUDE_CODE_SESSION_ID, rejoinable: () => true }],
-  codec: claudeStyleCodec,
+  codec: claudeCodec,
   restoreAtStartup: true,
   watcherStatus: true,
   emptyPrompt,
@@ -444,9 +528,10 @@ function createCodexQueueProcessPort(deps) {
 // src/wake/codex-probe.ts
 init_define_KHALA_BUNDLE();
 import { execFile as execFile2 } from "node:child_process";
-import { access, realpath, stat as stat2 } from "node:fs/promises";
+import { access, mkdtemp, realpath, rm, stat as stat2 } from "node:fs/promises";
 import { constants } from "node:fs";
 import path2 from "node:path";
+import os from "node:os";
 import { promisify as promisify2 } from "node:util";
 var execute = promisify2(execFile2);
 var probes = /* @__PURE__ */ new Map();
@@ -473,9 +558,18 @@ async function probeCodexQueue(env) {
   if (cached?.mtime === mtime) return cached.result;
   const binary = command;
   const result = (async () => {
+    let probeHome;
     try {
+      probeHome = await mkdtemp(path2.join(os.tmpdir(), "khala-codex-probe-"));
       const { stdout } = await execute(binary, ["queue", "--help"], {
-        env: scrubbedQueueEnv(env),
+        env: {
+          ...scrubbedQueueEnv(env),
+          HOME: probeHome,
+          CODEX_HOME: probeHome,
+          XDG_CONFIG_HOME: probeHome,
+          XDG_DATA_HOME: probeHome,
+          XDG_STATE_HOME: probeHome
+        },
         timeout: 5e3,
         killSignal: "SIGKILL",
         maxBuffer: 64 * 1024,
@@ -484,6 +578,8 @@ async function probeCodexQueue(env) {
       return /--thread\b/.test(stdout) && /--message\b/.test(stdout) ? { available: true, command: binary } : { available: false, reason: "codex_queue_unavailable" };
     } catch {
       return { available: false, reason: "codex_queue_unavailable" };
+    } finally {
+      if (probeHome) await rm(probeHome, { recursive: true, force: true });
     }
   })();
   probes.set(binary, { mtime, result });
@@ -515,14 +611,8 @@ function createWakeLadder(deps) {
   };
   const evaluate = async () => {
     try {
-      for (const driver2 of deps.drivers) await driver2.verify?.({
-        files: deps.files,
-        harness: deps.harness,
-        sessionId: deps.sessionId,
-        env: deps.env ?? process.env,
-        signal: controller.signal,
-        now: now()
-      });
+      const verificationCtx = { files: deps.files, harness: deps.harness, sessionId: deps.sessionId, env: deps.env ?? process.env, signal: controller.signal, now: now() };
+      for (const driver2 of deps.drivers) await driver2.verify?.(verificationCtx);
       if (deps.drivers.some((driver2) => driver2.verification !== "none")) await settleAttempts(deps.files.dir, { now: now(), activity: await readActivity(deps.files) });
       const driverStates = await readWakeState(deps.files.dir);
       for (const [id, state] of Object.entries(driverStates)) {
@@ -539,10 +629,12 @@ function createWakeLadder(deps) {
         const session = await readJson(channel.files.session);
         const metadata = channel.legacy ? null : await readJson(path3.join(channel.files.dir, "channel.json"));
         currentIdentities.set(channel.key, JSON.stringify([session?.roomId ?? channel.roomId, session?.userId, metadata?.joinedAt]));
-        if (await readListeningMode(channel.files) === "async") continue;
+        const mode = await readListeningMode(channel.files);
+        if (mode === "async") continue;
+        const you = (await readJson(channel.files.status))?.displayName;
         eligible.push({
           channel,
-          counts: { messages: (await unread(channel.files)).entries.filter((entry) => entry.kind === "message" && entry.sender !== session?.userId).length },
+          counts: { messages: (await unread(channel.files)).entries.filter((entry) => entry.sender !== session?.userId && wakesAgent(entry, mode, you)).length },
           cursor: await readCursor(channel.files)
         });
       }
@@ -608,9 +700,9 @@ function createWakeLadder(deps) {
       const attemptAt = now();
       const nonce = newNonce();
       if (driver.verification !== "none") {
-        await recordAttempt(deps.files.dir, { nonce, driver: driver.id, at: attemptAt, deadline: attemptAt + driver.deadlineMs, activityUpdatedAt: activity.updatedAt, ...driver.startsActivity ? { startsActivity: true } : {} });
+        await recordAttempt(deps.files.dir, { nonce, driver: driver.id, at: attemptAt, deadline: attemptAt + driver.deadlineMs, activityUpdatedAt: activity.updatedAt, ...driver.startsActivity ? { startsActivity: true } : {}, ...driver.verification === "transcript" ? { verification: "transcript" } : {} });
         if (!await stillEligible()) {
-          await settleAttempts(deps.files.dir, { now: now(), activity: await readActivity(deps.files), promptText: "" });
+          await cancelAttempt(deps.files.dir, nonce);
           return;
         }
       }
@@ -707,7 +799,7 @@ var codexWakeDriver = createCodexWakeDriver();
 
 // src/harness/codex.ts
 var emptyPrompt2 = { pattern: /^› ?(Ask Codex to do anything)?$/u, cursorColumn: 2 };
-var install = async (flags, deps) => (await import("./chunk-BLCRVRIK.mjs")).runCodexInstall(flags, deps);
+var install = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runCodexInstall(flags, deps);
 var codex = {
   id: "codex",
   // A string metadata id wins even when empty or invalid; validation happens after selection.
@@ -739,11 +831,11 @@ async function recordHookSession(harness, sessionId, env, options = {}) {
   if (!parent) return;
   const dir = mappingDir(harness, env);
   await ensureStateDir(dir);
-  const file2 = path4.join(dir, `${parent.pid}.json`);
+  const file3 = path4.join(dir, `${parent.pid}.json`);
   const at = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
-  const previous = await readJson(file2);
+  const previous = await readJson(file3);
   if (previous?.startTime === parent.startTime && typeof previous.at === "string" && previous.at > at) return;
-  await writeJsonAtomic(file2, {
+  await writeJsonAtomic(file3, {
     sessionId,
     startTime: parent.startTime,
     at,
@@ -789,7 +881,7 @@ async function resolveSources(sources, meta, env, context) {
 }
 
 // src/harness/muse.ts
-var install2 = async (flags, deps) => (await import("./chunk-BLCRVRIK.mjs")).runMuseInstall(flags, deps);
+var install2 = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runMuseInstall(flags, deps);
 var muse = {
   id: "muse",
   sessionSources: [{ kind: "env", resolve: (_meta, env) => env.MUSE_SESSION_ID, rejoinable: () => true }, hookMapSource],
@@ -844,7 +936,7 @@ function createCopilotCodec(event) {
     },
     noop: () => "{}\n",
     render(kind, frame) {
-      return JSON.stringify(kind === "stop" ? { decision: "block", reason: frame } : kind === "tool" ? { additionalContext: frame } : {}) + "\n";
+      return JSON.stringify(kind === "stop" ? { decision: "block", reason: STOP_NUDGE } : kind === "tool" ? { additionalContext: frame } : {}) + "\n";
     }
   };
 }
@@ -852,10 +944,10 @@ var copilotCodec = createCopilotCodec();
 
 // src/harness/copilot.ts
 var emptyPrompt3 = { pattern: /^❯ ?$/u, cursorColumn: 2 };
-var install3 = async (flags, deps) => (await import("./chunk-BLCRVRIK.mjs")).runCopilotInstall(flags, deps);
+var install3 = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runCopilotInstall(flags, deps);
 var copilot = {
   id: "copilot",
-  sessionSources: [hookMapSource],
+  sessionSources: [{ kind: "env", resolve: (_meta, env) => env.COPILOT_AGENT_SESSION_ID, rejoinable: () => true }, hookMapSource],
   codec: copilotCodec,
   restoreAtStartup: true,
   install: install3,
@@ -895,12 +987,12 @@ var cursorCodec = {
   noop: (kind) => JSON.stringify(kind === "prompt" ? { continue: true } : {}) + "\n",
   render(kind, frame) {
     if (kind === "prompt") return cursorCodec.noop(kind);
-    return JSON.stringify(kind === "stop" ? { followup_message: frame } : { additional_context: frame }) + "\n";
+    return JSON.stringify(kind === "stop" ? { followup_message: STOP_NUDGE } : { additional_context: frame }) + "\n";
   }
 };
 
 // src/harness/cursor.ts
-var install4 = async (flags, deps) => (await import("./chunk-BLCRVRIK.mjs")).runCursorInstall(flags, deps);
+var install4 = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runCursorInstall(flags, deps);
 var cursor = {
   id: "cursor",
   sessionSources: [{
@@ -914,6 +1006,56 @@ var cursor = {
   uninstall: (flags, deps) => install4([...flags, "--uninstall"], deps)
 };
 
+// src/harness/qwen.ts
+init_define_KHALA_BUNDLE();
+import path5 from "node:path";
+var qwenCodec = {
+  ...claudeStyleCodec,
+  parse(stdin) {
+    try {
+      if (JSON.parse(stdin)?.agent_id !== void 0) return null;
+    } catch {
+      return null;
+    }
+    return claudeStyleCodec.parse(stdin);
+  }
+};
+function createQwenBackgroundDriver(platform = process.platform) {
+  return {
+    id: "background-shell",
+    rung: 2,
+    optIn: false,
+    minIdleMs: 0,
+    deadlineMs: 3e4,
+    verification: "none",
+    async available(ctx) {
+      const settings = await readWakeSettings(stateRoot(ctx.env));
+      return platform === "win32" && !settings.off["qwen/socket"] && !settings.off["qwen/background-shell"] && await qwenInboundAllowed(ctx.env) && await (await import("./chunk-CHC4VZF5.mjs")).monitorArmed(ctx.files);
+    },
+    async unavailableReason(ctx) {
+      if (!await qwenInboundAllowed(ctx.env)) return "qwen_held";
+      return platform === "win32" ? "qwen_watcher_missing" : "driver_missing";
+    },
+    // Qwen itself owns the background tool. Khala never launches or injects input.
+    wake: () => "skipped"
+  };
+}
+var qwen = {
+  id: "qwen",
+  codec: qwenCodec,
+  restoreAtStartup: true,
+  sessionSources: [{ kind: "meta", resolve: (meta) => meta?.khala_session, rejoinable: () => true }, { kind: "env", resolve: (_meta, env) => qwenSession(env), rejoinable: () => true }, hookMapSource],
+  install: async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runQwenInstall(flags, deps),
+  uninstall: async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runQwenInstall([...flags, "--uninstall"], deps),
+  wakeLadder: [createQwenSocketDriver(), createQwenBackgroundDriver()],
+  async verifyWake(stdin, files, now) {
+    const input = JSON.parse(stdin);
+    if (typeof input.transcript_path !== "string") return;
+    await writeJsonAtomic(path5.join(files.dir, "qwen-transcript.json"), { path: input.transcript_path });
+    if (input.hook_event_name === "Stop") await verifyQwenTranscript(files.dir, input.transcript_path, now);
+  }
+};
+
 // src/harness/gemini.ts
 init_define_KHALA_BUNDLE();
 
@@ -942,13 +1084,13 @@ var geminiCodec = {
   },
   noop: (kind) => JSON.stringify(kind === "stop" ? { decision: "allow" } : {}) + "\n",
   render(kind, frame) {
-    return JSON.stringify(kind === "stop" ? { decision: "deny", reason: frame } : { hookSpecificOutput: { hookEventName: names2[kind], additionalContext: frame } }) + "\n";
+    return JSON.stringify(kind === "stop" ? { decision: "deny", reason: STOP_NUDGE } : { hookSpecificOutput: { hookEventName: names2[kind], additionalContext: frame } }) + "\n";
   }
 };
 
 // src/harness/gemini.ts
 var emptyPrompt4 = { pattern: /^ >(?: {3}Type your message or @path\/to\/file)?$/u, cursorColumn: 3 };
-var install5 = async (flags, deps) => (await import("./chunk-BLCRVRIK.mjs")).runGeminiInstall(flags, deps);
+var install5 = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runGeminiInstall(flags, deps);
 var gemini = {
   id: "gemini",
   sessionSources: [{ kind: "env", resolve: (_meta, env) => env.GEMINI_SESSION_ID, rejoinable: () => true }, hookMapSource],
@@ -961,6 +1103,207 @@ var gemini = {
   wakeWarningName: "gemini"
 };
 
+// src/harness/antigravity.ts
+init_define_KHALA_BUNDLE();
+
+// src/harness/codecs/antigravity.ts
+init_define_KHALA_BUNDLE();
+var antigravityCodec = {
+  promptDeliversWithoutWake: false,
+  promptAcceptsContext: false,
+  suppressOutputErrors: false,
+  parse(stdin) {
+    try {
+      const input = JSON.parse(stdin.replace(/^\uFEFF/u, ""));
+      if (!input || typeof input.conversationId !== "string") return null;
+      let event;
+      if (input.khalaHookEvent === "PreInvocation" && Number.isInteger(input.invocationNum) && input.invocationNum >= 0)
+        event = input.invocationNum === 0 ? "prompt" : "tool";
+      else if (input.khalaHookEvent === "Stop") event = "stop";
+      else return null;
+      return {
+        sessionId: input.conversationId,
+        event,
+        continuation: false,
+        ...typeof input.transcriptPath === "string" ? { transcriptPath: input.transcriptPath } : {},
+        ...typeof input.workspacePaths?.[0] === "string" ? { workspace: input.workspacePaths[0] } : {}
+      };
+    } catch {
+      return null;
+    }
+  },
+  noop: (kind) => JSON.stringify(kind === "stop" ? { decision: "stop" } : {}) + "\n",
+  render: (kind, frame) => JSON.stringify(kind === "stop" ? { decision: "continue", reason: STOP_NUDGE } : { injectSteps: [{ ephemeralMessage: frame }] }) + "\n"
+};
+
+// src/wake/antigravity.ts
+init_define_KHALA_BUNDLE();
+import * as fs from "node:fs/promises";
+import { constants as constants2 } from "node:fs";
+import path6 from "node:path";
+import { execFile as execFile3 } from "node:child_process";
+var file = "antigravity-wake.json";
+var localAddress = (value) => typeof value === "string" && /^(?:localhost|127\.0\.0\.1|\[::1\]):([0-9]{1,5})$/u.test(value) && Number(value.slice(value.lastIndexOf(":") + 1)) > 0 && Number(value.slice(value.lastIndexOf(":") + 1)) <= 65535;
+async function credentials(files, sessionId) {
+  let value;
+  try {
+    await ensureStateDir(files.dir);
+    const handle = await fs.open(path6.join(files.dir, file), constants2.O_RDONLY | constants2.O_NONBLOCK | constants2.O_NOFOLLOW);
+    try {
+      const stat4 = await handle.stat();
+      if (!stat4.isFile() || stat4.size > 16 * 1024 || process.platform !== "win32" && (stat4.mode & 63) !== 0 || typeof process.getuid === "function" && stat4.uid !== process.getuid()) return null;
+      value = JSON.parse(await handle.readFile("utf8"));
+    } finally {
+      await handle.close();
+    }
+  } catch {
+    return null;
+  }
+  return value && value.sessionId === sessionId && localAddress(value.address) && typeof value.token === "string" && value.token.length > 0 && !/[\r\n\0]/u.test(value.token) && typeof value.command === "string" && (path6.isAbsolute(value.command) || value.command === "agy") ? value : null;
+}
+async function stableAgyCommand(env) {
+  for (const dir of (env.PATH ?? "").split(path6.delimiter).filter(Boolean)) {
+    for (const name of process.platform === "win32" ? ["agy.exe", "agy.cmd", "agy"] : ["agy"]) {
+      const candidate = path6.resolve(dir, name);
+      try {
+        await fs.access(candidate, constants2.X_OK);
+        if ((await fs.stat(candidate)).isFile()) return candidate;
+      } catch {
+      }
+    }
+  }
+  return env.ANTIGRAVITY_AGENTAPI_EXE || "agy";
+}
+async function registerAntigravityWake(env) {
+  const sessionId = env.ANTIGRAVITY_CONVERSATION_ID;
+  const address = env.ANTIGRAVITY_LS_ADDRESS;
+  const token = env.ANTIGRAVITY_CSRF_TOKEN;
+  const command = await stableAgyCommand(env);
+  if (!sessionId || !SESSION_ID_PATTERN.test(sessionId) || !localAddress(address) || !token || /[\r\n\0]/u.test(token) || !(path6.isAbsolute(command) || command === "agy")) throw new Error("antigravity_registration_unavailable");
+  const files = await openSessionDir("antigravity", sessionId, env);
+  await withWakeLock(files.dir, "antigravity-credentials.lock", async () => {
+    await writeJsonAtomic(path6.join(files.dir, file), { sessionId, address, token, command });
+    await resetWakeDriver(files.dir, "antigravity-native");
+  });
+}
+var run = (command, argv, env, signal) => new Promise((resolve) => {
+  execFile3(command, [...argv], { env, signal, timeout: 1e4, maxBuffer: 64 * 1024, windowsHide: true }, (error) => resolve(!error));
+});
+function createAntigravityWakeDriver(execute2 = run) {
+  return {
+    id: "antigravity-native",
+    rung: 1,
+    optIn: true,
+    minIdleMs: 0,
+    deadlineMs: 3e4,
+    verification: "nonce",
+    async available(ctx) {
+      const value = await credentials(ctx.files, ctx.sessionId);
+      return !!value && !value.rejected;
+    },
+    async unavailableReason(ctx) {
+      const value = await credentials(ctx.files, ctx.sessionId);
+      return value?.rejected ? "antigravity_credentials_rejected" : "antigravity_credentials_missing";
+    },
+    async wake(ctx, line) {
+      if (!line.startsWith(CODEX_IDLE_WAKE_NOTICE + " ") || !/^\(k-[0-9a-f]{8}\)$/u.test(line.slice(CODEX_IDLE_WAKE_NOTICE.length + 1))) throw new Error("invalid_wake_line");
+      const value = await credentials(ctx.files, ctx.sessionId);
+      if (!value || value.rejected || ctx.signal.aborted || (await readActivity(ctx.files)).state !== "idle") return "skipped";
+      let accepted = false;
+      try {
+        accepted = await execute2(
+          value.command,
+          ["agentapi", "send-message", ctx.sessionId, line],
+          { ...ctx.env, ANTIGRAVITY_LS_ADDRESS: value.address, ANTIGRAVITY_CSRF_TOKEN: value.token },
+          ctx.signal
+        );
+      } catch {
+      }
+      if (!accepted && !ctx.signal.aborted) {
+        await withWakeLock(ctx.files.dir, "antigravity-credentials.lock", async () => {
+          const current = await credentials(ctx.files, ctx.sessionId);
+          if (current?.token === value.token && current.address === value.address) await writeJsonAtomic(path6.join(ctx.files.dir, file), { ...value, rejected: true });
+        });
+        return "skipped";
+      }
+    }
+  };
+}
+async function antigravityPromptText(input) {
+  if (!input.transcriptPath) return void 0;
+  let handle;
+  try {
+    handle = await fs.open(input.transcriptPath, constants2.O_RDONLY | constants2.O_NONBLOCK);
+    const stat4 = await handle.stat();
+    if (!stat4.isFile()) return void 0;
+    const length = Math.min(stat4.size, 64 * 1024), start = stat4.size - length;
+    const buffer = Buffer.alloc(length);
+    const { bytesRead } = await handle.read(buffer, 0, length, start);
+    let tail = buffer.subarray(0, bytesRead).toString("utf8");
+    if (start > 0) tail = tail.slice(tail.indexOf("\n") + 1);
+    return tail.split("\n").flatMap((line) => {
+      try {
+        const step = JSON.parse(line);
+        if (typeof step.content !== "string") return [];
+        if (step.source === "USER_EXPLICIT" && step.type === "USER_INPUT") {
+          const nonce = step.content.match(/\(k-([0-9a-f]{8})\)$/u)?.[1];
+          return nonce && wakeLine(nonce) === step.content ? [step.content] : [];
+        }
+        if (step.source !== "SYSTEM" || step.type !== "SYSTEM_MESSAGE") return [];
+        return step.content.split(CODEX_IDLE_WAKE_NOTICE + " ").slice(1).flatMap((suffix) => {
+          const nonce = suffix.match(/^\(k-[0-9a-f]{8}\)/u)?.[0];
+          return nonce ? [CODEX_IDLE_WAKE_NOTICE + " " + nonce] : [];
+        });
+      } catch {
+        return [];
+      }
+    }).join("\n") || void 0;
+  } catch {
+    return void 0;
+  } finally {
+    await handle?.close().catch(() => {
+    });
+  }
+}
+
+// src/harness/antigravity.ts
+var emptyPrompt5 = { pattern: /^>$/u, cursorColumn: 2 };
+var install6 = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runAntigravityInstall(flags, deps);
+var antigravity = {
+  id: "antigravity",
+  restoreAtStartup: true,
+  codec: antigravityCodec,
+  sessionSources: [
+    { kind: "meta", resolve: (meta) => meta?.["antigravity.google/conversation_id"], rejoinable: () => true },
+    { kind: "env", resolve: (_meta, env) => env.ANTIGRAVITY_CONVERSATION_ID, rejoinable: () => true },
+    {
+      kind: "process",
+      rejoinable: () => true,
+      async resolve(_meta, _env, context) {
+        const read = context.readProcess ?? readProcess;
+        for await (const parent of walkAncestors(context.pid ?? process.pid, read)) {
+          if (!/^agy(?:\.exe)?$/iu.test(parent.command.split(/[\\/]/u).pop() ?? "")) continue;
+          const args = await (context.readArguments ?? readProcessArguments)(parent.pid);
+          if (!args || (await read(parent.pid))?.startTime !== parent.startTime) return null;
+          for (let i = 1; i < args.length; i++) {
+            if (args[i] === "--") break;
+            if (args[i] === "--conversation") return args[i + 1] ?? "";
+            if (args[i]?.startsWith("--conversation=")) return args[i].slice("--conversation=".length);
+          }
+          return null;
+        }
+        return null;
+      }
+    }
+  ],
+  install: install6,
+  uninstall: (flags, deps) => install6([...flags, "--uninstall"], deps),
+  emptyPrompt: emptyPrompt5,
+  wakeLadder: [createAntigravityWakeDriver(), createTerminalWakeDriver(emptyPrompt5)],
+  wakeWarningName: "antigravity",
+  hookPromptText: antigravityPromptText
+};
+
 // src/harness/opencode.ts
 init_define_KHALA_BUNDLE();
 
@@ -987,13 +1330,13 @@ var opencodeCodec = {
     }
   },
   noop: () => "",
-  render: (_kind, frame) => frame
+  render: (kind, frame) => kind === "stop" ? STOP_NUDGE : frame
 };
 
 // src/wake/opencode.ts
 init_define_KHALA_BUNDLE();
-import path5 from "node:path";
-var file = "opencode-wake.json";
+import path7 from "node:path";
+var file2 = "opencode-wake.json";
 async function budget(files) {
   const pairs = await Promise.all((await listChannels(files)).map(async (channel) => [channel.key, (await readCursor(channel.files)).deliveredCount]));
   return JSON.stringify(pairs.sort(([a], [b]) => a.localeCompare(b)));
@@ -1007,20 +1350,20 @@ var opencodeWakeDriver = {
   deadlineMs: 3e3,
   verification: "nonce",
   async available(ctx) {
-    const prior = await readJson(path5.join(ctx.files.dir, file));
+    const prior = await readJson(path7.join(ctx.files.dir, file2));
     return canAttempt(prior, await budget(ctx.files), ctx.now);
   },
   async wake(ctx, line) {
     return withWakeLock(ctx.files.dir, "opencode-native.lock", async () => {
       if (ctx.signal.aborted || (await readActivity(ctx.files)).state !== "idle") return "skipped";
       const key = await budget(ctx.files);
-      const prior = await readJson(path5.join(ctx.files.dir, file));
+      const prior = await readJson(path7.join(ctx.files.dir, file2));
       if (!canAttempt(prior, key, ctx.now)) return "skipped";
       const channels = [];
       for (const channel of await listChannels(ctx.files)) {
         if (await readListeningMode(channel.files) !== "async") channels.push(channel.key);
       }
-      await writeJsonAtomic(path5.join(ctx.files.dir, file), {
+      await writeJsonAtomic(path7.join(ctx.files.dir, file2), {
         line,
         at: ctx.now,
         budget: key,
@@ -1033,7 +1376,7 @@ var opencodeWakeDriver = {
 };
 async function pollOpenCodeWake(files, io, replay = false) {
   if (replay) return withWakeLock(files.dir, "opencode-native.lock", async () => {
-    const pending = await readJson(path5.join(files.dir, file));
+    const pending = await readJson(path7.join(files.dir, file2));
     const activity = await readActivity(files);
     await settleAttempts(files.dir, { now: io.now().getTime(), activity });
     if (!pending || activity.state !== "idle" || !await driverAllowed(stateRoot(io.env), "opencode", opencodeWakeDriver.id, false) || (await readWakeState(files.dir))[opencodeWakeDriver.id]?.disabled) return;
@@ -1049,13 +1392,13 @@ async function pollOpenCodeWake(files, io, replay = false) {
       activityUpdatedAt: activity.updatedAt
     });
     const line = wakeLine(nonce);
-    await writeJsonAtomic(path5.join(files.dir, file), { ...pending, line, at });
+    await writeJsonAtomic(path7.join(files.dir, file2), { ...pending, line, at });
     return line;
   });
   const ladder = createWakeLadder({
     files,
     harness: "opencode",
-    sessionId: path5.basename(files.dir),
+    sessionId: path7.basename(files.dir),
     drivers: [opencodeWakeDriver],
     env: io.env,
     now: () => io.now().getTime(),
@@ -1067,31 +1410,33 @@ async function pollOpenCodeWake(files, io, replay = false) {
     await ladder.stop();
   }
   return withWakeLock(files.dir, "opencode-native.lock", async () => {
-    const pending = await readJson(path5.join(files.dir, file));
+    const pending = await readJson(path7.join(files.dir, file2));
     if (!pending || pending.delivered || io.now().getTime() > pending.at + opencodeWakeDriver.deadlineMs || pending.budget !== await budget(files) || (await readActivity(files)).state !== "idle" || !await driverAllowed(stateRoot(io.env), "opencode", opencodeWakeDriver.id, false) || (await readWakeState(files.dir))[opencodeWakeDriver.id]?.disabled) return;
     let eligible = false;
     for (const channel of await listChannels(files)) {
-      if (await readListeningMode(channel.files) === "async") continue;
+      const mode = await readListeningMode(channel.files);
+      if (mode === "async") continue;
       const session = await readJson(channel.files.session);
-      if ((await unread(channel.files)).entries.some((entry) => entry.kind === "message" && entry.sender !== session?.userId)) eligible = true;
+      const you = (await readJson(channel.files.status))?.displayName;
+      if ((await unread(channel.files)).entries.some((entry) => entry.sender !== session?.userId && wakesAgent(entry, mode, you))) eligible = true;
     }
     if (!eligible) return;
-    await writeJsonAtomic(path5.join(files.dir, file), { ...pending, delivered: true });
+    await writeJsonAtomic(path7.join(files.dir, file2), { ...pending, delivered: true });
     return pending.line;
   });
 }
 
 // src/harness/opencode.ts
-var install6 = async (flags, deps) => (await import("./chunk-BLCRVRIK.mjs")).runOpenCodeInstall(flags, deps);
+var install7 = async (flags, deps) => (await import("./chunk-CKLCR5G4.mjs")).runOpenCodeInstall(flags, deps);
 var opencode = {
   id: "opencode",
   sessionSources: [{ kind: "meta", resolve: (meta) => meta?.khala_session, rejoinable: () => true }, hookMapSource],
   codec: opencodeCodec,
-  restoreAtStartup: false,
+  restoreAtStartup: true,
   wakeLadder: [opencodeWakeDriver],
   pollIdleWake: pollOpenCodeWake,
-  install: install6,
-  uninstall: (flags, deps) => install6([...flags, "--uninstall"], deps)
+  install: install7,
+  uninstall: (flags, deps) => install7([...flags, "--uninstall"], deps)
 };
 
 // src/harness/generic.ts
@@ -1119,7 +1464,7 @@ function createAdapterRegistry(adapters) {
   }
   return Object.freeze({ resolve: (id) => byId.get(id) });
 }
-var ADAPTERS = Object.freeze([claude, codex, cursor, opencode, muse, gemini, copilot, generic]);
+var ADAPTERS = Object.freeze([claude, codex, cursor, opencode, muse, gemini, antigravity, copilot, qwen, generic]);
 var registry = createAdapterRegistry(ADAPTERS);
 function adapterFor(id) {
   return registry.resolve(id) ?? (isHarnessId(id) ? genericAdapter(id) : void 0);
@@ -1128,6 +1473,7 @@ function adapterFor(id) {
 export {
   createCopilotCodec,
   createWakeLadder,
+  registerAntigravityWake,
   SESSION_UNKNOWN_HINT,
   recordHookSession,
   resolveSources,