@cortexkit/aft-opencode 0.56.1 → 0.57.0

package/dist/entry/server.js

@@ -44,6 +44,17 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
 
 // ../../node_modules/.bun/esprima@4.0.1/node_modules/esprima/dist/esprima.js
 var require_esprima = __commonJS(function(exports, module) {
@@ -7802,6 +7813,1702 @@ var require_src2 = __commonJS(function(exports, module) {
   };
 });
 
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-m2eywc8w.js
+var init_service_m2eywc8w = () => {};
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-9rqn6x4v.js
+function __exportSetter2(name, newValue) {
+  this[name] = __returnValue2.bind(null, newValue);
+}
+var __defProp2, __returnValue2 = (v) => v, __export2 = (target, all) => {
+  for (var name in all)
+    __defProp2(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter2.bind(all, name)
+    });
+};
+var init_service_9rqn6x4v = __esm(() => {
+  __defProp2 = Object.defineProperty;
+});
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-frbwqjmf.js
+function make7(connect) {
+  let current;
+  const capacity = 4096;
+  function stop(connection) {
+    connection.connected = undefined;
+    connection.controller.abort();
+    if (current === connection)
+      current = undefined;
+  }
+  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 {
+      stop(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)
+              stop(connection);
+            pending.splice(0).forEach((request) => {
+              if ("error" in result)
+                request.reject(result.error);
+              else
+                request.resolve({ done: true, value: undefined });
+            });
+          }
+          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: 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: undefined });
+              }
+              if (options?.signal?.aborted) {
+                abort();
+                return Promise.resolve({ done: true, value: undefined });
+              }
+              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: undefined });
+            }
+          };
+        }
+      };
+    }
+  };
+}
+var exports_shared_events;
+var init_service_frbwqjmf = __esm(() => {
+  init_service_9rqn6x4v();
+  exports_shared_events = {};
+  __export2(exports_shared_events, {
+    SharedEvents: () => exports_shared_events,
+    make: () => make7
+  });
+});
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-qc0tvgb4.js
+var ClientError2;
+var init_service_qc0tvgb4 = __esm(() => {
+  ClientError2 = class ClientError2 extends Error {
+    reason;
+    name = "ClientError";
+    constructor(reason, options) {
+      super(reason, options);
+      this.reason = reason;
+    }
+  };
+});
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-5mmhmmk7.js
+function make3(options) {
+  const fetch2 = options.fetch ?? globalThis.fetch;
+  const prepare = (descriptor, requestOptions) => {
+    const url = new URL(descriptor.path, options.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 !== undefined && value !== null)
+        headers.set(key, String(value));
+    }
+    for (const [key, value] of new Headers(requestOptions?.headers))
+      headers.set(key, value);
+    if (descriptor.body !== undefined && !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 === undefined ? undefined : 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 await json3(response);
+    try {
+      await response.body?.cancel();
+    } catch {}
+    throw new ClientError2("UnexpectedStatus", { cause: { status: 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 json3(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");
+      }
+      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)
+    },
+    location: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/location`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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],
+        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],
+        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],
+        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, 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"],
+          title: input?.["title"],
+          agent: input?.["agent"],
+          model: input?.["model"],
+          location: input?.["location"],
+          metadata: input?.["metadata"],
+          permissions: input?.["permissions"]
+        },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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"], 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)}`,
+          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, 503],
+        empty: false
+      }, requestOptions),
+      default: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/model/default`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 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, 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, 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],
+        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],
+          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)
+      },
+      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],
+          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],
+          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],
+          empty: true
+        }, requestOptions)
+      }
+    },
+    mcp: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/mcp`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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],
+        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],
+          empty: false
+        }, requestOptions)
+      }
+    },
+    credential: {
+      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], 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],
+        empty: false
+      }, requestOptions)
+    },
+    permission: {
+      request: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/request`,
+          query: { location: input?.["location"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          empty: false
+        }, requestOptions)
+      },
+      saved: {
+        list: (input, requestOptions) => request({
+          method: "GET",
+          path: `/api/permission/saved`,
+          query: { projectID: input?.["projectID"] },
+          successStatus: 200,
+          declaredStatuses: [400, 401],
+          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],
+          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],
+        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],
+        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],
+        empty: false,
+        binaryBody: true
+      }, requestOptions)
+    },
+    command: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/command`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions)
+    },
+    skill: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/skill`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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, 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],
+        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],
+        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],
+        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],
+        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],
+        empty: true
+      }, requestOptions)
+    },
+    reference: {
+      list: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/reference`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      base: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/base`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401, 503],
+        empty: false
+      }, requestOptions),
+      status: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/vcs/status`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        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],
+          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, 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, 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, 503],
+        empty: false
+      }, requestOptions)
+    },
+    config: {
+      get: (input, requestOptions) => request({
+        method: "GET",
+        path: `/api/config`,
+        query: { location: input?.["location"] },
+        successStatus: 200,
+        declaredStatuses: [400, 401],
+        empty: false
+      }, requestOptions),
+      shells: (requestOptions) => request({ method: "GET", path: `/api/config/shell`, successStatus: 200, declaredStatuses: [400, 401], empty: false }, requestOptions),
+      update: (input, requestOptions) => request({
+        method: "PATCH",
+        path: `/api/experimental/config`,
+        body: { shell: input["shell"] },
+        successStatus: 204,
+        declaredStatuses: [400, 401],
+        empty: true
+      }, requestOptions)
+    }
+  };
+}
+function encodePath(value) {
+  return value.split("/").map(encodeURIComponent).join("/");
+}
+function appendQuery(params, key, value) {
+  if (value === undefined)
+    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 json3(response) {
+  if (!isContentType(response, "application/json") && !response.headers.get("content-type")?.includes("+json")) {
+    try {
+      await response.body?.cancel();
+    } catch {}
+    throw new ClientError2("UnsupportedContentType");
+  }
+  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 isContentType(response, expected) {
+  return response.headers.get("content-type")?.split(";", 1)[0]?.trim().toLowerCase() === expected;
+}
+var exports_client2, maxSseEventBytes;
+var init_service_5mmhmmk7 = __esm(() => {
+  init_service_qc0tvgb4();
+  init_service_9rqn6x4v();
+  exports_client2 = {};
+  __export2(exports_client2, {
+    make: () => make3
+  });
+  maxSseEventBytes = 16 * 1024 * 1024;
+});
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-4tveyqeh.js
+var 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";
+var init_service_4tveyqeh = () => {};
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-1tbj6z39.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 signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const iterator = async function* () {
+            try {
+              for await (const published of events.subscribe({ signal })) {
+                if (signal.aborted)
+                  return;
+                if (published.type !== type)
+                  continue;
+                yield published;
+              }
+            } catch (error) {
+              if (!signal.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 === undefined ? { 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 signal = options?.signal ? AbortSignal.any([controller.signal, options.signal]) : controller.signal;
+          const source = subscribe(name, { signal });
+          (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_1tbj6z39 = __esm(() => {
+  init_service_4tveyqeh();
+});
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-465j0w1p.js
+function make2(options) {
+  const raw = make3(options);
+  const events = make7((signal, onActivity) => raw.event.subscribe({ signal, onActivity }));
+  return {
+    ...raw,
+    rpc: Object.assign(makeRpc2(raw, events), raw.rpc),
+    event: events
+  };
+}
+var exports_client;
+var init_service_465j0w1p = __esm(() => {
+  init_service_frbwqjmf();
+  init_service_5mmhmmk7();
+  init_service_1tbj6z39();
+  init_service_9rqn6x4v();
+  exports_client = {};
+  __export2(exports_client, {
+    OpenCode: () => exports_client,
+    make: () => make2
+  });
+});
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-vyas3vgt.js
+var init_service_vyas3vgt = () => {};
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/promise/index.js
+var init_promise = __esm(() => {
+  init_service_m2eywc8w();
+  init_service_465j0w1p();
+  init_service_vyas3vgt();
+  init_service_5mmhmmk7();
+  init_service_qc0tvgb4();
+  init_service_1tbj6z39();
+  init_service_4tveyqeh();
+  init_service_frbwqjmf();
+});
+
 // ../aft-bridge/dist/active-logger.js
 var ACTIVE_LOGGER_SYMBOL = Symbol.for("aft-bridge-active-logger");
 function loggerGlobal() {
@@ -8677,6 +10384,7 @@ class BinaryBridge {
   pending = new Map;
   outstandingBackgroundTaskIds = new Set;
   nextId = 1;
+  processGeneration = 0;
   stdoutBuffer = "";
   stdoutReadOffset = 0;
   stderrBuffer = "";
@@ -8989,6 +10697,7 @@ class BinaryBridge {
         }
       }
       const id = String(this.nextId++);
+      const tool = command === "tool_call" && typeof params.name === "string" ? params.name : command;
       let request;
       if (command === "cancel_request" || Object.hasOwn(params, "command") || Object.hasOwn(params, "method")) {
         const nested = { ...params };
@@ -9042,14 +10751,20 @@ class BinaryBridge {
             return;
           }
           entry.reject(new Error(`${this.errorPrefix} Request "${command}" (id=${id}) timed out after ${effectiveTimeoutMs}ms`));
-          this.handleTimeout(requestSessionId);
+          this.handleTimeout({
+            requestId: id,
+            tool: entry.tool,
+            generation: entry.generation
+          }, requestSessionId);
         }, effectiveTimeoutMs);
         const entry = {
           resolve,
           reject,
           timer,
           onProgress: options?.onProgress,
-          command
+          command,
+          tool,
+          generation: this.processGeneration
         };
         this.pending.set(id, entry);
         if (!child?.stdin?.writable) {
@@ -9352,6 +11067,7 @@ class BinaryBridge {
       this.handleCrash();
     });
     this.process = child;
+    this.processGeneration += 1;
     this.spawnedBinaryFingerprint = readBinaryFingerprint(this.binaryPath);
     this.lastBinaryFingerprintCheckAt = Date.now();
     this.stdoutBuffer = "";
@@ -9523,10 +11239,15 @@ class BinaryBridge {
       this.outstandingBackgroundTaskIds.add(taskId);
     }
   }
-  handleTimeout(triggeringSessionId) {
+  handleTimeout(trigger, triggeringSessionId) {
     this.consecutiveRequestTimeouts = 0;
     this.spawnedBinaryFingerprint = null;
-    this.rejectAllPending(new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} bridge killed during sibling timeout — request aborted`));
+    const abortedSiblings = Array.from(this.pending, ([requestId, entry]) => ({
+      request_id: requestId,
+      tool: entry.tool
+    }));
+    const attribution = `triggering_request_id=${trigger.requestId} ` + `triggering_tool=${JSON.stringify(trigger.tool)} ` + `bridge_generation=${trigger.generation} ` + `aborted_siblings=${JSON.stringify(abortedSiblings)}`;
+    this.rejectAllPending(new BridgeTransportUnknownOutcomeError(`${this.errorPrefix} bridge killed during sibling timeout — request aborted; ${attribution}`));
     this.outstandingBackgroundTaskIds.clear();
     if (this.process) {
       this.process.kill("SIGKILL");
@@ -9536,17 +11257,11 @@ class BinaryBridge {
     this.configured = false;
     const tail = this.formatStderrTail();
     this.stderrTail = [];
-    const killedMsg = tail ? `Bridge killed after timeout.${tail}` : `Bridge killed after timeout (see ${this.getLogFilePathVia()})`;
-    if (tail) {
-      if (triggeringSessionId) {
-        this.sessionErrorVia(triggeringSessionId, killedMsg);
-      } else {
-        this.errorVia(killedMsg);
-      }
-    } else if (triggeringSessionId) {
-      this.sessionWarnVia(triggeringSessionId, killedMsg);
+    const killedMsg = tail ? `Bridge killed after timeout; ${attribution}.${tail}` : `Bridge killed after timeout; ${attribution} (see ${this.getLogFilePathVia()})`;
+    if (triggeringSessionId) {
+      this.sessionErrorVia(triggeringSessionId, killedMsg);
     } else {
-      this.warnVia(killedMsg);
+      this.errorVia(killedMsg);
     }
   }
   handleCrash(cause) {
@@ -15535,12 +17250,36 @@ function isNpmAvailable(deps = defaultDeps()) {
   return resolveNpm(deps) !== null;
 }
 // ../aft-bridge/dist/onnx-runtime.js
-import { execFileSync } from "node:child_process";
+import { execFileSync as execFileSync2 } from "node:child_process";
 import { createHash as createHash4 } from "node:crypto";
-import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync9, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, rmSync as rmSync3, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
-import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute5, join as join12, relative as relative2, resolve as resolve7, win32 } from "node:path";
+import { chmodSync as chmodSync3, closeSync as closeSync4, copyFileSync as copyFileSync3, createWriteStream as createWriteStream2, existsSync as existsSync10, lstatSync, mkdirSync as mkdirSync5, openSync as openSync4, readdirSync as readdirSync3, readFileSync as readFileSync6, readlinkSync, realpathSync as realpathSync2, renameSync as renameSync5, rmSync as rmSync3, statSync as statSync6, symlinkSync, unlinkSync as unlinkSync4, writeFileSync as writeFileSync3 } from "node:fs";
+import { basename as basename2, dirname as dirname5, isAbsolute as isAbsolute5, join as join13, relative as relative2, resolve as resolve7, win32 } from "node:path";
 import { Readable as Readable2 } from "node:stream";
 import { pipeline as pipeline2 } from "node:stream/promises";
+
+// ../aft-bridge/dist/tar-executable.js
+import { execFileSync } from "node:child_process";
+import { existsSync as existsSync9 } from "node:fs";
+import { join as join12 } from "node:path";
+function windowsTarExecutable(options = {}) {
+  const platform = options.platform ?? process.platform;
+  if (platform !== "win32")
+    return "tar";
+  const env = options.env ?? process.env;
+  const systemTar = join12(env.SystemRoot ?? "C:\\Windows", "System32", "tar.exe");
+  return (options.exists ?? existsSync9)(systemTar) ? systemTar : "tar";
+}
+function execTarExtractionSync(args, timeout) {
+  const executable = windowsTarExecutable();
+  try {
+    execFileSync(executable, args, { stdio: "pipe", timeout });
+  } catch (cause) {
+    const detail = cause instanceof Error ? cause.message : String(cause);
+    throw new Error(`tar extraction failed using ${executable}: ${detail}`, { cause });
+  }
+}
+
+// ../aft-bridge/dist/onnx-runtime.js
 var ORT_VERSION = "1.24.4";
 var ORT_REPO = "microsoft/onnxruntime";
 var MAX_DOWNLOAD_BYTES2 = 256 * 1024 * 1024;
@@ -15604,11 +17343,11 @@ function getManualInstallHint() {
 }
 async function ensureOnnxRuntime(storageDir) {
   const info = getPlatformInfo();
-  const ortVersionDir = join12(storageDir, "onnxruntime", ORT_VERSION);
+  const ortVersionDir = join13(storageDir, "onnxruntime", ORT_VERSION);
   const libName = info?.libName ?? "libonnxruntime.dylib";
   const resolvedOrtDir = resolveCachedOnnxRuntimeDir(ortVersionDir, libName);
-  const libPath = join12(resolvedOrtDir, libName);
-  if (existsSync9(libPath)) {
+  const libPath = join13(resolvedOrtDir, libName);
+  if (existsSync10(libPath)) {
     const meta = readOnnxInstalledMeta(ortVersionDir);
     if (meta?.sha256) {
       try {
@@ -15637,9 +17376,9 @@ async function ensureOnnxRuntime(storageDir) {
     warn(`ONNX Runtime auto-download not available for ${process.platform}/${process.arch}. Install manually: ${getManualInstallHint()}`);
     return null;
   }
-  const onnxBaseDir = join12(storageDir, "onnxruntime");
+  const onnxBaseDir = join13(storageDir, "onnxruntime");
   mkdirSync5(onnxBaseDir, { recursive: true });
-  const lockPath = join12(onnxBaseDir, ONNX_LOCK_FILE);
+  const lockPath = join13(onnxBaseDir, ONNX_LOCK_FILE);
   cleanupAbandonedStagingDirs(onnxBaseDir);
   if (!acquireLock(lockPath)) {
     warn(`ONNX Runtime install already in progress in another process (lock: ${lockPath}). Skipping.`);
@@ -15658,7 +17397,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
     for (const entry of entries) {
       if (!entry.startsWith(`${ORT_VERSION}.tmp.`))
         continue;
-      const stagingDir = join12(onnxBaseDir, entry);
+      const stagingDir = join13(onnxBaseDir, entry);
       const parts = entry.split(".");
       const pidStr = parts[parts.length - 2];
       const pid = pidStr ? Number.parseInt(pidStr, 10) : NaN;
@@ -15695,7 +17434,7 @@ function cleanupAbandonedStagingDirs(onnxBaseDir) {
 }
 function cleanupIncompleteTargetIfUnowned(ortDir) {
   try {
-    if (existsSync9(ortDir) && !existsSync9(join12(ortDir, ONNX_INSTALLED_META_FILE))) {
+    if (existsSync10(ortDir) && !existsSync10(join13(ortDir, ONNX_INSTALLED_META_FILE))) {
       log(`[onnx] removing half-populated install dir ${ortDir} (no meta file)`);
       rmSync3(ortDir, { recursive: true, force: true });
     }
@@ -15739,8 +17478,8 @@ function detectOnnxVersion(libDir, libName) {
       if (version)
         return version;
     }
-    const base = join12(libDir, libName);
-    if (existsSync9(base)) {
+    const base = join13(libDir, libName);
+    if (existsSync10(base)) {
       try {
         const real = realpathSync2(base);
         const version = parseOnnxVersionFromPath(real) ?? parseOnnxVersionFromDirectoryPath(real);
@@ -15806,10 +17545,10 @@ function directoryContainsLibrary(dir, libName) {
   }
 }
 function resolveCachedOnnxRuntimeDir(ortVersionDir, libName) {
-  if (existsSync9(join12(ortVersionDir, libName)))
+  if (existsSync10(join13(ortVersionDir, libName)))
     return ortVersionDir;
-  const libSubdir = join12(ortVersionDir, "lib");
-  if (existsSync9(join12(libSubdir, libName)))
+  const libSubdir = join13(ortVersionDir, "lib");
+  if (existsSync10(join13(libSubdir, libName)))
     return libSubdir;
   return ortVersionDir;
 }
@@ -15824,13 +17563,13 @@ function findSystemOnnxRuntime(libName) {
   } else if (process.platform === "win32") {
     const programFiles = process.env.ProgramFiles ?? "C:\\Program Files";
     const programFilesX86 = process.env["ProgramFiles(x86)"] ?? "C:\\Program Files (x86)";
-    searchPaths.push(join12(programFiles, "onnxruntime", "lib"), join12(programFiles, "Microsoft ONNX Runtime", "lib"), join12(programFiles, "Microsoft Machine Learning", "lib"), join12(programFilesX86, "onnxruntime", "lib"), ...(() => {
+    searchPaths.push(join13(programFiles, "onnxruntime", "lib"), join13(programFiles, "Microsoft ONNX Runtime", "lib"), join13(programFiles, "Microsoft Machine Learning", "lib"), join13(programFilesX86, "onnxruntime", "lib"), ...(() => {
       const nugetPaths = [];
       const userProfile = process.env.USERPROFILE ?? "";
       if (!userProfile)
         return nugetPaths;
-      const nugetPackageDir = join12(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
-      if (!existsSync9(nugetPackageDir))
+      const nugetPackageDir = join13(userProfile, ".nuget", "packages", "microsoft.ml.onnxruntime");
+      if (!existsSync10(nugetPackageDir))
         return nugetPaths;
       try {
         for (const entry of readdirSync3(nugetPackageDir, { withFileTypes: true })) {
@@ -15838,7 +17577,7 @@ function findSystemOnnxRuntime(libName) {
             continue;
           if (entry.name === "__globalPackagesFolder" || entry.name.startsWith("."))
             continue;
-          nugetPaths.push(join12(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join12(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
+          nugetPaths.push(join13(nugetPackageDir, entry.name, "runtimes", "win-x64", "native"), join13(nugetPackageDir, entry.name, "runtimes", "win-arm64", "native"));
         }
       } catch (err) {
         warn(`Failed to scan NuGet ONNX Runtime cache ${nugetPackageDir}: ${err instanceof Error ? err.message : String(err)}`);
@@ -15860,11 +17599,11 @@ function findSystemOnnxRuntime(libName) {
   });
   const unknownVersionPaths = [];
   for (const dir of uniquePaths) {
-    const libPath = join12(dir, libName);
+    const libPath = join13(dir, libName);
     if (process.platform === "win32") {
       if (!directoryContainsLibrary(dir, libName))
         continue;
-    } else if (!existsSync9(libPath)) {
+    } else if (!existsSync10(libPath)) {
       continue;
     }
     const version = detectOnnxVersion(dir, libName);
@@ -15930,7 +17669,7 @@ function validateExtractedTree(stagingRoot) {
   const walk = (dir) => {
     const entries = readdirSync3(dir);
     for (const entry of entries) {
-      const fullPath = join12(dir, entry);
+      const fullPath = join13(dir, entry);
       const lst = lstatSync(fullPath);
       if (lst.isSymbolicLink()) {
         const linkTarget = readlinkSync(fullPath);
@@ -15963,34 +17702,32 @@ async function downloadOnnxRuntime(info, targetDir) {
   const url = `https://github.com/${ORT_REPO}/releases/download/v${ORT_VERSION}/${info.assetName}.${info.archiveType === "tgz" ? "tgz" : "zip"}`;
   log(`Downloading ONNX Runtime v${ORT_VERSION} for ${process.platform}/${process.arch}...`);
   const tmpDir = `${targetDir}.tmp.${process.pid}.${Date.now().toString(36)}`;
+  const extractionRoot = join13(tmpDir, "extract");
+  const stagedInstallDir = join13(tmpDir, "install");
   try {
-    mkdirSync5(tmpDir, { recursive: true });
-    const archivePath = join12(tmpDir, `onnxruntime.${info.archiveType}`);
+    mkdirSync5(extractionRoot, { recursive: true });
+    const archivePath = join13(tmpDir, `onnxruntime.${info.archiveType}`);
     await downloadFileWithCap(url, archivePath);
     const archiveSha256 = sha256File(archivePath);
     log(`ONNX Runtime archive sha256=${archiveSha256}`);
     if (info.archiveType === "tgz") {
-      execFileSync("tar", ["xzf", archivePath, "-C", tmpDir], {
-        stdio: "pipe",
-        timeout: 120000
-      });
+      execTarExtractionSync(["xzf", archivePath, "-C", extractionRoot], 120000);
     } else {
-      await extractZipArchive(archivePath, tmpDir);
+      await extractZipArchive(archivePath, extractionRoot);
     }
     try {
       unlinkSync4(archivePath);
     } catch {}
-    validateExtractedTree(tmpDir);
-    const extractedDir = join12(tmpDir, info.assetName, "lib");
-    if (!existsSync9(extractedDir)) {
+    validateExtractedTree(extractionRoot);
+    const extractedDir = join13(extractionRoot, info.assetName, "lib");
+    if (!existsSync10(extractedDir)) {
       throw new Error(`Expected directory not found: ${extractedDir}`);
     }
-    mkdirSync5(targetDir, { recursive: true });
     const libFiles = readdirSync3(extractedDir).filter((f) => f.startsWith("libonnxruntime") || f.startsWith("onnxruntime"));
     const realFiles = [];
     const symlinks = [];
     for (const libFile of libFiles) {
-      const src = join12(extractedDir, libFile);
+      const src = join13(extractedDir, libFile);
       try {
         const stat = lstatSync(src);
         log(`ORT extract: ${libFile} — isSymlink=${stat.isSymbolicLink()}, isFile=${stat.isFile()}, size=${stat.size}`);
@@ -16004,15 +17741,11 @@ async function downloadOnnxRuntime(info, targetDir) {
         realFiles.push(libFile);
       }
     }
-    copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks);
-    const libPath = join12(targetDir, info.libName);
-    let libHash = null;
-    try {
-      libHash = sha256File(libPath);
-    } catch (err) {
-      warn(`Could not hash newly-installed ONNX library at ${libPath}: ${err}`);
-    }
-    writeOnnxInstalledMeta(targetDir, ORT_VERSION, libHash, archiveSha256);
+    copyOnnxLibraries(info, extractedDir, stagedInstallDir, realFiles, symlinks);
+    const libPath = join13(stagedInstallDir, info.libName);
+    const libHash = sha256File(libPath);
+    writeOnnxInstalledMeta(stagedInstallDir, ORT_VERSION, libHash, archiveSha256);
+    publishOnnxRuntime(stagedInstallDir, targetDir);
     rmSync3(tmpDir, { recursive: true, force: true });
     log(`ONNX Runtime v${ORT_VERSION} installed to ${targetDir}`);
     return targetDir;
@@ -16021,17 +17754,39 @@ async function downloadOnnxRuntime(info, targetDir) {
     try {
       rmSync3(tmpDir, { recursive: true, force: true });
     } catch {}
-    try {
-      rmSync3(targetDir, { recursive: true, force: true });
-    } catch {}
     return null;
   }
 }
+function publishOnnxRuntime(stagedInstallDir, targetDir) {
+  const backupDir = `${targetDir}.backup.${process.pid}.${Date.now().toString(36)}`;
+  const hadTarget = existsSync10(targetDir);
+  if (hadTarget)
+    renameSync5(targetDir, backupDir);
+  try {
+    renameSync5(stagedInstallDir, targetDir);
+  } catch (installError) {
+    if (hadTarget) {
+      try {
+        renameSync5(backupDir, targetDir);
+      } catch (restoreError) {
+        throw new Error(`ONNX Runtime replacement failed and the previous runtime could not be restored from ${backupDir}: ${restoreError}`, { cause: installError });
+      }
+    }
+    throw installError;
+  }
+  if (hadTarget) {
+    try {
+      rmSync3(backupDir, { recursive: true, force: true });
+    } catch (err) {
+      warn(`Could not remove replaced ONNX Runtime backup at ${backupDir}: ${err}`);
+    }
+  }
+}
 function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, copyFile = copyFileSync3) {
   const requiredLibs = new Set([info.libName]);
   for (const libFile of realFiles) {
-    const src = join12(extractedDir, libFile);
-    const dst = join12(targetDir, libFile);
+    const src = join13(extractedDir, libFile);
+    const dst = join13(targetDir, libFile);
     try {
       copyFile(src, dst);
       if (process.platform !== "win32") {
@@ -16047,11 +17802,11 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
   }
   const targetRoot = realpathSync2(targetDir);
   for (const link of symlinks) {
-    const dst = join12(targetDir, link.name);
+    const dst = join13(targetDir, link.name);
     try {
       unlinkSync4(dst);
     } catch {}
-    const dstForContainment = join12(targetRoot, link.name);
+    const dstForContainment = join13(targetRoot, link.name);
     const resolvedTarget = resolve7(dirname5(dstForContainment), link.target);
     if (!isPathInsideRoot(targetRoot, resolvedTarget)) {
       const message = `ONNX Runtime symlink ${link.name} points outside install dir: ${link.target}`;
@@ -16072,21 +17827,18 @@ function copyOnnxLibraries(info, extractedDir, targetDir, realFiles, symlinks, c
       log(`ORT extract: failed to symlink optional ${link.name}: ${symlinkErr}`);
     }
   }
-  const requiredPath = join12(targetDir, info.libName);
-  if (!existsSync9(requiredPath)) {
+  const requiredPath = join13(targetDir, info.libName);
+  if (!existsSync10(requiredPath)) {
     rmSync3(targetDir, { recursive: true, force: true });
     throw new Error(`Required ONNX Runtime library missing after install: ${requiredPath}`);
   }
 }
 async function extractZipArchive(archivePath, destinationDir) {
   if (process.platform === "win32") {
-    execFileSync("tar.exe", ["-xf", archivePath, "-C", destinationDir], {
-      stdio: "pipe",
-      timeout: 120000
-    });
+    execTarExtractionSync(["-xf", archivePath, "-C", destinationDir], 120000);
     return;
   }
-  execFileSync("unzip", ["-q", archivePath, "-d", destinationDir], {
+  execFileSync2("unzip", ["-q", archivePath, "-d", destinationDir], {
     stdio: "pipe",
     timeout: 120000
   });
@@ -16099,13 +17851,13 @@ function writeOnnxInstalledMeta(installDir, version, sha256, archiveSha256) {
       ...sha256 ? { sha256 } : {},
       archiveSha256
     };
-    writeFileSync3(join12(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync3(join13(installDir, ONNX_INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log(`[onnx] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readOnnxInstalledMeta(installDir) {
-  const path = join12(installDir, ONNX_INSTALLED_META_FILE);
+  const path = join13(installDir, ONNX_INSTALLED_META_FILE);
   try {
     if (!statSync6(path).isFile())
       return null;
@@ -16217,7 +17969,7 @@ function isWindowsProcessAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return false;
   try {
-    const output = execFileSync("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+    const output = execFileSync2("tasklist.exe", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
       encoding: "utf8",
       timeout: 2000,
       windowsHide: true
@@ -16438,10 +18190,8 @@ function prepareCanonicalEditArguments(toolName, rawArguments) {
   if (unknownRootKeys.length > 0) {
     throw new InvalidRequestError(formatUnknownKeys(unknownRootKeys));
   }
+  validateSymbolModePair(record);
   const modes = editModesPresent(record);
-  if (hasOrphanedSymbolContent(record)) {
-    throw new InvalidRequestError("edit: 'content' requires a non-empty string 'symbol' when symbol mode is selected");
-  }
   if (modes.length > 1) {
     throw new InvalidRequestError(`edit: conflicting modes: ${modes.join(", ")}. ${OMIT_OPTIONAL_FIELDS_STEERING}`);
   }
@@ -16461,7 +18211,7 @@ function prepareCanonicalEditArguments(toolName, rawArguments) {
       throw new InvalidRequestError("edit: 'symbol' must be a string when symbol mode is selected");
     }
     if (!hasOwn(record, "content") || typeof record.content !== "string") {
-      throw new InvalidRequestError("edit: symbol mode requires both 'symbol' and 'content' string properties");
+      throw new InvalidRequestError("edit: incomplete symbol mode: property 'content' must be a string. " + "Retry with `symbol` + `content`, or use `edits[]`.");
     }
   } else {
     const item = {};
@@ -16514,6 +18264,29 @@ function validateEditPath(record) {
 function formatUnknownKeys(keys) {
   return `Unrecognized keys: ${keys.map((key) => `"${key}"`).join(", ")}`;
 }
+function validateSymbolModePair(record) {
+  const completeShapes = "Retry with `symbol` + `content`, or use `edits[]`.";
+  const hasSymbol = isNonEmptyString(record.symbol);
+  const hasContent = isNonEmptyString(record.content);
+  if (hasSymbol) {
+    if (!hasOwn(record, "content")) {
+      throw new InvalidRequestError(`edit: incomplete symbol mode: missing property 'content'. ${completeShapes}`);
+    }
+    if (record.content === null) {
+      throw new InvalidRequestError(`edit: incomplete symbol mode: property 'content' is null. ${completeShapes}`);
+    }
+    return;
+  }
+  if (!hasContent)
+    return;
+  if (!hasOwn(record, "symbol")) {
+    throw new InvalidRequestError(`edit: incomplete symbol mode: missing property 'symbol'. ${completeShapes}`);
+  }
+  if (record.symbol === null) {
+    throw new InvalidRequestError(`edit: incomplete symbol mode: property 'symbol' is null. ${completeShapes}`);
+  }
+  throw new InvalidRequestError(`edit: incomplete symbol mode: property 'symbol' must be a non-empty string. ${completeShapes}`);
+}
 function editModesPresent(record) {
   const hasAppendContent = isNonEmptyString(record.appendContent);
   if (!hasAppendContent)
@@ -16599,9 +18372,6 @@ function normalizeEditArraySentinels(record) {
     return true;
   }
 }
-function hasOrphanedSymbolContent(record) {
-  return isNonEmptyString(record.content) && !isNonEmptyString(record.symbol);
-}
 function parseEditArray(value) {
   if (typeof value === "string") {
     let parsed;
@@ -16784,8 +18554,50 @@ function copyOwnProperties(source) {
     copy[key] = source[key];
   return copy;
 }
+// ../aft-bridge/dist/semantic-status.js
+var MISSING_ONNX_RUNTIME_MARKER = "ONNX Runtime not found.";
+var MISSING_ONNX_RUNTIME_LABEL = "unavailable — ONNX Runtime missing (npx @cortexkit/aft doctor --fix)";
+var REBUILDING_LABEL = "Rebuilding (model changed)";
+var SEMANTIC_PROGRESS_STATUSES = new Set(["building", "loading"]);
+var SEMANTIC_READY_STATUSES = new Set(["ready", "empty"]);
+var SEMANTIC_INACTIVE_STATUSES = new Set(["disabled", "busy"]);
+var SEMANTIC_FAILURE_LABELS = {
+  backend_unavailable: "backend unavailable",
+  degraded: "degraded",
+  error: "error",
+  failed: "failed",
+  unavailable: "unavailable"
+};
+function semanticIndexStatusKind(status) {
+  if (SEMANTIC_READY_STATUSES.has(status))
+    return "ready";
+  if (SEMANTIC_PROGRESS_STATUSES.has(status))
+    return "progress";
+  if (status in SEMANTIC_FAILURE_LABELS)
+    return "failure";
+  if (SEMANTIC_INACTIVE_STATUSES.has(status))
+    return "inactive";
+  return "unrecognized";
+}
+function mentionsMissingOnnxRuntime(...values) {
+  return values.some((value) => typeof value === "string" && value.includes(MISSING_ONNX_RUNTIME_MARKER));
+}
+function semanticFailureLabel(status, stage, error) {
+  if (mentionsMissingOnnxRuntime(error, stage))
+    return MISSING_ONNX_RUNTIME_LABEL;
+  return SEMANTIC_FAILURE_LABELS[status] ?? null;
+}
+function formatSemanticIndexStatus(status, stage, error) {
+  const failure = semanticFailureLabel(status, stage, error);
+  if (failure)
+    return failure;
+  if (semanticIndexStatusKind(status) === "progress" && stage === "fingerprint_change") {
+    return REBUILDING_LABEL;
+  }
+  return status;
+}
 // src/config.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7, renameSync as renameSync5, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7, renameSync as renameSync6, unlinkSync as unlinkSync5, writeFileSync as writeFileSync4 } from "node:fs";
 import { homedir as homedir10 } from "node:os";
 import { isAbsolute as isAbsolute6, parse as parsePath, resolve as resolvePath } from "node:path";
 var import_comment_json = __toESM(require_src2(), 1);
@@ -21492,6 +23304,9 @@ function write(level, message, data, sessionId) {
 function log2(message, data) {
   write("INFO", message, data);
 }
+function debug2(message, data) {
+  write("DEBUG", message, data);
+}
 function warn2(message, data) {
   write("WARN", message, data);
 }
@@ -21690,6 +23505,7 @@ var InspectConfigSchema = object({
   enabled: boolean2().optional(),
   diagnostics_timeout_ms: number2().int().positive().optional().transform((value) => value === undefined ? undefined : clampInspectDiagnosticsTimeoutMs(value)),
   tier2_idle_minutes: number2().min(0).optional(),
+  tier2_pass_timeout_ms: number2().int().positive().optional(),
   categories: record(string2(), boolean2()).optional(),
   tier2_soft_deadline_ms: number2().int().positive().optional(),
   max_drill_down_items: number2().int().positive().max(100).optional(),
@@ -22012,7 +23828,7 @@ function migrateExperimentalBashBlock(rawConfig, configPath, logger) {
   return movedKeys;
 }
 function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 }) {
-  if (!existsSync10(configPath)) {
+  if (!existsSync11(configPath)) {
     return { migrated: false, oldKeys: [] };
   }
   let tmpPath = null;
@@ -22036,7 +23852,7 @@ function migrateAftConfigFile2(configPath, logger = { log: log2, warn: warn2 })
 ${serialized}` : serialized;
     tmpPath = `${configPath}.tmp.${process.pid}`;
     writeFileSync4(tmpPath, nextContent, "utf-8");
-    renameSync5(tmpPath, configPath);
+    renameSync6(tmpPath, configPath);
     logger.log(`Migrated config at ${configPath}: removed ${oldKeys.join(", ")}`);
     return { migrated: true, oldKeys };
   } catch (err) {
@@ -22097,7 +23913,7 @@ function recordConfigParseFailure(configPath, errorMessage) {
 }
 function loadConfigFromPath(configPath) {
   try {
-    if (!existsSync10(configPath)) {
+    if (!existsSync11(configPath)) {
       return null;
     }
     const content = readFileSync7(configPath, "utf-8");
@@ -22437,7 +24253,7 @@ function loadAftConfig(projectDirectory) {
 }
 
 // src/tools/_shared.ts
-import { existsSync as existsSync11 } from "node:fs";
+import { existsSync as existsSync12 } from "node:fs";
 import * as os2 from "node:os";
 import * as path2 from "node:path";
 
@@ -34850,6 +36666,7 @@ var DEBOUNCE_STEP_MS = 200;
 var DEBOUNCE_CAP_MS = 1000;
 var MAX_WAKE_SEND_ATTEMPTS = 5;
 var DEFAULT_WAKE_CONFIRMATION_WINDOW_MS = 5000;
+var BUSY_WAKE_DEFER_CEILING_MS = 60000;
 var UNKNOWN_COMPLETION_TTL_MS = 5000;
 var UNKNOWN_COMPLETION_CAP = 32;
 var DEFAULT_SESSION_ID2 = "__default__";
@@ -34881,10 +36698,12 @@ function logDroppedForeignSessionFrame(drainContext, droppedSessionId, liveSessi
 var DEFAULT_BG_HOP_TIMEOUT_MS = 15000;
 var bgHopTimeoutMs = DEFAULT_BG_HOP_TIMEOUT_MS;
 var wakeConfirmationWindowMs = DEFAULT_WAKE_CONFIRMATION_WINDOW_MS;
+var busyWakeDeferCeilingMs = BUSY_WAKE_DEFER_CEILING_MS;
 var lastWakeMessageTimestamp = 0;
 var wakeMessageCounter = 0;
 var subcNudgesInFlight = new Map;
 var subcNudgeLogState = new Map;
+var deferredBusyWakes = new Map;
 function consumeBgCompletion(sessionID, taskId) {
   const state = stateFor(sessionID);
   state.pendingCompletions = state.pendingCompletions.filter((c) => c.task_id !== taskId);
@@ -34899,6 +36718,9 @@ function consumeBgCompletion(sessionID, taskId) {
     }
   }
   clearWakeTimerIfNoPending(state);
+  if (state.pendingCompletions.length === 0 && state.pendingLongRunning.length === 0 && state.pendingPatternMatches.length === 0) {
+    clearDeferredBusyWake(sessionID || DEFAULT_SESSION_ID2);
+  }
 }
 async function markBgCompletionDelivered(drainContext, taskId) {
   const state = stateFor(drainContext.sessionID);
@@ -35004,7 +36826,7 @@ async function handlePushedPatternMatch(drainContext, frame) {
   }
   const state = stateFor(drainContext.sessionID);
   queuePendingPatternMatch(state, { ...frame, ackCompletionOnDelivery: true });
-  await triggerWakeIfPending(drainContext, true);
+  await triggerWakeIfPending(drainContext, true, true, false, true);
 }
 function ingestBgCompletions(sessionID, completions) {
   if (!Array.isArray(completions) || completions.length === 0)
@@ -35042,11 +36864,11 @@ function ingestBgCompletions(sessionID, completions) {
 }
 async function handlePushedBgCompletion(drainContext, completion) {
   ingestBgCompletions(drainContext.sessionID, [completion]);
-  await triggerWakeIfPending(drainContext, true, false);
+  await triggerWakeIfPending(drainContext, true, false, false, true);
 }
 async function handlePushedBgLongRunning(drainContext, reminder) {
   stateFor(drainContext.sessionID).pendingLongRunning.push(reminder);
-  await triggerWakeIfPending(drainContext, true);
+  await triggerWakeIfPending(drainContext, true, true, false, true);
 }
 async function appendInTurnBgCompletions(drainContext, output) {
   if (!output)
@@ -35091,6 +36913,7 @@ async function appendInTurnBgCompletions(drainContext, output) {
   if (inTurnAcked)
     confirmAcked(state, inTurnAckIds);
   clearWakeTimerIfNoPending(state);
+  clearDeferredBusyWake(drainContext.sessionID);
 }
 async function handleIdleBgCompletions(drainContext) {
   stateFor(drainContext.sessionID).wakeDeferredTaskIds.clear();
@@ -35118,7 +36941,7 @@ async function handleSubcBgEventsNudgeOnce(drainContext) {
   const state = stateFor(drainContext.sessionID);
   state.wakeDeferredTaskIds.clear();
   rearmHardStoppedWake(state, drainContext);
-  await triggerWakeIfPending(drainContext, false, true, true);
+  await triggerWakeIfPending(drainContext, false, true, true, true);
 }
 function logSubcNudgeLifecycle(drainContext, kind, message) {
   logDeliveryHop(drainContext, kind, message, {
@@ -35333,6 +37156,42 @@ function registerWakeAdmission(state, admission) {
   }, wakeConfirmationWindowMs);
   tracked.confirmationTimer.unref?.();
 }
+function clearDeferredBusyWake(sessionID) {
+  const deferred = deferredBusyWakes.get(sessionID);
+  if (!deferred)
+    return;
+  deferredBusyWakes.delete(sessionID);
+  clearTimeout(deferred.timer);
+  return deferred;
+}
+function deferBusyWake(drainContext) {
+  const existing = deferredBusyWakes.get(drainContext.sessionID);
+  if (existing) {
+    existing.context = drainContext;
+    return;
+  }
+  const deferredAt = Date.now();
+  const deferred = {
+    context: drainContext,
+    deferredAt,
+    timer: setTimeout(() => {
+      if (deferredBusyWakes.get(drainContext.sessionID) !== deferred)
+        return;
+      deferredBusyWakes.delete(drainContext.sessionID);
+      const waitMs = Math.max(0, Date.now() - deferredAt);
+      sessionLog(drainContext.sessionID, `${LOG_PREFIX} busy wake defer ceiling reached`, {
+        event: "bash_completion_wake_deferred_ceiling",
+        wait_ms: waitMs,
+        ceiling_ms: busyWakeDeferCeilingMs
+      });
+      triggerWakeIfPending(deferred.context, true).catch(() => {
+        return;
+      });
+    }, busyWakeDeferCeilingMs)
+  };
+  deferred.timer.unref?.();
+  deferredBusyWakes.set(drainContext.sessionID, deferred);
+}
 function observeOpenCodeBgNotificationEvent(event) {
   try {
     if (!event || typeof event !== "object")
@@ -35381,12 +37240,17 @@ function observeOpenCodeBgNotificationEvent(event) {
       return;
     }
     if (nextStatus === "idle") {
+      const deferred = clearDeferredBusyWake(sessionID);
+      if (deferred)
+        triggerWakeIfPending(deferred.context, true).catch(() => {
+          return;
+        });
       for (const admission of state.wakeAdmissions.values())
         queueWakeRefire(state, admission);
     }
   } catch {}
 }
-async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false) {
+async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredCompletions = true, forceDrain = false, deferWhileBusy = false) {
   const state = stateFor(drainContext.sessionID);
   if (!skipDrain && (forceDrain || state.outstandingTaskIds.size > 0 || !state.forcedDrainCompleted)) {
     await drainCompletions(drainContext);
@@ -35394,6 +37258,10 @@ async function triggerWakeIfPending(drainContext, skipDrain, includeDeferredComp
   routeExplicitControlCompletions(state);
   if (!hasWakeEligiblePending(state, includeDeferredCompletions))
     return;
+  if (deferWhileBusy && state.hostStatus === "busy") {
+    deferBusyWake(drainContext);
+    return;
+  }
   scheduleWake(state, async (reminder, deliveredCompletions, deliveredPatternMatches) => {
     const liveSession = getActiveSessionId() ?? drainContext.sessionID;
     if (liveSession && drainContext.sessionID && drainContext.sessionID !== liveSession) {
@@ -36235,7 +38103,7 @@ function bridgeFor(ctx, runtime) {
   if (ctx.isProjectEnabled?.(projectRoot) === false) {
     throw new Error(`AFT disabled by config for ${projectRoot}`);
   }
-  if (!existsSync11(projectRoot)) {
+  if (!existsSync12(projectRoot)) {
     throw new Error(`project directory no longer exists: ${projectRoot} (stale restored session?)`);
   }
   return ctx.pool.getBridge(projectRoot);
@@ -36392,9 +38260,9 @@ async function signalBashWaitDetachForProject(pool, projectRoot, sessionID) {
 }
 
 // src/notifications.ts
-import { existsSync as existsSync12, readFileSync as readFileSync8 } from "node:fs";
+import { existsSync as existsSync13, readFileSync as readFileSync8 } from "node:fs";
 import { homedir as homedir12, platform } from "node:os";
-import { join as join13 } from "node:path";
+import { join as join14 } from "node:path";
 function isTuiMode() {
   return process.env.OPENCODE_CLIENT === "cli";
 }
@@ -36416,21 +38284,21 @@ function getDesktopStatePath() {
   const os = platform();
   const home = homedir12();
   if (os === "darwin") {
-    return join13(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
+    return join14(home, "Library", "Application Support", "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "linux") {
-    const xdgConfig = process.env.XDG_CONFIG_HOME || join13(home, ".config");
-    return join13(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
+    const xdgConfig = process.env.XDG_CONFIG_HOME || join14(home, ".config");
+    return join14(xdgConfig, "ai.opencode.desktop", "opencode.global.dat");
   }
   if (os === "win32") {
-    const appData = process.env.APPDATA || join13(home, "AppData", "Roaming");
-    return join13(appData, "ai.opencode.desktop", "opencode.global.dat");
+    const appData = process.env.APPDATA || join14(home, "AppData", "Roaming");
+    return join14(appData, "ai.opencode.desktop", "opencode.global.dat");
   }
   return null;
 }
 function readDesktopState() {
   const statePath = getDesktopStatePath();
-  if (!statePath || !existsSync12(statePath)) {
+  if (!statePath || !existsSync13(statePath)) {
     return { serverUrl: null };
   }
   try {
@@ -36930,11 +38798,11 @@ async function flushConfigureWarningsOnIdle(sessionId) {
 // src/hooks/auto-update-checker/index.ts
 import {
   closeSync as closeSync5,
-  existsSync as existsSync15,
+  existsSync as existsSync16,
   mkdirSync as mkdirSync6,
   openSync as openSync5,
   readFileSync as readFileSync11,
-  renameSync as renameSync6,
+  renameSync as renameSync7,
   rmSync as rmSync5,
   statSync as statSync8,
   writeFileSync as writeFileSync7
@@ -36943,30 +38811,30 @@ import { dirname as dirname8 } from "node:path";
 
 // src/hooks/auto-update-checker/cache.ts
 import { spawn as spawn4 } from "node:child_process";
-import { cpSync, existsSync as existsSync14, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
+import { cpSync, existsSync as existsSync15, mkdtempSync, readFileSync as readFileSync10, rmSync as rmSync4, writeFileSync as writeFileSync6 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { basename as basename3, dirname as dirname7, join as join16 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join17 } from "node:path";
 var import_comment_json3 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/checker.ts
-import { existsSync as existsSync13, readFileSync as readFileSync9, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
-import { dirname as dirname6, isAbsolute as isAbsolute8, join as join15, resolve as resolve9 } from "node:path";
+import { existsSync as existsSync14, readFileSync as readFileSync9, statSync as statSync7, writeFileSync as writeFileSync5 } from "node:fs";
+import { dirname as dirname6, isAbsolute as isAbsolute8, join as join16, resolve as resolve9 } from "node:path";
 import { fileURLToPath } from "node:url";
 var import_comment_json2 = __toESM(require_src2(), 1);
 
 // src/hooks/auto-update-checker/constants.ts
-import { join as join14 } from "node:path";
+import { join as join15 } from "node:path";
 var PACKAGE_NAME = "@cortexkit/aft-opencode";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org";
 var NPM_FETCH_TIMEOUT = 1e4;
 function cacheDir() {
-  return join14(getOpenCodeCacheRoot(), "packages");
+  return join15(getOpenCodeCacheRoot(), "packages");
 }
 function userOpenCodeConfig() {
-  return join14(getOpenCodeConfigRoot(), "opencode.json");
+  return join15(getOpenCodeConfigRoot(), "opencode.json");
 }
 function userOpenCodeConfigJsonc() {
-  return join14(getOpenCodeConfigRoot(), "opencode.jsonc");
+  return join15(getOpenCodeConfigRoot(), "opencode.jsonc");
 }
 
 // src/hooks/auto-update-checker/types.ts
@@ -37025,8 +38893,8 @@ function extractChannel(version) {
 }
 function getConfigPaths(directory) {
   return [
-    join15(directory, ".opencode", "opencode.json"),
-    join15(directory, ".opencode", "opencode.jsonc"),
+    join16(directory, ".opencode", "opencode.json"),
+    join16(directory, ".opencode", "opencode.jsonc"),
     userOpenCodeConfig(),
     userOpenCodeConfigJsonc()
   ];
@@ -37046,7 +38914,7 @@ function resolvePathPluginSpec(spec, configPath) {
 function getLocalDevPath(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync13(configPath))
+      if (!existsSync14(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync9(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -37072,8 +38940,8 @@ function findPackageJsonUp(startPath) {
     const stat = statSync7(startPath);
     let dir = stat.isDirectory() ? startPath : dirname6(startPath);
     for (let i = 0;i < 10; i++) {
-      const pkgPath = join15(dir, "package.json");
-      if (existsSync13(pkgPath)) {
+      const pkgPath = join16(dir, "package.json");
+      if (existsSync14(pkgPath)) {
         try {
           const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync9(pkgPath, "utf-8")));
           if (pkg.success && pkg.data.name === PACKAGE_NAME)
@@ -37113,7 +38981,7 @@ function getCurrentRuntimePackageJsonPath(currentModuleUrl = import.meta.url) {
 function findPluginEntry(directory) {
   for (const configPath of getConfigPaths(directory)) {
     try {
-      if (!existsSync13(configPath))
+      if (!existsSync14(configPath))
         continue;
       const rawConfig = parseJsonConfig(readFileSync9(configPath, "utf-8"));
       const plugins = getPluginEntries(rawConfig);
@@ -37133,7 +39001,7 @@ function findPluginEntry(directory) {
 }
 var cachedPackageVersion = null;
 function getSpecCachePackageJsonPath(spec) {
-  return join15(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
+  return join16(cacheDir(), spec, "node_modules", PACKAGE_NAME, "package.json");
 }
 function getCachedVersion(spec) {
   if (!spec && cachedPackageVersion)
@@ -37142,11 +39010,11 @@ function getCachedVersion(spec) {
     getCurrentRuntimePackageJsonPath(),
     spec ? getSpecCachePackageJsonPath(spec) : null,
     getSpecCachePackageJsonPath(`${PACKAGE_NAME}@latest`),
-    join15(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
+    join16(getOpenCodeCacheRoot(), "node_modules", PACKAGE_NAME, "package.json")
   ].filter(isString);
   for (const packageJsonPath of candidates) {
     try {
-      if (!existsSync13(packageJsonPath))
+      if (!existsSync14(packageJsonPath))
         continue;
       const pkg = PackageJsonSchema.safeParse(JSON.parse(readFileSync9(packageJsonPath, "utf-8")));
       if (pkg.success && pkg.data.version) {
@@ -37191,17 +39059,17 @@ async function getLatestVersion(channel = "latest", options = {}) {
 var pendingSnapshots = new Map;
 var quarantinedInstallDirs = new Set;
 function createAutoUpdateSnapshot(installDir, packageJsonPath, packageName) {
-  const packageDir = join16(installDir, "node_modules", packageName);
-  const lockfilePath = join16(installDir, "package-lock.json");
-  const tempDir = mkdtempSync(join16(tmpdir2(), "aft-auto-update-"));
-  const stagedPackageDir = existsSync14(packageDir) ? join16(tempDir, "package") : null;
+  const packageDir = join17(installDir, "node_modules", packageName);
+  const lockfilePath = join17(installDir, "package-lock.json");
+  const tempDir = mkdtempSync(join17(tmpdir2(), "aft-auto-update-"));
+  const stagedPackageDir = existsSync15(packageDir) ? join17(tempDir, "package") : null;
   if (stagedPackageDir)
     cpSync(packageDir, stagedPackageDir, { recursive: true });
   return {
     packageJsonPath,
-    packageJson: existsSync14(packageJsonPath) ? readFileSync10(packageJsonPath, "utf-8") : null,
+    packageJson: existsSync15(packageJsonPath) ? readFileSync10(packageJsonPath, "utf-8") : null,
     lockfilePath,
-    lockfile: existsSync14(lockfilePath) ? readFileSync10(lockfilePath, "utf-8") : null,
+    lockfile: existsSync15(lockfilePath) ? readFileSync10(lockfilePath, "utf-8") : null,
     packageDir,
     stagedPackageDir,
     tempDir
@@ -37235,8 +39103,8 @@ function stripPackageNameFromPath(pathValue, packageName) {
   return current;
 }
 function removeFromPackageLock(installDir, packageName) {
-  const lockPath = join16(installDir, "package-lock.json");
-  if (!existsSync14(lockPath))
+  const lockPath = join17(installDir, "package-lock.json");
+  if (!existsSync15(lockPath))
     return false;
   try {
     const lock = import_comment_json3.parse(readFileSync10(lockPath, "utf-8"));
@@ -37262,7 +39130,7 @@ function removeFromPackageLock(installDir, packageName) {
   }
 }
 function ensureDependencyVersion(packageJsonPath, packageName, version) {
-  if (!existsSync14(packageJsonPath))
+  if (!existsSync15(packageJsonPath))
     return false;
   try {
     const raw = import_comment_json3.parse(readFileSync10(packageJsonPath, "utf-8"));
@@ -37291,8 +39159,8 @@ function restorePendingSnapshot(installDir) {
   restoreAutoUpdateSnapshot(snapshot);
 }
 function removeInstalledPackage(installDir, packageName) {
-  const packageDir = join16(installDir, "node_modules", packageName);
-  if (!existsSync14(packageDir))
+  const packageDir = join17(installDir, "node_modules", packageName);
+  if (!existsSync15(packageDir))
     return false;
   rmSync4(packageDir, { recursive: true, force: true });
   log2(`[auto-update-checker] Package removed: ${packageDir}`);
@@ -37304,15 +39172,15 @@ function resolveInstallContext(runtimePackageJsonPath = getCurrentRuntimePackage
     const nodeModulesDir = stripPackageNameFromPath(packageDir, PACKAGE_NAME);
     if (nodeModulesDir && basename3(nodeModulesDir) === "node_modules") {
       const installDir = dirname7(nodeModulesDir);
-      const packageJsonPath = join16(installDir, "package.json");
-      if (existsSync14(packageJsonPath))
+      const packageJsonPath = join17(installDir, "package.json");
+      if (existsSync15(packageJsonPath))
         return { installDir, packageJsonPath };
     }
     return null;
   }
   const cacheRoot = dirname7(cacheDir());
-  const legacyPackageJsonPath = join16(cacheRoot, "package.json");
-  if (existsSync14(legacyPackageJsonPath)) {
+  const legacyPackageJsonPath = join17(cacheRoot, "package.json");
+  if (existsSync15(legacyPackageJsonPath)) {
     return { installDir: cacheRoot, packageJsonPath: legacyPackageJsonPath };
   }
   return null;
@@ -37535,7 +39403,7 @@ function claimCheckSlot(storageDir, intervalMs) {
       const replacementPath = `${lockPath}.tmp.${process.pid}`;
       writeFileSync7(replacementPath, JSON.stringify(owner), { encoding: "utf-8", mode: 384 });
       try {
-        renameSync6(replacementPath, lockPath);
+        renameSync7(replacementPath, lockPath);
       } catch (replaceError) {
         rmSync5(replacementPath, { force: true });
         throw replaceError;
@@ -37603,7 +39471,7 @@ function checkLockIsOwnedBy(lockPath, owner) {
   }
 }
 function hasRecentCheckTimestamp(file, intervalMs) {
-  if (!existsSync15(file))
+  if (!existsSync16(file))
     return false;
   try {
     const raw = JSON.parse(readFileSync11(file, "utf-8"));
@@ -37616,7 +39484,7 @@ function hasRecentCheckTimestamp(file, intervalMs) {
 function writeCheckTimestamp(file) {
   const tmp = `${file}.tmp.${process.pid}`;
   writeFileSync7(tmp, JSON.stringify({ lastCheckedMs: Date.now() }), "utf-8");
-  renameSync6(tmp, file);
+  renameSync7(tmp, file);
 }
 async function runStartupCheck(ctx, options) {
   if (options.signal.aborted)
@@ -37713,15 +39581,15 @@ import { spawn as spawn5 } from "node:child_process";
 import { createHash as createHash6 } from "node:crypto";
 import {
   createReadStream,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync8,
   readFileSync as readFileSync14,
-  renameSync as renameSync8,
+  renameSync as renameSync9,
   rmSync as rmSync7,
   statSync as statSync10,
   writeFileSync as writeFileSync9
 } from "node:fs";
-import { join as join19 } from "node:path";
+import { join as join20 } from "node:path";
 
 // src/lsp-cache.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
@@ -37730,13 +39598,13 @@ import {
   mkdirSync as mkdirSync7,
   openSync as openSync6,
   readFileSync as readFileSync12,
-  renameSync as renameSync7,
+  renameSync as renameSync8,
   rmSync as rmSync6,
   statSync as statSync9,
   unlinkSync as unlinkSync6,
   writeFileSync as writeFileSync8
 } from "node:fs";
-import { join as join17 } from "node:path";
+import { join as join18 } from "node:path";
 function aftCacheBase() {
   return getAftCacheRoot();
 }
@@ -37744,18 +39612,18 @@ function lspCacheRoot() {
   return getAftLspPackagesDir();
 }
 function lspPackageDir(npmPackage) {
-  return join17(lspCacheRoot(), encodeURIComponent(npmPackage));
+  return join18(lspCacheRoot(), encodeURIComponent(npmPackage));
 }
 function lspBinaryPath(npmPackage, binary) {
-  return join17(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
+  return join18(lspPackageDir(npmPackage), "node_modules", ".bin", binary);
 }
 function lspBinDir(npmPackage) {
-  return join17(lspPackageDir(npmPackage), "node_modules", ".bin");
+  return join18(lspPackageDir(npmPackage), "node_modules", ".bin");
 }
 function isInstalled(npmPackage, binary) {
   for (const candidate of lspBinaryCandidates(binary)) {
     try {
-      if (statSync9(join17(lspBinDir(npmPackage), candidate)).isFile())
+      if (statSync9(join18(lspBinDir(npmPackage), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -37775,13 +39643,13 @@ function writeInstalledMetaIn(installDir, version, sha256) {
       installedAt: new Date().toISOString(),
       ...sha256 ? { sha256 } : {}
     };
-    writeFileSync8(join17(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
+    writeFileSync8(join18(installDir, INSTALLED_META_FILE), JSON.stringify(meta), "utf8");
   } catch (err) {
     log2(`[lsp-cache] failed to write installed-meta in ${installDir}: ${err}`);
   }
 }
 function readInstalledMetaIn(installDir) {
-  const path = join17(installDir, INSTALLED_META_FILE);
+  const path = join18(installDir, INSTALLED_META_FILE);
   try {
     if (!statSync9(path).isFile())
       return null;
@@ -37805,7 +39673,7 @@ function readInstalledMeta(packageKey) {
   return readInstalledMetaIn(lspPackageDir(packageKey));
 }
 function lockPath(npmPackage) {
-  return join17(lspPackageDir(npmPackage), ".aft-installing");
+  return join18(lspPackageDir(npmPackage), ".aft-installing");
 }
 var STALE_LOCK_MS2 = 30 * 60 * 1000;
 function acquireInstallLock(lockKey) {
@@ -37936,7 +39804,7 @@ var AUTO_INSTALL_STAMP_FILE = "last-lsp-autoinstall.json";
 var AUTO_INSTALL_WINDOW_MS = 60 * 1000;
 var AUTO_INSTALL_LOCK_STALE_MS = 30 * 60 * 1000;
 function autoInstallStampPath() {
-  return join17(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
+  return join18(aftCacheBase(), AUTO_INSTALL_STAMP_FILE);
 }
 function hasRecentAutoInstallStamp(path) {
   try {
@@ -38022,7 +39890,7 @@ function claimLspAutoInstallPass() {
       encoding: "utf8",
       mode: 384
     });
-    renameSync7(tempPath, stampPath);
+    renameSync8(tempPath, stampPath);
     return { release };
   } catch (err) {
     if (claimed) {
@@ -38037,7 +39905,7 @@ function claimLspAutoInstallPass() {
 }
 var VERSION_CHECK_FILE = ".aft-version-check";
 function readVersionCheck(npmPackage) {
-  const file = join17(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join18(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   try {
     const raw = readFileSync12(file, "utf8");
     const parsed = JSON.parse(raw);
@@ -38054,7 +39922,7 @@ function readVersionCheck(npmPackage) {
 }
 function writeVersionCheck(npmPackage, latest) {
   mkdirSync7(lspPackageDir(npmPackage), { recursive: true });
-  const file = join17(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
+  const file = join18(lspPackageDir(npmPackage), VERSION_CHECK_FILE);
   const record = {
     last_checked: new Date().toISOString(),
     latest_eligible: latest
@@ -38216,8 +40084,8 @@ var NPM_LSP_TABLE = [
 ];
 
 // src/lsp-project-relevance.ts
-import { existsSync as existsSync16, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
-import { join as join18 } from "node:path";
+import { existsSync as existsSync17, readdirSync as readdirSync4, readFileSync as readFileSync13 } from "node:fs";
+import { join as join19 } from "node:path";
 var MAX_WALK_DIRS = 200;
 var MAX_WALK_DEPTH = 4;
 var NOISE_DIRS = new Set([
@@ -38234,7 +40102,7 @@ function hasRootMarker(projectRoot, rootMarkers) {
   if (!rootMarkers)
     return false;
   for (const marker of rootMarkers) {
-    if (existsSync16(join18(projectRoot, marker)))
+    if (existsSync17(join19(projectRoot, marker)))
       return true;
   }
   return false;
@@ -38258,7 +40126,7 @@ function hasPackageJsonDep(projectRoot, depNames) {
 }
 function readPackageJson(projectRoot) {
   try {
-    const raw = readFileSync13(join18(projectRoot, "package.json"), "utf8");
+    const raw = readFileSync13(join19(projectRoot, "package.json"), "utf8");
     const parsed = JSON.parse(raw);
     if (typeof parsed !== "object" || parsed === null)
       return null;
@@ -38288,7 +40156,7 @@ function relevantExtensionsInProject(projectRoot, extToServer) {
     for (const entry of entries) {
       if (entry.isDirectory()) {
         if (current.depth < MAX_WALK_DEPTH && !NOISE_DIRS.has(entry.name.toLowerCase())) {
-          queue.push({ dir: join18(current.dir, entry.name), depth: current.depth + 1 });
+          queue.push({ dir: join19(current.dir, entry.name), depth: current.depth + 1 });
         }
         continue;
       }
@@ -38416,8 +40284,8 @@ async function resolveTargetVersion(spec, config, fetchImpl = fetch) {
 }
 function ensureInstallAnchor(cwd) {
   try {
-    const stub = join19(cwd, "package.json");
-    if (!existsSync17(stub)) {
+    const stub = join20(cwd, "package.json");
+    if (!existsSync18(stub)) {
       writeFileSync9(stub, `${JSON.stringify({ name: "aft-lsp-cache", version: "0.0.0", private: true })}
 `);
     }
@@ -38643,12 +40511,12 @@ function sha256OfFileSync(path) {
 }
 function quarantineCachedNpmInstall(spec, reason) {
   const packageDir = lspPackageDir(spec.npm);
-  const dest = join19(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
+  const dest = join20(packageDir, "..", ".quarantine", encodeURIComponent(spec.npm), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.npm}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
-    mkdirSync8(join19(dest, ".."), { recursive: true });
+    mkdirSync8(join20(dest, ".."), { recursive: true });
     rmSync7(dest, { recursive: true, force: true });
-    renameSync8(packageDir, dest);
+    renameSync9(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.npm}: failed to quarantine cache entry: ${err}`);
   }
@@ -38729,26 +40597,26 @@ async function pushLspPathsAfterAutoInstall(pool, projectRoot, cachedBinDirs) {
 }
 
 // src/lsp-github-install.ts
-import { execFileSync as execFileSync2 } from "node:child_process";
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash7, randomBytes as randomBytes3 } from "node:crypto";
 import {
   copyFileSync as copyFileSync4,
   createReadStream as createReadStream2,
   createWriteStream as createWriteStream3,
-  existsSync as existsSync18,
+  existsSync as existsSync19,
   lstatSync as lstatSync2,
   mkdirSync as mkdirSync9,
   readdirSync as readdirSync5,
   readFileSync as readFileSync15,
   readlinkSync as readlinkSync2,
   realpathSync as realpathSync3,
-  renameSync as renameSync9,
+  renameSync as renameSync10,
   rmSync as rmSync8,
   statSync as statSync11,
   unlinkSync as unlinkSync7,
   writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname9, join as join20, relative as relative3, resolve as resolve10 } from "node:path";
+import { dirname as dirname9, join as join21, relative as relative3, resolve as resolve10 } from "node:path";
 import { Readable as Readable3 } from "node:stream";
 import { pipeline as pipeline3 } from "node:stream/promises";
 
@@ -38841,19 +40709,19 @@ function ghCacheRoot() {
   return getAftLspBinariesDir();
 }
 function ghPackageDir(spec) {
-  return join20(ghCacheRoot(), spec.id);
+  return join21(ghCacheRoot(), spec.id);
 }
 function ghBinDir(spec) {
-  return join20(ghPackageDir(spec), "bin");
+  return join21(ghPackageDir(spec), "bin");
 }
 function ghExtractDir(spec) {
-  return join20(ghPackageDir(spec), "extracted");
+  return join21(ghPackageDir(spec), "extracted");
 }
 var INSTALLED_META_FILE2 = ".aft-installed";
 var INSTALL_FAILED_FILE = ".aft-install-failed.json";
 var INSTALL_FAILURE_BACKOFF_MS = 6 * 60 * 60 * 1000;
 function installFailureMarkerPath(spec) {
-  return join20(ghPackageDir(spec), INSTALL_FAILED_FILE);
+  return join21(ghPackageDir(spec), INSTALL_FAILED_FILE);
 }
 function readInstallFailureMarker(spec) {
   try {
@@ -38874,7 +40742,7 @@ function writeInstallFailureMarker(spec, release, sha256, installError) {
     mkdirSync9(dirname9(path), { recursive: true });
     writeFileSync10(tempPath, `${JSON.stringify({ release, sha256, error: markerError, at: new Date().toISOString() })}
 `, { encoding: "utf8", mode: 384 });
-    renameSync9(tempPath, path);
+    renameSync10(tempPath, path);
   } catch (err) {
     try {
       rmSync8(tempPath, { force: true });
@@ -38895,12 +40763,12 @@ function isFreshInstallFailure(marker) {
 }
 function ghBinaryPath(spec, platform) {
   const ext = platform === "win32" ? ".exe" : "";
-  return join20(ghBinDir(spec), `${spec.binary}${ext}`);
+  return join21(ghBinDir(spec), `${spec.binary}${ext}`);
 }
 function isGithubInstalled(spec, platform) {
   for (const candidate of ghBinaryCandidates(spec, platform)) {
     try {
-      if (statSync11(join20(ghBinDir(spec), candidate)).isFile())
+      if (statSync11(join21(ghBinDir(spec), candidate)).isFile())
         return true;
     } catch {}
   }
@@ -38913,7 +40781,7 @@ function ghBinaryCandidates(spec, platform) {
 }
 function readGithubInstalledMetaIn(installDir) {
   try {
-    const path = join20(installDir, INSTALLED_META_FILE2);
+    const path = join21(installDir, INSTALLED_META_FILE2);
     if (!statSync11(path).isFile())
       return null;
     const parsed = JSON.parse(readFileSync15(path, "utf8"));
@@ -38940,7 +40808,7 @@ function writeGithubInstalledMetaIn(installDir, version, binarySha256, archiveSh
       binarySha256,
       ...archiveSha256 ? { archiveSha256 } : {}
     };
-    writeFileSync10(join20(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
+    writeFileSync10(join21(installDir, INSTALLED_META_FILE2), JSON.stringify(meta), "utf8");
   } catch (err) {
     warn2(`[lsp] failed to write github installed metadata in ${installDir}: ${err}`);
   }
@@ -39189,7 +41057,7 @@ function validateExtraction(stagingRoot) {
       throw new Error(`failed to read staging dir ${dir}: ${err}`);
     }
     for (const entry of entries) {
-      const full = join20(dir, entry);
+      const full = join21(dir, entry);
       let lst;
       try {
         lst = lstatSync2(full);
@@ -39235,7 +41103,7 @@ function assertArchiveEntryPath(entry) {
 }
 function precheckWithTar(archivePath, command) {
   let totalBytes = 0;
-  const verbose = execFileSync2(command, ["-tvf", archivePath], { encoding: "utf8" });
+  const verbose = execFileSync3(command, ["-tvf", archivePath], { encoding: "utf8" });
   for (const line of verbose.split(`
 `)) {
     if (line.startsWith("h")) {
@@ -39248,7 +41116,7 @@ function precheckWithTar(archivePath, command) {
         totalBytes += Math.max(...numeric);
     }
   }
-  const names = execFileSync2(command, ["-tf", archivePath], { encoding: "utf8" });
+  const names = execFileSync3(command, ["-tf", archivePath], { encoding: "utf8" });
   for (const entry of names.split(`
 `)) {
     if (entry.length > 0)
@@ -39259,19 +41127,18 @@ function precheckWithTar(archivePath, command) {
 function precheckArchiveContents(archivePath, archiveType, zipListingMode = "platform") {
   let totalBytes = 0;
   if (archiveType === "zip" && zipListingMode === "platform" && process.platform !== "win32") {
-    const out = execFileSync2("unzip", ["-l", archivePath], { encoding: "utf8" });
+    const out = execFileSync3("unzip", ["-l", archivePath], { encoding: "utf8" });
     const match = out.match(/^\s*(\d+)\s+\d+\s+files?\s*$/m);
     if (match)
       totalBytes = Number.parseInt(match[1] ?? "0", 10);
-    const names = execFileSync2("unzip", ["-Z1", archivePath], { encoding: "utf8" });
+    const names = execFileSync3("unzip", ["-Z1", archivePath], { encoding: "utf8" });
     for (const entry of names.split(`
 `)) {
       if (entry.length > 0)
         assertArchiveEntryPath(entry);
     }
   } else {
-    const command = process.platform === "win32" ? "tar.exe" : "tar";
-    totalBytes = precheckWithTar(archivePath, command);
+    totalBytes = precheckWithTar(archivePath, windowsTarExecutable());
   }
   if (totalBytes > MAX_EXTRACT_BYTES2) {
     throw new Error(`archive uncompressed size ${totalBytes} exceeds ${MAX_EXTRACT_BYTES2}`);
@@ -39291,7 +41158,7 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
     try {
       rmSync8(destDir, { recursive: true, force: true });
     } catch {}
-    renameSync9(stagingDir, destDir);
+    renameSync10(stagingDir, destDir);
   } catch (err) {
     try {
       rmSync8(stagingDir, { recursive: true, force: true });
@@ -39301,12 +41168,12 @@ function extractArchiveSafely(archivePath, destDir, archiveType) {
 }
 function quarantineCachedGithubInstall(spec, reason) {
   const packageDir = ghPackageDir(spec);
-  const dest = join20(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
+  const dest = join21(ghCacheRoot(), ".quarantine", encodeURIComponent(spec.id), `${Date.now()}`);
   warn2(`[lsp] tofu_mismatch ${spec.id}: ${reason}; quarantining ${packageDir} -> ${dest}`);
   try {
     mkdirSync9(dirname9(dest), { recursive: true });
     rmSync8(dest, { recursive: true, force: true });
-    renameSync9(packageDir, dest);
+    renameSync10(packageDir, dest);
   } catch (err) {
     warn2(`[lsp] tofu_mismatch ${spec.id}: failed to quarantine cache entry: ${err}`);
   }
@@ -39314,7 +41181,7 @@ function quarantineCachedGithubInstall(spec, reason) {
 function validateCachedGithubInstall(spec, platform) {
   const packageDir = ghPackageDir(spec);
   const meta = readGithubInstalledMetaIn(packageDir);
-  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join20(ghBinDir(spec), candidate)).find((candidate) => {
+  const binaryPath = ghBinaryCandidates(spec, platform).map((candidate) => join21(ghBinDir(spec), candidate)).find((candidate) => {
     try {
       return statSync11(candidate).isFile();
     } catch {
@@ -39350,30 +41217,21 @@ function validateCachedGithubInstall(spec, platform) {
 function runPlatformExtractor(archivePath, destDir, archiveType) {
   if (archiveType === "zip") {
     if (process.platform === "win32") {
-      execFileSync2("tar.exe", ["-xf", archivePath, "-C", destDir], {
-        stdio: "pipe",
-        timeout: 180000
-      });
+      execTarExtractionSync(["-xf", archivePath, "-C", destDir], 180000);
       return;
     }
-    execFileSync2("unzip", ["-q", "-o", archivePath, "-d", destDir], {
+    execFileSync3("unzip", ["-q", "-o", archivePath, "-d", destDir], {
       stdio: "pipe",
       timeout: 180000
     });
     return;
   }
   if (archiveType === "tar.gz") {
-    execFileSync2("tar", ["-xzf", archivePath, "-C", destDir], {
-      stdio: "pipe",
-      timeout: 180000
-    });
+    execTarExtractionSync(["-xzf", archivePath, "-C", destDir], 180000);
     return;
   }
   if (archiveType === "tar.xz") {
-    execFileSync2("tar", ["-xf", archivePath, "-C", destDir], {
-      stdio: "pipe",
-      timeout: 180000
-    });
+    execTarExtractionSync(["-xf", archivePath, "-C", destDir], 180000);
     return;
   }
   throw new Error(`unsupported archive type: ${archiveType}`);
@@ -39394,7 +41252,7 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
   }
   const pkgDir = ghPackageDir(spec);
   const extractDir = ghExtractDir(spec);
-  const archivePath = join20(pkgDir, expected.name);
+  const archivePath = join21(pkgDir, expected.name);
   log2(`[lsp] downloading ${spec.id} ${tag} → ${matchingAsset.url}`);
   try {
     await downloadFile(matchingAsset.url, archivePath, fetchImpl, matchingAsset.size, signal);
@@ -39436,8 +41294,8 @@ async function downloadAndInstall(spec, tag, assets, platform, arch, fetchImpl,
       unlinkSync7(archivePath);
     } catch {}
   }
-  const innerBinaryPath = join20(extractDir, spec.binaryPathInArchive(platform, arch, version));
-  if (!existsSync18(innerBinaryPath)) {
+  const innerBinaryPath = join21(extractDir, spec.binaryPathInArchive(platform, arch, version));
+  if (!existsSync19(innerBinaryPath)) {
     const message = `extracted binary not found at ${innerBinaryPath}`;
     error2(`[lsp] ${spec.id}: ${message}`);
     return { ok: false, sha256: archiveSha256, error: message };
@@ -39542,7 +41400,7 @@ function runGithubAutoInstall(relevantServers, config, fetchImpl = fetch) {
   if (!host) {
     for (const spec of GITHUB_LSP_TABLE) {
       try {
-        if (existsSync18(ghBinDir(spec))) {
+        if (existsSync19(ghBinDir(spec))) {
           cachedBinDirs.push(ghBinDir(spec));
         }
       } catch {}
@@ -39859,25 +41717,25 @@ function isTuiConnected(sessionId) {
 // src/shared/rpc-server.ts
 import { randomBytes as randomBytes4, timingSafeEqual as timingSafeEqual2 } from "node:crypto";
 import {
-  existsSync as existsSync19,
+  existsSync as existsSync20,
   mkdirSync as mkdirSync10,
   readdirSync as readdirSync6,
   readFileSync as readFileSync16,
-  renameSync as renameSync10,
+  renameSync as renameSync11,
   unlinkSync as unlinkSync8,
   writeFileSync as writeFileSync11
 } from "node:fs";
 import { createServer } from "node:http";
-import { dirname as dirname10, join as join22 } from "node:path";
+import { dirname as dirname10, join as join23 } from "node:path";
 
 // src/shared/rpc-utils.ts
-import { join as join21 } from "node:path";
+import { join as join22 } from "node:path";
 function projectHash(directory) {
   return projectRootKeyHash(directory);
 }
 function rpcPortFileDir(storageDir, directory) {
   const hash = projectHash(directory);
-  return join21(storageDir, "rpc", hash, "ports");
+  return join22(storageDir, "rpc", hash, "ports");
 }
 function isPidAlive(pid) {
   if (typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0)
@@ -39951,7 +41809,7 @@ class AftRpcServer {
   constructor(storageDir, directory) {
     this.portsDir = rpcPortFileDir(storageDir, directory);
     this.instanceId = randomBytes4(8).toString("hex");
-    this.portFilePath = join22(this.portsDir, `${this.instanceId}.json`);
+    this.portFilePath = join23(this.portsDir, `${this.instanceId}.json`);
   }
   handle(method, handler) {
     this.handlers.set(method, handler);
@@ -39981,6 +41839,7 @@ class AftRpcServer {
     });
     this.bunServer = server;
     this.port = server.port ?? 0;
+    server.unref?.();
     this.afterServerStarted();
     return this.port;
   }
@@ -40026,7 +41885,7 @@ class AftRpcServer {
       pid: process.pid,
       started_at: Date.now()
     }), { encoding: "utf-8", mode: 384 });
-    renameSync10(tmpPath, this.portFilePath);
+    renameSync11(tmpPath, this.portFilePath);
   }
   sweepDeadPortFiles() {
     let entries;
@@ -40038,7 +41897,7 @@ class AftRpcServer {
     for (const entry of entries) {
       if (!entry.endsWith(".json"))
         continue;
-      const filePath = join22(this.portsDir, entry);
+      const filePath = join23(this.portsDir, entry);
       if (filePath === this.portFilePath)
         continue;
       try {
@@ -40057,7 +41916,7 @@ class AftRpcServer {
     if (!this.nodeServer && !this.bunServer || this.port <= 0)
       return;
     try {
-      if (existsSync19(this.portFilePath))
+      if (existsSync20(this.portFilePath))
         return;
       this.writePortFile();
       log2(`RPC port file was missing; rewrote ${this.portFilePath}`);
@@ -40324,12 +42183,6 @@ function formatCacheRoleLabel(role) {
   }
   return role;
 }
-function formatSemanticIndexStatus(status, stage) {
-  if ((status === "loading" || status === "building") && stage === "fingerprint_change") {
-    return "Rebuilding (model changed)";
-  }
-  return status;
-}
 function formatSemanticRefreshing(refreshingCount) {
   if (!Number.isFinite(refreshingCount) || refreshingCount <= 0)
     return null;
@@ -40441,7 +42294,7 @@ function formatStatusMarkdown(status) {
     `- **Cache role:** \`${formatCacheRoleLabel(status.cache_role)}\``
   ];
   appendDegradedStatus(lines, status, true);
-  lines.push("", "### Enabled features", `- \`format_on_edit\`: ${formatFlag(status.features.format_on_edit)}`, `- \`search_index\`: ${formatFlag(status.features.search_index)}`, `- \`semantic_search\`: ${formatFlag(status.features.semantic_search)}`, `- \`callgraph_store\`: ${formatFlag(status.features.callgraph_store)}`, "", "### Search index", `- **Status:** \`${status.search_index.status}\``, `- **Files:** ${formatCount(status.search_index.files)}`, `- **Trigrams:** ${formatCount(status.search_index.trigrams)}`, "", "### Semantic index", `- **Status:** \`${formatSemanticIndexStatus(status.semantic_index.status, status.semantic_index.stage)}\``);
+  lines.push("", "### Enabled features", `- \`format_on_edit\`: ${formatFlag(status.features.format_on_edit)}`, `- \`search_index\`: ${formatFlag(status.features.search_index)}`, `- \`semantic_search\`: ${formatFlag(status.features.semantic_search)}`, `- \`callgraph_store\`: ${formatFlag(status.features.callgraph_store)}`, "", "### Search index", `- **Status:** \`${status.search_index.status}\``, `- **Files:** ${formatCount(status.search_index.files)}`, `- **Trigrams:** ${formatCount(status.search_index.trigrams)}`, "", "### Semantic index", `- **Status:** \`${formatSemanticIndexStatus(status.semantic_index.status, status.semantic_index.stage, status.semantic_index.error)}\``);
   const refreshing = formatSemanticRefreshing(status.semantic_index.refreshing_count);
   if (refreshing) {
     lines.push(`- **Refresh:** ${refreshing}`);
@@ -40610,7 +42463,7 @@ function isSyncWatchAborted(sessionID) {
 }
 
 // src/tools/permissions.ts
-import { execFileSync as execFileSync3 } from "node:child_process";
+import { execFileSync as execFileSync4 } from "node:child_process";
 import * as fs4 from "node:fs";
 import { tmpdir as tmpdir3 } from "node:os";
 import * as path3 from "node:path";
@@ -40865,7 +42718,7 @@ function gitRootForNearestExistingParent(resolved) {
       cwd = path3.dirname(nearest);
   } catch {}
   try {
-    const out = execFileSync3("git", ["rev-parse", "--show-toplevel"], {
+    const out = execFileSync4("git", ["rev-parse", "--show-toplevel"], {
       cwd,
       encoding: "utf8",
       stdio: ["ignore", "pipe", "ignore"]
@@ -41178,6 +43031,26 @@ function failure(error) {
   })();
   return new Error(`V2 tool execution rejected with a non-Error value: ${detail}`);
 }
+function isPlainObject3(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function jsonSafeMetadata(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => entry === undefined ? null : jsonSafeMetadata(entry));
+  }
+  if (!isPlainObject3(value))
+    return value;
+  const cleaned = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (entry === undefined)
+      continue;
+    cleaned[key] = jsonSafeMetadata(entry);
+  }
+  return cleaned;
+}
 function resultContent(result) {
   if (typeof result === "string")
     return { content: result };
@@ -41188,15 +43061,39 @@ function resultContent(result) {
     ...attachment.filename ? { name: attachment.filename } : {}
   }));
   const content = attachments.length ? [{ type: "text", text: result.output }, ...attachments] : result.output;
-  const metadata = {
+  const metadata = jsonSafeMetadata({
     ...result.metadata ?? {},
     ...result.title ? { title: result.title } : {}
-  };
+  });
   return {
     content,
     ...Object.keys(metadata).length ? { metadata } : {}
   };
 }
+function failureEnvelopeMessage(result) {
+  const output = typeof result === "string" ? result : result.output;
+  if (typeof output !== "string")
+    return;
+  const trimmed = output.trim();
+  if (!trimmed.startsWith("{") || !trimmed.includes('"success"'))
+    return;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return;
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    return;
+  const envelope = parsed;
+  if (envelope.success !== false)
+    return;
+  for (const field of [envelope.message, envelope.error, envelope.code]) {
+    if (typeof field === "string" && field.length > 0)
+      return field;
+  }
+  return "The tool call failed.";
+}
 function bareToolName3(name) {
   return name.startsWith("aft_") ? name.slice(4) : name;
 }
@@ -41259,15 +43156,15 @@ function runtimeFor(location, context, signal, consumers) {
     abort: signal,
     effectAbort: signal,
     metadata: (update) => {
-      Effect.runPromise(context.progress({
+      Effect.runPromise(context.progress(jsonSafeMetadata({
         ...update.metadata ?? {},
         ...update.title ? { title: update.title } : {}
-      }));
+      })));
     },
     ask: (request) => {
       if (consumers.requestPermission)
         return consumers.requestPermission(request, context);
-      return Promise.reject(new Error(`The "${request.permission}" operation was refused because the OpenCode V2 host did not provide a permission request endpoint.`));
+      return Promise.reject(new Error(`The "${request.permission}" operation was refused because this AFT runtime has no permission evaluator bound, so the host's permission rules for it could not be consulted.`));
     },
     progress: context.progress
   };
@@ -41296,6 +43193,9 @@ function projectV2Tool(name, definition, location, consumers = {}) {
           context: runtime,
           definition
         }) : await definition.execute(input, runtime);
+        const refusal = failureEnvelopeMessage(result);
+        if (refusal)
+          throw new Error(refusal);
         return resultContent(result);
       },
       catch: failure
@@ -42390,7 +44290,7 @@ function createReadTool(ctx) {
         try {
           await runAsk(context.ask({
             permission: "read",
-            patterns: [filePath],
+            patterns: [permissionPath(context, filePath)],
             always: ["*"],
             metadata: {}
           }));
@@ -42551,7 +44451,7 @@ function getEditDescription(ctx, writeToolName) {
 
 **Modes** (determined by which parameters you provide):
 
-Provide exactly one mode per call: appendContent, edits[], or symbol plus content. Mixing modes or providing none is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
+Provide exactly one mode per call: appendContent, edits[], or symbol plus content. \`symbol\` and \`content\` are only meaningful together; a call carrying one without the other is incomplete. Mixing modes or providing none is rejected — there is no implicit "write" fallback. To edit multiple files, make parallel \`edit\` calls in one response.
 
 1. **Append** — pass \`path\` + \`appendContent\`
    Appends text to the end of a file, creating it if it does not exist.
@@ -42652,8 +44552,8 @@ function createEditTool(ctx, writeToolName = "write") {
     description: getEditDescription(ctx, writeToolName),
     args: {
       filePath: z7.string().describe("Path to the file to edit (absolute or relative to project root)"),
-      symbol: z7.string().optional().describe("Named symbol to replace (function, class, type)"),
-      content: z7.string().optional().describe("Replacement content for symbol mode. For whole-file writes, use the `write` tool."),
+      symbol: z7.string().optional().describe("Named symbol to replace; only meaningful together with `content`. A call carrying one without the other is incomplete."),
+      content: z7.string().optional().describe("Replacement content for symbol mode; only meaningful together with `symbol`. A call carrying one without the other is incomplete. For whole-file writes, use the `write` tool."),
       appendContent: z7.string().optional().describe("Text to append to the end of path; creates the file if needed"),
       edits: z7.array(z7.object({
         oldString: z7.string().optional().describe("Text to find for a batch find/replace edit"),
@@ -42895,7 +44795,7 @@ function createDeleteTool(ctx) {
       }
       await runAsk(context.ask({
         permission: "edit",
-        patterns: absolutePaths,
+        patterns: resolveRelativePatterns(context, absolutePaths),
         always: ["*"],
         metadata: { action: "delete", count: absolutePaths.length }
       }));
@@ -42948,7 +44848,7 @@ function createMoveTool(ctx) {
       }
       await runAsk(context.ask({
         permission: "edit",
-        patterns: [filePath, destPath],
+        patterns: resolveRelativePatterns(context, [filePath, destPath]),
         always: ["*"],
         metadata: { action: "move" }
       }));
@@ -43278,7 +45178,7 @@ function inspectTools(ctx) {
 ` + "Treat `dead_code` as a hint, not proof: reachability is call-based, so symbols reached only via method dispatch or referenced only in type position may be false positives — verify before deleting.\n\n" + "When a list is cut, the reply ends with `shown N of M <unit> (<reason>) · narrow: <knobs>`; absence of that line means the list is complete.",
     args: {
       sections: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Categories to include in detailed drill-down (e.g. 'todos' or ['todos', 'dead_code', 'cycles']). Use 'all' for every active category. Omit for summary-only mode. `sections` changes detail, not the categories verified.")),
-      scope: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Restrict returned results to paths under this scope (file or directory, absolute or relative to project root). `scope=` narrows results and limits Rust LSP startup to owning Cargo workspaces; it does not trigger per-file diagnostic collection. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
+      scope: arg(z9.union([z9.string(), z9.array(z9.string())]).optional().describe("Restrict returned results to paths under this scope (one path, or an array of paths — not a space-separated list; file or directory; absolute or relative to project root). `scope=` narrows results and limits Rust LSP startup to owning Cargo workspaces; it does not trigger per-file diagnostic collection. Scoped files no producer has authoritatively analyzed are reported as named gaps (complete: false), never as a clean empty result.")),
       topK: arg(z9.number().int().positive().max(100).optional().describe("Max drill-down items per category. Default 20, max 100."))
     },
     execute: async (args, context) => {
@@ -43671,7 +45571,7 @@ function safetyTools(ctx) {
 ` + `- 'undo': Undo the entire last tool call when 'path' is omitted (typical), or undo the last edit to one file when 'path' is provided. Note: pops from the undo stack (irreversible, no redo). Use 'history' to inspect per-file history before undoing.
 ` + `- 'history': List all edit snapshots for a file. Requires 'path'.
 ` + `- 'checkpoint': Save a named snapshot. Explicit 'files' may be untracked or gitignored; omit them to snapshot backup-tracked files. Checkpoints are session-scoped and lost on bridge or daemon restart. Requires 'name'.
-` + `- 'restore': Restore files to a previously saved checkpoint. Requires 'name'.
+` + `- 'restore': Restore files to a previously saved checkpoint. Optional 'path'/'files' scopes the restore; omitted scope restores the whole checkpoint. Requires 'name'.
 ` + `- 'list': List all available named checkpoints. No extra params needed.
 
 ` + `Each op requires specific parameters — see parameter descriptions for requirements.
@@ -43679,9 +45579,9 @@ function safetyTools(ctx) {
 ` + "Use checkpoint before risky multi-file changes. Use undo for quick single-file rollback.",
       args: {
         op: z12.enum(["undo", "history", "checkpoint", "restore", "list"]).describe("Safety operation"),
-        path: z12.string().optional().describe("File path (required for history, optional for undo). Absolute or relative to project root"),
+        path: z12.string().optional().describe("File path (required for history, optional for undo, optional for restore — restores only that file). Absolute or relative to project root"),
         name: z12.string().optional().describe("Checkpoint name (required for checkpoint, restore)"),
-        files: z12.array(z12.string()).optional().describe("Specific files to include in checkpoint (optional, defaults to backup-tracked files; explicit files may be untracked or gitignored)")
+        files: z12.array(z12.string()).optional().describe("Specific files to include in checkpoint, or to restore from a checkpoint (optional; restore without path/files restores the whole checkpoint; explicit checkpoint files may be untracked or gitignored)")
       },
       execute: async (args, context) => {
         const op = args.op;
@@ -44000,7 +45900,7 @@ function semanticTools(ctx) {
 `),
     args: {
       query: arg3(z13.string().describe("Concept, regex, literal text, filename, or capability to find. Examples: 'fuzzy match with whitespace tolerance', '^export', 'Cargo.lock'.")),
-      topK: arg3(optionalInt(1, 100).describe("Number of results (default: 10, max: 100)")),
+      topK: arg3(optionalInt(1, 50).describe("Number of results (default: 10, max: 50)")),
       offset: arg3(optionalInt(0, 1e5).describe("Zero-based result offset (default: 0, max: 100000).")),
       includeTests: arg3(z13.boolean().optional().describe("Include test files (*.test.*, *_test.rs, __tests__/, …) plus test-support, fixture, mock, snapshot, and corpus files. Defaults to false.")),
       path: arg3(z13.string().optional().describe("Only set this to search a different Git project (absolute or ~ path). Omit it for the current configured workspace, including non-Git workspace roots; this is not a subdirectory filter. Unindexed external projects use a bounded lexical fallback."))
@@ -44016,9 +45916,9 @@ function semanticTools(ctx) {
       if (denied)
         return permissionDeniedResponse(denied);
       const rawArgs = { query };
-      const topK = coerceOptionalInt(args.topK, "topK", 1, 100);
+      const topK = coerceOptionalInt(args.topK, "topK", 1, 50);
       const offset = coerceOptionalInt(args.offset, "offset", 0, 1e5);
-      const includeTests = typeof args.includeTests === "boolean" ? args.includeTests : undefined;
+      const includeTests = !isEmptyParam(args.includeTests) ? coerceBoolean(args.includeTests) : undefined;
       if (topK !== undefined)
         rawArgs.topK = topK;
       if (offset !== undefined)
@@ -44258,11 +46158,11 @@ function throwSentinel(command) {
   throw sentinel;
 }
 var PLUGIN_VERSION = resolvePluginVersion(import.meta.url);
-var ANNOUNCEMENT_VERSION = "0.56.0";
+var ANNOUNCEMENT_VERSION = "0.57.0";
 var ANNOUNCEMENT_FEATURES = [
-  "Callgraph stays consistent under load: edits arriving mid-rebuild can no longer be silently lost from navigation results.",
-  "aft_zoom handles real-world .jsonc: files with comment banners above the opening brace now resolve, and not-found errors point at the segment that actually failed (thanks @iceteaSA).",
-  "Disk hygiene: stale per-checkout inspect caches from old worktrees are now swept automatically — one machine reclaimed 21 GB."
+  "OpenCode 2 is supported: tools, permission prompts, the sidebar and cancellation all work on the GA host, and an end-to-end matrix guards them.",
+  "`doctor` configures a machine that has only OpenCode 2 installed, and `--fix` no longer skips unrelated repairs when it cannot decide the generation.",
+  "A code-health scan no longer starts while the same project is still building its call graph, which cost about 90 MB of peak memory on large repositories."
 ];
 var ANNOUNCEMENT_FOOTER = "Join us on Discord: https://discord.gg/DSa65w8wuf";
 var plugin = async (input) => initializePluginForDirectory(input);
@@ -44934,7 +46834,7 @@ Install: ${getManualInstallHint()}`).catch(() => {});
 var src_default = plugin;
 
 // src/entry/server-runtime.mjs
-import { Effect as Effect5 } from "effect";
+import { Effect as Effect6 } from "effect";
 
 // src/rpc/register.ts
 import { Effect as Effect2 } from "effect";
@@ -45137,6 +47037,8 @@ function registerAftRpc(context, location, pool) {
 }
 
 // src/permissions/v2.ts
+import { Effect as Effect3 } from "effect";
+
 class PermissionDeniedError extends Error {
   name = "PermissionDeniedError";
 }
@@ -45144,6 +47046,107 @@ class PermissionDeniedError extends Error {
 class PermissionRejectedError extends Error {
   name = "PermissionRejectedError";
 }
+
+class PermissionPromptUnavailableError extends Error {
+  name = "PermissionPromptUnavailableError";
+}
+
+class PermissionPromptUnansweredError extends Error {
+  name = "PermissionPromptUnansweredError";
+}
+
+class PermissionRulesUnavailableError extends Error {
+  name = "PermissionRulesUnavailableError";
+}
+var V2_PROMPT_REPLY_TIMEOUT_MS = 10 * 60000;
+var V2_PROMPT_LISTEN_TIMEOUT_MS = 5000;
+function wildcardMatch(input, pattern) {
+  const normalized = input.replaceAll("\\", "/");
+  let escaped = pattern.replaceAll("\\", "/").replaceAll(/[.+^${}()|[\]\\]/g, "\\$&").replaceAll(/\*/g, ".*").replaceAll(/\?/g, ".");
+  if (escaped.endsWith(" .*"))
+    escaped = `${escaped.slice(0, -3)}( .*)?`;
+  return new RegExp(`^${escaped}$`, process.platform === "win32" ? "si" : "s").test(normalized);
+}
+function matchingRule(action, resource, rules) {
+  for (let index = rules.length - 1;index >= 0; index -= 1) {
+    const rule = rules[index];
+    if (rule && wildcardMatch(action, rule.action) && wildcardMatch(resource, rule.resource)) {
+      return rule;
+    }
+  }
+  return { action, resource: "*", effect: "ask" };
+}
+function decidePermission(request, rules) {
+  for (const resource of request.patterns) {
+    const rule = matchingRule(request.permission, resource, rules);
+    if (rule.effect === "deny")
+      return { effect: "deny", resource, rule };
+  }
+  for (const resource of request.patterns) {
+    const rule = matchingRule(request.permission, resource, rules);
+    if (rule.effect === "ask")
+      return { effect: "ask", resource, rule };
+  }
+  return { effect: "allow" };
+}
+function detail(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function runHostEffect(effect) {
+  return await Effect3.runPromise(effect);
+}
+async function sessionRecord(host, sessionID) {
+  if (!sessionID)
+    return;
+  try {
+    return await runHostEffect(host.session.get({ sessionID }));
+  } catch (error) {
+    throw new PermissionRulesUnavailableError(`reading session ${JSON.stringify(sessionID)} failed: ${detail(error)}`);
+  }
+}
+async function agentRules(host, agentID) {
+  let record;
+  try {
+    record = (await runHostEffect(host.agent.get({ agentID }))).data;
+  } catch (error) {
+    throw new PermissionRulesUnavailableError(`reading agent ${JSON.stringify(agentID)} failed: ${detail(error)}`);
+  }
+  if (!record.permissions) {
+    throw new PermissionRulesUnavailableError(`agent ${JSON.stringify(agentID)} reported no permission rules`);
+  }
+  return record.permissions;
+}
+async function configuredRules(host, context) {
+  const session = await sessionRecord(host, context.sessionID);
+  const agentID = context.agent ?? session?.agent;
+  if (!agentID) {
+    throw new PermissionRulesUnavailableError("the tool call carried no agent identifier and its session named none");
+  }
+  return [...await agentRules(host, agentID), ...session?.permissions ?? []];
+}
+function describeRule(rule) {
+  if (!rule)
+    return "no matching rule";
+  return `${JSON.stringify(rule.action)} on ${JSON.stringify(rule.resource)} is ${JSON.stringify(rule.effect)}`;
+}
+function deniedMessage(request, decision) {
+  return `Permission denied: this session's permission rules deny ${JSON.stringify(request.permission)}` + `${decision.resource === undefined ? "" : ` for ${JSON.stringify(decision.resource)}`}` + ` (${describeRule(decision.rule)}).`;
+}
+function promptUnavailableMessage(request, decision, observed) {
+  const resource = decision.resource ?? "*";
+  return `The ${JSON.stringify(request.permission)} operation needs interactive approval: this ` + `session's permission rules resolve it to "ask" for ${JSON.stringify(resource)}, and AFT ` + `could not reach the OpenCode service to raise a prompt (${observed}). Start OpenCode's ` + "background service and retry, or run it without a prompt by adding " + `{"action": ${JSON.stringify(request.permission)}, "resource": ${JSON.stringify(resource)}, ` + '"effect": "allow"} to the "permissions" list of the agent or session in your OpenCode config.';
+}
+function promptUnansweredMessage(request, decision, observed) {
+  const resource = decision.resource ?? "*";
+  return `The ${JSON.stringify(request.permission)} operation was refused: this session's permission ` + `rules resolve it to "ask" for ${JSON.stringify(resource)}, AFT raised a prompt and received ` + `no reply (${observed}), so nothing was permitted. Answer the prompt and run the operation ` + "again, or run it without a prompt by adding " + `{"action": ${JSON.stringify(request.permission)}, "resource": ${JSON.stringify(resource)}, ` + '"effect": "allow"} to the "permissions" list of the agent or session in your OpenCode config.';
+}
+function waitDuration(ms) {
+  if (ms >= 60000 && ms % 60000 === 0)
+    return `${ms / 60000}m`;
+  if (ms >= 1000 && ms % 1000 === 0)
+    return `${ms / 1000}s`;
+  return `${ms}ms`;
+}
 function requiredContextID(context, key) {
   const value = context[key];
   if (typeof value !== "string" || value.length === 0) {
@@ -45168,43 +47171,117 @@ function repliedEvent(event) {
   const candidate = envelope.payload ?? event;
   if (candidate.type !== "permission.replied")
     return;
-  if (!candidate.properties || typeof candidate.properties !== "object")
+  if (!candidate.data || typeof candidate.data !== "object")
     return;
-  return candidate;
+  return candidate.data;
 }
 async function closeStream(iterator) {
   if (typeof iterator.return === "function")
     await iterator.return();
 }
-async function waitForReply(stream, sessionID, requestID) {
-  const iterator = stream[Symbol.asyncIterator]();
+function pull(iterator) {
+  return iterator.next().then((result) => ({ kind: "event", result }), (error) => ({ kind: "failed", error }));
+}
+function countdown(ms) {
+  let handle;
+  const expired = new Promise((resolve) => {
+    handle = setTimeout(resolve, ms);
+  });
+  return {
+    expired,
+    cancel: () => {
+      if (handle !== undefined)
+        clearTimeout(handle);
+    }
+  };
+}
+function cancellation(signal) {
+  if (!signal)
+    return { cancelled: new Promise(() => {}), dispose: () => {} };
+  if (signal.aborted)
+    return { cancelled: Promise.resolve(), dispose: () => {} };
+  let listener;
+  const cancelled = new Promise((resolve) => {
+    listener = () => resolve();
+    signal.addEventListener("abort", listener, { once: true });
+  });
+  return {
+    cancelled,
+    dispose: () => {
+      if (listener)
+        signal.removeEventListener("abort", listener);
+    }
+  };
+}
+async function startListening(client, listenTimeoutMs) {
+  let iterator;
+  try {
+    const subscription = await client.event.subscribe();
+    iterator = subscription.stream[Symbol.asyncIterator]();
+  } catch (error) {
+    return { unavailable: `subscribing to the event stream failed: ${detail(error)}` };
+  }
+  const first = pull(iterator);
+  const ready = countdown(listenTimeoutMs);
+  try {
+    const settled = await Promise.race([first, ready.expired.then(() => {
+      return;
+    })]);
+    if (settled?.kind === "failed") {
+      await closeStream(iterator);
+      return { unavailable: `reading the event stream failed: ${detail(settled.error)}` };
+    }
+  } finally {
+    ready.cancel();
+  }
+  return { iterator, first };
+}
+async function waitForReply(iterator, first, sessionID, requestID, limits) {
+  const deadline = countdown(limits.replyTimeoutMs);
+  const abort = cancellation(limits.signal);
+  let pending = first;
   try {
     while (true) {
-      const next = await iterator.next();
-      if (next.done)
-        throw new Error("Permission event stream ended before a reply arrived");
-      const event = repliedEvent(next.value);
-      if (!event || event.properties.sessionID !== sessionID || event.properties.requestID !== requestID) {
+      const next = pending ?? pull(iterator);
+      pending = undefined;
+      const settled = await Promise.race([
+        next,
+        deadline.expired.then(() => ({ kind: "unanswered" })),
+        abort.cancelled.then(() => ({ kind: "cancelled" }))
+      ]);
+      if (settled.kind === "unanswered") {
+        throw new PermissionPromptUnansweredError(`waited ${waitDuration(limits.replyTimeoutMs)} after raising it`);
+      }
+      if (settled.kind === "cancelled") {
+        throw new PermissionPromptUnansweredError("the operation was cancelled while the prompt was still open");
+      }
+      if (settled.kind === "failed") {
+        throw new PermissionPromptUnansweredError(`reading the event stream failed: ${detail(settled.error)}`);
+      }
+      if (settled.result.done) {
+        throw new PermissionPromptUnansweredError("the event stream ended before a reply arrived");
+      }
+      const event = repliedEvent(settled.result.value);
+      if (!event || event.sessionID !== sessionID || event.requestID !== requestID)
         continue;
-      }
-      if (event.properties.reply === "reject") {
+      if (event.reply === "reject")
         throw new PermissionRejectedError("Permission denied.");
-      }
       return;
     }
   } finally {
+    deadline.cancel();
+    abort.dispose();
     await closeStream(iterator);
   }
 }
-async function requestPermission(host, request, context) {
+async function raisePrompt(client, request, decision, context, limits) {
   const sessionID = requiredContextID(context, "sessionID");
   const messageID = requiredContextID(context, "messageID");
   const id = requiredContextID(context, "id");
-  const subscription = await host.client.event.subscribe();
-  const iterator = subscription.stream[Symbol.asyncIterator]();
+  const listening = await startListening(client, limits.listenTimeoutMs);
   let streamClaimed = false;
   try {
-    const result = createResult(await host.client.permission.create({
+    const result = createResult(await client.permission.create({
       sessionID,
       action: request.permission,
       resources: [...request.patterns],
@@ -45216,25 +47293,343 @@ async function requestPermission(host, request, context) {
       return;
     if (result.effect === "deny")
       throw new PermissionDeniedError("Permission denied.");
+    if ("unavailable" in listening) {
+      throw new PermissionPromptUnavailableError(promptUnavailableMessage(request, decision, listening.unavailable));
+    }
     streamClaimed = true;
-    await waitForReply({ [Symbol.asyncIterator]: () => iterator }, sessionID, result.id);
+    try {
+      await waitForReply(listening.iterator, listening.first, sessionID, result.id, limits);
+    } catch (error) {
+      if (!(error instanceof PermissionPromptUnansweredError))
+        throw error;
+      throw new PermissionPromptUnansweredError(promptUnansweredMessage(request, decision, error.message));
+    }
   } finally {
-    if (!streamClaimed)
-      await closeStream(iterator);
+    if (!streamClaimed && "iterator" in listening)
+      await closeStream(listening.iterator);
+  }
+}
+function contextAbortSignal(context) {
+  const candidate = context.abort;
+  return candidate instanceof AbortSignal ? candidate : undefined;
+}
+function resolveLimits(context, limits) {
+  return {
+    replyTimeoutMs: limits.replyTimeoutMs ?? V2_PROMPT_REPLY_TIMEOUT_MS,
+    listenTimeoutMs: limits.listenTimeoutMs ?? V2_PROMPT_LISTEN_TIMEOUT_MS,
+    signal: limits.signal ?? contextAbortSignal(context)
+  };
+}
+async function requestPermission(host, request, context, prompt, limits = {}) {
+  let rules;
+  try {
+    rules = await configuredRules(host, context);
+  } catch (error) {
+    if (!(error instanceof PermissionRulesUnavailableError))
+      throw error;
+    throw new PermissionRulesUnavailableError(`The ${JSON.stringify(request.permission)} operation was refused because AFT could not ` + `read this session's OpenCode permission rules (${error.message}), so it cannot tell ` + "whether the operation is permitted.");
+  }
+  const decision = decidePermission(request, rules);
+  if (decision.effect === "allow")
+    return;
+  if (decision.effect === "deny")
+    throw new PermissionDeniedError(deniedMessage(request, decision));
+  const channel = await prompt.client();
+  if (!channel.client) {
+    throw new PermissionPromptUnavailableError(promptUnavailableMessage(request, decision, channel.unavailable));
+  }
+  await raisePrompt(channel.client, request, decision, context, resolveLimits(context, limits));
+}
+
+// src/permissions/v2-service.ts
+init_promise();
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-txckps9j.js
+var stderrLimit = 8 * 1024;
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-xgnj2w4v.js
+var timings = new WeakMap;
+var defaultEnsureTiming2 = {
+  pollInterval: 25,
+  requestTimeout: 2000,
+  spawnDelay: 5000,
+  maxSpawnDelay: 30000,
+  promiseTimeout: 120000,
+  stopPollInterval: 50,
+  stopPollAttempts: 100
+};
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-sxt88q69.js
+function matchesVersion2(version, options) {
+  if (options.version === undefined)
+    return true;
+  if (version === undefined)
+    return false;
+  if (typeof options.version === "function")
+    return options.version(version);
+  return version === options.version;
+}
+
+// ../../node_modules/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/chunks/service-rg0h87gt.js
+init_service_9rqn6x4v();
+import { readFile, rename as rename2, rm as rm2, 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 !== undefined && existing.expiresAt > Date.now() && same(existing.source, info))
+    return;
+  await Promise.resolve().then(() => init_promise());
+  const client = exports_client.make({
+    baseUrl: info.url,
+    headers: info.password === undefined ? undefined : { authorization: "Basic " + Buffer.from(`opencode:${info.password}`).toString("base64") }
+  });
+  const missing = (error) => error instanceof ClientError2 && error.reason === "UnexpectedStatus" && typeof error.cause === "object" && error.cause !== null && ("status" in error.cause) && error.cause.status === 404;
+  const result = await client.experimental.persistentPty.handoff({ signal: AbortSignal.timeout(timeout) }).then((value) => ({ value }), (cause) => ({ cause }));
+  if ("cause" in result) {
+    const concurrent = await read(file);
+    if (concurrent !== undefined && concurrent.expiresAt > Date.now() && same(concurrent.source, info))
+      return;
+    if (!missing(result.cause))
+      throw new Error("Failed to prepare persistent terminals for service replacement", { cause: result.cause });
+    console.warn("Background service cannot hand off persistent terminals; shutting them down before replacement");
+    await client.experimental.persistentPty.shutdown({ signal: AbortSignal.timeout(timeout) }).catch((cause) => {
+      if (missing(cause))
+        return;
+      throw new Error("Failed to shut down persistent terminals before service replacement", { cause });
+    });
+    await publish(file, info, null);
+    return;
+  }
+  const body = result.value;
+  if (typeof body !== "object" || body === null || !("handoff" in body))
+    throw new Error("Invalid persistent terminal handoff response");
+  if (body.handoff === null) {
+    await publish(file, info, null);
+    return;
+  }
+  if (!isHandoff(body.handoff) || body.handoff.expiresAt <= Date.now())
+    throw new Error("Invalid or expired persistent terminal handoff");
+  await publish(file, info, body.handoff);
+}
+async function publish(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() + 30000
+  }), { mode: 384, flag: "wx" });
+  await rename2(temporary, file + ".pty-handoff").finally(() => rm2(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 !== undefined && record.expiresAt > Date.now() && (current === undefined || same(record.source, current)) ? record.handoff : undefined;
+  return { ...env, OPENCODE_PTY_HANDOFF: handoff == null ? undefined : JSON.stringify(handoff) };
+}
+async function complete2(file, info) {
+  const record = await read(file);
+  if (record !== undefined && !same(record.source, info))
+    await clear2(file);
+}
+async function clear2(file) {
+  await rm2(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 : undefined,
+      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/.bun/@opencode+client@2.0.11+bdc4bbd92cece36b/node_modules/@opencode/client/dist/promise/service.js
+import { readFile as readFile2, rm as rm3 } from "node:fs/promises";
+import { homedir as homedir13 } from "node:os";
+import { join as join25 } from "node:path";
+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;
+}
+function fallback() {
+  return join25(process.env["XDG_STATE_HOME"] ?? join25(homedir13(), ".local", "state"), "opencode", "service.json");
+}
+function headers(endpoint) {
+  if (endpoint.auth === undefined)
+    return;
+  return {
+    authorization: "Basic " + Buffer.from(endpoint.auth.username + ":" + endpoint.auth.password).toString("base64")
+  };
+}
+async function read2(file) {
+  const text = await readFile2(file ?? fallback(), "utf8").catch(() => {
+    return;
+  });
+  if (text === undefined)
+    return;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return;
   }
 }
+async function probeResult(info, timeout = defaultEnsureTiming2.requestTimeout) {
+  const endpoint = {
+    url: info.url,
+    auth: info.password === undefined ? undefined : { type: "basic", username: "opencode", password: info.password }
+  };
+  const signal = AbortSignal.timeout(timeout);
+  const result = await fetch(new URL("/api/info", info.url), { headers: headers(endpoint), signal }).then(async (response) => ({
+    response,
+    body: response.status === 404 ? undefined : await response.json()
+  })).then((value) => ({ value }), (cause) => ({ cause }));
+  if ("cause" in result)
+    return { service: undefined, timedOut: signal.aborted };
+  const response = result.value.response;
+  if (response.status === 404)
+    return {
+      service: {
+        info,
+        endpoint,
+        version: info.version,
+        state: "ready",
+        compatible: false
+      },
+      timedOut: false
+    };
+  const serverInfo = decodeInfo(result.value.body);
+  if (serverInfo !== undefined) {
+    if (serverInfo.pid !== info.pid)
+      return { service: undefined, timedOut: false };
+    if (info.version !== undefined && serverInfo.version !== info.version)
+      return { service: undefined, timedOut: false };
+    return {
+      service: {
+        info,
+        endpoint,
+        version: serverInfo.version,
+        state: response.ok ? "ready" : response.status === 500 ? "failed" : "waiting",
+        compatible: true
+      },
+      timedOut: false
+    };
+  }
+  return { service: undefined, timedOut: false };
+}
+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 };
+}
+async function registered(file, timeout) {
+  const info = await read2(file);
+  if (info === undefined)
+    return { info: undefined, service: undefined, timedOut: false };
+  return { info, ...await probeResult(info, timeout) };
+}
+
+// src/permissions/v2-service.ts
+function detail2(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function promptClient(endpoint) {
+  const client = exports_client.make({ baseUrl: endpoint.url, headers: headers(endpoint) });
+  return {
+    permission: {
+      create: (input) => client.permission.create(input)
+    },
+    event: {
+      subscribe: async () => ({ stream: client.event.subscribe() })
+    }
+  };
+}
+async function discoverPromptClient() {
+  let endpoint;
+  try {
+    endpoint = await discover();
+  } catch (error) {
+    return { unavailable: `looking up the local OpenCode service failed: ${detail2(error)}` };
+  }
+  if (!endpoint) {
+    return { unavailable: "no healthy, compatible local OpenCode service is registered" };
+  }
+  return { client: promptClient(endpoint) };
+}
+function createV2PromptChannel(discovery = discoverPromptClient) {
+  let cached;
+  return {
+    async client() {
+      if (cached)
+        return { client: cached };
+      const result = await discovery();
+      if (result.client)
+        cached = result.client;
+      return result;
+    }
+  };
+}
 
 // src/tools/hoisted/v2.ts
-function hoistedV2ToolConsumers(host) {
-  if (!("client" in host))
+function domainMethod(host, domain, method) {
+  const value = host[domain];
+  if (!value || typeof value !== "object")
+    return false;
+  return typeof value[method] === "function";
+}
+function hoistedV2ToolConsumers(host, prompt = createV2PromptChannel()) {
+  if (!domainMethod(host, "agent", "get") || !domainMethod(host, "session", "get"))
     return {};
   return {
-    requestPermission: (request, context) => requestPermission(host, request, context)
+    requestPermission: (request, context) => requestPermission(host, request, context, prompt)
   };
 }
 
 // src/wakes/runtime-consumer.ts
-import { Effect as Effect4 } from "effect";
+import { Effect as Effect5 } from "effect";
 
 // src/cancellation/effect-abort.ts
 function forwardEffectAbort(signal, send) {
@@ -45283,7 +47678,7 @@ async function executeV2Bash(execution) {
 }
 
 // src/wakes/session-delivery.ts
-import { Effect as Effect3 } from "effect";
+import { Effect as Effect4 } from "effect";
 
 class V2SessionDelivery {
   session;
@@ -45293,12 +47688,12 @@ class V2SessionDelivery {
     this.session = session;
   }
   completion(input) {
-    return Effect3.suspend(() => {
+    return Effect4.suspend(() => {
       if (this.disposed)
-        return Effect3.succeed(false);
+        return Effect4.succeed(false);
       const keys = [...new Set(input.taskIDs)].map((taskID) => `${input.sessionID}\x00${taskID}`);
       if (keys.length === 0 || keys.every((key) => this.admittedCompletions.has(key))) {
-        return Effect3.succeed(false);
+        return Effect4.succeed(false);
       }
       for (const key of keys)
         this.admittedCompletions.add(key);
@@ -45310,20 +47705,20 @@ class V2SessionDelivery {
           ...input.metadata,
           task_ids: [...new Set(input.taskIDs)]
         }
-      }).pipe(Effect3.map(() => true));
+      }).pipe(Effect4.map(() => true));
     });
   }
   status(input) {
-    return Effect3.suspend(() => {
+    return Effect4.suspend(() => {
       if (this.disposed)
-        return Effect3.succeed(undefined);
+        return Effect4.succeed(undefined);
       return this.session.synthetic({
         sessionID: input.sessionID,
         text: input.text,
         description: input.description,
         metadata: input.metadata,
         resume: false
-      }).pipe(Effect3.asVoid);
+      }).pipe(Effect4.asVoid);
     });
   }
   dispose() {
@@ -45340,7 +47735,7 @@ async function routeCompletion(completion, bridge) {
   const route = sessionRoutes.get(completion.session_id);
   if (!route)
     return;
-  const admitted = await Effect4.runPromise(route.delivery.completion({
+  const admitted = await Effect5.runPromise(route.delivery.completion({
     sessionID: completion.session_id,
     taskIDs: [completion.task_id],
     text: formatSystemReminder([completion]),
@@ -45362,7 +47757,7 @@ async function routeLongRunning(reminder, _bridge) {
   const route = sessionRoutes.get(reminder.session_id);
   if (!route)
     return;
-  await Effect4.runPromise(route.delivery.status({
+  await Effect5.runPromise(route.delivery.status({
     sessionID: reminder.session_id,
     text: formatLongRunningReminder([reminder]),
     description: "Background bash status",
@@ -45460,16 +47855,21 @@ function makeServerEffect(overrides = {}) {
   const dependencies = { ...defaults, ...overrides };
   return (context) => {
     const location = context.location;
-    return Effect5.gen(function* () {
-      const runtime = yield* Effect5.promise(() => bootLocation(context, location, dependencies));
+    if (typeof location?.directory !== "string") {
+      debug2("V2 effect skipped: host context has no location");
+      return Effect6.void;
+    }
+    log2("AFT V2 runtime starting");
+    return Effect6.gen(function* () {
+      const runtime = yield* Effect6.promise(() => bootLocation(context, location, dependencies));
       if (!runtime)
         return;
-      yield* Effect5.addFinalizer(() => Effect5.promise(async () => {
+      yield* Effect6.addFinalizer(() => Effect6.promise(async () => {
         runtime.consumers.dispose?.();
         await dependencies.releaseBridge(runtime.pool);
       }));
       const rpc = yield* dependencies.registerRpc(context, location, runtime.pool);
-      yield* Effect5.addFinalizer(() => Effect5.promise(() => rpc.dispose()));
+      yield* Effect6.addFinalizer(() => Effect6.promise(() => rpc.dispose()));
       yield* dependencies.registerTools(context, location, runtime.tools, runtime.consumers);
     });
   };