backeer-opencode 0.3.2 → 0.5.1

package/dist/backeer-permission.js

@@ -1,7 +1,1863 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/@opencode/client/dist/chunks/service-timing-9rqn6x4v.js
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __defProp2, __returnValue, __export2;
+var init_service_timing_9rqn6x4v = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-9rqn6x4v.js"() {
+    __defProp2 = Object.defineProperty;
+    __returnValue = (v) => v;
+    __export2 = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, {
+          get: all[name],
+          enumerable: true,
+          configurable: true,
+          set: __exportSetter.bind(all, name)
+        });
+    };
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-frbwqjmf.js
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop2(connection) {
+    connection.connected = void 0;
+    connection.controller.abort();
+    if (current === connection)
+      current = void 0;
+  }
+  async function run(connection) {
+    let iterator;
+    let completion = {};
+    try {
+      if (connection.controller.signal.aborted)
+        return;
+      iterator = connect(connection.controller.signal, () => {
+        connection.subscribers.forEach((subscriber) => subscriber.activity?.());
+      })[Symbol.asyncIterator]();
+      while (!connection.controller.signal.aborted) {
+        const item = await iterator.next();
+        if (item.done || connection.controller.signal.aborted)
+          break;
+        if (item.value.type === "server.connected")
+          connection.connected = item.value;
+        connection.subscribers.forEach((subscriber) => subscriber.push(item.value));
+      }
+    } catch (error) {
+      completion = { error };
+    } finally {
+      stop2(connection);
+      try {
+        await iterator?.return?.();
+      } catch (error) {
+        if (!("error" in completion))
+          completion = { error };
+      }
+      connection.subscribers.forEach((subscriber) => subscriber.finish(completion));
+    }
+  }
+  return {
+    subscribe(options) {
+      return {
+        [Symbol.asyncIterator]() {
+          const pending = [];
+          const queued = [];
+          let started = false;
+          let completion;
+          let connection;
+          function finish(result, discard = true) {
+            completion = result;
+            if (discard)
+              queued.length = 0;
+            options?.signal?.removeEventListener("abort", abort);
+            if (connection?.subscribers.delete(subscriber) && !connection.subscribers.size)
+              stop2(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: void 0 });
+            });
+          }
+          function abort() {
+            finish({});
+          }
+          const subscriber = {
+            activity: options?.onActivity,
+            finish(result) {
+              finish(result, false);
+            },
+            push(value) {
+              if (completion)
+                return;
+              const request = pending.shift();
+              if (request) {
+                request.resolve({ done: false, value });
+                return;
+              }
+              if (queued.length === capacity) {
+                finish({ error: new Error(`Event subscriber exceeded its ${capacity}-event capacity`) });
+                return;
+              }
+              queued.push(value);
+            }
+          };
+          function start() {
+            if (completion)
+              return;
+            const fresh = !current;
+            connection = current ?? {
+              controller: new AbortController(),
+              subscribers: /* @__PURE__ */ new Set()
+            };
+            current = connection;
+            connection.subscribers.add(subscriber);
+            if (connection.connected)
+              subscriber.push(connection.connected);
+            if (fresh)
+              run(connection);
+          }
+          return {
+            next() {
+              const value = queued.shift();
+              if (value)
+                return Promise.resolve({ done: false, value });
+              if (completion) {
+                if ("error" in completion)
+                  return Promise.reject(completion.error);
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: void 0 });
+              }
+              const request = Promise.withResolvers();
+              pending.push(request);
+              if (!started) {
+                started = true;
+                options?.signal?.addEventListener("abort", abort, { once: true });
+                start();
+              }
+              return request.promise;
+            },
+            return() {
+              finish({});
+              return Promise.resolve({ done: true, value: void 0 });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+var exports_shared_events;
+var init_service_timing_frbwqjmf = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-frbwqjmf.js"() {
+    init_service_timing_9rqn6x4v();
+    exports_shared_events = {};
+    __export2(exports_shared_events, {
+      SharedEvents: () => exports_shared_events,
+      make: () => make7
+    });
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-js54wxgp.js
+var ClientError2;
+var init_service_timing_js54wxgp = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-js54wxgp.js"() {
+    ClientError2 = class extends Error {
+      reason;
+      name = "ClientError";
+      constructor(reason, options) {
+        const detail = options?.detail ?? (options?.cause instanceof Error ? options.cause.message : void 0);
+        super(detail ? `${reason}: ${detail}` : reason, options);
+        this.reason = reason;
+      }
+    };
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-tbh3h57v.js
+function make3(options) {
+  const fetch2 = options.fetch ?? globalThis.fetch;
+  const prepare = (descriptor, requestOptions) => {
+    const baseUrl = new URL(options.baseUrl);
+    if (!baseUrl.pathname.endsWith("/"))
+      baseUrl.pathname += "/";
+    const url = new URL(descriptor.path.slice(1), baseUrl);
+    for (const [key, value] of Object.entries(descriptor.query ?? {}))
+      appendQuery(url.searchParams, key, value);
+    const headers = new Headers(options.headers);
+    for (const [key, value] of Object.entries(descriptor.headers ?? {})) {
+      if (value !== void 0 && value !== null)
+        headers.set(key, String(value));
+    }
+    for (const [key, value] of new Headers(requestOptions?.headers))
+      headers.set(key, value);
+    if (descriptor.body !== void 0 && !headers.has("content-type"))
+      headers.set("content-type", descriptor.binaryBody ? "application/octet-stream" : "application/json");
+    return {
+      url,
+      init: {
+        method: descriptor.method,
+        signal: requestOptions?.signal,
+        headers,
+        body: descriptor.body === void 0 ? void 0 : descriptor.binaryBody ? descriptor.body : JSON.stringify(descriptor.body)
+      }
+    };
+  };
+  const execute = async (descriptor, requestOptions) => {
+    try {
+      const prepared = prepare(descriptor, requestOptions);
+      return await fetch2(prepared.url, prepared.init);
+    } catch (cause) {
+      throw new ClientError2("Transport", { cause });
+    }
+  };
+  const responseError = async (response, descriptor) => {
+    if (descriptor.declaredStatuses.includes(response.status))
+      throw declared(await json2(response));
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+    throw new ClientError2("UnexpectedStatus", { cause: { status: response.status }, detail: String(response.status) });
+  };
+  const request = async (descriptor, requestOptions) => {
+    const response = await execute(descriptor, requestOptions);
+    if (response.status !== descriptor.successStatus)
+      return responseError(response, descriptor);
+    if (descriptor.binary)
+      return new Uint8Array(await response.arrayBuffer());
+    if (descriptor.empty) {
+      try {
+        await response.body?.cancel();
+      } catch {
+      }
+      return;
+    }
+    return await json2(response);
+  };
+  const sse = (descriptor, requestOptions) => ({
+    async *[Symbol.asyncIterator]() {
+      const response = await execute(descriptor, requestOptions);
+      if (response.status !== descriptor.successStatus)
+        await responseError(response, descriptor);
+      if (!isContentType(response, "text/event-stream")) {
+        try {
+          await response.body?.cancel();
+        } catch {
+        }
+        throw new ClientError2("UnsupportedContentType", { detail: response.headers.get("content-type") });
+      }
+      if (response.body === null)
+        throw new ClientError2("MalformedResponse");
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      let buffer = "";
+      try {
+        while (true) {
+          let next;
+          try {
+            next = await reader.read();
+          } catch (cause) {
+            throw new ClientError2("Transport", { cause });
+          }
+          if (!next.done)
+            requestOptions?.onActivity?.();
+          buffer += decoder.decode(next.value, { stream: !next.done });
+          if (buffer.length > maxSseEventBytes)
+            throw new ClientError2("SseEventTooLarge");
+          const trailingCarriageReturn = !next.done && buffer.endsWith("\r");
+          if (trailingCarriageReturn)
+            buffer = buffer.slice(0, -1);
+          buffer = buffer.replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`);
+          if (trailingCarriageReturn)
+            buffer += "\r";
+          if (next.done && buffer !== "")
+            buffer += `
+
+`;
+          let boundary = buffer.indexOf(`
+
+`);
+          while (boundary >= 0) {
+            const block = buffer.slice(0, boundary);
+            buffer = buffer.slice(boundary + 2);
+            const data = block.split(`
+`).flatMap((line) => line.startsWith("data:") ? [line.slice(5).trimStart()] : []).join(`
+`);
+            if (data !== "") {
+              try {
+                yield JSON.parse(data);
+              } catch (cause) {
+                throw new ClientError2("MalformedResponse", { cause });
+              }
+            }
+            boundary = buffer.indexOf(`
+
+`);
+          }
+          if (next.done)
+            return;
+        }
+      } finally {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        reader.releaseLock();
+      }
+    }
+  });
+  return {
+    server: {
+      info: (requestOptions) => request({ method: "GET", path: `/api/info`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      pair: (requestOptions) => request({ method: "POST", path: `/api/pair`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      connect: (input, requestOptions) => request({
+        method: "GET",
+        path: `/auth/connect/${encodeURIComponent(input.code)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    location: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/location`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      reload: (requestOptions) => request({
+        method: "POST",
+        path: `/api/location/reload`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 503],
+        empty: true
+      }, requestOptions)
+    },
+    agent: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/agent`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/agent/${encodeURIComponent(input.agentID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    plugin: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/plugin`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      check: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/plugin/check`,
+        query: { location: input?.["location"] },
+        body: { target: input?.["target"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/plugin/update`,
+        query: { location: input["location"] },
+        body: { targets: input["targets"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: true
+      }, requestOptions)
+    },
+    session: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session`,
+        query: {
+          limit: input?.["limit"],
+          order: input?.["order"],
+          search: input?.["search"],
+          parentID: input?.["parentID"],
+          directory: input?.["directory"],
+          project: input?.["project"],
+          subpath: input?.["subpath"],
+          cursor: input?.["cursor"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      stats: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/experimental/session/stats`,
+        query: {
+          from: input?.["from"],
+          to: input?.["to"],
+          project: input?.["project"],
+          timezone: input?.["timezone"],
+          tools: input?.["tools"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session`,
+        body: {
+          id: input?.["id"],
+          parentID: input?.["parentID"],
+          title: input?.["title"],
+          agent: input?.["agent"],
+          model: input?.["model"],
+          location: input?.["location"],
+          metadata: input?.["metadata"],
+          permissions: input?.["permissions"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      import: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/import`,
+        body: { info: input["info"], messages: input["messages"], location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      export: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/export`,
+        query: { sanitize: input["sanitize"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      active: (requestOptions) => request({
+        method: "GET",
+        path: `/api/session/active`,
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      fork: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/fork`,
+        body: { before: input["before"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      switchAgent: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/agent`,
+        body: { agent: input["agent"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      switchModel: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/model`,
+        body: { model: input["model"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}`,
+        body: { title: input["title"], metadata: input["metadata"], permissions: input["permissions"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      move: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/move`,
+        body: { directory: input["directory"], delivery: input["delivery"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      prompt: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/prompt`,
+        body: {
+          id: input["id"],
+          text: input["text"],
+          files: input["files"],
+          agents: input["agents"],
+          skills: input["skills"],
+          metadata: input["metadata"],
+          delivery: input["delivery"],
+          resume: input["resume"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      command: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/command`,
+        body: {
+          name: input["name"],
+          text: input["text"],
+          files: input["files"],
+          agents: input["agents"],
+          skills: input["skills"],
+          delivery: input["delivery"]
+        },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: true
+      }, requestOptions),
+      skill: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/skill`,
+        body: { id: input["id"], resume: input["resume"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      synthetic: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/synthetic`,
+        body: {
+          id: input["id"],
+          text: input["text"],
+          description: input["description"],
+          metadata: input["metadata"],
+          delivery: input["delivery"],
+          resume: input["resume"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      shell: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/shell`,
+        body: { id: input["id"], command: input["command"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      compact: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/compact`,
+        body: { id: input["id"], delivery: input["delivery"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      wait: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/wait`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: true
+      }, requestOptions),
+      revert: {
+        stage: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/stage`,
+          body: { messageID: input["messageID"], files: input["files"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409, 500],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        clear: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409, 500],
+          empty: true
+        }, requestOptions),
+        commit: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/revert/commit`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      context: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/context`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      diff: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/diff`,
+        query: { from: input["from"], to: input["to"], context: input["context"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      inbox: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        update: (input, requestOptions) => request({
+          method: "PATCH",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/inbox/${encodeURIComponent(input.inboxID)}`,
+          body: { delivery: input["delivery"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      instructions: {
+        entry: {
+          list: (input, requestOptions) => request({
+            method: "GET",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries`,
+            successStatus: 200,
+            declaredStatuses: [400, 401, 404],
+            empty: false
+          }, requestOptions).then((value) => value.data),
+          put: (input, requestOptions) => request({
+            method: "PUT",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
+            body: { value: input["value"] },
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404, 413],
+            empty: true
+          }, requestOptions),
+          remove: (input, requestOptions) => request({
+            method: "DELETE",
+            path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/instructions/entries/${encodeURIComponent(input.key)}`,
+            successStatus: 204,
+            declaredStatuses: [400, 401, 404],
+            empty: true
+          }, requestOptions)
+        }
+      },
+      generate: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/generate`,
+        body: { prompt: input["prompt"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      log: (input, requestOptions) => sse({
+        method: "GET",
+        path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/log`,
+        query: { after: input["after"], follow: input["follow"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      interrupt: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/interrupt`,
+        query: { resume: input["resume"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      background: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/background`,
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      message: {
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/message/${encodeURIComponent(input.messageID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      },
+      form: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form`,
+          body: { id: input["id"], title: input["title"], metadata: input["metadata"], fields: input["fields"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        reply: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}/reply`,
+          body: { answer: input["answer"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/session/${encodeURIComponent(input.sessionID)}/form/${encodeURIComponent(input.formID)}`,
+          query: { message: input["message"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 409],
+          empty: true
+        }, requestOptions)
+      },
+      environment: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/environment`,
+        body: { variables: input["variables"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      view: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/view`,
+        body: { idle: input["idle"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    message: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/message`,
+        query: { limit: input["limit"], order: input["order"], cursor: input["cursor"], type: input["type"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions)
+    },
+    model: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      default: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model/default`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    generate: {
+      text: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/generate`,
+        body: { prompt: input["prompt"], model: input["model"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions).then((value) => value.data)
+    },
+    provider: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/provider`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/provider/${encodeURIComponent(input.providerID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    integration: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/integration`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/integration/${encodeURIComponent(input.integrationID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      wellknown: {
+        add: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/integration/wellknown`,
+          query: { location: input["location"] },
+          body: { url: input["url"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      connect: {
+        key: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/key`,
+          query: { location: input["location"] },
+          body: { key: input["key"], answer: input["answer"], label: input["label"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        external: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/external`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      oauth: {
+        connect: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], answer: input["answer"], label: input["label"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        status: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        complete: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}/complete`,
+          query: { location: input["location"] },
+          body: { code: input["code"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/oauth/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      command: {
+        connect: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command`,
+          query: { location: input["location"] },
+          body: { methodID: input["methodID"], label: input["label"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        status: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions),
+        cancel: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/integration/${encodeURIComponent(input.integrationID)}/connect/command/${encodeURIComponent(input.attemptID)}`,
+          query: { location: input["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    mcp: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/mcp`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      add: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
+        query: { location: input["location"] },
+        body: { config: input["config"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      connect: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/connect`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      disconnect: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/mcp/${encodeURIComponent(input.server)}/disconnect`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      resource: {
+        catalog: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/mcp/resource`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    credential: {
+      list: (requestOptions) => request({ method: "GET", path: `/api/credential`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions).then((value) => value.data),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/credential`,
+        body: {
+          id: input["id"],
+          integrationID: input["integrationID"],
+          label: input["label"],
+          value: input["value"],
+          activate: input["activate"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 409],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+        body: { label: input["label"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      activate: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}/activate`,
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/credential/${encodeURIComponent(input.credentialID)}`,
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    },
+    project: {
+      list: (requestOptions) => request({ method: "GET", path: `/api/project`, successStatus: 200, declaredStatuses: [400, 401, 404], empty: false }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/project/${encodeURIComponent(input.projectID)}`,
+        body: {
+          canonical: input["canonical"],
+          name: input["name"],
+          icon: input["icon"],
+          commands: input["commands"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    form: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/form`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    permission: {
+      request: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/request`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions)
+      },
+      saved: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/saved`,
+          query: { projectID: input?.["projectID"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        remove: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/permission/saved/${encodeURIComponent(input.id)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404],
+          empty: true
+        }, requestOptions)
+      },
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+        body: {
+          id: input["id"],
+          action: input["action"],
+          resources: input["resources"],
+          save: input["save"],
+          metadata: input["metadata"],
+          source: input["source"],
+          agent: input["agent"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions).then((value) => value.data),
+      reply: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/session/${encodeURIComponent(input.sessionID)}/permission/${encodeURIComponent(input.requestID)}/reply`,
+        body: { decision: input["decision"], message: input["message"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    file: {
+      read: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/read/${encodePath(input.path)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false,
+        binary: true
+      }, requestOptions),
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/list`,
+        query: { location: input?.["location"], path: input?.["path"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      find: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/fs/find`,
+        query: { location: input["location"], query: input["query"], type: input["type"], limit: input["limit"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      write: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/experimental/fs/write`,
+        query: { location: input["location"], path: input["path"] },
+        body: input["payload"],
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false,
+        binaryBody: true
+      }, requestOptions)
+    },
+    command: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/command`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    skill: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/skill`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    rpc: {
+      call: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/rpc/${encodeURIComponent(input.rpcID)}/${encodeURIComponent(input.method)}`,
+        query: { location: input["location"] },
+        body: { input: input["input"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 500],
+        empty: false
+      }, requestOptions)
+    },
+    event: {
+      subscribe: (requestOptions) => sse({ method: "GET", path: `/api/event`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions)
+    },
+    pty: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/pty`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/pty`,
+        query: { location: input?.["location"] },
+        body: {
+          command: input?.["command"],
+          args: input?.["args"],
+          cwd: input?.["cwd"],
+          title: input?.["title"],
+          env: input?.["env"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PUT",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        body: { title: input["title"], size: input["size"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/pty/${encodeURIComponent(input.ptyID)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      connect: {
+        token: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+          query: { location: input["location"] },
+          headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    experimental: {
+      persistentPty: {
+        read: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal/read`,
+          query: { lines: input["lines"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        create: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/session/${encodeURIComponent(input.sessionID)}/terminal`,
+          body: {
+            command: input["command"],
+            args: input["args"],
+            cwd: input["cwd"],
+            title: input["title"],
+            env: input["env"],
+            size: input["size"]
+          },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        shutdown: (requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/shutdown`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 503],
+          empty: true
+        }, requestOptions),
+        handoff: (requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/handoff`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 503],
+          empty: false
+        }, requestOptions),
+        get: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        update: (input, requestOptions) => request({
+          method: "PUT",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          body: { attachmentID: input["attachmentID"], size: input["size"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        snapshot: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/snapshot`,
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data),
+        remove: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}`,
+          successStatus: 204,
+          declaredStatuses: [400, 401, 404, 503],
+          empty: true
+        }, requestOptions),
+        connectToken: (input, requestOptions) => request({
+          method: "POST",
+          path: `/api/experimental/persistent-pty/${encodeURIComponent(input.ptyID)}/connect-token`,
+          headers: { "x-opencode-ticket": input["x-opencode-ticket"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 403, 404, 503],
+          empty: false
+        }, requestOptions).then((value) => value.data)
+      }
+    },
+    shell: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/shell`,
+        query: { location: input["location"] },
+        body: {
+          command: input["command"],
+          cwd: input["cwd"],
+          timeout: input["timeout"],
+          metadata: input["metadata"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell/${encodeURIComponent(input.id)}`,
+        query: { location: input["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      output: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/shell/${encodeURIComponent(input.id)}/output`,
+        query: { location: input["location"], cursor: input["cursor"], limit: input["limit"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/shell/${encodeURIComponent(input.id)}`,
+        query: { location: input["location"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    reference: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/reference`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions)
+    },
+    worktree: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/worktree`,
+        query: { projectID: input["projectID"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      create: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/worktree`,
+        body: {
+          projectID: input["projectID"],
+          from: input["from"],
+          branch: input["branch"],
+          directory: input["directory"],
+          name: input["name"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      remove: (input, requestOptions) => request({
+        method: "DELETE",
+        path: `/api/worktree`,
+        body: { projectID: input["projectID"], directory: input["directory"], force: input["force"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions),
+      refresh: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/worktree/refresh`,
+        body: { projectID: input["projectID"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    },
+    vcs: {
+      init: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/vcs/init`,
+        query: { location: input?.["location"], provider: input?.["provider"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404, 409, 501, 503],
+        empty: true
+      }, requestOptions),
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      base: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/base`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      status: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/status`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      branch: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/vcs/branch`,
+          query: { location: input?.["location"], search: input?.["search"], limit: input?.["limit"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401, 404],
+          empty: false
+        }, requestOptions)
+      },
+      diff: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/diff`,
+        query: { location: input["location"], mode: input["mode"], base: input["base"], context: input["context"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    debug: {
+      location: {
+        list: (requestOptions) => request({
+          method: "GET",
+          path: `/api/debug/location`,
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions),
+        evict: (input, requestOptions) => request({
+          method: "DELETE",
+          path: `/api/debug/location`,
+          query: { location: input?.["location"] },
+          successStatus: 204,
+          declaredStatuses: [400, 401],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    migration: {
+      v1: {
+        status: (requestOptions) => request({
+          method: "GET",
+          path: `/api/experimental/migration/v1`,
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    websearch: {
+      providers: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/websearch/provider`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions),
+      query: (input, requestOptions) => request({
+        method: "POST",
+        path: `/api/websearch`,
+        query: { location: input["location"] },
+        body: { query: input["query"], providerID: input["providerID"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404, 503],
+        empty: false
+      }, requestOptions)
+    },
+    config: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/config`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      shells: (requestOptions) => request({
+        method: "GET",
+        path: `/api/config/shell`,
+        successStatus: 200,
+        declaredStatuses: [400, 401, 404],
+        empty: false
+      }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/experimental/config`,
+        body: { shell: input["shell"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401, 404],
+        empty: true
+      }, requestOptions)
+    }
+  };
+}
+function encodePath(value) {
+  return value.split("/").map(encodeURIComponent).join("/");
+}
+function appendQuery(params, key, value) {
+  if (value === void 0)
+    return;
+  if (value === null) {
+    params.append(key, "null");
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value)
+      appendQuery(params, key, item);
+    return;
+  }
+  if (typeof value === "object") {
+    for (const [child, item] of Object.entries(value))
+      appendQuery(params, `${key}[${child}]`, item);
+    return;
+  }
+  params.append(key, String(value));
+}
+async function json2(response) {
+  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+    try {
+      await response.body?.cancel();
+    } catch {
+    }
+    throw new ClientError2("UnsupportedContentType", { detail: response.headers.get("content-type") });
+  }
+  let text;
+  try {
+    text = await response.text();
+  } catch (cause) {
+    throw new ClientError2("Transport", { cause });
+  }
+  if (text === "")
+    throw new ClientError2("MalformedResponse");
+  try {
+    return JSON.parse(text);
+  } catch (cause) {
+    throw new ClientError2("MalformedResponse", { cause });
+  }
+}
+function declared(body) {
+  const error = Object.assign(new Error(body.message ?? body.data?.message), body);
+  if (body._tag)
+    error.name = body._tag;
+  return error;
+}
+function isContentType(response, expected) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
+}
+var exports_client2, maxSseEventBytes;
+var init_service_timing_tbh3h57v = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-tbh3h57v.js"() {
+    init_service_timing_js54wxgp();
+    init_service_timing_9rqn6x4v();
+    exports_client2 = {};
+    __export2(exports_client2, {
+      make: () => make3
+    });
+    maxSseEventBytes = 16 * 1024 * 1024;
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-vt9jbch8.js
+var isInvalidRequestError2, isUnauthorizedError2, isLocationNotFoundError2, isServiceUnavailableError2, isAgentNotFoundError2, isInvalidCursorError2, isSessionNotFoundError2, isConflictError2, isUnknownError2, isMessageNotFoundError2, isCommandNotFoundError2, isCommandExecutionError2, isSkillNotFoundError2, isSessionBusyError2, isInstructionEntryValueTooLargeError2, isFormNotFoundError2, isFormInvalidAnswerError2, isFormAlreadySettledError2, isProviderNotFoundError2, isIntegrationNotFoundError2, isIntegrationAttemptNotFoundError2, isIntegrationMethodNotFoundError2, isMcpServerNotFoundError2, isProjectNotFoundError2, isPermissionNotFoundError2, isFileNotFoundError2, isRpcError2, isRpcInternalError2, isPtyNotFoundError2, isForbiddenError2, isShellNotFoundError2, isWorktreeError2, isVcsInitNotSupportedError2;
+var init_service_timing_vt9jbch8 = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-vt9jbch8.js"() {
+    isInvalidRequestError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InvalidRequestError";
+    isUnauthorizedError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "UnauthorizedError";
+    isLocationNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "LocationNotFoundError";
+    isServiceUnavailableError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ServiceUnavailableError";
+    isAgentNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "AgentNotFoundError";
+    isInvalidCursorError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InvalidCursorError";
+    isSessionNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SessionNotFoundError";
+    isConflictError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ConflictError";
+    isUnknownError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "UnknownError";
+    isMessageNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "MessageNotFoundError";
+    isCommandNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "CommandNotFoundError";
+    isCommandExecutionError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "CommandExecutionError";
+    isSkillNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SkillNotFoundError";
+    isSessionBusyError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "SessionBusyError";
+    isInstructionEntryValueTooLargeError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "InstructionEntryValueTooLargeError";
+    isFormNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormNotFoundError";
+    isFormInvalidAnswerError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormInvalidAnswerError";
+    isFormAlreadySettledError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FormAlreadySettledError";
+    isProviderNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProviderNotFoundError";
+    isIntegrationNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationNotFoundError";
+    isIntegrationAttemptNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationAttemptNotFoundError";
+    isIntegrationMethodNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "IntegrationMethodNotFoundError";
+    isMcpServerNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "McpServerNotFoundError";
+    isProjectNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ProjectNotFoundError";
+    isPermissionNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PermissionNotFoundError";
+    isFileNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "FileNotFoundError";
+    isRpcError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcError";
+    isRpcInternalError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "RpcInternalError";
+    isPtyNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "PtyNotFoundError";
+    isForbiddenError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ForbiddenError";
+    isShellNotFoundError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "ShellNotFoundError";
+    isWorktreeError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "WorktreeError";
+    isVcsInitNotSupportedError2 = (value) => typeof value === "object" && value !== null && "_tag" in value && value["_tag"] === "VcsInitNotSupportedError";
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-1y4a697q.js
+function makeRpc2(raw, events) {
+  return (definition) => {
+    const subscribe = (name, options) => {
+      if (!Object.hasOwn(definition.events, name))
+        throw new Error(`Unknown RPC event: ${definition.id}.${name}`);
+      const type = eventType(definition, name);
+      return {
+        [Symbol.asyncIterator]() {
+          const controller = new AbortController();
+          const signal2 = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = (async function* () {
+            try {
+              for await (const published of events.subscribe({ signal: signal2 })) {
+                if (signal2.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error) {
+              if (!signal2.aborted)
+                throw error;
+            } finally {
+              controller.abort();
+            }
+          })();
+          return {
+            next: () => iterator.next(),
+            return: () => {
+              controller.abort();
+              return iterator.return();
+            }
+          };
+        }
+      };
+    };
+    return Object.assign(Object.fromEntries(Object.keys(definition.methods).map((name) => [
+      name,
+      async (input, options) => {
+        try {
+          const result = await raw.rpc.call({
+            rpcID: definition.id,
+            method: name,
+            input,
+            location: options?.location
+          }, { signal: options?.signal, headers: options?.headers });
+          return result.output;
+        } catch (error) {
+          if (!isRpcError2(error) && !isRpcInternalError2(error))
+            throw error;
+          throw error.data === void 0 ? { type: error.type, message: error.message } : { type: error.type, message: error.message, data: error.data };
+        }
+      }
+    ])), {
+      events: {
+        subscribe,
+        on: (name, handler, options) => {
+          const controller = new AbortController();
+          const signal2 = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal: signal2 });
+          (async () => {
+            for await (const event of source)
+              await handler(event);
+          })().catch((error) => console.error(error));
+          return () => controller.abort();
+        }
+      }
+    });
+  };
+}
+function eventType(definition, name) {
+  return `rpc.${definition.id}.${name}`;
+}
+var init_service_timing_1y4a697q = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-1y4a697q.js"() {
+    init_service_timing_vt9jbch8();
+  }
+});
+
+// node_modules/@opencode/client/dist/chunks/service-timing-e4sc9kq6.js
+function make2(options) {
+  const raw = make3(options);
+  const events = make7((signal2, onActivity) => raw.event.subscribe({ signal: signal2, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
+var exports_client;
+var init_service_timing_e4sc9kq6 = __esm({
+  "node_modules/@opencode/client/dist/chunks/service-timing-e4sc9kq6.js"() {
+    init_service_timing_frbwqjmf();
+    init_service_timing_tbh3h57v();
+    init_service_timing_1y4a697q();
+    init_service_timing_9rqn6x4v();
+    exports_client = {};
+    __export2(exports_client, {
+      OpenCode: () => exports_client,
+      make: () => make2
+    });
+  }
+});
+
+// node_modules/@opencode/client/dist/promise/index.js
+var promise_exports = {};
+__export(promise_exports, {
+  ClientError: () => ClientError2,
+  OpenCode: () => exports_client,
+  isAgentNotFoundError: () => isAgentNotFoundError2,
+  isCommandExecutionError: () => isCommandExecutionError2,
+  isCommandNotFoundError: () => isCommandNotFoundError2,
+  isConflictError: () => isConflictError2,
+  isFileNotFoundError: () => isFileNotFoundError2,
+  isForbiddenError: () => isForbiddenError2,
+  isFormAlreadySettledError: () => isFormAlreadySettledError2,
+  isFormInvalidAnswerError: () => isFormInvalidAnswerError2,
+  isFormNotFoundError: () => isFormNotFoundError2,
+  isInstructionEntryValueTooLargeError: () => isInstructionEntryValueTooLargeError2,
+  isIntegrationAttemptNotFoundError: () => isIntegrationAttemptNotFoundError2,
+  isIntegrationMethodNotFoundError: () => isIntegrationMethodNotFoundError2,
+  isIntegrationNotFoundError: () => isIntegrationNotFoundError2,
+  isInvalidCursorError: () => isInvalidCursorError2,
+  isInvalidRequestError: () => isInvalidRequestError2,
+  isLocationNotFoundError: () => isLocationNotFoundError2,
+  isMcpServerNotFoundError: () => isMcpServerNotFoundError2,
+  isMessageNotFoundError: () => isMessageNotFoundError2,
+  isPermissionNotFoundError: () => isPermissionNotFoundError2,
+  isProjectNotFoundError: () => isProjectNotFoundError2,
+  isProviderNotFoundError: () => isProviderNotFoundError2,
+  isPtyNotFoundError: () => isPtyNotFoundError2,
+  isRpcError: () => isRpcError2,
+  isRpcInternalError: () => isRpcInternalError2,
+  isServiceUnavailableError: () => isServiceUnavailableError2,
+  isSessionBusyError: () => isSessionBusyError2,
+  isSessionNotFoundError: () => isSessionNotFoundError2,
+  isShellNotFoundError: () => isShellNotFoundError2,
+  isSkillNotFoundError: () => isSkillNotFoundError2,
+  isUnauthorizedError: () => isUnauthorizedError2,
+  isUnknownError: () => isUnknownError2,
+  isVcsInitNotSupportedError: () => isVcsInitNotSupportedError2,
+  isWorktreeError: () => isWorktreeError2
+});
+var init_promise = __esm({
+  "node_modules/@opencode/client/dist/promise/index.js"() {
+    init_service_timing_e4sc9kq6();
+    init_service_timing_tbh3h57v();
+    init_service_timing_js54wxgp();
+    init_service_timing_1y4a697q();
+    init_service_timing_vt9jbch8();
+    init_service_timing_frbwqjmf();
+  }
+});
+
 // src/config.js
-import { readFileSync } from "node:fs";
+import { readFileSync as readFileSync2 } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 
 // src/utilities.js
 var MAX_TRACKED_ITEMS = 500;
@@ -74,6 +1930,48 @@ function rememberRecent(map, key, value) {
   while (map.size > 100) map.delete(map.keys().next().value);
 }
 
+// src/live-bridge-config.js
+import { constants, closeSync, fstatSync, openSync, readFileSync } from "node:fs";
+import { isAbsolute, join } from "node:path";
+function readCredential(file) {
+  if (typeof file !== "string" || !isAbsolute(file)) {
+    throw new Error("Live control requires an absolute credential-file path");
+  }
+  let descriptor;
+  try {
+    descriptor = openSync(file, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0) | (constants.O_NONBLOCK ?? 0));
+    const stat = fstatSync(descriptor);
+    if (!stat.isFile() || stat.size > 4096 || process.platform !== "win32" && ((stat.mode & 63) !== 0 || stat.uid !== process.getuid())) {
+      throw new Error("invalid_file");
+    }
+    const token = readFileSync(descriptor, "utf8").trim();
+    if (!/^[A-Za-z0-9_-]{32,256}$/.test(token)) throw new Error("invalid_token");
+    return token;
+  } catch {
+    throw new Error("Live control credential must be an owner-only regular file containing a 32\u2013256 character token");
+  } finally {
+    if (descriptor !== void 0) closeSync(descriptor);
+  }
+}
+function loadLiveBridgeConfig(option, { configDirectory, ingestToken } = {}) {
+  const values = option && typeof option === "object" ? option : {};
+  const enabled2 = (typeof option === "boolean" ? option : values.enabled) ?? process.env.BACKEER_LIVE_ENABLED;
+  if (enabled2 !== true && enabled2 !== "true" && enabled2 !== "1") return { enabled: false };
+  try {
+    const rawPort = values.port ?? process.env.BACKEER_LIVE_PORT ?? 43871;
+    const port = Number(rawPort);
+    if (!Number.isInteger(port) || port < 1 || port > 65535) {
+      throw new Error("Live control port must be an integer between 1 and 65535");
+    }
+    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 };
+  } catch (error) {
+    return { enabled: false, error: error.message };
+  }
+}
+
 // src/config.js
 var DEFAULT_ORIGIN = "https://external-gateway.backeer.com";
 function integer(value, fallback, { minimum = 0, maximum = 86400 } = {}) {
@@ -115,13 +2013,13 @@ function loadLifecycleConfig(option) {
 }
 function defaultConfigDirectory() {
   const base = process.env.XDG_CONFIG_HOME?.trim();
-  return base ? join(base, "opencode") : join(homedir(), ".config", "opencode");
+  return base ? join2(base, "opencode") : join2(homedir(), ".config", "opencode");
 }
 function loadToken(tokenFile) {
   const environmentToken = process.env.BACKEER_INGEST_TOKEN?.trim();
   if (environmentToken) return { token: environmentToken, source: "environment" };
   try {
-    const token = readFileSync(tokenFile, "utf8").trim();
+    const token = readFileSync2(tokenFile, "utf8").trim();
     return { token, source: token ? "file" : "missing" };
   } catch {
     return { token: "", source: "missing" };
@@ -134,7 +2032,7 @@ function loadConfig(options = {}) {
   if (origin.protocol !== "https:") {
     throw new Error("Backeer origin must use HTTPS");
   }
-  const tokenFile = options.tokenFile ?? process.env.BACKEER_TOKEN_FILE ?? join(defaultConfigDirectory(), "secrets", "backeer-ingest-token");
+  const tokenFile = options.tokenFile ?? process.env.BACKEER_TOKEN_FILE ?? join2(defaultConfigDirectory(), "secrets", "backeer-ingest-token");
   const loadedToken = loadToken(tokenFile);
   return {
     origin,
@@ -144,6 +2042,10 @@ function loadConfig(options = {}) {
     token: loadedToken.token,
     tokenSource: loadedToken.source,
     tokenFile,
+    liveBridge: loadLiveBridgeConfig(options.liveBridge, {
+      configDirectory: defaultConfigDirectory(),
+      ingestToken: loadedToken.token
+    }),
     permissions: enabled(
       options.permissions ?? process.env.BACKEER_NOTIFY_PERMISSIONS
     ),
@@ -238,19 +2140,19 @@ function isRetryable(status) {
 function isAbortError(error) {
   return error instanceof Error && error.name === "AbortError";
 }
-function sleep(milliseconds, signal) {
+function sleep(milliseconds, signal2) {
   return new Promise((resolve2) => {
-    if (signal?.aborted) {
+    if (signal2?.aborted) {
       resolve2();
       return;
     }
     const timeout = setTimeout(done, milliseconds);
     function done() {
       clearTimeout(timeout);
-      signal?.removeEventListener("abort", done);
+      signal2?.removeEventListener("abort", done);
       resolve2();
     }
-    signal?.addEventListener("abort", done, { once: true });
+    signal2?.addEventListener("abort", done, { once: true });
   });
 }
 async function postJsonWithRetry(config, url, body, options = {}) {
@@ -481,7 +2383,7 @@ async function publishTodoCompletion(config, reporter, request, eventID, client,
 import {
   chmodSync,
   mkdirSync,
-  readFileSync as readFileSync2,
+  readFileSync as readFileSync3,
   renameSync,
   statSync as statSync2,
   writeFileSync
@@ -493,7 +2395,7 @@ import { randomUUID } from "node:crypto";
 import { statSync } from "node:fs";
 
 // src/updates.js
-var PLUGIN_VERSION = "0.3.2";
+var PLUGIN_VERSION = "0.5.1";
 var PACKAGE_NAME = "backeer-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var CHECK_TIMEOUT_MS = 3e3;
@@ -524,7 +2426,8 @@ function isVersionNewer(latestValue, currentValue) {
 }
 function createUpdateChecker({
   fetchImplementation = globalThis.fetch,
-  now = () => Date.now()
+  now = () => Date.now(),
+  v2 = false
 } = {}) {
   let checkedAt = 0;
   let cachedResult;
@@ -554,7 +2457,7 @@ function createUpdateChecker({
         state: "available",
         currentVersion: PLUGIN_VERSION,
         latestVersion,
-        updateCommand: `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`
+        updateCommand: v2 ? `opencode plugin add ${PACKAGE_NAME}@${latestVersion}` : `opencode plugin ${PACKAGE_NAME}@${latestVersion} -g --force`
       };
     } catch {
       return { state: "unavailable", currentVersion: PLUGIN_VERSION };
@@ -983,7 +2886,7 @@ function rotateTokenFromFile(config, sourcePathValue) {
   if ((sourceStats.mode & 63) !== 0) {
     throw new Error("The token source must not be readable by group or other users");
   }
-  const token = readFileSync2(sourcePath, "utf8").trim();
+  const token = readFileSync3(sourcePath, "utf8").trim();
   if (!token || /\s/.test(token)) {
     throw new Error("The token source must contain exactly one non-empty token");
   }
@@ -1510,35 +3413,546 @@ function createLifecycleController({
   };
 }
 
-// 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"
-    };
+// src/live-bridge.js
+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;
   }
+  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();
+    }
+  };
 }
-function failureAcknowledgement(command, error) {
-  const stale = error instanceof HttpError && error.status === 404;
+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
+      }));
+    }
+  };
+}
+
+// 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");
+      }
+    }
+  }
+  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/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 };
+  }
+  function text(value, max) {
+    return clipped(value, max).value;
+  }
+  function content(key, value) {
+    const result = clipped(value);
+    return { [key]: result.value, ...result.truncated ? { truncated: true } : {} };
+  }
+  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 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 {
+    return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  } catch {
+    throw failure(400, "invalid_json");
+  }
+}
+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);
+        }
+      );
+    });
+  }
+  async function session(id) {
+    if (!validBridgeID(id) || id === "global") throw failure(400, "invalid_session");
+    let info;
+    try {
+      info = await lookup(id);
+    } catch (error) {
+      if (["session_lookup_busy", "session_lookup_timed_out", "bridge_closed"].includes(error.code)) throw error;
+      throw failure(404, "session_not_found");
+    }
+    if (info?.id !== id || (info.location?.directory ?? info.directory) !== directory) {
+      throw failure(404, "session_not_found");
+    }
+    return {
+      id,
+      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);
+  }
+  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 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);
+  }
+  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);
+  }
+  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 };
+  }
+  async function route(request, response) {
+    if (!authorized(request)) return json(response, 401, { error: "unauthorized" });
+    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 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) && (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 } : {}
+        })), 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();
+        }
+        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);
+      }
+      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);
+      }
+      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
+      };
+      commands.set(body.requestId, command);
+      command.task = Promise.resolve().then(() => api.prompt(match[1], body.prompt)).finally(() => {
+        command.settled = true;
+      });
+      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);
+    }
+  }
+  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();
+        }
+        server.close(() => {
+          void connectionNotifications.dispose().then(resolve2);
+        });
+        server.closeAllConnections?.();
+        events.length = 0;
+        states.clear();
+        commands.clear();
+        sanitizer.clear();
+        api.dispose?.();
+      });
+      return disposeTask;
+    }
+  };
+}
+
+// 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 {
     status: stale ? "stale" : "failed",
     decision: command.decision,
@@ -1651,13 +4065,13 @@ function nextSseFrame(buffer) {
   }
   return { frame: buffer.slice(0, lfIndex), rest: buffer.slice(lfIndex + 2) };
 }
-async function consumeSse(response, state, onCommand, signal, reporter) {
+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 (!signal.aborted) {
+    while (!signal2.aborted) {
       const item = await reader.read();
       if (item.done) break;
       buffer += decoder.decode(item.value, { stream: true });
@@ -1686,7 +4100,7 @@ async function consumeSse(response, state, onCommand, signal, reporter) {
     });
   }
 }
-async function openCommandStream(config, state, signal, fetchImplementation) {
+async function openCommandStream(config, state, signal2, fetchImplementation) {
   const headers = {
     Accept: "text/event-stream",
     Authorization: `Bearer ${config.token}`
@@ -1694,7 +4108,7 @@ async function openCommandStream(config, state, signal, fetchImplementation) {
   if (state.lastEventID) headers["Last-Event-ID"] = state.lastEventID;
   const response = await fetchImplementation(config.commandStreamEndpoint, {
     headers,
-    signal
+    signal: signal2
   });
   if (!response.ok) {
     const responseBody = limit(await response.text(), 500);
@@ -1713,7 +4127,7 @@ async function consumeConnection({
   response,
   state,
   onCommand,
-  signal,
+  signal: signal2,
   reporter,
   now,
   stableConnectionMs,
@@ -1722,7 +4136,7 @@ async function consumeConnection({
   const connectedAt = now();
   const framesBeforeConnection = state.framesReceived;
   try {
-    await consumeSse(response, state, onCommand, signal, reporter);
+    await consumeSse(response, state, onCommand, signal2, reporter);
   } finally {
     const receivedFrame = state.framesReceived > framesBeforeConnection;
     if (receivedFrame || now() - connectedAt >= stableConnectionMs) onStable();
@@ -1743,7 +4157,7 @@ function streamErrorState(error, lastLoggedError, reconnectDelay, reporter) {
   };
 }
 async function runCommandStream(config, reporter, {
-  signal,
+  signal: signal2,
   hasPending,
   onCommand,
   fetchImplementation = fetch,
@@ -1754,19 +4168,19 @@ async function runCommandStream(config, reporter, {
   const state = { lastEventID: "", framesReceived: 0 };
   let reconnectDelay = 1e3;
   let lastLoggedError = "";
-  while (!signal.aborted && hasPending()) {
+  while (!signal2.aborted && hasPending()) {
     try {
       const response = await openCommandStream(
         config,
         state,
-        signal,
+        signal2,
         fetchImplementation
       );
       await consumeConnection({
         response,
         state,
         onCommand,
-        signal,
+        signal: signal2,
         reporter,
         now,
         stableConnectionMs,
@@ -1776,13 +4190,13 @@ async function runCommandStream(config, reporter, {
         }
       });
     } catch (error) {
-      if (signal.aborted || isAbortError(error)) return;
+      if (signal2.aborted || isAbortError(error)) return;
       const next = streamErrorState(error, lastLoggedError, reconnectDelay, reporter);
       reconnectDelay = next.reconnectDelay;
       lastLoggedError = next.lastLoggedError;
     }
-    if (!signal.aborted && hasPending()) {
-      await sleepImplementation(reconnectDelay, signal);
+    if (!signal2.aborted && hasPending()) {
+      await sleepImplementation(reconnectDelay, signal2);
       reconnectDelay = Math.min(reconnectDelay * 2, 6e4);
     }
   }
@@ -2070,7 +4484,7 @@ function createPermissionController({
 }
 
 // src/plugin.js
-async function BackeerPlugin({ client, directory }, options = {}) {
+async function BackeerPlugin({ client, directory, feedback, v2 = false }, options = {}) {
   const bootstrapReporter = createOpenCodeReporter(
     client,
     options.logLevel ?? process.env.BACKEER_LOG_LEVEL
@@ -2083,7 +4497,14 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     return {};
   }
   const reporter = createOpenCodeReporter(client, config.logLevel);
-  const conversation = createConversationFeedback({ client, reporter });
+  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) => {
+    reporter.error("Live control unavailable", error);
+    return { async handle() {
+    }, async dispose() {
+    } };
+  });
   const permissionController = createPermissionController({
     config,
     reporter,
@@ -2101,7 +4522,7 @@ async function BackeerPlugin({ client, directory }, options = {}) {
   const permissionPublications = createDeliveryTracker();
   const questionPublications = createDeliveryTracker();
   const todoCompletions = createCompletionTracker();
-  const updateChecker = createUpdateChecker();
+  const updateChecker = createUpdateChecker({ v2 });
   const handleBackeerCommand = createBackeerCommandHandler({
     client,
     config,
@@ -2191,6 +4612,38 @@ async function BackeerPlugin({ client, directory }, options = {}) {
       conversation.error(identity.sessionID, "Question could not be sent");
     });
   }
+  async function handleNotificationEvent(event) {
+    if (!config.token) return;
+    conversation.handle(event);
+    lifecycleController.handle(event);
+    if (config.permissions && event.type === "permission.asked") {
+      await handlePermissionAsked(event);
+      return;
+    }
+    if (config.permissions && event.type === "permission.replied") {
+      permissionController.resolveLocally(
+        event.properties.requestID ?? event.properties.id
+      );
+      return;
+    }
+    if (config.todos && event.type === "todo.updated") {
+      await handleTodoUpdated(event);
+      return;
+    }
+    if (config.questions && (event.type === "question.asked" || event.type === "question.v2.asked")) {
+      await handleQuestionAsked(event);
+      return;
+    }
+    if (config.questions && ["question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"].includes(event.type)) {
+      const requestID = event.properties.requestID ?? event.properties.id;
+      if (typeof requestID === "string") {
+        permissionController.resolveQuestionLocally(
+          requestID,
+          event.type.endsWith("rejected") ? "rejected" : "answered"
+        );
+      }
+    }
+  }
   return {
     config: async (opencodeConfig) => {
       registerBackeerCommand(opencodeConfig);
@@ -2198,38 +4651,10 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     "command.execute.before": handleBackeerCommand,
     "chat.message": handleUpdateNotice,
     event: async ({ event }) => {
-      if (!config.token) return;
-      conversation.handle(event);
-      lifecycleController.handle(event);
-      if (config.permissions && event.type === "permission.asked") {
-        await handlePermissionAsked(event);
-        return;
-      }
-      if (config.permissions && event.type === "permission.replied") {
-        permissionController.resolveLocally(
-          event.properties.requestID ?? event.properties.id
-        );
-        return;
-      }
-      if (config.todos && event.type === "todo.updated") {
-        await handleTodoUpdated(event);
-        return;
-      }
-      if (config.questions && (event.type === "question.asked" || event.type === "question.v2.asked")) {
-        await handleQuestionAsked(event);
-        return;
-      }
-      if (config.questions && ["question.replied", "question.v2.replied", "question.rejected", "question.v2.rejected"].includes(event.type)) {
-        const requestID = event.properties.requestID ?? event.properties.id;
-        if (typeof requestID === "string") {
-          permissionController.resolveQuestionLocally(
-            requestID,
-            event.type.endsWith("rejected") ? "rejected" : "answered"
-          );
-        }
-      }
+      await Promise.all([handleNotificationEvent(event), liveBridge.handle(event)]);
     },
     dispose: async () => {
+      await liveBridge.dispose();
       await permissionController.dispose();
       lifecycleController.dispose();
       permissionPublications.clear();
@@ -2239,6 +4664,744 @@ async function BackeerPlugin({ client, directory }, options = {}) {
     }
   };
 }
+
+// src/opencode-v2-forms.js
+init_promise();
+
+// node_modules/@opencode/client/dist/chunks/service-timing-ve4aws36.js
+import { spawn } from "node:child_process";
+var stderrLimit = 8 * 1024;
+function spawnServiceContender2(command, args, env) {
+  const child = spawn(command, args, {
+    detached: true,
+    windowsHide: true,
+    stdio: ["ignore", "ignore", "pipe"],
+    env: { ...process.env, ...env }
+  });
+  let error;
+  let closed = false;
+  let stderr = Buffer.alloc(0);
+  const onStderr = (chunk) => {
+    const tail = chunk.subarray(-stderrLimit);
+    stderr = tail.length === stderrLimit ? Buffer.from(tail) : Buffer.concat([stderr.subarray(-(stderrLimit - tail.length)), tail]);
+  };
+  child.stderr?.on("data", onStderr);
+  if (child.stderr !== null && "unref" in child.stderr && typeof child.stderr.unref === "function")
+    child.stderr.unref();
+  child.once("error", (cause) => {
+    error = new Error("Failed to start server", { cause });
+  });
+  child.once("close", () => {
+    closed = true;
+  });
+  child.unref();
+  return {
+    child,
+    error: () => error,
+    closed: () => closed,
+    stderr: () => stderr.toString("utf8").trim(),
+    release: () => {
+      child.stderr?.off("data", onStderr);
+      child.stderr?.resume();
+      stderr = Buffer.alloc(0);
+    }
+  };
+}
+function contenderPool2(timing) {
+  const contenders = /* @__PURE__ */ new Set();
+  let failure2;
+  let spawnDelay = timing.spawnDelay;
+  let lastSpawn = 0;
+  return {
+    failure: () => failure2,
+    serviceAnswered() {
+      spawnDelay = timing.spawnDelay;
+    },
+    evict(pid) {
+      for (const item of contenders) {
+        if (item.child.pid === pid || contenderFinished2(item)) {
+          item.release();
+          contenders.delete(item);
+        }
+      }
+      failure2 = void 0;
+      lastSpawn = 0;
+    },
+    recruitNow() {
+      lastSpawn = Date.now() - spawnDelay;
+    },
+    reap() {
+      const finished = [...contenders].filter(contenderFinished2);
+      failure2 ??= finished.map(contenderFailure).find((error) => error !== void 0);
+      if (finished.some((item) => item.child.exitCode === 0))
+        spawnDelay = Math.min(spawnDelay * 2, timing.maxSpawnDelay);
+      finished.forEach((item) => contenders.delete(item));
+      return contenders.size === 0 ? failure2 : void 0;
+    },
+    shouldRecruit(registered2) {
+      if (lastSpawn === 0 && registered2)
+        lastSpawn = Date.now();
+      return failure2 === void 0 && contenders.size < 2 && Date.now() - lastSpawn >= spawnDelay;
+    },
+    add(contender) {
+      contenders.add(contender);
+      lastSpawn = Date.now();
+    },
+    releaseAll() {
+      contenders.forEach((contender) => contender.release());
+    }
+  };
+}
+function contenderFailure(contender) {
+  const error = contender.error();
+  if (error !== void 0)
+    return error;
+  if (contender.child.exitCode !== null && contender.child.exitCode !== 0)
+    return startupError(`Server process exited with code ${contender.child.exitCode}`, contender.stderr());
+  if (contender.child.signalCode !== null)
+    return startupError(`Server process terminated by ${contender.child.signalCode}`, contender.stderr());
+  return;
+}
+function contenderFinished2(contender) {
+  return contender.error() !== void 0 || contender.closed();
+}
+function startupError(message, stderr) {
+  return new Error(stderr ? `${message}
+${stderr}` : message);
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-xgnj2w4v.js
+var timings = /* @__PURE__ */ new WeakMap();
+var defaultEnsureTiming2 = {
+  pollInterval: 25,
+  requestTimeout: 2e3,
+  spawnDelay: 5e3,
+  maxSpawnDelay: 3e4,
+  promiseTimeout: 12e4,
+  stopPollInterval: 50,
+  stopPollAttempts: 100
+};
+function ensureTiming2(options) {
+  return timings.get(options) ?? defaultEnsureTiming2;
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-sxt88q69.js
+function matchesVersion2(version, options) {
+  if (options.version === void 0)
+    return true;
+  if (version === void 0)
+    return false;
+  if (typeof options.version === "function")
+    return options.version(version);
+  return version === options.version;
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-0rcx1gca.js
+init_service_timing_9rqn6x4v();
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+var exports_pty_handoff = {};
+__export2(exports_pty_handoff, {
+  PtyHandoff: () => exports_pty_handoff,
+  clear: () => clear2,
+  complete: () => complete2,
+  environment: () => environment2,
+  prepare: () => prepare2
+});
+async function prepare2(file, info, timeout) {
+  const existing = await read(file);
+  if (existing !== void 0 && existing.expiresAt > Date.now() && same(existing.source, info))
+    return;
+  const { OpenCode } = await Promise.resolve().then(() => (init_promise(), promise_exports));
+  const client = OpenCode.make({
+    baseUrl: info.url,
+    headers: info.password === void 0 ? void 0 : { authorization: "Basic " + Buffer.from(`opencode:${info.password}`).toString("base64") }
+  });
+  const handoff = await client.experimental.persistentPty.handoff({ signal: AbortSignal.timeout(timeout) }).then(parse).catch(async (cause) => {
+    const concurrent = await read(file);
+    if (concurrent !== void 0 && concurrent.expiresAt > Date.now() && same(concurrent.source, info))
+      return;
+    console.warn("Background service cannot hand off persistent terminals; shutting them down before replacement", cause);
+    await client.experimental.persistentPty.shutdown({ signal: AbortSignal.timeout(timeout) }).catch(() => {
+    });
+    return null;
+  });
+  if (handoff === void 0)
+    return;
+  await publish2(file, info, handoff).catch((cause) => console.warn("Failed to publish persistent terminal handoff", cause));
+}
+function parse(body) {
+  if (typeof body !== "object" || body === null || !("handoff" in body))
+    throw new Error("Invalid persistent terminal handoff response");
+  if (body.handoff === null)
+    return null;
+  if (!isHandoff(body.handoff) || body.handoff.expiresAt <= Date.now())
+    throw new Error("Invalid or expired persistent terminal handoff");
+  return body.handoff;
+}
+async function publish2(file, info, handoff) {
+  const temporary = `${file}.pty-handoff.${crypto.randomUUID()}.tmp`;
+  await writeFile(temporary, JSON.stringify({
+    source: { id: info.id, pid: info.pid, url: info.url },
+    handoff,
+    expiresAt: handoff?.expiresAt ?? Date.now() + 3e4
+  }), { mode: 384, flag: "wx" });
+  await rename(temporary, file + ".pty-handoff").finally(() => rm(temporary, { force: true }));
+}
+async function environment2(file, env) {
+  const record = await read(file);
+  const current = await readFile(file, "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  const handoff = record !== void 0 && record.expiresAt > Date.now() && (current === void 0 || same(record.source, current)) ? record.handoff : void 0;
+  return { ...env, OPENCODE_PTY_HANDOFF: handoff == null ? void 0 : JSON.stringify(handoff) };
+}
+async function complete2(file, info) {
+  const record = await read(file);
+  if (record !== void 0 && !same(record.source, info))
+    await clear2(file);
+}
+async function clear2(file) {
+  await rm(file + ".pty-handoff", { force: true });
+}
+async function read(file) {
+  const value = await readFile(file + ".pty-handoff", "utf8").then((text) => JSON.parse(text)).catch(() => {
+    return;
+  });
+  if (typeof value !== "object" || value === null || !("source" in value) || !("handoff" in value))
+    return;
+  if (typeof value.source !== "object" || value.source === null)
+    return;
+  if (!("pid" in value.source) || typeof value.source.pid !== "number")
+    return;
+  if (!("url" in value.source) || typeof value.source.url !== "string")
+    return;
+  if ("id" in value.source && typeof value.source.id !== "string")
+    return;
+  if (value.handoff !== null && !isHandoff(value.handoff))
+    return;
+  if (!("expiresAt" in value) || typeof value.expiresAt !== "number" || !Number.isFinite(value.expiresAt))
+    return;
+  return {
+    source: {
+      id: "id" in value.source && typeof value.source.id === "string" ? value.source.id : void 0,
+      pid: value.source.pid,
+      url: value.source.url
+    },
+    handoff: value.handoff,
+    expiresAt: value.expiresAt
+  };
+}
+function same(left, right) {
+  return left.id === right.id && left.pid === right.pid && left.url === right.url;
+}
+function isHandoff(value) {
+  return typeof value === "object" && value !== null && "directory" in value && typeof value.directory === "string" && "instanceID" in value && typeof value.instanceID === "string" && "ticket" in value && typeof value.ticket === "string" && "expiresAt" in value && typeof value.expiresAt === "number" && Number.isFinite(value.expiresAt);
+}
+
+// node_modules/@opencode/client/dist/chunks/service-timing-8ye1ye6f.js
+import { homedir as homedir2 } from "node:os";
+import { join as join3 } from "node:path";
+function decide2(service, options) {
+  if (!matchesVersion2(service.version, options))
+    return { _tag: "replace", pty: service.state === "ready" ? "handoff" : "clear" };
+  if (!service.compatible)
+    return fail("Background service uses an incompatible health protocol. Update this client or explicitly restart the service.");
+  if (service.state === "ready")
+    return { _tag: "reuse" };
+  if (service.state === "failed")
+    return fail("Background service failed to start");
+  return { _tag: "wait" };
+}
+function fail(message) {
+  return { _tag: "fail", error: new Error(message) };
+}
+function fallback2() {
+  return join3(process.env["XDG_STATE_HOME"] ?? join3(homedir2(), ".local", "state"), "opencode", "service.json");
+}
+function same2(left, right) {
+  return left.id === right.id && left.version === right.version && left.url === right.url && left.pid === right.pid;
+}
+async function probeResult2(info, timeout = defaultEnsureTiming2.requestTimeout) {
+  const endpoint = {
+    url: info.url,
+    auth: info.password === void 0 ? void 0 : { type: "basic", username: "opencode", password: info.password }
+  };
+  const signal2 = AbortSignal.timeout(timeout);
+  const result = await fetch(new URL("/api/info", info.url), { headers: headers2(endpoint), signal: signal2 }).then(async (response2) => ({
+    response: response2,
+    body: response2.status === 404 ? void 0 : await response2.json()
+  })).catch(() => {
+    return;
+  });
+  if (result === void 0)
+    return { service: void 0, timedOut: signal2.aborted };
+  const response = result.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
+    };
+  const serverInfo = decodeInfo(result.body);
+  if (serverInfo === void 0)
+    return { service: void 0, timedOut: false };
+  if (serverInfo.pid !== info.pid)
+    return { service: void 0, timedOut: false };
+  if (info.version !== void 0 && serverInfo.version !== info.version)
+    return { service: void 0, timedOut: false };
+  return {
+    service: {
+      info,
+      endpoint,
+      version: serverInfo.version,
+      state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+      compatible: true
+    },
+    timedOut: false
+  };
+}
+function headers2(endpoint) {
+  if (endpoint.auth === void 0)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
+}
+function decodeInfo(input) {
+  if (typeof input !== "object" || input === null)
+    return;
+  if (!("version" in input) || typeof input.version !== "string")
+    return;
+  if (!("pid" in input) || typeof input.pid !== "number" || !Number.isInteger(input.pid) || input.pid < 0)
+    return;
+  return { version: input.version, pid: input.pid };
+}
+
+// node_modules/@opencode/client/dist/promise/service.js
+import { readFile as readFile2, rm as rm2 } from "node:fs/promises";
+async function discover(options = {}) {
+  const found = (await registered(options.file)).service;
+  if (found?.state !== "ready")
+    return;
+  if (!found.compatible)
+    return;
+  if (!matchesVersion2(found.version, options))
+    return;
+  return found.endpoint;
+}
+async function ensure(options = {}) {
+  const timing = ensureTiming2(options);
+  const deadline = Date.now() + timing.promiseTimeout;
+  const pool = contenderPool2(timing);
+  let timeouts;
+  let announced = false;
+  const announce = (reason, previousVersion) => {
+    if (announced)
+      return;
+    announced = true;
+    options.onStart?.(reason, previousVersion);
+  };
+  const spawnContender = async () => {
+    const [command, ...args] = options.command ?? ["opencode", "serve", "--service"];
+    if (command === void 0)
+      throw new Error("Missing service command");
+    try {
+      return spawnServiceContender2(command, args, await environment2(options.file ?? fallback2(), options.env));
+    } catch (cause) {
+      throw new Error("Failed to start server", { cause });
+    }
+  };
+  try {
+    while (true) {
+      if (Date.now() >= deadline)
+        throw pool.failure() ?? new Error("Timed out waiting for the background service to start");
+      const registration = await registered(options.file, timing.requestTimeout);
+      if (registration.timedOut && registration.info !== void 0) {
+        timeouts = {
+          info: registration.info,
+          count: timeouts !== void 0 && same2(timeouts.info, registration.info) ? timeouts.count + 1 : 1
+        };
+        if (timeouts.count >= 3) {
+          announce("missing");
+          console.warn("Background service is unresponsive; recovery cannot preserve persistent terminals");
+          await clear2(options.file ?? fallback2());
+          await terminate(registration.info, options, timing);
+          pool.evict(registration.info.pid);
+          pool.recruitNow();
+          timeouts = void 0;
+        }
+      } else
+        timeouts = void 0;
+      if (registration.service !== void 0) {
+        pool.serviceAnswered();
+        const service2 = registration.service;
+        const decision = decide2(service2, options);
+        if (decision._tag === "fail")
+          throw decision.error;
+        if (decision._tag === "reuse") {
+          await complete2(options.file ?? fallback2(), service2.info);
+          return service2.endpoint;
+        }
+        if (decision._tag === "replace") {
+          announce("version-mismatch", service2.version);
+          if (service2.state !== "ready")
+            console.warn("Background service is not ready; replacement cannot preserve persistent terminals");
+          await stop({ file: options.file, pty: decision.pty }).catch(() => {
+            return;
+          });
+          pool.evict(service2.info.pid);
+        }
+      } else {
+        const failed = pool.reap();
+        if (failed !== void 0)
+          throw failed;
+        if (pool.shouldRecruit(registration.info !== void 0)) {
+          announce("missing");
+          pool.add(await spawnContender());
+        }
+      }
+      await delay(timing.pollInterval);
+    }
+  } finally {
+    pool.releaseAll();
+  }
+}
+async function stop(options = {}) {
+  const info = await read2(options.file);
+  await (options.pty === "handoff" && info !== void 0 ? prepare2(options.file ?? fallback2(), info, defaultEnsureTiming2.requestTimeout) : clear2(options.file ?? fallback2())).catch((cause) => console.warn("Failed to prepare persistent terminals for replacement", cause));
+  if (info !== void 0)
+    await terminate(info, options, ensureTiming2(options));
+}
+async function read2(file) {
+  const text = await readFile2(file ?? fallback2(), "utf8").catch(() => {
+    return;
+  });
+  if (text === void 0)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
+  }
+}
+async function registered(file, timeout) {
+  const info = await read2(file);
+  if (info === void 0)
+    return { info: void 0, service: void 0, timedOut: false };
+  return { info, ...await probeResult2(info, timeout) };
+}
+function signal(pid, name) {
+  try {
+    process.kill(pid, name);
+  } catch {
+  }
+}
+function stopped(pid) {
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function waitUntilStopped(pid, timing) {
+  for (let attempt = 0; attempt <= timing.stopPollAttempts; attempt++) {
+    if (stopped(pid))
+      return true;
+    if (attempt < timing.stopPollAttempts)
+      await delay(timing.stopPollInterval);
+  }
+  return false;
+}
+async function terminate(info, options, timing) {
+  const current = await read2(options.file);
+  if (current === void 0 || !same2(current, info))
+    return;
+  signal(info.pid, "SIGTERM");
+  if (!await waitUntilStopped(info.pid, timing)) {
+    signal(info.pid, "SIGKILL");
+    if (!await waitUntilStopped(info.pid, timing))
+      throw new Error(`Server process ${info.pid} is still running`);
+  }
+  const latest = await read2(options.file);
+  if (latest === void 0 || !same2(latest, info))
+    return;
+  await rm2(options.file ?? fallback2(), { force: true });
+}
+function delay(milliseconds) {
+  return new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+var Service = { discover, ensure, stop, headers: headers2 };
+
+// src/opencode-v2-forms.js
+async function getFormApi(ctx, sessionID, { makeClient = exports_client.make } = {}) {
+  const endpoint = await Service.discover({ version: ctx.app.version });
+  if (!endpoint) {
+    throw new HttpError("Remote question replies require the OpenCode V2 shared service", 501);
+  }
+  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);
+  }
+  if (session.location.directory !== ctx.location.directory) {
+    throw new HttpError("The question session belongs to another OpenCode location", 403);
+  }
+  return client.session.form;
+}
+
+// src/opencode-v2-client.js
+async function nativeReply(operation) {
+  try {
+    return await operation();
+  } catch (error) {
+    const statuses = {
+      PermissionNotFoundError: 404,
+      SessionNotFoundError: 404,
+      FormNotFoundError: 404,
+      FormAlreadySettledError: 409,
+      FormInvalidAnswerError: 422
+    };
+    const status = statuses[error?._tag];
+    if (status) throw new HttpError(error.message || error._tag, status);
+    throw error;
+  }
+}
+function questionForm(form) {
+  return form?.metadata?.kind === "question" && typeof form.sessionID === "string" && form.sessionID !== "global" && Array.isArray(form.fields) && form.fields.length > 0 && form.fields.every(
+    (field) => ["string", "multiselect"].includes(field.type) && !field.hidden && !field.when?.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
+      }))
+    } }];
+  }
+  if (event.type === "form.replied" || event.type === "form.cancelled") {
+    return [{ ...normalized, type: event.type === "form.replied" ? "question.v2.replied" : "question.v2.rejected" }];
+  }
+  if (event.type === "session.execution.started") {
+    return [{ ...normalized, type: "session.status", properties: {
+      ...properties,
+      status: { type: "busy" }
+    } }];
+  }
+  if (["session.execution.succeeded", "session.execution.interrupted"].includes(event.type)) {
+    return [
+      { ...normalized, type: "message.updated", properties: { info: {
+        role: "assistant",
+        sessionID: properties.sessionID,
+        id: event.id,
+        time: { completed: event.created },
+        error: event.type === "session.execution.interrupted"
+      } } },
+      { ...normalized, type: "session.idle" }
+    ];
+  }
+  if (event.type === "session.execution.failed") {
+    return [{ ...normalized, type: "session.error" }, { ...normalized, type: "session.idle" }];
+  }
+  if (event.type === "session.idle" || event.type === "session.status" && properties.status?.type === "idle") {
+    return [];
+  }
+  return [normalized];
+}
+function createV2Client(ctx, resolveFormApi = (sessionID) => getFormApi(ctx, sessionID)) {
+  return {
+    liveBridge: createV2LiveClient(ctx),
+    app: {
+      async log({ body }) {
+        console.error(JSON.stringify(body));
+      }
+    },
+    session: {
+      get: ({ path }) => ctx.session.get({ sessionID: path.id }),
+      prompt: ({ path, body }) => ctx.session.synthetic({
+        sessionID: path.id,
+        text: body.parts.map((part) => part.text).join("\n"),
+        resume: false
+      })
+    },
+    postSessionIdPermissionsPermissionId: ({ path, body }) => nativeReply(() => ctx.permission.reply({
+      sessionID: path.id,
+      requestID: path.permissionID,
+      decision: body.response
+    })),
+    v2: { session: { question: {
+      async reply({ sessionID, requestID, questionV2Reply }) {
+        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);
+        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);
+        }
+        const answer = {};
+        form.fields.forEach((field, index) => {
+          const selections = answers[index];
+          if (!Array.isArray(selections) || selections.some((value) => typeof value !== "string")) {
+            throw new HttpError("Invalid question answer", 422);
+          }
+          const values = selections.map(
+            (label) => field.options?.find((option) => option.label === label)?.value ?? label
+          );
+          if (field.type === "multiselect") answer[field.key] = values;
+          else if (values.length === 1) answer[field.key] = values[0];
+          else if (values.length > 1) throw new HttpError("Single-choice question has multiple answers", 422);
+        });
+        return nativeReply(() => api.reply({ sessionID, formID: requestID, answer }));
+      },
+      async reject({ sessionID, requestID }) {
+        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);
+        return nativeReply(() => api.cancel({ sessionID, formID: requestID }));
+      }
+    } } },
+    async ownsEvent(event) {
+      if (event.location?.directory) return event.location.directory === ctx.location.directory;
+      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;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+
+// src/opencode-v2.js
+function waitForReconnect(signal2, delay2) {
+  return new Promise((resolve2) => {
+    const finish = () => {
+      clearTimeout(timer);
+      signal2.removeEventListener("abort", finish);
+      resolve2();
+    };
+    const timer = setTimeout(finish, delay2);
+    signal2.addEventListener("abort", finish, { once: true });
+    if (signal2.aborted) finish();
+  });
+}
+async function setup(ctx) {
+  const client = createV2Client(ctx);
+  const reporter = createOpenCodeReporter(client, ctx.options?.logLevel ?? process.env.BACKEER_LOG_LEVEL);
+  const feedback = Object.fromEntries(
+    ["info", "success", "applied", "warning", "error"].map((kind) => [
+      kind,
+      () => {
+      }
+    ])
+  );
+  feedback.handle = () => {
+  };
+  feedback.dispose = () => {
+  };
+  const hooks = await BackeerPlugin({
+    client,
+    directory: ctx.location.directory,
+    feedback,
+    v2: true
+  }, { ...ctx.options, todos: false });
+  if (!hooks.event) return;
+  const controller = new AbortController();
+  let streamTask;
+  let cleanupTask;
+  const registrations = [];
+  function cleanup() {
+    cleanupTask ??= (async () => {
+      controller.abort();
+      await streamTask?.catch(() => {
+      });
+      await hooks.dispose();
+      await Promise.all(registrations.map((registration) => registration.dispose()));
+    })();
+    return cleanupTask;
+  }
+  try {
+    await ctx.command.transform((editor) => {
+      editor.add({
+        name: "backeer",
+        description: "Check, test, update, or manage Backeer",
+        async execute({ sessionID, prompt, delivery }) {
+          const output = { parts: [] };
+          await hooks["command.execute.before"]({
+            command: "backeer",
+            sessionID,
+            arguments: prompt.text
+          }, output);
+          if (output.parts.length) {
+            await ctx.session.prompt({
+              sessionID,
+              text: output.parts.map((part) => part.text).join("\n"),
+              delivery
+            });
+          }
+        }
+      });
+    }).then((registration) => registrations.push(registration));
+    registrations.push(await ctx.session.hook("prompt", async (event) => {
+      const output = { message: { id: event.messageID }, parts: [] };
+      await hooks["chat.message"]({ sessionID: event.sessionID }, output);
+      if (output.parts.length) {
+        event.prompt.text += `
+
+${output.parts.map((part) => part.text).join("\n")}`;
+      }
+    }));
+    streamTask = (async () => {
+      while (!controller.signal.aborted) {
+        try {
+          for await (const event of ctx.event.subscribe({ signal: controller.signal })) {
+            if (controller.signal.aborted) break;
+            if (!await client.ownsEvent(event)) continue;
+            for (const normalized of normalizeV2Event(event)) {
+              await hooks.event({ event: normalized });
+            }
+          }
+        } catch (error) {
+          if (!controller.signal.aborted) reporter.error("OpenCode event stream disconnected", error);
+        }
+        if (!controller.signal.aborted) {
+          await waitForReconnect(controller.signal, LIVE_RECONNECT_MS);
+        }
+      }
+    })();
+    return cleanup;
+  } catch (error) {
+    await cleanup();
+    throw error;
+  }
+}
+
+// src/index.js
+var index_default = { id: "backeer-opencode", setup, server: BackeerPlugin };
 export {
-  BackeerPlugin as default
+  index_default as default
 };