@rzx/ohs 1.1.16 → 1.1.17

package/dist/frontend/index.js

@@ -128,91 +128,6 @@ var init_session = __esm(() => {
   };
 });
 
-// ../../packages/protocol/src/runtime-config.ts
-function isRecord(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function stringValue(value) {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-function numberValue(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
-}
-function stringArrayValue(value) {
-  if (!Array.isArray(value))
-    return;
-  const items = value.filter((item) => typeof item === "string" && item.trim().length > 0);
-  return items.length > 0 ? items : undefined;
-}
-function permissionModeValue(value) {
-  return value === "default" || value === "plan" || value === "full_auto" ? value : undefined;
-}
-function effortValue(value) {
-  return value === "low" || value === "medium" || value === "high" ? value : undefined;
-}
-function sessionModeValue(value) {
-  return value === "coordinator" ? "coordinator" : value === "direct" ? "direct" : undefined;
-}
-function apiFormatValue(value) {
-  return value === "anthropic" || value === "openai" ? value : undefined;
-}
-function booleanValue(value) {
-  return typeof value === "boolean" ? value : undefined;
-}
-function readRuntimeMetadata(metadata) {
-  return isRecord(metadata?.runtime) ? metadata.runtime : {};
-}
-function readSessionRuntimeConfig(session, defaults) {
-  const runtime = readRuntimeMetadata(session.metadata);
-  const model = stringValue(runtime.model);
-  if (!model) {
-    throw new Error(`Session runtime config is missing metadata.runtime.model: ${session.id}`);
-  }
-  return {
-    model,
-    ...stringValue(runtime.provider) ?? defaults?.provider ? { provider: stringValue(runtime.provider) ?? defaults?.provider } : {},
-    ...stringValue(runtime.baseUrl) ?? defaults?.baseUrl ? { baseUrl: stringValue(runtime.baseUrl) ?? defaults?.baseUrl } : {},
-    ...apiFormatValue(runtime.apiFormat) ?? defaults?.apiFormat ? { apiFormat: apiFormatValue(runtime.apiFormat) ?? defaults?.apiFormat } : {},
-    ...permissionModeValue(runtime.permissionMode) ?? defaults?.permissionMode ? { permissionMode: permissionModeValue(runtime.permissionMode) ?? defaults?.permissionMode } : {},
-    ...numberValue(runtime.maxTurns) ?? defaults?.maxTurns ? { maxTurns: numberValue(runtime.maxTurns) ?? defaults?.maxTurns } : {},
-    ...effortValue(runtime.effort) ?? defaults?.effort ? { effort: effortValue(runtime.effort) ?? defaults?.effort } : {},
-    ...sessionModeValue(runtime.sessionMode) ?? defaults?.sessionMode ? { sessionMode: sessionModeValue(runtime.sessionMode) ?? defaults?.sessionMode } : {},
-    ...stringValue(runtime.systemPrompt) ?? defaults?.systemPrompt ? { systemPrompt: stringValue(runtime.systemPrompt) ?? defaults?.systemPrompt } : {},
-    ...stringArrayValue(runtime.allowedTools) ?? defaults?.allowedTools ? { allowedTools: stringArrayValue(runtime.allowedTools) ?? defaults?.allowedTools } : {},
-    ...stringArrayValue(runtime.disallowedTools) ?? defaults?.disallowedTools ? { disallowedTools: stringArrayValue(runtime.disallowedTools) ?? defaults?.disallowedTools } : {},
-    ...(booleanValue(runtime.pluginsEnabled) ?? defaults?.pluginsEnabled) !== undefined ? { pluginsEnabled: booleanValue(runtime.pluginsEnabled) ?? defaults?.pluginsEnabled } : {}
-  };
-}
-function patchSessionRuntimeMetadata(metadata, patch) {
-  const runtime = {
-    ...readRuntimeMetadata(metadata),
-    ...stripUndefined(patch)
-  };
-  return {
-    ...metadata,
-    runtime
-  };
-}
-function stripUndefined(input) {
-  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
-}
-
-// ../../packages/protocol/src/session-input-items.ts
-var SESSION_INPUT_LIMITS;
-var init_session_input_items = __esm(() => {
-  SESSION_INPUT_LIMITS = {
-    maxItems: 256,
-    maxSkills: 32,
-    maxTextBytes: 1024 * 1024,
-    maxNameChars: 128,
-    maxDisplayNameChars: 256
-  };
-});
-
-// ../../packages/protocol/src/requests.ts
-var init_requests = __esm(() => {
-  init_session_input_items();
-});
 // ../../packages/protocol/src/serialization.ts
 function object(value, path) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -603,6 +518,138 @@ var init_serialization = __esm(() => {
     }
   };
 });
+
+// ../../packages/protocol/src/runtime-config.ts
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function stringValue(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function numberValue(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+function stringArrayValue(value) {
+  if (!Array.isArray(value))
+    return;
+  const items = value.filter((item) => typeof item === "string" && item.trim().length > 0);
+  return items.length > 0 ? items : undefined;
+}
+function permissionModeValue(value) {
+  return value === "default" || value === "plan" || value === "full_auto" ? value : undefined;
+}
+function effortValue(value) {
+  return value === "low" || value === "medium" || value === "high" ? value : undefined;
+}
+function sessionModeValue(value) {
+  return value === "coordinator" ? "coordinator" : value === "direct" ? "direct" : undefined;
+}
+function apiFormatValue(value) {
+  return value === "anthropic" || value === "openai" ? value : undefined;
+}
+function booleanValue(value) {
+  return typeof value === "boolean" ? value : undefined;
+}
+function readRuntimeMetadata(metadata) {
+  const runtime = metadata?.runtime;
+  if (runtime === undefined)
+    return {};
+  if (!isRecord(runtime))
+    throw new ProtocolDataError("metadata.runtime must be an object", "metadata.runtime");
+  for (const [field, value] of Object.entries(runtime)) {
+    let valid = false;
+    switch (field) {
+      case "model":
+      case "provider":
+      case "baseUrl":
+      case "systemPrompt":
+        valid = typeof value === "string";
+        break;
+      case "apiFormat":
+        valid = apiFormatValue(value) !== undefined;
+        break;
+      case "permissionMode":
+        valid = permissionModeValue(value) !== undefined;
+        break;
+      case "effort":
+        valid = effortValue(value) !== undefined;
+        break;
+      case "sessionMode":
+        valid = sessionModeValue(value) !== undefined;
+        break;
+      case "maxTurns":
+        valid = numberValue(value) !== undefined;
+        break;
+      case "pluginsEnabled":
+        valid = booleanValue(value) !== undefined;
+        break;
+      case "allowedTools":
+      case "disallowedTools":
+        valid = Array.isArray(value) && value.every((item) => typeof item === "string" && item.trim().length > 0);
+        break;
+    }
+    if (!valid) {
+      throw new ProtocolDataError(`Invalid runtime config field metadata.runtime.${field}`, `metadata.runtime.${field}`);
+    }
+  }
+  return runtime;
+}
+function readSessionRuntimeConfig(session, defaults) {
+  const runtime = readRuntimeMetadata(session.metadata);
+  const model = stringValue(runtime.model);
+  if (!model) {
+    throw new Error(`Session runtime config is missing metadata.runtime.model: ${session.id}`);
+  }
+  return {
+    model,
+    ...stringValue(runtime.provider) ?? defaults?.provider ? { provider: stringValue(runtime.provider) ?? defaults?.provider } : {},
+    ...stringValue(runtime.baseUrl) ?? defaults?.baseUrl ? { baseUrl: stringValue(runtime.baseUrl) ?? defaults?.baseUrl } : {},
+    ...apiFormatValue(runtime.apiFormat) ?? defaults?.apiFormat ? { apiFormat: apiFormatValue(runtime.apiFormat) ?? defaults?.apiFormat } : {},
+    ...permissionModeValue(runtime.permissionMode) ?? defaults?.permissionMode ? { permissionMode: permissionModeValue(runtime.permissionMode) ?? defaults?.permissionMode } : {},
+    ...numberValue(runtime.maxTurns) ?? defaults?.maxTurns ? { maxTurns: numberValue(runtime.maxTurns) ?? defaults?.maxTurns } : {},
+    ...effortValue(runtime.effort) ?? defaults?.effort ? { effort: effortValue(runtime.effort) ?? defaults?.effort } : {},
+    ...sessionModeValue(runtime.sessionMode) ?? defaults?.sessionMode ? { sessionMode: sessionModeValue(runtime.sessionMode) ?? defaults?.sessionMode } : {},
+    ...stringValue(runtime.systemPrompt) ?? defaults?.systemPrompt ? { systemPrompt: stringValue(runtime.systemPrompt) ?? defaults?.systemPrompt } : {},
+    ...stringArrayValue(runtime.allowedTools) ?? defaults?.allowedTools ? { allowedTools: stringArrayValue(runtime.allowedTools) ?? defaults?.allowedTools } : {},
+    ...stringArrayValue(runtime.disallowedTools) ?? defaults?.disallowedTools ? { disallowedTools: stringArrayValue(runtime.disallowedTools) ?? defaults?.disallowedTools } : {},
+    ...(booleanValue(runtime.pluginsEnabled) ?? defaults?.pluginsEnabled) !== undefined ? { pluginsEnabled: booleanValue(runtime.pluginsEnabled) ?? defaults?.pluginsEnabled } : {}
+  };
+}
+function patchSessionRuntimeMetadata(metadata, patch) {
+  const runtime = {
+    ...readRuntimeMetadata(metadata),
+    ...stripUndefined(patch)
+  };
+  readRuntimeMetadata({ runtime });
+  return {
+    ...metadata,
+    runtime
+  };
+}
+function stripUndefined(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined));
+}
+var init_runtime_config = __esm(() => {
+  init_serialization();
+});
+
+// ../../packages/protocol/src/session-input-items.ts
+var SESSION_INPUT_LIMITS;
+var init_session_input_items = __esm(() => {
+  SESSION_INPUT_LIMITS = {
+    maxItems: 256,
+    maxSkills: 32,
+    maxTextBytes: 1024 * 1024,
+    maxNameChars: 128,
+    maxDisplayNameChars: 256
+  };
+});
+
+// ../../packages/protocol/src/requests.ts
+var init_requests = __esm(() => {
+  init_runtime_config();
+  init_session_input_items();
+});
 // ../../packages/protocol/src/attachment.ts
 function parseAttachmentLimits(value) {
   const record = recordValue(value, "attachment limits");
@@ -794,6 +841,7 @@ function parseAttachmentTransferCapabilities(value) {
     uploadModes
   };
 }
+var CURRENT_PROTOCOL_VERSION = 4, PROTOCOL_VERSION_HEADER = "x-openharness-protocol-version";
 var init_capabilities = __esm(() => {
   init_attachment();
 });
