chatroom-cli 1.35.1 → 1.36.1

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,
@@ -54488,7 +56809,7 @@ var init_telegram = __esm(() => {
 });
 
 // ../../services/backend/config/reliability.ts
-var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000;
+var DAEMON_HEARTBEAT_INTERVAL_MS = 30000, AGENT_REQUEST_DEADLINE_MS = 120000, OBSERVATION_TTL_MS = 60000, OBSERVED_SAFETY_POLL_MS = 30000;
 
 // src/events/daemon/agent/on-request-start-agent.ts
 async function onRequestStartAgent(ctx, event) {
@@ -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,9 +56971,58 @@ function releaseLock() {
 var CHATROOM_DIR4;
 var init_pid = __esm(() => {
   init_client2();
-  CHATROOM_DIR4 = join7(homedir4(), ".chatroom");
+  CHATROOM_DIR4 = join8(homedir5(), ".chatroom");
 });
 
+// src/infrastructure/git/git-state-pipeline.ts
+import { createHash as createHash3 } from "node:crypto";
+
+class GitStatePipeline {
+  fields;
+  constructor(fields) {
+    this.fields = fields;
+  }
+  async collect(workingDir, preCollected) {
+    const results = new Map(preCollected);
+    if (this.fields.length === 0)
+      return results;
+    const entries = await Promise.all(this.fields.filter((f) => !results.has(f.key)).map(async (field) => {
+      try {
+        const raw = await field.collect(workingDir);
+        return { key: field.key, raw };
+      } catch {
+        return { key: field.key, raw: field.defaultValue };
+      }
+    }));
+    for (const { key, raw } of entries) {
+      results.set(key, raw);
+    }
+    return results;
+  }
+  computeHash(values, slim) {
+    const hashInput = {};
+    for (const field of this.fields) {
+      if (slim && !field.includeInSlim)
+        continue;
+      const raw = values.get(field.key) ?? field.defaultValue;
+      hashInput[field.key] = field.toHashable(raw);
+    }
+    return createHash3("md5").update(JSON.stringify(hashInput)).digest("hex");
+  }
+  toMutationArgs(values, slim) {
+    const args = {};
+    for (const field of this.fields) {
+      if (slim && !field.includeInSlim)
+        continue;
+      const raw = values.get(field.key) ?? field.defaultValue;
+      Object.assign(args, field.toMutationPartial(raw));
+    }
+    args.pipelineMode = slim ? "slim" : "full";
+    return args;
+  }
+}
+var init_git_state_pipeline = () => {};
+
 // src/commands/machine/daemon-start/utils.ts
 function formatTimestamp() {
   return new Date().toISOString().replace("T", " ").substring(0, 19);
@@ -55292,6 +57662,28 @@ async function processMoreCommits(ctx, req) {
   });
   console.log(`[${formatTimestamp()}] \uD83D\uDCDC More commits appended: ${req.workingDir} (+${commits.length} commits, offset=${offset})`);
 }
+async function processAllPullRequests(ctx, req) {
+  const pullRequests = await getAllPRs(req.workingDir);
+  await ctx.deps.backend.mutation(api.workspaces.upsertAllPullRequests, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    pullRequests
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCCB All pull requests pushed: ${req.workingDir} (${pullRequests.length} PRs)`);
+}
+async function processRecentCommits(ctx, req) {
+  const commits = await getRecentCommits(req.workingDir, COMMITS_PER_PAGE, 0);
+  const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
+  await ctx.deps.backend.mutation(api.workspaces.upsertRecentCommits, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir: req.workingDir,
+    commits,
+    hasMoreCommits
+  });
+  console.log(`[${formatTimestamp()}] \uD83D\uDCDC Recent commits pushed: ${req.workingDir} (${commits.length} commits)`);
+}
 async function processRequests(ctx, requests, processedRequestIds, dedupTtlMs) {
   const evictBefore = Date.now() - dedupTtlMs;
   for (const [id, ts] of processedRequestIds) {
@@ -55328,6 +57720,12 @@ async function processRequests(ctx, requests, processedRequestIds, dedupTtlMs) {
         case "pr_commits":
           await processPRCommits(ctx, req);
           break;
+        case "all_pull_requests":
+          await processAllPullRequests(ctx, req);
+          break;
+        case "recent_commits":
+          await processRecentCommits(ctx, req);
+          break;
       }
       await ctx.deps.backend.mutation(api.workspaces.updateRequestStatus, {
         sessionId: ctx.sessionId,
@@ -55352,7 +57750,26 @@ var init_git_subscription = __esm(() => {
 });
 
 // src/commands/machine/daemon-start/git-heartbeat.ts
-import { createHash as createHash3 } from "node:crypto";
+function makeBranchDependentFields(branch) {
+  return [
+    {
+      key: "openPullRequests",
+      includeInSlim: true,
+      collect: (wd) => getOpenPRsForBranch(wd, branch),
+      toHashable: (raw) => raw.map((pr) => pr.prNumber),
+      toMutationPartial: (raw) => ({ openPullRequests: raw }),
+      defaultValue: []
+    },
+    {
+      key: "headCommitStatus",
+      includeInSlim: true,
+      collect: (wd) => getCommitStatusChecks(wd, branch),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ headCommitStatus: raw }),
+      defaultValue: null
+    }
+  ];
+}
 async function pushGitState(ctx) {
   let workspaces;
   try {
@@ -55379,8 +57796,8 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
   const stateKey = makeGitStateKey(ctx.machineId, workingDir);
   const isRepo = await isGitRepo(workingDir);
   if (!isRepo) {
-    const stateHash2 = "not_found";
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+    const stateHash = "not_found";
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash)
       return;
     await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: ctx.sessionId,
@@ -55388,20 +57805,13 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
       workingDir,
       status: "not_found"
     });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    ctx.lastPushedGitState.set(stateKey, stateHash);
     return;
   }
-  const [branchResult, dirtyResult, diffStatResult, commits, commitsAhead] = await Promise.all([
-    getBranch(workingDir),
-    isDirty(workingDir),
-    getDiffStat(workingDir),
-    getRecentCommits(workingDir, COMMITS_PER_PAGE),
-    getCommitsAhead(workingDir)
-  ]);
-  const remotes = await getRemotes(workingDir);
+  const branchResult = await getBranch(workingDir);
   if (branchResult.status === "error") {
-    const stateHash2 = `error:${branchResult.message}`;
-    if (ctx.lastPushedGitState.get(stateKey) === stateHash2)
+    const stateHash = `error:${branchResult.message}`;
+    if (ctx.lastPushedGitState.get(stateKey) === stateHash)
       return;
     await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
       sessionId: ctx.sessionId,
@@ -55410,21 +57820,21 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
       status: "error",
       errorMessage: branchResult.message
     });
-    ctx.lastPushedGitState.set(stateKey, stateHash2);
+    ctx.lastPushedGitState.set(stateKey, stateHash);
     return;
   }
   if (branchResult.status === "not_found") {
     return;
   }
-  const openPRs = await getOpenPRsForBranch(workingDir, branchResult.branch);
-  const allPRs = await getAllPRs(workingDir);
-  const headCommitStatus = await getCommitStatusChecks(workingDir, branchResult.branch);
   const branch = branchResult.branch;
-  const isDirty2 = dirtyResult;
-  const diffStat = diffStatResult.status === "available" ? diffStatResult.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+  const allFields = [branchField, ...GIT_STATE_FIELDS, ...makeBranchDependentFields(branch)];
+  const pipeline2 = new GitStatePipeline(allFields);
+  const preCollected = new Map([["branch", branchResult]]);
+  const values = await pipeline2.collect(workingDir, preCollected);
+  const commits = values.get("commits");
   const hasMoreCommits = commits.length >= COMMITS_PER_PAGE;
-  const stateHash = createHash3("md5").update(JSON.stringify({ branch, isDirty: isDirty2, diffStat, commitsAhead, shas: commits.map((c) => c.sha), prs: openPRs.map((pr) => pr.prNumber), allPrs: allPRs.map((pr) => `${pr.prNumber}:${pr.state}`), remotes: remotes.map((r) => `${r.name}:${r.url}`), headCommitStatus })).digest("hex");
-  if (ctx.lastPushedGitState.get(stateKey) === stateHash) {
+  const hash = pipeline2.computeHash(values, false);
+  if (ctx.lastPushedGitState.get(stateKey) === hash) {
     return;
   }
   await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
@@ -55432,23 +57842,73 @@ async function pushSingleWorkspaceGitState(ctx, workingDir) {
     machineId: ctx.machineId,
     workingDir,
     status: "available",
-    branch,
-    isDirty: isDirty2,
-    diffStat,
+    ...pipeline2.toMutationArgs(values, false),
     recentCommits: commits,
-    hasMoreCommits,
-    openPullRequests: openPRs,
-    allPullRequests: allPRs,
-    remotes,
-    commitsAhead,
-    headCommitStatus
+    hasMoreCommits
   });
-  ctx.lastPushedGitState.set(stateKey, stateHash);
-  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${isDirty2 ? ", dirty" : ", clean"})`);
+  ctx.lastPushedGitState.set(stateKey, hash);
+  console.log(`[${formatTimestamp()}] \uD83D\uDD00 Git state pushed: ${workingDir} (${branch}${values.get("isDirty") ? ", dirty" : ", clean"})`);
   prefetchMissingCommitDetails(ctx, workingDir, commits).catch((err) => {
     console.warn(`[${formatTimestamp()}] ⚠️  Commit pre-fetch failed for ${workingDir}: ${getErrorMessage(err)}`);
   });
 }
+async function pushSingleWorkspaceGitSummaryForObserved(ctx, workingDir, reason = "safety-poll") {
+  const stateKey = makeGitStateKey(ctx.machineId, workingDir);
+  const isRepo = await isGitRepo(workingDir);
+  if (!isRepo) {
+    const stateHash = "not_found";
+    if (reason !== "refresh" && ctx.lastPushedGitState.get(stateKey) === stateHash)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      status: "not_found"
+    });
+    ctx.lastPushedGitState.set(stateKey, stateHash);
+    return;
+  }
+  const branchResult = await getBranch(workingDir);
+  if (branchResult.status === "error") {
+    const stateHash = `error:${branchResult.message}`;
+    if (reason !== "refresh" && ctx.lastPushedGitState.get(stateKey) === stateHash)
+      return;
+    await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId,
+      workingDir,
+      status: "error",
+      errorMessage: branchResult.message
+    });
+    ctx.lastPushedGitState.set(stateKey, stateHash);
+    return;
+  }
+  if (branchResult.status === "not_found") {
+    return;
+  }
+  const branch = branchResult.branch;
+  const slimFields = [
+    branchField,
+    ...GIT_STATE_FIELDS.filter((f) => f.includeInSlim),
+    ...makeBranchDependentFields(branch)
+  ];
+  const pipeline2 = new GitStatePipeline(slimFields);
+  const preCollected = new Map([["branch", branchResult]]);
+  const values = await pipeline2.collect(workingDir, preCollected);
+  const hash = pipeline2.computeHash(values, true);
+  if (reason !== "refresh" && ctx.lastPushedGitState.get(stateKey) === hash) {
+    return;
+  }
+  await ctx.deps.backend.mutation(api.workspaces.upsertWorkspaceGitState, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId,
+    workingDir,
+    status: "available",
+    ...pipeline2.toMutationArgs(values, true)
+  });
+  ctx.lastPushedGitState.set(stateKey, hash);
+  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed git summary pushed: ${workingDir} (${branch}${values.get("isDirty") ? ", dirty" : ", clean"})${reason === "refresh" ? " [refresh]" : ""}`);
+}
 async function prefetchMissingCommitDetails(ctx, workingDir, commits) {
   if (commits.length === 0)
     return;
@@ -55519,29 +57979,105 @@ async function prefetchSingleCommit(ctx, workingDir, sha, commits) {
   });
   console.log(`[${formatTimestamp()}] ✅ Pre-fetched: ${sha.slice(0, 7)} in ${workingDir}`);
 }
+var branchField, GIT_STATE_FIELDS;
 var init_git_heartbeat = __esm(() => {
+  init_git_state_pipeline();
   init_git_subscription();
   init_api3();
   init_git_reader();
   init_convex_error();
+  branchField = {
+    key: "branch",
+    includeInSlim: true,
+    collect: () => {
+      throw new Error("branch must be pre-collected");
+    },
+    toHashable: (raw) => {
+      const r = raw;
+      return r.status === "available" ? r.branch : "unknown";
+    },
+    toMutationPartial: (raw) => {
+      const r = raw;
+      return r.status === "available" ? { branch: r.branch } : {};
+    },
+    defaultValue: { status: "not_found" }
+  };
+  GIT_STATE_FIELDS = [
+    {
+      key: "isDirty",
+      includeInSlim: true,
+      collect: (wd) => isDirty(wd),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ isDirty: raw }),
+      defaultValue: false
+    },
+    {
+      key: "diffStat",
+      includeInSlim: false,
+      collect: (wd) => getDiffStat(wd),
+      toHashable: (raw) => {
+        const r = raw;
+        return r.status === "available" ? r.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 };
+      },
+      toMutationPartial: (raw) => {
+        const r = raw;
+        return {
+          diffStat: r.status === "available" ? r.diffStat : { filesChanged: 0, insertions: 0, deletions: 0 }
+        };
+      },
+      defaultValue: { status: "not_found" }
+    },
+    {
+      key: "commits",
+      includeInSlim: false,
+      collect: (wd) => getRecentCommits(wd, COMMITS_PER_PAGE),
+      toHashable: (raw) => raw.map((c) => c.sha),
+      toMutationPartial: () => ({}),
+      defaultValue: []
+    },
+    {
+      key: "commitsAhead",
+      includeInSlim: false,
+      collect: (wd) => getCommitsAhead(wd),
+      toHashable: (raw) => raw,
+      toMutationPartial: (raw) => ({ commitsAhead: raw }),
+      defaultValue: 0
+    },
+    {
+      key: "remotes",
+      includeInSlim: false,
+      collect: (wd) => getRemotes(wd),
+      toHashable: (raw) => raw.map((r) => `${r.name}:${r.url}`),
+      toMutationPartial: (raw) => ({ remotes: raw }),
+      defaultValue: []
+    },
+    {
+      key: "allPullRequests",
+      includeInSlim: false,
+      collect: (wd) => getAllPRs(wd),
+      toHashable: (raw) => raw.map((pr) => `${pr.prNumber}:${pr.state}`),
+      toMutationPartial: (raw) => ({ allPullRequests: raw }),
+      defaultValue: []
+    }
+  ];
 });
 
 // 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 +58088,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 +58101,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 +58113,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 +58140,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 +58190,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 +58241,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 +58262,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") {
@@ -56164,6 +58700,176 @@ var init_file_tree_subscription = __esm(() => {
   init_convex_error();
 });
 
+// src/commands/machine/daemon-start/observed-sync.ts
+function startObservedSyncSubscription(ctx, wsClient2) {
+  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Starting observed-sync subscription (reactive)`);
+  const observedWorkingDirs = new Map;
+  const chatroomRefreshState = new Map;
+  const skippedPushCount = new Map;
+  const pendingRefresh = new Map;
+  let stopped = false;
+  let reconcileInFlight = false;
+  const unsubscribe = wsClient2.onUpdate(api.machines.getObservedChatroomsForMachine, {
+    sessionId: ctx.sessionId,
+    machineId: ctx.machineId
+  }, (observed) => {
+    if (stopped)
+      return;
+    handleObservedChange(observed ?? []);
+  }, (err) => {
+    console.warn(`[${formatTimestamp()}] ⚠️ Observed-sync subscription error: ${getErrorMessage(err)}`);
+  });
+  const reconcileIntervalMs = Math.max(OBSERVATION_TTL_MS / 2, OBSERVED_SAFETY_POLL_MS);
+  const reconcileTimer = setInterval(() => {
+    if (stopped || reconcileInFlight)
+      return;
+    reconcileInFlight = true;
+    ctx.deps.backend.query(api.machines.getObservedChatroomsForMachine, {
+      sessionId: ctx.sessionId,
+      machineId: ctx.machineId
+    }).then((observed) => {
+      if (!stopped)
+        handleObservedChange(observed ?? []);
+    }).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Observed-sync reconcile query failed: ${getErrorMessage(err)}`);
+    }).finally(() => {
+      reconcileInFlight = false;
+    });
+  }, reconcileIntervalMs);
+  console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync subscription started`);
+  return {
+    stop: () => {
+      stopped = true;
+      unsubscribe();
+      clearInterval(reconcileTimer);
+      for (const [wd, state] of observedWorkingDirs) {
+        clearInterval(state.intervalHandle);
+        const skips = skippedPushCount.get(wd) ?? 0;
+        if (skips > 0) {
+          console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd} (skipped ${skips} overlapping pushes)`);
+        } else {
+          console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd}`);
+        }
+      }
+      observedWorkingDirs.clear();
+      skippedPushCount.clear();
+      pendingRefresh.clear();
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync subscription stopped`);
+    }
+  };
+  function handleObservedChange(observed) {
+    const newWorkingDirs = new Set;
+    const refreshedWorkingDirs = new Set;
+    for (const chatroom of observed) {
+      const chatroomId = chatroom.chatroomId;
+      const currentRefresh = chatroom.lastRefreshedAt;
+      const previous = chatroomRefreshState.get(chatroomId);
+      const wasRefreshed = currentRefresh !== null && currentRefresh !== undefined && (previous === undefined || (previous.lastRefreshedAt ?? 0) < currentRefresh);
+      if (wasRefreshed) {
+        chatroomRefreshState.set(chatroomId, { lastRefreshedAt: currentRefresh });
+        for (const wd of chatroom.workingDirs) {
+          refreshedWorkingDirs.add(wd);
+        }
+      }
+      for (const wd of chatroom.workingDirs) {
+        newWorkingDirs.add(wd);
+      }
+    }
+    for (const [chatroomId] of chatroomRefreshState) {
+      const stillObserved = observed.some((c) => c.chatroomId === chatroomId);
+      if (!stillObserved) {
+        chatroomRefreshState.delete(chatroomId);
+      }
+    }
+    const currentWorkingDirs = new Set(observedWorkingDirs.keys());
+    let addedCount = 0;
+    let removedCount = 0;
+    for (const wd of currentWorkingDirs) {
+      if (!newWorkingDirs.has(wd)) {
+        const state = observedWorkingDirs.get(wd);
+        if (state) {
+          clearInterval(state.intervalHandle);
+          observedWorkingDirs.delete(wd);
+          const skips = skippedPushCount.get(wd) ?? 0;
+          if (skips > 0) {
+            console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd} (skipped ${skips} overlapping pushes)`);
+          } else {
+            console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Stopped observing ${wd}`);
+          }
+          skippedPushCount.delete(wd);
+          pendingRefresh.delete(wd);
+          removedCount++;
+        }
+      }
+    }
+    for (const wd of newWorkingDirs) {
+      if (!observedWorkingDirs.has(wd)) {
+        observedWorkingDirs.set(wd, {
+          intervalHandle: setInterval(() => {
+            schedulePushForWorkingDir(wd, "safety-poll");
+          }, OBSERVED_SAFETY_POLL_MS),
+          pushInFlight: false
+        });
+        console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Started observing ${wd}`);
+        schedulePushForWorkingDir(wd, "safety-poll");
+        addedCount++;
+      }
+    }
+    if (addedCount > 0 || removedCount > 0) {
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observing ${observedWorkingDirs.size} working dir(s)`);
+    }
+    for (const wd of refreshedWorkingDirs) {
+      if (observedWorkingDirs.has(wd)) {
+        console.log(`[${formatTimestamp()}] \uD83D\uDD04 Refresh triggered for ${wd}`);
+        schedulePushForWorkingDir(wd, "refresh");
+      }
+    }
+  }
+  function schedulePushForWorkingDir(workingDir, reason = "safety-poll") {
+    if (stopped)
+      return;
+    const state = observedWorkingDirs.get(workingDir);
+    if (!state)
+      return;
+    if (state.pushInFlight) {
+      if (reason === "refresh") {
+        pendingRefresh.set(workingDir, true);
+      }
+      const current = skippedPushCount.get(workingDir) ?? 0;
+      skippedPushCount.set(workingDir, current + 1);
+      console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Skipping observed push for ${workingDir} (${reason}, in flight)`);
+      return;
+    }
+    state.pushInFlight = true;
+    pushForWorkingDir(workingDir, reason).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Push failed for ${workingDir}: ${getErrorMessage(err)}`);
+    }).finally(() => {
+      const s = observedWorkingDirs.get(workingDir);
+      if (s) {
+        s.pushInFlight = false;
+        if (pendingRefresh.get(workingDir)) {
+          pendingRefresh.delete(workingDir);
+          schedulePushForWorkingDir(workingDir, "refresh");
+        }
+      }
+    });
+  }
+  async function pushForWorkingDir(workingDir, reason = "safety-poll") {
+    await pushSingleWorkspaceGitSummaryForObserved(ctx, workingDir, reason).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Observed git summary push failed for ${workingDir}: ${getErrorMessage(err)}`);
+    });
+    await pushSingleWorkspaceCommands(ctx, workingDir).catch((err) => {
+      console.warn(`[${formatTimestamp()}] ⚠️ Command sync failed for ${workingDir}: ${getErrorMessage(err)}`);
+    });
+  }
+}
+var init_observed_sync = __esm(() => {
+  init_api3();
+  init_git_heartbeat();
+  init_command_sync_heartbeat();
+  init_convex_error();
+});
+
 // src/commands/machine/daemon-start/handlers/ping.ts
 function handlePing() {
   console.log(`   ↪ Responding: pong`);
@@ -56661,7 +59367,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 +59377,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 +59390,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 +59404,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 +59417,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 +59664,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 +59979,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: {
@@ -57399,6 +60112,15 @@ var init_agent_process_manager = __esm(() => {
   init_api3();
 });
 
+// ../../services/backend/config/featureFlags.ts
+var featureFlags;
+var init_featureFlags = __esm(() => {
+  featureFlags = {
+    observedSyncEnabled: false,
+    disableLogin: false
+  };
+});
+
 // src/commands/machine/daemon-start/init.ts
 import { stat as stat2 } from "node:fs/promises";
 async function discoverModels(agentServices) {
@@ -57481,8 +60203,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 +60215,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 +60230,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 +60248,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 +60301,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 +60335,7 @@ async function initDaemon() {
       });
       const events = new DaemonEventBus;
       const ctx = {
-        client: client2,
+        client: client4,
         sessionId: typedSessionId,
         machineId,
         config: config3,
@@ -57621,7 +60343,8 @@ async function initDaemon() {
         events,
         agentServices,
         lastPushedGitState: new Map,
-        lastPushedModels: availableModels
+        lastPushedModels: availableModels,
+        observedSyncEnabled: featureFlags.observedSyncEnabled ?? false
       };
       registerEventListeners(ctx);
       logStartup(ctx, availableModels);
@@ -57663,6 +60386,7 @@ var init_init2 = __esm(() => {
   init_convex_error();
   init_version();
   init_pid();
+  init_featureFlags();
   AUTH_WAIT_TIMEOUT_MS = 5 * 60 * 1000;
 });
 
@@ -58006,12 +60730,14 @@ async function startCommandLoop(ctx) {
     }).then(() => {
       heartbeatCount++;
       console.log(`[${formatTimestamp()}] \uD83D\uDC93 Daemon heartbeat #${heartbeatCount} OK`);
-      pushGitState(ctx).catch((err) => {
-        console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
-      });
-      pushCommands(ctx).catch((err) => {
-        console.warn(`[${formatTimestamp()}] ⚠️  Command sync failed: ${getErrorMessage(err)}`);
-      });
+      if (!ctx.observedSyncEnabled) {
+        pushGitState(ctx).catch((err) => {
+          console.warn(`[${formatTimestamp()}] ⚠️  Git state push failed: ${getErrorMessage(err)}`);
+        });
+        pushCommands(ctx).catch((err) => {
+          console.warn(`[${formatTimestamp()}] ⚠️  Command sync failed: ${getErrorMessage(err)}`);
+        });
+      }
     }).catch((err) => {
       console.warn(`[${formatTimestamp()}] ⚠️  Daemon heartbeat failed: ${getErrorMessage(err)}`);
     });
@@ -58020,8 +60746,13 @@ async function startCommandLoop(ctx) {
   let gitSubscriptionHandle = null;
   let fileContentSubscriptionHandle = null;
   let fileTreeSubscriptionHandle = null;
-  pushGitState(ctx).catch(() => {});
-  pushCommands(ctx).catch(() => {});
+  let observedSyncSubscriptionHandle = null;
+  if (ctx.observedSyncEnabled) {
+    console.log(`[${formatTimestamp()}] \uD83D\uDC41️ Observed-sync enabled, skipping immediate push`);
+  } else {
+    pushGitState(ctx).catch(() => {});
+    pushCommands(ctx).catch(() => {});
+  }
   const shutdown = async () => {
     console.log(`
 [${formatTimestamp()}] Shutting down...`);
@@ -58032,6 +60763,8 @@ async function startCommandLoop(ctx) {
       fileContentSubscriptionHandle.stop();
     if (fileTreeSubscriptionHandle)
       fileTreeSubscriptionHandle.stop();
+    if (observedSyncSubscriptionHandle)
+      observedSyncSubscriptionHandle.stop();
     await onDaemonShutdown(ctx);
     if (ctx.stopLocalApi) {
       await ctx.stopLocalApi().catch(() => {});
@@ -58046,6 +60779,9 @@ async function startCommandLoop(ctx) {
   gitSubscriptionHandle = startGitRequestSubscription(ctx, wsClient2);
   fileContentSubscriptionHandle = startFileContentSubscription(ctx, wsClient2);
   fileTreeSubscriptionHandle = startFileTreeSubscription(ctx, wsClient2);
+  if (ctx.observedSyncEnabled) {
+    observedSyncSubscriptionHandle = startObservedSyncSubscription(ctx, wsClient2);
+  }
   console.log(`
 Listening for commands...`);
   console.log(`Press Ctrl+C to stop
@@ -58092,6 +60828,7 @@ var init_command_loop = __esm(() => {
   init_file_content_subscription();
   init_file_tree_subscription();
   init_git_subscription();
+  init_observed_sync();
   init_command_runner();
   init_init2();
   init_api3();
@@ -58188,12 +60925,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 +61355,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 +61929,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=C6BB51F249BBA12864756E2164756E21
 //# sourceMappingURL=index.js.map