backeer-opencode 0.7.0 → 0.8.1

package/dist/backeer-permission.js

@@ -44,7 +44,7 @@ function make7(connect) {
     if (current === connection)
       current = void 0;
   }
-  async function run(connection) {
+  async function run2(connection) {
     let iterator;
     let completion = {};
     try {
@@ -133,7 +133,7 @@ function make7(connect) {
             if (connection.connected)
               subscriber.push(connection.connected);
             if (fresh)
-              run(connection);
+              run2(connection);
           }
           return {
             next() {
@@ -1966,7 +1966,9 @@ function loadLiveBridgeConfig(option, { configDirectory, ingestToken } = {}) {
     const tokenFile = values.tokenFile ?? process.env.BACKEER_LIVE_TOKEN_FILE ?? join(configDirectory, "secrets", "backeer-live-token");
     const token = readCredential(tokenFile);
     if (token === ingestToken) throw new Error("Live control requires a credential distinct from the Backeer ingest token");
-    return { enabled: true, token, tokenFile, port };
+    const owner = values.owner ?? "server";
+    if (!["server", "tui"].includes(owner)) throw new Error("Live control owner must be server or tui");
+    return { enabled: true, token, tokenFile, port, owner };
   } catch (error) {
     return { enabled: false, error: error.message };
   }
@@ -2395,7 +2397,7 @@ import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 
 // src/updates.js
-var PLUGIN_VERSION = "0.7.0";
+var PLUGIN_VERSION = "0.8.1";
 var PACKAGE_NAME = "backeer-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
@@ -3417,1072 +3419,1275 @@ function createLifecycleController({
 import { createServer } from "node:http";
 import { randomUUID as randomUUID3, timingSafeEqual } from "node:crypto";
 
-// src/live-bridge-client.js
-function createV2LiveClient(ctx) {
-  const known = /* @__PURE__ */ new Map();
-  let disposed = false;
-  async function get(id) {
-    const info = await ctx.session.get({ sessionID: id });
-    if (disposed) return info;
-    known.set(id, info);
-    if (known.size > 100) known.delete(known.keys().next().value);
-    return info;
+// src/permission-command.js
+var ALLOWED_DECISIONS = /* @__PURE__ */ new Set(["once", "always", "reject"]);
+var DECISION_LABELS = {
+  once: "Allow once",
+  always: "Always allow",
+  reject: "Reject"
+};
+function validatePermissionCommand(command, now = Date.now()) {
+  if (!ALLOWED_DECISIONS.has(command.decision)) {
+    return {
+      status: "rejected",
+      decision: command.decision,
+      errorCode: "invalid_decision"
+    };
+  }
+  const expiresAt = Date.parse(command.expiresAt);
+  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+    return { status: "expired", decision: command.decision };
+  }
+  if (command.decision === "always" && command.confirmed !== true) {
+    return {
+      status: "rejected",
+      decision: command.decision,
+      errorCode: "confirmation_required"
+    };
   }
+}
+function failureAcknowledgement(command, error) {
+  const stale = error instanceof HttpError && error.status === 404;
   return {
-    async list() {
-      if (typeof ctx.session.list === "function") {
-        return ctx.session.list({ directory: ctx.location.directory, limit: 100, order: "desc" });
-      }
-      const refreshed = [];
-      for (const id of known.keys()) {
-        try {
-          refreshed.push(await get(id));
-        } catch {
-          known.delete(id);
-        }
-      }
-      return refreshed;
-    },
-    get,
-    prompt: (id, text) => ctx.session.prompt({ sessionID: id, text, delivery: "queue" }),
-    dispose: () => {
-      disposed = true;
-      known.clear();
-    }
+    status: stale ? "stale" : "failed",
+    decision: command.decision,
+    errorCode: stale ? "permission_not_found" : "opencode_reply_failed"
   };
 }
-function unwrap(value) {
-  if (value?.error) throw new Error("OpenCode request failed");
-  return value?.data ?? value;
-}
-function createV1LiveClient(client, directory) {
-  return {
-    list: async () => unwrap(await client.session.list({ query: { directory }, throwOnError: true })),
-    get: async (id) => unwrap(await client.session.get({ path: { id }, query: { directory }, throwOnError: true })),
-    async prompt(id, text) {
-      if (typeof client.session.promptAsync !== "function") {
-        throw Object.assign(new Error("OpenCode asynchronous prompts are unavailable"), { status: 501 });
-      }
-      return unwrap(await client.session.promptAsync({
-        path: { id },
-        query: { directory },
-        body: { parts: [{ type: "text", text }] },
-        throwOnError: true
-      }));
-    }
+function reportAcknowledgement(acknowledgement, pending, reporter, conversation) {
+  const messages = {
+    applied: `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`,
+    expired: "Decision expired before it could be applied",
+    stale: "Permission was already answered locally",
+    rejected: "Decision was rejected by validation"
   };
+  const message = messages[acknowledgement.status];
+  if (!message) return;
+  if (acknowledgement.status === "applied") {
+    reporter.applied(message);
+    conversation?.applied(pending.sessionID, message);
+    return;
+  }
+  reporter.warning(message);
+  conversation?.warning(pending.sessionID, message);
 }
 
-// src/live-connection.js
-import { randomUUID as randomUUID2 } from "node:crypto";
-var LIVE_RECONNECT_MS = 3e3;
-var LIVE_HEARTBEAT_MS = 15e3;
-function createLiveConnectionNotifier(config, reporter) {
-  const epoch = randomUUID2();
-  const controller = new AbortController();
-  let last, sequence = 0, pending, task;
-  async function drain() {
-    while (pending && !controller.signal.aborted) {
-      const event = pending;
-      pending = void 0;
-      try {
-        await postJsonWithRetry(config, config.eventsEndpoint, event, { signal: controller.signal });
-      } catch {
-        if (!controller.signal.aborted) reporter?.error("Live connection notification could not be sent");
+// src/question-command.js
+var QUESTION_ACTIONS = /* @__PURE__ */ new Set(["answer", "reject"]);
+function validateQuestionCommand(command, pending, now = Date.now()) {
+  const response = command?.response;
+  if (!response || !QUESTION_ACTIONS.has(response.action)) {
+    return { status: "rejected", action: response?.action, errorCode: "invalid_action" };
+  }
+  const expiresAt = Date.parse(command.expiresAt);
+  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
+    return { status: "expired", action: response.action };
+  }
+  if (response.action === "reject") return;
+  const errorCode = validateQuestionAnswers(response.answers, pending.questions);
+  if (errorCode) return { status: "rejected", action: response.action, errorCode };
+}
+function validateQuestionAnswers(values, questions) {
+  if (!Array.isArray(values) || values.length !== questions.length) {
+    return "invalid_answers";
+  }
+  for (let index = 0; index < questions.length; index++) {
+    const question = questions[index];
+    const answers = values[index];
+    if (!Array.isArray(answers) || !question.multiple && answers.length > 1) {
+      return "invalid_answers";
+    }
+    for (const answer of answers) {
+      if (typeof answer !== "string" || answer.trim().length === 0) {
+        return "invalid_answers";
+      }
+      const known = question.options.some((option) => option.label === answer);
+      if (!known && !question.custom) {
+        return "custom_not_allowed";
       }
     }
   }
+}
+function questionFailureAcknowledgement(command, error) {
+  const stale = error instanceof HttpError && error.status === 404;
   return {
-    update(connected) {
-      if (controller.signal.aborted || connected === last) return;
-      const initial = last === void 0;
-      last = connected;
-      if (initial || !config.token || !config.eventsEndpoint) return;
-      pending = {
-        type: "application",
-        severity: connected ? "info" : "warning",
-        title: connected ? "OpenCode ba\u011Flant\u0131s\u0131 yeniden kuruldu" : "OpenCode ba\u011Flant\u0131s\u0131 kesildi",
-        body: connected ? "Canl\u0131 takip yeniden ba\u011Fland\u0131. Sunucudaki g\xF6rev otomatik olarak yeniden ba\u015Flat\u0131lmad\u0131." : "Canl\u0131 takip ba\u011Flant\u0131s\u0131 kesildi. Yeniden ba\u011Flanma her 3 saniyede denenecek; sunucudaki g\xF6rev durdurulmad\u0131.",
-        payload: [{ key: "Connection", value: connected ? "reconnected" : "disconnected" }],
-        externalId: `opencode:live:${epoch}:${++sequence}`,
-        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-        notify: true,
-        direction: "in"
-      };
-      task ??= drain().finally(() => {
-        task = void 0;
-      });
-    },
-    async dispose() {
-      controller.abort();
-      pending = void 0;
-      await task;
-    }
+    status: stale ? "stale" : "failed",
+    action: command?.response?.action,
+    errorCode: stale ? "question_not_found" : "opencode_question_reply_failed"
   };
 }
+function reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation) {
+  const messages = {
+    applied: acknowledgement.action === "reject" ? "Question rejected from Backeer" : "Question answered from Backeer",
+    expired: "Question response expired before it could be applied",
+    stale: "Question was already answered locally",
+    rejected: "Question response was rejected by validation"
+  };
+  const message = messages[acknowledgement.status];
+  if (!message) return;
+  if (acknowledgement.status === "applied") {
+    reporter.applied(message);
+    conversation?.applied(pending.sessionID, message);
+  } else {
+    reporter.warning(message);
+    conversation?.warning(pending.sessionID, message);
+  }
+}
 
-// src/live-bridge-events.js
-var ID = /^[A-Za-z0-9_-]{1,160}$/;
-var validBridgeID = (value) => typeof value === "string" && ID.test(value);
-function createBridgeSanitizer(secrets = []) {
-  const known = secrets.filter((value) => typeof value === "string" && value.length > 0);
-  const assistants = /* @__PURE__ */ new Map();
-  function clipped(value, max = 12e3) {
-    if (typeof value !== "string") return { value: "", truncated: false };
-    let result = value.slice(0, 64e3);
-    for (const secret of known) result = result.split(secret).join("[REDACTED]");
-    result = result.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, "[REDACTED PRIVATE KEY]").replace(/\bBearer\s+[^\s"'<>]+/gi, "Bearer [REDACTED]").replace(/\b(?:sk|bgi)_[A-Za-z0-9_-]{12,}|\bsk-[A-Za-z0-9_-]{12,}/g, "[REDACTED]").replace(/((?:api[_-]?key|access[_-]?token|secret|password|authorization)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]");
-    return { value: result.slice(0, max), truncated: value.length > 64e3 || result.length > max };
+// src/sse.js
+function parseSseFrame(frame) {
+  const data = [];
+  let event = "message";
+  let id;
+  for (const line of frame.split(/\r?\n/)) {
+    if (!line || line.startsWith(":")) continue;
+    const separator = line.indexOf(":");
+    const field = separator === -1 ? line : line.slice(0, separator);
+    let value = separator === -1 ? "" : line.slice(separator + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") event = value;
+    if (field === "id") id = value;
+    if (field === "data") data.push(value);
   }
-  function text(value, max) {
-    return clipped(value, max).value;
+  if (data.length === 0) return;
+  return { event, id, data: data.join("\n") };
+}
+function nextSseFrame(buffer) {
+  const lfIndex = buffer.indexOf("\n\n");
+  const crlfIndex = buffer.indexOf("\r\n\r\n");
+  if (lfIndex === -1 && crlfIndex === -1) return;
+  if (crlfIndex !== -1 && (lfIndex === -1 || crlfIndex < lfIndex)) {
+    return {
+      frame: buffer.slice(0, crlfIndex),
+      rest: buffer.slice(crlfIndex + 4)
+    };
   }
-  function content(key, value) {
-    const result = clipped(value);
-    return { [key]: result.value, ...result.truncated ? { truncated: true } : {} };
+  return { frame: buffer.slice(0, lfIndex), rest: buffer.slice(lfIndex + 2) };
+}
+async function consumeSse(response, state, onCommand, signal2, reporter) {
+  if (!response.body) throw new Error("Backeer command stream has no body");
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = "";
+  try {
+    while (!signal2.aborted) {
+      const item = await reader.read();
+      if (item.done) break;
+      buffer += decoder.decode(item.value, { stream: true });
+      for (; ; ) {
+        const next = nextSseFrame(buffer);
+        if (!next) break;
+        buffer = next.rest;
+        state.framesReceived = (state.framesReceived ?? 0) + 1;
+        const message = parseSseFrame(next.frame);
+        if (!message) continue;
+        if (message.id) state.lastEventID = message.id;
+        if (message.event !== "message" && message.event !== "command") continue;
+        try {
+          await onCommand(JSON.parse(message.data));
+        } catch (error) {
+          if (error instanceof SyntaxError) {
+            reporter.error("Invalid command received", "SSE data is not valid JSON");
+            continue;
+          }
+          throw error;
+        }
+      }
+    }
+  } finally {
+    await reader.cancel().catch(() => {
+    });
   }
-  function sanitize(event) {
-    const p = event?.properties ?? event?.data ?? {};
-    const sessionID = p.sessionID ?? p.info?.sessionID ?? p.part?.sessionID;
-    if (!validBridgeID(sessionID) || sessionID === "global") return void 0;
-    const base = { type: event.type, sessionID, data: {} };
-    if (event.type === "message.updated") {
-      const info = p.info;
-      if (!validBridgeID(info?.id)) return void 0;
-      if (info.role === "assistant") {
-        assistants.set(info.id, sessionID);
-        if (assistants.size > 256) assistants.delete(assistants.keys().next().value);
-      }
-      return info.role === "assistant" ? { ...base, data: {
-        messageID: info.id,
-        completed: !!info.time?.completed,
-        failed: !!info.error
-      } } : void 0;
-    }
-    if (event.type === "message.part.updated") {
-      const part = p.part;
-      if (assistants.get(part?.messageID) !== sessionID) return void 0;
-      if (part.type === "text") return { ...base, type: "assistant.text", data: {
-        messageID: part.messageID,
-        ...content("text", part.text),
-        replace: true
-      } };
-      if (part.type !== "tool") return void 0;
-      const state = part.state ?? {};
-      return { ...base, type: "tool.status", data: {
-        tool: text(part.tool, 80),
-        status: text(state.status, 40),
-        ...state.status === "completed" ? content("output", state.output) : {},
-        ...state.status === "error" ? { failed: true } : {}
-      } };
-    }
-    if (event.type === "session.text.ended") return { ...base, type: "assistant.text", data: {
-      messageID: validBridgeID(p.assistantMessageID) ? p.assistantMessageID : void 0,
-      ...content("text", p.text),
-      replace: true
-    } };
-    if (["session.tool.called", "session.tool.success", "session.tool.failed"].includes(event.type)) {
-      return { ...base, type: "tool.status", data: {
-        status: event.type.split(".").at(-1),
-        ...event.type === "session.tool.success" ? content(
-          "output",
-          (p.content ?? []).filter((item) => item?.type === "text").map((item) => item.text).join("\n")
-        ) : {}
-      } };
-    }
-    if (["permission.asked", "question.asked", "question.v2.asked"].includes(event.type)) {
-      return { ...base, type: "approval.waiting", data: { kind: event.type.split(".")[0] } };
-    }
-    if (["permission.replied", "question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"].includes(event.type)) {
-      return { ...base, type: "approval.settled", data: { kind: event.type.split(".")[0] } };
-    }
-    if (event.type === "session.status") return { ...base, data: {
-      status: ["idle", "busy", "retry"].includes(p.status?.type) ? p.status.type : "unknown"
-    } };
-    if (["session.idle", "session.error", "session.deleted"].includes(event.type)) return base;
-    return void 0;
-  }
-  return { sanitize, text, clear: () => assistants.clear() };
-}
-
-// src/live-bridge.js
-var LIMITS = { events: 256, bytes: 2e6, clients: 8, commands: 1024, commandTTL: 864e5, body: 32768, requests: 16 };
-function failure(status, code) {
-  return Object.assign(new Error(code), { status, code });
 }
-function json(response, status, value) {
-  if (!response.destroyed && !response.headersSent) {
-    response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
-    response.end(JSON.stringify(value));
+async function openCommandStream(config, state, signal2, fetchImplementation) {
+  const headers = {
+    Accept: "text/event-stream",
+    Authorization: `Bearer ${config.token}`
+  };
+  if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID;
+  const response = await fetchImplementation(config.commandStreamEndpoint, {
+    headers,
+    signal: signal2
+  });
+  if (!response.ok) {
+    const responseBody = limit(await response.text(), 500);
+    throw new HttpError(
+      `Backeer command stream failed with status ${response.status}`,
+      response.status,
+      responseBody
+    );
   }
-}
-async function readBody(request) {
-  const chunks = [];
-  let bytes = 0;
-  for await (const chunk of request) {
-    bytes += chunk.length;
-    if (bytes > LIMITS.body) throw failure(413, "body_too_large");
-    chunks.push(chunk);
+  if (!response.headers.get("content-type")?.includes("text/event-stream")) {
+    throw new Error("Backeer command stream returned an invalid content type");
   }
+  return response;
+}
+async function consumeConnection({
+  response,
+  state,
+  onCommand,
+  signal: signal2,
+  reporter,
+  now,
+  stableConnectionMs,
+  onStable
+}) {
+  const connectedAt = now();
+  const framesBeforeConnection = state.framesReceived;
   try {
-    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  } catch {
-    throw failure(400, "invalid_json");
+    await consumeSse(response, state, onCommand, signal2, reporter);
+  } finally {
+    const receivedFrame = state.framesReceived > framesBeforeConnection;
+    if (receivedFrame || now() - connectedAt >= stableConnectionMs) onStable();
   }
 }
-async function createLiveBridge({ config, client, directory, reporter }) {
-  const options = config.liveBridge;
-  if (!options?.enabled) return { handle() {
-  }, async dispose() {
-  }, address: void 0 };
-  const token = options.token;
-  if (typeof token !== "string" || token.length < 32 || token === config.token) {
-    throw new Error("Live bridge requires a separate credential of at least 32 characters");
-  }
-  const api = client.liveBridge ?? createV1LiveClient(client, directory);
-  const connectionNotifications = createLiveConnectionNotifier(config, reporter);
-  const sanitizer = createBridgeSanitizer([token, config.token]);
-  const epoch = randomUUID3();
-  const events = [], streams = /* @__PURE__ */ new Set(), commands = /* @__PURE__ */ new Map(), states = /* @__PURE__ */ new Map();
-  let sequence = 0, bytes = 0, active = 0, disposed = false, disposeTask;
-  let lookups = 0;
-  const lookupWaiters = /* @__PURE__ */ new Set();
-  const cursor = () => `${epoch}:${sequence}`;
-  function lookup(id) {
-    if (disposed) return Promise.reject(failure(503, "bridge_closed"));
-    if (lookups >= 16) return Promise.reject(failure(429, "session_lookup_busy"));
-    lookups++;
-    return new Promise((resolve2, reject) => {
-      let finished = false;
-      const finish = (complete, value) => {
-        if (finished) return;
-        finished = true;
-        clearTimeout(timer);
-        lookupWaiters.delete(cancel);
-        complete(value);
-      };
-      const cancel = () => finish(reject, failure(503, "bridge_closed"));
-      const timer = setTimeout(() => finish(reject, failure(504, "session_lookup_timed_out")), 1e3);
-      lookupWaiters.add(cancel);
-      Promise.resolve().then(() => api.get(id)).then(
-        (value) => {
-          lookups--;
-          finish(resolve2, value);
-        },
-        (error) => {
-          lookups--;
-          finish(reject, error);
-        }
-      );
-    });
+function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
+  const message = error instanceof HttpError ? `${error.message}: ${error.responseBody}` : limit(error, 500);
+  if (message !== lastLoggedError) {
+    const authenticationFailure = error instanceof HttpError && [401, 403].includes(error.status);
+    reporter.error(
+      authenticationFailure ? "Authentication failed \u2014 run: npx backeer-opencode@latest configure" : "Connection interrupted \u2014 retrying",
+      message
+    );
   }
-  async function session(id) {
-    if (!validBridgeID(id) || id === "global") throw failure(400, "invalid_session");
-    let info;
+  return {
+    lastLoggedError: message,
+    reconnectDelay: error instanceof HttpError && [401, 403, 404].includes(error.status) ? 6e4 : reconnectDelay
+  };
+}
+async function runCommandStream(config, reporter, {
+  signal: signal2,
+  hasPending,
+  onCommand,
+  fetchImplementation = fetch,
+  sleepImplementation = sleep,
+  now = Date.now,
+  stableConnectionMs = 5e3
+}) {
+  const state = { lastEventID: "", framesReceived: 0 };
+  let reconnectDelay = 1e3;
+  let lastLoggedError = "";
+  while (!signal2.aborted && hasPending()) {
     try {
-      info = await lookup(id);
+      const response = await openCommandStream(
+        config,
+        state,
+        signal2,
+        fetchImplementation
+      );
+      await consumeConnection({
+        response,
+        state,
+        onCommand,
+        signal: signal2,
+        reporter,
+        now,
+        stableConnectionMs,
+        onStable: () => {
+          reconnectDelay = 1e3;
+          lastLoggedError = "";
+        }
+      });
     } catch (error) {
-      if (["session_lookup_busy", "session_lookup_timed_out", "bridge_closed"].includes(error.code)) throw error;
-      throw failure(404, "session_not_found");
+      if (signal2.aborted || isAbortError(error)) return;
+      const next = streamErrorState(error, lastLoggedError, reconnectDelay, reporter);
+      reconnectDelay = next.reconnectDelay;
+      lastLoggedError = next.lastLoggedError;
     }
-    if (info?.id !== id || typeof info.time?.archived === "number" || (info.location?.directory ?? info.directory) !== directory) {
-      throw failure(404, "session_not_found");
+    if (!signal2.aborted && hasPending()) {
+      await sleepImplementation(reconnectDelay, signal2);
+      reconnectDelay = Math.min(reconnectDelay * 2, 6e4);
     }
-    return {
-      id,
-      directory,
-      title: sanitizer.text(info.title, 240),
-      ...validBridgeID(info.parentID) ? { parentID: info.parentID } : {},
-      status: states.get(id) ?? "unknown"
-    };
   }
-  function removeStream(stream) {
-    const removed = streams.delete(stream);
-    clearInterval(stream.heartbeat);
-    stream.queue.length = 0;
-    stream.queuedBytes = 0;
-    if (removed && !streams.size && !disposed) connectionNotifications.update(false);
+}
+
+// src/permission-controller.js
+async function replyToOpenCode(client, pending, decision) {
+  const result = await client.postSessionIdPermissionsPermissionId({
+    path: { id: pending.sessionID, permissionID: pending.requestID },
+    query: { directory: pending.directory },
+    body: { response: decision },
+    throwOnError: true
+  });
+  if (result?.data === false || result === false) {
+    throw new HttpError("OpenCode did not apply the permission reply", 409);
   }
-  function write(stream, value) {
-    if (!streams.has(stream)) return;
-    if (stream.blocked) {
-      stream.queue.push(value);
-      stream.queuedBytes += Buffer.byteLength(value);
-      if (stream.queuedBytes > LIMITS.bytes) {
-        removeStream(stream);
-        stream.response.destroy();
-      }
-      return;
-    }
-    if (!stream.response.write(value)) {
-      stream.blocked = true;
-    }
+}
+async function acknowledgeCommand(config, commandID, acknowledgement) {
+  const url = new URL(
+    `/v1/commands/${encodeURIComponent(commandID)}/ack`,
+    config.origin
+  );
+  await postJsonWithRetry(config, url, acknowledgement);
+}
+function questionResponseError(result) {
+  if (!result?.error) return;
+  const status = Number(result?.response?.status) || 502;
+  const detail = result.error?.data?.message ?? result.error?.message ?? "OpenCode rejected the question response";
+  return new HttpError(String(detail), status);
+}
+function normalizeQuestionError(error) {
+  if (error instanceof HttpError) return error;
+  const status = Number(error?.status ?? error?.statusCode ?? error?.cause?.status);
+  if (!Number.isFinite(status)) return error;
+  return new HttpError(error?.message || "OpenCode rejected the question response", status);
+}
+function rawQuestionRequest(client, pending, response, isV2) {
+  const transport = client?._client;
+  if (typeof transport?.post !== "function") {
+    throw new HttpError("This OpenCode version cannot apply remote question replies", 501);
   }
-  async function handle(event) {
-    if (disposed) return;
-    const safe = sanitizer.sanitize(event);
-    if (!safe) return;
-    try {
-      await session(safe.sessionID);
-    } catch {
-      return;
+  const rejecting = response.action === "reject";
+  if (isV2) {
+    return transport.post({
+      url: `/api/session/{sessionID}/question/{requestID}/${rejecting ? "reject" : "reply"}`,
+      path: { sessionID: pending.sessionID, requestID: pending.requestID },
+      ...rejecting ? {} : { body: { answers: response.answers } },
+      ...rejecting ? {} : { headers: { "Content-Type": "application/json" } },
+      throwOnError: true
+    });
+  }
+  return transport.post({
+    url: `/question/{requestID}/${rejecting ? "reject" : "reply"}`,
+    path: { requestID: pending.requestID },
+    query: { directory: pending.directory },
+    ...rejecting ? {} : { body: { answers: response.answers } },
+    ...rejecting ? {} : { headers: { "Content-Type": "application/json" } },
+    throwOnError: true
+  });
+}
+async function replyToQuestion(client, pending, response) {
+  const isV2 = pending.sourceEvent === "question.v2.asked";
+  const api = isV2 ? client?.v2?.session?.question : client?.question;
+  const method = response.action === "reject" ? api?.reject : api?.reply;
+  const input = isV2 ? {
+    sessionID: pending.sessionID,
+    requestID: pending.requestID,
+    directory: pending.directory,
+    ...response.action === "answer" ? { questionV2Reply: { answers: response.answers } } : {}
+  } : {
+    requestID: pending.requestID,
+    directory: pending.directory,
+    ...response.action === "answer" ? { answers: response.answers } : {}
+  };
+  let result;
+  try {
+    result = typeof method === "function" ? await method.call(api, input, { throwOnError: true }) : await rawQuestionRequest(client, pending, response, isV2);
+  } catch (error) {
+    throw normalizeQuestionError(error);
+  }
+  const responseError = questionResponseError(result);
+  if (responseError) throw responseError;
+  if (result?.data === false || result === false) {
+    throw new HttpError("OpenCode did not apply the question response", 409);
+  }
+}
+async function postQuestionState(config, eventID, path, body = {}) {
+  const url = new URL(`/v1/events/${encodeURIComponent(eventID)}/${path}`, config.origin);
+  await postJsonWithRetry(config, url, body, { retryDelays: [0, 500] });
+}
+function createPermissionController({
+  config,
+  reporter,
+  client,
+  directory,
+  conversation
+}) {
+  const pendingByExternalID = /* @__PURE__ */ new Map();
+  const externalIDByRequestID = /* @__PURE__ */ new Map();
+  const questionsByExternalID = /* @__PURE__ */ new Map();
+  const questionExternalIDByRequestID = /* @__PURE__ */ new Map();
+  const remotelyResolvingQuestions = /* @__PURE__ */ new Set();
+  const processingCommands = /* @__PURE__ */ new Set();
+  const completedCommands = /* @__PURE__ */ new Map();
+  let commandStream;
+  let leaseTimer;
+  let disposed = false;
+  function removePendingByRequestID(requestID) {
+    const externalId = externalIDByRequestID.get(requestID);
+    if (!externalId) return;
+    externalIDByRequestID.delete(requestID);
+    pendingByExternalID.delete(externalId);
+  }
+  function stopCommandStreamIfIdle() {
+    if (pendingByExternalID.size === 0 && questionsByExternalID.size === 0) {
+      commandStream?.controller.abort();
     }
-    if (disposed) return;
-    if (safe.type === "session.status") states.set(safe.sessionID, safe.data.status);
-    if (safe.type === "session.idle") states.set(safe.sessionID, "idle");
-    if (safe.type === "session.deleted") states.delete(safe.sessionID);
-    if (states.size > 256) states.delete(states.keys().next().value);
-    const record = { id: `${epoch}:${++sequence}`, ...safe, timestamp: Date.now() };
-    let frame = `id: ${record.id}
-event: backeer.event
-data: ${JSON.stringify(record)}
-
-`;
-    if (Buffer.byteLength(frame) > 32768) {
-      record.data = { truncated: true };
-      frame = `id: ${record.id}
-event: backeer.event
-data: ${JSON.stringify(record)}
-
-`;
+  }
+  function removeQuestionByRequestID(requestID) {
+    const externalId = questionExternalIDByRequestID.get(requestID);
+    if (!externalId) return;
+    questionExternalIDByRequestID.delete(requestID);
+    questionsByExternalID.delete(externalId);
+    if (questionsByExternalID.size === 0 && leaseTimer) {
+      clearInterval(leaseTimer);
+      leaseTimer = void 0;
     }
-    const size = Buffer.byteLength(frame);
-    events.push({ sequence, sessionID: record.sessionID, frame, size });
-    bytes += size;
-    while (events.length > LIMITS.events || bytes > LIMITS.bytes) bytes -= events.shift().size;
-    for (const stream of streams) if (!stream.sessionID || stream.sessionID === record.sessionID) write(stream, frame);
   }
-  function authorized(request) {
-    if (request.headers.origin || request.headers["sec-fetch-site"]) return false;
-    const expected = Buffer.from(`Bearer ${token}`);
-    const actual = Buffer.from(request.headers.authorization ?? "");
-    return actual.length === expected.length && timingSafeEqual(actual, expected);
+  async function renewQuestionLeases() {
+    for (const pending of questionsByExternalID.values()) {
+      if (!pending.eventID) continue;
+      await postQuestionState(config, pending.eventID, "lease").catch((error) => {
+        reporter.warning("Question lease could not be renewed", error);
+      });
+    }
   }
-  function parseCursor(value) {
-    if (!value) return { after: 0 };
-    const match = /^([a-f0-9-]{36}):(\d{1,16})$/.exec(value);
-    if (!match) throw failure(400, "invalid_cursor");
-    if (match[1] !== epoch) return { gap: "stream_restarted" };
-    const after = Number(match[2]);
-    if (!Number.isSafeInteger(after) || after > sequence) throw failure(400, "invalid_cursor");
-    if (events.length && after < events[0].sequence - 1) return { gap: "cursor_expired" };
-    return { after };
+  function ensureLeaseTimer() {
+    if (leaseTimer || questionsByExternalID.size === 0) return;
+    leaseTimer = setInterval(() => void renewQuestionLeases(), 6e4);
+    leaseTimer.unref?.();
   }
-  async function route(request, response) {
-    if (!authorized(request)) return json(response, 401, { error: "unauthorized" });
-    if (request.headers["x-backeer-project"] !== void 0 && request.headers["x-backeer-project"] !== encodeURIComponent(directory)) {
-      return json(response, 409, { error: "project_mismatch" });
+  async function handleCommand(command) {
+    if (!command || typeof command !== "object") return;
+    if (!["opencode_permission_reply", "opencode_question_reply"].includes(command.type)) return;
+    if (typeof command.id !== "string" || command.id.length > 200) return;
+    const previousAcknowledgement = completedCommands.get(command.id);
+    if (previousAcknowledgement) {
+      await acknowledgeCommand(config, command.id, previousAcknowledgement).catch((error) => reporter.warning("Decision receipt retry failed", error));
+      return;
     }
-    if (active >= LIMITS.requests) return json(response, 429, { error: "bridge_busy" });
-    active++;
-    const timeout = setTimeout(() => json(response, 504, { error: "request_timed_out" }), 15e3);
-    timeout.unref();
+    if (processingCommands.has(command.id)) return;
+    if (typeof command.externalId !== "string") return;
+    const isQuestion = command.type === "opencode_question_reply";
+    const pending = isQuestion ? questionsByExternalID.get(command.externalId) : pendingByExternalID.get(command.externalId);
+    if (!pending) return;
+    processingCommands.add(command.id);
+    let acknowledgement = isQuestion ? validateQuestionCommand(command, pending) : validatePermissionCommand(command);
     try {
-      const url = new URL(request.url, "http://127.0.0.1");
-      if (url.username || url.password) throw failure(400, "invalid_url");
-      if (request.method === "GET" && url.pathname === "/v1/sessions") {
-        const result = await api.list();
-        const values = Array.isArray(result) ? result : result?.data;
-        if (!Array.isArray(values)) throw failure(502, "invalid_session_list");
-        const own = values.slice(0, 100).filter((info) => validBridgeID(info?.id) && typeof info.time?.archived !== "number" && (info.location?.directory ?? info.directory) === directory);
-        return json(response, 200, { sessions: own.map((info) => ({
-          id: info.id,
-          title: sanitizer.text(info.title, 240),
-          status: states.get(info.id) ?? "unknown",
-          ...validBridgeID(info.parentID) ? { parentID: info.parentID } : {}
-        })), directory, cursor: cursor() });
-      }
-      if (request.method === "GET" && url.pathname === "/v1/events") {
-        const selected = url.searchParams.get("sessionID") || void 0;
-        if (selected) await session(selected);
-        const parsed = parseCursor(url.searchParams.get("after") ?? request.headers["last-event-id"]);
-        if (response.headersSent) return;
-        if (streams.size >= LIMITS.clients) throw failure(429, "too_many_streams");
-        clearTimeout(timeout);
-        response.writeHead(200, {
-          "content-type": "text/event-stream",
-          "cache-control": "no-cache, no-transform",
-          "x-accel-buffering": "no",
-          connection: "keep-alive"
-        });
-        if (parsed.gap) {
-          response.end(`event: backeer.gap
-data: ${JSON.stringify({ reason: parsed.gap, cursor: cursor() })}
-
-`);
-          return;
-        }
-        const stream = {
-          response,
-          sessionID: selected,
-          heartbeat: void 0,
-          blocked: false,
-          queue: [],
-          queuedBytes: 0
-        };
-        streams.add(stream);
-        connectionNotifications.update(true);
-        request.socket.setTimeout(0);
-        request.socket.setKeepAlive(true, LIVE_HEARTBEAT_MS);
-        response.on("close", () => removeStream(stream));
-        response.on("drain", () => {
-          stream.blocked = false;
-          while (streams.has(stream) && !stream.blocked && stream.queue.length) {
-            const next = stream.queue.shift();
-            stream.queuedBytes -= Buffer.byteLength(next);
-            write(stream, next);
-          }
-        });
-        write(stream, `: connected
-retry: ${LIVE_RECONNECT_MS}
-
-`);
-        for (const item of events) {
-          if (!streams.has(stream)) break;
-          if (item.sequence > parsed.after && (!selected || selected === item.sessionID)) write(stream, item.frame);
-        }
-        if (streams.has(stream)) {
-          stream.heartbeat = setInterval(() => write(stream, ": heartbeat\n\n"), LIVE_HEARTBEAT_MS);
-          stream.heartbeat.unref();
+      if (!acknowledgement) {
+        if (isQuestion) {
+          remotelyResolvingQuestions.add(pending.requestID);
+          await replyToQuestion(client, pending, command.response);
+          acknowledgement = { status: "applied", action: command.response.action };
+          removeQuestionByRequestID(pending.requestID);
+          const cleanup = setTimeout(
+            () => remotelyResolvingQuestions.delete(pending.requestID),
+            3e4
+          );
+          cleanup.unref?.();
+        } else {
+          await replyToOpenCode(client, pending, command.decision);
+          acknowledgement = { status: "applied", decision: command.decision };
+          removePendingByRequestID(pending.requestID);
         }
-        return;
       }
-      const match = /^\/v1\/sessions\/([A-Za-z0-9_-]{1,160})(\/instructions)?$/.exec(url.pathname);
-      if (!match) throw failure(404, "route_not_found");
-      if (request.method === "GET" && !match[2]) return json(response, 200, await session(match[1]));
-      if (request.method !== "POST" || !match[2]) throw failure(405, "method_not_allowed");
-      if (!/^application\/json(?:;|$)/i.test(request.headers["content-type"] ?? "")) throw failure(415, "json_required");
-      const body = await readBody(request);
-      if (!body || !validBridgeID(body.requestId) || typeof body.prompt !== "string" || !body.prompt.trim() || body.prompt.length > 16e3 || Object.keys(body).some((key) => !["requestId", "prompt"].includes(key))) throw failure(400, "invalid_instruction");
-      await session(match[1]);
-      if (response.headersSent || disposed) return;
-      for (const [id, command2] of commands) {
-        if (command2.settled && Date.now() - command2.created >= LIMITS.commandTTL) commands.delete(id);
+    } catch (error) {
+      if (isQuestion) remotelyResolvingQuestions.delete(pending.requestID);
+      acknowledgement = isQuestion ? questionFailureAcknowledgement(command, error) : failureAcknowledgement(command, error);
+      if (acknowledgement.status === "stale") {
+        if (isQuestion) removeQuestionByRequestID(pending.requestID);
+        else removePendingByRequestID(pending.requestID);
+      }
+      const message = isQuestion ? "Question response could not be applied" : "Decision could not be applied";
+      reporter.error(message, error);
+      conversation?.error(pending.sessionID, message);
+    } finally {
+      processingCommands.delete(command.id);
+    }
+    acknowledgement = {
+      ...acknowledgement,
+      type: isQuestion ? "opencode_question_reply_ack" : "opencode_permission_reply_ack",
+      externalId: command.externalId,
+      processedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    rememberBounded(completedCommands, command.id, acknowledgement);
+    if (isQuestion) {
+      reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation);
+    } else {
+      reportAcknowledgement(acknowledgement, pending, reporter, conversation);
+    }
+    await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {
+      reporter.warning("Decision receipt could not be sent", error);
+    });
+    stopCommandStreamIfIdle();
+  }
+  function ensureCommandStream() {
+    const hasPending = () => pendingByExternalID.size > 0 || questionsByExternalID.size > 0;
+    if (disposed || commandStream || !hasPending()) return;
+    const controller = new AbortController();
+    const current = {
+      controller,
+      task: runCommandStream(config, reporter, {
+        signal: controller.signal,
+        hasPending,
+        onCommand: handleCommand
+      })
+    };
+    commandStream = current;
+    void current.task.finally(() => {
+      if (commandStream === current) commandStream = void 0;
+      if (!disposed && hasPending()) ensureCommandStream();
+    });
+  }
+  return {
+    register(identity) {
+      pendingByExternalID.set(identity.externalId, { ...identity, directory });
+      externalIDByRequestID.set(identity.requestID, identity.externalId);
+      ensureCommandStream();
+    },
+    resolveLocally(requestID) {
+      removePendingByRequestID(requestID);
+      stopCommandStreamIfIdle();
+    },
+    registerQuestion(identity, details) {
+      questionsByExternalID.set(identity.externalId, {
+        ...identity,
+        ...details,
+        directory
+      });
+      questionExternalIDByRequestID.set(identity.requestID, identity.externalId);
+      ensureLeaseTimer();
+      ensureCommandStream();
+    },
+    resolveQuestionLocally(requestID, outcome) {
+      if (remotelyResolvingQuestions.delete(requestID)) {
+        removeQuestionByRequestID(requestID);
+        stopCommandStreamIfIdle();
+        return;
       }
-      const existing = commands.get(body.requestId);
-      if (existing) {
-        if (existing.sessionID !== match[1] || existing.prompt !== body.prompt) throw failure(409, "request_id_conflict");
-        await existing.task;
-        return json(response, 200, existing.result);
+      const externalId = questionExternalIDByRequestID.get(requestID);
+      const pending = externalId ? questionsByExternalID.get(externalId) : void 0;
+      if (!pending) return;
+      removeQuestionByRequestID(requestID);
+      if (pending.eventID) {
+        void postQuestionState(config, pending.eventID, "source-resolution", { outcome }).catch((error) => reporter.warning("Local question state could not be sent", error));
       }
-      if (commands.size >= LIMITS.commands) throw failure(429, "command_window_full");
-      const command = {
-        sessionID: match[1],
-        prompt: body.prompt,
-        created: Date.now(),
-        settled: false,
-        result: { requestId: body.requestId, sessionID: match[1], status: "accepted" },
-        task: void 0
+      stopCommandStreamIfIdle();
+    },
+    refreshCredentials() {
+      commandStream?.controller.abort();
+      if (!commandStream) ensureCommandStream();
+    },
+    status() {
+      return {
+        pending: pendingByExternalID.size,
+        pendingQuestions: questionsByExternalID.size,
+        stream: commandStream ? "active" : "idle"
       };
-      commands.set(body.requestId, command);
-      command.task = Promise.resolve().then(() => api.prompt(match[1], body.prompt)).finally(() => {
-        command.settled = true;
+    },
+    async dispose() {
+      disposed = true;
+      commandStream?.controller.abort();
+      if (leaseTimer) clearInterval(leaseTimer);
+      await commandStream?.task.catch(() => {
       });
-      await command.task;
-      return json(response, 202, command.result);
-    } catch (error) {
-      json(response, error.status ?? 502, { error: error.code ?? "opencode_request_failed" });
-    } finally {
-      active--;
-      clearTimeout(timeout);
+      pendingByExternalID.clear();
+      externalIDByRequestID.clear();
+      processingCommands.clear();
+      completedCommands.clear();
+      questionsByExternalID.clear();
+      questionExternalIDByRequestID.clear();
+      remotelyResolvingQuestions.clear();
+    }
+  };
+}
+
+// src/live-session-scope.js
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { realpath } from "node:fs/promises";
+import { isAbsolute as isAbsolute2 } from "node:path";
+var run = promisify(execFile);
+async function commonDirectory(directory) {
+  const { stdout } = await run(
+    "git",
+    ["-C", directory, "rev-parse", "--path-format=absolute", "--git-common-dir"],
+    { timeout: 1e3, maxBuffer: 8192, windowsHide: true }
+  );
+  return realpath(stdout.trim());
+}
+function approvedWorktreeSessions(value) {
+  if (!Array.isArray(value) || value.length > 16) return [];
+  return value.filter((item) => /^[A-Za-z0-9_-]{1,160}$/.test(item?.sessionID) && item.sessionID !== "global" && typeof item.directory === "string" && isAbsolute2(item.directory) && item.directory.length <= 4096);
+}
+function createSessionScope(directory, { resolveCommon = commonDirectory, approvedSessions = [] } = {}) {
+  const observed = /* @__PURE__ */ new Map();
+  const approved = approvedWorktreeSessions(approvedSessions);
+  return async function owns(info) {
+    const location = info?.location?.directory ?? info?.directory;
+    if (typeof location !== "string" || typeof directory !== "string") return false;
+    if (location === directory) {
+      if (info.id) {
+        observed.set(info.id, info.projectID);
+        if (observed.size > 256) observed.delete(observed.keys().next().value);
+      }
+      return true;
+    }
+    const explicitlyApproved = approved.some((item) => item.sessionID === info.id && item.directory === location);
+    if (!explicitlyApproved && (!observed.has(info.id) || !info.projectID || observed.get(info.id) !== info.projectID)) return false;
+    try {
+      const [base, current] = await Promise.all([resolveCommon(directory), resolveCommon(location)]);
+      return base === current;
+    } catch {
+      return false;
     }
+  };
+}
+
+// src/live-bridge-client.js
+function createV2LiveClient(ctx) {
+  const approvedSessions = approvedWorktreeSessions(ctx.options?.liveBridge?.sessionWorktrees);
+  const known = new Map(approvedSessions.map((item) => [item.sessionID, void 0]));
+  const ownsSession = createSessionScope(ctx.location?.directory, { approvedSessions });
+  let disposed = false;
+  async function get(id) {
+    const info = await ctx.session.get({ sessionID: id });
+    if (disposed) return info;
+    await ownsSession(info);
+    known.set(id, info);
+    if (known.size > 100) known.delete(known.keys().next().value);
+    return info;
   }
-  const server = createServer((request, response) => {
-    void route(request, response);
-  });
-  server.requestTimeout = 15e3;
-  server.headersTimeout = 1e4;
-  server.keepAliveTimeout = 5e3;
-  await new Promise((resolve2, reject) => {
-    server.once("error", reject);
-    server.listen(options.port ?? 43871, "127.0.0.1", () => {
-      server.off("error", reject);
-      resolve2();
-    });
-  });
-  server.on("error", () => {
-  });
   return {
-    handle,
-    address: server.address(),
-    dispose() {
-      disposeTask ??= new Promise((resolve2) => {
-        disposed = true;
-        for (const cancel of lookupWaiters) cancel();
-        for (const stream of streams) {
-          removeStream(stream);
-          stream.response.destroy();
+    async list() {
+      const refreshed = [];
+      if (typeof ctx.session.list === "function") {
+        const result = await ctx.session.list({ directory: ctx.location.directory, limit: 100, order: "desc" });
+        const values = Array.isArray(result) ? result : result?.data;
+        if (!Array.isArray(values)) throw new Error("Invalid native session list");
+        for (const info of values.slice(0, 100)) {
+          if (await ownsSession(info)) {
+            refreshed.push(info);
+            known.set(info.id, info);
+          }
         }
-        server.close(() => {
-          void connectionNotifications.dispose().then(resolve2);
-        });
-        server.closeAllConnections?.();
-        events.length = 0;
-        states.clear();
-        commands.clear();
-        sanitizer.clear();
-        api.dispose?.();
-      });
-      return disposeTask;
+      }
+      for (const id of [...known.keys()].slice(0, 100)) {
+        if (refreshed.some((info) => info.id === id)) continue;
+        try {
+          refreshed.push(await get(id));
+        } catch {
+          known.delete(id);
+        }
+      }
+      return refreshed;
+    },
+    get,
+    ownsSession,
+    prompt: (id, text) => ctx.session.prompt({ sessionID: id, text, delivery: "queue" }),
+    dispose: () => {
+      disposed = true;
+      known.clear();
     }
   };
 }
-
-// src/permission-command.js
-var ALLOWED_DECISIONS = /* @__PURE__ */ new Set(["once", "always", "reject"]);
-var DECISION_LABELS = {
-  once: "Allow once",
-  always: "Always allow",
-  reject: "Reject"
-};
-function validatePermissionCommand(command, now = Date.now()) {
-  if (!ALLOWED_DECISIONS.has(command.decision)) {
-    return {
-      status: "rejected",
-      decision: command.decision,
-      errorCode: "invalid_decision"
-    };
-  }
-  const expiresAt = Date.parse(command.expiresAt);
-  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
-    return { status: "expired", decision: command.decision };
-  }
-  if (command.decision === "always" && command.confirmed !== true) {
-    return {
-      status: "rejected",
-      decision: command.decision,
-      errorCode: "confirmation_required"
-    };
-  }
+function unwrap(value) {
+  if (value?.error) throw new Error("OpenCode request failed");
+  return value?.data ?? value;
 }
-function failureAcknowledgement(command, error) {
-  const stale = error instanceof HttpError && error.status === 404;
+function createV1LiveClient(client, directory) {
   return {
-    status: stale ? "stale" : "failed",
-    decision: command.decision,
-    errorCode: stale ? "permission_not_found" : "opencode_reply_failed"
+    async questions(sessionID) {
+      const result = typeof client.question?.list === "function" ? await client.question.list({ directory }, { throwOnError: true }) : typeof client._client?.get === "function" ? await client._client.get({ url: "/question", query: { directory }, throwOnError: true }) : (() => {
+        throw Object.assign(new Error("Question listing unavailable"), { status: 501 });
+      })();
+      const values = unwrap(result);
+      if (!Array.isArray(values)) throw new Error("Invalid question list");
+      return values.filter((question) => question.sessionID === sessionID);
+    },
+    answerQuestion: (pending, answers) => replyToQuestion(
+      client,
+      { ...pending, requestID: pending.id, directory, sourceEvent: "question.asked" },
+      { action: "answer", answers }
+    ),
+    list: async () => unwrap(await client.session.list({ query: { directory }, throwOnError: true })),
+    get: async (id) => unwrap(await client.session.get({ path: { id }, query: { directory }, throwOnError: true })),
+    async prompt(id, text) {
+      if (typeof client.session.promptAsync !== "function") {
+        throw Object.assign(new Error("OpenCode asynchronous prompts are unavailable"), { status: 501 });
+      }
+      return unwrap(await client.session.promptAsync({
+        path: { id },
+        query: { directory },
+        body: { parts: [{ type: "text", text }] },
+        throwOnError: true
+      }));
+    }
   };
 }
-function reportAcknowledgement(acknowledgement, pending, reporter, conversation) {
-  const messages = {
-    applied: `Decision applied: ${DECISION_LABELS[acknowledgement.decision]}`,
-    expired: "Decision expired before it could be applied",
-    stale: "Permission was already answered locally",
-    rejected: "Decision was rejected by validation"
-  };
-  const message = messages[acknowledgement.status];
-  if (!message) return;
-  if (acknowledgement.status === "applied") {
-    reporter.applied(message);
-    conversation?.applied(pending.sessionID, message);
-    return;
+
+// src/live-connection.js
+import { randomUUID as randomUUID2 } from "node:crypto";
+var LIVE_RECONNECT_MS = 3e3;
+var LIVE_HEARTBEAT_MS = 15e3;
+function createLiveConnectionNotifier(config, reporter) {
+  const epoch = randomUUID2();
+  const controller = new AbortController();
+  let last, sequence = 0, pending, task;
+  async function drain() {
+    while (pending && !controller.signal.aborted) {
+      const event = pending;
+      pending = void 0;
+      try {
+        await postJsonWithRetry(config, config.eventsEndpoint, event, { signal: controller.signal });
+      } catch {
+        if (!controller.signal.aborted) reporter?.error("Live connection notification could not be sent");
+      }
+    }
   }
-  reporter.warning(message);
-  conversation?.warning(pending.sessionID, message);
+  return {
+    update(connected) {
+      if (controller.signal.aborted || connected === last) return;
+      const initial = last === void 0;
+      last = connected;
+      if (initial || !config.token || !config.eventsEndpoint) return;
+      pending = {
+        type: "application",
+        severity: connected ? "info" : "warning",
+        title: connected ? "OpenCode ba\u011Flant\u0131s\u0131 yeniden kuruldu" : "OpenCode ba\u011Flant\u0131s\u0131 kesildi",
+        body: connected ? "Canl\u0131 takip yeniden ba\u011Fland\u0131. Sunucudaki g\xF6rev otomatik olarak yeniden ba\u015Flat\u0131lmad\u0131." : "Canl\u0131 takip ba\u011Flant\u0131s\u0131 kesildi. Yeniden ba\u011Flanma her 3 saniyede denenecek; sunucudaki g\xF6rev durdurulmad\u0131.",
+        payload: [{ key: "Connection", value: connected ? "reconnected" : "disconnected" }],
+        externalId: `opencode:live:${epoch}:${++sequence}`,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        notify: true,
+        direction: "in"
+      };
+      task ??= drain().finally(() => {
+        task = void 0;
+      });
+    },
+    async dispose() {
+      controller.abort();
+      pending = void 0;
+      await task;
+    }
+  };
 }
 
-// src/question-command.js
-var QUESTION_ACTIONS = /* @__PURE__ */ new Set(["answer", "reject"]);
-function validateQuestionCommand(command, pending, now = Date.now()) {
-  const response = command?.response;
-  if (!response || !QUESTION_ACTIONS.has(response.action)) {
-    return { status: "rejected", action: response?.action, errorCode: "invalid_action" };
+// src/live-bridge-events.js
+var ID = /^[A-Za-z0-9_-]{1,160}$/;
+var validBridgeID = (value) => typeof value === "string" && ID.test(value);
+function createBridgeSanitizer(secrets = []) {
+  const known = secrets.filter((value) => typeof value === "string" && value.length > 0);
+  const assistants = /* @__PURE__ */ new Map();
+  function clipped(value, max = 12e3) {
+    if (typeof value !== "string") return { value: "", truncated: false };
+    let result = value.slice(0, 64e3);
+    for (const secret of known) result = result.split(secret).join("[REDACTED]");
+    result = result.replace(/-----BEGIN [^-]*PRIVATE KEY-----[\s\S]*?(?:-----END [^-]*PRIVATE KEY-----|$)/g, "[REDACTED PRIVATE KEY]").replace(/\bBearer\s+[^\s"'<>]+/gi, "Bearer [REDACTED]").replace(/\b(?:sk|bgi)_[A-Za-z0-9_-]{12,}|\bsk-[A-Za-z0-9_-]{12,}/g, "[REDACTED]").replace(/((?:api[_-]?key|access[_-]?token|secret|password|authorization)\s*[=:]\s*)[^\s,;]+/gi, "$1[REDACTED]");
+    return { value: result.slice(0, max), truncated: value.length > 64e3 || result.length > max };
   }
-  const expiresAt = Date.parse(command.expiresAt);
-  if (!Number.isFinite(expiresAt) || expiresAt <= now) {
-    return { status: "expired", action: response.action };
+  function text(value, max) {
+    return clipped(value, max).value;
   }
-  if (response.action === "reject") return;
-  if (!Array.isArray(response.answers) || response.answers.length !== pending.questions.length) {
-    return { status: "rejected", action: response.action, errorCode: "invalid_answers" };
+  function content(key, value) {
+    const result = clipped(value);
+    return { [key]: result.value, ...result.truncated ? { truncated: true } : {} };
   }
-  for (let index = 0; index < pending.questions.length; index++) {
-    const question = pending.questions[index];
-    const answers = response.answers[index];
-    if (!Array.isArray(answers) || !question.multiple && answers.length > 1) {
-      return { status: "rejected", action: response.action, errorCode: "invalid_answers" };
+  function sanitize(event) {
+    const p = event?.properties ?? event?.data ?? {};
+    const sessionID = p.sessionID ?? p.info?.sessionID ?? p.part?.sessionID;
+    if (!validBridgeID(sessionID) || sessionID === "global") return void 0;
+    const base = { type: event.type, sessionID, data: {} };
+    if (event.type === "message.updated") {
+      const info = p.info;
+      if (!validBridgeID(info?.id)) return void 0;
+      if (info.role === "assistant") {
+        assistants.set(info.id, sessionID);
+        if (assistants.size > 256) assistants.delete(assistants.keys().next().value);
+      }
+      return info.role === "assistant" ? { ...base, data: {
+        messageID: info.id,
+        completed: !!info.time?.completed,
+        failed: !!info.error
+      } } : void 0;
+    }
+    if (event.type === "message.part.updated") {
+      const part = p.part;
+      if (assistants.get(part?.messageID) !== sessionID) return void 0;
+      if (part.type === "text") return { ...base, type: "assistant.text", data: {
+        messageID: part.messageID,
+        ...content("text", part.text),
+        replace: true
+      } };
+      if (part.type !== "tool") return void 0;
+      const state = part.state ?? {};
+      return { ...base, type: "tool.status", data: {
+        tool: text(part.tool, 80),
+        status: text(state.status, 40),
+        ...state.status === "completed" ? content("output", state.output) : {},
+        ...state.status === "error" ? { failed: true } : {}
+      } };
+    }
+    if (event.type === "session.text.ended") return { ...base, type: "assistant.text", data: {
+      messageID: validBridgeID(p.assistantMessageID) ? p.assistantMessageID : void 0,
+      ...content("text", p.text),
+      replace: true
+    } };
+    if (["session.tool.called", "session.tool.success", "session.tool.failed"].includes(event.type)) {
+      return { ...base, type: "tool.status", data: {
+        status: event.type.split(".").at(-1),
+        ...event.type === "session.tool.success" ? content(
+          "output",
+          (p.content ?? []).filter((item) => item?.type === "text").map((item) => item.text).join("\n")
+        ) : {}
+      } };
     }
-    for (const answer of answers) {
-      if (typeof answer !== "string" || answer.trim().length === 0) {
-        return { status: "rejected", action: response.action, errorCode: "invalid_answers" };
-      }
-      const known = question.options.some((option) => option.label === answer);
-      if (!known && !question.custom) {
-        return { status: "rejected", action: response.action, errorCode: "custom_not_allowed" };
-      }
+    if (["permission.asked", "question.asked", "question.v2.asked"].includes(event.type)) {
+      return { ...base, type: "approval.waiting", data: {
+        kind: event.type.split(".")[0],
+        ...event.type !== "permission.asked" && validBridgeID(p.id ?? p.requestID) ? { questionId: p.id ?? p.requestID } : {}
+      } };
     }
+    if (["permission.replied", "question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"].includes(event.type)) {
+      return { ...base, type: "approval.settled", data: { kind: event.type.split(".")[0] } };
+    }
+    if (event.type === "session.status") return { ...base, data: {
+      status: ["idle", "busy", "retry"].includes(p.status?.type) ? p.status.type : "unknown"
+    } };
+    if (["session.idle", "session.error", "session.deleted"].includes(event.type)) return base;
+    return void 0;
   }
-}
-function questionFailureAcknowledgement(command, error) {
-  const stale = error instanceof HttpError && error.status === 404;
-  return {
-    status: stale ? "stale" : "failed",
-    action: command?.response?.action,
-    errorCode: stale ? "question_not_found" : "opencode_question_reply_failed"
-  };
-}
-function reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation) {
-  const messages = {
-    applied: acknowledgement.action === "reject" ? "Question rejected from Backeer" : "Question answered from Backeer",
-    expired: "Question response expired before it could be applied",
-    stale: "Question was already answered locally",
-    rejected: "Question response was rejected by validation"
-  };
-  const message = messages[acknowledgement.status];
-  if (!message) return;
-  if (acknowledgement.status === "applied") {
-    reporter.applied(message);
-    conversation?.applied(pending.sessionID, message);
-  } else {
-    reporter.warning(message);
-    conversation?.warning(pending.sessionID, message);
-  }
+  return { sanitize, text, clear: () => assistants.clear() };
 }
 
-// src/sse.js
-function parseSseFrame(frame) {
-  const data = [];
-  let event = "message";
-  let id;
-  for (const line of frame.split(/\r?\n/)) {
-    if (!line || line.startsWith(":")) continue;
-    const separator = line.indexOf(":");
-    const field = separator === -1 ? line : line.slice(0, separator);
-    let value = separator === -1 ? "" : line.slice(separator + 1);
-    if (value.startsWith(" ")) value = value.slice(1);
-    if (field === "event") event = value;
-    if (field === "id") id = value;
-    if (field === "data") data.push(value);
-  }
-  if (data.length === 0) return;
-  return { event, id, data: data.join("\n") };
-}
-function nextSseFrame(buffer) {
-  const lfIndex = buffer.indexOf("\n\n");
-  const crlfIndex = buffer.indexOf("\r\n\r\n");
-  if (lfIndex === -1 && crlfIndex === -1) return;
-  if (crlfIndex !== -1 && (lfIndex === -1 || crlfIndex < lfIndex)) {
+// src/live-questions.js
+import { createHash } from "node:crypto";
+var invalid = (code = "invalid_question_answer", status = 422) => Object.assign(new Error(code), { code, status });
+function questionSnapshot(pending, text) {
+  if (!validBridgeID(pending?.id) || !validBridgeID(pending?.sessionID) || pending.sessionID === "global" || !Array.isArray(pending.questions) || !pending.questions.length || pending.questions.length > 16) throw invalid("unsupported_question");
+  const questions = pending.questions.map((question, index) => {
+    if (typeof question.question !== "string" || !Array.isArray(question.options) || question.options.length > 32 || question.options.some((option) => typeof option?.label !== "string") || new Set(question.options.map((option) => option.label)).size !== question.options.length) {
+      throw invalid("unsupported_question");
+    }
     return {
-      frame: buffer.slice(0, crlfIndex),
-      rest: buffer.slice(crlfIndex + 4)
+      index,
+      header: text(question.header, 240),
+      question: text(question.question, 2e3),
+      multiple: question.multiple === true,
+      custom: question.custom === true,
+      options: question.options.map((option, index2) => ({
+        index: index2,
+        label: text(option.label, 500),
+        description: text(option.description, 1e3)
+      }))
     };
-  }
-  return { frame: buffer.slice(0, lfIndex), rest: buffer.slice(lfIndex + 2) };
+  });
+  const revision = createHash("sha256").update(JSON.stringify({
+    id: pending.id,
+    sessionID: pending.sessionID,
+    questions: pending.questions,
+    ...pending.nativeRevision ? { nativeRevision: pending.nativeRevision } : {}
+  })).digest("hex");
+  const result = { questionId: pending.id, sessionID: pending.sessionID, revision, questions };
+  if (Buffer.byteLength(JSON.stringify(result)) > 3e4) throw invalid("question_too_large");
+  return result;
+}
+function resolveQuestionAnswers(pending, answers) {
+  if (!Array.isArray(answers) || answers.length !== pending.questions.length) throw invalid();
+  const values = answers.map((answer, index) => {
+    const question = pending.questions[index];
+    if (!answer || !Array.isArray(answer.choices) || answer.choices.length > 32 || Object.keys(answer).some((key) => !["choices", "text"].includes(key)) || new Set(answer.choices).size !== answer.choices.length || answer.choices.some((choice) => !Number.isInteger(choice) || choice < 0 || choice >= question.options.length) || answer.text !== void 0 && (typeof answer.text !== "string" || !answer.text.trim() || answer.text.length > 8e3)) throw invalid();
+    if (answer.text !== void 0 && question.custom !== true) throw invalid("custom_not_allowed");
+    return [
+      ...answer.choices.map((choice) => question.options[choice].label),
+      ...answer.text === void 0 ? [] : [answer.text]
+    ];
+  });
+  const errorCode = validateQuestionAnswers(values, pending.questions);
+  if (errorCode) throw invalid(errorCode);
+  return values;
 }
-async function consumeSse(response, state, onCommand, signal2, reporter) {
-  if (!response.body) throw new Error("Backeer command stream has no body");
-  const reader = response.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  try {
-    while (!signal2.aborted) {
-      const item = await reader.read();
-      if (item.done) break;
-      buffer += decoder.decode(item.value, { stream: true });
-      for (; ; ) {
-        const next = nextSseFrame(buffer);
-        if (!next) break;
-        buffer = next.rest;
-        state.framesReceived = (state.framesReceived ?? 0) + 1;
-        const message = parseSseFrame(next.frame);
-        if (!message) continue;
-        if (message.id) state.lastEventID = message.id;
-        if (message.event !== "message" && message.event !== "command") continue;
-        try {
-          await onCommand(JSON.parse(message.data));
-        } catch (error) {
-          if (error instanceof SyntaxError) {
-            reporter.error("Invalid command received", "SSE data is not valid JSON");
-            continue;
-          }
-          throw error;
-        }
-      }
-    }
-  } finally {
-    await reader.cancel().catch(() => {
-    });
-  }
+
+// src/live-bridge.js
+var LIMITS = { events: 256, bytes: 2e6, clients: 8, commands: 1024, commandTTL: 864e5, body: 32768, requests: 16 };
+function failure(status, code) {
+  return Object.assign(new Error(code), { status, code });
 }
-async function openCommandStream(config, state, signal2, fetchImplementation) {
-  const headers = {
-    Accept: "text/event-stream",
-    Authorization: `Bearer ${config.token}`
-  };
-  if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID;
-  const response = await fetchImplementation(config.commandStreamEndpoint, {
-    headers,
-    signal: signal2
-  });
-  if (!response.ok) {
-    const responseBody = limit(await response.text(), 500);
-    throw new HttpError(
-      `Backeer command stream failed with status ${response.status}`,
-      response.status,
-      responseBody
-    );
-  }
-  if (!response.headers.get("content-type")?.includes("text/event-stream")) {
-    throw new Error("Backeer command stream returned an invalid content type");
+function json(response, status, value) {
+  if (!response.destroyed && !response.headersSent) {
+    response.writeHead(status, { "content-type": "application/json", "cache-control": "no-store" });
+    response.end(JSON.stringify(value));
   }
-  return response;
 }
-async function consumeConnection({
-  response,
-  state,
-  onCommand,
-  signal: signal2,
-  reporter,
-  now,
-  stableConnectionMs,
-  onStable
-}) {
-  const connectedAt = now();
-  const framesBeforeConnection = state.framesReceived;
+async function readBody(request) {
+  const chunks = [];
+  let bytes = 0;
+  for await (const chunk of request) {
+    bytes += chunk.length;
+    if (bytes > LIMITS.body) throw failure(413, "body_too_large");
+    chunks.push(chunk);
+  }
   try {
-    await consumeSse(response, state, onCommand, signal2, reporter);
-  } finally {
-    const receivedFrame = state.framesReceived > framesBeforeConnection;
-    if (receivedFrame || now() - connectedAt >= stableConnectionMs) onStable();
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw failure(400, "invalid_json");
   }
 }
-function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
-  const message = error instanceof HttpError ? `${error.message}: ${error.responseBody}` : limit(error, 500);
-  if (message !== lastLoggedError) {
-    const authenticationFailure = error instanceof HttpError && [401, 403].includes(error.status);
-    reporter.error(
-      authenticationFailure ? "Authentication failed \u2014 run: npx backeer-opencode@latest configure" : "Connection interrupted \u2014 retrying",
-      message
-    );
+async function createLiveBridge({ config, client, directory, reporter }) {
+  const options = config.liveBridge;
+  if (!options?.enabled) return { handle() {
+  }, async dispose() {
+  }, address: void 0 };
+  const token = options.token;
+  if (typeof token !== "string" || token.length < 32 || token === config.token) {
+    throw new Error("Live bridge requires a separate credential of at least 32 characters");
   }
-  return {
-    lastLoggedError: message,
-    reconnectDelay: error instanceof HttpError && [401, 403, 404].includes(error.status) ? 6e4 : reconnectDelay
-  };
-}
-async function runCommandStream(config, reporter, {
-  signal: signal2,
-  hasPending,
-  onCommand,
-  fetchImplementation = fetch,
-  sleepImplementation = sleep,
-  now = Date.now,
-  stableConnectionMs = 5e3
-}) {
-  const state = { lastEventID: "", framesReceived: 0 };
-  let reconnectDelay = 1e3;
-  let lastLoggedError = "";
-  while (!signal2.aborted && hasPending()) {
-    try {
-      const response = await openCommandStream(
-        config,
-        state,
-        signal2,
-        fetchImplementation
-      );
-      await consumeConnection({
-        response,
-        state,
-        onCommand,
-        signal: signal2,
-        reporter,
-        now,
-        stableConnectionMs,
-        onStable: () => {
-          reconnectDelay = 1e3;
-          lastLoggedError = "";
+  const api = client.liveBridge ?? createV1LiveClient(client, directory);
+  const connectionNotifications = createLiveConnectionNotifier(config, reporter);
+  const sanitizer = createBridgeSanitizer([token, config.token]);
+  const epoch = randomUUID3();
+  const events = [], streams = /* @__PURE__ */ new Set(), commands = /* @__PURE__ */ new Map(), states = /* @__PURE__ */ new Map();
+  let sequence = 0, bytes = 0, active = 0, disposed = false, disposeTask;
+  let lookups = 0;
+  const lookupWaiters = /* @__PURE__ */ new Set();
+  const cursor = () => `${epoch}:${sequence}`;
+  function lookup(id) {
+    if (disposed) return Promise.reject(failure(503, "bridge_closed"));
+    if (lookups >= 16) return Promise.reject(failure(429, "session_lookup_busy"));
+    lookups++;
+    return new Promise((resolve2, reject) => {
+      let finished = false;
+      const finish = (complete, value) => {
+        if (finished) return;
+        finished = true;
+        clearTimeout(timer);
+        lookupWaiters.delete(cancel);
+        complete(value);
+      };
+      const cancel = () => finish(reject, failure(503, "bridge_closed"));
+      const timer = setTimeout(() => finish(reject, failure(504, "session_lookup_timed_out")), 1e3);
+      lookupWaiters.add(cancel);
+      Promise.resolve().then(() => api.get(id)).then(
+        (value) => {
+          lookups--;
+          finish(resolve2, value);
+        },
+        (error) => {
+          lookups--;
+          finish(reject, error);
         }
-      });
+      );
+    });
+  }
+  async function session(id) {
+    if (!validBridgeID(id) || id === "global") throw failure(400, "invalid_session");
+    let info;
+    try {
+      info = await lookup(id);
     } catch (error) {
-      if (signal2.aborted || isAbortError(error)) return;
-      const next = streamErrorState(error, lastLoggedError, reconnectDelay, reporter);
-      reconnectDelay = next.reconnectDelay;
-      lastLoggedError = next.lastLoggedError;
+      if (["session_lookup_busy", "session_lookup_timed_out", "bridge_closed"].includes(error.code)) throw error;
+      throw failure(404, "session_not_found");
     }
-    if (!signal2.aborted && hasPending()) {
-      await sleepImplementation(reconnectDelay, signal2);
-      reconnectDelay = Math.min(reconnectDelay * 2, 6e4);
+    if (info?.id !== id || typeof info.time?.archived === "number") {
+      throw failure(404, "session_not_found");
     }
+    const locationDirectory = info.location?.directory ?? info.directory;
+    const owned = api.ownsSession ? await api.ownsSession(info) : locationDirectory === directory;
+    if (!owned) throw failure(404, "session_not_found");
+    return {
+      id,
+      directory,
+      title: sanitizer.text(info.title, 240),
+      ...locationDirectory !== directory ? { locationDirectory: sanitizer.text(locationDirectory, 4096), scope: "verified_git_worktree" } : {},
+      ...validBridgeID(info.parentID) ? { parentID: info.parentID } : {},
+      status: states.get(id) ?? "unknown"
+    };
   }
-}
-
-// src/permission-controller.js
-async function replyToOpenCode(client, pending, decision) {
-  const result = await client.postSessionIdPermissionsPermissionId({
-    path: { id: pending.sessionID, permissionID: pending.requestID },
-    query: { directory: pending.directory },
-    body: { response: decision },
-    throwOnError: true
-  });
-  if (result?.data === false || result === false) {
-    throw new HttpError("OpenCode did not apply the permission reply", 409);
-  }
-}
-async function acknowledgeCommand(config, commandID, acknowledgement) {
-  const url = new URL(
-    `/v1/commands/${encodeURIComponent(commandID)}/ack`,
-    config.origin
-  );
-  await postJsonWithRetry(config, url, acknowledgement);
-}
-function questionResponseError(result) {
-  if (!result?.error) return;
-  const status = Number(result?.response?.status) || 502;
-  const detail = result.error?.data?.message ?? result.error?.message ?? "OpenCode rejected the question response";
-  return new HttpError(String(detail), status);
-}
-function normalizeQuestionError(error) {
-  if (error instanceof HttpError) return error;
-  const status = Number(error?.status ?? error?.statusCode ?? error?.cause?.status);
-  if (!Number.isFinite(status)) return error;
-  return new HttpError(error?.message || "OpenCode rejected the question response", status);
-}
-function rawQuestionRequest(client, pending, response, isV2) {
-  const transport = client?._client;
-  if (typeof transport?.post !== "function") {
-    throw new HttpError("This OpenCode version cannot apply remote question replies", 501);
+  function removeStream(stream) {
+    const removed = streams.delete(stream);
+    clearInterval(stream.heartbeat);
+    stream.queue.length = 0;
+    stream.queuedBytes = 0;
+    if (removed && !streams.size && !disposed) connectionNotifications.update(false);
   }
-  const rejecting = response.action === "reject";
-  if (isV2) {
-    return transport.post({
-      url: `/api/session/{sessionID}/question/{requestID}/${rejecting ? "reject" : "reply"}`,
-      path: { sessionID: pending.sessionID, requestID: pending.requestID },
-      ...rejecting ? {} : { body: { answers: response.answers } },
-      ...rejecting ? {} : { headers: { "Content-Type": "application/json" } },
-      throwOnError: true
-    });
+  function write(stream, value) {
+    if (!streams.has(stream)) return;
+    if (stream.blocked) {
+      stream.queue.push(value);
+      stream.queuedBytes += Buffer.byteLength(value);
+      if (stream.queuedBytes > LIMITS.bytes) {
+        removeStream(stream);
+        stream.response.destroy();
+      }
+      return;
+    }
+    if (!stream.response.write(value)) {
+      stream.blocked = true;
+    }
   }
-  return transport.post({
-    url: `/question/{requestID}/${rejecting ? "reject" : "reply"}`,
-    path: { requestID: pending.requestID },
-    query: { directory: pending.directory },
-    ...rejecting ? {} : { body: { answers: response.answers } },
-    ...rejecting ? {} : { headers: { "Content-Type": "application/json" } },
-    throwOnError: true
-  });
-}
-async function replyToQuestion(client, pending, response) {
-  const isV2 = pending.sourceEvent === "question.v2.asked";
-  const api = isV2 ? client?.v2?.session?.question : client?.question;
-  const method = response.action === "reject" ? api?.reject : api?.reply;
-  const input = isV2 ? {
-    sessionID: pending.sessionID,
-    requestID: pending.requestID,
-    directory: pending.directory,
-    ...response.action === "answer" ? { questionV2Reply: { answers: response.answers } } : {}
-  } : {
-    requestID: pending.requestID,
-    directory: pending.directory,
-    ...response.action === "answer" ? { answers: response.answers } : {}
-  };
-  let result;
-  try {
-    result = typeof method === "function" ? await method.call(api, input, { throwOnError: true }) : await rawQuestionRequest(client, pending, response, isV2);
-  } catch (error) {
-    throw normalizeQuestionError(error);
+  async function handle(event) {
+    if (disposed) return;
+    const safe = sanitizer.sanitize(event);
+    if (!safe) return;
+    try {
+      await session(safe.sessionID);
+    } catch {
+      return;
+    }
+    if (disposed) return;
+    if (safe.type === "session.status") states.set(safe.sessionID, safe.data.status);
+    if (safe.type === "session.idle") states.set(safe.sessionID, "idle");
+    if (safe.type === "session.deleted") states.delete(safe.sessionID);
+    if (states.size > 256) states.delete(states.keys().next().value);
+    const record = { id: `${epoch}:${++sequence}`, ...safe, timestamp: Date.now() };
+    let frame = `id: ${record.id}
+event: backeer.event
+data: ${JSON.stringify(record)}
+
+`;
+    if (Buffer.byteLength(frame) > 32768) {
+      record.data = { truncated: true };
+      frame = `id: ${record.id}
+event: backeer.event
+data: ${JSON.stringify(record)}
+
+`;
+    }
+    const size = Buffer.byteLength(frame);
+    events.push({ sequence, sessionID: record.sessionID, frame, size });
+    bytes += size;
+    while (events.length > LIMITS.events || bytes > LIMITS.bytes) bytes -= events.shift().size;
+    for (const stream of streams) if (!stream.sessionID || stream.sessionID === record.sessionID) write(stream, frame);
   }
-  const responseError = questionResponseError(result);
-  if (responseError) throw responseError;
-  if (result?.data === false || result === false) {
-    throw new HttpError("OpenCode did not apply the question response", 409);
+  function authorized(request) {
+    if (request.headers.origin || request.headers["sec-fetch-site"]) return false;
+    const expected = Buffer.from(`Bearer ${token}`);
+    const actual = Buffer.from(request.headers.authorization ?? "");
+    return actual.length === expected.length && timingSafeEqual(actual, expected);
   }
-}
-async function postQuestionState(config, eventID, path, body = {}) {
-  const url = new URL(`/v1/events/${encodeURIComponent(eventID)}/${path}`, config.origin);
-  await postJsonWithRetry(config, url, body, { retryDelays: [0, 500] });
-}
-function createPermissionController({
-  config,
-  reporter,
-  client,
-  directory,
-  conversation
-}) {
-  const pendingByExternalID = /* @__PURE__ */ new Map();
-  const externalIDByRequestID = /* @__PURE__ */ new Map();
-  const questionsByExternalID = /* @__PURE__ */ new Map();
-  const questionExternalIDByRequestID = /* @__PURE__ */ new Map();
-  const remotelyResolvingQuestions = /* @__PURE__ */ new Set();
-  const processingCommands = /* @__PURE__ */ new Set();
-  const completedCommands = /* @__PURE__ */ new Map();
-  let commandStream;
-  let leaseTimer;
-  let disposed = false;
-  function removePendingByRequestID(requestID) {
-    const externalId = externalIDByRequestID.get(requestID);
-    if (!externalId) return;
-    externalIDByRequestID.delete(requestID);
-    pendingByExternalID.delete(externalId);
+  function parseCursor(value) {
+    if (!value) return { after: 0 };
+    const match = /^([a-f0-9-]{36}):(\d{1,16})$/.exec(value);
+    if (!match) throw failure(400, "invalid_cursor");
+    if (match[1] !== epoch) return { gap: "stream_restarted" };
+    const after = Number(match[2]);
+    if (!Number.isSafeInteger(after) || after > sequence) throw failure(400, "invalid_cursor");
+    if (events.length && after < events[0].sequence - 1) return { gap: "cursor_expired" };
+    return { after };
   }
-  function stopCommandStreamIfIdle() {
-    if (pendingByExternalID.size === 0 && questionsByExternalID.size === 0) {
-      commandStream?.controller.abort();
+  function cachedCommand(requestId, sessionID, signature) {
+    for (const [id, command] of commands) {
+      if (command.settled && Date.now() - command.created >= LIMITS.commandTTL) commands.delete(id);
     }
-  }
-  function removeQuestionByRequestID(requestID) {
-    const externalId = questionExternalIDByRequestID.get(requestID);
-    if (!externalId) return;
-    questionExternalIDByRequestID.delete(requestID);
-    questionsByExternalID.delete(externalId);
-    if (questionsByExternalID.size === 0 && leaseTimer) {
-      clearInterval(leaseTimer);
-      leaseTimer = void 0;
+    const existing = commands.get(requestId);
+    if (existing && (existing.sessionID !== sessionID || existing.signature !== signature)) {
+      throw failure(409, "request_id_conflict");
     }
+    return existing;
   }
-  async function renewQuestionLeases() {
-    for (const pending of questionsByExternalID.values()) {
-      if (!pending.eventID) continue;
-      await postQuestionState(config, pending.eventID, "lease").catch((error) => {
-        reporter.warning("Question lease could not be renewed", error);
+  async function execute(requestId, sessionID, signature, operation, questionId) {
+    let command = cachedCommand(requestId, sessionID, signature);
+    if (!command) {
+      if (commands.size >= LIMITS.commands) throw failure(429, "command_window_full");
+      if (questionId && [...commands.values()].some((item) => item.sessionID === sessionID && item.questionId === questionId)) {
+        throw failure(409, "question_reply_already_submitted");
+      }
+      command = {
+        sessionID,
+        signature,
+        questionId,
+        created: Date.now(),
+        settled: false,
+        result: {
+          requestId,
+          sessionID,
+          ...questionId ? { questionId } : {},
+          status: questionId ? "answered" : "accepted"
+        }
+      };
+      commands.set(requestId, command);
+      command.task = Promise.resolve().then(operation).finally(() => {
+        command.settled = true;
       });
     }
+    await command.task;
+    return command.result;
   }
-  function ensureLeaseTimer() {
-    if (leaseTimer || questionsByExternalID.size === 0) return;
-    leaseTimer = setInterval(() => void renewQuestionLeases(), 6e4);
-    leaseTimer.unref?.();
+  async function questions(sessionID) {
+    if (typeof api.questions !== "function") throw failure(501, "questions_unavailable_update_bridge");
+    const pending = await api.questions(sessionID);
+    if (!Array.isArray(pending)) throw failure(502, "invalid_question_list");
+    const own = pending.filter((item) => item.sessionID === sessionID);
+    if (own.length > 16) throw failure(413, "too_many_questions");
+    return own;
   }
-  async function handleCommand(command) {
-    if (!command || typeof command !== "object") return;
-    if (!["opencode_permission_reply", "opencode_question_reply"].includes(command.type)) return;
-    if (typeof command.id !== "string" || command.id.length > 200) return;
-    const previousAcknowledgement = completedCommands.get(command.id);
-    if (previousAcknowledgement) {
-      await acknowledgeCommand(config, command.id, previousAcknowledgement).catch((error) => reporter.warning("Decision receipt retry failed", error));
-      return;
-    }
-    if (processingCommands.has(command.id)) return;
-    if (typeof command.externalId !== "string") return;
-    const isQuestion = command.type === "opencode_question_reply";
-    const pending = isQuestion ? questionsByExternalID.get(command.externalId) : pendingByExternalID.get(command.externalId);
-    if (!pending) return;
-    processingCommands.add(command.id);
-    let acknowledgement = isQuestion ? validateQuestionCommand(command, pending) : validatePermissionCommand(command);
-    try {
-      if (!acknowledgement) {
-        if (isQuestion) {
-          remotelyResolvingQuestions.add(pending.requestID);
-          await replyToQuestion(client, pending, command.response);
-          acknowledgement = { status: "applied", action: command.response.action };
-          removeQuestionByRequestID(pending.requestID);
-          const cleanup = setTimeout(
-            () => remotelyResolvingQuestions.delete(pending.requestID),
-            3e4
-          );
-          cleanup.unref?.();
-        } else {
-          await replyToOpenCode(client, pending, command.decision);
-          acknowledgement = { status: "applied", decision: command.decision };
-          removePendingByRequestID(pending.requestID);
+  async function route(request, response) {
+    if (!authorized(request)) return json(response, 401, { error: "unauthorized" });
+    if (request.headers["x-backeer-project"] !== void 0 && request.headers["x-backeer-project"] !== encodeURIComponent(directory)) {
+      return json(response, 409, { error: "project_mismatch" });
+    }
+    if (active >= LIMITS.requests) return json(response, 429, { error: "bridge_busy" });
+    active++;
+    const timeout = setTimeout(() => json(response, 504, { error: "request_timed_out" }), 15e3);
+    timeout.unref();
+    try {
+      const url = new URL(request.url, "http://127.0.0.1");
+      if (url.username || url.password) throw failure(400, "invalid_url");
+      if (request.method === "GET" && url.pathname === "/v1/sessions") {
+        const result2 = await api.list();
+        const values = Array.isArray(result2) ? result2 : result2?.data;
+        if (!Array.isArray(values)) throw failure(502, "invalid_session_list");
+        const own = [];
+        for (const info of values.slice(0, 100)) {
+          if (!validBridgeID(info?.id) || typeof info.time?.archived === "number") continue;
+          if (api.ownsSession ? await api.ownsSession(info) : (info.location?.directory ?? info.directory) === directory) own.push(info);
         }
+        return json(response, 200, {
+          sessions: own.map((info) => ({
+            id: info.id,
+            title: sanitizer.text(info.title, 240),
+            status: states.get(info.id) ?? "unknown",
+            ...(info.location?.directory ?? info.directory) !== directory ? {
+              locationDirectory: sanitizer.text(info.location?.directory ?? info.directory, 4096),
+              scope: "verified_git_worktree"
+            } : {},
+            ...validBridgeID(info.parentID) ? { parentID: info.parentID } : {}
+          })),
+          directory,
+          cursor: cursor(),
+          protocolVersion: 1,
+          bridgeVersion: PLUGIN_VERSION,
+          capabilities: {
+            questions: typeof api.questions === "function",
+            questionAnswers: typeof api.answerQuestion === "function",
+            verifiedWorktreeSessions: typeof api.ownsSession === "function",
+            questionTransport: api.questionTransport ?? "server"
+          }
+        });
       }
-    } catch (error) {
-      if (isQuestion) remotelyResolvingQuestions.delete(pending.requestID);
-      acknowledgement = isQuestion ? questionFailureAcknowledgement(command, error) : failureAcknowledgement(command, error);
-      if (acknowledgement.status === "stale") {
-        if (isQuestion) removeQuestionByRequestID(pending.requestID);
-        else removePendingByRequestID(pending.requestID);
+      if (request.method === "GET" && url.pathname === "/v1/events") {
+        const selected = url.searchParams.get("sessionID") || void 0;
+        if (selected) await session(selected);
+        const parsed = parseCursor(url.searchParams.get("after") ?? request.headers["last-event-id"]);
+        if (response.headersSent) return;
+        if (streams.size >= LIMITS.clients) throw failure(429, "too_many_streams");
+        clearTimeout(timeout);
+        response.writeHead(200, {
+          "content-type": "text/event-stream",
+          "cache-control": "no-cache, no-transform",
+          "x-accel-buffering": "no",
+          connection: "keep-alive"
+        });
+        if (parsed.gap) {
+          response.end(`event: backeer.gap
+data: ${JSON.stringify({ reason: parsed.gap, cursor: cursor() })}
+
+`);
+          return;
+        }
+        const stream = {
+          response,
+          sessionID: selected,
+          heartbeat: void 0,
+          blocked: false,
+          queue: [],
+          queuedBytes: 0
+        };
+        streams.add(stream);
+        connectionNotifications.update(true);
+        request.socket.setTimeout(0);
+        request.socket.setKeepAlive(true, LIVE_HEARTBEAT_MS);
+        response.on("close", () => removeStream(stream));
+        response.on("drain", () => {
+          stream.blocked = false;
+          while (streams.has(stream) && !stream.blocked && stream.queue.length) {
+            const next = stream.queue.shift();
+            stream.queuedBytes -= Buffer.byteLength(next);
+            write(stream, next);
+          }
+        });
+        write(stream, `: connected
+retry: ${LIVE_RECONNECT_MS}
+
+`);
+        for (const item of events) {
+          if (!streams.has(stream)) break;
+          if (item.sequence > parsed.after && (!selected || selected === item.sessionID)) write(stream, item.frame);
+        }
+        if (streams.has(stream)) {
+          stream.heartbeat = setInterval(() => write(stream, ": heartbeat\n\n"), LIVE_HEARTBEAT_MS);
+          stream.heartbeat.unref();
+        }
+        return;
       }
-      const message = isQuestion ? "Question response could not be applied" : "Decision could not be applied";
-      reporter.error(message, error);
-      conversation?.error(pending.sessionID, message);
+      const match = /^\/v1\/sessions\/([A-Za-z0-9_-]{1,160})(\/instructions|\/questions(?:\/([A-Za-z0-9_-]{1,160})\/answers)?)?$/.exec(url.pathname);
+      if (!match) throw failure(404, "route_not_found");
+      if (request.method === "GET" && !match[2]) return json(response, 200, await session(match[1]));
+      if (request.method === "GET" && match[2] === "/questions") {
+        await session(match[1]);
+        const result2 = { questions: (await questions(match[1])).map((item) => questionSnapshot(item, sanitizer.text)) };
+        if (Buffer.byteLength(JSON.stringify(result2)) > 24e4) throw failure(413, "questions_too_large");
+        return json(response, 200, result2);
+      }
+      if (request.method !== "POST" || !match[2]) throw failure(405, "method_not_allowed");
+      if (!/^application\/json(?:;|$)/i.test(request.headers["content-type"] ?? "")) throw failure(415, "json_required");
+      const body = await readBody(request);
+      if (match[3]) {
+        if (!body || !validBridgeID(body.requestId) || !/^[a-f0-9]{64}$/.test(body.revision) || Object.keys(body).some((key) => !["requestId", "revision", "answers"].includes(key))) throw failure(400, "invalid_question_answer");
+        await session(match[1]);
+        const signature2 = JSON.stringify({ questionId: match[3], revision: body.revision, answers: body.answers });
+        const existing2 = cachedCommand(body.requestId, match[1], signature2);
+        if (existing2) {
+          await existing2.task;
+          return json(response, 200, existing2.result);
+        }
+        const pending = (await questions(match[1])).find((item) => item.id === match[3]);
+        if (!pending) throw failure(409, "question_already_settled_or_missing");
+        if (questionSnapshot(pending, sanitizer.text).revision !== body.revision) throw failure(409, "question_changed_read_again");
+        const answers = resolveQuestionAnswers(pending, body.answers);
+        if (typeof api.answerQuestion !== "function") throw failure(501, "questions_unavailable_update_bridge");
+        if (response.headersSent || disposed) return;
+        return json(response, 200, await execute(
+          body.requestId,
+          match[1],
+          signature2,
+          () => api.answerQuestion(pending, answers),
+          match[3]
+        ));
+      }
+      if (match[2] !== "/instructions") throw failure(405, "method_not_allowed");
+      if (!body || !validBridgeID(body.requestId) || typeof body.prompt !== "string" || !body.prompt.trim() || body.prompt.length > 16e3 || Object.keys(body).some((key) => !["requestId", "prompt"].includes(key))) throw failure(400, "invalid_instruction");
+      await session(match[1]);
+      if (response.headersSent || disposed) return;
+      const signature = JSON.stringify({ prompt: body.prompt });
+      const existing = cachedCommand(body.requestId, match[1], signature);
+      const result = await execute(body.requestId, match[1], signature, () => api.prompt(match[1], body.prompt));
+      return json(response, existing ? 200 : 202, result);
+    } catch (error) {
+      json(response, error.status ?? 502, { error: error.code ?? "opencode_request_failed" });
     } finally {
-      processingCommands.delete(command.id);
-    }
-    acknowledgement = {
-      ...acknowledgement,
-      type: isQuestion ? "opencode_question_reply_ack" : "opencode_permission_reply_ack",
-      externalId: command.externalId,
-      processedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    rememberBounded(completedCommands, command.id, acknowledgement);
-    if (isQuestion) {
-      reportQuestionAcknowledgement(acknowledgement, pending, reporter, conversation);
-    } else {
-      reportAcknowledgement(acknowledgement, pending, reporter, conversation);
+      active--;
+      clearTimeout(timeout);
     }
-    await acknowledgeCommand(config, command.id, acknowledgement).catch((error) => {
-      reporter.warning("Decision receipt could not be sent", error);
-    });
-    stopCommandStreamIfIdle();
   }
-  function ensureCommandStream() {
-    const hasPending = () => pendingByExternalID.size > 0 || questionsByExternalID.size > 0;
-    if (disposed || commandStream || !hasPending()) return;
-    const controller = new AbortController();
-    const current = {
-      controller,
-      task: runCommandStream(config, reporter, {
-        signal: controller.signal,
-        hasPending,
-        onCommand: handleCommand
-      })
-    };
-    commandStream = current;
-    void current.task.finally(() => {
-      if (commandStream === current) commandStream = void 0;
-      if (!disposed && hasPending()) ensureCommandStream();
+  const server = createServer((request, response) => {
+    void route(request, response);
+  });
+  server.requestTimeout = 15e3;
+  server.headersTimeout = 1e4;
+  server.keepAliveTimeout = 5e3;
+  await new Promise((resolve2, reject) => {
+    server.once("error", reject);
+    server.listen(options.port ?? 43871, "127.0.0.1", () => {
+      server.off("error", reject);
+      resolve2();
     });
-  }
+  });
+  server.on("error", () => {
+  });
   return {
-    register(identity) {
-      pendingByExternalID.set(identity.externalId, { ...identity, directory });
-      externalIDByRequestID.set(identity.requestID, identity.externalId);
-      ensureCommandStream();
-    },
-    resolveLocally(requestID) {
-      removePendingByRequestID(requestID);
-      stopCommandStreamIfIdle();
-    },
-    registerQuestion(identity, details) {
-      questionsByExternalID.set(identity.externalId, {
-        ...identity,
-        ...details,
-        directory
-      });
-      questionExternalIDByRequestID.set(identity.requestID, identity.externalId);
-      ensureLeaseTimer();
-      ensureCommandStream();
-    },
-    resolveQuestionLocally(requestID, outcome) {
-      if (remotelyResolvingQuestions.delete(requestID)) {
-        removeQuestionByRequestID(requestID);
-        stopCommandStreamIfIdle();
-        return;
-      }
-      const externalId = questionExternalIDByRequestID.get(requestID);
-      const pending = externalId ? questionsByExternalID.get(externalId) : void 0;
-      if (!pending) return;
-      removeQuestionByRequestID(requestID);
-      if (pending.eventID) {
-        void postQuestionState(config, pending.eventID, "source-resolution", { outcome }).catch((error) => reporter.warning("Local question state could not be sent", error));
-      }
-      stopCommandStreamIfIdle();
-    },
-    refreshCredentials() {
-      commandStream?.controller.abort();
-      if (!commandStream) ensureCommandStream();
-    },
-    status() {
-      return {
-        pending: pendingByExternalID.size,
-        pendingQuestions: questionsByExternalID.size,
-        stream: commandStream ? "active" : "idle"
-      };
-    },
-    async dispose() {
-      disposed = true;
-      commandStream?.controller.abort();
-      if (leaseTimer) clearInterval(leaseTimer);
-      await commandStream?.task.catch(() => {
+    handle,
+    address: server.address(),
+    dispose() {
+      disposeTask ??= new Promise((resolve2) => {
+        disposed = true;
+        for (const cancel of lookupWaiters) cancel();
+        for (const stream of streams) {
+          removeStream(stream);
+          stream.response.destroy();
+        }
+        server.close(() => {
+          void connectionNotifications.dispose().then(resolve2);
+        });
+        server.closeAllConnections?.();
+        events.length = 0;
+        states.clear();
+        commands.clear();
+        sanitizer.clear();
+        api.dispose?.();
       });
-      pendingByExternalID.clear();
-      externalIDByRequestID.clear();
-      processingCommands.clear();
-      completedCommands.clear();
-      questionsByExternalID.clear();
-      questionExternalIDByRequestID.clear();
-      remotelyResolvingQuestions.clear();
+      return disposeTask;
     }
   };
 }
@@ -4503,7 +4708,8 @@ async function BackeerPlugin({ client, directory, feedback, v2 = false }, option
   const reporter = createOpenCodeReporter(client, config.logLevel);
   const conversation = feedback ?? createConversationFeedback({ client, reporter });
   if (config.liveBridge.error) reporter.error("Live control disabled", config.liveBridge.error);
-  const liveBridge = await createLiveBridge({ config, client, directory, reporter }).catch((error) => {
+  const bridgeConfig = config.liveBridge.owner === "tui" ? { ...config, liveBridge: { enabled: false } } : config;
+  const liveBridge = await createLiveBridge({ config: bridgeConfig, client, directory, reporter }).catch((error) => {
     reporter.error("Live control unavailable", error);
     return { async handle() {
     }, async dispose() {
@@ -5142,26 +5348,103 @@ function delay(milliseconds) {
 }
 var Service = { discover, ensure, stop, headers: headers2 };
 
+// src/opencode-v2-endpoint.js
+import { readdir, readFile as readFile3, readlink } from "node:fs/promises";
+async function ownLoopbackUrls({ platform = process.platform, fs = { readdir, readFile: readFile3, readlink } } = {}) {
+  if (platform !== "linux") return [];
+  const inodes = new Set((await Promise.all((await fs.readdir("/proc/self/fd")).map(async (fd) => {
+    try {
+      return /^socket:\[(\d+)\]$/.exec(await fs.readlink(`/proc/self/fd/${fd}`))?.[1];
+    } catch {
+      return void 0;
+    }
+  }))).filter(Boolean));
+  const tables = await Promise.all(["tcp", "tcp6"].map(async (name) => {
+    try {
+      return await fs.readFile(`/proc/self/net/${name}`, "utf8");
+    } catch (error) {
+      if (error.code === "ENOENT") return "";
+      throw error;
+    }
+  }));
+  const urls = /* @__PURE__ */ new Set();
+  for (const table of tables) for (const row of table.trim().split("\n").slice(1)) {
+    const fields = row.trim().split(/\s+/);
+    if (fields[3] !== "0A" || !inodes.has(fields[9])) continue;
+    const [address, portHex] = fields[1].split(":");
+    const host = address === "0100007F" ? "127.0.0.1" : address === "00000000000000000000000001000000" ? "[::1]" : void 0;
+    const port = Number.parseInt(portHex, 16);
+    if (host && port > 0 && port <= 65535) urls.add(`http://${host}:${port}`);
+  }
+  return [...urls];
+}
+async function privateEndpoint({
+  argv = process.argv,
+  env = process.env,
+  pid = process.pid,
+  urls = ownLoopbackUrls,
+  request = fetch
+} = {}) {
+  if (!argv.includes("--stdio")) return void 0;
+  const flag = argv.indexOf("--port");
+  const rawPort = flag >= 0 ? argv[flag + 1] : argv.find((arg) => arg.startsWith("--port="))?.slice(7);
+  const port = typeof rawPort === "string" && /^\d+$/.test(rawPort) ? Number(rawPort) : NaN;
+  const password = env.OPENCODE_PASSWORD;
+  try {
+    if (!Number.isInteger(port) || port < 0 || port > 65535 || !password) throw new Error();
+    const candidates = port === 0 ? await urls() : [`http://127.0.0.1:${port}`];
+    for (const url of candidates) {
+      const endpoint = { url, auth: { type: "basic", username: "opencode", password } };
+      let response;
+      try {
+        response = await request(`${url}/api/info`, {
+          headers: Service.headers(endpoint),
+          signal: AbortSignal.timeout(2e3),
+          redirect: "error"
+        });
+        if (response.ok && (await response.json()).pid === pid) return endpoint;
+      } catch {
+      } finally {
+        await response?.body?.cancel().catch(() => {
+        });
+      }
+    }
+  } catch {
+  }
+  throw Object.assign(
+    new HttpError("The existing private OpenCode server could not be verified; keep its session running", 501),
+    { code: "question_private_server_unavailable" }
+  );
+}
+
 // src/opencode-v2-forms.js
-async function getFormApi(ctx, sessionID, { makeClient = exports_client.make } = {}) {
-  const endpoint = await Service.discover({ version: ctx.app.version });
+function unavailable(code, message, status = 501) {
+  return Object.assign(new HttpError(message, status), { code });
+}
+async function getFormApi(ctx, sessionID, { makeClient = exports_client.make, ownsSession, resolvePrivate = privateEndpoint } = {}) {
+  const endpoint = await resolvePrivate() ?? await Service.discover({ version: ctx.app.version }) ?? await Service.discover();
   if (!endpoint) {
-    throw new HttpError("Remote question replies require the OpenCode V2 shared service", 501);
+    throw unavailable("question_shared_service_unavailable", "Remote questions require a compatible running OpenCode V2 shared service");
   }
   const client = makeClient({ baseUrl: endpoint.url, headers: Service.headers(endpoint) });
   let session;
   try {
     session = await client.session.get({ sessionID });
   } catch {
-    throw new HttpError("The question session is not owned by the shared OpenCode service", 501);
+    throw unavailable("question_session_not_in_shared_service", "The question session is not owned by the shared OpenCode service");
+  }
+  if (session.id !== void 0 && session.id !== sessionID) {
+    throw unavailable("question_session_not_in_shared_service", "The shared service returned another question session");
   }
-  if (session.location.directory !== ctx.location.directory) {
-    throw new HttpError("The question session belongs to another OpenCode location", 403);
+  const owned = ownsSession ? await ownsSession(session) : session.location?.directory === ctx.location.directory;
+  if (!owned) {
+    throw unavailable("question_session_location_mismatch", "The question session belongs to another OpenCode location", 403);
   }
   return client.session.form;
 }
 
 // src/opencode-v2-client.js
+import { createHash as createHash2 } from "node:crypto";
 async function nativeReply(operation) {
   try {
     return await operation();
@@ -5183,26 +5466,35 @@ function questionForm(form) {
     (field) => ["string", "multiselect"].includes(field.type) && !field.hidden && !field.when?.length
   );
 }
+function questionProperties(form) {
+  return {
+    id: form.id,
+    sessionID: form.sessionID,
+    nativeRevision: createHash2("sha256").update(JSON.stringify({
+      id: form.id,
+      sessionID: form.sessionID,
+      title: form.title,
+      fields: form.fields
+    })).digest("hex"),
+    questions: form.fields.map((field) => ({
+      header: field.title ?? form.title,
+      question: field.description ?? field.title ?? form.title,
+      options: (field.options ?? []).map((option) => ({
+        label: option.label,
+        description: option.description ?? ""
+      })),
+      multiple: field.type === "multiselect",
+      custom: field.custom === true || !field.options?.length
+    }))
+  };
+}
 function normalizeV2Event(event) {
   const properties = event.data ?? {};
   const normalized = { ...event, properties };
   if (event.type === "form.created") {
     const form = properties.form;
     if (!questionForm(form)) return [];
-    return [{ ...normalized, type: "question.v2.asked", properties: {
-      id: form.id,
-      sessionID: form.sessionID,
-      questions: form.fields.map((field) => ({
-        header: field.title ?? form.title,
-        question: field.description ?? field.title ?? form.title,
-        options: (field.options ?? []).map((option) => ({
-          label: option.label,
-          description: option.description ?? ""
-        })),
-        multiple: field.type === "multiselect",
-        custom: field.custom === true || !field.options?.length
-      }))
-    } }];
+    return [{ ...normalized, type: "question.v2.asked", properties: questionProperties(form) }];
   }
   if (event.type === "form.replied" || event.type === "form.cancelled") {
     return [{ ...normalized, type: event.type === "form.replied" ? "question.v2.replied" : "question.v2.rejected" }];
@@ -5233,9 +5525,11 @@ function normalizeV2Event(event) {
   }
   return [normalized];
 }
-function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, sessionID)) {
-  return {
-    liveBridge: createV2LiveClient(ctx),
+function createV2Client(ctx, resolveFormApi) {
+  const liveBridge = createV2LiveClient(ctx);
+  resolveFormApi ??= (sessionID) => getFormApi(ctx, sessionID, { ownsSession: liveBridge.ownsSession });
+  const client = {
+    liveBridge,
     app: {
       async log({ body }) {
         console.error(JSON.stringify(body));
@@ -5255,10 +5549,13 @@ function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, ses
       decision: body.response
     })),
     v2: { session: { question: {
-      async reply({ sessionID, requestID, questionV2Reply }) {
+      async reply({ sessionID, requestID, questionV2Reply, expectedNativeRevision }) {
         const api = await resolveFormApi(sessionID);
         const form = await nativeReply(() => api.get({ sessionID, formID: requestID }));
         if (!questionForm(form)) throw new HttpError("Unsupported OpenCode question form", 422);
+        if (expectedNativeRevision && questionProperties(form).nativeRevision !== expectedNativeRevision) {
+          throw Object.assign(new HttpError("The native question changed; read it again", 409), { code: "question_changed_read_again" });
+        }
         const answers = questionV2Reply.answers;
         if (!Array.isArray(answers) || answers.length !== form.fields.length) {
           throw new HttpError("Question answer count does not match the form", 422);
@@ -5286,18 +5583,31 @@ function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, ses
       }
     } } },
     async ownsEvent(event) {
-      if (event.location?.directory) return event.location.directory === ctx.location.directory;
+      if (event.location?.directory === ctx.location.directory) return true;
       const sessionID = event.data?.sessionID ?? event.data?.form?.sessionID;
       if (!sessionID) return event.type === "installation.update-available";
       if (sessionID === "global") return false;
       try {
-        const session = await ctx.session.get({ sessionID });
-        return session.location?.directory === ctx.location.directory;
+        const session = await liveBridge.get(sessionID);
+        return liveBridge.ownsSession(session);
       } catch {
         return false;
       }
     }
   };
+  client.liveBridge.questions = async (sessionID) => {
+    const api = await resolveFormApi(sessionID);
+    const forms = await nativeReply(() => api.list({ sessionID }));
+    if (!Array.isArray(forms)) throw new HttpError("Invalid question list", 502);
+    return forms.filter((form) => form.sessionID === sessionID && questionForm(form) && (!form.state || form.state.status === "pending")).map(questionProperties);
+  };
+  client.liveBridge.answerQuestion = (pending, answers) => client.v2.session.question.reply({
+    sessionID: pending.sessionID,
+    requestID: pending.id,
+    questionV2Reply: { answers },
+    expectedNativeRevision: pending.nativeRevision
+  });
+  return client;
 }
 
 // src/opencode-v2.js