khala-cli 0.4.6 → 0.4.8

package/dist/chunk-5BQTYU66.mjs

@@ -0,0 +1,886 @@
+import { createRequire as __khalaCreateRequire } from 'node:module'; const require = __khalaCreateRequire(import.meta.url);
+import {
+  advanceCursor,
+  listChannels,
+  readActivity,
+  readCursor,
+  unread
+} from "./chunk-VKQ3KUYO.mjs";
+import {
+  SESSION_ID_PATTERN,
+  StateError,
+  ensureStateDir,
+  readJson,
+  stateRoot,
+  writeJsonAtomic
+} from "./chunk-CBPLCCRZ.mjs";
+import {
+  DEFAULT_LISTENING_MODE,
+  decodeListeningMode
+} from "./chunk-IQJQ4RF5.mjs";
+import {
+  HARNESS_REGISTRY,
+  isHarnessId
+} from "./chunk-NKX3SLS7.mjs";
+
+// src/mode.ts
+async function readListeningMode(files) {
+  const content = await readJson(files.mode);
+  const decoded = decodeListeningMode(typeof content === "object" && content !== null ? content.mode : void 0);
+  return decoded.ok ? decoded.value : DEFAULT_LISTENING_MODE;
+}
+async function applyListeningMode(files, next, meta, now = () => /* @__PURE__ */ new Date()) {
+  const previous = await readListeningMode(files);
+  if (previous === "async" && next !== "async") {
+    for (let attempt = 0; attempt < 2; attempt++) {
+      const { cursor: cursor2, entries } = await unread(files);
+      if (await advanceCursor(files, cursor2, entries) !== "conflict") break;
+      if (attempt === 1) throw new StateError("storage_failed");
+    }
+  }
+  await writeJsonAtomic(files.mode, { mode: next, ...meta, updatedAt: now().toISOString() });
+  return { previous, next };
+}
+
+// src/harness/codecs/claude-style.ts
+var events = { SessionStart: "start", UserPromptSubmit: "prompt", PostToolUse: "tool", Stop: "stop" };
+var names = { prompt: "UserPromptSubmit", tool: "PostToolUse", stop: "Stop" };
+var claudeStyleCodec = {
+  promptDeliversWithoutWake: true,
+  promptAcceptsContext: true,
+  suppressOutputErrors: false,
+  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;
+      return {
+        sessionId: input.session_id,
+        event: events[input.hook_event_name],
+        continuation: input.stop_hook_active === true,
+        ...typeof input.cwd === "string" ? { workspace: input.cwd } : {},
+        ...typeof input.prompt === "string" ? { promptText: input.prompt } : {}
+      };
+    } catch {
+      return null;
+    }
+  },
+  noop: () => "",
+  render(kind, frame) {
+    return JSON.stringify(kind === "stop" ? { decision: "block", reason: frame } : { hookSpecificOutput: { hookEventName: names[kind], additionalContext: frame } }) + "\n";
+  }
+};
+
+// src/harness/claude.ts
+var claude = {
+  id: "claude",
+  sessionSources: [{ kind: "env", resolve: (_meta, env) => env.CLAUDE_CODE_SESSION_ID, rejoinable: () => true }],
+  codec: claudeStyleCodec,
+  restoreAtStartup: true,
+  watcherStatus: true
+};
+
+// src/wake/shared/rules.ts
+import { randomBytes } from "node:crypto";
+var CODEX_IDLE_WAKE_NOTICE = "Khala: channel messages are waiting. Continue.";
+function newNonce() {
+  return randomBytes(4).toString("hex");
+}
+function wakeLine(nonce) {
+  if (!/^[a-f0-9]{8}$/.test(nonce)) throw new Error("invalid_wake_nonce");
+  return `${CODEX_IDLE_WAKE_NOTICE} (k-${nonce})`;
+}
+
+// src/wake/idle-wake.ts
+function codexIdleWakeArgv(sessionId, line) {
+  return ["queue", "--thread", sessionId, "--message", line];
+}
+
+// src/wake/idle-wake-process.ts
+import { spawn as nodeSpawn } from "node:child_process";
+var CODEX_QUEUE_ENV_ALLOWLIST = [
+  "PATH",
+  "HOME",
+  "USER",
+  "LOGNAME",
+  "SHELL",
+  "LANG",
+  "LC_ALL",
+  "TMPDIR",
+  "CODEX_HOME",
+  "XDG_CONFIG_HOME",
+  "XDG_DATA_HOME",
+  "XDG_STATE_HOME",
+  "XDG_RUNTIME_DIR"
+];
+function scrubbedQueueEnv(source) {
+  const env = {};
+  for (const name of CODEX_QUEUE_ENV_ALLOWLIST) {
+    const value = source[name];
+    if (value !== void 0) env[name] = value;
+  }
+  return env;
+}
+function createCodexQueueProcessPort(deps) {
+  const spawn = deps.spawn ?? ((command, argv, options) => nodeSpawn(command, [...argv], options));
+  const timeoutMs = deps.timeoutMs ?? 1e4;
+  return {
+    run(argv, signal) {
+      return new Promise((resolve) => {
+        if (signal.aborted) return resolve({ status: "not_started" });
+        let child;
+        try {
+          child = spawn(deps.command, argv, { shell: false, stdio: "ignore", env: scrubbedQueueEnv(deps.env) });
+        } catch {
+          return resolve({ status: "not_started" });
+        }
+        let timedOut = false;
+        let stopped = false;
+        let force = null;
+        const stop = () => {
+          if (stopped) return;
+          stopped = true;
+          child.kill("SIGTERM");
+          force = setTimeout(() => {
+            child.kill("SIGKILL");
+          }, 500);
+        };
+        const timer = setTimeout(() => {
+          timedOut = true;
+          stop();
+        }, timeoutMs);
+        signal.addEventListener("abort", stop, { once: true });
+        const settle = (outcome) => {
+          clearTimeout(timer);
+          if (force !== null) clearTimeout(force);
+          signal.removeEventListener("abort", stop);
+          resolve(outcome);
+        };
+        child.on("error", () => settle({ status: "not_started" }));
+        child.on("close", (code) => settle(timedOut ? { status: "lost", cause: "timeout" } : code === 0 ? { status: "queued" } : { status: "exited", code: code ?? -1 }));
+      });
+    }
+  };
+}
+
+// src/wake/codex-probe.ts
+import { execFile } from "node:child_process";
+import { access, realpath, stat } from "node:fs/promises";
+import { constants } from "node:fs";
+import path from "node:path";
+import { promisify } from "node:util";
+var execute = promisify(execFile);
+var probes = /* @__PURE__ */ new Map();
+async function probeCodexQueue(env) {
+  let command;
+  for (const dir of (env.PATH ?? "").split(path.delimiter).filter(Boolean)) {
+    try {
+      const candidate = path.join(dir, process.platform === "win32" ? "codex.exe" : "codex");
+      await access(candidate, constants.X_OK);
+      if (!(await stat(candidate)).isFile()) continue;
+      command = await realpath(candidate);
+      break;
+    } catch {
+    }
+  }
+  if (!command) return { available: false, reason: "codex_binary_missing" };
+  let mtime;
+  try {
+    mtime = (await stat(command)).mtimeMs;
+  } catch {
+    return { available: false, reason: "codex_binary_missing" };
+  }
+  const cached = probes.get(command);
+  if (cached?.mtime === mtime) return cached.result;
+  const binary = command;
+  const result = (async () => {
+    try {
+      const { stdout } = await execute(binary, ["queue", "--help"], {
+        env: scrubbedQueueEnv(env),
+        timeout: 5e3,
+        killSignal: "SIGKILL",
+        maxBuffer: 64 * 1024,
+        windowsHide: true
+      });
+      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" };
+    }
+  })();
+  probes.set(binary, { mtime, result });
+  return result;
+}
+
+// src/wake/ladder.ts
+import path4 from "node:path";
+
+// src/wake/shared/settings.ts
+import * as fs from "node:fs/promises";
+import path2 from "node:path";
+async function readWakeSettings(root) {
+  try {
+    const value = JSON.parse(await fs.readFile(path2.join(root, "wake-settings.json"), "utf8"));
+    const entries = (input) => {
+      if (!input || typeof input !== "object" || Array.isArray(input)) return {};
+      return Object.fromEntries(Object.entries(input).filter(([, entry]) => entry && typeof entry === "object" && typeof entry.at === "string"));
+    };
+    return { consent: entries(value?.consent), off: entries(value?.off) };
+  } catch (error) {
+    if (error.code === "ENOENT") return { consent: {}, off: {} };
+    throw error;
+  }
+}
+async function driverAllowed(root, harness, driver, optIn) {
+  const settings = await readWakeSettings(root);
+  const key = `${harness}/${driver}`;
+  return !Object.hasOwn(settings.off, key) && (!optIn || Object.hasOwn(settings.consent, key));
+}
+
+// src/wake/shared/nonce.ts
+import * as fs2 from "node:fs/promises";
+import path3 from "node:path";
+import { randomBytes as randomBytes2 } from "node:crypto";
+async function readJson2(file, fallback) {
+  try {
+    return JSON.parse(await fs2.readFile(file, "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return fallback;
+    throw error;
+  }
+}
+async function atomic(file, value) {
+  const temp = `${file}.${randomBytes2(8).toString("hex")}.tmp`;
+  try {
+    await fs2.writeFile(temp, JSON.stringify(value), { mode: 384 });
+    await fs2.rename(temp, file);
+  } finally {
+    await fs2.rm(temp, { force: true });
+  }
+}
+async function clearAbandonedLock(lock) {
+  let entries;
+  try {
+    entries = await fs2.readdir(lock);
+  } catch (error) {
+    if (error.code === "ENOENT") return;
+    throw error;
+  }
+  for (const entry of entries) {
+    const owner = /^owner-(\d+)-[a-f0-9]{16}$/.exec(entry);
+    if (!owner) continue;
+    try {
+      process.kill(Number(owner[1]), 0);
+    } catch (error) {
+      if (error.code !== "ESRCH") continue;
+      await fs2.rm(path3.join(lock, entry), { force: true });
+    }
+  }
+  try {
+    await fs2.rmdir(lock);
+  } catch (error) {
+    if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+  }
+}
+async function locked(dir, work) {
+  await fs2.mkdir(dir, { recursive: true, mode: 448 });
+  const lock = path3.join(dir, "wake.lock");
+  const owner = `owner-${process.pid}-${randomBytes2(8).toString("hex")}`;
+  const candidate = path3.join(dir, `.${owner}`);
+  await fs2.mkdir(candidate, { mode: 448 });
+  await fs2.writeFile(path3.join(candidate, owner), "", { mode: 384 });
+  let acquired = false;
+  try {
+    for (let tries = 0; tries < 200; tries++) {
+      try {
+        await fs2.rename(candidate, lock);
+        acquired = true;
+        break;
+      } catch (error) {
+        if (!["EEXIST", "ENOTEMPTY", "EPERM", "EACCES"].includes(error.code ?? "")) throw error;
+      }
+      await clearAbandonedLock(lock);
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+  } finally {
+    if (!acquired) await fs2.rm(candidate, { recursive: true, force: true });
+  }
+  if (!acquired) throw new Error("wake_state_locked");
+  try {
+    const data = await readJson2(path3.join(dir, "wake-journal.json"), { attempts: [], state: {} });
+    const result = work(data);
+    await atomic(path3.join(dir, "wake-journal.json"), data);
+    await atomic(path3.join(dir, "wake-state.json"), data.state);
+    return result;
+  } finally {
+    await fs2.rm(path3.join(lock, owner), { force: true });
+    try {
+      await fs2.rmdir(lock);
+    } catch (error) {
+      if (!["ENOENT", "ENOTEMPTY", "EEXIST"].includes(error.code ?? "")) throw error;
+    }
+  }
+}
+async function readWakeState(dir) {
+  return (await readJson2(path3.join(dir, "wake-journal.json"), { attempts: [], state: {} })).state;
+}
+async function recordAttempt(dir, attempt) {
+  wakeLine(attempt.nonce);
+  if (!attempt.driver || ["__proto__", "constructor", "prototype"].includes(attempt.driver) || !Number.isFinite(attempt.at) || !Number.isFinite(attempt.deadline) || attempt.deadline <= attempt.at) throw new Error("invalid_wake_attempt");
+  await locked(dir, (data) => {
+    if (data.attempts.some((item) => item.nonce === attempt.nonce)) throw new Error("duplicate_wake_nonce");
+    data.attempts.push(attempt);
+  });
+}
+async function settleAttempts(dir, input) {
+  const snapshot = await readJson2(path3.join(dir, "wake-journal.json"), { attempts: [], state: {} });
+  if (!snapshot.attempts.length) return [];
+  return locked(dir, (data) => {
+    const results = [];
+    const remaining = [];
+    const activityAt = typeof input.activity?.updatedAt === "number" ? input.activity.updatedAt : Date.parse(input.activity?.updatedAt ?? "");
+    for (const attempt of data.attempts) {
+      let status;
+      const baselineAt = typeof attempt.activityUpdatedAt === "number" ? attempt.activityUpdatedAt : attempt.activityUpdatedAt === void 0 ? attempt.at : Date.parse(attempt.activityUpdatedAt);
+      const verified = input.promptText?.includes(`(k-${attempt.nonce})`);
+      const activityChanged = input.activity && (input.activity.state !== "idle" || activityAt > baselineAt);
+      if (activityChanged) status = "void";
+      else if (verified && input.now <= attempt.deadline) status = "success";
+      else if (input.now >= attempt.deadline && input.activity?.state === "idle") status = "failure";
+      else if (input.promptText !== void 0) status = "void";
+      if (!status) {
+        remaining.push(attempt);
+        continue;
+      }
+      results.push({ nonce: attempt.nonce, driver: attempt.driver, status });
+      if (status === "void") continue;
+      const prior = data.state[attempt.driver] ?? { failures: 0 };
+      if (status === "success") data.state[attempt.driver] = { failures: 0 };
+      else {
+        const failures = prior.failures + 1;
+        data.state[attempt.driver] = failures >= 2 ? { failures, disabled: true, reason: "nonce_timeout", at: new Date(input.now).toISOString() } : { failures };
+      }
+    }
+    data.attempts = remaining;
+    return results;
+  });
+}
+
+// src/wake/ladder.ts
+function createWakeLadder(deps) {
+  if (!SESSION_ID_PATTERN.test(deps.sessionId)) throw new TypeError("invalid_session_id");
+  const now = deps.now ?? Date.now;
+  const stderr = deps.stderr ?? ((line) => {
+    process.stderr.write(line);
+  });
+  const controller = new AbortController();
+  let pending;
+  const wakesAtCount = /* @__PURE__ */ new Map();
+  const identities = /* @__PURE__ */ new Map();
+  const disabledDrivers = /* @__PURE__ */ new Set();
+  let stopped = false;
+  let again = false;
+  let inFlight;
+  const warn = (warning, status) => {
+    try {
+      stderr(JSON.stringify({ ok: false, warning, ...status ? { status } : {} }) + "\n");
+    } catch {
+    }
+  };
+  const evaluate = async () => {
+    try {
+      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)) {
+        if (state.disabled && !disabledDrivers.has(id)) {
+          disabledDrivers.add(id);
+          wakesAtCount.clear();
+          pending = void 0;
+        }
+      }
+      const channels = await listChannels(deps.files);
+      const eligible = [];
+      const currentIdentities = /* @__PURE__ */ new Map();
+      for (const channel of channels) {
+        const session = await readJson(channel.files.session);
+        const metadata = channel.legacy ? null : await readJson(path4.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;
+        eligible.push({
+          channel,
+          counts: { messages: (await unread(channel.files)).entries.filter((entry) => entry.kind === "message" && entry.sender !== session?.userId).length },
+          cursor: await readCursor(channel.files)
+        });
+      }
+      const keys = new Set(currentIdentities.keys());
+      const changed = /* @__PURE__ */ new Set();
+      for (const [key, identity] of currentIdentities) {
+        if (identities.get(key) !== identity) changed.add(key);
+      }
+      for (const key of identities.keys()) if (!keys.has(key)) changed.add(key);
+      if (changed.size) {
+        for (const [key, wakes2] of [...wakesAtCount]) {
+          const pairs2 = JSON.parse(key);
+          if (!pairs2.some(([id]) => changed.has(id))) continue;
+          wakesAtCount.delete(key);
+          const remainingPairs = pairs2.filter(([id]) => !changed.has(id));
+          if (!remainingPairs.length) continue;
+          const remaining = JSON.stringify(remainingPairs);
+          wakesAtCount.set(remaining, Math.max(wakes2, wakesAtCount.get(remaining) ?? 0));
+        }
+      }
+      for (const key of changed) identities.delete(key);
+      for (const [key, identity] of currentIdentities) identities.set(key, identity);
+      const pairs = eligible.map(({ channel, cursor: cursor2 }) => [channel.key, cursor2.deliveredCount]).sort(([a], [b]) => a.localeCompare(b));
+      const budgetKey = JSON.stringify(pairs);
+      if (changed.size) {
+        const inheritedKey = JSON.stringify(pairs.filter(([key]) => !changed.has(key)));
+        const newUnread = eligible.some((item) => changed.has(item.channel.key) && item.counts.messages > 0);
+        wakesAtCount.set(budgetKey, newUnread ? 0 : wakesAtCount.get(inheritedKey) ?? 0);
+        if (newUnread || !eligible.some((item) => !changed.has(item.channel.key) && item.counts.messages > 0)) pending = void 0;
+      }
+      if (!eligible.some((item) => item.counts.messages > 0)) {
+        pending = void 0;
+        return;
+      }
+      const activity = await readActivity(deps.files);
+      if (pending && Date.parse(activity.updatedAt) > pending.at) pending = void 0;
+      const at = now();
+      if (pending && at - pending.at < (deps.retryAfterMs ?? 6e4)) return;
+      if (stopped || activity.state !== "idle") return;
+      const wakes = wakesAtCount.get(budgetKey) ?? 0;
+      if (wakes >= 2) return;
+      for (const { channel } of eligible) {
+        if (await readListeningMode(channel.files) === "async") {
+          pending = void 0;
+          return;
+        }
+      }
+      if (stopped) return;
+      const ctx = { files: deps.files, harness: deps.harness, sessionId: deps.sessionId, env: deps.env ?? process.env, signal: controller.signal, now: at };
+      const driver = await chooseWakeDriver(deps.drivers, ctx, activity);
+      if (!driver || stopped) return;
+      const stillEligible = async () => {
+        if (stopped) return false;
+        if (!await driverAllowed(stateRoot(ctx.env), ctx.harness, driver.id, driver.optIn)) return false;
+        if ((await readWakeState(deps.files.dir))[driver.id]?.disabled) return false;
+        for (const { channel } of eligible) {
+          if (await readListeningMode(channel.files) === "async") return false;
+        }
+        const current = await readActivity(deps.files);
+        return !stopped && current.state === "idle" && current.updatedAt === activity.updatedAt;
+      };
+      if (!await stillEligible()) return;
+      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 });
+        if (!await stillEligible()) {
+          await settleAttempts(deps.files.dir, { now: now(), activity: await readActivity(deps.files), promptText: "" });
+          return;
+        }
+      }
+      if (stopped) return;
+      pending = { at: attemptAt };
+      wakesAtCount.set(budgetKey, wakes + 1);
+      await driver.wake({ ...ctx, now: attemptAt }, wakeLine(nonce));
+    } catch {
+      warn(`${deps.warningPrefix ?? "wake"}_waker_error`);
+    }
+  };
+  const notify = () => {
+    if (stopped) return;
+    if (inFlight) {
+      again = true;
+      return;
+    }
+    inFlight = (async () => {
+      do {
+        again = false;
+        await evaluate();
+      } while (again && !stopped);
+    })().finally(() => {
+      inFlight = void 0;
+      if (again && !stopped) notify();
+    });
+  };
+  const timer = setInterval(notify, deps.pollMs ?? 1e3);
+  timer.unref();
+  return {
+    notify,
+    async stop() {
+      stopped = true;
+      again = false;
+      clearInterval(timer);
+      controller.abort();
+      await inFlight;
+    }
+  };
+}
+async function chooseWakeDriver(drivers, ctx, activity) {
+  if (activity.state !== "idle") return void 0;
+  const states = await readWakeState(ctx.files.dir);
+  const override = ctx.env.KHALA_WAKE_TEST_IDLE_MS;
+  const idleOverride = override !== void 0 && /^\d+$/.test(override) ? Number(override) : void 0;
+  for (const driver of [...drivers].sort((a, b) => a.rung - b.rung)) {
+    if (states[driver.id]?.disabled) continue;
+    if (!await driverAllowed(stateRoot(ctx.env), ctx.harness, driver.id, driver.optIn)) continue;
+    if (!await driver.available(ctx)) continue;
+    if (ctx.now - Date.parse(activity.updatedAt) < (idleOverride ?? driver.minIdleMs)) return void 0;
+    return driver;
+  }
+  return void 0;
+}
+
+// src/wake/codex.ts
+function createCodexWakeDriver(deps = {}) {
+  return {
+    id: "queue",
+    rung: 1,
+    optIn: false,
+    minIdleMs: 0,
+    deadlineMs: 3e4,
+    verification: "nonce",
+    available: async (ctx) => (await (deps.probe ?? probeCodexQueue)(ctx.env)).available,
+    unavailableReason: async (ctx) => (await (deps.probe ?? probeCodexQueue)(ctx.env)).reason,
+    async wake(ctx, line) {
+      const probe = await (deps.probe ?? probeCodexQueue)(ctx.env);
+      if (!probe.available || ctx.signal.aborted) return;
+      const port = deps.port ?? createCodexQueueProcessPort({ command: probe.command, env: ctx.env });
+      const outcome = await port.run(codexIdleWakeArgv(ctx.sessionId, line), ctx.signal);
+      if (outcome.status !== "queued") {
+        const line2 = JSON.stringify({ ok: false, warning: "codex_queue_failed", status: outcome.status }) + "\n";
+        try {
+          (deps.stderr ?? ((value) => {
+            process.stderr.write(value);
+          }))(line2);
+        } catch {
+        }
+      }
+    }
+  };
+}
+var codexWakeDriver = createCodexWakeDriver();
+
+// src/harness/codex.ts
+var install = async (flags, deps) => (await import("./chunk-5PUQT3YS.mjs")).runCodexInstall(flags, deps);
+var codex = {
+  id: "codex",
+  // A string metadata id wins even when empty or invalid; validation happens after selection.
+  sessionSources: [
+    { kind: "meta", resolve: (meta) => typeof meta?.threadId === "string" ? meta.threadId : void 0, rejoinable: () => true },
+    { kind: "env", resolve: (_meta, env) => env.CODEX_THREAD_ID, rejoinable: () => true }
+  ],
+  codec: claudeStyleCodec,
+  restoreAtStartup: true,
+  install,
+  uninstall: (flags, deps) => install([...flags, "--uninstall"], deps),
+  wakeLadder: [codexWakeDriver],
+  wakeWarningName: "codex"
+};
+
+// src/cursor.ts
+import { createHash } from "node:crypto";
+var CURSOR_WORKSPACE_ENV = "KHALA_CURSOR_WORKSPACE";
+var CURSOR_DEFAULT_SESSION = "cursor-default";
+function normalizeWorkspace(root) {
+  let value = root.trim();
+  if (!value || value.includes("${")) return null;
+  if (/^file:\/\//iu.test(value)) {
+    try {
+      value = decodeURIComponent(new URL(value).pathname);
+    } catch {
+      return null;
+    }
+  }
+  value = value.replaceAll("\\", "/");
+  if (/^\/[A-Za-z]:(?:\/|$)/u.test(value)) value = value.slice(1);
+  if (/^[A-Za-z]:(?:\/|$)/u.test(value)) value = value.toLowerCase();
+  value = value.replace(/\/+$/u, "");
+  if (/^[a-z]:$/u.test(value)) value += "/";
+  return value || null;
+}
+function cursorSessionId(root) {
+  const normalized = typeof root === "string" ? normalizeWorkspace(root) : null;
+  if (normalized === null) return CURSOR_DEFAULT_SESSION;
+  return `ws-${createHash("sha256").update(normalized).digest("hex").slice(0, 32)}`;
+}
+
+// src/harness/codecs/cursor.ts
+var events2 = { beforeSubmitPrompt: "prompt", postToolUse: "tool", stop: "stop" };
+var cursorCodec = {
+  promptDeliversWithoutWake: false,
+  promptAcceptsContext: false,
+  suppressOutputErrors: true,
+  fallbackSession: CURSOR_DEFAULT_SESSION,
+  parse(stdin) {
+    try {
+      const input = JSON.parse(stdin.replace(/^\uFEFF/u, ""));
+      if (!input || typeof input.hook_event_name !== "string" || !Object.hasOwn(events2, input.hook_event_name)) return null;
+      const workspace = Array.isArray(input.workspace_roots) && typeof input.workspace_roots[0] === "string" ? input.workspace_roots[0] : void 0;
+      return {
+        sessionId: cursorSessionId(workspace),
+        event: events2[input.hook_event_name],
+        continuation: typeof input.loop_count === "number" && input.loop_count > 0,
+        ...typeof input.prompt === "string" ? { promptText: input.prompt } : {},
+        ...workspace !== void 0 ? { workspace } : {}
+      };
+    } catch {
+      return null;
+    }
+  },
+  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";
+  }
+};
+
+// src/harness/cursor.ts
+var install2 = async (flags, deps) => (await import("./chunk-5PUQT3YS.mjs")).runCursorInstall(flags, deps);
+var cursor = {
+  id: "cursor",
+  sessionSources: [{
+    kind: "workspace",
+    resolve: (_meta, env) => cursorSessionId(env[CURSOR_WORKSPACE_ENV]),
+    rejoinable: (sessionId) => sessionId !== CURSOR_DEFAULT_SESSION
+  }],
+  codec: cursorCodec,
+  restoreAtStartup: false,
+  install: install2,
+  uninstall: (flags, deps) => install2([...flags, "--uninstall"], deps)
+};
+
+// src/harness/codecs/opencode.ts
+var events3 = { "session-start": "start", prompt: "prompt", "post-tool": "tool", "turn-end": "stop", idle: "stop" };
+var opencodeCodec = {
+  promptAcceptsContext: true,
+  promptDeliversWithoutWake: true,
+  suppressOutputErrors: false,
+  parse(stdin) {
+    try {
+      const input = JSON.parse(stdin.replace(/^\uFEFF/u, ""));
+      if (!input || typeof input.session_id !== "string" || typeof input.event !== "string" || !Object.hasOwn(events3, input.event)) return null;
+      return {
+        sessionId: input.session_id,
+        event: events3[input.event],
+        continuation: false,
+        ...typeof input.prompt === "string" ? { promptText: input.prompt } : {}
+      };
+    } catch {
+      return null;
+    }
+  },
+  noop: () => "",
+  render: (_kind, frame) => frame
+};
+
+// src/harness/session-sources.ts
+import path5 from "node:path";
+import { lstat } from "node:fs/promises";
+
+// src/harness/proc.ts
+import { execFile as execFile2 } from "node:child_process";
+import { readFile as readFile3 } from "node:fs/promises";
+import { promisify as promisify2 } from "node:util";
+var execFileAsync = promisify2(execFile2);
+var validPid = (pid) => Number.isSafeInteger(pid) && pid > 0;
+function startToken(value) {
+  return value.trim().replace(/[^a-zA-Z0-9_-]+/g, "-");
+}
+function parseLinuxStat(pid, text) {
+  const open = text.indexOf("(");
+  const close = text.lastIndexOf(")");
+  if (!validPid(pid) || open < 0 || close < open || Number(text.slice(0, open).trim()) !== pid) return null;
+  const fields = text.slice(close + 1).trim().split(/\s+/);
+  const ppid = Number(fields[1]);
+  const startTime = fields[19];
+  if (!Number.isSafeInteger(ppid) || ppid < 0 || !startTime || !/^\d+$/.test(startTime)) return null;
+  return { pid, ppid, startTime, command: text.slice(open + 1, close) };
+}
+function parseDarwinPs(pid, text) {
+  const match = text.trim().match(/^(\d+)\s+([A-Za-z]{3}\s+[A-Za-z]{3}\s+\d{1,2}\s+\d{2}:\d{2}:\d{2}\s+\d{4})\s+(.+)$/);
+  if (!validPid(pid) || !match) return null;
+  return { pid, ppid: Number(match[1]), startTime: startToken(match[2]), command: match[3] };
+}
+function csvFields(line) {
+  const fields = [];
+  let value = "";
+  let quoted = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    if (char === '"') {
+      if (quoted && line[i + 1] === '"') {
+        value += '"';
+        i++;
+      } else quoted = !quoted;
+    } else if (char === "," && !quoted) {
+      fields.push(value);
+      value = "";
+    } else value += char;
+  }
+  if (quoted) return null;
+  fields.push(value);
+  return fields;
+}
+function parseWindowsCsv(text, pid) {
+  if (!validPid(pid)) return null;
+  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/).filter((line) => line.trim() && !line.startsWith("#"));
+  const headers = csvFields(lines[0] ?? "");
+  if (!headers) return null;
+  for (const line of lines.slice(1)) {
+    const values = csvFields(line);
+    if (!values) continue;
+    const field = (name) => values[headers.indexOf(name)] ?? "";
+    if (Number(field("ProcessId")) !== pid) continue;
+    const ppid = Number(field("ParentProcessId"));
+    const startTime = startToken(field("CreationDate"));
+    const command = field("Name");
+    if (!field("ParentProcessId") || !Number.isSafeInteger(ppid) || ppid < 0 || !startTime || !command) return null;
+    return { pid, ppid, startTime, command };
+  }
+  return null;
+}
+async function readProcess(pid) {
+  if (!validPid(pid)) return null;
+  try {
+    if (process.platform === "linux") return parseLinuxStat(pid, await readFile3(`/proc/${pid}/stat`, "utf8"));
+    if (process.platform === "darwin") {
+      const { stdout } = await execFileAsync("ps", ["-o", "ppid=,lstart=,comm=", "-p", String(pid)], { env: { ...process.env, LC_ALL: "C" }, timeout: 5e3 });
+      return parseDarwinPs(pid, stdout);
+    }
+    if (process.platform === "win32") {
+      const script = `Get-CimInstance Win32_Process -Filter 'ProcessId = ${pid}' | Select-Object ProcessId,ParentProcessId,@{Name='CreationDate';Expression={$_.CreationDate.ToUniversalTime().ToString('o')}},Name | ConvertTo-Csv -NoTypeInformation`;
+      const { stdout } = await execFileAsync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", script], { timeout: 5e3 });
+      return parseWindowsCsv(stdout, pid);
+    }
+  } catch {
+  }
+  return null;
+}
+async function* walkAncestors(pid, read = readProcess) {
+  const seen = /* @__PURE__ */ new Set([pid]);
+  let current = await read(pid);
+  while (current && validPid(current.ppid) && !seen.has(current.ppid)) {
+    seen.add(current.ppid);
+    current = await read(current.ppid);
+    if (current) yield current;
+  }
+}
+async function nearestNonShellAncestor(pid, read = readProcess) {
+  for await (const ancestor of walkAncestors(pid, read)) {
+    const name = ancestor.command.split(/[\\/]/).pop()?.replace(/^-/, "").toLowerCase() ?? "";
+    if (!/^(?:sh|bash|dash|zsh|fish|ksh|csh|tcsh|ash|cmd(?:\.exe)?|powershell(?:\.exe)?|pwsh(?:\.exe)?)$/.test(name)) return ancestor;
+  }
+  return null;
+}
+
+// src/harness/session-sources.ts
+var SESSION_UNKNOWN_HINT = "Send the agent one message first, then retry.";
+var mappingDir = (harness, env) => path5.join(stateRoot(env), harness, ".by-pid");
+async function recordHookSession(harness, sessionId, env, options = {}) {
+  if (!SESSION_ID_PATTERN.test(sessionId)) return;
+  const parent = await nearestNonShellAncestor(options.pid ?? process.pid, options.readProcess ?? readProcess);
+  if (!parent) return;
+  const dir = mappingDir(harness, env);
+  await ensureStateDir(dir);
+  const file = path5.join(dir, `${parent.pid}.json`);
+  const at = (options.now ?? (() => /* @__PURE__ */ new Date()))().toISOString();
+  const previous = await readJson(file);
+  if (previous?.startTime === parent.startTime && typeof previous.at === "string" && previous.at > at) return;
+  await writeJsonAtomic(file, {
+    sessionId,
+    startTime: parent.startTime,
+    at,
+    ...options.workspace !== void 0 ? { workspace: options.workspace } : {}
+  });
+}
+var hookMapSource = {
+  kind: "hook-map",
+  rejoinable: () => true,
+  async resolve(_meta, env, context) {
+    const dir = mappingDir(context.harness, env);
+    try {
+      await lstat(dir);
+    } catch (error) {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    }
+    await ensureStateDir(dir);
+    const parent = await nearestNonShellAncestor(context.pid ?? process.pid, context.readProcess ?? readProcess);
+    if (!parent) return null;
+    const entry = await readJson(path5.join(dir, `${parent.pid}.json`));
+    if (entry?.startTime === parent.startTime && typeof entry.sessionId === "string" && SESSION_ID_PATTERN.test(entry.sessionId) && typeof entry.at === "string" && Number.isFinite(Date.parse(entry.at))) return entry.sessionId;
+    return null;
+  }
+};
+var processSource = {
+  kind: "process",
+  rejoinable: () => false,
+  async resolve(_meta, _env, context) {
+    for await (const parent of walkAncestors(context.pid ?? process.pid, context.readProcess ?? readProcess)) {
+      return `proc-${parent.pid}-${parent.startTime}`;
+    }
+    return null;
+  }
+};
+async function resolveSources(sources, meta, env, context) {
+  for (const source of sources) {
+    const value = await source.resolve(meta, env, context);
+    if (value === void 0 || value === null) continue;
+    return typeof value === "string" && SESSION_ID_PATTERN.test(value) ? { sessionId: value, rejoinable: source.rejoinable(value) } : null;
+  }
+  return null;
+}
+
+// src/harness/opencode.ts
+var install3 = async (flags, deps) => (await import("./chunk-5PUQT3YS.mjs")).runOpenCodeInstall(flags, deps);
+var opencode = {
+  id: "opencode",
+  sessionSources: [{ kind: "meta", resolve: (meta) => meta?.khala_session, rejoinable: () => true }, hookMapSource],
+  codec: opencodeCodec,
+  restoreAtStartup: false,
+  install: install3,
+  uninstall: (flags, deps) => install3([...flags, "--uninstall"], deps)
+};
+
+// src/harness/generic.ts
+var generic = {
+  id: "generic",
+  sessionSources: [
+    { kind: "env", resolve: (_meta, env) => env.KHALA_SESSION_ID, rejoinable: () => true },
+    processSource
+  ],
+  codec: void 0,
+  restoreAtStartup: true
+};
+function genericAdapter(id) {
+  return { ...generic, id };
+}
+
+// src/harness/index.ts
+function createAdapterRegistry(adapters) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const adapter of adapters) {
+    if (byId.has(adapter.id)) throw new Error(`duplicate_adapter: ${adapter.id}`);
+    if (!HARNESS_REGISTRY.some((row) => row.id === adapter.id)) throw new Error(`unregistered_adapter: ${adapter.id}`);
+    byId.set(adapter.id, adapter);
+  }
+  return Object.freeze({ resolve: (id) => byId.get(id) });
+}
+var ADAPTERS = Object.freeze([claude, codex, cursor, opencode, generic]);
+var registry = createAdapterRegistry(ADAPTERS);
+function adapterFor(id) {
+  return registry.resolve(id) ?? (isHarnessId(id) ? genericAdapter(id) : void 0);
+}
+
+export {
+  readListeningMode,
+  applyListeningMode,
+  readWakeState,
+  settleAttempts,
+  createWakeLadder,
+  CURSOR_WORKSPACE_ENV,
+  SESSION_UNKNOWN_HINT,
+  recordHookSession,
+  resolveSources,
+  adapterFor
+};