chatroom-cli 1.35.1 → 1.36.0

package/dist/index.js

@@ -10503,7 +10503,7 @@ class PiRpcReader {
 var init_pi_rpc_reader = () => {};
 
 // src/infrastructure/services/remote-agents/pi/pi-agent-service.ts
-var PI_COMMAND = "pi", DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.", PiAgentService;
+var PI_COMMAND = "pi", PiAgentService;
 var init_pi_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_pi_rpc_reader();
@@ -10549,8 +10549,7 @@ var init_pi_agent_service = __esm(() => {
       }
     }
     async spawn(options) {
-      const { systemPrompt, model } = options;
-      const prompt = options.prompt?.trim() ? options.prompt : DEFAULT_TRIGGER_PROMPT;
+      const { prompt, systemPrompt, model } = options;
       const args = ["--mode", "rpc", "--no-session"];
       if (model) {
         args.push("--model", model);
@@ -11040,7 +11039,7 @@ var init_copilot_stream_reader = __esm(() => {
 });
 
 // src/infrastructure/services/remote-agents/copilot/copilot-agent-service.ts
-var COPILOT_COMMAND = "copilot", DEFAULT_TRIGGER_PROMPT2 = "Please read your system prompt carefully and follow the Getting Started instructions.", CopilotAgentService;
+var COPILOT_COMMAND = "copilot", CopilotAgentService;
 var init_copilot_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_copilot_stream_reader();
@@ -11072,7 +11071,7 @@ var init_copilot_agent_service = __esm(() => {
       ];
     }
     async spawn(options) {
-      const prompt = options.prompt?.trim() ? options.prompt : DEFAULT_TRIGGER_PROMPT2;
+      const { prompt } = options;
       const args = ["-p"];
       args.push("--stream", "on");
       if (options.model) {
@@ -11228,7 +11227,7 @@ class ClaudeStreamReader {
 var init_claude_stream_reader = () => {};
 
 // src/infrastructure/services/remote-agents/claude/claude-code-agent-service.ts
-var DEFAULT_TRIGGER_PROMPT3 = "Please read your system prompt carefully and follow the Getting Started instructions.", CLAUDE_COMMAND = "claude", DEFAULT_MAX_TURNS = 200, ClaudeCodeAgentService;
+var CLAUDE_COMMAND = "claude", DEFAULT_MAX_TURNS = 200, ClaudeCodeAgentService;
 var init_claude_code_agent_service = __esm(() => {
   init_base_cli_agent_service();
   init_claude_stream_reader();
@@ -11249,8 +11248,7 @@ var init_claude_code_agent_service = __esm(() => {
       return ["claude-haiku-4-5", "claude-sonnet-4-6", "claude-opus-4-6"];
     }
     async spawn(options) {
-      const { systemPrompt, model } = options;
-      const prompt = options.prompt?.trim() ? options.prompt : DEFAULT_TRIGGER_PROMPT3;
+      const { prompt, systemPrompt, model } = options;
       const args = ["-p", "--output-format", "stream-json", "--verbose"];
       args.push("--max-turns", String(DEFAULT_MAX_TURNS));
       if (model) {
@@ -11380,11 +11378,2333 @@ var init_claude = __esm(() => {
   init_claude_code_agent_service();
 });
 
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/types.gen.js
+var init_types_gen = () => {};
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/core/serverSentEvents.gen.js
+var createSseClient = ({ onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+  let lastEventId;
+  const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const createStream = async function* () {
+    let retryDelay = sseDefaultRetryDelay ?? 3000;
+    let attempt = 0;
+    const signal = options.signal ?? new AbortController().signal;
+    while (true) {
+      if (signal.aborted)
+        break;
+      attempt++;
+      const headers = options.headers instanceof Headers ? options.headers : new Headers(options.headers);
+      if (lastEventId !== undefined) {
+        headers.set("Last-Event-ID", lastEventId);
+      }
+      try {
+        const response = await fetch(url, { ...options, headers, signal });
+        if (!response.ok)
+          throw new Error(`SSE failed: ${response.status} ${response.statusText}`);
+        if (!response.body)
+          throw new Error("No body in SSE response");
+        const reader = response.body.pipeThrough(new TextDecoderStream).getReader();
+        let buffer = "";
+        const abortHandler = () => {
+          try {
+            reader.cancel();
+          } catch {}
+        };
+        signal.addEventListener("abort", abortHandler);
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += value;
+            const chunks = buffer.split(`
+
+`);
+            buffer = chunks.pop() ?? "";
+            for (const chunk of chunks) {
+              const lines = chunk.split(`
+`);
+              const dataLines = [];
+              let eventName;
+              for (const line of lines) {
+                if (line.startsWith("data:")) {
+                  dataLines.push(line.replace(/^data:\s*/, ""));
+                } else if (line.startsWith("event:")) {
+                  eventName = line.replace(/^event:\s*/, "");
+                } else if (line.startsWith("id:")) {
+                  lastEventId = line.replace(/^id:\s*/, "");
+                } else if (line.startsWith("retry:")) {
+                  const parsed = Number.parseInt(line.replace(/^retry:\s*/, ""), 10);
+                  if (!Number.isNaN(parsed)) {
+                    retryDelay = parsed;
+                  }
+                }
+              }
+              let data;
+              let parsedJson = false;
+              if (dataLines.length) {
+                const rawData = dataLines.join(`
+`);
+                try {
+                  data = JSON.parse(rawData);
+                  parsedJson = true;
+                } catch {
+                  data = rawData;
+                }
+              }
+              if (parsedJson) {
+                if (responseValidator) {
+                  await responseValidator(data);
+                }
+                if (responseTransformer) {
+                  data = await responseTransformer(data);
+                }
+              }
+              onSseEvent?.({
+                data,
+                event: eventName,
+                id: lastEventId,
+                retry: retryDelay
+              });
+              if (dataLines.length) {
+                yield data;
+              }
+            }
+          }
+        } finally {
+          signal.removeEventListener("abort", abortHandler);
+          reader.releaseLock();
+        }
+        break;
+      } catch (error) {
+        onSseError?.(error);
+        if (sseMaxRetryAttempts !== undefined && attempt >= sseMaxRetryAttempts) {
+          break;
+        }
+        const backoff = Math.min(retryDelay * 2 ** (attempt - 1), sseMaxRetryDelay ?? 30000);
+        await sleep(backoff);
+      }
+    }
+  };
+  const stream = createStream();
+  return { stream };
+};
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/core/auth.gen.js
+var getAuthToken = async (auth, callback) => {
+  const token = typeof callback === "function" ? await callback(auth) : callback;
+  if (!token) {
+    return;
+  }
+  if (auth.scheme === "bearer") {
+    return `Bearer ${token}`;
+  }
+  if (auth.scheme === "basic") {
+    return `Basic ${btoa(token)}`;
+  }
+  return token;
+};
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/core/bodySerializer.gen.js
+var jsonBodySerializer;
+var init_bodySerializer_gen = __esm(() => {
+  jsonBodySerializer = {
+    bodySerializer: (body) => JSON.stringify(body, (_key, value) => typeof value === "bigint" ? value.toString() : value)
+  };
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/core/pathSerializer.gen.js
+var separatorArrayExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, separatorArrayNoExplode = (style) => {
+  switch (style) {
+    case "form":
+      return ",";
+    case "pipeDelimited":
+      return "|";
+    case "spaceDelimited":
+      return "%20";
+    default:
+      return ",";
+  }
+}, separatorObjectExplode = (style) => {
+  switch (style) {
+    case "label":
+      return ".";
+    case "matrix":
+      return ";";
+    case "simple":
+      return ",";
+    default:
+      return "&";
+  }
+}, serializeArrayParam = ({ allowReserved, explode, name, style, value }) => {
+  if (!explode) {
+    const joinedValues2 = (allowReserved ? value : value.map((v3) => encodeURIComponent(v3))).join(separatorArrayNoExplode(style));
+    switch (style) {
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      case "simple":
+        return joinedValues2;
+      default:
+        return `${name}=${joinedValues2}`;
+    }
+  }
+  const separator = separatorArrayExplode(style);
+  const joinedValues = value.map((v3) => {
+    if (style === "label" || style === "simple") {
+      return allowReserved ? v3 : encodeURIComponent(v3);
+    }
+    return serializePrimitiveParam({
+      allowReserved,
+      name,
+      value: v3
+    });
+  }).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+}, serializePrimitiveParam = ({ allowReserved, name, value }) => {
+  if (value === undefined || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+  }
+  return `${name}=${allowReserved ? value : encodeURIComponent(value)}`;
+}, serializeObjectParam = ({ allowReserved, explode, name, style, value, valueOnly }) => {
+  if (value instanceof Date) {
+    return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+  }
+  if (style !== "deepObject" && !explode) {
+    let values = [];
+    Object.entries(value).forEach(([key, v3]) => {
+      values = [...values, key, allowReserved ? v3 : encodeURIComponent(v3)];
+    });
+    const joinedValues2 = values.join(",");
+    switch (style) {
+      case "form":
+        return `${name}=${joinedValues2}`;
+      case "label":
+        return `.${joinedValues2}`;
+      case "matrix":
+        return `;${name}=${joinedValues2}`;
+      default:
+        return joinedValues2;
+    }
+  }
+  const separator = separatorObjectExplode(style);
+  const joinedValues = Object.entries(value).map(([key, v3]) => serializePrimitiveParam({
+    allowReserved,
+    name: style === "deepObject" ? `${name}[${key}]` : key,
+    value: v3
+  })).join(separator);
+  return style === "label" || style === "matrix" ? separator + joinedValues : joinedValues;
+};
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/core/utils.gen.js
+var PATH_PARAM_RE, defaultPathSerializer = ({ path, url: _url }) => {
+  let url = _url;
+  const matches = _url.match(PATH_PARAM_RE);
+  if (matches) {
+    for (const match of matches) {
+      let explode = false;
+      let name = match.substring(1, match.length - 1);
+      let style = "simple";
+      if (name.endsWith("*")) {
+        explode = true;
+        name = name.substring(0, name.length - 1);
+      }
+      if (name.startsWith(".")) {
+        name = name.substring(1);
+        style = "label";
+      } else if (name.startsWith(";")) {
+        name = name.substring(1);
+        style = "matrix";
+      }
+      const value = path[name];
+      if (value === undefined || value === null) {
+        continue;
+      }
+      if (Array.isArray(value)) {
+        url = url.replace(match, serializeArrayParam({ explode, name, style, value }));
+        continue;
+      }
+      if (typeof value === "object") {
+        url = url.replace(match, serializeObjectParam({
+          explode,
+          name,
+          style,
+          value,
+          valueOnly: true
+        }));
+        continue;
+      }
+      if (style === "matrix") {
+        url = url.replace(match, `;${serializePrimitiveParam({
+          name,
+          value
+        })}`);
+        continue;
+      }
+      const replaceValue = encodeURIComponent(style === "label" ? `.${value}` : value);
+      url = url.replace(match, replaceValue);
+    }
+  }
+  return url;
+}, getUrl = ({ baseUrl, path, query, querySerializer, url: _url }) => {
+  const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+  let url = (baseUrl ?? "") + pathUrl;
+  if (path) {
+    url = defaultPathSerializer({ path, url });
+  }
+  let search = query ? querySerializer(query) : "";
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    url += `?${search}`;
+  }
+  return url;
+};
+var init_utils_gen = __esm(() => {
+  PATH_PARAM_RE = /\{[^{}]+\}/g;
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/client/utils.gen.js
+class Interceptors {
+  _fns;
+  constructor() {
+    this._fns = [];
+  }
+  clear() {
+    this._fns = [];
+  }
+  getInterceptorIndex(id) {
+    if (typeof id === "number") {
+      return this._fns[id] ? id : -1;
+    } else {
+      return this._fns.indexOf(id);
+    }
+  }
+  exists(id) {
+    const index = this.getInterceptorIndex(id);
+    return !!this._fns[index];
+  }
+  eject(id) {
+    const index = this.getInterceptorIndex(id);
+    if (this._fns[index]) {
+      this._fns[index] = null;
+    }
+  }
+  update(id, fn) {
+    const index = this.getInterceptorIndex(id);
+    if (this._fns[index]) {
+      this._fns[index] = fn;
+      return id;
+    } else {
+      return false;
+    }
+  }
+  use(fn) {
+    this._fns = [...this._fns, fn];
+    return this._fns.length - 1;
+  }
+}
+var createQuerySerializer = ({ allowReserved, array, object } = {}) => {
+  const querySerializer = (queryParams) => {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === undefined || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          const serializedArray = serializeArrayParam({
+            allowReserved,
+            explode: true,
+            name,
+            style: "form",
+            value,
+            ...array
+          });
+          if (serializedArray)
+            search.push(serializedArray);
+        } else if (typeof value === "object") {
+          const serializedObject = serializeObjectParam({
+            allowReserved,
+            explode: true,
+            name,
+            style: "deepObject",
+            value,
+            ...object
+          });
+          if (serializedObject)
+            search.push(serializedObject);
+        } else {
+          const serializedPrimitive = serializePrimitiveParam({
+            allowReserved,
+            name,
+            value
+          });
+          if (serializedPrimitive)
+            search.push(serializedPrimitive);
+        }
+      }
+    }
+    return search.join("&");
+  };
+  return querySerializer;
+}, getParseAs = (contentType) => {
+  if (!contentType) {
+    return "stream";
+  }
+  const cleanContent = contentType.split(";")[0]?.trim();
+  if (!cleanContent) {
+    return;
+  }
+  if (cleanContent.startsWith("application/json") || cleanContent.endsWith("+json")) {
+    return "json";
+  }
+  if (cleanContent === "multipart/form-data") {
+    return "formData";
+  }
+  if (["application/", "audio/", "image/", "video/"].some((type) => cleanContent.startsWith(type))) {
+    return "blob";
+  }
+  if (cleanContent.startsWith("text/")) {
+    return "text";
+  }
+  return;
+}, checkForExistence = (options, name) => {
+  if (!name) {
+    return false;
+  }
+  if (options.headers.has(name) || options.query?.[name] || options.headers.get("Cookie")?.includes(`${name}=`)) {
+    return true;
+  }
+  return false;
+}, setAuthParams = async ({ security, ...options }) => {
+  for (const auth of security) {
+    if (checkForExistence(options, auth.name)) {
+      continue;
+    }
+    const token = await getAuthToken(auth, options.auth);
+    if (!token) {
+      continue;
+    }
+    const name = auth.name ?? "Authorization";
+    switch (auth.in) {
+      case "query":
+        if (!options.query) {
+          options.query = {};
+        }
+        options.query[name] = token;
+        break;
+      case "cookie":
+        options.headers.append("Cookie", `${name}=${token}`);
+        break;
+      case "header":
+      default:
+        options.headers.set(name, token);
+        break;
+    }
+  }
+}, buildUrl = (options) => getUrl({
+  baseUrl: options.baseUrl,
+  path: options.path,
+  query: options.query,
+  querySerializer: typeof options.querySerializer === "function" ? options.querySerializer : createQuerySerializer(options.querySerializer),
+  url: options.url
+}), mergeConfigs = (a, b) => {
+  const config = { ...a, ...b };
+  if (config.baseUrl?.endsWith("/")) {
+    config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+  }
+  config.headers = mergeHeaders(a.headers, b.headers);
+  return config;
+}, mergeHeaders = (...headers) => {
+  const mergedHeaders = new Headers;
+  for (const header of headers) {
+    if (!header || typeof header !== "object") {
+      continue;
+    }
+    const iterator = header instanceof Headers ? header.entries() : Object.entries(header);
+    for (const [key, value] of iterator) {
+      if (value === null) {
+        mergedHeaders.delete(key);
+      } else if (Array.isArray(value)) {
+        for (const v3 of value) {
+          mergedHeaders.append(key, v3);
+        }
+      } else if (value !== undefined) {
+        mergedHeaders.set(key, typeof value === "object" ? JSON.stringify(value) : value);
+      }
+    }
+  }
+  return mergedHeaders;
+}, createInterceptors = () => ({
+  error: new Interceptors,
+  request: new Interceptors,
+  response: new Interceptors
+}), defaultQuerySerializer, defaultHeaders, createConfig = (override = {}) => ({
+  ...jsonBodySerializer,
+  headers: defaultHeaders,
+  parseAs: "auto",
+  querySerializer: defaultQuerySerializer,
+  ...override
+});
+var init_utils_gen2 = __esm(() => {
+  init_bodySerializer_gen();
+  init_utils_gen();
+  defaultQuerySerializer = createQuerySerializer({
+    allowReserved: false,
+    array: {
+      explode: true,
+      style: "form"
+    },
+    object: {
+      explode: true,
+      style: "deepObject"
+    }
+  });
+  defaultHeaders = {
+    "Content-Type": "application/json"
+  };
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/client/client.gen.js
+var createClient = (config = {}) => {
+  let _config = mergeConfigs(createConfig(), config);
+  const getConfig = () => ({ ..._config });
+  const setConfig = (config2) => {
+    _config = mergeConfigs(_config, config2);
+    return getConfig();
+  };
+  const interceptors = createInterceptors();
+  const beforeRequest = async (options) => {
+    const opts = {
+      ..._config,
+      ...options,
+      fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+      headers: mergeHeaders(_config.headers, options.headers),
+      serializedBody: undefined
+    };
+    if (opts.security) {
+      await setAuthParams({
+        ...opts,
+        security: opts.security
+      });
+    }
+    if (opts.requestValidator) {
+      await opts.requestValidator(opts);
+    }
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+    if (opts.serializedBody === undefined || opts.serializedBody === "") {
+      opts.headers.delete("Content-Type");
+    }
+    const url = buildUrl(opts);
+    return { opts, url };
+  };
+  const request = async (options) => {
+    const { opts, url } = await beforeRequest(options);
+    const requestInit = {
+      redirect: "follow",
+      ...opts,
+      body: opts.serializedBody
+    };
+    let request2 = new Request(url, requestInit);
+    for (const fn of interceptors.request._fns) {
+      if (fn) {
+        request2 = await fn(request2, opts);
+      }
+    }
+    const _fetch = opts.fetch;
+    let response = await _fetch(request2);
+    for (const fn of interceptors.response._fns) {
+      if (fn) {
+        response = await fn(response, request2, opts);
+      }
+    }
+    const result = {
+      request: request2,
+      response
+    };
+    if (response.ok) {
+      if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+        return opts.responseStyle === "data" ? {} : {
+          data: {},
+          ...result
+        };
+      }
+      const parseAs = (opts.parseAs === "auto" ? getParseAs(response.headers.get("Content-Type")) : opts.parseAs) ?? "json";
+      let data;
+      switch (parseAs) {
+        case "arrayBuffer":
+        case "blob":
+        case "formData":
+        case "json":
+        case "text":
+          data = await response[parseAs]();
+          break;
+        case "stream":
+          return opts.responseStyle === "data" ? response.body : {
+            data: response.body,
+            ...result
+          };
+      }
+      if (parseAs === "json") {
+        if (opts.responseValidator) {
+          await opts.responseValidator(data);
+        }
+        if (opts.responseTransformer) {
+          data = await opts.responseTransformer(data);
+        }
+      }
+      return opts.responseStyle === "data" ? data : {
+        data,
+        ...result
+      };
+    }
+    const textError = await response.text();
+    let jsonError;
+    try {
+      jsonError = JSON.parse(textError);
+    } catch {}
+    const error = jsonError ?? textError;
+    let finalError = error;
+    for (const fn of interceptors.error._fns) {
+      if (fn) {
+        finalError = await fn(error, response, request2, opts);
+      }
+    }
+    finalError = finalError || {};
+    if (opts.throwOnError) {
+      throw finalError;
+    }
+    return opts.responseStyle === "data" ? undefined : {
+      error: finalError,
+      ...result
+    };
+  };
+  const makeMethod = (method) => {
+    const fn = (options) => request({ ...options, method });
+    fn.sse = async (options) => {
+      const { opts, url } = await beforeRequest(options);
+      return createSseClient({
+        ...opts,
+        body: opts.body,
+        headers: opts.headers,
+        method,
+        url
+      });
+    };
+    return fn;
+  };
+  return {
+    buildUrl,
+    connect: makeMethod("CONNECT"),
+    delete: makeMethod("DELETE"),
+    get: makeMethod("GET"),
+    getConfig,
+    head: makeMethod("HEAD"),
+    interceptors,
+    options: makeMethod("OPTIONS"),
+    patch: makeMethod("PATCH"),
+    post: makeMethod("POST"),
+    put: makeMethod("PUT"),
+    request,
+    setConfig,
+    trace: makeMethod("TRACE")
+  };
+};
+var init_client_gen = __esm(() => {
+  init_utils_gen2();
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/core/params.gen.js
+var extraPrefixesMap, extraPrefixes;
+var init_params_gen = __esm(() => {
+  extraPrefixesMap = {
+    $body_: "body",
+    $headers_: "headers",
+    $path_: "path",
+    $query_: "query"
+  };
+  extraPrefixes = Object.entries(extraPrefixesMap);
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/client/index.js
+var init_client3 = __esm(() => {
+  init_bodySerializer_gen();
+  init_params_gen();
+  init_client_gen();
+  init_utils_gen2();
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/client.gen.js
+var client2;
+var init_client_gen2 = __esm(() => {
+  init_client3();
+  client2 = createClient(createConfig({
+    baseUrl: "http://localhost:4096"
+  }));
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/gen/sdk.gen.js
+class _HeyApiClient {
+  _client = client2;
+  constructor(args) {
+    if (args?.client) {
+      this._client = args.client;
+    }
+  }
+}
+var Global, Project, Pty, Config, Tool, Instance, Path, Vcs, Session, Command2, Oauth, Provider, Find, File, App, Auth, Mcp, Lsp, Formatter, Control, Tui, Event, OpencodeClient;
+var init_sdk_gen = __esm(() => {
+  init_client_gen2();
+  Global = class Global extends _HeyApiClient {
+    event(options) {
+      return (options?.client ?? this._client).get.sse({
+        url: "/global/event",
+        ...options
+      });
+    }
+  };
+  Project = class Project extends _HeyApiClient {
+    list(options) {
+      return (options?.client ?? this._client).get({
+        url: "/project",
+        ...options
+      });
+    }
+    current(options) {
+      return (options?.client ?? this._client).get({
+        url: "/project/current",
+        ...options
+      });
+    }
+  };
+  Pty = class Pty extends _HeyApiClient {
+    list(options) {
+      return (options?.client ?? this._client).get({
+        url: "/pty",
+        ...options
+      });
+    }
+    create(options) {
+      return (options?.client ?? this._client).post({
+        url: "/pty",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    remove(options) {
+      return (options.client ?? this._client).delete({
+        url: "/pty/{id}",
+        ...options
+      });
+    }
+    get(options) {
+      return (options.client ?? this._client).get({
+        url: "/pty/{id}",
+        ...options
+      });
+    }
+    update(options) {
+      return (options.client ?? this._client).put({
+        url: "/pty/{id}",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    connect(options) {
+      return (options.client ?? this._client).get({
+        url: "/pty/{id}/connect",
+        ...options
+      });
+    }
+  };
+  Config = class Config extends _HeyApiClient {
+    get(options) {
+      return (options?.client ?? this._client).get({
+        url: "/config",
+        ...options
+      });
+    }
+    update(options) {
+      return (options?.client ?? this._client).patch({
+        url: "/config",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    providers(options) {
+      return (options?.client ?? this._client).get({
+        url: "/config/providers",
+        ...options
+      });
+    }
+  };
+  Tool = class Tool extends _HeyApiClient {
+    ids(options) {
+      return (options?.client ?? this._client).get({
+        url: "/experimental/tool/ids",
+        ...options
+      });
+    }
+    list(options) {
+      return (options.client ?? this._client).get({
+        url: "/experimental/tool",
+        ...options
+      });
+    }
+  };
+  Instance = class Instance extends _HeyApiClient {
+    dispose(options) {
+      return (options?.client ?? this._client).post({
+        url: "/instance/dispose",
+        ...options
+      });
+    }
+  };
+  Path = class Path extends _HeyApiClient {
+    get(options) {
+      return (options?.client ?? this._client).get({
+        url: "/path",
+        ...options
+      });
+    }
+  };
+  Vcs = class Vcs extends _HeyApiClient {
+    get(options) {
+      return (options?.client ?? this._client).get({
+        url: "/vcs",
+        ...options
+      });
+    }
+  };
+  Session = class Session extends _HeyApiClient {
+    list(options) {
+      return (options?.client ?? this._client).get({
+        url: "/session",
+        ...options
+      });
+    }
+    create(options) {
+      return (options?.client ?? this._client).post({
+        url: "/session",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    status(options) {
+      return (options?.client ?? this._client).get({
+        url: "/session/status",
+        ...options
+      });
+    }
+    delete(options) {
+      return (options.client ?? this._client).delete({
+        url: "/session/{id}",
+        ...options
+      });
+    }
+    get(options) {
+      return (options.client ?? this._client).get({
+        url: "/session/{id}",
+        ...options
+      });
+    }
+    update(options) {
+      return (options.client ?? this._client).patch({
+        url: "/session/{id}",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    children(options) {
+      return (options.client ?? this._client).get({
+        url: "/session/{id}/children",
+        ...options
+      });
+    }
+    todo(options) {
+      return (options.client ?? this._client).get({
+        url: "/session/{id}/todo",
+        ...options
+      });
+    }
+    init(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/init",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    fork(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/fork",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    abort(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/abort",
+        ...options
+      });
+    }
+    unshare(options) {
+      return (options.client ?? this._client).delete({
+        url: "/session/{id}/share",
+        ...options
+      });
+    }
+    share(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/share",
+        ...options
+      });
+    }
+    diff(options) {
+      return (options.client ?? this._client).get({
+        url: "/session/{id}/diff",
+        ...options
+      });
+    }
+    summarize(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/summarize",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    messages(options) {
+      return (options.client ?? this._client).get({
+        url: "/session/{id}/message",
+        ...options
+      });
+    }
+    prompt(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/message",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    message(options) {
+      return (options.client ?? this._client).get({
+        url: "/session/{id}/message/{messageID}",
+        ...options
+      });
+    }
+    promptAsync(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/prompt_async",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    command(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/command",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    shell(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/shell",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    revert(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/revert",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    unrevert(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/unrevert",
+        ...options
+      });
+    }
+  };
+  Command2 = class Command2 extends _HeyApiClient {
+    list(options) {
+      return (options?.client ?? this._client).get({
+        url: "/command",
+        ...options
+      });
+    }
+  };
+  Oauth = class Oauth extends _HeyApiClient {
+    authorize(options) {
+      return (options.client ?? this._client).post({
+        url: "/provider/{id}/oauth/authorize",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    callback(options) {
+      return (options.client ?? this._client).post({
+        url: "/provider/{id}/oauth/callback",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+  };
+  Provider = class Provider extends _HeyApiClient {
+    list(options) {
+      return (options?.client ?? this._client).get({
+        url: "/provider",
+        ...options
+      });
+    }
+    auth(options) {
+      return (options?.client ?? this._client).get({
+        url: "/provider/auth",
+        ...options
+      });
+    }
+    oauth = new Oauth({ client: this._client });
+  };
+  Find = class Find extends _HeyApiClient {
+    text(options) {
+      return (options.client ?? this._client).get({
+        url: "/find",
+        ...options
+      });
+    }
+    files(options) {
+      return (options.client ?? this._client).get({
+        url: "/find/file",
+        ...options
+      });
+    }
+    symbols(options) {
+      return (options.client ?? this._client).get({
+        url: "/find/symbol",
+        ...options
+      });
+    }
+  };
+  File = class File extends _HeyApiClient {
+    list(options) {
+      return (options.client ?? this._client).get({
+        url: "/file",
+        ...options
+      });
+    }
+    read(options) {
+      return (options.client ?? this._client).get({
+        url: "/file/content",
+        ...options
+      });
+    }
+    status(options) {
+      return (options?.client ?? this._client).get({
+        url: "/file/status",
+        ...options
+      });
+    }
+  };
+  App = class App extends _HeyApiClient {
+    log(options) {
+      return (options?.client ?? this._client).post({
+        url: "/log",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    agents(options) {
+      return (options?.client ?? this._client).get({
+        url: "/agent",
+        ...options
+      });
+    }
+  };
+  Auth = class Auth extends _HeyApiClient {
+    remove(options) {
+      return (options.client ?? this._client).delete({
+        url: "/mcp/{name}/auth",
+        ...options
+      });
+    }
+    start(options) {
+      return (options.client ?? this._client).post({
+        url: "/mcp/{name}/auth",
+        ...options
+      });
+    }
+    callback(options) {
+      return (options.client ?? this._client).post({
+        url: "/mcp/{name}/auth/callback",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    authenticate(options) {
+      return (options.client ?? this._client).post({
+        url: "/mcp/{name}/auth/authenticate",
+        ...options
+      });
+    }
+    set(options) {
+      return (options.client ?? this._client).put({
+        url: "/auth/{id}",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+  };
+  Mcp = class Mcp extends _HeyApiClient {
+    status(options) {
+      return (options?.client ?? this._client).get({
+        url: "/mcp",
+        ...options
+      });
+    }
+    add(options) {
+      return (options?.client ?? this._client).post({
+        url: "/mcp",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    connect(options) {
+      return (options.client ?? this._client).post({
+        url: "/mcp/{name}/connect",
+        ...options
+      });
+    }
+    disconnect(options) {
+      return (options.client ?? this._client).post({
+        url: "/mcp/{name}/disconnect",
+        ...options
+      });
+    }
+    auth = new Auth({ client: this._client });
+  };
+  Lsp = class Lsp extends _HeyApiClient {
+    status(options) {
+      return (options?.client ?? this._client).get({
+        url: "/lsp",
+        ...options
+      });
+    }
+  };
+  Formatter = class Formatter extends _HeyApiClient {
+    status(options) {
+      return (options?.client ?? this._client).get({
+        url: "/formatter",
+        ...options
+      });
+    }
+  };
+  Control = class Control extends _HeyApiClient {
+    next(options) {
+      return (options?.client ?? this._client).get({
+        url: "/tui/control/next",
+        ...options
+      });
+    }
+    response(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/control/response",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+  };
+  Tui = class Tui extends _HeyApiClient {
+    appendPrompt(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/append-prompt",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    openHelp(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/open-help",
+        ...options
+      });
+    }
+    openSessions(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/open-sessions",
+        ...options
+      });
+    }
+    openThemes(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/open-themes",
+        ...options
+      });
+    }
+    openModels(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/open-models",
+        ...options
+      });
+    }
+    submitPrompt(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/submit-prompt",
+        ...options
+      });
+    }
+    clearPrompt(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/clear-prompt",
+        ...options
+      });
+    }
+    executeCommand(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/execute-command",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    showToast(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/show-toast",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    publish(options) {
+      return (options?.client ?? this._client).post({
+        url: "/tui/publish",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options?.headers
+        }
+      });
+    }
+    control = new Control({ client: this._client });
+  };
+  Event = class Event extends _HeyApiClient {
+    subscribe(options) {
+      return (options?.client ?? this._client).get.sse({
+        url: "/event",
+        ...options
+      });
+    }
+  };
+  OpencodeClient = class OpencodeClient extends _HeyApiClient {
+    postSessionIdPermissionsPermissionId(options) {
+      return (options.client ?? this._client).post({
+        url: "/session/{id}/permissions/{permissionID}",
+        ...options,
+        headers: {
+          "Content-Type": "application/json",
+          ...options.headers
+        }
+      });
+    }
+    global = new Global({ client: this._client });
+    project = new Project({ client: this._client });
+    pty = new Pty({ client: this._client });
+    config = new Config({ client: this._client });
+    tool = new Tool({ client: this._client });
+    instance = new Instance({ client: this._client });
+    path = new Path({ client: this._client });
+    vcs = new Vcs({ client: this._client });
+    session = new Session({ client: this._client });
+    command = new Command2({ client: this._client });
+    provider = new Provider({ client: this._client });
+    find = new Find({ client: this._client });
+    file = new File({ client: this._client });
+    app = new App({ client: this._client });
+    mcp = new Mcp({ client: this._client });
+    lsp = new Lsp({ client: this._client });
+    formatter = new Formatter({ client: this._client });
+    tui = new Tui({ client: this._client });
+    auth = new Auth({ client: this._client });
+    event = new Event({ client: this._client });
+  };
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/client.js
+function pick(value, fallback) {
+  if (!value)
+    return;
+  if (!fallback)
+    return value;
+  if (value === fallback)
+    return fallback;
+  if (value === encodeURIComponent(fallback))
+    return fallback;
+  return value;
+}
+function rewrite(request, directory) {
+  if (request.method !== "GET" && request.method !== "HEAD")
+    return request;
+  const value = pick(request.headers.get("x-opencode-directory"), directory);
+  if (!value)
+    return request;
+  const url = new URL(request.url);
+  if (!url.searchParams.has("directory")) {
+    url.searchParams.set("directory", value);
+  }
+  const next = new Request(url, request);
+  next.headers.delete("x-opencode-directory");
+  return next;
+}
+function createOpencodeClient(config) {
+  if (!config?.fetch) {
+    const customFetch = (req) => {
+      req.timeout = false;
+      return fetch(req);
+    };
+    config = {
+      ...config,
+      fetch: customFetch
+    };
+  }
+  if (config?.directory) {
+    config.headers = {
+      ...config.headers,
+      "x-opencode-directory": encodeURIComponent(config.directory)
+    };
+  }
+  const client3 = createClient(config);
+  client3.interceptors.request.use((request) => rewrite(request, config?.directory));
+  return new OpencodeClient({ client: client3 });
+}
+var init_client4 = __esm(() => {
+  init_client_gen();
+  init_sdk_gen();
+  init_types_gen();
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function checkPathExt(path, options) {
+    var pathext = options.pathExt !== undefined ? options.pathExt : process.env.PATHEXT;
+    if (!pathext) {
+      return true;
+    }
+    pathext = pathext.split(";");
+    if (pathext.indexOf("") !== -1) {
+      return true;
+    }
+    for (var i2 = 0;i2 < pathext.length; i2++) {
+      var p = pathext[i2].toLowerCase();
+      if (p && path.substr(-p.length).toLowerCase() === p) {
+        return true;
+      }
+    }
+    return false;
+  }
+  function checkStat(stat, path, options) {
+    if (!stat.isSymbolicLink() && !stat.isFile()) {
+      return false;
+    }
+    return checkPathExt(path, options);
+  }
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, path, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), path, options);
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS((exports, module) => {
+  module.exports = isexe;
+  isexe.sync = sync;
+  var fs = __require("fs");
+  function isexe(path, options, cb) {
+    fs.stat(path, function(er, stat) {
+      cb(er, er ? false : checkStat(stat, options));
+    });
+  }
+  function sync(path, options) {
+    return checkStat(fs.statSync(path), options);
+  }
+  function checkStat(stat, options) {
+    return stat.isFile() && checkMode(stat, options);
+  }
+  function checkMode(stat, options) {
+    var mod = stat.mode;
+    var uid = stat.uid;
+    var gid = stat.gid;
+    var myUid = options.uid !== undefined ? options.uid : process.getuid && process.getuid();
+    var myGid = options.gid !== undefined ? options.gid : process.getgid && process.getgid();
+    var u = parseInt("100", 8);
+    var g = parseInt("010", 8);
+    var o = parseInt("001", 8);
+    var ug = u | g;
+    var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+    return ret;
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var core;
+  if (process.platform === "win32" || global.TESTING_WINDOWS) {
+    core = require_windows();
+  } else {
+    core = require_mode();
+  }
+  module.exports = isexe;
+  isexe.sync = sync;
+  function isexe(path, options, cb) {
+    if (typeof options === "function") {
+      cb = options;
+      options = {};
+    }
+    if (!cb) {
+      if (typeof Promise !== "function") {
+        throw new TypeError("callback not provided");
+      }
+      return new Promise(function(resolve, reject) {
+        isexe(path, options || {}, function(er, is) {
+          if (er) {
+            reject(er);
+          } else {
+            resolve(is);
+          }
+        });
+      });
+    }
+    core(path, options || {}, function(er, is) {
+      if (er) {
+        if (er.code === "EACCES" || options && options.ignoreErrors) {
+          er = null;
+          is = false;
+        }
+      }
+      cb(er, is);
+    });
+  }
+  function sync(path, options) {
+    try {
+      return core.sync(path, options || {});
+    } catch (er) {
+      if (options && options.ignoreErrors || er.code === "EACCES") {
+        return false;
+      } else {
+        throw er;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS((exports, module) => {
+  var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+  var path = __require("path");
+  var COLON = isWindows ? ";" : ":";
+  var isexe = require_isexe();
+  var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+  var getPathInfo = (cmd, opt) => {
+    const colon = opt.colon || COLON;
+    const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+      ...isWindows ? [process.cwd()] : [],
+      ...(opt.path || process.env.PATH || "").split(colon)
+    ];
+    const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+    const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+    if (isWindows) {
+      if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+        pathExt.unshift("");
+    }
+    return {
+      pathEnv,
+      pathExt,
+      pathExtExe
+    };
+  };
+  var which = (cmd, opt, cb) => {
+    if (typeof opt === "function") {
+      cb = opt;
+      opt = {};
+    }
+    if (!opt)
+      opt = {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    const step = (i2) => new Promise((resolve, reject) => {
+      if (i2 === pathEnv.length)
+        return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      resolve(subStep(p, i2, 0));
+    });
+    const subStep = (p, i2, ii) => new Promise((resolve, reject) => {
+      if (ii === pathExt.length)
+        return resolve(step(i2 + 1));
+      const ext = pathExt[ii];
+      isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+        if (!er && is) {
+          if (opt.all)
+            found.push(p + ext);
+          else
+            return resolve(p + ext);
+        }
+        return resolve(subStep(p, i2, ii + 1));
+      });
+    });
+    return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+  };
+  var whichSync = (cmd, opt) => {
+    opt = opt || {};
+    const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+    const found = [];
+    for (let i2 = 0;i2 < pathEnv.length; i2++) {
+      const ppRaw = pathEnv[i2];
+      const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+      const pCmd = path.join(pathPart, cmd);
+      const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+      for (let j = 0;j < pathExt.length; j++) {
+        const cur = p + pathExt[j];
+        try {
+          const is = isexe.sync(cur, { pathExt: pathExtExe });
+          if (is) {
+            if (opt.all)
+              found.push(cur);
+            else
+              return cur;
+          }
+        } catch (ex) {}
+      }
+    }
+    if (opt.all && found.length)
+      return found;
+    if (opt.nothrow)
+      return null;
+    throw getNotFoundError(cmd);
+  };
+  module.exports = which;
+  which.sync = whichSync;
+});
+
+// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS((exports, module) => {
+  var pathKey = (options = {}) => {
+    const environment = options.env || process.env;
+    const platform = options.platform || process.platform;
+    if (platform !== "win32") {
+      return "PATH";
+    }
+    return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+  };
+  module.exports = pathKey;
+  module.exports.default = pathKey;
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS((exports, module) => {
+  var path = __require("path");
+  var which = require_which();
+  var getPathKey = require_path_key();
+  function resolveCommandAttempt(parsed, withoutPathExt) {
+    const env = parsed.options.env || process.env;
+    const cwd = process.cwd();
+    const hasCustomCwd = parsed.options.cwd != null;
+    const shouldSwitchCwd = hasCustomCwd && process.chdir !== undefined && !process.chdir.disabled;
+    if (shouldSwitchCwd) {
+      try {
+        process.chdir(parsed.options.cwd);
+      } catch (err) {}
+    }
+    let resolved;
+    try {
+      resolved = which.sync(parsed.command, {
+        path: env[getPathKey({ env })],
+        pathExt: withoutPathExt ? path.delimiter : undefined
+      });
+    } catch (e) {} finally {
+      if (shouldSwitchCwd) {
+        process.chdir(cwd);
+      }
+    }
+    if (resolved) {
+      resolved = path.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+    }
+    return resolved;
+  }
+  function resolveCommand(parsed) {
+    return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+  }
+  module.exports = resolveCommand;
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS((exports, module) => {
+  var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+  function escapeCommand(arg) {
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    return arg;
+  }
+  function escapeArgument(arg, doubleEscapeMetaChars) {
+    arg = `${arg}`;
+    arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+    arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+    arg = `"${arg}"`;
+    arg = arg.replace(metaCharsRegExp, "^$1");
+    if (doubleEscapeMetaChars) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+    }
+    return arg;
+  }
+  exports.command = escapeCommand;
+  exports.argument = escapeArgument;
+});
+
+// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS((exports, module) => {
+  module.exports = /^#!(.*)/;
+});
+
+// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS((exports, module) => {
+  var shebangRegex = require_shebang_regex();
+  module.exports = (string = "") => {
+    const match = string.match(shebangRegex);
+    if (!match) {
+      return null;
+    }
+    const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+    const binary = path.split("/").pop();
+    if (binary === "env") {
+      return argument;
+    }
+    return argument ? `${binary} ${argument}` : binary;
+  };
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS((exports, module) => {
+  var fs = __require("fs");
+  var shebangCommand = require_shebang_command();
+  function readShebang(command) {
+    const size = 150;
+    const buffer = Buffer.alloc(size);
+    let fd;
+    try {
+      fd = fs.openSync(command, "r");
+      fs.readSync(fd, buffer, 0, size, 0);
+      fs.closeSync(fd);
+    } catch (e) {}
+    return shebangCommand(buffer.toString());
+  }
+  module.exports = readShebang;
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var path = __require("path");
+  var resolveCommand = require_resolveCommand();
+  var escape = require_escape();
+  var readShebang = require_readShebang();
+  var isWin = process.platform === "win32";
+  var isExecutableRegExp = /\.(?:com|exe)$/i;
+  var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+  function detectShebang(parsed) {
+    parsed.file = resolveCommand(parsed);
+    const shebang = parsed.file && readShebang(parsed.file);
+    if (shebang) {
+      parsed.args.unshift(parsed.file);
+      parsed.command = shebang;
+      return resolveCommand(parsed);
+    }
+    return parsed.file;
+  }
+  function parseNonShell(parsed) {
+    if (!isWin) {
+      return parsed;
+    }
+    const commandFile = detectShebang(parsed);
+    const needsShell = !isExecutableRegExp.test(commandFile);
+    if (parsed.options.forceShell || needsShell) {
+      const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+      parsed.command = path.normalize(parsed.command);
+      parsed.command = escape.command(parsed.command);
+      parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+      const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+      parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+      parsed.command = process.env.comspec || "cmd.exe";
+      parsed.options.windowsVerbatimArguments = true;
+    }
+    return parsed;
+  }
+  function parse(command, args, options) {
+    if (args && !Array.isArray(args)) {
+      options = args;
+      args = null;
+    }
+    args = args ? args.slice(0) : [];
+    options = Object.assign({}, options);
+    const parsed = {
+      command,
+      args,
+      options,
+      file: undefined,
+      original: {
+        command,
+        args
+      }
+    };
+    return options.shell ? parsed : parseNonShell(parsed);
+  }
+  module.exports = parse;
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS((exports, module) => {
+  var isWin = process.platform === "win32";
+  function notFoundError(original, syscall) {
+    return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+      code: "ENOENT",
+      errno: "ENOENT",
+      syscall: `${syscall} ${original.command}`,
+      path: original.command,
+      spawnargs: original.args
+    });
+  }
+  function hookChildProcess(cp, parsed) {
+    if (!isWin) {
+      return;
+    }
+    const originalEmit = cp.emit;
+    cp.emit = function(name, arg1) {
+      if (name === "exit") {
+        const err = verifyENOENT(arg1, parsed);
+        if (err) {
+          return originalEmit.call(cp, "error", err);
+        }
+      }
+      return originalEmit.apply(cp, arguments);
+    };
+  }
+  function verifyENOENT(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawn");
+    }
+    return null;
+  }
+  function verifyENOENTSync(status, parsed) {
+    if (isWin && status === 1 && !parsed.file) {
+      return notFoundError(parsed.original, "spawnSync");
+    }
+    return null;
+  }
+  module.exports = {
+    hookChildProcess,
+    verifyENOENT,
+    verifyENOENTSync,
+    notFoundError
+  };
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS((exports, module) => {
+  var cp = __require("child_process");
+  var parse = require_parse();
+  var enoent = require_enoent();
+  function spawn2(command, args, options) {
+    const parsed = parse(command, args, options);
+    const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+    enoent.hookChildProcess(spawned, parsed);
+    return spawned;
+  }
+  function spawnSync(command, args, options) {
+    const parsed = parse(command, args, options);
+    const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+    result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+    return result;
+  }
+  module.exports = spawn2;
+  module.exports.spawn = spawn2;
+  module.exports.sync = spawnSync;
+  module.exports._parse = parse;
+  module.exports._enoent = enoent;
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/process.js
+var init_process = () => {};
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/server.js
+var import_cross_spawn;
+var init_server2 = __esm(() => {
+  init_process();
+  import_cross_spawn = __toESM(require_cross_spawn(), 1);
+});
+
+// ../../node_modules/.pnpm/@opencode-ai+sdk@1.14.22/node_modules/@opencode-ai/sdk/dist/index.js
+var init_dist = __esm(() => {
+  init_client4();
+  init_server2();
+  init_client4();
+  init_server2();
+});
+
+// src/infrastructure/services/remote-agents/opencode-sdk/select-agent.ts
+function selectAgent(agents) {
+  const primaries = agents.filter((a) => a.mode !== "subagent");
+  if (primaries.length === 0) {
+    throw new Error("No usable opencode agent available (server returned 0 non-subagent agents)");
+  }
+  const buildAgent = primaries.find((a) => a.name === "build");
+  return buildAgent ?? primaries[0];
+}
+
+// src/infrastructure/services/remote-agents/opencode-sdk/compose-system-prompt.ts
+function composeSystemPrompt(agentPrompt, chatroomSystemPrompt) {
+  const trimmedAgent = agentPrompt?.trim() ?? "";
+  const trimmedChatroom = chatroomSystemPrompt.trim();
+  if (!trimmedAgent && !trimmedChatroom) {
+    return;
+  }
+  if (!trimmedAgent) {
+    return trimmedChatroom;
+  }
+  if (!trimmedChatroom) {
+    return trimmedAgent;
+  }
+  return `${trimmedAgent}${CHATROOM_PROMPT_SEPARATOR}${trimmedChatroom}`;
+}
+var CHATROOM_PROMPT_SEPARATOR = `
+
+# Chatroom Role & Instructions (Important)
+
+`;
+
+// src/infrastructure/services/remote-agents/opencode-sdk/parse-listening-url.ts
+async function waitForListeningUrl(child, options) {
+  return new Promise((resolve, reject) => {
+    const buffers = { stdout: "", stderr: "" };
+    const cleanup = () => {
+      clearTimeout(timer);
+      child.stdout?.removeListener("data", onStdout);
+      child.stderr?.removeListener("data", onStderr);
+      child.removeListener("exit", onExit);
+    };
+    const tryMatch = (key, chunk) => {
+      buffers[key] += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      const match = buffers[key].match(LISTENING_URL_RE);
+      if (match) {
+        cleanup();
+        resolve(match[1]);
+        return;
+      }
+      const lastNl = buffers[key].lastIndexOf(`
+`);
+      if (lastNl >= 0) {
+        buffers[key] = buffers[key].slice(lastNl + 1);
+      }
+    };
+    const onStdout = (chunk) => tryMatch("stdout", chunk);
+    const onStderr = (chunk) => tryMatch("stderr", chunk);
+    const onExit = (code2, signal) => {
+      cleanup();
+      reject(new Error(`opencode serve exited unexpectedly during startup (code=${code2}, signal=${signal})`));
+    };
+    child.stdout?.on("data", onStdout);
+    child.stderr?.on("data", onStderr);
+    child.on("exit", onExit);
+    const timer = setTimeout(() => {
+      cleanup();
+      reject(new Error(`opencode serve did not print a listening URL within ${options.timeoutMs}ms`));
+    }, options.timeoutMs);
+  });
+}
+var LISTENING_URL_RE;
+var init_parse_listening_url = __esm(() => {
+  LISTENING_URL_RE = /opencode server listening on (https?:\/\/127\.0\.0\.1:\d+(?:\/[^\s]*)?)/;
+});
+
+// src/infrastructure/services/remote-agents/opencode-sdk/session-metadata-store.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import { dirname as dirname2, join as join3 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+
+class FileSessionMetadataStore {
+  filePath;
+  constructor(filePath) {
+    this.filePath = filePath ?? join3(homedir2(), ".chatroom", "opencode-sdk-sessions.json");
+  }
+  load() {
+    try {
+      if (existsSync2(this.filePath)) {
+        return JSON.parse(readFileSync3(this.filePath, "utf-8"));
+      }
+    } catch {}
+    return {};
+  }
+  save(sessions) {
+    try {
+      const dir = dirname2(this.filePath);
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+      writeFileSync2(this.filePath, JSON.stringify(sessions, null, 2));
+    } catch {}
+  }
+  get(sessionId) {
+    return this.load()[sessionId];
+  }
+  findByPid(pid) {
+    const sessions = this.load();
+    return Object.values(sessions).find((m) => m.pid === pid);
+  }
+  upsert(meta) {
+    const sessions = this.load();
+    sessions[meta.sessionId] = meta;
+    this.save(sessions);
+  }
+  remove(sessionId) {
+    const sessions = this.load();
+    delete sessions[sessionId];
+    this.save(sessions);
+  }
+}
+var init_session_metadata_store = () => {};
+
+// src/infrastructure/services/remote-agents/opencode-sdk/node-streams.ts
+function forwardFiltered(source, target, shouldDrop) {
+  if (!source)
+    return;
+  let buf = "";
+  source.on("data", (chunk) => {
+    buf += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+    let nl;
+    while ((nl = buf.indexOf(`
+`)) !== -1) {
+      const line = buf.slice(0, nl);
+      buf = buf.slice(nl + 1);
+      if (!shouldDrop(line))
+        target.write(line + `
+`);
+    }
+  });
+  source.on("end", () => {
+    if (buf.length > 0 && !shouldDrop(buf))
+      target.write(buf);
+    buf = "";
+  });
+}
+
+// src/infrastructure/services/remote-agents/opencode-sdk/pure.ts
+function parseModelId(model) {
+  if (!model)
+    return;
+  const slashIdx = model.indexOf("/");
+  if (slashIdx === -1)
+    return;
+  const providerID = model.substring(0, slashIdx);
+  const modelID = model.substring(slashIdx + 1);
+  if (!providerID || !modelID)
+    return;
+  return { providerID, modelID };
+}
+var isInfoLine = (line) => line.trimStart().startsWith("INFO ");
+
+// src/infrastructure/services/remote-agents/opencode-sdk/session-event-forwarder.ts
+function formatLogLine(options, kind, payload) {
+  const ts = options.now ? options.now() : new Date().toISOString();
+  return `[${ts}] role:${options.role} ${kind}]${payload ? ` ${payload}` : ""}`;
+}
+function eventSessionId(event) {
+  const p = event.properties;
+  if (!p || typeof p !== "object")
+    return;
+  if ("sessionID" in p && typeof p.sessionID === "string")
+    return p.sessionID;
+  if ("part" in p && p.part && typeof p.part === "object") {
+    return p.part.sessionID;
+  }
+  if ("info" in p && p.info && typeof p.info === "object") {
+    return p.info.sessionID;
+  }
+  return;
+}
+function startSessionEventForwarder(client4, options) {
+  const target = options.target ?? process.stdout;
+  const errorTarget = options.errorTarget ?? process.stderr;
+  let cancelled = false;
+  let doneResolve;
+  const donePromise = new Promise((resolve) => {
+    doneResolve = resolve;
+  });
+  async function run() {
+    try {
+      const result = await client4.event.subscribe();
+      const stream = result.stream;
+      if (cancelled) {
+        await stream.return?.(undefined);
+        return;
+      }
+      for await (const event of stream) {
+        if (cancelled) {
+          await stream.return?.(undefined);
+          break;
+        }
+        const eventSession = eventSessionId(event);
+        if (eventSession && eventSession !== options.sessionId)
+          continue;
+        if (eventSession === undefined && event.type !== "session.idle" && event.type !== "session.compacted" && event.type !== "session.error" && event.type !== "session.status" && event.type !== "file.edited")
+          continue;
+        switch (event.type) {
+          case "message.part.updated": {
+            const props = event.properties;
+            const part = props?.part;
+            if (part?.type === "text" && part.delta) {
+              target.write(formatLogLine(options, "text", part.delta) + `
+`);
+            } else if (part?.type === "tool" && part.tool) {
+              const state = props?.state ?? "started";
+              target.write(formatLogLine(options, "tool: " + part.tool, state) + `
+`);
+            }
+            break;
+          }
+          case "file.edited": {
+            const props = event.properties;
+            target.write(formatLogLine(options, "file", props?.file) + `
+`);
+            break;
+          }
+          case "session.idle": {
+            target.write(formatLogLine(options, "agent_end") + `
+`);
+            break;
+          }
+          case "session.compacted": {
+            target.write(formatLogLine(options, "compacted") + `
+`);
+            break;
+          }
+          case "session.status": {
+            const props = event.properties;
+            target.write(formatLogLine(options, "status", props?.status?.type) + `
+`);
+            break;
+          }
+          case "session.error": {
+            const props = event.properties;
+            const err = props?.error;
+            const errMsg = err?.name ? `${err.name}${err?.data?.message ? ": " + err.data.message : ""}` : String(err ?? "unknown");
+            errorTarget.write(formatLogLine(options, "error", errMsg) + `
+`);
+            break;
+          }
+          default:
+            break;
+        }
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      errorTarget.write(formatLogLine(options, "error", message) + `
+`);
+    } finally {
+      doneResolve();
+    }
+  }
+  run();
+  return {
+    stop: () => {
+      cancelled = true;
+    },
+    done: donePromise
+  };
+}
+
+// src/infrastructure/services/remote-agents/opencode-sdk/opencode-sdk-agent-service.ts
+async function withTimeout(p, ms, label) {
+  let timer;
+  try {
+    return await Promise.race([
+      p,
+      new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+      })
+    ]);
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+var OPENCODE_COMMAND2 = "opencode", SERVE_STARTUP_TIMEOUT_MS = 1e4, SESSION_CREATE_TIMEOUT_MS = 30000, PROMPT_ASYNC_TIMEOUT_MS = 60000, SESSION_ABORT_TIMEOUT_MS = 5000, AGENTS_LIST_TIMEOUT_MS = 1e4, OpenCodeSdkAgentService;
+var init_opencode_sdk_agent_service = __esm(() => {
+  init_dist();
+  init_base_cli_agent_service();
+  init_parse_listening_url();
+  init_session_metadata_store();
+  OpenCodeSdkAgentService = class OpenCodeSdkAgentService extends BaseCLIAgentService {
+    id = "opencode-sdk";
+    displayName = "OpenCode (SDK)";
+    command = OPENCODE_COMMAND2;
+    sessionStore;
+    forwarders = new Map;
+    constructor(deps) {
+      super(deps);
+      this.sessionStore = deps?.sessionMetadataStore ?? new FileSessionMetadataStore;
+    }
+    isInstalled() {
+      return this.checkInstalled(OPENCODE_COMMAND2);
+    }
+    getVersion() {
+      return this.checkVersion(OPENCODE_COMMAND2);
+    }
+    async listModels() {
+      try {
+        const output = this.deps.execSync(`${OPENCODE_COMMAND2} models`, {
+          stdio: ["pipe", "pipe", "pipe"],
+          timeout: 1e4
+        }).toString().trim();
+        if (!output)
+          return [];
+        return output.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0);
+      } catch {
+        return [];
+      }
+    }
+    async stop(pid) {
+      const forwarder = this.forwarders.get(pid);
+      if (forwarder) {
+        forwarder.stop();
+        this.forwarders.delete(pid);
+      }
+      const meta = this.sessionStore.findByPid(pid);
+      if (meta) {
+        try {
+          const client4 = createOpencodeClient({ baseUrl: meta.baseUrl });
+          await withTimeout(client4.session.abort({ path: { id: meta.sessionId } }), SESSION_ABORT_TIMEOUT_MS, "session.abort");
+        } catch (err) {
+          console.warn(`[opencode-sdk] session.abort for pid=${pid} sessionId=${meta.sessionId} failed (continuing with SIGTERM):`, err instanceof Error ? err.message : err);
+        }
+      }
+      await super.stop(pid);
+    }
+    async spawn(options) {
+      const { prompt, systemPrompt, model, context } = options;
+      const childProcess = this.deps.spawn(OPENCODE_COMMAND2, ["serve", "--print-logs"], {
+        cwd: options.workingDir,
+        stdio: ["pipe", "pipe", "pipe"],
+        shell: false,
+        detached: true,
+        env: {
+          ...process.env,
+          GIT_EDITOR: "true",
+          GIT_SEQUENCE_EDITOR: "true"
+        }
+      });
+      if (!childProcess.pid) {
+        throw new Error("Failed to spawn opencode serve process");
+      }
+      const pid = childProcess.pid;
+      const baseUrl = await waitForListeningUrl(childProcess, {
+        timeoutMs: SERVE_STARTUP_TIMEOUT_MS
+      }).catch((err) => {
+        childProcess.kill();
+        throw err;
+      });
+      const client4 = createOpencodeClient({
+        baseUrl
+      });
+      let sessionId;
+      let forwarder;
+      try {
+        const sessionCreateResult = await withTimeout(client4.session.create({ body: {} }), SESSION_CREATE_TIMEOUT_MS, "session.create");
+        if (!sessionCreateResult.data?.id) {
+          throw new Error("Failed to create session");
+        }
+        sessionId = sessionCreateResult.data.id;
+        forwarder = startSessionEventForwarder(client4, {
+          sessionId,
+          role: context.role
+        });
+        const agentsResponse = await withTimeout(client4.app.agents(), AGENTS_LIST_TIMEOUT_MS, "app.agents");
+        const availableAgents = agentsResponse.data ?? [];
+        const selected = selectAgent(availableAgents);
+        const composedSystem = composeSystemPrompt(selected.prompt, systemPrompt);
+        const modelParts = model ? parseModelId(model) : undefined;
+        await withTimeout(client4.session.promptAsync({
+          path: { id: sessionId },
+          body: {
+            agent: selected.name,
+            ...composedSystem ? { system: composedSystem } : {},
+            parts: [{ type: "text", text: prompt }],
+            ...modelParts ? { model: modelParts } : {}
+          }
+        }), PROMPT_ASYNC_TIMEOUT_MS, "session.promptAsync");
+      } catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        process.stderr.write(`[${new Date().toISOString()}] role:${context.role} spawn-error] ${reason}
+`);
+        forwarder?.stop();
+        childProcess.kill();
+        if (sessionId)
+          this.sessionStore.remove(sessionId);
+        throw err;
+      }
+      const meta = {
+        sessionId,
+        machineId: context.machineId,
+        chatroomId: context.chatroomId,
+        role: context.role,
+        pid,
+        createdAt: new Date().toISOString(),
+        baseUrl
+      };
+      this.sessionStore.upsert(meta);
+      const entry = this.registerProcess(pid, context);
+      if (forwarder)
+        this.forwarders.set(pid, forwarder);
+      const outputCallbacks = [];
+      forwardFiltered(childProcess.stdout, process.stdout, isInfoLine);
+      forwardFiltered(childProcess.stderr, process.stderr, isInfoLine);
+      if (childProcess.stdout) {
+        childProcess.stdout.on("data", () => {
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+      }
+      if (childProcess.stderr) {
+        childProcess.stderr.on("data", () => {
+          entry.lastOutputAt = Date.now();
+          for (const cb of outputCallbacks)
+            cb();
+        });
+      }
+      return {
+        pid,
+        onExit: (cb) => {
+          childProcess.on("exit", (code2, signal) => {
+            const fwd = this.forwarders.get(pid);
+            if (fwd) {
+              fwd.stop();
+              this.forwarders.delete(pid);
+            }
+            this.sessionStore.remove(sessionId);
+            this.deleteProcess(pid);
+            cb({ code: code2, signal, context });
+          });
+        },
+        onOutput: (cb) => {
+          outputCallbacks.push(cb);
+        }
+      };
+    }
+  };
+});
+
+// src/infrastructure/services/remote-agents/opencode-sdk/index.ts
+var init_opencode_sdk = __esm(() => {
+  init_opencode_sdk_agent_service();
+});
+
 // src/infrastructure/services/remote-agents/init-registry.ts
 function initHarnessRegistry() {
   if (initialized)
     return;
   registerHarness(new OpenCodeAgentService);
+  registerHarness(new OpenCodeSdkAgentService);
   registerHarness(new PiAgentService);
   registerHarness(new CursorAgentService);
   registerHarness(new ClaudeCodeAgentService);
@@ -11397,6 +13717,7 @@ var init_init_registry = __esm(() => {
   init_copilot();
   init_cursor();
   init_opencode();
+  init_opencode_sdk();
   init_pi();
   init_registry();
 });
@@ -11442,28 +13763,28 @@ var MACHINE_CONFIG_VERSION = "1";
 
 // src/infrastructure/machine/storage.ts
 import { randomUUID } from "node:crypto";
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "node:fs";
-import { homedir as homedir2, hostname as hostname2 } from "node:os";
-import { join as join3 } from "node:path";
+import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync } from "node:fs";
+import { homedir as homedir3, hostname as hostname2 } from "node:os";
+import { join as join4 } from "node:path";
 function chatroomConfigDir() {
-  return join3(homedir2(), ".chatroom");
+  return join4(homedir3(), ".chatroom");
 }
 function ensureConfigDir2() {
   const dir = chatroomConfigDir();
-  if (!existsSync2(dir)) {
-    mkdirSync2(dir, { recursive: true, mode: 448 });
+  if (!existsSync3(dir)) {
+    mkdirSync3(dir, { recursive: true, mode: 448 });
   }
 }
 function getMachineConfigPath() {
-  return join3(chatroomConfigDir(), MACHINE_FILE);
+  return join4(chatroomConfigDir(), MACHINE_FILE);
 }
 function loadConfigFile() {
   const configPath = getMachineConfigPath();
-  if (!existsSync2(configPath)) {
+  if (!existsSync3(configPath)) {
     return null;
   }
   try {
-    const content = readFileSync3(configPath, "utf-8");
+    const content = readFileSync4(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error) {
     console.warn(`⚠️  Failed to read machine config at ${configPath}: ${error.message}`);
@@ -11477,7 +13798,7 @@ function saveConfigFile(configFile) {
   const configPath = getMachineConfigPath();
   const tempPath = `${configPath}.tmp`;
   const content = JSON.stringify(configFile, null, 2);
-  writeFileSync2(tempPath, content, { encoding: "utf-8", mode: 384 });
+  writeFileSync3(tempPath, content, { encoding: "utf-8", mode: 384 });
   renameSync(tempPath, configPath);
 }
 function loadMachineConfig() {
@@ -11545,27 +13866,27 @@ var init_storage2 = __esm(() => {
 });
 
 // src/infrastructure/machine/daemon-state.ts
-import { existsSync as existsSync3, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync as renameSync2 } from "node:fs";
-import { homedir as homedir3 } from "node:os";
-import { join as join4 } from "node:path";
+import { existsSync as existsSync4, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync4, renameSync as renameSync2 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { join as join5 } from "node:path";
 function agentKey(chatroomId, role) {
   return `${chatroomId}/${role}`;
 }
 function ensureStateDir() {
-  if (!existsSync3(STATE_DIR)) {
-    mkdirSync3(STATE_DIR, { recursive: true, mode: 448 });
+  if (!existsSync4(STATE_DIR)) {
+    mkdirSync4(STATE_DIR, { recursive: true, mode: 448 });
   }
 }
 function stateFilePath(machineId) {
-  return join4(STATE_DIR, `${machineId}.json`);
+  return join5(STATE_DIR, `${machineId}.json`);
 }
 function loadDaemonState(machineId) {
   const filePath = stateFilePath(machineId);
-  if (!existsSync3(filePath)) {
+  if (!existsSync4(filePath)) {
     return null;
   }
   try {
-    const content = readFileSync4(filePath, "utf-8");
+    const content = readFileSync5(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -11576,7 +13897,7 @@ function saveDaemonState(state) {
   const filePath = stateFilePath(state.machineId);
   const tempPath = `${filePath}.tmp`;
   const content = JSON.stringify(state, null, 2);
-  writeFileSync3(tempPath, content, { encoding: "utf-8", mode: 384 });
+  writeFileSync4(tempPath, content, { encoding: "utf-8", mode: 384 });
   renameSync2(tempPath, filePath);
 }
 function loadOrCreate(machineId) {
@@ -11639,8 +13960,8 @@ function loadEventCursor(machineId) {
 }
 var CHATROOM_DIR2, STATE_DIR, STATE_VERSION = "1";
 var init_daemon_state = __esm(() => {
-  CHATROOM_DIR2 = join4(homedir3(), ".chatroom");
-  STATE_DIR = join4(CHATROOM_DIR2, "machines", "state");
+  CHATROOM_DIR2 = join5(homedir4(), ".chatroom");
+  STATE_DIR = join5(CHATROOM_DIR2, "machines", "state");
 });
 
 // src/infrastructure/machine/index.ts
@@ -11679,10 +14000,10 @@ __export(exports_auth_status, {
   authStatus: () => authStatus
 });
 async function createDefaultDeps3() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      query: (endpoint, args) => client2.query(endpoint, args)
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       loadAuthData,
@@ -12001,9 +14322,9 @@ var init_init = __esm(() => {
 });
 
 // src/tools/output.ts
-import { join as join5 } from "node:path";
+import { join as join6 } from "node:path";
 function resolveChatroomDir(workingDir) {
-  return join5(workingDir, CHATROOM_DIR3);
+  return join6(workingDir, CHATROOM_DIR3);
 }
 async function ensureChatroomDir(deps, workingDir) {
   const dir = resolveChatroomDir(workingDir);
@@ -12011,7 +14332,7 @@ async function ensureChatroomDir(deps, workingDir) {
   return dir;
 }
 async function ensureGitignore(deps, workingDir) {
-  const gitignorePath = join5(workingDir, ".gitignore");
+  const gitignorePath = join6(workingDir, ".gitignore");
   const entry = CHATROOM_DIR3;
   let content = "";
   try {
@@ -12041,7 +14362,7 @@ function formatOutputTimestamp(date = new Date) {
 function generateOutputPath(workingDir, toolName, extension, date) {
   const timestamp = formatOutputTimestamp(date);
   const filename = `${toolName}-${timestamp}.${extension}`;
-  return join5(resolveChatroomDir(workingDir), filename);
+  return join6(resolveChatroomDir(workingDir), filename);
 }
 var CHATROOM_DIR3 = ".chatroom";
 var init_output = () => {};
@@ -18055,7 +20376,7 @@ var require_filesystem = __commonJS((exports, module) => {
   var LDD_PATH = "/usr/bin/ldd";
   var SELF_PATH = "/proc/self/exe";
   var MAX_LENGTH = 2048;
-  var readFileSync5 = (path2) => {
+  var readFileSync6 = (path2) => {
     const fd = fs.openSync(path2, "r");
     const buffer = Buffer.alloc(MAX_LENGTH);
     const bytesRead = fs.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -18078,7 +20399,7 @@ var require_filesystem = __commonJS((exports, module) => {
   module.exports = {
     LDD_PATH,
     SELF_PATH,
-    readFileSync: readFileSync5,
+    readFileSync: readFileSync6,
     readFile
   };
 });
@@ -18121,7 +20442,7 @@ var require_elf = __commonJS((exports, module) => {
 var require_detect_libc = __commonJS((exports, module) => {
   var childProcess = __require("child_process");
   var { isLinux, getReport } = require_process();
-  var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync5 } = require_filesystem();
+  var { LDD_PATH, SELF_PATH, readFile, readFileSync: readFileSync6 } = require_filesystem();
   var { interpreterPath } = require_elf();
   var cachedFamilyInterpreter;
   var cachedFamilyFilesystem;
@@ -18212,7 +20533,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyFilesystem = null;
     try {
-      const lddContent = readFileSync5(LDD_PATH);
+      const lddContent = readFileSync6(LDD_PATH);
       cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
     } catch (e) {}
     return cachedFamilyFilesystem;
@@ -18235,7 +20556,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedFamilyInterpreter = null;
     try {
-      const selfContent = readFileSync5(SELF_PATH);
+      const selfContent = readFileSync6(SELF_PATH);
       const path2 = interpreterPath(selfContent);
       cachedFamilyInterpreter = familyFromInterpreterPath(path2);
     } catch (e) {}
@@ -18297,7 +20618,7 @@ var require_detect_libc = __commonJS((exports, module) => {
     }
     cachedVersionFilesystem = null;
     try {
-      const lddContent = readFileSync5(LDD_PATH);
+      const lddContent = readFileSync6(LDD_PATH);
       const versionMatch = lddContent.match(RE_GLIBC_VERSION);
       if (versionMatch) {
         cachedVersionFilesystem = versionMatch[1];
@@ -18790,7 +21111,7 @@ var require_semver = __commonJS((exports, module) => {
 });
 
 // ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/parse.js
-var require_parse = __commonJS((exports, module) => {
+var require_parse2 = __commonJS((exports, module) => {
   var SemVer = require_semver();
   var parse = (version2, options, throwErrors = false) => {
     if (version2 instanceof SemVer) {
@@ -18811,7 +21132,7 @@ var require_parse = __commonJS((exports, module) => {
 // ../../node_modules/.pnpm/semver@7.7.4/node_modules/semver/functions/coerce.js
 var require_coerce = __commonJS((exports, module) => {
   var SemVer = require_semver();
-  var parse = require_parse();
+  var parse = require_parse2();
   var { safeRe: re, t } = require_re();
   var coerce = (version2, options) => {
     if (version2 instanceof SemVer) {
@@ -24493,11 +26814,11 @@ var init_pdfium_renderer = __esm(() => {
 
 // ../../node_modules/.pnpm/@llamaindex+liteparse@1.4.6/node_modules/@llamaindex/liteparse/dist/src/engines/pdf/pdfjsImporter.js
 import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { dirname as dirname2 } from "node:path";
+import { dirname as dirname3 } from "node:path";
 async function importPdfJs() {
   const pdfUrl = new URL("../../vendor/pdfjs/pdf.mjs", import.meta.url);
   const pdfjs = await import(pdfUrl.href);
-  const dirPath = dirname2(fileURLToPath2(pdfUrl));
+  const dirPath = dirname3(fileURLToPath2(pdfUrl));
   return {
     fn: pdfjs.getDocument,
     dir: dirPath
@@ -27997,11 +30318,11 @@ var require_lib3 = __commonJS((exports, module) => {
   }
   var MAP = Symbol("map");
 
-  class Headers {
+  class Headers2 {
     constructor() {
       let init2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : undefined;
       this[MAP] = Object.create(null);
-      if (init2 instanceof Headers) {
+      if (init2 instanceof Headers2) {
         const rawHeaders = init2.raw();
         const headerNames = Object.keys(rawHeaders);
         for (const headerName of headerNames) {
@@ -28109,14 +30430,14 @@ var require_lib3 = __commonJS((exports, module) => {
       return createHeadersIterator(this, "key+value");
     }
   }
-  Headers.prototype.entries = Headers.prototype[Symbol.iterator];
-  Object.defineProperty(Headers.prototype, Symbol.toStringTag, {
+  Headers2.prototype.entries = Headers2.prototype[Symbol.iterator];
+  Object.defineProperty(Headers2.prototype, Symbol.toStringTag, {
     value: "Headers",
     writable: false,
     enumerable: false,
     configurable: true
   });
-  Object.defineProperties(Headers.prototype, {
+  Object.defineProperties(Headers2.prototype, {
     get: { enumerable: true },
     forEach: { enumerable: true },
     set: { enumerable: true },
@@ -28185,7 +30506,7 @@ var require_lib3 = __commonJS((exports, module) => {
     return obj;
   }
   function createHeadersLenient(obj) {
-    const headers = new Headers;
+    const headers = new Headers2;
     for (const name of Object.keys(obj)) {
       if (invalidTokenRegex.test(name)) {
         continue;
@@ -28216,7 +30537,7 @@ var require_lib3 = __commonJS((exports, module) => {
       let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       Body.call(this, body, opts);
       const status = opts.status || 200;
-      const headers = new Headers(opts.headers);
+      const headers = new Headers2(opts.headers);
       if (body != null && !headers.has("Content-Type")) {
         const contentType = extractContentType(body);
         if (contentType) {
@@ -28295,7 +30616,7 @@ var require_lib3 = __commonJS((exports, module) => {
     return !!(proto && proto.constructor.name === "AbortSignal");
   }
 
-  class Request {
+  class Request2 {
     constructor(input) {
       let init2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
       let parsedURL;
@@ -28319,7 +30640,7 @@ var require_lib3 = __commonJS((exports, module) => {
         timeout: init2.timeout || input.timeout || 0,
         size: init2.size || input.size || 0
       });
-      const headers = new Headers(init2.headers || input.headers || {});
+      const headers = new Headers2(init2.headers || input.headers || {});
       if (inputBody != null && !headers.has("Content-Type")) {
         const contentType = extractContentType(inputBody);
         if (contentType) {
@@ -28360,17 +30681,17 @@ var require_lib3 = __commonJS((exports, module) => {
       return this[INTERNALS$2].signal;
     }
     clone() {
-      return new Request(this);
+      return new Request2(this);
     }
   }
-  Body.mixIn(Request.prototype);
-  Object.defineProperty(Request.prototype, Symbol.toStringTag, {
+  Body.mixIn(Request2.prototype);
+  Object.defineProperty(Request2.prototype, Symbol.toStringTag, {
     value: "Request",
     writable: false,
     enumerable: false,
     configurable: true
   });
-  Object.defineProperties(Request.prototype, {
+  Object.defineProperties(Request2.prototype, {
     method: { enumerable: true },
     url: { enumerable: true },
     headers: { enumerable: true },
@@ -28380,7 +30701,7 @@ var require_lib3 = __commonJS((exports, module) => {
   });
   function getNodeRequestOptions(request) {
     const parsedURL = request[INTERNALS$2].parsedURL;
-    const headers = new Headers(request[INTERNALS$2].headers);
+    const headers = new Headers2(request[INTERNALS$2].headers);
     if (!headers.has("Accept")) {
       headers.set("Accept", "*/*");
     }
@@ -28449,7 +30770,7 @@ var require_lib3 = __commonJS((exports, module) => {
     }
     Body.Promise = fetch2.Promise;
     return new fetch2.Promise(function(resolve, reject) {
-      const request = new Request(url, opts);
+      const request = new Request2(url, opts);
       const options = getNodeRequestOptions(request);
       const send = (options.protocol === "https:" ? https : http).request;
       const signal = request.signal;
@@ -28557,7 +30878,7 @@ var require_lib3 = __commonJS((exports, module) => {
                 return;
               }
               const requestOpts = {
-                headers: new Headers(request.headers),
+                headers: new Headers2(request.headers),
                 follow: request.follow,
                 counter: request.counter + 1,
                 agent: request.agent,
@@ -28583,7 +30904,7 @@ var require_lib3 = __commonJS((exports, module) => {
                 requestOpts.body = undefined;
                 requestOpts.headers.delete("content-length");
               }
-              resolve(fetch2(new Request(locationURL, requestOpts)));
+              resolve(fetch2(new Request2(locationURL, requestOpts)));
               finalize();
               return;
           }
@@ -28683,8 +31004,8 @@ var require_lib3 = __commonJS((exports, module) => {
   module.exports = exports = fetch2;
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.default = exports;
-  exports.Headers = Headers;
-  exports.Request = Request;
+  exports.Headers = Headers2;
+  exports.Request = Request2;
   exports.Response = Response2;
   exports.FetchError = FetchError;
   exports.AbortError = AbortError;
@@ -40467,7 +42788,7 @@ var init_AxiosHeaders = __esm(() => {
     constructor(headers) {
       headers && this.set(headers);
     }
-    set(header, valueOrRewrite, rewrite) {
+    set(header, valueOrRewrite, rewrite2) {
       const self2 = this;
       function setHeader(_value, _header, _rewrite) {
         const lHeader = normalizeHeader(_header);
@@ -40495,7 +42816,7 @@ var init_AxiosHeaders = __esm(() => {
         }
         setHeaders(obj, valueOrRewrite);
       } else {
-        header != null && setHeader(valueOrRewrite, header, rewrite);
+        header != null && setHeader(valueOrRewrite, header, rewrite2);
       }
       return this;
     }
@@ -43643,19 +45964,19 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
   env = utils_default.merge.call({
     skipUndefined: true
   }, globalFetchAPI, env);
-  const { fetch: envFetch, Request, Response: Response2 } = env;
+  const { fetch: envFetch, Request: Request2, Response: Response2 } = env;
   const isFetchSupported = envFetch ? isFunction2(envFetch) : typeof fetch === "function";
-  const isRequestSupported = isFunction2(Request);
+  const isRequestSupported = isFunction2(Request2);
   const isResponseSupported = isFunction2(Response2);
   if (!isFetchSupported) {
     return false;
   }
   const isReadableStreamSupported = isFetchSupported && isFunction2(ReadableStream2);
-  const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder2) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
+  const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder2) : async (str) => new Uint8Array(await new Request2(str).arrayBuffer()));
   const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
     let duplexAccessed = false;
     const body = new ReadableStream2;
-    const hasContentType = new Request(platform_default.origin, {
+    const hasContentType = new Request2(platform_default.origin, {
       body,
       method: "POST",
       get duplex() {
@@ -43689,7 +46010,7 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
       return body.size;
     }
     if (utils_default.isSpecCompliantForm(body)) {
-      const _request = new Request(platform_default.origin, {
+      const _request = new Request2(platform_default.origin, {
         method: "POST",
         body
       });
@@ -43734,7 +46055,7 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
     let requestContentLength;
     try {
       if (onUploadProgress && supportsRequestStream && method !== "get" && method !== "head" && (requestContentLength = await resolveBodyLength(headers, data)) !== 0) {
-        let _request = new Request(url2, {
+        let _request = new Request2(url2, {
           method: "POST",
           body: data,
           duplex: "half"
@@ -43751,7 +46072,7 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
       if (!utils_default.isString(withCredentials)) {
         withCredentials = withCredentials ? "include" : "omit";
       }
-      const isCredentialsSupported = isRequestSupported && "credentials" in Request.prototype;
+      const isCredentialsSupported = isRequestSupported && "credentials" in Request2.prototype;
       const resolvedOptions = {
         ...fetchOptions,
         signal: composedSignal,
@@ -43761,7 +46082,7 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
         duplex: "half",
         credentials: isCredentialsSupported ? withCredentials : undefined
       };
-      request = isRequestSupported && new Request(url2, resolvedOptions);
+      request = isRequestSupported && new Request2(url2, resolvedOptions);
       let response = await (isRequestSupported ? _fetch(request, fetchOptions) : _fetch(url2, resolvedOptions));
       const isStreamResponse = supportsResponseStream && (responseType === "stream" || responseType === "response");
       if (supportsResponseStream && (onDownloadProgress || isStreamResponse && unsubscribe)) {
@@ -43801,8 +46122,8 @@ var DEFAULT_CHUNK_SIZE, isFunction2, globalFetchAPI, ReadableStream2, TextEncode
   };
 }, seedCache, getFetch = (config) => {
   let env = config && config.env || {};
-  const { fetch: fetch2, Request, Response: Response2 } = env;
-  const seeds = [Request, Response2, fetch2];
+  const { fetch: fetch2, Request: Request2, Response: Response2 } = env;
+  const seeds = [Request2, Response2, fetch2];
   let len2 = seeds.length, i2 = len2, seed, target, map = seedCache;
   while (i2--) {
     seed = seeds[i2];
@@ -43823,8 +46144,8 @@ var init_fetch = __esm(() => {
   init_settle();
   DEFAULT_CHUNK_SIZE = 64 * 1024;
   ({ isFunction: isFunction2 } = utils_default);
-  globalFetchAPI = (({ Request, Response: Response2 }) => ({
-    Request,
+  globalFetchAPI = (({ Request: Request2, Response: Response2 }) => ({
+    Request: Request2,
     Response: Response2
   }))(utils_default.global);
   ({ ReadableStream: ReadableStream2, TextEncoder: TextEncoder2 } = utils_default.global);
@@ -47347,13 +49668,13 @@ class ZipHandler {
     if (entries) {
       return this.iterateOverCentralDirectory(entries, fileCb);
     }
-    let stop = false;
+    let stop2 = false;
     do {
       const zipHeader = await this.readLocalFileHeader();
       if (!zipHeader)
         break;
       const next = fileCb(zipHeader);
-      stop = !!next.stop;
+      stop2 = !!next.stop;
       let fileData;
       await this.tokenizer.ignore(zipHeader.extraFieldLength);
       if (zipHeader.dataDescriptor && zipHeader.compressedSize === 0) {
@@ -47395,7 +49716,7 @@ class ZipHandler {
           throw new Error(`Expected data-descriptor-signature at position ${this.tokenizer.position - DataDescriptor.len}`);
         }
       }
-    } while (!stop);
+    } while (!stop2);
   }
   async iterateOverCentralDirectory(entries, fileCb) {
     for (const fileHeader of entries) {
@@ -50111,7 +52432,7 @@ var init_core2 = __esm(() => {
     return callback(uncompressedData);
   };
   ZipHandler.prototype.unzip = async function(fileCallback) {
-    let stop = false;
+    let stop2 = false;
     let zipEntryCount = 0;
     const zipScanStart = this.tokenizer.position;
     this.knownSizeDescriptorScannedBytes = 0;
@@ -50128,7 +52449,7 @@ var init_core2 = __esm(() => {
         throw new Error(`ZIP entry count exceeds ${maximumZipEntryCount}`);
       }
       const next = fileCallback(zipHeader);
-      stop = Boolean(next.stop);
+      stop2 = Boolean(next.stop);
       await this.tokenizer.ignore(zipHeader.extraFieldLength);
       const fileData = await readZipEntryData(this, zipHeader, {
         shouldBuffer: Boolean(next.handler),
@@ -50147,7 +52468,7 @@ var init_core2 = __esm(() => {
       if (hasExceededUnknownSizeScanBudget(this.tokenizer, zipScanStart, maximumUntrustedSkipSizeInBytes)) {
         throw new ParserHardLimitError(`ZIP stream probing exceeds ${maximumUntrustedSkipSizeInBytes} bytes`);
       }
-    } while (!stop);
+    } while (!stop2);
   };
   supportedExtensions = new Set(extensions);
   supportedMimeTypes = new Set(mimeTypes);
@@ -51065,11 +53386,11 @@ __export(exports_register_agent, {
   registerAgent: () => registerAgent
 });
 async function createDefaultDeps7() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -51530,7 +53851,7 @@ __export(exports_get_next_task, {
   GetNextTaskSession: () => GetNextTaskSession
 });
 async function getNextTask(chatroomId, options) {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   const { role, silent } = options;
   const convexUrl = getConvexUrl();
   const cliEnvPrefix = getCliEnvPrefix(convexUrl);
@@ -51563,7 +53884,7 @@ async function getNextTask(chatroomId, options) {
   }
   let chatroom;
   try {
-    chatroom = await client2.query(api.chatrooms.get, {
+    chatroom = await client4.query(api.chatrooms.get, {
       sessionId,
       chatroomId
     });
@@ -51581,14 +53902,14 @@ async function getNextTask(chatroomId, options) {
   const connectionId = `${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
   let participantAgentType;
   try {
-    const teamConfigs = await client2.query(api.machines.getTeamAgentConfigs, {
+    const teamConfigs = await client4.query(api.machines.getTeamAgentConfigs, {
       sessionId,
       chatroomId
     });
     const roleConfig = teamConfigs?.find((c) => c.role.toLowerCase() === role.toLowerCase());
     participantAgentType = roleConfig?.type;
   } catch {}
-  await client2.mutation(api.participants.join, {
+  await client4.mutation(api.participants.join, {
     sessionId,
     chatroomId,
     role,
@@ -51601,7 +53922,7 @@ async function getNextTask(chatroomId, options) {
     console.log(`[${connectionTime}] ⏳ Connecting to chatroom as "${role}"...`);
   }
   try {
-    const initPromptResult = await client2.query(api.messages.getInitPrompt, {
+    const initPromptResult = await client4.query(api.messages.getInitPrompt, {
       sessionId,
       chatroomId,
       role,
@@ -51639,7 +53960,7 @@ async function getNextTask(chatroomId, options) {
     sessionId,
     connectionId,
     cliEnvPrefix,
-    client: client2
+    client: client4
   });
   await session.start();
 }
@@ -51660,11 +53981,11 @@ __export(exports_classify, {
   classify: () => classify
 });
 async function createDefaultDeps8() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -51944,11 +54265,11 @@ __export(exports_handoff, {
   handoff: () => handoff
 });
 async function createDefaultDeps9() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -52149,11 +54470,11 @@ __export(exports_report_progress, {
   reportProgress: () => reportProgress
 });
 async function createDefaultDeps10() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -52264,12 +54585,12 @@ __export(exports_backlog, {
 import { createHash } from "node:crypto";
 import * as nodePath from "node:path";
 async function createDefaultDeps11() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   const fs6 = await import("node:fs/promises");
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -52893,12 +55214,12 @@ var exports_file_content = {};
 __export(exports_file_content, {
   readFileContent: () => readFileContent
 });
-import { readFileSync as readFileSync5 } from "fs";
-import { resolve as resolve2 } from "path";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { resolve as resolve2 } from "node:path";
 function readFileContent(filePath, optionName) {
   const absolutePath = resolve2(process.cwd(), filePath);
   try {
-    return readFileSync5(absolutePath, "utf-8");
+    return readFileSync6(absolutePath, "utf-8");
   } catch (err) {
     const nodeErr = err;
     throw new Error(`Cannot read file for --${optionName}: ${absolutePath}
@@ -52920,11 +55241,11 @@ __export(exports_workflow, {
   completeStep: () => completeStep
 });
 async function createDefaultDeps12() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -53412,11 +55733,11 @@ __export(exports_read, {
   taskRead: () => taskRead
 });
 async function createDefaultDeps13() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -53540,11 +55861,11 @@ __export(exports_skill, {
   activateSkill: () => activateSkill
 });
 async function createDefaultDeps14() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -53621,11 +55942,11 @@ __export(exports_messages, {
   listBySenderRole: () => listBySenderRole
 });
 async function createDefaultDeps15() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -53776,11 +56097,11 @@ __export(exports_context, {
   inspectContext: () => inspectContext
 });
 async function createDefaultDeps16() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -54071,11 +56392,11 @@ __export(exports_guidelines, {
   listGuidelineTypes: () => listGuidelineTypes
 });
 async function createDefaultDeps17() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -54163,11 +56484,11 @@ __export(exports_artifact, {
   createArtifact: () => createArtifact
 });
 async function createDefaultDeps18() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -54342,11 +56663,11 @@ __export(exports_get_system_prompt, {
   getSystemPrompt: () => getSystemPrompt
 });
 async function createDefaultDeps19() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -54404,10 +56725,10 @@ __export(exports_telegram, {
   sendMessage: () => sendMessage
 });
 async function createDefaultDeps20() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   return {
     backend: {
-      action: (endpoint, args) => client2.action(endpoint, args)
+      action: (endpoint, args) => client4.action(endpoint, args)
     },
     session: {
       getSessionId,
@@ -54569,9 +56890,9 @@ var init_on_request_stop_agent = () => {};
 
 // src/commands/machine/pid.ts
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync4, unlinkSync as unlinkSync2, mkdirSync as mkdirSync4 } from "node:fs";
-import { homedir as homedir4 } from "node:os";
-import { join as join7 } from "node:path";
+import { existsSync as existsSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync5, unlinkSync as unlinkSync2, mkdirSync as mkdirSync5 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import { join as join8 } from "node:path";
 function getUrlHash() {
   const url2 = getConvexUrl();
   return createHash2("sha256").update(url2).digest("hex").substring(0, 8);
@@ -54580,12 +56901,12 @@ function getPidFileName() {
   return `daemon-${getUrlHash()}.pid`;
 }
 function ensureChatroomDir2() {
-  if (!existsSync4(CHATROOM_DIR4)) {
-    mkdirSync4(CHATROOM_DIR4, { recursive: true, mode: 448 });
+  if (!existsSync5(CHATROOM_DIR4)) {
+    mkdirSync5(CHATROOM_DIR4, { recursive: true, mode: 448 });
   }
 }
 function getPidFilePath() {
-  return join7(CHATROOM_DIR4, getPidFileName());
+  return join8(CHATROOM_DIR4, getPidFileName());
 }
 function isProcessRunning(pid) {
   try {
@@ -54597,11 +56918,11 @@ function isProcessRunning(pid) {
 }
 function readPid() {
   const pidPath = getPidFilePath();
-  if (!existsSync4(pidPath)) {
+  if (!existsSync5(pidPath)) {
     return null;
   }
   try {
-    const content = readFileSync6(pidPath, "utf-8").trim();
+    const content = readFileSync7(pidPath, "utf-8").trim();
     const pid = parseInt(content, 10);
     if (isNaN(pid) || pid <= 0) {
       return null;
@@ -54614,12 +56935,12 @@ function readPid() {
 function writePid() {
   ensureChatroomDir2();
   const pidPath = getPidFilePath();
-  writeFileSync4(pidPath, process.pid.toString(), "utf-8");
+  writeFileSync5(pidPath, process.pid.toString(), "utf-8");
 }
 function removePid() {
   const pidPath = getPidFilePath();
   try {
-    if (existsSync4(pidPath)) {
+    if (existsSync5(pidPath)) {
       unlinkSync2(pidPath);
     }
   } catch {}
@@ -54650,7 +56971,7 @@ function releaseLock() {
 var CHATROOM_DIR4;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join7(homedir4(), ".chatroom");
+  CHATROOM_DIR4 = join8(homedir5(), ".chatroom");
 });
 
 // src/commands/machine/daemon-start/utils.ts
@@ -55528,20 +57849,20 @@ var init_git_heartbeat = __esm(() => {
 
 // src/infrastructure/services/workspace/workspace-resolver.ts
 import { readFile as readFile2, readdir, stat } from "node:fs/promises";
-import { join as join8, basename, resolve as resolve3 } from "node:path";
+import { join as join9, basename, resolve as resolve3 } from "node:path";
 async function resolveGlobPattern(rootDir, pattern) {
   const cleaned = pattern.replace(/\/+$/, "");
   if (cleaned.includes("..")) {
     return [];
   }
   if (cleaned.endsWith("/*")) {
-    const parentDir = join8(rootDir, cleaned.slice(0, -2));
+    const parentDir = join9(rootDir, cleaned.slice(0, -2));
     try {
       const entries = await readdir(parentDir, { withFileTypes: true });
       const dirs = [];
       for (const entry of entries) {
         if (entry.isDirectory()) {
-          const dirPath = join8(parentDir, entry.name);
+          const dirPath = join9(parentDir, entry.name);
           if (resolve3(dirPath).startsWith(resolve3(rootDir))) {
             dirs.push(dirPath);
           }
@@ -55552,7 +57873,7 @@ async function resolveGlobPattern(rootDir, pattern) {
       return [];
     }
   } else {
-    const dir = join8(rootDir, cleaned);
+    const dir = join9(rootDir, cleaned);
     try {
       if (!resolve3(dir).startsWith(resolve3(rootDir)))
         return [];
@@ -55565,7 +57886,7 @@ async function resolveGlobPattern(rootDir, pattern) {
 }
 async function readPackageJson(dir) {
   try {
-    const content = await readFile2(join8(dir, "package.json"), "utf-8");
+    const content = await readFile2(join9(dir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     return {
       name: pkg.name || basename(dir),
@@ -55577,7 +57898,7 @@ async function readPackageJson(dir) {
 }
 async function readPnpmWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile2(join8(rootDir, "pnpm-workspace.yaml"), "utf-8");
+    const content = await readFile2(join9(rootDir, "pnpm-workspace.yaml"), "utf-8");
     const patterns = [];
     let inPackages = false;
     for (const line of content.split(`
@@ -55604,7 +57925,7 @@ async function readPnpmWorkspacePatterns(rootDir) {
 }
 async function readPackageJsonWorkspacePatterns(rootDir) {
   try {
-    const content = await readFile2(join8(rootDir, "package.json"), "utf-8");
+    const content = await readFile2(join9(rootDir, "package.json"), "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.workspaces)
       return [];
@@ -55654,11 +57975,11 @@ var init_workspace_resolver = () => {};
 // src/infrastructure/services/workspace/command-discovery.ts
 import { access as access2 } from "node:fs/promises";
 import { readFile as readFile3 } from "node:fs/promises";
-import { join as join9, relative, basename as basename2 } from "node:path";
+import { join as join10, relative, basename as basename2 } from "node:path";
 async function detectPackageManager(workingDir) {
   for (const { file, manager } of LOCKFILE_MAP) {
     try {
-      await access2(join9(workingDir, file));
+      await access2(join10(workingDir, file));
       return manager;
     } catch {}
   }
@@ -55705,7 +58026,7 @@ async function discoverCommands(workingDir) {
   const turboTaskNames = [];
   let rootPackageName = basename2(workingDir);
   try {
-    const pkgPath = join9(workingDir, "package.json");
+    const pkgPath = join10(workingDir, "package.json");
     const pkgContent = await readFile3(pkgPath, "utf-8");
     const pkg = JSON.parse(pkgContent);
     if (pkg.name)
@@ -55726,7 +58047,7 @@ async function discoverCommands(workingDir) {
   } catch {}
   const rootSubWorkspace = { type: "npm", path: ".", name: rootPackageName };
   try {
-    const turboPath = join9(workingDir, "turbo.json");
+    const turboPath = join10(workingDir, "turbo.json");
     const turboContent = await readFile3(turboPath, "utf-8");
     const turbo = JSON.parse(turboContent);
     if (turbo.tasks && typeof turbo.tasks === "object") {
@@ -56661,7 +58982,7 @@ function ts() {
 }
 async function startLocalApi(ctx, port = resolvePort()) {
   const router = createRouter();
-  const server = createServer(async (req, res) => {
+  const server2 = createServer(async (req, res) => {
     try {
       const localReq = await normalizeRequest(req);
       const localRes = await router.handleRequest(localReq, ctx);
@@ -56671,11 +58992,11 @@ async function startLocalApi(ctx, port = resolvePort()) {
     }
   });
   await new Promise((resolve5) => {
-    server.listen(port, "127.0.0.1", () => {
+    server2.listen(port, "127.0.0.1", () => {
       console.log(`[${ts()}] \uD83C\uDF10 Local API started on http://localhost:${port}`);
       resolve5();
     });
-    server.on("error", (err) => {
+    server2.on("error", (err) => {
       if (err.code === "EADDRINUSE") {
         console.warn(`[${ts()}] ⚠️  Local API port ${port} already in use — skipping local API`);
       } else {
@@ -56684,12 +59005,12 @@ async function startLocalApi(ctx, port = resolvePort()) {
       resolve5();
     });
   });
-  const stop = () => new Promise((resolve5, reject) => {
-    if (!server.listening) {
+  const stop2 = () => new Promise((resolve5, reject) => {
+    if (!server2.listening) {
       resolve5();
       return;
     }
-    server.close((err) => {
+    server2.close((err) => {
       if (err) {
         reject(err);
       } else {
@@ -56698,10 +59019,10 @@ async function startLocalApi(ctx, port = resolvePort()) {
       }
     });
   });
-  return { stop };
+  return { stop: stop2 };
 }
 var LOCAL_API_PORT = 19847;
-var init_server2 = __esm(() => {
+var init_server3 = __esm(() => {
   init_identity();
   init_open_finder();
   init_open_github_desktop();
@@ -56711,7 +59032,7 @@ var init_server2 = __esm(() => {
 
 // src/infrastructure/local-api/index.ts
 var init_local_api = __esm(() => {
-  init_server2();
+  init_server3();
 });
 
 // src/events/daemon/event-bus.ts
@@ -56958,6 +59279,13 @@ function resolveStopReason(code2, signal) {
   return "agent_process.crashed";
 }
 
+// src/infrastructure/services/remote-agents/spawn-prompt.ts
+function createSpawnPrompt(raw) {
+  const trimmed = raw?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : DEFAULT_TRIGGER_PROMPT;
+}
+var DEFAULT_TRIGGER_PROMPT = "Please read your system prompt carefully and follow the Getting Started instructions.";
+
 // src/infrastructure/services/agent-process-manager/agent-process-manager.ts
 function agentKey2(chatroomId, role) {
   return `${chatroomId}:${role.toLowerCase()}`;
@@ -57266,7 +59594,7 @@ class AgentProcessManager {
       try {
         spawnResult = await service.spawn({
           workingDir: opts.workingDir,
-          prompt: initPromptResult.initialMessage,
+          prompt: createSpawnPrompt(initPromptResult.initialMessage),
           systemPrompt: initPromptResult.rolePrompt,
           model: opts.model,
           context: {
@@ -57481,8 +59809,8 @@ Run: chatroom auth login`);
 ⏳ Waiting for authentication (timeout: 5 minutes)...`);
   return waitForAuthentication(convexUrl);
 }
-async function validateSession(client2, sessionId, convexUrl) {
-  const validation = await client2.query(api.cliAuth.validateSession, { sessionId });
+async function validateSession(client4, sessionId, convexUrl) {
+  const validation = await client4.query(api.cliAuth.validateSession, { sessionId });
   if (validation.valid) {
     return sessionId;
   }
@@ -57493,7 +59821,7 @@ Run: chatroom auth login`);
 ⏳ Waiting for re-authentication (timeout: 5 minutes)...`);
   const newSessionId2 = await waitForAuthentication(convexUrl);
   const typedNewSession = newSessionId2;
-  const revalidation = await client2.query(api.cliAuth.validateSession, {
+  const revalidation = await client4.query(api.cliAuth.validateSession, {
     sessionId: typedNewSession
   });
   if (!revalidation.valid) {
@@ -57508,11 +59836,11 @@ function setupMachine() {
   const config3 = loadMachineConfig();
   return config3;
 }
-async function registerCapabilities(client2, sessionId, config3, agentServices) {
+async function registerCapabilities(client4, sessionId, config3, agentServices) {
   const { machineId } = config3;
   const availableModels = await discoverModels(agentServices);
   try {
-    await client2.mutation(api.machines.register, {
+    await client4.mutation(api.machines.register, {
       sessionId,
       machineId,
       hostname: config3.hostname,
@@ -57526,9 +59854,9 @@ async function registerCapabilities(client2, sessionId, config3, agentServices)
   }
   return availableModels;
 }
-async function connectDaemon(client2, sessionId, machineId, convexUrl) {
+async function connectDaemon(client4, sessionId, machineId, convexUrl) {
   try {
-    await client2.mutation(api.machines.updateDaemonStatus, {
+    await client4.mutation(api.machines.updateDaemonStatus, {
       sessionId,
       machineId,
       connected: true
@@ -57579,25 +59907,25 @@ async function initDaemon() {
   }
   const convexUrl = getConvexUrl();
   const sessionId = await validateAuthentication(convexUrl);
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   let typedSessionId = sessionId;
   let consecutiveFailures = 0;
   while (true) {
     try {
-      typedSessionId = await validateSession(client2, typedSessionId, convexUrl);
+      typedSessionId = await validateSession(client4, typedSessionId, convexUrl);
       const config3 = setupMachine();
       const { machineId } = config3;
       initHarnessRegistry();
       const agentServices = new Map(getAllHarnesses().map((s) => [s.id, s]));
-      const availableModels = await registerCapabilities(client2, typedSessionId, config3, agentServices);
-      await connectDaemon(client2, typedSessionId, machineId, convexUrl);
+      const availableModels = await registerCapabilities(client4, typedSessionId, config3, agentServices);
+      await connectDaemon(client4, typedSessionId, machineId, convexUrl);
       if (consecutiveFailures > 0) {
         console.log(`[${formatTimestamp()}] ✅ Backend reachable again at ${convexUrl}`);
         consecutiveFailures = 0;
       }
       const deps = createDefaultDeps21();
-      deps.backend.mutation = (endpoint, args) => client2.mutation(endpoint, args);
-      deps.backend.query = (endpoint, args) => client2.query(endpoint, args);
+      deps.backend.mutation = (endpoint, args) => client4.mutation(endpoint, args);
+      deps.backend.query = (endpoint, args) => client4.query(endpoint, args);
       deps.agentProcessManager = new AgentProcessManager({
         agentServices,
         backend: deps.backend,
@@ -57613,7 +59941,7 @@ async function initDaemon() {
       });
       const events = new DaemonEventBus;
       const ctx = {
-        client: client2,
+        client: client4,
         sessionId: typedSessionId,
         machineId,
         config: config3,
@@ -58188,12 +60516,12 @@ async function isChatroomInstalledDefault() {
   }
 }
 async function createDefaultDeps22() {
-  const client2 = await getConvexClient();
+  const client4 = await getConvexClient();
   const fs6 = await import("fs/promises");
   return {
     backend: {
-      mutation: (endpoint, args) => client2.mutation(endpoint, args),
-      query: (endpoint, args) => client2.query(endpoint, args)
+      mutation: (endpoint, args) => client4.mutation(endpoint, args),
+      query: (endpoint, args) => client4.query(endpoint, args)
     },
     session: {
       getSessionId,
@@ -58618,8 +60946,8 @@ var exports_lifecycle_heartbeat = {};
 __export(exports_lifecycle_heartbeat, {
   sendLifecycleHeartbeat: () => sendLifecycleHeartbeat
 });
-function sendLifecycleHeartbeat(client2, opts) {
-  withRetry(() => client2.mutation(api.participants.join, {
+function sendLifecycleHeartbeat(client4, opts) {
+  withRetry(() => client4.mutation(api.participants.join, {
     sessionId: opts.sessionId,
     chatroomId: opts.chatroomId,
     role: opts.role,
@@ -59192,10 +61520,10 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
   const sessionId = getSessionId2();
   if (!sessionId)
     return;
-  const client2 = await getConvexClient2();
-  sendLifecycleHeartbeat2(client2, { sessionId, chatroomId, role, action: actionCommand.name() });
+  const client4 = await getConvexClient2();
+  sendLifecycleHeartbeat2(client4, { sessionId, chatroomId, role, action: actionCommand.name() });
 });
 program2.parse();
 
-//# debugId=44A7863B280772E964756E2164756E21
+//# debugId=29314BC73A4B833B64756E2164756E21
 //# sourceMappingURL=index.js.map