@@ -806,6 +854,7 @@ var init_session_goals = __esm(() => {
 // ../../packages/protocol/src/index.ts
 var init_src = __esm(() => {
   init_session();
+  init_runtime_config();
   init_requests();
   init_serialization();
   init_capabilities();
@@ -814,7 +863,45 @@ var init_src = __esm(() => {
   init_session_goals();
 });
 
-// ../../packages/client/src/transport/http-client.ts
+// ../../packages/client/src/protocol/protocol-client.ts
+class ProtocolClient {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async health(options = {}) {
+    return this.transport.request("/health", {
+      auth: false,
+      signal: options.signal
+    });
+  }
+  async capabilities(options = {}) {
+    const value = await this.transport.request("/capabilities", {
+      auth: false,
+      signal: options.signal
+    });
+    const capabilities = parseServerCapabilities(value);
+    const compatibility = checkProtocolCompatibility(capabilities, options.support ?? { version: CURRENT_PROTOCOL_VERSION });
+    if (!compatibility.compatible) {
+      throw new IncompatibleProtocolError(capabilities, compatibility.reason ?? "Client and server protocol versions are incompatible");
+    }
+    return capabilities;
+  }
+}
+var IncompatibleProtocolError;
+var init_protocol_client = __esm(() => {
+  init_src();
+  IncompatibleProtocolError = class IncompatibleProtocolError extends Error {
+    capabilities;
+    constructor(capabilities, message) {
+      super(message);
+      this.capabilities = capabilities;
+      this.name = "IncompatibleProtocolError";
+    }
+  };
+});
+
+// ../../packages/client/src/transport/http-transport.ts
 function responseField(value, field) {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new ProtocolDataError("Response body must be an object");
@@ -853,14 +940,56 @@ function normalizeDaemonBaseUrl(value) {
   const pathname = url.pathname.replace(/\/+$/, "");
   return `${url.origin}${pathname === "/" ? "" : pathname}`;
 }
-function createPromptRequestId() {
-  if (typeof globalThis.crypto?.randomUUID === "function")
-    return globalThis.crypto.randomUUID();
-  promptRequestCounter += 1;
-  return `prompt-${Date.now().toString(36)}-${promptRequestCounter.toString(36)}`;
+function isReadableStream(value) {
+  return typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
+}
+function attachmentRangeHeader(range) {
+  if (!range)
+    return;
+  const { start, end, suffixBytes } = range;
+  if (suffixBytes !== undefined) {
+    if (start !== undefined || end !== undefined) {
+      throw new Error("suffixBytes cannot be combined with start or end");
+    }
+    assertPositiveSafeInteger(suffixBytes, "suffixBytes");
+    return `bytes=-${suffixBytes}`;
+  }
+  if (start === undefined && end === undefined)
+    return;
+  if (start === undefined) {
+    throw new Error("range start is required when end is provided");
+  }
+  assertNonNegativeSafeInteger(start, "start");
+  if (end === undefined)
+    return `bytes=${start}-`;
+  assertNonNegativeSafeInteger(end, "end");
+  if (end < start)
+    throw new Error("range end must not be less than start");
+  return `bytes=${start}-${end}`;
+}
+function assertNonNegativeSafeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error(`${field} must be a non-negative safe integer`);
+  }
+}
+function assertPositiveSafeInteger(value, field) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error(`${field} must be a positive safe integer`);
+  }
+}
+async function throwResponseError(response) {
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    body = await response.text().catch(() => "");
+  }
+  const message = body && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : body && typeof body === "object" && ("message" in body) && typeof body.message === "string" ? body.message : `OpenHarness API request failed with ${response.status}`;
+  throw new OpenHarnessApiError(message, response.status, body);
 }
 
-class OpenHarnessClient {
+class HttpTransport {
+  protocolHandshake;
   baseUrl;
   token;
   fetchImpl;
@@ -869,162 +998,347 @@ class OpenHarnessClient {
     this.token = options.token;
     this.fetchImpl = options.fetch ?? fetch;
   }
-  async health(options = {}) {
-    return this.request("/health", {
-      auth: false,
-      signal: options.signal
+  isHandshakeExempt(pathname) {
+    const path = pathname.split("?")[0];
+    return path === "/health" || path === "/capabilities";
+  }
+  ensureProtocol(signal) {
+    signal?.throwIfAborted();
+    this.protocolHandshake ??= this.requestUnknown("/capabilities", { auth: false }).then((value) => {
+      const capabilities = parseServerCapabilities(value);
+      const result = checkProtocolCompatibility(capabilities, { version: CURRENT_PROTOCOL_VERSION });
+      if (!result.compatible) {
+        throw new IncompatibleProtocolError(capabilities, result.reason);
+      }
+      return capabilities;
+    }).catch((error) => {
+      this.protocolHandshake = undefined;
+      throw error;
+    });
+    if (!signal)
+      return this.protocolHandshake;
+    return new Promise((resolve, reject) => {
+      const onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+      this.protocolHandshake.then(resolve, reject).finally(() => {
+        signal.removeEventListener("abort", onAbort);
+      });
     });
   }
-  async capabilities(options = {}) {
-    const value = await this.request("/capabilities", {
-      auth: false,
+  headers(jsonOrOptions = false, auth = true) {
+    let json = false;
+    let authHeader = auth;
+    let extra;
+    if (typeof jsonOrOptions === "object" && jsonOrOptions !== null) {
+      json = jsonOrOptions.json ?? false;
+      authHeader = jsonOrOptions.auth ?? true;
+      extra = jsonOrOptions.extra;
+    } else {
+      json = Boolean(jsonOrOptions);
+      authHeader = auth;
+    }
+    return {
+      ...authHeader && this.token ? { authorization: `Bearer ${this.token}` } : {},
+      ...json ? { "content-type": "application/json" } : {},
+      ...extra ?? {}
+    };
+  }
+  path(pathname, query = {}) {
+    const params = new URLSearchParams;
+    for (const [key, value] of Object.entries(query)) {
+      if (value === undefined || value === null || value === false)
+        continue;
+      params.set(key, String(value));
+    }
+    const qs = params.toString();
+    return qs ? `${pathname}?${qs}` : pathname;
+  }
+  resolveUrl(pathname, query) {
+    const resolvedPath = query ? this.path(pathname, query) : pathname;
+    return `${this.baseUrl}${resolvedPath}`;
+  }
+  async request(path, options = {}) {
+    const business = !this.isHandshakeExempt(path);
+    if (business)
+      await this.ensureProtocol(options.signal);
+    options.signal?.throwIfAborted();
+    const url = this.resolveUrl(path, options.query);
+    const hasJsonBody = options.body !== undefined;
+    const headers = mergeHeaders(this.headers(hasJsonBody, options.auth ?? true), options.headers);
+    if (business)
+      headers[PROTOCOL_VERSION_HEADER] = String(CURRENT_PROTOCOL_VERSION);
+    const response = await this.fetchImpl(url, {
+      method: options.method ?? "GET",
+      headers,
+      body: hasJsonBody ? JSON.stringify(options.body) : undefined,
       signal: options.signal
     });
-    const capabilities = parseServerCapabilities(value);
-    const compatibility = checkProtocolCompatibility(capabilities, options.support ?? { version: 2 });
-    if (!compatibility.compatible) {
-      throw new IncompatibleProtocolError(capabilities, compatibility.reason ?? "Client and server protocol versions are incompatible");
+    if (!response.ok) {
+      await throwResponseError(response);
     }
-    return capabilities;
+    return await response.json();
   }
-  async uploadAttachment(input) {
-    const headers = this.headers();
-    headers["x-openharness-filename"] = encodeURIComponent(input.displayName);
-    if (input.mediaType)
-      headers["content-type"] = input.mediaType;
+  async requestUnknown(path, options = {}) {
+    return this.request(path, options);
+  }
+  async requestResponse(path, options = {}) {
+    const business = !this.isHandshakeExempt(path);
+    if (business)
+      await this.ensureProtocol(options.signal ?? undefined);
+    options.signal?.throwIfAborted();
+    const url = this.resolveUrl(path, options.query);
+    const auth = options.auth ?? true;
+    const headers = mergeHeaders(this.headers(false, auth), options.headers);
+    if (business)
+      headers[PROTOCOL_VERSION_HEADER] = String(CURRENT_PROTOCOL_VERSION);
     const init = {
-      method: "POST",
-      headers,
-      body: input.body,
-      signal: input.signal
+      ...options,
+      headers
     };
-    if (isReadableStream(input.body))
+    if (isReadableStream(init.body) && !init.duplex) {
       init.duplex = "half";
-    const response = await this.fetchImpl(`${this.baseUrl}/attachments`, init);
-    if (!response.ok)
-      await this.throwResponseError(response);
-    return parseAttachmentAssetRecord(await response.json());
-  }
-  async getAttachment(id, options = {}) {
-    const value = await this.request(`/attachments/${encodeURIComponent(id)}`, { signal: options.signal });
-    return parseAttachmentAssetRecord(value);
-  }
-  async downloadAttachment(id, options = {}) {
-    const range = attachmentRangeHeader(options.range);
-    const headers = this.headers();
-    if (range)
-      headers.range = range;
-    const response = await this.fetchImpl(`${this.baseUrl}/attachments/${encodeURIComponent(id)}/content`, { method: "GET", headers, signal: options.signal });
-    if (!response.ok)
-      await this.throwResponseError(response);
+    }
+    const response = await this.fetchImpl(url, init);
+    if (!response.ok) {
+      await throwResponseError(response);
+    }
     return response;
   }
-  async deleteAttachment(id, options = {}) {
-    const value = await this.request(`/attachments/${encodeURIComponent(id)}`, { method: "DELETE", signal: options.signal });
-    return parseAttachmentAssetRecord(value);
+  async throwResponseError(response) {
+    return throwResponseError(response);
   }
-  async scanAttachmentStorage(options = {}) {
-    return await this.request("/attachments/storage", {
-      signal: options.signal
-    });
+}
+function mergeHeaders(defaults, overrides) {
+  const headers = new Headers(defaults);
+  if (overrides) {
+    new Headers(overrides).forEach((value, key) => headers.set(key, value));
   }
-  async repairAttachmentStorage(options = {}) {
-    return await this.request("/attachments/storage/actions", {
-      method: "POST",
-      body: { action: "repair-safe" },
-      signal: options.signal
-    });
+  return Object.fromEntries(headers.entries());
+}
+var OpenHarnessApiError;
+var init_http_transport = __esm(() => {
+  init_src();
+  init_protocol_client();
+  OpenHarnessApiError = class OpenHarnessApiError extends Error {
+    status;
+    body;
+    constructor(message, status, body) {
+      super(message);
+      this.status = status;
+      this.body = body;
+      this.name = "OpenHarnessApiError";
+    }
+  };
+});
+
+// ../../packages/client/src/transport/sse-transport.ts
+function parseRawSseFrame(frame) {
+  let id;
+  let event;
+  let retry;
+  const dataLines = [];
+  for (const line of frame.split(/\r?\n/)) {
+    if (!line || line.startsWith(":"))
+      continue;
+    if (line.startsWith("data:")) {
+      dataLines.push(line.startsWith("data: ") ? line.slice(6) : line.slice(5));
+    } else if (line.startsWith("event:")) {
+      event = (line.startsWith("event: ") ? line.slice(7) : line.slice(6)).trim();
+    } else if (line.startsWith("id:")) {
+      id = (line.startsWith("id: ") ? line.slice(4) : line.slice(3)).trim();
+    } else if (line.startsWith("retry:")) {
+      const value = (line.startsWith("retry: ") ? line.slice(7) : line.slice(6)).trim();
+      const parsed = parseInt(value, 10);
+      if (!Number.isNaN(parsed)) {
+        retry = parsed;
+      }
+    }
   }
-  async gcAttachmentStorage(options = {}) {
-    return await this.request("/attachments/storage/actions", {
-      method: "POST",
-      body: { action: "gc" },
-      signal: options.signal
-    });
+  if (dataLines.length === 0 && !id && !event && retry === undefined) {
+    return;
   }
-  async handleChannelMessage(input, options = {}) {
-    return await this.request("/channels/messages", { method: "POST", body: input, signal: options.signal });
+  return {
+    id,
+    event,
+    retry,
+    data: dataLines.length > 0 ? dataLines.join(`
+`) : undefined
+  };
+}
+function parseSseFrame(frame) {
+  let data = "";
+  for (const line of frame.split(/\r?\n/)) {
+    if (!line || line.startsWith(":"))
+      continue;
+    if (line.startsWith("data:")) {
+      const slice = line.slice(5).trimStart();
+      data = data ? `${data}
+${slice}` : slice;
+    }
   }
-  async recordChannelDelivery(deliveryId, input, options = {}) {
-    const response = await this.request(`/channels/deliveries/${encodeURIComponent(deliveryId)}/result`, { method: "POST", body: input, signal: options.signal });
-    return response.delivery;
+  if (!data)
+    return;
+  return JSON.parse(data);
+}
+async function* streamServerSentEvents(open, decode = (value) => value) {
+  const reader = (await open()).getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      buffer += decoder.decode(chunk.value, { stream: true });
+      const frames = buffer.split(/\r?\n\r?\n/);
+      buffer = frames.pop() ?? "";
+      for (const frame of frames) {
+        const event = parseSseFrame(frame);
+        if (event !== undefined)
+          yield decode(event);
+      }
+    }
+    buffer += decoder.decode();
+    const event = parseSseFrame(buffer);
+    if (event !== undefined)
+      yield decode(event);
+  } finally {
+    reader.releaseLock();
   }
-  async getChannelStatus(options = {}) {
-    const { signal, ...query } = options;
-    return await this.request(this.path("/channels/status", query), { signal });
+}
+
+class SseTransport {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  streamFromReader(open, decode = (val) => val) {
+    return streamServerSentEvents(open, decode);
+  }
+  async* stream(url, options = {}) {
+    let lastEventId = options.lastEventId;
+    let reconnectDelayMs = options.reconnectDelayMs ?? 250;
+    let connected = false;
+    while (!options.signal?.aborted) {
+      const headers = new Headers(options.headers);
+      if (lastEventId)
+        headers.set("Last-Event-ID", lastEventId);
+      const requestUrl = connected && lastEventId ? withoutCursor(url) : url;
+      const response = await this.transport.requestResponse(requestUrl.slice(this.transport.baseUrl.length), { headers, signal: options.signal });
+      connected = true;
+      if (!response.body) {
+        throw new Error(options.noBodyMessage ?? "Event stream response has no body");
+      }
+      for await (const frame of readRawSseFrames(response.body)) {
+        if (frame.id !== undefined)
+          lastEventId = frame.id;
+        if (frame.retry !== undefined)
+          reconnectDelayMs = frame.retry;
+        if (frame.data !== undefined) {
+          yield (options.decode ?? ((value) => value))(JSON.parse(frame.data));
+        }
+      }
+      if (!options.reconnect || options.signal?.aborted)
+        return;
+      await waitForReconnect(reconnectDelayMs, options.signal);
+    }
   }
-  async listPendingChannelDeliveries(options = {}) {
-    const { signal, ...query } = options;
-    const response = await this.request(this.path("/channels/deliveries/pending", query), { signal });
-    return response.deliveries;
+}
+async function* readRawSseFrames(stream) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder;
+  let buffer = "";
+  try {
+    while (true) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      buffer += decoder.decode(chunk.value, { stream: true });
+      const frames = buffer.split(/\r?\n\r?\n/);
+      buffer = frames.pop() ?? "";
+      for (const value of frames) {
+        const frame = parseRawSseFrame(value);
+        if (frame)
+          yield frame;
+      }
+    }
+    buffer += decoder.decode();
+    const frame = parseRawSseFrame(buffer);
+    if (frame)
+      yield frame;
+  } finally {
+    reader.releaseLock();
+  }
+}
+function waitForReconnect(ms, signal) {
+  if (signal?.aborted)
+    return Promise.reject(abortError(signal));
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, Math.max(0, ms));
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(abortError(signal));
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function abortError(signal) {
+  if (signal.reason instanceof Error)
+    return signal.reason;
+  return new DOMException("Aborted", "AbortError");
+}
+function withoutCursor(url) {
+  const parsed = new URL(url);
+  parsed.searchParams.delete("cursor");
+  return parsed.toString();
+}
+
+// ../../packages/client/src/protocol/index.ts
+var init_protocol = __esm(() => {
+  init_protocol_client();
+});
+
+// ../../packages/client/src/resources/system-resource.ts
+class SystemResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
   }
   async listCommands(options) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/commands", query), { signal });
+    const response = await this.transport.request(this.transport.path("/commands", query), { signal });
     return response.commands;
   }
   async getSettings(options = {}) {
-    const response = await this.request("/settings", { signal: options.signal });
+    const response = await this.transport.request("/settings", { signal: options.signal });
     return response.settings;
   }
   async patchSettings(patch, options = {}) {
-    const response = await this.request("/settings", {
+    const response = await this.transport.request("/settings", {
       method: "PATCH",
       body: patch,
       signal: options.signal
     });
     return response.settings;
   }
-  async listProviders(options = {}) {
-    const response = await this.request("/providers", { signal: options.signal });
-    return response.providers;
-  }
-  async createCustomProvider(input, options = {}) {
-    const response = await this.request("/providers/custom", {
-      method: "POST",
-      body: input,
-      signal: options.signal
-    });
-    return response.provider;
-  }
-  async connectCatalogProvider(id, apiKey, options = {}) {
-    const response = await this.request(`/providers/catalog/${encodeURIComponent(id)}/connect`, { method: "POST", body: { apiKey }, signal: options.signal });
-    return response.provider;
-  }
-  async disconnectCatalogProvider(id, options = {}) {
-    await this.request(`/providers/catalog/${encodeURIComponent(id)}/connect`, { method: "DELETE", signal: options.signal });
-  }
-  async updateCustomProvider(id, input, options = {}) {
-    const response = await this.request(`/providers/custom/${encodeURIComponent(id)}`, { method: "PATCH", body: input, signal: options.signal });
-    return response.provider;
-  }
-  async removeCustomProvider(id, options = {}) {
-    await this.request(`/providers/custom/${encodeURIComponent(id)}`, {
-      method: "DELETE",
-      signal: options.signal
-    });
-  }
-  async listModels(options = {}) {
-    const response = await this.request("/models", { signal: options.signal });
-    return response.providers;
-  }
   async getSessionMcp(sessionId, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/mcp`, { signal: options.signal });
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/mcp`, { signal: options.signal });
     return response.servers;
   }
   async listMemory(options) {
     const { signal, ...query } = options;
-    return await this.request(this.path("/memory", query), {
-      signal
-    });
+    return await this.transport.request(this.transport.path("/memory", query), { signal });
   }
   async getMemory(entryId, options) {
     const { signal, cwd } = options;
-    const response = await this.request(this.path(`/memory/${encodeURIComponent(entryId)}`, { cwd }), { signal });
+    const response = await this.transport.request(this.transport.path(`/memory/${encodeURIComponent(entryId)}`, { cwd }), { signal });
     return response.entry;
   }
   async addMemory(input, options = {}) {
-    const response = await this.request("/memory", {
+    const response = await this.transport.request("/memory", {
       method: "POST",
       body: input,
       signal: options.signal
@@ -1033,36 +1347,21 @@ class OpenHarnessClient {
   }
   async removeMemory(entryId, options) {
     const { signal, cwd } = options;
-    await this.request(this.path(`/memory/${encodeURIComponent(entryId)}`, { cwd }), { method: "DELETE", signal });
-  }
-  async getAuthStatus(options = {}) {
-    const response = await this.request("/auth", {
-      signal: options.signal
-    });
-    return response.auth;
-  }
-  async authLogin(input, options = {}) {
-    return await this.request("/auth/login", {
-      method: "POST",
-      body: input,
-      signal: options.signal
-    });
+    await this.transport.request(this.transport.path(`/memory/${encodeURIComponent(entryId)}`, { cwd }), { method: "DELETE", signal });
   }
-  async authLogout(input, options = {}) {
-    return await this.request("/auth/logout", {
-      method: "POST",
-      body: input,
-      signal: options.signal
-    });
+  async listContextPlugins(options) {
+    const { signal, ...query } = options;
+    const response = await this.transport.request(this.transport.path("/context/plugins", query), { signal });
+    return response.plugins;
   }
   async getContextPreview(options) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/context", query), { signal });
+    const response = await this.transport.request(this.transport.path("/context", query), { signal });
     return response.report;
   }
   async getContextStatus(options) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/context/status", query), { signal });
+    const response = await this.transport.request(this.transport.path("/context/status", query), { signal });
     return response.report;
   }
   async getContextUsage(options) {
@@ -1072,357 +1371,559 @@ class OpenHarnessClient {
       ...refresh !== undefined ? { refresh: refresh ? "true" : "false" } : {},
       ...previousContextWindow !== undefined ? { previousContextWindow: String(previousContextWindow) } : {}
     };
-    return await this.request(this.path("/context/usage", query), { signal });
-  }
-  async compactSession(sessionId, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/compact`, { method: "POST", signal: options.signal });
-  }
-  async getSessionGoal(sessionId) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/goal`);
-    return response.goal;
-  }
-  async createSessionGoal(sessionId, input) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/goals`, { method: "POST", body: input });
-    return response.goal;
-  }
-  async updateSessionGoal(sessionId, goalId, input) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/goals/${encodeURIComponent(goalId)}`, { method: "PATCH", body: input });
-    return response.goal;
-  }
-  async applySessionGoalAction(sessionId, goalId, input) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/goals/${encodeURIComponent(goalId)}/actions`, { method: "POST", body: input });
-    return response.goal;
-  }
-  async rewindSession(sessionId, input = {}, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/rewind`, { method: "POST", body: input, signal: options.signal });
-  }
-  async rememberSession(sessionId, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/remember`, { method: "POST", signal: options.signal });
+    return await this.transport.request(this.transport.path("/context/usage", query), { signal });
   }
   async startDream(input, options = {}) {
-    return await this.request("/dream", {
+    return await this.transport.request("/dream", {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
   async getProfileStatus(options = {}) {
-    const response = await this.request("/profile", {
+    const response = await this.transport.request("/profile", {
       signal: options.signal
     });
     return response.report;
   }
   async initProfile(options = {}) {
-    const response = await this.request("/profile/init", {
+    const response = await this.transport.request("/profile/init", {
       method: "POST",
       signal: options.signal
     });
     return response.report;
   }
   async listOutputStyles(options = {}) {
-    const response = await this.request("/output-styles", {
+    const response = await this.transport.request("/output-styles", {
       signal: options.signal
     });
     return response.styles;
   }
-  async initProject(input, options = {}) {
-    const response = await this.request("/project/init", {
+}
+
+// ../../packages/client/src/resources/provider-resource.ts
+class ProviderResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async listProviders(options = {}) {
+    const response = await this.transport.request("/providers", { signal: options.signal });
+    return response.providers;
+  }
+  async createCustomProvider(input, options = {}) {
+    const response = await this.transport.request("/providers/custom", {
+      method: "POST",
+      body: input,
+      signal: options.signal
+    });
+    return response.provider;
+  }
+  async connectCatalogProvider(id, apiKeyOrInput, options = {}) {
+    const body = typeof apiKeyOrInput === "string" ? { apiKey: apiKeyOrInput } : apiKeyOrInput;
+    const response = await this.transport.request(`/providers/catalog/${encodeURIComponent(id)}/connect`, { method: "POST", body, signal: options.signal });
+    return response.provider;
+  }
+  async updateCatalogProviderHeaders(id, headers, options = {}) {
+    const response = await this.transport.request(`/providers/catalog/${encodeURIComponent(id)}`, {
+      method: "PATCH",
+      body: { headers },
+      signal: options.signal
+    });
+    return response.provider;
+  }
+  async disconnectCatalogProvider(id, options = {}) {
+    await this.transport.request(`/providers/catalog/${encodeURIComponent(id)}/connect`, { method: "DELETE", signal: options.signal });
+  }
+  async updateCustomProvider(id, input, options = {}) {
+    const response = await this.transport.request(`/providers/custom/${encodeURIComponent(id)}`, { method: "PATCH", body: input, signal: options.signal });
+    return response.provider;
+  }
+  async removeCustomProvider(id, options = {}) {
+    await this.transport.request(`/providers/custom/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+      signal: options.signal
+    });
+  }
+  async listModels(options = {}) {
+    const response = await this.transport.request("/models", { signal: options.signal });
+    return response.providers;
+  }
+}
+
+// ../../packages/client/src/resources/auth-resource.ts
+class AuthResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getStatus(options = {}) {
+    const response = await this.transport.request("/auth", {
+      signal: options.signal
+    });
+    return response.auth;
+  }
+  async login(input, options = {}) {
+    return await this.transport.request("/auth/login", {
+      method: "POST",
+      body: input,
+      signal: options.signal
+    });
+  }
+  async logout(input, options = {}) {
+    return await this.transport.request("/auth/logout", {
+      method: "POST",
+      body: input,
+      signal: options.signal
+    });
+  }
+}
+
+// ../../packages/client/src/resources/project-resource.ts
+class ProjectResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(options = {}) {
+    const { signal, ...query } = options;
+    const response = await this.transport.request(this.transport.path("/projects", query), { signal });
+    return response.projects;
+  }
+  async inspect(path) {
+    return (await this.transport.request("/projects/inspect", {
+      method: "POST",
+      body: { path }
+    })).project;
+  }
+  async rename(projectId, name) {
+    return (await this.transport.request(`/projects/${encodeURIComponent(projectId)}`, { method: "PATCH", body: { name } })).project;
+  }
+  async setPinned(projectId, pinned) {
+    return (await this.transport.request(`/projects/${encodeURIComponent(projectId)}`, { method: "PATCH", body: { pinned } })).project;
+  }
+  async setDefaultShell(projectId, defaultShell) {
+    return (await this.transport.request(`/projects/${encodeURIComponent(projectId)}`, { method: "PATCH", body: { defaultShell } })).project;
+  }
+  async rebind(projectId, path) {
+    return (await this.transport.request(`/projects/${encodeURIComponent(projectId)}/rebind`, { method: "POST", body: { path } })).project;
+  }
+  async archive(projectId) {
+    return (await this.transport.request(`/projects/${encodeURIComponent(projectId)}`, { method: "DELETE" })).project;
+  }
+  async init(input, options = {}) {
+    const response = await this.transport.request("/project/init", {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return response.report;
   }
-  async listPlugins(options) {
+}
+
+// ../../packages/client/src/resources/plugin-resource.ts
+class PluginResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async list(options) {
     const { signal, ...query } = options;
-    return await this.request(this.path("/plugins", query), { signal });
+    return await this.transport.request(this.transport.path("/plugins", query), { signal });
+  }
+  async enable(id, input, options = {}) {
+    return await this.transport.request(`/plugins/${encodeURIComponent(id)}/enable`, { method: "POST", body: input, signal: options.signal });
+  }
+  async disable(id, input, options = {}) {
+    return await this.transport.request(`/plugins/${encodeURIComponent(id)}/disable`, { method: "POST", body: input, signal: options.signal });
   }
-  async enablePlugin(id, input, options = {}) {
-    return await this.request(`/plugins/${encodeURIComponent(id)}/enable`, { method: "POST", body: input, signal: options.signal });
+  async installLocal(input) {
+    return await this.transport.request(input.link ? "/plugins/link-local" : "/plugins/install-local", { method: "POST", body: input });
   }
-  async disablePlugin(id, input, options = {}) {
-    return await this.request(`/plugins/${encodeURIComponent(id)}/disable`, { method: "POST", body: input, signal: options.signal });
+  async previewArchive(input, options = {}) {
+    return await this.transport.request("/plugins/archive/preview", {
+      method: "POST",
+      body: input,
+      signal: options.signal
+    });
   }
-  async installLocalPlugin(input) {
-    return await this.request(input.link ? "/plugins/link-local" : "/plugins/install-local", { method: "POST", body: input });
+  async installArchive(input, options = {}) {
+    return await this.transport.request("/plugins/archive/install", {
+      method: "POST",
+      body: input,
+      signal: options.signal
+    });
   }
-  async previewPluginArchive(input, options = {}) {
-    return await this.request("/plugins/archive/preview", {
+  async previewGit(input, options = {}) {
+    return await this.transport.request("/plugins/git/preview", {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
-  async installPluginArchive(input, options = {}) {
-    return await this.request("/plugins/archive/install", {
+  async installGit(input, options = {}) {
+    return await this.transport.request("/plugins/git/install", {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
-  async uninstallPlugin(id, input) {
-    return await this.request(`/plugins/${encodeURIComponent(id)}`, { method: "DELETE", body: input });
+  async uninstall(id, input) {
+    return await this.transport.request(`/plugins/${encodeURIComponent(id)}`, { method: "DELETE", body: input });
   }
-  async reloadPlugins(input, options = {}) {
-    return await this.request("/plugins/reload", {
+  async reload(input, options = {}) {
+    return await this.transport.request("/plugins/reload", {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
+}
+
+// ../../packages/client/src/resources/development-resource.ts
+class DevelopmentResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
   async listSkills(options = {}) {
-    return await this.request("/skills", {
+    return await this.transport.request("/skills", {
       signal: options.signal
     });
   }
   async removeSkill(id, input, options = {}) {
-    return await this.request(`/skills/${encodeURIComponent(id)}`, {
+    return await this.transport.request(`/skills/${encodeURIComponent(id)}`, {
       method: "DELETE",
       body: input,
       signal: options.signal
     });
   }
   async listAgentPersonas(options = {}) {
-    const response = await this.request("/agent-personas", {
+    const response = await this.transport.request("/agent-personas", {
       signal: options.signal
     });
     return response.agents;
   }
   async listHooks(options) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/hooks", query), { signal });
+    const response = await this.transport.request(this.transport.path("/hooks", query), { signal });
     return response.hooks;
   }
   async getGitDiff(options) {
     const { signal, cwd, full } = options;
-    const response = await this.request(this.path("/git/diff", { cwd, ...full ? { full: "true" } : {} }), { signal });
+    const response = await this.transport.request(this.transport.path("/git/diff", { cwd, ...full ? { full: "true" } : {} }), { signal });
     return response.output;
   }
   async getGitBranch(options) {
     const { signal, cwd, list } = options;
-    const response = await this.request(this.path("/git/branch", { cwd, ...list ? { list: "true" } : {} }), { signal });
+    const response = await this.transport.request(this.transport.path("/git/branch", { cwd, ...list ? { list: "true" } : {} }), { signal });
     return response.output;
   }
   async getGitStatus(options) {
     const { signal, cwd } = options;
-    const response = await this.request(this.path("/git/status", { cwd }), { signal });
+    const response = await this.transport.request(this.transport.path("/git/status", { cwd }), { signal });
     return response.output;
   }
   async gitCommit(input, options = {}) {
-    const response = await this.request("/git/commit", {
+    const response = await this.transport.request("/git/commit", {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return response.output;
   }
-  async getSessionUsage(sessionId, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/usage`, { signal: options.signal });
+}
+
+// ../../packages/client/src/resources/session-resource.ts
+function createPromptRequestId() {
+  if (typeof globalThis.crypto?.randomUUID === "function") {
+    return globalThis.crypto.randomUUID();
   }
-  async exportSession(sessionId, input = {}, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/export`, { method: "POST", body: input, signal: options.signal });
+  promptRequestCounter += 1;
+  return `prompt-${Date.now().toString(36)}-${promptRequestCounter.toString(36)}`;
+}
+
+class SessionResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
   }
-  async listSessions(options = {}) {
+  async list(options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/sessions", query), { signal });
+    const response = await this.transport.request(this.transport.path("/sessions", query), { signal });
     return response.sessions;
   }
-  async listProjects(options = {}) {
-    const { signal, ...query } = options;
-    const response = await this.request(this.path("/projects", query), { signal });
-    return response.projects;
-  }
-  async inspectProject(path) {
-    return (await this.request("/projects/inspect", {
-      method: "POST",
-      body: { path }
-    })).project;
-  }
-  async renameProject(projectId, name) {
-    return (await this.request(`/projects/${encodeURIComponent(projectId)}`, { method: "PATCH", body: { name } })).project;
-  }
-  async setProjectPinned(projectId, pinned) {
-    return (await this.request(`/projects/${encodeURIComponent(projectId)}`, { method: "PATCH", body: { pinned } })).project;
-  }
-  async setProjectDefaultShell(projectId, defaultShell) {
-    return (await this.request(`/projects/${encodeURIComponent(projectId)}`, { method: "PATCH", body: { defaultShell } })).project;
-  }
-  async rebindProject(projectId, path) {
-    return (await this.request(`/projects/${encodeURIComponent(projectId)}/rebind`, { method: "POST", body: { path } })).project;
-  }
-  async archiveProject(projectId) {
-    return (await this.request(`/projects/${encodeURIComponent(projectId)}`, { method: "DELETE" })).project;
+  async get(sessionId, options = {}) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}`, {
+      signal: options.signal
+    });
+    return response.session;
   }
-  async createSession(input, options = {}) {
-    const response = await this.request("/sessions", {
+  async create(input, options = {}) {
+    const response = await this.transport.request("/sessions", {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return response.session;
   }
-  async getSession(sessionId, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}`, {
+  async update(sessionId, input, options = {}) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}`, {
+      method: "PATCH",
+      body: input,
       signal: options.signal
     });
     return response.session;
   }
-  async forkSession(sessionId, input = {}, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/fork`, {
+  async fork(sessionId, input = {}, options = {}) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/fork`, {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return response.session;
   }
-  async getSessionState(sessionId, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/state`, {
-      signal: options.signal
-    });
-    return decodeSessionStateSnapshot(response);
-  }
-  async archiveSession(sessionId, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}`, {
+  async archive(sessionId, options = {}) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}`, {
       method: "DELETE",
       signal: options.signal
     });
     return response.session;
   }
-  async deleteSession(sessionId, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}/hard`, {
+  async delete(sessionId, options = {}) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/hard`, {
       method: "DELETE",
       signal: options.signal
     });
     return response.deletedSessionIds;
   }
-  async updateSession(sessionId, input, options = {}) {
-    const response = await this.request(`/sessions/${encodeURIComponent(sessionId)}`, {
-      method: "PATCH",
-      body: input,
+  async getState(sessionId, options = {}) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/state`, {
       signal: options.signal
     });
-    return response.session;
+    return decodeSessionStateSnapshot(response);
   }
   async listMessages(sessionId, options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path(`/sessions/${encodeURIComponent(sessionId)}/messages`, query), { signal });
+    const response = await this.transport.request(this.transport.path(`/sessions/${encodeURIComponent(sessionId)}/messages`, query), { signal });
     return response.messages;
   }
   async listMessageParts(sessionId, options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path(`/sessions/${encodeURIComponent(sessionId)}/parts`, query), { signal });
+    const response = await this.transport.request(this.transport.path(`/sessions/${encodeURIComponent(sessionId)}/parts`, query), { signal });
     return response.parts;
   }
   async admitPrompt(sessionId, input, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/prompts`, {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts`, {
       method: "POST",
       body: { ...input, id: input.id ?? createPromptRequestId() },
       signal: options.signal
     });
   }
   async editLatestPrompt(sessionId, input, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/latest/edit`, {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/latest/edit`, {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
-  async promoteQueuedPrompt(sessionId, inputId, input, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/${encodeURIComponent(inputId)}/promote`, { method: "POST", body: input, signal: options.signal });
+  async promoteQueuedPrompt(sessionId, inputId, input, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/${encodeURIComponent(inputId)}/promote`, { method: "POST", body: input, signal: options.signal });
+  }
+  async cancelQueuedPrompt(sessionId, inputId, input, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/${encodeURIComponent(inputId)}/cancel`, { method: "POST", body: input, signal: options.signal });
+  }
+  async resumeInterruptedRun(sessionId, runId, input = {}, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/runs/${encodeURIComponent(runId)}/resume`, {
+      method: "POST",
+      body: { ...input, id: input.id ?? createPromptRequestId() },
+      signal: options.signal
+    });
+  }
+  async interrupt(sessionId, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/interrupt`, {
+      method: "POST",
+      body: options.expectedRunId ? { expectedRunId: options.expectedRunId } : undefined,
+      signal: options.signal
+    });
+  }
+  async compact(sessionId, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/compact`, { method: "POST", signal: options.signal });
+  }
+  async rewind(sessionId, input = {}, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/rewind`, { method: "POST", body: input, signal: options.signal });
+  }
+  async remember(sessionId, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/remember`, { method: "POST", signal: options.signal });
+  }
+  async export(sessionId, input = {}, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/export`, { method: "POST", body: input, signal: options.signal });
+  }
+  async getUsage(sessionId, options = {}) {
+    return await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/usage`, { signal: options.signal });
+  }
+  async getGoal(sessionId) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/goal`);
+    return response.goal;
+  }
+  async createGoal(sessionId, input) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/goals`, { method: "POST", body: input });
+    return response.goal;
+  }
+  async updateGoal(sessionId, goalId, input) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/goals/${encodeURIComponent(goalId)}`, { method: "PATCH", body: input });
+    return response.goal;
+  }
+  async applyGoalAction(sessionId, goalId, input) {
+    const response = await this.transport.request(`/sessions/${encodeURIComponent(sessionId)}/goals/${encodeURIComponent(goalId)}/actions`, { method: "POST", body: input });
+    return response.goal;
+  }
+}
+var promptRequestCounter = 0;
+var init_session_resource = __esm(() => {
+  init_src();
+});
+
+// ../../packages/client/src/resources/attachment-resource.ts
+class AttachmentResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async upload(input) {
+    const headers = {};
+    headers["x-openharness-filename"] = encodeURIComponent(input.displayName);
+    if (input.mediaType)
+      headers["content-type"] = input.mediaType;
+    const response = await this.transport.requestResponse("/attachments", {
+      method: "POST",
+      headers,
+      body: input.body,
+      signal: input.signal
+    });
+    return parseAttachmentAssetRecord(await response.json());
+  }
+  async get(id, options = {}) {
+    const value = await this.transport.request(`/attachments/${encodeURIComponent(id)}`, { signal: options.signal });
+    return parseAttachmentAssetRecord(value);
+  }
+  async download(id, options = {}) {
+    const range = attachmentRangeHeader(options.range);
+    const headers = {};
+    if (range)
+      headers.range = range;
+    return await this.transport.requestResponse(`/attachments/${encodeURIComponent(id)}/content`, { method: "GET", headers, signal: options.signal });
   }
-  async cancelQueuedPrompt(sessionId, inputId, input, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/prompts/${encodeURIComponent(inputId)}/cancel`, { method: "POST", body: input, signal: options.signal });
+  async delete(id, options = {}) {
+    const value = await this.transport.request(`/attachments/${encodeURIComponent(id)}`, { method: "DELETE", signal: options.signal });
+    return parseAttachmentAssetRecord(value);
   }
-  async resumeInterruptedRun(sessionId, runId, input = {}, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/runs/${encodeURIComponent(runId)}/resume`, {
+  async scanStorage(options = {}) {
+    return await this.transport.request("/attachments/storage", { signal: options.signal });
+  }
+  async repairStorage(options = {}) {
+    return await this.transport.request("/attachments/storage/actions", {
       method: "POST",
-      body: { ...input, id: input.id ?? createPromptRequestId() },
+      body: { action: "repair-safe" },
       signal: options.signal
     });
   }
-  async interruptSession(sessionId, options = {}) {
-    return await this.request(`/sessions/${encodeURIComponent(sessionId)}/interrupt`, {
+  async gcStorage(options = {}) {
+    return await this.transport.request("/attachments/storage/actions", {
       method: "POST",
-      body: options.expectedRunId ? { expectedRunId: options.expectedRunId } : undefined,
+      body: { action: "gc" },
       signal: options.signal
     });
   }
-  async listEvents(options = {}) {
-    const { signal, ...query } = options;
-    const response = await this.request(this.path("/events", query), {
-      signal
-    });
-    return responseArray(response, "events", decodeSessionEventRecord);
+}
+var init_attachment_resource = __esm(() => {
+  init_src();
+  init_http_transport();
+});
+
+// ../../packages/client/src/resources/permission-resource.ts
+class PermissionResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
   }
-  async listPermissions(options = {}) {
+  async list(options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/permissions", query), { signal });
+    const response = await this.transport.request(this.transport.path("/permissions", query), { signal });
     return response.requests;
   }
-  async replyPermission(requestId, input, options = {}) {
-    const response = await this.request(`/permissions/${encodeURIComponent(requestId)}/reply`, {
+  async reply(requestId, input, options = {}) {
+    const response = await this.transport.request(`/permissions/${encodeURIComponent(requestId)}/reply`, {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return response.request;
   }
-  async getScheduledTaskStatus(options = {}) {
-    return await this.request("/schedules/status", {
+}
+
+// ../../packages/client/src/resources/schedule-resource.ts
+class ScheduleResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
+  }
+  async getStatus(options = {}) {
+    return await this.transport.request("/schedules/status", {
       signal: options.signal
     });
   }
-  async listScheduledTasks(options = {}) {
+  async listTasks(options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/schedules/tasks", query), { signal });
+    const response = await this.transport.request(this.transport.path("/schedules/tasks", query), { signal });
     return response.tasks;
   }
-  async getScheduledTask(id, options = {}) {
-    const response = await this.request(`/schedules/tasks/${encodeURIComponent(id)}`, { signal: options.signal });
+  async getTask(id, options = {}) {
+    const response = await this.transport.request(`/schedules/tasks/${encodeURIComponent(id)}`, { signal: options.signal });
     return response.task;
   }
-  async createScheduledTask(input, options = {}) {
-    const response = await this.request("/schedules/tasks", {
+  async createTask(input, options = {}) {
+    const response = await this.transport.request("/schedules/tasks", {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return response.task;
   }
-  async updateScheduledTask(id, input, options = {}) {
-    const response = await this.request(`/schedules/tasks/${encodeURIComponent(id)}`, { method: "PATCH", body: input, signal: options.signal });
+  async updateTask(id, input, options = {}) {
+    const response = await this.transport.request(`/schedules/tasks/${encodeURIComponent(id)}`, { method: "PATCH", body: input, signal: options.signal });
     return response.task;
   }
-  async removeScheduledTask(id, options = {}) {
-    await this.request(`/schedules/tasks/${encodeURIComponent(id)}`, {
+  async removeTask(id, options = {}) {
+    await this.transport.request(`/schedules/tasks/${encodeURIComponent(id)}`, {
       method: "DELETE",
       signal: options.signal
     });
   }
-  async triggerScheduledTask(id, options = {}) {
-    const response = await this.request(`/schedules/tasks/${encodeURIComponent(id)}/run`, { method: "POST", signal: options.signal });
+  async triggerTask(id, options = {}) {
+    const response = await this.transport.request(`/schedules/tasks/${encodeURIComponent(id)}/run`, { method: "POST", signal: options.signal });
     return response.run;
   }
-  async listScheduledRuns(options = {}) {
+  async listRuns(options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/schedules/runs", query), { signal });
+    const response = await this.transport.request(this.transport.path("/schedules/runs", query), { signal });
     return response.runs;
   }
-  async setScheduledRunUnread(id, unread, options = {}) {
-    const response = await this.request(`/schedules/runs/${encodeURIComponent(id)}/read`, { method: "PATCH", body: { unread }, signal: options.signal });
+  async setRunUnread(id, unread, options = {}) {
+    const response = await this.transport.request(`/schedules/runs/${encodeURIComponent(id)}/read`, { method: "PATCH", body: { unread }, signal: options.signal });
     return response.run;
   }
-  async createTerminal(input, options = {}) {
-    const response = await this.request("/terminals", {
-      method: "POST",
-      body: input,
-      signal: options.signal
-    });
-    return decodeTerminalSessionInfo(responseField(response, "terminal"));
+}
+
+// ../../packages/client/src/resources/job-resource.ts
+class JobResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
   }
-  async listJobs(options) {
+  async list(options) {
     const { signal, kinds, statuses, includeFinished, ...query } = options;
-    const response = await this.request(this.path("/jobs", {
+    const response = await this.transport.request(this.transport.path("/jobs", {
       ...query,
       ...kinds ? { kinds: kinds.join(",") } : {},
       ...statuses ? { statuses: statuses.join(",") } : {},
@@ -1431,236 +1932,214 @@ class OpenHarnessClient {
     return responseArray(response, "jobs", decodeJobSnapshot);
   }
   async createBackgroundShell(input, options = {}) {
-    return await this.request("/background-shells", {
+    return await this.transport.request("/background-shells", {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
-  async readJob(jobId, options) {
+  async read(jobId, options) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path(`/jobs/${encodeURIComponent(jobId)}`, query), { signal });
+    const response = await this.transport.request(this.transport.path(`/jobs/${encodeURIComponent(jobId)}`, query), { signal });
     return decodeJobReadResult(response);
   }
-  async waitJob(jobId, input, options = {}) {
-    const response = await this.request(`/jobs/${encodeURIComponent(jobId)}/wait`, {
+  async wait(jobId, input, options = {}) {
+    const response = await this.transport.request(`/jobs/${encodeURIComponent(jobId)}/wait`, {
       method: "POST",
       body: input,
       signal: options.signal
     });
     return decodeJobWaitResult(response);
   }
-  async sendJob(jobId, input, options = {}) {
-    await this.request(`/jobs/${encodeURIComponent(jobId)}/input`, {
+  async send(jobId, input, options = {}) {
+    await this.transport.request(`/jobs/${encodeURIComponent(jobId)}/input`, {
       method: "POST",
       body: input,
       signal: options.signal
     });
   }
-  async cancelJob(jobId, input, options = {}) {
-    const response = await this.request(`/jobs/${encodeURIComponent(jobId)}/cancel`, { method: "POST", body: input, signal: options.signal });
+  async cancel(jobId, input, options = {}) {
+    const response = await this.transport.request(`/jobs/${encodeURIComponent(jobId)}/cancel`, { method: "POST", body: input, signal: options.signal });
     return decodeJobSnapshot(responseField(response, "snapshot"));
   }
-  async listTerminals(options = {}) {
+}
+var init_job_resource = __esm(() => {
+  init_src();
+  init_http_transport();
+});
+
+// ../../packages/client/src/resources/terminal-resource.ts
+class TerminalResource {
+  transport;
+  sse;
+  constructor(transport, sse) {
+    this.transport = transport;
+    this.sse = sse;
+  }
+  async create(input, options = {}) {
+    const response = await this.transport.request("/terminals", {
+      method: "POST",
+      body: input,
+      signal: options.signal
+    });
+    return decodeTerminalSessionInfo(responseField(response, "terminal"));
+  }
+  async list(options = {}) {
     const { signal, ...query } = options;
-    const response = await this.request(this.path("/terminals", query), { signal });
+    const response = await this.transport.request(this.transport.path("/terminals", query), { signal });
     return responseArray(response, "terminals", decodeTerminalSessionInfo);
   }
-  async getTerminal(terminalId, options = {}) {
-    const response = await this.request(`/terminals/${encodeURIComponent(terminalId)}`, { signal: options.signal });
+  async get(terminalId, options = {}) {
+    const response = await this.transport.request(`/terminals/${encodeURIComponent(terminalId)}`, { signal: options.signal });
     return decodeTerminalSessionInfo(responseField(response, "terminal"));
   }
-  async readTerminal(terminalId, options = {}) {
-    const response = await this.request(`/terminals/${encodeURIComponent(terminalId)}/output`, { signal: options.signal });
+  async read(terminalId, options = {}) {
+    const response = await this.transport.request(`/terminals/${encodeURIComponent(terminalId)}/output`, { signal: options.signal });
     return decodeTerminalReadResult(responseField(response, "snapshot"));
   }
-  async writeTerminal(input, options = {}) {
-    await this.request(`/terminals/${encodeURIComponent(input.terminalId)}/input`, { method: "POST", body: { data: input.data }, signal: options.signal });
+  async write(input, options = {}) {
+    await this.transport.request(`/terminals/${encodeURIComponent(input.terminalId)}/input`, { method: "POST", body: { data: input.data }, signal: options.signal });
   }
-  async resizeTerminal(input, options = {}) {
-    await this.request(`/terminals/${encodeURIComponent(input.terminalId)}/resize`, {
+  async resize(input, options = {}) {
+    await this.transport.request(`/terminals/${encodeURIComponent(input.terminalId)}/resize`, {
       method: "POST",
       body: { cols: input.cols, rows: input.rows },
       signal: options.signal
     });
   }
-  async signalTerminal(terminalId, signal, options = {}) {
-    await this.request(`/terminals/${encodeURIComponent(terminalId)}/signal`, { method: "POST", body: { signal }, signal: options.signal });
+  async signal(terminalId, signal, options = {}) {
+    await this.transport.request(`/terminals/${encodeURIComponent(terminalId)}/signal`, { method: "POST", body: { signal }, signal: options.signal });
   }
-  async closeTerminal(terminalId, options = {}) {
-    await this.request(`/terminals/${encodeURIComponent(terminalId)}`, {
+  async close(terminalId, options = {}) {
+    await this.transport.request(`/terminals/${encodeURIComponent(terminalId)}`, {
       method: "DELETE",
       signal: options.signal
     });
   }
-  streamTerminalEvents(options = {}) {
-    return streamServerSentEvents(async () => {
-      const response = await this.fetchImpl(`${this.baseUrl}/terminals/stream`, {
-        headers: this.headers(),
-        signal: options.signal
-      });
-      if (!response.ok)
-        await this.throwResponseError(response);
-      if (!response.body)
-        throw new Error("Terminal event stream response has no body");
-      return response.body;
-    }, decodeTerminalEvent);
-  }
   streamEvents(options = {}) {
-    return streamServerSentEvents(async () => {
-      const query = {
-        cursor: options.cursor,
-        sessionId: options.sessionId
-      };
-      const response = await this.fetchImpl(`${this.baseUrl}${this.path("/events/stream", query)}`, {
-        headers: this.headers(),
-        signal: options.signal
-      });
-      if (!response.ok)
-        await this.throwResponseError(response);
-      if (!response.body)
-        throw new Error("Event stream response has no body");
-      return response.body;
-    }, decodeSessionEventRecord);
-  }
-  async request(path, options = {}) {
-    const response = await this.fetchImpl(`${this.baseUrl}${path}`, {
-      method: options.method ?? "GET",
-      headers: this.headers(options.body !== undefined, options.auth ?? true),
-      body: options.body === undefined ? undefined : JSON.stringify(options.body),
-      signal: options.signal
+    return this.sse.stream(this.transport.resolveUrl("/terminals/stream"), {
+      headers: this.transport.headers(),
+      signal: options.signal,
+      decode: decodeTerminalEvent,
+      noBodyMessage: "Terminal event stream response has no body"
     });
-    if (!response.ok)
-      await this.throwResponseError(response);
-    return await response.json();
-  }
-  headers(json = false, auth = true) {
-    return {
-      ...auth && this.token ? { authorization: `Bearer ${this.token}` } : {},
-      ...json ? { "content-type": "application/json" } : {}
-    };
   }
-  path(pathname, query = {}) {
-    const params = new URLSearchParams;
-    for (const [key, value] of Object.entries(query)) {
-      if (value === undefined || value === null || value === false)
-        continue;
-      params.set(key, String(value));
-    }
-    const qs = params.toString();
-    return qs ? `${pathname}?${qs}` : pathname;
+}
+var init_terminal_resource = __esm(() => {
+  init_src();
+  init_http_transport();
+});
+
+// ../../packages/client/src/resources/channel-resource.ts
+class ChannelResource {
+  transport;
+  constructor(transport) {
+    this.transport = transport;
   }
-  async throwResponseError(response) {
-    let body;
-    try {
-      body = await response.json();
-    } catch {
-      body = await response.text().catch(() => "");
-    }
-    const message = body && typeof body === "object" && "error" in body && typeof body.error === "string" ? body.error : body && typeof body === "object" && ("message" in body) && typeof body.message === "string" ? body.message : `OpenHarness API request failed with ${response.status}`;
-    throw new OpenHarnessApiError(message, response.status, body);
+  async handleMessage(input, options = {}) {
+    return await this.transport.request("/channels/messages", { method: "POST", body: input, signal: options.signal });
   }
-}
-function isReadableStream(value) {
-  return typeof ReadableStream !== "undefined" && value instanceof ReadableStream;
-}
-function attachmentRangeHeader(range) {
-  if (!range)
-    return;
-  const { start, end, suffixBytes } = range;
-  if (suffixBytes !== undefined) {
-    if (start !== undefined || end !== undefined) {
-      throw new Error("suffixBytes cannot be combined with start or end");
-    }
-    assertPositiveSafeInteger(suffixBytes, "suffixBytes");
-    return `bytes=-${suffixBytes}`;
+  async recordDelivery(deliveryId, input, options = {}) {
+    const response = await this.transport.request(`/channels/deliveries/${encodeURIComponent(deliveryId)}/result`, { method: "POST", body: input, signal: options.signal });
+    return response.delivery;
   }
-  if (start === undefined && end === undefined)
-    return;
-  if (start === undefined) {
-    throw new Error("range start is required when end is provided");
+  async getStatus(options = {}) {
+    const { signal, ...query } = options;
+    return await this.transport.request(this.transport.path("/channels/status", query), { signal });
   }
-  assertNonNegativeSafeInteger(start, "start");
-  if (end === undefined)
-    return `bytes=${start}-`;
-  assertNonNegativeSafeInteger(end, "end");
-  if (end < start)
-    throw new Error("range end must not be less than start");
-  return `bytes=${start}-${end}`;
-}
-function assertNonNegativeSafeInteger(value, field) {
-  if (!Number.isSafeInteger(value) || value < 0) {
-    throw new Error(`${field} must be a non-negative safe integer`);
+  async listPendingDeliveries(options = {}) {
+    const { signal, ...query } = options;
+    const response = await this.transport.request(this.transport.path("/channels/deliveries/pending", query), { signal });
+    return response.deliveries;
   }
 }
-function assertPositiveSafeInteger(value, field) {
-  if (!Number.isSafeInteger(value) || value < 1) {
-    throw new Error(`${field} must be a positive safe integer`);
+
+// ../../packages/client/src/resources/event-resource.ts
+class EventResource {
+  transport;
+  sse;
+  constructor(transport, sse) {
+    this.transport = transport;
+    this.sse = sse;
+  }
+  async list(options = {}) {
+    const { signal, ...query } = options;
+    const response = await this.transport.request(this.transport.path("/events", query), { signal });
+    return responseArray(response, "events", decodeSessionEventRecord);
   }
-}
-async function* streamServerSentEvents(open, decode = (value) => value) {
-  const reader = (await open()).getReader();
-  const decoder = new TextDecoder;
-  let buffer = "";
-  try {
-    while (true) {
-      const chunk = await reader.read();
-      if (chunk.done)
-        break;
-      buffer += decoder.decode(chunk.value, { stream: true });
-      const frames = buffer.split(/\r?\n\r?\n/);
-      buffer = frames.pop() ?? "";
-      for (const frame of frames) {
-        const event = parseSseFrame(frame);
-        if (event !== undefined)
-          yield decode(event);
-      }
-    }
-    buffer += decoder.decode();
-    const event = parseSseFrame(buffer);
-    if (event !== undefined)
-      yield decode(event);
-  } finally {
-    reader.releaseLock();
+  stream(options = {}) {
+    const query = {
+      cursor: options.cursor,
+      sessionId: options.sessionId
+    };
+    return this.sse.stream(this.transport.resolveUrl("/events/stream", query), {
+      headers: this.transport.headers(),
+      signal: options.signal,
+      decode: decodeSessionEventRecord,
+      reconnect: options.transportReconnect ?? false
+    });
   }
 }
-function parseSseFrame(frame) {
-  let data = "";
-  for (const line of frame.split(/\r?\n/)) {
-    if (!line || line.startsWith(":"))
-      continue;
-    if (line.startsWith("data:"))
-      data += line.slice(5).trimStart();
+var init_event_resource = __esm(() => {
+  init_src();
+  init_http_transport();
+});
+
+// ../../packages/client/src/resources/index.ts
+var init_resources = __esm(() => {
+  init_session_resource();
+  init_attachment_resource();
+  init_job_resource();
+  init_terminal_resource();
+  init_event_resource();
+});
+
+// ../../packages/client/src/transport/http-client.ts
+class OpenHarnessClient {
+  protocol;
+  system;
+  providers;
+  auth;
+  projects;
+  plugins;
+  development;
+  sessions;
+  attachments;
+  permissions;
+  schedules;
+  jobs;
+  terminals;
+  channels;
+  events;
+  constructor(options) {
+    const transport = new HttpTransport(options);
+    const sse = new SseTransport(transport);
+    this.protocol = new ProtocolClient(transport);
+    this.system = new SystemResource(transport);
+    this.providers = new ProviderResource(transport);
+    this.auth = new AuthResource(transport);
+    this.projects = new ProjectResource(transport);
+    this.plugins = new PluginResource(transport);
+    this.development = new DevelopmentResource(transport);
+    this.sessions = new SessionResource(transport);
+    this.attachments = new AttachmentResource(transport);
+    this.permissions = new PermissionResource(transport);
+    this.schedules = new ScheduleResource(transport);
+    this.jobs = new JobResource(transport);
+    this.terminals = new TerminalResource(transport, sse);
+    this.channels = new ChannelResource(transport);
+    this.events = new EventResource(transport, sse);
   }
-  if (!data)
-    return;
-  return JSON.parse(data);
 }
-var promptRequestCounter = 0, OpenHarnessApiError, IncompatibleProtocolError;
 var init_http_client = __esm(() => {
-  init_src();
-  OpenHarnessApiError = class OpenHarnessApiError extends Error {
-    status;
-    body;
-    constructor(message, status, body) {
-      super(message);
-      this.status = status;
-      this.body = body;
-      this.name = "OpenHarnessApiError";
-    }
-  };
-  IncompatibleProtocolError = class IncompatibleProtocolError extends Error {
-    capabilities;
-    constructor(capabilities, message) {
-      super(message);
-      this.capabilities = capabilities;
-      this.name = "IncompatibleProtocolError";
-    }
-  };
+  init_http_transport();
+  init_protocol();
+  init_resources();
 });
 
 // ../../packages/client/src/transport/index.ts
 var init_transport = __esm(() => {
+  init_http_transport();
   init_http_client();
 });
 
@@ -1677,6 +2156,9 @@ function createInitialClientState() {
   };
 }
 function applySessionSnapshot(state, snapshot) {
+  const knownCursor = state.snapshotCursorBySession[snapshot.session.id] ?? 0;
+  if (snapshot.cursor < knownCursor)
+    return state;
   const partsByMessageId = {};
   for (const part of snapshot.parts) {
     const parts = partsByMessageId[part.messageId] ?? [];
@@ -2010,126 +2492,221 @@ function selectSessionMessagesWithParts(bucket) {
     parts: [...bucket.partsByMessageId[message.id] ?? []].sort((a, b) => a.seq - b.seq)
   }));
 }
+function selectFirstPendingPermission(state, sessionId) {
+  if (!sessionId)
+    return;
+  const bucket = state.buckets[sessionId];
+  if (!bucket)
+    return;
+  return Object.values(bucket.permissions).filter((request) => request.status === "pending").sort((a, b) => a.createdAt - b.createdAt).at(0);
+}
 
 // ../../packages/client/src/state/sync.ts
-async function* syncEvents(client, options = {}) {
-  let state = createInitialClientState();
-  if (options.sessionId) {
-    const snapshot = await client.getSessionState(options.sessionId, { signal: options.signal });
-    state = applySessionSnapshot(state, snapshot);
-    yield { state, source: "snapshot" };
-    yield* liveWithReconnect(client, state, options, snapshot.cursor);
-    return;
+var init_sync = __esm(() => {
+  init_reducer();
+});
+
+// ../../packages/client/src/state/session-sync-controller.ts
+class SessionSyncController {
+  client;
+  sessionId;
+  initialCursor;
+  generation;
+  externalSignal;
+  reconnectDelayMs;
+  onUpdate;
+  onStatusChange;
+  onError;
+  abortController = new AbortController;
+  state;
+  status = "idle";
+  running = false;
+  constructor(options) {
+    this.client = options.client;
+    this.sessionId = options.sessionId;
+    this.state = options.initialState ?? createInitialClientState();
+    if ((options.cursor ?? 0) > 0 && !options.initialState) {
+      throw new Error("A non-zero cursor requires initialState so durable state is not skipped");
+    }
+    this.initialCursor = Math.max(0, options.cursor ?? 0, this.state.lastSeq);
+    this.generation = options.generation ?? 0;
+    this.externalSignal = options.signal;
+    this.reconnectDelayMs = options.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
+    this.onUpdate = options.onUpdate;
+    this.onStatusChange = options.onStatusChange;
+    this.onError = options.onError;
+    if (this.externalSignal) {
+      if (this.externalSignal.aborted) {
+        this.abortController.abort(this.externalSignal.reason);
+      } else {
+        this.externalSignal.addEventListener("abort", () => this.abortController.abort(this.externalSignal?.reason), { once: true });
+      }
+    }
   }
-  const replay = await client.listEvents({
-    cursor: options.cursor,
-    sessionId: options.sessionId,
-    signal: options.signal
-  });
-  for (const event of replay) {
-    state = applyEvent(state, event);
-    yield { event, state, source: "replay" };
-  }
-  yield* liveWithReconnect(client, state, options, state.lastSeq);
-}
-async function* liveWithReconnect(client, initialState, options, initialCursor) {
-  let state = initialState;
-  let cursor = initialCursor;
-  let attempt = 0;
-  const delayMs = options.reconnectDelayMs ?? DEFAULT_RECONNECT_DELAY_MS;
-  while (!options.signal?.aborted) {
+  get currentStatus() {
+    return this.status;
+  }
+  get currentState() {
+    return this.state;
+  }
+  get currentGeneration() {
+    return this.generation;
+  }
+  get signal() {
+    return this.abortController.signal;
+  }
+  abort(reason) {
+    this.abortController.abort(reason);
+  }
+  setStatus(status) {
+    if (this.status === status)
+      return;
+    this.status = status;
+    this.onStatusChange?.(status, this.generation);
+  }
+  emitUpdate(update) {
+    if (this.abortController.signal.aborted)
+      return;
+    this.state = update.state;
+    this.onUpdate?.(update, this.generation);
+  }
+  async start() {
+    if (this.running)
+      return;
+    this.running = true;
+    const signal = this.abortController.signal;
+    if (signal.aborted) {
+      this.setStatus("idle");
+      return;
+    }
+    let cursor = this.initialCursor;
+    let attempt = 0;
     try {
-      for await (const event of client.streamEvents({
-        cursor,
-        sessionId: options.sessionId,
-        signal: options.signal
-      })) {
-        attempt = 0;
-        if (event.seq > state.lastSeq + 1 && !options.sessionId) {
-          const gap = await client.listEvents({
-            cursor: state.lastSeq,
-            signal: options.signal
-          });
-          for (const missed of gap) {
-            const beforeGap = state;
-            state = applyEvent(state, missed);
-            if (state !== beforeGap)
-              yield { event: missed, state, source: "replay" };
+      this.setStatus("connecting");
+      if (this.sessionId) {
+        const snapshot = await this.client.sessions.getState(this.sessionId, { signal });
+        if (signal.aborted)
+          return;
+        this.state = applySessionSnapshot(this.state, snapshot);
+        cursor = Math.max(cursor, snapshot.cursor, this.state.lastSeq);
+        this.setStatus("connected");
+        this.emitUpdate({ state: this.state, source: "snapshot" });
+      } else {
+        const replay = await this.client.events.list({
+          cursor,
+          sessionId: this.sessionId,
+          signal
+        });
+        if (signal.aborted)
+          return;
+        for (const event of replay) {
+          this.state = applyEvent(this.state, event);
+          this.emitUpdate({ event, state: this.state, source: "replay" });
+        }
+        cursor = Math.max(cursor, this.state.lastSeq);
+        this.setStatus("connected");
+      }
+      while (!signal.aborted) {
+        try {
+          for await (const event of this.client.events.stream({
+            cursor,
+            sessionId: this.sessionId,
+            signal,
+            transportReconnect: false
+          })) {
+            if (signal.aborted)
+              return;
+            attempt = 0;
+            this.setStatus("connected");
+            if (event.seq > cursor + 1) {
+              const gap = await this.client.events.list({
+                cursor,
+                sessionId: this.sessionId,
+                signal
+              });
+              if (signal.aborted)
+                return;
+              for (const missed of gap) {
+                const beforeGap = this.state;
+                this.state = applyEvent(this.state, missed);
+                if (this.state !== beforeGap) {
+                  this.emitUpdate({ event: missed, state: this.state, source: "replay" });
+                }
+              }
+              cursor = Math.max(cursor, this.state.lastSeq);
+            }
+            const before = this.state;
+            this.state = applyEvent(this.state, event);
+            cursor = Math.max(cursor, this.state.lastSeq);
+            if (this.state !== before) {
+              this.emitUpdate({ event, state: this.state, source: "live" });
+            }
+          }
+          if (signal.aborted)
+            return;
+          this.setStatus("reconnecting");
+          this.emitUpdate({ state: this.state, source: "reconnecting" });
+          const delay = this.reconnectDelayMs(attempt);
+          attempt += 1;
+          cursor = this.state.lastSeq;
+          if (!await this.waitForDelay(delay, signal))
+            return;
+        } catch (error) {
+          if (error instanceof UnsupportedSessionEventSchemaVersionError) {
+            throw error;
           }
-          cursor = state.lastSeq;
+          if (this.isAbortError(error) || signal.aborted)
+            return;
+          this.setStatus("reconnecting");
+          this.emitUpdate({ state: this.state, source: "reconnecting" });
+          const delay = this.reconnectDelayMs(attempt);
+          attempt += 1;
+          cursor = this.state.lastSeq;
+          if (!await this.waitForDelay(delay, signal))
+            return;
         }
-        const before = state;
-        state = applyEvent(state, event);
-        cursor = state.lastSeq;
-        if (state !== before)
-          yield { event, state, source: "live" };
       }
-      if (options.signal?.aborted)
-        return;
-      yield { state, source: "reconnecting" };
-      if (!await waitForReconnect(delayMs(attempt), options.signal))
-        return;
-      attempt += 1;
-      cursor = state.lastSeq;
     } catch (error) {
-      if (error instanceof UnsupportedSessionEventSchemaVersionError)
-        throw error;
-      if (isAbortError(error) || options.signal?.aborted)
-        return;
-      yield { state, source: "reconnecting" };
-      if (!await waitForReconnect(delayMs(attempt), options.signal))
-        return;
-      attempt += 1;
-      cursor = state.lastSeq;
+      if (!this.isAbortError(error) && !signal.aborted) {
+        this.setStatus("error");
+        this.onError?.(error, this.generation);
+      }
+    } finally {
+      this.running = false;
+      if (signal.aborted && this.status !== "error") {
+        this.setStatus("idle");
+      }
     }
   }
-}
-async function waitForReconnect(ms, signal) {
-  try {
-    await sleep(ms, signal);
-    return !signal?.aborted;
-  } catch (error) {
-    if (isAbortError(error) || signal?.aborted)
+  isAbortError(error) {
+    if (!error || typeof error !== "object")
       return false;
-    throw error;
-  }
-}
-function isAbortError(error) {
-  if (!error || typeof error !== "object")
+    if ("name" in error && error.name === "AbortError")
+      return true;
     return false;
-  if ("name" in error && error.name === "AbortError")
-    return true;
-  return false;
-}
-function sleep(ms, signal) {
-  if (ms <= 0) {
-    if (signal?.aborted)
-      return Promise.reject(abortError(signal));
-    return Promise.resolve();
   }
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(abortError(signal));
-      return;
-    }
-    const timer = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve();
-    }, ms);
-    const onAbort = () => {
-      clearTimeout(timer);
-      reject(abortError(signal));
-    };
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function abortError(signal) {
-  if (signal.reason instanceof Error)
-    return signal.reason;
-  return new DOMException("Aborted", "AbortError");
+  waitForDelay(ms, signal) {
+    if (ms <= 0)
+      return Promise.resolve(!signal.aborted);
+    return new Promise((resolve) => {
+      if (signal.aborted) {
+        resolve(false);
+        return;
+      }
+      const timer = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(!signal.aborted);
+      }, ms);
+      const onAbort = () => {
+        clearTimeout(timer);
+        resolve(false);
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
 }
 var DEFAULT_RECONNECT_DELAY_MS = (attempt) => Math.min(30000, 250 * 2 ** Math.max(0, attempt));
-var init_sync = __esm(() => {
+var init_session_sync_controller = __esm(() => {
   init_reducer();
 });
 
@@ -2137,6 +2714,7 @@ var init_sync = __esm(() => {
 var init_state = __esm(() => {
   init_reducer();
   init_sync();
+  init_session_sync_controller();
 });
 
 // ../../packages/client/src/commands/plugin-presentation.ts
@@ -2330,7 +2908,7 @@ async function dispatchSessionCommand(slash, host) {
     }
     patchStatus({ permission_mode: next });
     if (sessionId) {
-      await client.updateSession(sessionId, {
+      await client.sessions.update(sessionId, {
         metadata: patchSessionRuntimeMetadata({}, { permissionMode: next })
       });
     }
@@ -2365,7 +2943,7 @@ async function dispatchSessionCommand(slash, host) {
   }
   if (slash?.name === "/version") {
     await readPresentation("version", "Version", async () => {
-      const health = await client.health();
+      const health = await client.protocol.health();
       return `OpenHarness${health.version ? ` v${health.version}` : ""}`;
     });
     return "handled";
@@ -2386,7 +2964,7 @@ async function dispatchSessionCommand(slash, host) {
     const args = slash.args.trim();
     if (!args || args === "show") {
       await readPresentation(`config:${cwd}`, "Config", async () => {
-        const settings = await client.getSettings();
+        const settings = await client.system.getSettings();
         return JSON.stringify(settings, null, 2);
       });
       return "handled";
@@ -2396,14 +2974,14 @@ async function dispatchSessionCommand(slash, host) {
       emit("Usage: /config [show | set KEY VALUE]");
       return "handled";
     }
-    await client.patchSettings({ path: setMatch[1], value: setMatch[2].trim() });
+    await client.system.patchSettings({ path: setMatch[1], value: setMatch[2].trim() });
     emit(`Set ${setMatch[1]} = ${setMatch[2].trim()}`);
     return "handled";
   }
   if (slash?.name === "/provider") {
     if (!slash.args) {
       await readPresentation("providers", "Provider", async () => {
-        const providers = await client.listProviders();
+        const providers = await client.providers.listProviders();
         const lines = ["Available providers:", ""];
         for (const provider of providers) {
           const marker = provider.active ? " (active)" : "";
@@ -2415,7 +2993,7 @@ async function dispatchSessionCommand(slash, host) {
       });
       return "handled";
     }
-    const settings = await client.patchSettings(slash.args === "auto" ? { provider: "auto" } : { provider: slash.args });
+    const settings = await client.system.patchSettings(slash.args === "auto" ? { provider: "auto" } : { provider: slash.args });
     if (typeof settings.model === "string") {
       patchStatus({ model: settings.model });
     }
@@ -2426,7 +3004,7 @@ async function dispatchSessionCommand(slash, host) {
     if (!sessionId)
       return "handled";
     await readPresentation(`mcp:${sessionId}`, "MCP", async () => {
-      const servers = await client.getSessionMcp(sessionId);
+      const servers = await client.system.getSessionMcp(sessionId);
       if (servers.length === 0)
         return "No MCP servers connected.";
       return [
@@ -2451,7 +3029,7 @@ async function dispatchSessionCommand(slash, host) {
     const [sub, id, ...extra] = args.split(/\s+/).filter(Boolean);
     if ((!sub || sub === "list") && !id) {
       await readPresentation(`jobs:${sessionId}`, "Jobs", async () => {
-        const jobs = await client.listJobs({
+        const jobs = await client.jobs.list({
           sessionId,
           includeFinished: true,
           limit: 100
@@ -2469,13 +3047,13 @@ async function dispatchSessionCommand(slash, host) {
     }
     if (sub === "show" && id && extra.length === 0) {
       await readPresentation(`job:${sessionId}:${id}`, "Jobs", async () => {
-        const result = await client.readJob(id, { sessionId });
+        const result = await client.jobs.read(id, { sessionId });
         return formatJobReadResult(result);
       });
       return "handled";
     }
     if (sub === "cancel" && id && extra.length === 0) {
-      const snapshot = await client.cancelJob(id, {
+      const snapshot = await client.jobs.cancel(id, {
         sessionId,
         reason: "Cancelled from slash command"
       });
@@ -2493,7 +3071,7 @@ async function dispatchSessionCommand(slash, host) {
     }
     if (!sessionId)
       return "handled";
-    const result = await client.createBackgroundShell({ sessionId, command });
+    const result = await client.jobs.createBackgroundShell({ sessionId, command });
     emit(`Background shell started: ${result.jobId}. Use /jobs to inspect it.`);
     return "handled";
   }
@@ -2502,7 +3080,7 @@ async function dispatchSessionCommand(slash, host) {
     const [sub, ...rest] = args.split(/\s+/).filter(Boolean);
     if (!sub || sub === "list") {
       await readPresentation(`memory:${cwd}:list`, "Memory", async () => {
-        const listed = await client.listMemory({ cwd });
+        const listed = await client.system.listMemory({ cwd });
         if (listed.entries.length === 0)
           return `Memory directory: ${listed.directory}
 No entries found.`;
@@ -2522,7 +3100,7 @@ No entries found.`;
     if (sub === "show" && rest[0]) {
       const memoryId = rest[0];
       await readPresentation(`memory:${cwd}:show:${memoryId}`, "Memory", async () => {
-        const entry = await client.getMemory(memoryId, { cwd });
+        const entry = await client.system.getMemory(memoryId, { cwd });
         return [
           `ID:       ${entry.id}`,
           `Created:  ${new Date(entry.createdAt).toISOString()}`,
@@ -2541,12 +3119,12 @@ No entries found.`;
         emit("Usage: /memory add <content>");
         return "handled";
       }
-      const entry = await client.addMemory({ cwd, content });
+      const entry = await client.system.addMemory({ cwd, content });
       emit(`Memory added: ${entry.id}`);
       return "handled";
     }
     if (sub === "remove" && rest[0]) {
-      await client.removeMemory(rest[0], { cwd });
+      await client.system.removeMemory(rest[0], { cwd });
       emit(`Memory removed: ${rest[0]}`);
       return "handled";
     }
@@ -2558,7 +3136,7 @@ No entries found.`;
     const [sub, provider, apiKey] = args.split(/\s+/).filter(Boolean);
     if (!sub || sub === "status") {
       await readPresentation("auth:status", "Auth", async () => {
-        const auth = await client.getAuthStatus();
+        const auth = await client.auth.getStatus();
         const lines = ["Credential status:", "", "  Auth sources:"];
         lines.push(`    codex_subscription: ${auth.codex.configured ? "ready" : auth.codex.state} (${auth.codex.source})`);
         if (auth.storedProviders.length > 0) {
@@ -2586,7 +3164,7 @@ No entries found.`;
         emit("Usage: /auth login <provider> <api-key> or /auth login codex");
         return "handled";
       }
-      const result = await client.authLogin({ provider, apiKey });
+      const result = await client.auth.login({ provider, apiKey });
       emit(result.message);
       return "handled";
     }
@@ -2595,7 +3173,7 @@ No entries found.`;
         emit("Usage: /auth logout <provider>");
         return "handled";
       }
-      const result = await client.authLogout({ provider });
+      const result = await client.auth.logout({ provider });
       emit(result.message);
       return "handled";
     }
@@ -2605,12 +3183,12 @@ No entries found.`;
   if (slash?.name === "/context") {
     const action = slash.args.trim().split(/\s+/).filter(Boolean)[0] ?? "preview";
     if (action === "status") {
-      await readPresentation(`context:${cwd}:status`, "Context", async () => await client.getContextStatus({ cwd }));
+      await readPresentation(`context:${cwd}:status`, "Context", async () => await client.system.getContextStatus({ cwd }));
       return "handled";
     }
     if (action === "usage") {
       await readPresentation(`context:${cwd}:usage:${sessionId ?? "none"}`, "Context", async () => {
-        const result = await client.getContextUsage({
+        const result = await client.system.getContextUsage({
           cwd,
           ...sessionId ? { sessionId } : {}
         });
@@ -2622,7 +3200,7 @@ No entries found.`;
       emit("Usage: /context [preview|status|usage]");
       return "handled";
     }
-    await readPresentation(`context:${cwd}`, "Context", async () => await client.getContextPreview({ cwd }));
+    await readPresentation(`context:${cwd}`, "Context", async () => await client.system.getContextPreview({ cwd }));
     return "handled";
   }
   if (slash?.name === "/stats") {
@@ -2633,11 +3211,11 @@ No entries found.`;
     const text = (bucket?.messages ?? []).flatMap((message) => bucket?.partsByMessageId[message.id] ?? []).map((part) => part.text ?? "").join(" ");
     const estimatedTokens = Math.max(1, Math.ceil(text.length / 4));
     const [memory, jobsResult, settings] = await Promise.all([
-      client.listMemory({ cwd }).catch(() => ({ entries: [] })),
-      client.listJobs({ sessionId, includeFinished: true, limit: 100 }).then((jobs) => ({ jobs })).catch((error) => ({
+      client.system.listMemory({ cwd }).catch(() => ({ entries: [] })),
+      client.jobs.list({ sessionId, includeFinished: true, limit: 100 }).then((jobs) => ({ jobs })).catch((error) => ({
         error: error instanceof Error ? error.message : String(error)
       })),
-      client.getSettings().catch(() => ({}))
+      client.system.getSettings().catch(() => ({}))
     ]);
     const jobsSummary = "jobs" in jobsResult ? String(jobsResult.jobs.length) : `unavailable (${jobsResult.error})`;
     emit([
@@ -2654,7 +3232,7 @@ No entries found.`;
   if (slash?.name === "/agents") {
     if (!sessionId)
       return "handled";
-    const agents = await client.listJobs({
+    const agents = await client.jobs.list({
       sessionId,
       kinds: ["agent"],
       includeFinished: true,
@@ -2681,21 +3259,21 @@ No entries found.`;
       emit("Count must be a positive integer");
       return "handled";
     }
-    const result = await client.rewindSession(sessionId, { count });
+    const result = await client.sessions.rewind(sessionId, { count });
     emit(`Rewound ${result.turns} turn(s), removed ${result.removed} message(s).`);
     return "handled";
   }
   if (slash?.name === "/compact") {
     if (!sessionId)
       return "handled";
-    const result = await client.compactSession(sessionId);
+    const result = await client.sessions.compact(sessionId);
     emit(`Conversation compacted (${result.messageCount} messages retained).`);
     return "handled";
   }
   if (slash?.name === "/remember") {
     if (!sessionId)
       return "handled";
-    const result = await client.rememberSession(sessionId);
+    const result = await client.sessions.remember(sessionId);
     if (result.skipped) {
       emit(`\u672A\u5199\u5165\u8BB0\u5FC6:${result.reason ?? "skipped"}`);
       return "handled";
@@ -2705,7 +3283,7 @@ No entries found.`;
   }
   if (slash?.name === "/dream") {
     const preview = slash.args.includes("--preview");
-    const result = await client.startDream({
+    const result = await client.system.startDream({
       cwd,
       ...sessionId ? { sessionId } : {},
       preview
@@ -2716,11 +3294,11 @@ No entries found.`;
   if (slash?.name === "/profile") {
     const action = slash.args.trim().split(/\s+/).filter(Boolean)[0] ?? "status";
     if (action === "status" || action === "show") {
-      emit(await client.getProfileStatus());
+      emit(await client.system.getProfileStatus());
       return "handled";
     }
     if (action === "init") {
-      emit(await client.initProfile());
+      emit(await client.system.initProfile());
       return "handled";
     }
     emit("Usage: /profile [status|init]");
@@ -2728,11 +3306,11 @@ No entries found.`;
   }
   if (slash?.name === "/doctor") {
     const [settings, auth, memory, mcp, jobsResult] = await Promise.all([
-      client.getSettings().catch(() => ({})),
-      client.getAuthStatus().catch(() => null),
-      client.listMemory({ cwd }).catch(() => ({ directory: "(unavailable)", entries: [] })),
-      sessionId ? client.getSessionMcp(sessionId).catch(() => []) : Promise.resolve([]),
-      sessionId ? client.listJobs({ sessionId, includeFinished: true, limit: 100 }).then((jobs) => ({ jobs })).catch((error) => ({
+      client.system.getSettings().catch(() => ({})),
+      client.auth.getStatus().catch(() => null),
+      client.system.listMemory({ cwd }).catch(() => ({ directory: "(unavailable)", entries: [] })),
+      sessionId ? client.system.getSessionMcp(sessionId).catch(() => []) : Promise.resolve([]),
+      sessionId ? client.jobs.list({ sessionId, includeFinished: true, limit: 100 }).then((jobs) => ({ jobs })).catch((error) => ({
         error: error instanceof Error ? error.message : String(error)
       })) : Promise.resolve({ jobs: [] })
     ]);
@@ -2782,7 +3360,7 @@ No entries found.`;
   if (slash?.name === "/effort") {
     const level = slash.args.trim().split(/\s+/).filter(Boolean)[0];
     if (!level) {
-      const settings = await client.getSettings();
+      const settings = await client.system.getSettings();
       emit(`Current effort: ${String(settings.effort ?? "medium")}`);
       return "handled";
     }
@@ -2790,13 +3368,13 @@ No entries found.`;
       emit("Invalid effort. Use: low, medium, or high");
       return "handled";
     }
-    await client.patchSettings({ effort: level });
+    await client.system.patchSettings({ effort: level });
     emit(`Effort set to: ${level}`);
     return "handled";
   }
   if (slash?.name === "/fast") {
     const arg = slash.args.trim().split(/\s+/).filter(Boolean)[0];
-    const settings = await client.getSettings();
+    const settings = await client.system.getSettings();
     const current = settings.fastMode === true;
     let next;
     if (arg === "on")
@@ -2805,14 +3383,14 @@ No entries found.`;
       next = false;
     else
       next = !current;
-    await client.patchSettings({ fastMode: next });
+    await client.system.patchSettings({ fastMode: next });
     emit(`Fast mode: ${next ? "ON" : "OFF"}`);
     return "handled";
   }
   if (slash?.name === "/turns") {
     const value = slash.args.trim().split(/\s+/).filter(Boolean)[0];
     if (!value) {
-      const settings = await client.getSettings();
+      const settings = await client.system.getSettings();
       emit(`Current max turns: ${String(settings.maxTurns ?? "(default)")}`);
       return "handled";
     }
@@ -2821,7 +3399,7 @@ No entries found.`;
       emit("Value must be between 1 and 512");
       return "handled";
     }
-    await client.patchSettings({ maxTurns: n });
+    await client.system.patchSettings({ maxTurns: n });
     emit(`Max turns set to: ${n}`);
     return "handled";
   }
@@ -2830,7 +3408,7 @@ No entries found.`;
       return "handled";
     if (slash.name === "/cost") {
       await readPresentation(`cost:${sessionId}`, "Cost", async () => {
-        const usage = await client.getSessionUsage(sessionId);
+        const usage = await client.sessions.getUsage(sessionId);
         return [
           "Cost estimate:",
           `  Model:         ${usage.model}`,
@@ -2845,7 +3423,7 @@ No entries found.`;
       return "handled";
     }
     await readPresentation(`usage:${sessionId}`, "Usage", async () => {
-      const usage = await client.getSessionUsage(sessionId);
+      const usage = await client.sessions.getUsage(sessionId);
       return [
         "Token usage:",
         `  Input:         ${usage.inputTokens.toLocaleString()}`,
@@ -2866,7 +3444,7 @@ No entries found.`;
     const args = slash.args.trim().split(/\s+/).filter(Boolean);
     const forceJson = args.includes("--json");
     const filename = args.find((arg) => !arg.startsWith("--"));
-    const result = await client.exportSession(sessionId, {
+    const result = await client.sessions.export(sessionId, {
       ...filename ? { filename } : {},
       json: forceJson
     });
@@ -2875,8 +3453,8 @@ No entries found.`;
   }
   if (slash?.name === "/output-style") {
     const args = slash.args.trim();
-    const styles = await client.listOutputStyles();
-    const settings = await client.getSettings();
+    const styles = await client.system.listOutputStyles();
+    const settings = await client.system.getSettings();
     const current = typeof settings.outputStyle === "string" ? settings.outputStyle : "default";
     const firstSpace = args.search(/\s/);
     const first = firstSpace === -1 ? args : args.slice(0, firstSpace);
@@ -2899,12 +3477,12 @@ No entries found.`;
       emit(`Unknown output style: ${styleName}`);
       return "handled";
     }
-    await client.patchSettings({ outputStyle: styleName });
+    await client.system.patchSettings({ outputStyle: styleName });
     emit(`Output style set to ${styleName}`);
     return "handled";
   }
   if (slash?.name === "/init") {
-    emit(await client.initProject({ cwd }));
+    emit(await client.projects.init({ cwd }));
     return "handled";
   }
   if (slash?.name === "/plugin") {
@@ -2912,7 +3490,7 @@ No entries found.`;
     const sub = args[0];
     if (!sub || sub === "list") {
       await readPresentation(`plugins:${cwd}`, "Plugin", async () => {
-        const listed = await client.listPlugins({ cwd });
+        const listed = await client.plugins.list({ cwd });
         if (listed.plugins.length === 0)
           return "No plugins discovered.";
         return [
@@ -2925,7 +3503,7 @@ No entries found.`;
       return "handled";
     }
     if ((sub === "enable" || sub === "disable") && args[1]) {
-      const result = sub === "enable" ? await client.enablePlugin(args[1], { cwd }) : await client.disablePlugin(args[1], { cwd });
+      const result = sub === "enable" ? await client.plugins.enable(args[1], { cwd }) : await client.plugins.disable(args[1], { cwd });
       emit(result.message);
       return "handled";
     }
@@ -2933,13 +3511,13 @@ No entries found.`;
     return "handled";
   }
   if (slash?.name === "/reload-plugins") {
-    const result = await client.reloadPlugins({ cwd });
+    const result = await client.plugins.reload({ cwd });
     emit(formatPluginReload(result));
     return "handled";
   }
   if (slash?.name === "/hooks") {
     await readPresentation(`hooks:${cwd}:${sessionId ?? "global"}`, "Hooks", async () => {
-      const hooks = await client.listHooks({
+      const hooks = await client.development.listHooks({
         cwd,
         ...sessionId ? { sessionId } : {}
       });
@@ -2967,7 +3545,7 @@ No entries found.`;
     return "handled";
   }
   if (slash?.name === "/subagents") {
-    const agents = await client.listAgentPersonas();
+    const agents = await client.development.listAgentPersonas();
     emit([
       `Available subagent personas (${agents.length}):`,
       "",
@@ -2984,21 +3562,21 @@ No entries found.`;
   }
   if (slash?.name === "/diff") {
     const full = slash.args.trim().split(/\s+/).includes("full");
-    await readPresentation(`git:diff:${cwd}:${full ? "full" : "summary"}`, "Diff", async () => await client.getGitDiff({ cwd, full }));
+    await readPresentation(`git:diff:${cwd}:${full ? "full" : "summary"}`, "Diff", async () => await client.development.getGitDiff({ cwd, full }));
     return "handled";
   }
   if (slash?.name === "/branch") {
     const list = slash.args.trim().split(/\s+/).includes("list");
-    await readPresentation(`git:branch:${cwd}:${list ? "list" : "current"}`, "Branch", async () => await client.getGitBranch({ cwd, list }));
+    await readPresentation(`git:branch:${cwd}:${list ? "list" : "current"}`, "Branch", async () => await client.development.getGitBranch({ cwd, list }));
     return "handled";
   }
   if (slash?.name === "/commit") {
     const message = slash.args.trim();
     if (!message) {
-      await readPresentation(`git:status:${cwd}`, "Commit", async () => await client.getGitStatus({ cwd }));
+      await readPresentation(`git:status:${cwd}`, "Commit", async () => await client.development.getGitStatus({ cwd }));
       return "handled";
     }
-    emit(await client.gitCommit({ cwd, message }));
+    emit(await client.development.gitCommit({ cwd, message }));
     return "handled";
   }
   if (slash && LOCAL_COMMAND_NAMES.has(slash.name)) {
@@ -3031,6 +3609,8 @@ var init_commands = __esm(() => {
 // ../../packages/client/src/index.ts
 var init_src2 = __esm(() => {
   init_transport();
+  init_protocol();
+  init_resources();
   init_src();
   init_src();
   init_state();
@@ -3301,128 +3881,588 @@ async function dispatchSessionSlashCommand(slash, ctx) {
     return "local_ui_ignored";
   return outcome;
 }
-var init_sessionSlashCommands = __esm(() => {
+var init_sessionSlashCommands = __esm(() => {
+  init_src2();
+});
+
+// ../frontend/src/hooks/sync-submodules/connection.ts
+function stringSetting(value) {
+  return typeof value === "string" && value.trim() ? value : undefined;
+}
+function normalizeSessionMode(value) {
+  return value === "coordinator" ? "coordinator" : null;
+}
+function statusSessionMode(value) {
+  return normalizeSessionMode(value) ?? "direct";
+}
+function shouldAutoActivateSession(session, defaultModel, pluginsEnabled) {
+  const runtime = readSessionRuntimeConfig(session);
+  return runtime.model === defaultModel && (pluginsEnabled == null || (runtime.pluginsEnabled ?? true) === pluginsEnabled);
+}
+function createDaemonClient(daemon) {
+  if (!daemon?.url)
+    return null;
+  return new OpenHarnessClient({
+    baseUrl: daemon.url,
+    token: daemon.token ?? undefined
+  });
+}
+var init_connection = __esm(() => {
+  init_src2();
+});
+
+// ../frontend/src/hooks/sync-submodules/permissions.ts
+function permissionToModal(request) {
+  const input = request.payload.input && typeof request.payload.input === "object" ? request.payload.input : {};
+  return {
+    kind: "permission",
+    request_id: request.id,
+    tool_name: request.toolName,
+    reason: typeof request.payload.reason === "string" ? request.payload.reason : null,
+    input
+  };
+}
+function firstPendingPermission(state, sessionId) {
+  return selectFirstPendingPermission(state, sessionId);
+}
+var init_permissions = __esm(() => {
+  init_src2();
+});
+
+// ../frontend/src/hooks/sync-submodules/view-model.ts
+function isRecord5(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value);
+}
+function sessionRuntimeMetadata(input) {
+  const runtime = {};
+  if (typeof input.model === "string" && input.model) {
+    runtime.model = input.model;
+  }
+  if (typeof input.provider === "string" && input.provider) {
+    runtime.provider = input.provider;
+  }
+  if (typeof input.baseUrl === "string" && input.baseUrl) {
+    runtime.baseUrl = input.baseUrl;
+  }
+  if (input.apiFormat === "anthropic" || input.apiFormat === "openai") {
+    runtime.apiFormat = input.apiFormat;
+  }
+  if (input.permissionMode === "default" || input.permissionMode === "plan" || input.permissionMode === "full_auto") {
+    runtime.permissionMode = input.permissionMode;
+  }
+  if (typeof input.maxTurns === "number" && Number.isFinite(input.maxTurns)) {
+    runtime.maxTurns = input.maxTurns;
+  }
+  if (input.sessionMode === "coordinator" || input.sessionMode === "direct") {
+    runtime.sessionMode = input.sessionMode;
+  }
+  if (typeof input.pluginsEnabled === "boolean") {
+    runtime.pluginsEnabled = input.pluginsEnabled;
+  }
+  return patchSessionRuntimeMetadata({}, runtime);
+}
+function archiveClientSession(state, sessionId, archivedAt) {
+  const current = state.sessions[sessionId];
+  if (!current || current.status === "archived")
+    return state;
+  const archived = {
+    ...current,
+    status: "archived",
+    archivedAt,
+    updatedAt: Math.max(current.updatedAt, archivedAt)
+  };
+  const bucket = state.buckets[sessionId];
+  return {
+    ...state,
+    sessions: { ...state.sessions, [sessionId]: archived },
+    buckets: bucket ? { ...state.buckets, [sessionId]: { ...bucket, session: archived } } : state.buckets
+  };
+}
+function listTopLevelSessions(sessions, activeSessionId) {
+  return [...sessions].filter((session) => !session.parentId && session.status !== "archived").sort((a, b) => {
+    if (a.id === activeSessionId)
+      return -1;
+    if (b.id === activeSessionId)
+      return 1;
+    return b.updatedAt - a.updatedAt;
+  });
+}
+function sessionSelectOptions(sessions, activeSessionId) {
+  return listTopLevelSessions(sessions, activeSessionId).map((session) => ({
+    value: session.id,
+    label: `${session.id === activeSessionId ? "* " : ""}${session.title || session.id}`,
+    description: `${session.model} | ${session.status}`
+  }));
+}
+function recoverableInterruptedRuns(bucket) {
+  if (!bucket)
+    return [];
+  const recoveredSourceRunIds = new Set(bucket.inputs.flatMap((input) => isRecord5(input.metadata.recovery) && typeof input.metadata.recovery.sourceRunId === "string" ? [input.metadata.recovery.sourceRunId] : []));
+  return Object.values(bucket.runs).filter((run) => run.status === "interrupted" && !!run.inputId && !recoveredSourceRunIds.has(run.id)).sort((a, b) => b.updatedAt - a.updatedAt).flatMap((run) => {
+    const input = bucket.inputs.find((candidate) => candidate.id === run.inputId);
+    return input ? [{ id: run.id, error: run.error, prompt: input.content }] : [];
+  });
+}
+function shouldCoalesceClientState(update) {
+  return update.source === "live" && update.event?.type === "session.message.part.delta";
+}
+var init_view_model = __esm(() => {
+  init_src2();
+});
+
+// ../frontend/src/hooks/sync-submodules/mcp.ts
+function mcpServerSnapshot(server) {
+  return {
+    name: server.name,
+    state: server.status,
+    ...server.error || server.command ? { detail: server.error ?? server.command } : {},
+    tool_count: server.toolCount,
+    resource_count: server.resourceCount
+  };
+}
+
+// ../frontend/src/hooks/sync-submodules/actions.ts
+async function executeTuiAction(action, ctx) {
+  const client = ctx.clientRef.current;
+  let sessionId = ctx.activeSessionIdRef.current;
+  const runtimeAction = action;
+  const runtimeType = typeof runtimeAction.type === "string" ? runtimeAction.type : "unknown";
+  switch (action.type) {
+    case "select_model": {
+      if (!client)
+        return;
+      const model = action.model.trim();
+      const provider = action.provider?.trim() ?? "";
+      if (!model)
+        return;
+      if (sessionId) {
+        const session = await client.sessions.update(sessionId, {
+          metadata: patchSessionRuntimeMetadata({}, {
+            model,
+            ...provider ? { provider } : {}
+          })
+        });
+        ctx.activateSession(session);
+      } else {
+        const settingsPatch = { model };
+        if (provider)
+          settingsPatch.provider = provider;
+        await client.system.patchSettings(settingsPatch);
+        ctx.defaultRuntimeRef.current = {
+          ...ctx.defaultRuntimeRef.current,
+          model,
+          ...provider ? { provider } : {}
+        };
+        ctx.setStatus((current) => ({
+          ...current,
+          model,
+          ...provider ? { provider } : {}
+        }));
+      }
+      ctx.pushSystem(`Model selected: ${model}`);
+      return;
+    }
+    case "submit_line": {
+      if (!client)
+        return;
+      const line = action.line;
+      const slash = parseSlashLine(line);
+      const newSession = line.match(/^\/new(?:\s+(.+))?$/);
+      if (newSession) {
+        ctx.returnToHome(newSession[1]);
+        return;
+      }
+      const switchSession = line.match(/^\/sessions\s+open\s+(.+)$/);
+      if (switchSession?.[1]) {
+        const target = switchSession[1].trim();
+        ctx.setLocalBusy(false);
+        ctx.setSubmittedRun(null);
+        ctx.pendingNewSessionTitleRef.current = undefined;
+        ctx.setSelectRequest(null);
+        const knownSession = ctx.clientState.sessions[target] ?? ctx.listedSessionsRef.current[target];
+        if (knownSession) {
+          ctx.activateSession(knownSession);
+          return;
+        }
+        const session = await client.sessions.get(target);
+        ctx.activateSession(session);
+        return;
+      }
+      if (slash?.name === "/resume") {
+        if (!sessionId) {
+          ctx.pushSystem("No active session to resume.");
+          return;
+        }
+        const recoverable = recoverableInterruptedRuns(ctx.clientState.buckets[sessionId]);
+        if (!slash.args) {
+          if (recoverable.length === 0) {
+            ctx.pushSystem("No interrupted prompt runs are available to resume.");
+            return;
+          }
+          ctx.clearDisplayRequest();
+          ctx.setSelectRequest({
+            title: "Resume interrupted run",
+            submitPrefix: "/resume ",
+            options: recoverable.map((run) => ({
+              value: run.id,
+              label: run.prompt.length > 72 ? `${run.prompt.slice(0, 72)}...` : run.prompt,
+              description: run.error ?? "Interrupted before completion"
+            }))
+          });
+          return;
+        }
+        const runId = slash.args.trim();
+        if (!recoverable.some((run) => run.id === runId)) {
+          ctx.pushSystem(`Run is not available for recovery: ${runId}`);
+          return;
+        }
+        ctx.setLocalBusy(true);
+        const response = await client.sessions.resumeInterruptedRun(sessionId, runId, { id: createPromptRequestId() });
+        ctx.setLocalBusy(false);
+        ctx.setSubmittedRun(response.run ? { sessionId, runId: response.run.id } : null);
+        ctx.setSelectRequest(null);
+        return;
+      }
+      let slashResult;
+      try {
+        slashResult = await dispatchSessionSlashCommand(slash, {
+          client,
+          sessionId,
+          pushSystem: ctx.pushSystem,
+          presentSystem: (title, content) => ctx.showDisplayRequest({ title, content }),
+          statusRef: ctx.statusRef,
+          commandCatalogRef: ctx.commandCatalogRef,
+          clientState: ctx.clientState,
+          localBusy: ctx.localBusy,
+          cacheFirstRead: ctx.cacheFirstRead,
+          daemon: ctx.daemon,
+          setStatus: ctx.setStatusAndDefault
+        });
+      } catch (error) {
+        if (slash && JOBS_AUXILIARY_SLASH_COMMANDS.has(slash.name)) {
+          ctx.reportAuxiliaryError("Jobs", error);
+          return;
+        }
+        throw error;
+      }
+      if (slashResult === "handled") {
+        if (slash?.name === "/background" && slash.args.trim() && sessionId) {
+          await ctx.refreshJobs();
+        }
+        return;
+      }
+      if (slashResult === "local_ui_ignored")
+        return;
+      if (slash) {
+        const catalogEntry = ctx.commandCatalogRef.current.find((entry) => entry.name === slash.name);
+        if (catalogEntry?.kind === "template") {
+          if (!sessionId)
+            return;
+          ctx.setLocalBusy(true);
+          const response = await client.sessions.admitPrompt(sessionId, {
+            id: createPromptRequestId(),
+            items: [
+              {
+                type: "skill",
+                name: catalogEntry.skillName,
+                path: catalogEntry.path,
+                ...catalogEntry.displayName ? { displayName: catalogEntry.displayName } : {},
+                ...catalogEntry.source && catalogEntry.source !== "builtin" ? { source: catalogEntry.source } : {}
+              },
+              ...slash.args ? [{ type: "text", text: ` ${slash.args}` }] : []
+            ]
+          });
+          ctx.setLocalBusy(false);
+          ctx.setSubmittedRun(response.run ? { sessionId, runId: response.run.id } : null);
+          return;
+        }
+        ctx.pushSystem(`Unknown command: ${slash.name}`);
+        return;
+      }
+      if (!sessionId) {
+        const session = await ctx.createAndSwitchSession(ctx.pendingNewSessionTitleRef.current);
+        if (!session)
+          return;
+        sessionId = session.id;
+      }
+      ctx.setLocalBusy(true);
+      const response = await client.sessions.admitPrompt(sessionId, {
+        id: createPromptRequestId(),
+        items: [{ type: "text", text: line }]
+      });
+      ctx.setLocalBusy(false);
+      ctx.setSubmittedRun(response.run ? { sessionId, runId: response.run.id } : null);
+      return;
+    }
+    case "delete_session": {
+      if (!client)
+        return;
+      const target = action.session_id;
+      if (!target)
+        return;
+      const archived = await client.sessions.archive(target);
+      const archivedAt = archived.archivedAt ?? Date.now();
+      delete ctx.listedSessionsRef.current[target];
+      ctx.setClientState((current) => archiveClientSession(current, target, archivedAt));
+      ctx.setLocalBusy(false);
+      ctx.setSubmittedRun(null);
+      ctx.setSelectRequest((current) => current ? {
+        ...current,
+        options: current.options.filter((option) => option.value !== target)
+      } : current);
+      if (target === ctx.activeSessionIdRef.current) {
+        const remaining = listTopLevelSessions(Object.values({
+          ...ctx.clientState.sessions,
+          ...ctx.listedSessionsRef.current,
+          [target]: { ...archived, status: "archived", archivedAt }
+        }));
+        if (remaining[0]) {
+          ctx.activateSession(remaining[0]);
+        } else {
+          const sessions = await client.sessions.list({
+            cwd: ctx.daemon?.cwd ?? undefined,
+            includeArchived: false,
+            limit: 20
+          });
+          ctx.listedSessionsRef.current = Object.fromEntries(sessions.map((session) => [session.id, session]));
+          const remoteNext = sessions.find((session) => session.id !== target);
+          if (remoteNext)
+            ctx.activateSession(remoteNext);
+          else
+            ctx.returnToHome();
+        }
+      }
+      return;
+    }
+    case "interrupt": {
+      if (!client)
+        return;
+      if (sessionId)
+        await client.sessions.interrupt(sessionId);
+      ctx.setLocalBusy(false);
+      ctx.setSubmittedRun(null);
+      return;
+    }
+    case "permission_response": {
+      if (!client)
+        return;
+      const requestId = action.request_id;
+      const allowed = action.allowed;
+      await client.permissions.reply(requestId, {
+        status: allowed ? "approved" : "denied",
+        decision: action.scope === "session" ? "session" : "once",
+        clientId: "tui"
+      });
+      ctx.setModal(null);
+      return;
+    }
+    case "list_sessions": {
+      if (!client)
+        return;
+      const cachedSessions = {
+        ...ctx.listedSessionsRef.current,
+        ...ctx.clientState.sessions
+      };
+      const cachedOptions = sessionSelectOptions(Object.values(cachedSessions), ctx.activeSessionIdRef.current);
+      ctx.clearDisplayRequest();
+      ctx.setSelectRequest({
+        title: "Sessions",
+        submitPrefix: "/sessions open ",
+        options: cachedOptions
+      });
+      const sessions = await client.sessions.list({
+        cwd: ctx.daemon?.cwd ?? undefined,
+        includeArchived: false,
+        limit: 20
+      });
+      ctx.listedSessionsRef.current = Object.fromEntries(sessions.map((session) => [session.id, session]));
+      ctx.setSelectRequest((current) => current?.submitPrefix === "/sessions open " ? {
+        title: "Sessions",
+        submitPrefix: "/sessions open ",
+        options: sessionSelectOptions(sessions, ctx.activeSessionIdRef.current)
+      } : current);
+      return;
+    }
+    case "set_permission_mode": {
+      if (!client)
+        return;
+      const mode = action.permission_mode;
+      ctx.setStatus((current) => ({ ...current, permission_mode: mode }));
+      if (sessionId) {
+        await client.sessions.update(sessionId, {
+          metadata: patchSessionRuntimeMetadata({}, { permissionMode: mode })
+        });
+      }
+      return;
+    }
+    case "question_response": {
+      if (!client)
+        return;
+      ctx.reportError("Interactive question responses are not available through the daemon client.");
+      return;
+    }
+    case "set_session_mode": {
+      if (!client)
+        return;
+      if (sessionId) {
+        ctx.pushSystem("Coordinator mode can only be changed before starting a new session. Use /new first.");
+        return;
+      }
+      const mode = normalizeSessionMode(action.session_mode);
+      ctx.nextSessionModeRef.current = statusSessionMode(mode);
+      ctx.setStatus((current) => ({
+        ...current,
+        session_mode: ctx.nextSessionModeRef.current
+      }));
+      return;
+    }
+    case "job_request": {
+      if (!client) {
+        ctx.reportAuxiliaryError("Jobs", "The daemon client is not connected.");
+        return;
+      }
+      const currentSessionId = ctx.activeSessionIdRef.current;
+      if (!currentSessionId)
+        return;
+      try {
+        switch (action.job_action) {
+          case "open":
+            await ctx.refreshJobs();
+            return;
+          case "refresh": {
+            ctx.jobControlGenerationRef.current += 1;
+            ctx.jobControlAbortRef.current?.abort();
+            ctx.jobControlAbortRef.current = null;
+            const detail = ctx.jobDetailStateRef.current;
+            const detailJobId = detail.status === "idle" ? undefined : detail.jobId;
+            await Promise.all([
+              ctx.refreshJobs(),
+              detailJobId ? ctx.loadJobDetail(client, currentSessionId, detailJobId) : Promise.resolve()
+            ]);
+            return;
+          }
+          case "select":
+            ctx.jobControlGenerationRef.current += 1;
+            ctx.jobControlAbortRef.current?.abort();
+            ctx.jobControlAbortRef.current = null;
+            await ctx.loadJobDetail(client, currentSessionId, action.job_id);
+            return;
+          case "cancel": {
+            const controlGeneration = ++ctx.jobControlGenerationRef.current;
+            const detailGeneration = ctx.jobDetailGenerationRef.current;
+            ctx.jobControlAbortRef.current?.abort();
+            const controller = new AbortController;
+            ctx.jobControlAbortRef.current = controller;
+            let response;
+            try {
+              response = await client.jobs.cancel(action.job_id, {
+                sessionId: currentSessionId,
+                reason: action.reason
+              }, { signal: controller.signal });
+            } catch (error) {
+              if (ctx.activeSessionIdRef.current !== currentSessionId)
+                return;
+              if (controller.signal.aborted || ctx.jobControlGenerationRef.current !== controlGeneration) {
+                await ctx.refreshJobs();
+                return;
+              }
+              throw error;
+            } finally {
+              if (ctx.jobControlAbortRef.current === controller)
+                ctx.jobControlAbortRef.current = null;
+            }
+            if (ctx.activeSessionIdRef.current !== currentSessionId)
+              return;
+            const ownsDetail = !controller.signal.aborted && ctx.jobControlGenerationRef.current === controlGeneration && ctx.jobDetailGenerationRef.current === detailGeneration;
+            const validated = validateJobSnapshot(response, currentSessionId, action.job_id);
+            if (!validated.snapshot) {
+              if (controller.signal.aborted || ctx.jobControlGenerationRef.current !== controlGeneration) {
+                await ctx.refreshJobs();
+                return;
+              }
+              throw new Error(validated.error ?? "Job snapshot has invalid fields.");
+            }
+            const snapshot = validated.snapshot;
+            const next = mergeJobSnapshot(ctx.jobStateRef.current, snapshot, Date.now());
+            ctx.jobStateRef.current = next;
+            ctx.setJobState(next);
+            if (ownsDetail) {
+              await ctx.loadJobDetail(client, currentSessionId, action.job_id);
+            }
+            await ctx.refreshJobs();
+            return;
+          }
+          case "send": {
+            const controlGeneration = ++ctx.jobControlGenerationRef.current;
+            const detailGeneration = ctx.jobDetailGenerationRef.current;
+            ctx.jobControlAbortRef.current?.abort();
+            const controller = new AbortController;
+            ctx.jobControlAbortRef.current = controller;
+            try {
+              await client.jobs.send(action.job_id, {
+                sessionId: currentSessionId,
+                data: action.data
+              }, { signal: controller.signal });
+            } catch (error) {
+              if (ctx.activeSessionIdRef.current !== currentSessionId)
+                return;
+              if (controller.signal.aborted || ctx.jobControlGenerationRef.current !== controlGeneration) {
+                await ctx.refreshJobs();
+                return;
+              }
+              throw error;
+            } finally {
+              if (ctx.jobControlAbortRef.current === controller)
+                ctx.jobControlAbortRef.current = null;
+            }
+            if (ctx.activeSessionIdRef.current !== currentSessionId)
+              return;
+            const ownsDetail = !controller.signal.aborted && ctx.jobControlGenerationRef.current === controlGeneration && ctx.jobDetailGenerationRef.current === detailGeneration;
+            if (ownsDetail) {
+              await ctx.loadJobDetail(client, currentSessionId, action.job_id);
+            }
+            await ctx.refreshJobs();
+            return;
+          }
+        }
+      } catch (error) {
+        ctx.reportAuxiliaryError("Jobs", error);
+        return;
+      }
+    }
+    default: {
+      const exhaustive = action;
+      ctx.reportError(`Unsupported TUI action: ${runtimeType}`);
+      return;
+    }
+  }
+}
+var JOBS_AUXILIARY_SLASH_COMMANDS;
+var init_actions = __esm(() => {
   init_src2();
+  init_job_remote_state();
+  init_sessionSlashCommands();
+  init_view_model();
+  init_connection();
+  JOBS_AUXILIARY_SLASH_COMMANDS = new Set([
+    "/agents",
+    "/background",
+    "/doctor",
+    "/jobs",
+    "/stats"
+  ]);
+});
+
+// ../frontend/src/hooks/sync-submodules/index.ts
+var init_sync_submodules = __esm(() => {
+  init_connection();
+  init_permissions();
+  init_view_model();
+  init_actions();
 });
 
 // ../frontend/src/hooks/useServerSync.ts
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
-function isRecord5(value) {
-  return !!value && typeof value === "object" && !Array.isArray(value);
-}
-function sessionRuntimeMetadata(input) {
-  const runtime = {};
-  if (typeof input.model === "string" && input.model) {
-    runtime.model = input.model;
-  }
-  if (typeof input.provider === "string" && input.provider) {
-    runtime.provider = input.provider;
-  }
-  if (typeof input.baseUrl === "string" && input.baseUrl) {
-    runtime.baseUrl = input.baseUrl;
-  }
-  if (input.apiFormat === "anthropic" || input.apiFormat === "openai") {
-    runtime.apiFormat = input.apiFormat;
-  }
-  if (input.permissionMode === "default" || input.permissionMode === "plan" || input.permissionMode === "full_auto") {
-    runtime.permissionMode = input.permissionMode;
-  }
-  if (typeof input.maxTurns === "number" && Number.isFinite(input.maxTurns)) {
-    runtime.maxTurns = input.maxTurns;
-  }
-  if (input.sessionMode === "coordinator" || input.sessionMode === "direct") {
-    runtime.sessionMode = input.sessionMode;
-  }
-  if (typeof input.pluginsEnabled === "boolean") {
-    runtime.pluginsEnabled = input.pluginsEnabled;
-  }
-  return patchSessionRuntimeMetadata({}, runtime);
-}
-function mcpServerSnapshot(server) {
-  return {
-    name: server.name,
-    state: server.status,
-    ...server.error || server.command ? { detail: server.error ?? server.command } : {},
-    tool_count: server.toolCount,
-    resource_count: server.resourceCount
-  };
-}
-function normalizeSessionMode(value) {
-  return value === "coordinator" ? "coordinator" : null;
-}
-function statusSessionMode(value) {
-  return normalizeSessionMode(value) ?? "direct";
-}
-function stringSetting(value) {
-  return typeof value === "string" && value.trim() ? value : undefined;
-}
-function archiveClientSession(state, sessionId, archivedAt) {
-  const current = state.sessions[sessionId];
-  if (!current || current.status === "archived")
-    return state;
-  const archived = {
-    ...current,
-    status: "archived",
-    archivedAt,
-    updatedAt: Math.max(current.updatedAt, archivedAt)
-  };
-  const bucket = state.buckets[sessionId];
-  return {
-    ...state,
-    sessions: { ...state.sessions, [sessionId]: archived },
-    buckets: bucket ? { ...state.buckets, [sessionId]: { ...bucket, session: archived } } : state.buckets
-  };
-}
-function listTopLevelSessions(sessions, activeSessionId) {
-  return [...sessions].filter((session) => !session.parentId && session.status !== "archived").sort((a, b) => {
-    if (a.id === activeSessionId)
-      return -1;
-    if (b.id === activeSessionId)
-      return 1;
-    return b.updatedAt - a.updatedAt;
-  });
-}
-function sessionSelectOptions(sessions, activeSessionId) {
-  return listTopLevelSessions(sessions, activeSessionId).map((session) => ({
-    value: session.id,
-    label: `${session.id === activeSessionId ? "* " : ""}${session.title || session.id}`,
-    description: `${session.model} | ${session.status}`
-  }));
-}
-function shouldAutoActivateSession(session, defaultModel, pluginsEnabled) {
-  const runtime = readSessionRuntimeConfig(session);
-  return runtime.model === defaultModel && (pluginsEnabled == null || (runtime.pluginsEnabled ?? true) === pluginsEnabled);
-}
-function recoverableInterruptedRuns(bucket) {
-  if (!bucket)
-    return [];
-  const recoveredSourceRunIds = new Set(bucket.inputs.flatMap((input) => isRecord5(input.metadata.recovery) && typeof input.metadata.recovery.sourceRunId === "string" ? [input.metadata.recovery.sourceRunId] : []));
-  return Object.values(bucket.runs).filter((run) => run.status === "interrupted" && !!run.inputId && !recoveredSourceRunIds.has(run.id)).sort((a, b) => b.updatedAt - a.updatedAt).flatMap((run) => {
-    const input = bucket.inputs.find((candidate) => candidate.id === run.inputId);
-    return input ? [{ id: run.id, error: run.error, prompt: input.content }] : [];
-  });
-}
-function shouldCoalesceClientState(update) {
-  return update.source === "live" && update.event?.type === "session.message.part.delta";
-}
-function permissionToModal(request) {
-  const input = request.payload.input && typeof request.payload.input === "object" ? request.payload.input : {};
-  return {
-    kind: "permission",
-    request_id: request.id,
-    tool_name: request.toolName,
-    reason: typeof request.payload.reason === "string" ? request.payload.reason : null,
-    input
-  };
-}
-function firstPendingPermission(state, sessionId) {
-  if (!sessionId)
-    return;
-  const bucket = state.buckets[sessionId];
-  if (!bucket)
-    return;
-  return Object.values(bucket.permissions).filter((request) => request.status === "pending").sort((a, b) => a.createdAt - b.createdAt).at(0);
-}
 function useServerSync(config, onError) {
   const daemon = config.daemon;
   const [clientState, setClientState] = useState(() => createInitialClientState());
@@ -3462,6 +4502,7 @@ function useServerSync(config, onError) {
   const pendingClientStateTimerRef = useRef(null);
   const shownPermissionIdRef = useRef(undefined);
   const auxiliaryGenerationRef = useRef(0);
+  const syncGenerationRef = useRef(0);
   const jobStateRef = useRef(jobState);
   const jobDetailStateRef = useRef(jobDetailState);
   const jobGenerationRef = useRef(0);
@@ -3576,7 +4617,7 @@ function useServerSync(config, onError) {
       return next;
     });
     try {
-      const response = await client.listJobs({
+      const response = await client.jobs.list({
         sessionId,
         includeFinished: true,
         limit: 100,
@@ -3635,7 +4676,7 @@ function useServerSync(config, onError) {
     jobDetailStateRef.current = loading;
     setJobDetailState(loading);
     try {
-      const response = await client.readJob(jobId, {
+      const response = await client.jobs.read(jobId, {
         sessionId,
         signal: controller.signal
       });
@@ -3678,7 +4719,7 @@ function useServerSync(config, onError) {
     const client = clientRef.current;
     if (!client)
       return [];
-    return await client.listModels();
+    return await client.providers.listModels();
   }, []);
   const cacheFirstRead = useCallback((request) => {
     const cached = presentationCacheRef.current[request.key];
@@ -3787,16 +4828,19 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
       return;
     }
     let cancelled = false;
-    const client = new OpenHarnessClient({
-      baseUrl: daemon.url,
-      token: daemon.token ?? undefined
-    });
+    const client = createDaemonClient(daemon);
+    if (!client)
+      return;
     clientRef.current = client;
     (async () => {
       try {
-        await client.health();
+        await client.protocol.health();
         const cwd = daemon.cwd ?? process.cwd();
-        const [settings, sessions, commands] = await Promise.all([client.getSettings().catch(() => ({})), client.listSessions({ cwd, limit: 20 }), client.listCommands({ cwd }).catch(() => [])]);
+        const [settings, sessions, commands] = await Promise.all([
+          client.system.getSettings().catch(() => ({})),
+          client.sessions.list({ cwd, limit: 20 }),
+          client.system.listCommands({ cwd }).catch(() => [])
+        ]);
         const model = daemon.model ?? stringSetting(settings.model) ?? "default";
         const provider = stringSetting(settings.provider);
         const baseUrl = stringSetting(settings.baseUrl);
@@ -3823,7 +4867,7 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
         const session = sessions[0];
         if (session && shouldAutoActivateSession(session, model, daemon?.pluginsEnabled)) {
           activateSession(session);
-          client.getSession(session.id).catch(() => {});
+          client.sessions.get(session.id).catch(() => {});
         }
         setReady(true);
       } catch (error) {
@@ -3842,36 +4886,46 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
     const client = clientRef.current;
     if (!client || !activeSessionId)
       return;
-    const controller = new AbortController;
-    (async () => {
-      let reconnectNotice = false;
-      try {
-        for await (const update of syncEvents(client, {
-          sessionId: activeSessionId,
-          signal: controller.signal
-        })) {
-          if (update.source === "reconnecting") {
-            if (!reconnectNotice) {
-              reconnectNotice = true;
-              pushSystem("reconnecting...");
-            }
-            continue;
+    const generation = ++syncGenerationRef.current;
+    let reconnectNotice = false;
+    const controller = new SessionSyncController({
+      client,
+      sessionId: activeSessionId,
+      generation,
+      onUpdate: (update, gen) => {
+        if (gen !== syncGenerationRef.current)
+          return;
+        if (update.source === "reconnecting") {
+          if (!reconnectNotice) {
+            reconnectNotice = true;
+            pushSystem("reconnecting...");
           }
-          if (reconnectNotice)
-            reconnectNotice = false;
-          commitClientState(update.state, shouldCoalesceClientState(update));
+          return;
         }
-      } catch (error) {
-        if (controller.signal.aborted)
+        if (reconnectNotice)
+          reconnectNotice = false;
+        commitClientState(update.state, shouldCoalesceClientState(update));
+      },
+      onError: (error, gen) => {
+        if (gen !== syncGenerationRef.current)
           return;
         reportError(error instanceof Error ? error.message : String(error));
       }
-    })();
+    });
+    controller.start();
     return () => {
       clearPendingClientState();
       controller.abort();
     };
-  }, [activeSessionId, clearPendingClientState, commitClientState, pushSystem, reportError]);
+  }, [
+    activeSessionId,
+    clearPendingClientState,
+    commitClientState,
+    daemon?.token,
+    daemon?.url,
+    pushSystem,
+    reportError
+  ]);
   useEffect(() => {
     const client = clientRef.current;
     const sessionId = activeSessionId;
@@ -3882,7 +4936,7 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
     const controller = new AbortController;
     mcpAbortRef.current = controller;
     const isCurrent = () => activeSessionIdRef.current === sessionId && auxiliaryGenerationRef.current === generation;
-    client.getSessionMcp(sessionId, { signal: controller.signal }).then((servers) => {
+    client.system.getSessionMcp(sessionId, { signal: controller.signal }).then((servers) => {
       if (!isCurrent())
         return;
       setMcpServers(Array.isArray(servers) ? servers.map(mcpServerSnapshot) : []);
@@ -3957,7 +5011,7 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
       sessionMode: nextSessionModeRef.current,
       pluginsEnabled: daemon?.pluginsEnabled
     });
-    const session = await client.createSession({
+    const session = await client.sessions.create({
       cwd,
       model,
       title: title?.trim() || "TUI",
@@ -3979,12 +5033,12 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
       return;
     setLocalBusy(true);
     (async () => {
-      const session = activeSessionId ? clientState.sessions[activeSessionId] ?? await client.getSession(activeSessionId) : await createAndSwitchSession();
+      const session = activeSessionId ? clientState.sessions[activeSessionId] ?? await client.sessions.get(activeSessionId) : await createAndSwitchSession();
       if (!session) {
         setLocalBusy(false);
         return;
       }
-      const response = await client.admitPrompt(session.id, {
+      const response = await client.sessions.admitPrompt(session.id, {
         id: createPromptRequestId(),
         items: [{ type: "text", text: config.initial_prompt }]
       });
@@ -3993,424 +5047,46 @@ Refresh failed: ${message}` : `Failed to load ${request.title}: ${message}`;
     })().catch((error) => reportError(error instanceof Error ? error.message : String(error)));
   }, [activeSessionId, clientState.sessions, config.initial_prompt, createAndSwitchSession, ready, reportError]);
   const sendRequest = useCallback((action) => {
-    const client = clientRef.current;
-    let sessionId = activeSessionIdRef.current;
-    (async () => {
-      const runtimeAction = action;
-      const runtimeType = typeof runtimeAction.type === "string" ? runtimeAction.type : "unknown";
-      switch (action.type) {
-        case "select_model": {
-          if (!client)
-            return;
-          const model = action.model.trim();
-          const provider = action.provider?.trim() ?? "";
-          if (!model)
-            return;
-          if (sessionId) {
-            const session = await client.updateSession(sessionId, {
-              metadata: patchSessionRuntimeMetadata({}, {
-                model,
-                ...provider ? { provider } : {}
-              })
-            });
-            activateSession(session);
-          } else {
-            const settingsPatch = { model };
-            if (provider)
-              settingsPatch.provider = provider;
-            await client.patchSettings(settingsPatch);
-            defaultRuntimeRef.current = {
-              ...defaultRuntimeRef.current,
-              model,
-              ...provider ? { provider } : {}
-            };
-            setStatus((current) => ({
-              ...current,
-              model,
-              ...provider ? { provider } : {}
-            }));
-          }
-          pushSystem(`Model selected: ${model}`);
-          return;
-        }
-        case "submit_line": {
-          if (!client)
-            return;
-          const line = action.line;
-          const slash = parseSlashLine(line);
-          const newSession = line.match(/^\/new(?:\s+(.+))?$/);
-          if (newSession) {
-            returnToHome(newSession[1]);
-            return;
-          }
-          const switchSession = line.match(/^\/sessions\s+open\s+(.+)$/);
-          if (switchSession?.[1]) {
-            const target = switchSession[1].trim();
-            setLocalBusy(false);
-            setSubmittedRun(null);
-            pendingNewSessionTitleRef.current = undefined;
-            setSelectRequest(null);
-            const knownSession = clientState.sessions[target] ?? listedSessionsRef.current[target];
-            if (knownSession) {
-              activateSession(knownSession);
-              return;
-            }
-            const session = await client.getSession(target);
-            activateSession(session);
-            return;
-          }
-          if (slash?.name === "/resume") {
-            if (!sessionId) {
-              pushSystem("No active session to resume.");
-              return;
-            }
-            const recoverable = recoverableInterruptedRuns(clientState.buckets[sessionId]);
-            if (!slash.args) {
-              if (recoverable.length === 0) {
-                pushSystem("No interrupted prompt runs are available to resume.");
-                return;
-              }
-              clearDisplayRequest();
-              setSelectRequest({
-                title: "Resume interrupted run",
-                submitPrefix: "/resume ",
-                options: recoverable.map((run) => ({
-                  value: run.id,
-                  label: run.prompt.length > 72 ? `${run.prompt.slice(0, 72)}...` : run.prompt,
-                  description: run.error ?? "Interrupted before completion"
-                }))
-              });
-              return;
-            }
-            const runId = slash.args.trim();
-            if (!recoverable.some((run) => run.id === runId)) {
-              pushSystem(`Run is not available for recovery: ${runId}`);
-              return;
-            }
-            setLocalBusy(true);
-            const response = await client.resumeInterruptedRun(sessionId, runId, { id: createPromptRequestId() });
-            setLocalBusy(false);
-            setSubmittedRun(response.run ? { sessionId, runId: response.run.id } : null);
-            setSelectRequest(null);
-            return;
-          }
-          let slashResult;
-          try {
-            slashResult = await dispatchSessionSlashCommand(slash, {
-              client,
-              sessionId,
-              pushSystem,
-              presentSystem: (title, content) => showDisplayRequest({ title, content }),
-              statusRef,
-              commandCatalogRef,
-              clientState,
-              localBusy,
-              cacheFirstRead,
-              daemon,
-              setStatus: setStatusAndDefault
-            });
-          } catch (error) {
-            if (slash && JOBS_AUXILIARY_SLASH_COMMANDS.has(slash.name)) {
-              reportAuxiliaryError("Jobs", error);
-              return;
-            }
-            throw error;
-          }
-          if (slashResult === "handled") {
-            if (slash?.name === "/background" && slash.args.trim() && sessionId) {
-              await refreshJobs();
-            }
-            return;
-          }
-          if (slashResult === "local_ui_ignored")
-            return;
-          if (slash) {
-            const catalogEntry = commandCatalogRef.current.find((entry) => entry.name === slash.name);
-            if (catalogEntry?.kind === "template") {
-              if (!sessionId)
-                return;
-              setLocalBusy(true);
-              const response = await client.admitPrompt(sessionId, {
-                id: createPromptRequestId(),
-                items: [
-                  {
-                    type: "skill",
-                    name: catalogEntry.skillName,
-                    path: catalogEntry.path,
-                    ...catalogEntry.displayName ? { displayName: catalogEntry.displayName } : {},
-                    ...catalogEntry.source && catalogEntry.source !== "builtin" ? { source: catalogEntry.source } : {}
-                  },
-                  ...slash.args ? [{ type: "text", text: ` ${slash.args}` }] : []
-                ]
-              });
-              setLocalBusy(false);
-              setSubmittedRun(response.run ? { sessionId, runId: response.run.id } : null);
-              return;
-            }
-            pushSystem(`Unknown command: ${slash.name}`);
-            return;
-          }
-          if (!sessionId) {
-            const session = await createAndSwitchSession(pendingNewSessionTitleRef.current);
-            if (!session)
-              return;
-            sessionId = session.id;
-          }
-          setLocalBusy(true);
-          const response = await client.admitPrompt(sessionId, {
-            id: createPromptRequestId(),
-            items: [{ type: "text", text: line }]
-          });
-          setLocalBusy(false);
-          setSubmittedRun(response.run ? { sessionId, runId: response.run.id } : null);
-          return;
-        }
-        case "delete_session": {
-          if (!client)
-            return;
-          const target = action.session_id;
-          if (!target)
-            return;
-          const archived = await client.archiveSession(target);
-          const archivedAt = archived.archivedAt ?? Date.now();
-          delete listedSessionsRef.current[target];
-          setClientState((current) => archiveClientSession(current, target, archivedAt));
-          setLocalBusy(false);
-          setSubmittedRun(null);
-          setSelectRequest((current) => current ? {
-            ...current,
-            options: current.options.filter((option) => option.value !== target)
-          } : current);
-          if (target === activeSessionIdRef.current) {
-            const remaining = listTopLevelSessions(Object.values({
-              ...clientState.sessions,
-              ...listedSessionsRef.current,
-              [target]: { ...archived, status: "archived", archivedAt }
-            }));
-            if (remaining[0]) {
-              activateSession(remaining[0]);
-            } else {
-              const sessions = await client.listSessions({
-                cwd: daemon?.cwd ?? undefined,
-                includeArchived: false,
-                limit: 20
-              });
-              listedSessionsRef.current = Object.fromEntries(sessions.map((session) => [session.id, session]));
-              const remoteNext = sessions.find((session) => session.id !== target);
-              if (remoteNext)
-                activateSession(remoteNext);
-              else
-                returnToHome();
-            }
-          }
-          return;
-        }
-        case "interrupt": {
-          if (!client)
-            return;
-          if (sessionId)
-            await client.interruptSession(sessionId);
-          setLocalBusy(false);
-          setSubmittedRun(null);
-          return;
-        }
-        case "permission_response": {
-          if (!client)
-            return;
-          const requestId = action.request_id;
-          const allowed = action.allowed;
-          await client.replyPermission(requestId, {
-            status: allowed ? "approved" : "denied",
-            decision: action.scope === "session" ? "session" : "once",
-            clientId: "tui"
-          });
-          setModal(null);
-          return;
-        }
-        case "list_sessions": {
-          if (!client)
-            return;
-          const cachedSessions = {
-            ...listedSessionsRef.current,
-            ...clientState.sessions
-          };
-          const cachedOptions = sessionSelectOptions(Object.values(cachedSessions), activeSessionIdRef.current);
-          clearDisplayRequest();
-          setSelectRequest({
-            title: "Sessions",
-            submitPrefix: "/sessions open ",
-            options: cachedOptions
-          });
-          const sessions = await client.listSessions({
-            cwd: daemon?.cwd ?? undefined,
-            includeArchived: false,
-            limit: 20
-          });
-          listedSessionsRef.current = Object.fromEntries(sessions.map((session) => [session.id, session]));
-          setSelectRequest((current) => current?.submitPrefix === "/sessions open " ? {
-            title: "Sessions",
-            submitPrefix: "/sessions open ",
-            options: sessionSelectOptions(sessions, activeSessionIdRef.current)
-          } : current);
-          return;
-        }
-        case "set_permission_mode": {
-          if (!client)
-            return;
-          const mode = action.permission_mode;
-          setStatus((current) => ({ ...current, permission_mode: mode }));
-          if (sessionId) {
-            await client.updateSession(sessionId, {
-              metadata: patchSessionRuntimeMetadata({}, { permissionMode: mode })
-            });
-          }
-          return;
-        }
-        case "question_response": {
-          if (!client)
-            return;
-          reportError("Interactive question responses are not available through the daemon client.");
-          return;
-        }
-        case "set_session_mode": {
-          if (!client)
-            return;
-          if (sessionId) {
-            pushSystem("Coordinator mode can only be changed before starting a new session. Use /new first.");
-            return;
-          }
-          const mode = normalizeSessionMode(action.session_mode);
-          nextSessionModeRef.current = statusSessionMode(mode);
-          setStatus((current) => ({
-            ...current,
-            session_mode: nextSessionModeRef.current
-          }));
-          return;
-        }
-        case "job_request": {
-          if (!client) {
-            reportAuxiliaryError("Jobs", "The daemon client is not connected.");
-            return;
-          }
-          const currentSessionId = activeSessionIdRef.current;
-          if (!currentSessionId)
-            return;
-          try {
-            switch (action.job_action) {
-              case "open":
-                await refreshJobs();
-                return;
-              case "refresh": {
-                jobControlGenerationRef.current += 1;
-                jobControlAbortRef.current?.abort();
-                jobControlAbortRef.current = null;
-                const detail = jobDetailStateRef.current;
-                const detailJobId = detail.status === "idle" ? undefined : detail.jobId;
-                await Promise.all([
-                  refreshJobs(),
-                  detailJobId ? loadJobDetail(client, currentSessionId, detailJobId) : Promise.resolve()
-                ]);
-                return;
-              }
-              case "select":
-                jobControlGenerationRef.current += 1;
-                jobControlAbortRef.current?.abort();
-                jobControlAbortRef.current = null;
-                await loadJobDetail(client, currentSessionId, action.job_id);
-                return;
-              case "cancel": {
-                const controlGeneration = ++jobControlGenerationRef.current;
-                const detailGeneration = jobDetailGenerationRef.current;
-                jobControlAbortRef.current?.abort();
-                const controller = new AbortController;
-                jobControlAbortRef.current = controller;
-                let response;
-                try {
-                  response = await client.cancelJob(action.job_id, {
-                    sessionId: currentSessionId,
-                    reason: action.reason
-                  }, { signal: controller.signal });
-                } catch (error) {
-                  if (activeSessionIdRef.current !== currentSessionId)
-                    return;
-                  if (controller.signal.aborted || jobControlGenerationRef.current !== controlGeneration) {
-                    await refreshJobs();
-                    return;
-                  }
-                  throw error;
-                } finally {
-                  if (jobControlAbortRef.current === controller)
-                    jobControlAbortRef.current = null;
-                }
-                if (activeSessionIdRef.current !== currentSessionId)
-                  return;
-                const ownsDetail = !controller.signal.aborted && jobControlGenerationRef.current === controlGeneration && jobDetailGenerationRef.current === detailGeneration;
-                const validated = validateJobSnapshot(response, currentSessionId, action.job_id);
-                if (!validated.snapshot) {
-                  if (controller.signal.aborted || jobControlGenerationRef.current !== controlGeneration) {
-                    await refreshJobs();
-                    return;
-                  }
-                  throw new Error(validated.error ?? "Job snapshot has invalid fields.");
-                }
-                const snapshot = validated.snapshot;
-                const next = mergeJobSnapshot(jobStateRef.current, snapshot, Date.now());
-                jobStateRef.current = next;
-                setJobState(next);
-                if (ownsDetail) {
-                  await loadJobDetail(client, currentSessionId, action.job_id);
-                }
-                await refreshJobs();
-                return;
-              }
-              case "send": {
-                const controlGeneration = ++jobControlGenerationRef.current;
-                const detailGeneration = jobDetailGenerationRef.current;
-                jobControlAbortRef.current?.abort();
-                const controller = new AbortController;
-                jobControlAbortRef.current = controller;
-                try {
-                  await client.sendJob(action.job_id, {
-                    sessionId: currentSessionId,
-                    data: action.data
-                  }, { signal: controller.signal });
-                } catch (error) {
-                  if (activeSessionIdRef.current !== currentSessionId)
-                    return;
-                  if (controller.signal.aborted || jobControlGenerationRef.current !== controlGeneration) {
-                    await refreshJobs();
-                    return;
-                  }
-                  throw error;
-                } finally {
-                  if (jobControlAbortRef.current === controller)
-                    jobControlAbortRef.current = null;
-                }
-                if (activeSessionIdRef.current !== currentSessionId)
-                  return;
-                const ownsDetail = !controller.signal.aborted && jobControlGenerationRef.current === controlGeneration && jobDetailGenerationRef.current === detailGeneration;
-                if (ownsDetail) {
-                  await loadJobDetail(client, currentSessionId, action.job_id);
-                }
-                await refreshJobs();
-                return;
-              }
-            }
-          } catch (error) {
-            reportAuxiliaryError("Jobs", error);
-            return;
-          }
-        }
-        default: {
-          const exhaustive = action;
-          reportError(`Unsupported TUI action: ${runtimeType}`);
-          return;
-        }
-      }
-    })().catch((error) => {
+    executeTuiAction(action, {
+      clientRef,
+      activeSessionIdRef,
+      clientState,
+      setClientState,
+      daemon,
+      defaultRuntimeRef,
+      nextSessionModeRef,
+      statusRef,
+      setStatus,
+      setStatusAndDefault,
+      listedSessionsRef,
+      commandCatalogRef,
+      pendingNewSessionTitleRef,
+      localBusy,
+      setLocalBusy,
+      setSubmittedRun,
+      setModal,
+      setSelectRequest,
+      clearDisplayRequest,
+      showDisplayRequest,
+      pushSystem,
+      reportError,
+      reportAuxiliaryError,
+      activateSession,
+      returnToHome,
+      refreshJobs,
+      loadJobDetail,
+      createAndSwitchSession,
+      cacheFirstRead,
+      jobStateRef,
+      setJobState,
+      jobDetailStateRef,
+      jobControlGenerationRef,
+      jobDetailGenerationRef,
+      jobControlAbortRef
+    }).catch((error) => {
       reportError(error instanceof Error ? error.message : String(error));
     });
-  }, [activeSessionId, activateSession, cacheFirstRead, clearDisplayRequest, clientState, createAndSwitchSession, daemon, loadJobDetail, localBusy, pushSystem, refreshJobs, reportAuxiliaryError, reportError, returnToHome, showDisplayRequest]);
+  }, [activateSession, cacheFirstRead, clearDisplayRequest, clientState, createAndSwitchSession, daemon, loadJobDetail, localBusy, pushSystem, refreshJobs, reportAuxiliaryError, reportError, returnToHome, setStatusAndDefault, showDisplayRequest]);
   const bucket = activeSessionId ? clientState.buckets[activeSessionId] : undefined;
   const recoveryItems = useMemo(() => recoverableInterruptedRuns(bucket).map((run) => ({
     id: `recovery:${run.id}`,
@@ -4452,19 +5128,14 @@ Use /resume ${run.id} to replay its original prompt.`
     sendRequest
   }), [commandDetails, commands, displayRequest, jobDetailState, jobState, loadModels, localBusy, mcpServers, modal, ready, running, selectRequest, sendRequest, status, transcriptView, waitingForSubmittedRun]);
 }
-var JOBS_AUXILIARY_SLASH_COMMANDS, LIVE_TEXT_DELTA_FLUSH_MS = 33, PRESENTATION_LOADING_TEXT = "Loading...";
+var LIVE_TEXT_DELTA_FLUSH_MS = 33, PRESENTATION_LOADING_TEXT = "Loading...";
 var init_useServerSync = __esm(() => {
   init_src2();
   init_job_remote_state();
   init_transcript();
   init_sessionSlashCommands();
-  JOBS_AUXILIARY_SLASH_COMMANDS = new Set([
-    "/agents",
-    "/background",
-    "/doctor",
-    "/jobs",
-    "/stats"
-  ]);
+  init_sync_submodules();
+  init_sync_submodules();
 });
 
 // ../frontend/src/ui/constants.ts
@@ -8167,4 +8838,4 @@ try {
   process.exit(1);
 }
 
-//# debugId=CC7EA554B2C5EAF964756E2164756E21
+//# debugId=9F3BE548A8F89F3864756E2164756E21