@gatherthread/dsh-host 0.1.0-alpha.1

package/dist/bundle/plugin.js

@@ -0,0 +1,3713 @@
+// dist/src/config.js
+import { createHash } from "node:crypto";
+import { lstat as lstat2 } from "node:fs/promises";
+import path2 from "node:path";
+
+// dist/src/path-security.js
+import { lstat, realpath } from "node:fs/promises";
+import path from "node:path";
+async function prospectiveRealPath(candidate) {
+  let current = path.resolve(candidate);
+  const missing = [];
+  while (true) {
+    try {
+      return path.join(await realpath(current), ...missing);
+    } catch (error) {
+      if (!isNodeError(error) || error.code !== "ENOENT")
+        throw error;
+      const parent = path.dirname(current);
+      if (parent === current)
+        throw new Error(`No existing ancestor for path: ${candidate}`);
+      missing.unshift(path.basename(current));
+      current = parent;
+    }
+  }
+}
+async function secureDirectoryChain(directory) {
+  const absolute = path.resolve(directory);
+  const root = path.parse(absolute).root;
+  const relative = path.relative(root, absolute);
+  const components = relative ? relative.split(path.sep) : [];
+  const identities = [];
+  let current = root;
+  for (const component of components) {
+    current = path.join(current, component);
+    let metadata;
+    try {
+      metadata = await lstat(current);
+    } catch (error) {
+      if (isNodeError(error) && error.code === "ENOENT")
+        break;
+      throw error;
+    }
+    if (metadata.isSymbolicLink()) {
+      throw new Error("DSH connector state path must not traverse a symbolic-link ancestor");
+    }
+    if (!metadata.isDirectory()) {
+      throw new Error("DSH connector state path ancestor must be a directory");
+    }
+    identities.push({ path: current, dev: metadata.dev, ino: metadata.ino });
+  }
+  return identities;
+}
+function assertSameDirectoryChain(before, after) {
+  if (before.length !== after.length || before.some((entry, index) => {
+    const candidate = after[index];
+    return candidate === void 0 || candidate.path !== entry.path || candidate.dev !== entry.dev || candidate.ino !== entry.ino;
+  })) {
+    throw new Error("DSH connector state path ancestors changed during file access");
+  }
+}
+function isNodeError(error) {
+  return error instanceof Error && "code" in error;
+}
+
+// dist/src/config.js
+var CONFIG_KEYS = /* @__PURE__ */ new Set([
+  "enabled",
+  "bindingMode",
+  "apiUrl",
+  "credentialReference",
+  "projectId",
+  "projectName",
+  "sessionId",
+  "deviceId",
+  "workspacePath",
+  "statePath",
+  "stateRoot",
+  "provider",
+  "model",
+  "pollIntervalMs",
+  "pollLimit",
+  "shareToolEvents",
+  "refreshIntervalMs",
+  "maxConcurrentSessions",
+  "retryBaseMs",
+  "retryMaxMs"
+]);
+var SINGLE_ONLY_KEYS = ["sessionId", "statePath"];
+var PROJECT_ONLY_KEYS = [
+  "stateRoot",
+  "refreshIntervalMs",
+  "maxConcurrentSessions",
+  "retryBaseMs",
+  "retryMaxMs"
+];
+function parseDshHostConfig(input) {
+  if (input === void 0)
+    return { enabled: false };
+  const value = requiredObject(input, "config");
+  rejectUnknownKeys(value, CONFIG_KEYS, "config");
+  if (value.enabled !== true) {
+    if (value.enabled !== void 0 && value.enabled !== false) {
+      throw new Error("config.enabled must be true or false");
+    }
+    return { enabled: false };
+  }
+  const bindingMode = value.bindingMode === void 0 ? "single" : value.bindingMode;
+  if (bindingMode !== "single" && bindingMode !== "project") {
+    throw new Error("config.bindingMode must be single or project");
+  }
+  rejectModeKeys(value, bindingMode === "single" ? PROJECT_ONLY_KEYS : SINGLE_ONLY_KEYS, bindingMode);
+  const workspacePath = absolutePath(value.workspacePath, "config.workspacePath");
+  const credential = requiredObject(value.credentialReference, "config.credentialReference");
+  rejectUnknownKeys(credential, /* @__PURE__ */ new Set(["kind", "variable"]), "config.credentialReference");
+  if (credential.kind !== "environment") {
+    throw new Error("config.credentialReference.kind must be environment");
+  }
+  const variable = requiredString(credential.variable, "config.credentialReference.variable", 128);
+  if (!/^[A-Z][A-Z0-9_]*$/.test(variable)) {
+    throw new Error("config.credentialReference.variable must be an uppercase environment variable name");
+  }
+  const projectId = safeIdentifier(value.projectId, "config.projectId");
+  const projectName = value.projectName === void 0 ? void 0 : safeText(value.projectName, "config.projectName", 160);
+  const deviceId = safeIdentifier(value.deviceId, "config.deviceId");
+  const provider = safeText(value.provider, "config.provider", 80);
+  const model = safeText(value.model, "config.model", 160);
+  const common = {
+    enabled: true,
+    apiUrl: normalizeApiUrl(requiredString(value.apiUrl, "config.apiUrl", 2048)),
+    credentialReference: { kind: "environment", variable },
+    projectId,
+    ...projectName === void 0 ? {} : { projectName },
+    deviceId,
+    workspacePath,
+    provider,
+    model,
+    pollIntervalMs: boundedInteger(value.pollIntervalMs, 1e3, 50, 6e4, "config.pollIntervalMs"),
+    pollLimit: boundedInteger(value.pollLimit, 200, 1, 500, "config.pollLimit"),
+    shareToolEvents: optionalBoolean(value.shareToolEvents, false, "config.shareToolEvents")
+  };
+  if (bindingMode === "project") {
+    const stateRoot = absolutePath(value.stateRoot, "config.stateRoot");
+    if (isWithin(workspacePath, stateRoot)) {
+      throw new Error("config.stateRoot must be outside the read-only workspace");
+    }
+    const retryBaseMs = boundedInteger(value.retryBaseMs, 1e3, 50, 6e4, "config.retryBaseMs");
+    const retryMaxMs = boundedInteger(value.retryMaxMs, 3e4, 50, 3e5, "config.retryMaxMs");
+    if (retryMaxMs < retryBaseMs) {
+      throw new Error("config.retryMaxMs must be greater than or equal to config.retryBaseMs");
+    }
+    return {
+      ...common,
+      bindingMode,
+      stateRoot,
+      refreshIntervalMs: boundedInteger(value.refreshIntervalMs, 5e3, 250, 3e5, "config.refreshIntervalMs"),
+      maxConcurrentSessions: boundedInteger(value.maxConcurrentSessions, 4, 1, 32, "config.maxConcurrentSessions"),
+      retryBaseMs,
+      retryMaxMs
+    };
+  }
+  const sessionId = safeIdentifier(value.sessionId, "config.sessionId");
+  const statePath = absolutePath(value.statePath, "config.statePath");
+  if (isWithin(workspacePath, statePath)) {
+    throw new Error("config.statePath must be outside the read-only workspace");
+  }
+  return {
+    ...common,
+    bindingMode,
+    sessionId,
+    statePath,
+    dshSessionId: deriveDshSessionId(projectId, sessionId, workspacePath)
+  };
+}
+function assertSafeDshEnvironment(env = process.env) {
+  const telemetryDisabled = env.DSH_TELEMETRY_DISABLED === "1" || env.DSH_TELEMETRY_MODE?.trim().toUpperCase() === "DISABLED";
+  if (!telemetryDisabled) {
+    throw new Error("DeepSeek Harness telemetry must be disabled for the GatherThread host plugin");
+  }
+  if (env.DSH_PERMISSION_MODE?.trim().toLowerCase() !== "read-only") {
+    throw new Error("DSH_PERMISSION_MODE must be read-only for the GatherThread host plugin MVP");
+  }
+}
+async function assertSafeDshPaths(config) {
+  await assertRealStateSeparation(config.workspacePath, config.statePath, "config.statePath");
+  await secureDirectoryChain(path2.dirname(config.statePath));
+  try {
+    const target = await lstat2(config.statePath);
+    if (target.isSymbolicLink()) {
+      throw new Error("config.statePath must never be a symbolic link");
+    }
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+async function assertSafeDshStateRoot(config) {
+  await assertRealStateSeparation(config.workspacePath, config.stateRoot, "config.stateRoot");
+  await secureDirectoryChain(config.stateRoot);
+  try {
+    const target = await lstat2(config.stateRoot);
+    if (target.isSymbolicLink() || !target.isDirectory()) {
+      throw new Error("config.stateRoot must be a real directory, never a symbolic link");
+    }
+    if (process.platform !== "win32" && (Number(target.mode) & 511) !== 448) {
+      throw new Error("config.stateRoot permissions must be 0700");
+    }
+  } catch (error) {
+    if (isNodeError2(error) && error.code === "ENOENT")
+      return;
+    throw error;
+  }
+}
+async function assertRealStateSeparation(workspacePath, stateLocation, label) {
+  const [workspaceRealPath, stateRealPath] = await Promise.all([
+    prospectiveRealPath(workspacePath),
+    prospectiveRealPath(stateLocation)
+  ]);
+  if (isWithin(workspaceRealPath, stateRealPath)) {
+    throw new Error(`${label} real path must be outside the read-only workspace`);
+  }
+}
+function rejectModeKeys(value, forbidden, bindingMode) {
+  const present = forbidden.filter((key) => value[key] !== void 0);
+  if (present.length > 0) {
+    throw new Error(`config bindingMode ${bindingMode} does not accept: ${present.join(", ")}`);
+  }
+}
+function resolveCredentialReference(reference, env = process.env) {
+  if (reference.kind !== "environment") {
+    throw new Error("DSH grant credentials must be resolved by the native Host boundary");
+  }
+  const credential = env[reference.variable];
+  if (!credential || !credential.trim() || /[\r\n]/.test(credential)) {
+    throw new Error(`credential reference ${reference.variable} is missing or invalid`);
+  }
+  return credential;
+}
+function deriveDshSessionId(projectId, sessionId, workspacePath) {
+  const digest2 = createHash("sha256").update(JSON.stringify([projectId, sessionId, path2.resolve(workspacePath)])).digest("hex").slice(0, 32);
+  return `gatherthread-${digest2}`;
+}
+function normalizeApiUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("config.apiUrl must be an absolute HTTP(S) URL");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error("config.apiUrl must use HTTP or HTTPS");
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new Error("config.apiUrl cannot contain credentials, a query, or a fragment");
+  }
+  if (url.protocol === "http:" && !isLoopback(url.hostname)) {
+    throw new Error("config.apiUrl must use HTTPS except for a loopback host");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+function isLoopback(hostname) {
+  return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+function safeIdentifier(value, label) {
+  const text = requiredString(value, label, 128);
+  if (!/^[A-Za-z0-9._:-]+$/.test(text))
+    throw new Error(`${label} contains unsupported characters`);
+  return text;
+}
+function safeText(value, label, maximum) {
+  const text = requiredString(value, label, maximum);
+  if (/[\u0000-\u001f\u007f-\u009f]/u.test(text))
+    throw new Error(`${label} contains control characters`);
+  return text;
+}
+function absolutePath(value, label) {
+  const text = requiredString(value, label, 4096);
+  if (!path2.isAbsolute(text))
+    throw new Error(`${label} must be absolute`);
+  return path2.resolve(text);
+}
+function isWithin(parent, candidate) {
+  const relative = path2.relative(parent, candidate);
+  return relative === "" || !relative.startsWith(`..${path2.sep}`) && relative !== "..";
+}
+function isNodeError2(error) {
+  return error instanceof Error && "code" in error;
+}
+function boundedInteger(value, fallback, minimum, maximum, label) {
+  if (value === void 0)
+    return fallback;
+  if (!Number.isSafeInteger(value) || Number(value) < minimum || Number(value) > maximum) {
+    throw new Error(`${label} must be an integer from ${minimum} to ${maximum}`);
+  }
+  return Number(value);
+}
+function optionalBoolean(value, fallback, label) {
+  if (value === void 0)
+    return fallback;
+  if (typeof value !== "boolean")
+    throw new Error(`${label} must be true or false`);
+  return value;
+}
+function requiredString(value, label, maximum) {
+  if (typeof value !== "string" || !value.trim() || value.length > maximum) {
+    throw new Error(`${label} must be a non-empty string no longer than ${maximum} characters`);
+  }
+  return value.trim();
+}
+function requiredObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function rejectUnknownKeys(value, allowed, label) {
+  const unknown = Object.keys(value).filter((key) => !allowed.has(key));
+  if (unknown.length > 0)
+    throw new Error(`${label} contains unsupported keys: ${unknown.join(", ")}`);
+}
+
+// ../bridge/dist/src/http-client.js
+import { createHash as createHash2 } from "node:crypto";
+var CollaborationHttpError = class extends Error {
+  status;
+  code;
+  constructor(status, message, code) {
+    super(message);
+    this.name = "CollaborationHttpError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var HttpCollaborationClient = class {
+  #baseUrl;
+  #bearerToken;
+  #fetch;
+  #signal;
+  #requestTimeoutMs;
+  constructor(options) {
+    const parsedBaseUrl = validateBaseUrl(options.baseUrl);
+    if (!options.bearerToken || /[\r\n]/.test(options.bearerToken)) {
+      throw new Error("bearerToken must be a non-empty HTTP bearer token");
+    }
+    if (options.requestTimeoutMs !== void 0 && (!Number.isSafeInteger(options.requestTimeoutMs) || options.requestTimeoutMs < 1)) {
+      throw new Error("requestTimeoutMs must be a positive integer");
+    }
+    this.#baseUrl = parsedBaseUrl;
+    this.#bearerToken = options.bearerToken;
+    this.#fetch = options.fetch ?? globalThis.fetch;
+    this.#signal = options.signal;
+    this.#requestTimeoutMs = options.requestTimeoutMs ?? 3e4;
+  }
+  async listSessions() {
+    const body = await this.#request("/sessions");
+    const sessions = isObject(body) && Array.isArray(body.sessions) ? body.sessions : body;
+    if (!Array.isArray(sessions))
+      throw new Error("Collaboration API returned an invalid session list");
+    return sessions.map(fromWireSession);
+  }
+  async listProjects() {
+    const body = await this.#request("/projects");
+    const projects = isObject(body) && Array.isArray(body.projects) ? body.projects : body;
+    if (!Array.isArray(projects))
+      throw new Error("Collaboration API returned an invalid project list");
+    return projects.map(fromWireProject);
+  }
+  async listProjectSessions(projectId) {
+    const body = await this.#request(`/projects/${encodeURIComponent(projectId)}/sessions`);
+    const sessions = isObject(body) && Array.isArray(body.sessions) ? body.sessions : body;
+    if (!Array.isArray(sessions))
+      throw new Error("Collaboration API returned an invalid project session list");
+    return sessions.map(fromWireSession);
+  }
+  async listSessionMembers(sessionId) {
+    const body = await this.#request(`/sessions/${encodeURIComponent(sessionId)}/members`);
+    const members = isObject(body) && Array.isArray(body.members) ? body.members : body;
+    if (!Array.isArray(members))
+      throw new Error("Collaboration API returned an invalid member list");
+    return members.map(fromWireSessionMember);
+  }
+  async createSession(projectId, input) {
+    const body = requiredObject2(await this.#request(`/projects/${encodeURIComponent(projectId)}/sessions`, {
+      method: "POST",
+      body: JSON.stringify({
+        ...input.sessionId === void 0 ? {} : { session_id: input.sessionId },
+        title: input.title,
+        mode: input.mode,
+        idempotency_key: input.idempotencyKey
+      })
+    }));
+    return fromWireSession(body.session ?? body);
+  }
+  async updateSession(sessionId, input) {
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}`, {
+      method: "PATCH",
+      body: JSON.stringify({
+        title: input.title,
+        idempotency_key: input.idempotencyKey
+      })
+    }));
+    return fromWireSession(body.session ?? body);
+  }
+  async getCurrentActor() {
+    const body = requiredObject2(await this.#request("/me"));
+    return {
+      id: requiredString2(body.id, "actor.id"),
+      displayName: requiredString2(body.username, "actor.username"),
+      deviceId: requiredString2(body.device_id, "actor.device_id")
+    };
+  }
+  async readEvents(sessionId, afterSequence, limit = 200) {
+    const query = new URLSearchParams({
+      after_sequence: String(afterSequence),
+      limit: String(limit)
+    });
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/events?${query}`));
+    const events = requiredArray(body.events).map(fromWireEvent);
+    return {
+      events,
+      nextSequence: requiredNumber(body.cursor, "cursor"),
+      hasMore: body.has_more === true
+    };
+  }
+  async appendEvent(sessionId, event) {
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/events`, {
+      method: "POST",
+      body: JSON.stringify(toWireEvent(event))
+    }));
+    return fromWireEvent(body.event ?? body);
+  }
+  async registerRuntime(runtime) {
+    const body = requiredObject2(await this.#request("/runtimes", {
+      method: "POST",
+      body: JSON.stringify(toSnakeCase(runtime))
+    }));
+    return fromWireRuntime(body.runtime ?? body);
+  }
+  async heartbeatRuntime(runtimeId) {
+    const body = requiredObject2(await this.#request(`/runtimes/${encodeURIComponent(runtimeId)}/heartbeat`, {
+      method: "POST",
+      body: "{}"
+    }));
+    return fromWireRuntime(body.runtime ?? body);
+  }
+  async claimAgentRequest(sessionId, requestId, runtimeId) {
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/agent-requests/${encodeURIComponent(requestId)}/claim`, {
+      method: "POST",
+      body: JSON.stringify({ runtime_id: runtimeId })
+    }));
+    const status = body.status === "completed" ? "completed" : "claimed";
+    return {
+      claimed: status === "claimed",
+      status,
+      requestId: requiredString2(body.request_event_id, "claim.request_event_id"),
+      runtimeId: requiredString2(body.runtime_id, "claim.runtime_id")
+    };
+  }
+  async completeAgentRequest(sessionId, requestId, input) {
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/agent-requests/${encodeURIComponent(requestId)}/complete`, {
+      method: "POST",
+      body: JSON.stringify({
+        runtime_id: input.runtimeId,
+        idempotency_key: input.idempotencyKey,
+        payload: truncateJsonValue(input.payload, 160 * 1024),
+        ...input.observedModel === void 0 ? {} : { observed_model: input.observedModel },
+        ...input.observedReasoningEffort === void 0 ? {} : { observed_reasoning_effort: input.observedReasoningEffort }
+      })
+    }));
+    return fromWireEvent(body.event ?? body);
+  }
+  async appendAgentProgress(sessionId, requestId, input) {
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/agent-requests/${encodeURIComponent(requestId)}/progress`, {
+      method: "POST",
+      body: JSON.stringify({
+        runtime_id: input.runtimeId,
+        idempotency_key: input.idempotencyKey,
+        payload: truncateJsonValue(input.payload, 32 * 1024),
+        ...input.observedModel === void 0 ? {} : { observed_model: input.observedModel },
+        ...input.observedReasoningEffort === void 0 ? {} : { observed_reasoning_effort: input.observedReasoningEffort }
+      })
+    }));
+    return fromWireEvent(body.event ?? body);
+  }
+  async commitLocalTurn(sessionId, input) {
+    const toolEvents = (input.toolEvents ?? []).slice(0, 32).map(boundLocalToolEvent);
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/local-turns`, {
+      method: "POST",
+      body: JSON.stringify({
+        local_turn_id: input.localTurnId,
+        runtime_id: input.runtimeId,
+        based_on_sequence: input.basedOnSequence,
+        occurred_at: input.occurredAt,
+        ...input.observedModel === void 0 ? {} : { observed_model: input.observedModel },
+        ...input.observedReasoningEffort === void 0 ? {} : { observed_reasoning_effort: input.observedReasoningEffort },
+        request_payload: truncateJsonValue(input.requestPayload, 32 * 1024),
+        response_payload: truncateJsonValue(input.responsePayload, 112 * 1024),
+        ...input.toolEvents === void 0 ? {} : { tool_events: toolEvents }
+      })
+    }));
+    return {
+      localTurnId: requiredString2(body.local_turn_id, "local_turn.local_turn_id"),
+      runtimeId: requiredString2(body.runtime_id, "local_turn.runtime_id"),
+      headBeforeCommit: requiredNumber(body.head_before_commit, "local_turn.head_before_commit"),
+      reconciliationRequired: body.reconciliation_required === true,
+      requestEvent: fromWireEvent(body.request_event),
+      responseEvent: fromWireEvent(body.response_event),
+      toolEvents: Array.isArray(body.tool_events) ? body.tool_events.map(fromWireEvent) : []
+    };
+  }
+  async getSnapshotRequest(requestId) {
+    const body = requiredObject2(await this.#request(`/snapshot-requests/${encodeURIComponent(requestId)}`));
+    return fromWireSnapshotRequest(body.snapshot_request ?? body);
+  }
+  async createSnapshotRequest(sessionId) {
+    const body = requiredObject2(await this.#request(`/sessions/${encodeURIComponent(sessionId)}/snapshot-requests`, {
+      method: "POST",
+      body: "{}"
+    }));
+    return fromWireSnapshotRequest(body.snapshot_request ?? body);
+  }
+  async listSnapshotRequests(status, limit = 20) {
+    const query = new URLSearchParams({ status, limit: String(limit) });
+    const body = await this.#request(`/snapshot-requests?${query}`);
+    const requests = isObject(body) && Array.isArray(body.snapshot_requests) ? body.snapshot_requests : body;
+    if (!Array.isArray(requests))
+      throw new Error("Collaboration API returned an invalid snapshot request list");
+    return requests.map(fromWireSnapshotRequest);
+  }
+  async claimSnapshotRequest(requestId, runtimeId) {
+    return this.#mutateSnapshotRequest(requestId, "claim", { runtime_id: runtimeId });
+  }
+  async completeSnapshotRequest(requestId, runtimeId, result) {
+    return this.#mutateSnapshotRequest(requestId, "complete", { runtime_id: runtimeId, result });
+  }
+  async failSnapshotRequest(requestId, runtimeId, error) {
+    return this.#mutateSnapshotRequest(requestId, "fail", { runtime_id: runtimeId, error });
+  }
+  async #mutateSnapshotRequest(requestId, action, input) {
+    const body = requiredObject2(await this.#request(`/snapshot-requests/${encodeURIComponent(requestId)}/${action}`, {
+      method: "POST",
+      body: JSON.stringify(input)
+    }));
+    return fromWireSnapshotRequest(body.snapshot_request ?? body);
+  }
+  async #request(path5, init = {}) {
+    const signal = combineSignals(init.signal ?? void 0, this.#signal, AbortSignal.timeout(this.#requestTimeoutMs));
+    const response = await this.#fetch(`${this.#baseUrl}${path5}`, {
+      ...init,
+      redirect: "error",
+      signal,
+      headers: {
+        accept: "application/json",
+        authorization: `Bearer ${this.#bearerToken}`,
+        ...init.body ? { "content-type": "application/json" } : {},
+        ...init.headers
+      }
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok) {
+      const detail = isObject(body) && typeof body.error === "string" ? body.error : isObject(body) && isObject(body.error) && typeof body.error.message === "string" ? body.error.message : response.statusText;
+      const code = isObject(body) && isObject(body.error) && typeof body.error.code === "string" ? body.error.code : void 0;
+      throw new CollaborationHttpError(response.status, `Collaboration API ${response.status}: ${redactCredential(detail, this.#bearerToken)}`, code);
+    }
+    return isObject(body) && "data" in body ? body.data : body;
+  }
+};
+function validateBaseUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("baseUrl must be an absolute HTTP(S) URL");
+  }
+  if (url.protocol !== "https:" && url.protocol !== "http:") {
+    throw new Error("baseUrl must use HTTP or HTTPS");
+  }
+  if (url.username || url.password || url.search || url.hash) {
+    throw new Error("baseUrl cannot contain credentials, a query, or a fragment");
+  }
+  return url.toString().replace(/\/$/, "");
+}
+function combineSignals(...signals) {
+  const present = signals.filter((signal) => signal !== void 0);
+  return present.length === 1 ? present[0] : AbortSignal.any(present);
+}
+function redactCredential(value, credential) {
+  return value.replaceAll(credential, "[REDACTED]").replace(/[\r\n]+/g, " ");
+}
+function toWireEvent(event) {
+  return {
+    type: event.type,
+    idempotency_key: event.idempotencyKey,
+    payload: event.payload,
+    reply_to_event_id: event.replyTo,
+    visibility: event.visibility ?? "session",
+    runtime_id: event.runtimeId ?? event.runtime?.runtimeId,
+    observed_model: event.observedModel,
+    observed_reasoning_effort: event.observedReasoningEffort
+  };
+}
+function toSnakeCase(value) {
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`),
+    item
+  ]));
+}
+function fromWireEvent(value) {
+  const input = requiredObject2(value);
+  const actorDisplayName = optionalWireString(input.actor_display_name) ?? optionalWireString(input.actor_username);
+  const runtime = input.runtime_provenance === null || input.runtime_provenance === void 0 ? void 0 : fromWireProvenance(input.runtime_provenance);
+  return {
+    id: requiredString2(input.id, "event.id"),
+    sessionId: requiredString2(input.session_id, "event.session_id"),
+    sequence: requiredNumber(input.sequence, "event.sequence"),
+    type: requiredString2(input.type, "event.type"),
+    actorId: requiredString2(input.actor_user_id, "event.actor_user_id"),
+    ...actorDisplayName === void 0 ? {} : { actorDisplayName },
+    timestamp: requiredString2(input.created_at, "event.created_at"),
+    payload: input.payload,
+    ...runtime === void 0 ? {} : { runtime }
+  };
+}
+function fromWireSnapshotRequest(value) {
+  const input = requiredObject2(value);
+  const status = requiredString2(input.status, "snapshot_request.status");
+  if (status !== "pending" && status !== "claimed" && status !== "completed" && status !== "failed") {
+    throw new Error("Collaboration API returned an invalid snapshot request status");
+  }
+  const failureInput = isObject(input.failure) ? input.failure : isObject(input.error) ? input.error : void 0;
+  const failure = failureInput ? {
+    code: requiredString2(failureInput.code, "snapshot_request.failure.code"),
+    message: requiredString2(failureInput.message, "snapshot_request.failure.message")
+  } : void 0;
+  const createdAt = optionalWireString(input.created_at) ?? optionalWireString(input.requested_at);
+  return {
+    id: requiredString2(input.id, "snapshot_request.id"),
+    sessionId: requiredString2(input.session_id, "snapshot_request.session_id"),
+    throughSequence: requiredNumber(input.through_sequence, "snapshot_request.through_sequence"),
+    status,
+    ...createdAt === void 0 ? {} : { createdAt },
+    ..."result" in input ? { result: input.result } : {},
+    ...failure === void 0 ? {} : { failure }
+  };
+}
+function fromWireSession(value) {
+  const input = requiredObject2(value);
+  const name2 = optionalWireString(input.title) ?? optionalWireString(input.name);
+  const role = optionalWireString(input.role);
+  const latestSequence = typeof input.current_sequence === "number" ? input.current_sequence : typeof input.next_sequence === "number" ? input.next_sequence : void 0;
+  return {
+    id: requiredString2(input.id, "session.id"),
+    ...typeof input.project_id === "string" ? { projectId: input.project_id } : {},
+    ...typeof input.owner_user_id === "string" ? { ownerUserId: input.owner_user_id } : {},
+    mode: requiredString2(input.mode, "session.mode"),
+    ...input.state === "active" || input.state === "archived" ? { state: input.state } : {},
+    ...name2 === void 0 ? {} : { name: name2 },
+    ...role === void 0 ? {} : { role },
+    ...latestSequence === void 0 ? {} : { latestSequence }
+  };
+}
+function fromWireProject(value) {
+  const input = requiredObject2(value);
+  return {
+    id: requiredString2(input.id, "project.id"),
+    name: requiredString2(input.title, "project.title"),
+    role: requiredString2(input.role, "project.role"),
+    state: requiredString2(input.state, "project.state"),
+    sessionCount: requiredNumber(input.session_count, "project.session_count")
+  };
+}
+function fromWireSessionMember(value) {
+  const input = requiredObject2(value);
+  let runtime = null;
+  if (input.runtime !== null && input.runtime !== void 0) {
+    const wireRuntime = requiredObject2(input.runtime);
+    runtime = {
+      purpose: wireRuntime.purpose === "snapshot_connector" ? "snapshot_connector" : "execution",
+      harness: requiredString2(wireRuntime.harness, "member.runtime.harness"),
+      provider: requiredString2(wireRuntime.provider, "member.runtime.provider"),
+      model: requiredString2(wireRuntime.model, "member.runtime.model"),
+      status: wireRuntime.status === "online" ? "online" : "offline"
+    };
+  }
+  return {
+    displayName: requiredString2(input.display_name, "member.display_name"),
+    role: requiredString2(input.role, "member.role"),
+    runtime
+  };
+}
+function fromWireRuntime(value) {
+  const input = requiredObject2(value);
+  const purpose = input.purpose === "snapshot_connector" ? "snapshot_connector" : "execution";
+  return {
+    id: requiredString2(input.id, "runtime.id"),
+    userId: requiredString2(input.user_id, "runtime.user_id"),
+    runtimeId: requiredString2(input.id, "runtime.id"),
+    sessionId: requiredString2(input.session_id, "runtime.session_id"),
+    deviceId: requiredString2(input.device_id, "runtime.device_id"),
+    harness: requiredString2(input.harness, "runtime.harness"),
+    provider: requiredString2(input.provider, "runtime.provider"),
+    model: requiredString2(input.model, "runtime.model"),
+    localSessionId: requiredString2(input.local_session_id, "runtime.local_session_id"),
+    captureFidelity: requiredString2(input.capture_fidelity, "runtime.capture_fidelity"),
+    purpose
+  };
+}
+function fromWireProvenance(value) {
+  const input = requiredObject2(value);
+  return {
+    userId: requiredString2(input.user_id, "runtime_provenance.user_id"),
+    deviceId: requiredString2(input.device_id, "runtime_provenance.device_id"),
+    runtimeId: requiredString2(input.runtime_id, "runtime_provenance.runtime_id"),
+    harness: requiredString2(input.harness, "runtime_provenance.harness"),
+    provider: requiredString2(input.provider, "runtime_provenance.provider"),
+    model: requiredString2(input.model, "runtime_provenance.model"),
+    ...typeof input.reasoning_effort === "string" ? { reasoningEffort: input.reasoning_effort } : {},
+    localSessionId: requiredString2(input.local_session_id, "runtime_provenance.local_session_id"),
+    captureFidelity: requiredString2(input.capture_fidelity, "runtime_provenance.capture_fidelity")
+  };
+}
+function requiredObject2(value) {
+  if (!isObject(value))
+    throw new Error("Collaboration API returned an invalid object");
+  return value;
+}
+function requiredArray(value) {
+  if (!Array.isArray(value))
+    throw new Error("Collaboration API returned an invalid array");
+  return value;
+}
+function requiredString2(value, field) {
+  if (typeof value !== "string")
+    throw new Error(`Collaboration API omitted ${field}`);
+  return value;
+}
+function requiredNumber(value, field) {
+  if (!Number.isSafeInteger(value))
+    throw new Error(`Collaboration API omitted ${field}`);
+  return Number(value);
+}
+function optionalWireString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function truncateJsonValue(value, maxBytes) {
+  let encoded;
+  try {
+    encoded = JSON.stringify(value);
+  } catch {
+    encoded = JSON.stringify("[unserializable]");
+  }
+  if (Buffer.byteLength(encoded) <= maxBytes)
+    return value;
+  const originalBytes = Buffer.byteLength(encoded);
+  const sha256 = createHash2("sha256").update(encoded).digest("hex");
+  let end = Math.min(encoded.length, Math.max(0, maxBytes - 256));
+  while (end > 0 && Buffer.byteLength(encoded.slice(0, end)) > maxBytes - 256)
+    end -= 1;
+  return { truncated: true, original_bytes: originalBytes, sha256, preview: encoded.slice(0, end) };
+}
+function boundLocalToolEvent(value) {
+  if (!isObject(value) || value.type !== "tool_call" && value.type !== "tool_result") {
+    return { type: "tool_result", payload: truncateJsonValue(value, 768) };
+  }
+  return {
+    type: value.type,
+    payload: truncateJsonValue(value.payload, 768),
+    ...typeof value.occurred_at === "string" ? { occurred_at: value.occurred_at } : {}
+  };
+}
+async function readResponseBody(response) {
+  const text = await response.text();
+  if (!text)
+    return void 0;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function isObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+// ../adapters/dist/src/redaction.js
+var REDACTED = "[REDACTED]";
+var DEFAULT_SECRET_PATTERNS = [
+  /-----BEGIN (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA |EC |OPENSSH |DSA )?PRIVATE KEY-----/g,
+  /\bAKIA[0-9A-Z]{16}\b/g,
+  /\b(?:ghp|github_pat|glpat|sk|xox[baprs])[-_][A-Za-z0-9_-]{16,}\b/g,
+  /\bBearer\s+[A-Za-z0-9._~+/=-]{8,}\b/gi,
+  /\b(?:gt[abid]|acp(?:i|d)?)_[A-Za-z0-9_-]{20,}\b/g,
+  /\b((?:api[_-]?key|access[_-]?token|auth[_-]?token|client[_-]?secret|password|passwd|secret|token)\s*[=:]\s*)[^\s,;]+/gi,
+  /\b([A-Z][A-Z0-9_]*(?:TOKEN|SECRET|PASSWORD|PASSWD|API_KEY|AUTH_TOKEN_PEPPER)\s*[=:]\s*)[^\s,;]+/g
+];
+var SENSITIVE_KEY_NAMES = /* @__PURE__ */ new Set([
+  "apikey",
+  "accesstoken",
+  "authtoken",
+  "authorization",
+  "bearer",
+  "clientsecret",
+  "password",
+  "passwd",
+  "privatekey",
+  "refreshtoken",
+  "secret",
+  "token",
+  "thinking",
+  "rawthinking",
+  "systemprompt",
+  "developerprompt",
+  "localsessionid"
+]);
+function redactText(value, options = {}) {
+  const replacement = options.replacement ?? REDACTED;
+  return [...DEFAULT_SECRET_PATTERNS, ...options.extraPatterns ?? []].reduce((redacted, pattern) => redacted.replace(cloneGlobal(pattern), (match, prefix) => typeof prefix === "string" && prefix.length < match.length ? `${prefix}${replacement}` : replacement), value);
+}
+function redactValue(value, options = {}) {
+  if (typeof value === "string")
+    return redactText(value, options);
+  if (Array.isArray(value))
+    return value.map((item) => redactValue(item, options));
+  if (!value || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    isSensitiveKey(key) ? options.replacement ?? REDACTED : redactValue(item, options)
+  ]));
+}
+function isSensitiveKey(key) {
+  const normalized = key.replace(/[^a-z0-9]/gi, "").toLowerCase();
+  return SENSITIVE_KEY_NAMES.has(normalized) || normalized.endsWith("token") || normalized.endsWith("secret") || normalized.endsWith("password") || normalized.endsWith("passwd") || normalized.endsWith("apikey") || normalized.endsWith("privatekey") || normalized.endsWith("tokenpepper") || normalized.endsWith("systemprompt") || normalized.endsWith("developerprompt") || normalized.endsWith("rawthinking");
+}
+function cloneGlobal(pattern) {
+  return new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+}
+
+// ../adapters/dist/src/jsonl.js
+var DEFAULT_MAX_READ_BYTES = 4 * 1024 * 1024;
+
+// ../bridge/dist/src/codex-executor.js
+var DEFAULT_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_MAX_OUTPUT_BYTES = 16 * 1024 * 1024;
+var DEFAULT_MAX_PROMPT_BYTES = 8 * 1024 * 1024;
+var DEFAULT_MAX_TOOL_OUTPUT_BYTES = 32 * 1024;
+
+// ../bridge/dist/src/codex-hooks.js
+var DEFAULT_SPOOL_MAX_BYTES = 8 * 1024 * 1024;
+
+// ../bridge/dist/src/codex-app-server.js
+var DEFAULT_TURN_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_MAX_MESSAGE_BYTES = 16 * 1024 * 1024;
+var DEFAULT_MAX_PROMPT_BYTES2 = 8 * 1024 * 1024;
+var DEFAULT_MAX_INJECTION_ITEM_BYTES = 64 * 1024;
+var DEFAULT_MAX_TOOL_OUTPUT_BYTES2 = 32 * 1024;
+var MAX_LOCAL_TURN_UPLOAD_BYTES = 180 * 1024;
+var DEFAULT_DESKTOP_RELAY_CONTEXT_BYTES = 7 * 1024;
+var DESKTOP_RELAY_EVENT_CHUNK_BYTES = 16 * 1024;
+
+// ../bridge/dist/src/project-session-permissions.js
+function isSessionWritableBy(session, actorUserId) {
+  if (session.role === "viewer")
+    return false;
+  if (session.mode === "solo") {
+    return session.ownerUserId === void 0 ? session.role === "owner" : session.ownerUserId === actorUserId;
+  }
+  return session.role === "owner" || session.role === "participant";
+}
+async function reconcileProjectSessionPermissions(input) {
+  const visibleSessions = input.sessions.filter((session) => session.state !== "archived");
+  const eligibleSessions = visibleSessions.filter((session) => isSessionWritableBy(session, input.actorUserId));
+  const eligibleIds = new Set(eligibleSessions.map((session) => session.id));
+  const sessionsById = new Map(input.sessions.map((session) => [session.id, session]));
+  const errors = [];
+  for (const [sessionId, current] of [...input.managed]) {
+    if (eligibleIds.has(sessionId))
+      continue;
+    input.managed.delete(sessionId);
+    try {
+      await current.deactivateLocalPublishing?.(projectSessionDeactivationReason(sessionsById.get(sessionId)));
+    } catch (error) {
+      errors.push(error instanceof Error ? error : new Error("Local publishing deactivation failed"));
+    }
+  }
+  try {
+    await input.harness.deactivateExecutionBindings?.({
+      retainSessionIds: [...input.managed.keys()],
+      preserveSessionIds: [...eligibleIds]
+    });
+  } catch (error) {
+    errors.push(error instanceof Error ? error : new Error("Execution allowlist reconciliation failed"));
+  }
+  return { visibleSessions, eligibleSessions, errors };
+}
+async function refreshProjectSessionPermissions(input) {
+  let sessions;
+  try {
+    sessions = await input.loadSessions();
+  } catch (error) {
+    return isProjectAccessRevoked(error) ? { status: "project_inaccessible", error } : { status: "transient_failure", error };
+  }
+  return {
+    status: "updated",
+    ...await reconcileProjectSessionPermissions({
+      sessions,
+      ...input.actorUserId === void 0 ? {} : { actorUserId: input.actorUserId },
+      managed: input.managed,
+      harness: input.harness
+    })
+  };
+}
+function projectSessionDeactivationReason(session) {
+  if (!session)
+    return "removed";
+  if (session.state === "archived")
+    return "archived";
+  return "read_only";
+}
+function isProjectAccessRevoked(error) {
+  return error instanceof CollaborationHttpError && (error.status === 403 || error.status === 404);
+}
+
+// ../bridge/dist/src/local-api-relay.js
+var MAX_FRAME_BYTES = 1024 * 1024;
+
+// dist/src/collaboration-api.js
+function createHttpDshCollaborationApi(options) {
+  const client = new HttpCollaborationClient({
+    baseUrl: options.baseUrl,
+    bearerToken: options.credential,
+    ...options.requestTimeoutMs === void 0 ? {} : { requestTimeoutMs: options.requestTimeoutMs },
+    ...options.fetch === void 0 ? {} : { fetch: options.fetch },
+    ...options.signal === void 0 ? {} : { signal: options.signal }
+  });
+  return {
+    ...adaptCollaborationApi(client),
+    getCurrentActor: () => client.getCurrentActor(),
+    createSession: (projectId, input) => client.createSession(projectId, input)
+  };
+}
+function adaptCollaborationApi(client) {
+  const listProjectSessions = client.listProjectSessions;
+  const heartbeatRuntime = client.heartbeatRuntime;
+  const appendAgentProgress = client.appendAgentProgress;
+  const commitLocalTurn = client.commitLocalTurn;
+  if (listProjectSessions === void 0 || heartbeatRuntime === void 0 || appendAgentProgress === void 0 || commitLocalTurn === void 0) {
+    throw new Error("GatherThread Collaboration API lacks required session, heartbeat, progress, or local-turn support");
+  }
+  return {
+    listProjectSessions: (projectId) => listProjectSessions.call(client, projectId),
+    readEvents: (sessionId, afterSequence, limit) => client.readEvents(sessionId, afterSequence, limit),
+    registerRuntime: async (input) => client.registerRuntime(input),
+    heartbeatRuntime: async (runtimeId) => heartbeatRuntime.call(client, runtimeId),
+    claimAgentRequest: (sessionId, requestId, runtimeId) => client.claimAgentRequest(sessionId, requestId, runtimeId),
+    appendAgentProgress: (sessionId, requestId, input) => appendAgentProgress.call(client, sessionId, requestId, input),
+    appendEvent: (sessionId, input) => client.appendEvent(sessionId, input),
+    completeAgentRequest: (sessionId, requestId, input) => client.completeAgentRequest(sessionId, requestId, input),
+    commitLocalTurn: (sessionId, input) => commitLocalTurn.call(client, sessionId, input)
+  };
+}
+function isTerminalClaimConflict(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const candidate = error;
+  return candidate.status === 409 && (candidate.code === "agent_request_already_claimed" || candidate.code === "agent_request_already_completed");
+}
+
+// dist/src/connector.js
+import { createHash as createHash3 } from "node:crypto";
+
+// dist/src/canonical-prompt.js
+var MAX_EVENT_TEXT_BYTES = 8 * 1024;
+var MAX_REQUEST_TEXT_BYTES = 32 * 1024;
+var MAX_PROMPT_BYTES = 128 * 1024;
+function requestedDshProfile(event) {
+  if (event.type !== "agent_request")
+    return void 0;
+  const payload = asObject(event.payload);
+  const profile = asObject(payload?.execution_profile);
+  if (profile === void 0)
+    return void 0;
+  const harness = safeProfileText(profile.harness, 80).toLowerCase();
+  if (harness !== "deepseek-harness")
+    return void 0;
+  const model = safeProfileText(profile.model, 160);
+  if (!model)
+    throw new Error("DeepSeek Harness Agent request must name a model");
+  const provider = profile.provider === void 0 ? void 0 : safeProfileText(profile.provider, 80);
+  if (profile.provider !== void 0 && !provider) {
+    throw new Error("DeepSeek Harness Agent request has an invalid provider target");
+  }
+  const runtimeId = profile.runtime_id === void 0 ? void 0 : safeRuntimeId(profile.runtime_id);
+  return {
+    harness,
+    ...provider === void 0 ? {} : { provider },
+    model,
+    ...runtimeId === void 0 ? {} : { runtimeId }
+  };
+}
+function buildDshCanonicalPrompt(history, request, ownRuntimeId) {
+  if (request.type !== "agent_request")
+    throw new Error("Expected an agent_request event");
+  const requestText = extractPublicText(request.payload);
+  if (!requestText)
+    throw new Error("DeepSeek Harness Agent request has no public text content");
+  const boundedRequest = boundText(redactText(requestText), MAX_REQUEST_TEXT_BYTES);
+  const contextLines = history.filter((event) => event.sequence < request.sequence).filter((event) => !isAlreadyPresentLocalOutput(event, ownRuntimeId)).filter((event) => [
+    "human_chat",
+    "agent_progress",
+    "agent_response",
+    "tool_call",
+    "tool_result"
+  ].includes(event.type)).flatMap((event) => {
+    const text = extractPublicEventText(event);
+    if (!text)
+      return [];
+    const actor = boundText(redactText(event.actorDisplayName ?? event.actorId), 512);
+    return [`[${event.sequence}] ${event.type} \xB7 ${actor}: ${boundText(redactText(text), MAX_EVENT_TEXT_BYTES)}`];
+  });
+  const header = [
+    "GatherThread canonical context follows. It is collaboration data for this request.",
+    "Do not reveal hidden reasoning, credentials, local paths, or private tool metadata in your answer.",
+    "Context updates:"
+  ].join("\n");
+  const footer = [
+    "Current GatherThread Agent request:",
+    `[${request.sequence}] ${boundedRequest}`,
+    "Return a public final answer for the shared GatherThread session."
+  ].join("\n");
+  const fixedBytes = Buffer.byteLength(`${header}
+
+${footer}`, "utf8");
+  const contextBudget = Math.max(0, MAX_PROMPT_BYTES - fixedBytes - 64);
+  const retained = [];
+  let used = 0;
+  for (const line of contextLines.toReversed()) {
+    const bytes = Buffer.byteLength(`${line}
+`, "utf8");
+    if (used + bytes > contextBudget)
+      continue;
+    retained.push(line);
+    used += bytes;
+  }
+  retained.reverse();
+  const omitted = retained.length < contextLines.length ? [`[${contextLines.length - retained.length} older public context update(s) omitted by size limit]`] : [];
+  const prompt = `${header}
+${[...omitted, ...retained].join("\n") || "[none]"}
+
+${footer}`;
+  if (Buffer.byteLength(prompt, "utf8") > MAX_PROMPT_BYTES) {
+    throw new Error("GatherThread canonical prompt exceeds the connector safety limit");
+  }
+  return prompt;
+}
+function buildDshRequestPrompt(request) {
+  if (request.type !== "agent_request")
+    throw new Error("Expected an agent_request event");
+  const requestText = extractPublicText(request.payload);
+  if (!requestText)
+    throw new Error("DeepSeek Harness Agent request has no public text content");
+  return boundText(redactText(requestText), MAX_REQUEST_TEXT_BYTES);
+}
+function extractPublicText(value) {
+  if (typeof value === "string")
+    return value;
+  const payload = asObject(value);
+  if (payload === void 0)
+    return "";
+  for (const key of ["content", "text", "message", "prompt", "response"]) {
+    if (typeof payload[key] === "string")
+      return payload[key];
+  }
+  return "";
+}
+function extractPublicEventText(event) {
+  if (event.type !== "tool_call" && event.type !== "tool_result") {
+    return extractPublicText(event.payload);
+  }
+  const payload = asObject(event.payload);
+  if (payload === void 0)
+    return "";
+  const selected = event.type === "tool_call" ? compact({
+    tool_name: stringValue(payload.tool_name),
+    tool_call_id: stringValue(payload.tool_call_id),
+    arguments: payload.arguments
+  }) : compact({
+    tool_call_id: stringValue(payload.tool_call_id),
+    result: payload.result,
+    is_error: typeof payload.is_error === "boolean" ? payload.is_error : void 0,
+    error_code: stringValue(payload.error_code)
+  });
+  if (Object.keys(selected).length === 0)
+    return "";
+  return JSON.stringify(redactValue(selected));
+}
+function isAlreadyPresentLocalOutput(event, runtimeId) {
+  return runtimeId !== void 0 && event.runtime?.runtimeId === runtimeId && ["agent_progress", "agent_response", "tool_call", "tool_result"].includes(event.type);
+}
+function safeProfileText(value, maximum) {
+  if (typeof value !== "string")
+    return "";
+  const text = value.trim();
+  if (!text || text.length > maximum || /[\u0000-\u001f\u007f-\u009f]/u.test(text)) {
+    throw new Error("Agent request contains an invalid execution profile");
+  }
+  return text;
+}
+function safeRuntimeId(value) {
+  if (typeof value !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/u.test(value.trim())) {
+    throw new Error("Agent request contains an invalid DeepSeek Harness runtime target");
+  }
+  return value.trim();
+}
+function stringValue(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function compact(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, item]) => item !== void 0));
+}
+function boundText(value, maximumBytes) {
+  if (Buffer.byteLength(value, "utf8") <= maximumBytes)
+    return value;
+  const suffix = "\n[TRUNCATED]";
+  const target = maximumBytes - Buffer.byteLength(suffix, "utf8");
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= target)
+      low = middle;
+    else
+      high = middle - 1;
+  }
+  return `${value.slice(0, low)}${suffix}`;
+}
+function asObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// dist/src/event-mapper.js
+var DEFAULT_ASSISTANT_BYTES = 112 * 1024;
+var DEFAULT_TOOL_BYTES = 32 * 1024;
+function mapDshSessionEvent(event, options = {}) {
+  const timestamp2 = safeTimestamp(event.time);
+  if (timestamp2 === void 0)
+    return void 0;
+  const data = asObject2(event.data);
+  if (data === void 0)
+    return void 0;
+  const assistantBytes = checkedLimit(options.maxAssistantBytes, DEFAULT_ASSISTANT_BYTES);
+  const toolBytes = checkedLimit(options.maxToolBytes, DEFAULT_TOOL_BYTES);
+  if (event.type === "assistant/message") {
+    const message = asObject2(data.message);
+    const content = visibleTextBlocks(message?.content);
+    if (!content)
+      return void 0;
+    const mapped = {
+      kind: "assistant",
+      localEventId: `dsh-assistant-${event.seq}`,
+      sequence: event.seq,
+      timestamp: timestamp2,
+      content: boundText2(redactText(content), assistantBytes)
+    };
+    return mapped;
+  }
+  if (event.type === "tool/call") {
+    if (typeof data.callId !== "string" || typeof data.name !== "string" || typeof data.arguments !== "string") {
+      return void 0;
+    }
+    const mapped = {
+      kind: "tool_call",
+      localEventId: `dsh-tool-call-${event.seq}`,
+      sequence: event.seq,
+      timestamp: timestamp2,
+      toolName: boundText2(redactText(data.name), 512),
+      toolCallId: boundText2(redactText(data.callId), 512),
+      arguments: redactAndBound(parseToolArguments(data.arguments), toolBytes)
+    };
+    return mapped;
+  }
+  if (event.type === "tool/result") {
+    const message = asObject2(data.message);
+    const block = firstToolResultBlock(message?.content);
+    if (block === void 0 || typeof block.toolCallId !== "string")
+      return void 0;
+    const result = visibleTextBlocks(block.content);
+    const error = asObject2(data.error);
+    const mapped = {
+      kind: "tool_result",
+      localEventId: `dsh-tool-result-${event.seq}`,
+      sequence: event.seq,
+      timestamp: timestamp2,
+      toolCallId: boundText2(redactText(block.toolCallId), 512),
+      result: redactAndBound(result, toolBytes),
+      isError: block.isError === true || error !== void 0,
+      ...typeof error?.code === "string" ? { errorCode: boundText2(redactText(error.code), 256) } : {}
+    };
+    return mapped;
+  }
+  return void 0;
+}
+function mapDshSessionEvents(events, options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const mapped = [];
+  for (const event of events) {
+    const candidate = mapDshSessionEvent(event, options);
+    if (candidate === void 0 || seen.has(candidate.localEventId))
+      continue;
+    seen.add(candidate.localEventId);
+    mapped.push(candidate);
+  }
+  return mapped.sort((left, right) => left.sequence - right.sequence);
+}
+function finalVisibleAssistant(events) {
+  return events.findLast((event) => event.kind === "assistant" && event.content.trim().length > 0);
+}
+function visibleTextBlocks(value) {
+  if (!Array.isArray(value))
+    return "";
+  return value.flatMap((block) => {
+    const candidate = asObject2(block);
+    return candidate?.type === "text" && typeof candidate.text === "string" ? [candidate.text] : [];
+  }).join("");
+}
+function firstToolResultBlock(value) {
+  if (!Array.isArray(value))
+    return void 0;
+  return value.map(asObject2).find((block) => block?.type === "tool-result");
+}
+function parseToolArguments(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function redactAndBound(value, maximumBytes) {
+  const redacted = redactValue(value);
+  const encoded = safeJson(redacted);
+  if (Buffer.byteLength(encoded, "utf8") <= maximumBytes)
+    return redacted;
+  return {
+    truncated: true,
+    preview: boundText2(encoded, Math.max(256, maximumBytes - 128))
+  };
+}
+function safeJson(value) {
+  try {
+    return JSON.stringify(value) ?? "null";
+  } catch {
+    return "[Unserializable tool value]";
+  }
+}
+function boundText2(value, maximumBytes) {
+  if (Buffer.byteLength(value, "utf8") <= maximumBytes)
+    return value;
+  const suffix = "\n[TRUNCATED]";
+  const target = Math.max(0, maximumBytes - Buffer.byteLength(suffix, "utf8"));
+  let low = 0;
+  let high = value.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(value.slice(0, middle), "utf8") <= target)
+      low = middle;
+    else
+      high = middle - 1;
+  }
+  return `${value.slice(0, low)}${suffix}`;
+}
+function checkedLimit(value, fallback) {
+  if (value === void 0)
+    return fallback;
+  if (!Number.isSafeInteger(value) || value < 1024 || value > 2 * 1024 * 1024) {
+    throw new Error("DSH event mapping byte limits must be integers from 1024 to 2097152");
+  }
+  return value;
+}
+function safeTimestamp(value) {
+  try {
+    const timestamp2 = new Date(value);
+    if (!Number.isFinite(timestamp2.getTime()))
+      return void 0;
+    return timestamp2.toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function asObject2(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// dist/src/connector.js
+var DshHostConnector = class {
+  #config;
+  #api;
+  #host;
+  #stateStore;
+  #onBackgroundError;
+  #heartbeatIntervalMs;
+  #actorUserId;
+  #executionGate;
+  #onLifecycle;
+  #adoptExistingLocalSession;
+  #state;
+  #runtime;
+  #started = false;
+  #stopped = false;
+  #timer;
+  #heartbeatTimer;
+  #pollPromise;
+  #heartbeatPromise;
+  #stopPromise;
+  #backgroundFatalError;
+  #lifecycleAbort = new AbortController();
+  #listenerDisposers = [];
+  #activeStatuses = [];
+  #liveEventSequences = /* @__PURE__ */ new Set();
+  #session;
+  #visibleState = "connecting";
+  #automaticPolling = false;
+  constructor(options) {
+    if (options.host.sessionId !== options.config.dshSessionId) {
+      throw new Error("DSH Host facade Session does not match the configured binding");
+    }
+    this.#config = options.config;
+    this.#api = options.api;
+    this.#host = options.host;
+    this.#stateStore = options.stateStore;
+    this.#onBackgroundError = options.onBackgroundError;
+    this.#actorUserId = options.actorUserId;
+    this.#executionGate = options.executionGate;
+    this.#onLifecycle = options.onLifecycle;
+    this.#adoptExistingLocalSession = options.adoptExistingLocalSession === true;
+    if (options.heartbeatIntervalMs !== void 0 && (!Number.isSafeInteger(options.heartbeatIntervalMs) || options.heartbeatIntervalMs < 1)) {
+      throw new Error("DSH connector heartbeat interval must be a positive integer");
+    }
+    this.#heartbeatIntervalMs = options.heartbeatIntervalMs ?? 1e4;
+  }
+  get stopped() {
+    return this.#stopped;
+  }
+  async start(options = {}) {
+    if (this.#started)
+      throw new Error("DSH connector is already started");
+    if (this.#stopped)
+      throw new Error("DSH connector cannot restart after disposal");
+    this.#started = true;
+    this.#automaticPolling = options.schedule !== false;
+    this.#notifyLifecycle("connecting");
+    this.#listenerDisposers.push(this.#host.onSessionEvent((event) => {
+      const active = this.#state?.activeRequest;
+      if (active !== void 0 && event.seq >= active.dshFromSequence) {
+        this.#liveEventSequences.add(event.seq);
+      }
+      if (active === void 0 && event.type === "turn/end" && turnSettlement([event]) === "completed" && this.#automaticPolling) {
+        queueMicrotask(() => {
+          if (this.#started && !this.#stopped) {
+            void this.pollOnce().catch((error) => {
+              this.#onBackgroundError?.(publicError(error));
+            });
+          }
+        });
+      }
+    }));
+    this.#listenerDisposers.push(this.#host.onStatus((status) => {
+      if (this.#state?.activeRequest === void 0)
+        return;
+      if (this.#activeStatuses.at(-1) !== status)
+        this.#activeStatuses.push(status);
+      this.#notifyLifecycle(status);
+    }));
+    try {
+      const session = await this.#verifySessionBinding();
+      this.#session = session;
+      this.#notifyLifecycle("connecting");
+      const storedState = await this.#stateStore.load();
+      if (storedState !== void 0 && session.latestSequence !== void 0 && storedState.serverCursor > session.latestSequence) {
+        throw new Error("GatherThread Session head precedes the persisted DSH cursor; refusing identity reuse");
+      }
+      const mode = await this.#host.open();
+      this.#state = this.#reconcileState(storedState, mode);
+      await this.#stateStore.save(this.#state);
+      this.#runtime = await this.#api.registerRuntime({
+        sessionId: this.#config.sessionId,
+        deviceId: this.#config.deviceId,
+        harness: "deepseek-harness",
+        provider: this.#config.provider,
+        model: this.#config.model,
+        localSessionId: this.#config.dshSessionId,
+        captureFidelity: "harness_transcript",
+        capabilities: [
+          "agent_request",
+          "agent_progress",
+          "durable_session_events",
+          "native_session_resume",
+          "outbox_replay",
+          "canonical_history_projection",
+          "bidirectional_local_turns"
+        ],
+        purpose: "execution"
+      });
+      this.#assertRuntime(this.#runtime);
+      this.#notifyLifecycle("idle");
+      if (options.schedule !== false)
+        this.#scheduleHeartbeat();
+      await this.#flushOutbox();
+      await this.#finalizeDeliveredRequest();
+      if (this.#state.activeRequest !== void 0) {
+        await this.#withExecutionPermit(() => this.#recoverActiveRequest());
+      }
+      if (options.runImmediately !== false)
+        await this.pollOnce();
+      if (this.#backgroundFatalError !== void 0)
+        throw this.#backgroundFatalError;
+      if (options.schedule !== false)
+        this.#schedulePoll();
+    } catch (error) {
+      this.#notifyLifecycle("error");
+      await this.stop();
+      throw this.#backgroundFatalError ?? error;
+    }
+  }
+  pollOnce() {
+    if (!this.#started || this.#stopped) {
+      return Promise.reject(new Error("DSH connector is not running"));
+    }
+    if (this.#pollPromise !== void 0)
+      return this.#pollPromise;
+    this.#pollPromise = this.#poll().then((result) => {
+      this.#notifyLifecycle(this.#visibleState === "running" ? "running" : "idle", true);
+      return result;
+    }).catch((error) => {
+      if (!this.#stopped)
+        this.#notifyLifecycle("offline");
+      throw error;
+    }).finally(() => {
+      this.#pollPromise = void 0;
+    });
+    return this.#pollPromise;
+  }
+  stop() {
+    this.#stopPromise ??= (async () => {
+      this.#stopped = true;
+      this.#notifyLifecycle("stopped");
+      this.#lifecycleAbort.abort(new Error("DSH connector stopped"));
+      if (this.#timer !== void 0) {
+        clearInterval(this.#timer);
+        this.#timer = void 0;
+      }
+      if (this.#heartbeatTimer !== void 0) {
+        clearInterval(this.#heartbeatTimer);
+        this.#heartbeatTimer = void 0;
+      }
+      for (const dispose of this.#listenerDisposers.splice(0))
+        dispose();
+      await this.#host.dispose();
+      try {
+        await this.#pollPromise;
+      } catch {
+      }
+      try {
+        await this.#heartbeatPromise;
+      } catch {
+      }
+    })();
+    return this.#stopPromise;
+  }
+  async #poll() {
+    const state = this.#requireState();
+    await this.#flushOutbox();
+    await this.#finalizeDeliveredRequest();
+    if (state.activeRequest !== void 0) {
+      await this.#withExecutionPermit(() => this.#recoverActiveRequest());
+      return { scanned: 0, claimed: 0, completed: 1 };
+    }
+    await this.#captureLocalTurns();
+    await this.#flushOutbox();
+    let scanCursor = state.projectionCursor;
+    let scanned = 0;
+    while (!this.#stopped) {
+      const page = await this.#api.readEvents(this.#config.sessionId, scanCursor, this.#config.pollLimit);
+      this.#validatePage(page.events, scanCursor);
+      const passive = [];
+      for (const event of page.events) {
+        scanCursor = Math.max(scanCursor, event.sequence);
+        scanned += 1;
+        const profile = requestedDshProfile(event);
+        if (profile === void 0 || event.actorId !== this.#requireRuntime().userId || profile.runtimeId !== void 0 && profile.runtimeId !== this.#requireRuntime().id) {
+          passive.push(event);
+          continue;
+        }
+        await this.#projectCanonicalBatch(passive, passive.at(-1)?.sequence ?? state.projectionCursor);
+        if (profile.provider !== void 0 && profile.provider !== this.#config.provider) {
+          throw new Error("DeepSeek Harness Agent request provider does not match the configured Host binding");
+        }
+        if (profile.model !== this.#config.model) {
+          throw new Error("DeepSeek Harness Agent request model does not match the configured Host binding");
+        }
+        const outcome = await this.#withExecutionPermit(() => this.#executeRequest(event));
+        return {
+          scanned,
+          claimed: outcome.claimed ? 1 : 0,
+          completed: outcome.completed ? 1 : 0
+        };
+      }
+      await this.#projectCanonicalBatch(passive, Math.max(scanCursor, page.hasMore ? scanCursor : page.nextSequence));
+      if (!page.hasMore) {
+        return { scanned, claimed: 0, completed: 0 };
+      }
+      if (page.nextSequence <= scanCursor && page.events.length === 0) {
+        throw new Error("GatherThread replay did not advance its cursor");
+      }
+      scanCursor = Math.max(scanCursor, page.nextSequence);
+    }
+    throw new Error("DSH connector stopped during event replay");
+  }
+  async #executeRequest(request) {
+    if (this.#stopped)
+      throw new Error("DSH connector stopped before claiming an Agent request");
+    const state = this.#requireState();
+    const runtime = this.#requireRuntime();
+    let claim;
+    try {
+      claim = await this.#api.claimAgentRequest(this.#config.sessionId, request.id, runtime.id);
+    } catch (error) {
+      if (!isTerminalClaimConflict(error))
+        throw error;
+      await this.#projectCanonicalBatch([request], request.sequence);
+      return { claimed: false, completed: false };
+    }
+    if (!claim.claimed || claim.status === "completed") {
+      await this.#projectCanonicalBatch([request], request.sequence);
+      return { claimed: false, completed: false };
+    }
+    const prompt = buildDshRequestPrompt(request);
+    const baseline = this.#host.currentSequence();
+    state.activeRequest = {
+      requestId: request.id,
+      requestSequence: request.sequence,
+      dshFromSequence: baseline,
+      promptDigest: digest(prompt)
+    };
+    this.#activeStatuses = [];
+    this.#liveEventSequences.clear();
+    await this.#stateStore.save(state);
+    const result = await this.#host.prompt(prompt);
+    if (result.fromSequence !== baseline || result.toSequence < result.fromSequence) {
+      throw new Error("DSH Host prompt returned an inconsistent durable event range");
+    }
+    this.#assertLiveEventsDurable(result);
+    await this.#settleActiveRequest(result.events, result.toSequence);
+    return { claimed: true, completed: true };
+  }
+  async #recoverActiveRequest() {
+    if (this.#stopped)
+      throw new Error("DSH connector stopped before recovering an Agent request");
+    const state = this.#requireState();
+    const active = state.activeRequest;
+    if (active === void 0)
+      return;
+    if (active.dshToSequence !== void 0) {
+      await this.#flushOutbox();
+      await this.#finalizeDeliveredRequest();
+      return;
+    }
+    const history = await this.#readThroughRequest(active.requestId, active.requestSequence);
+    const request = history.find((event) => event.id === active.requestId);
+    if (request === void 0 || request.type !== "agent_request") {
+      throw new Error("Active GatherThread request is unavailable during DSH resume");
+    }
+    const prompt = buildDshRequestPrompt(request);
+    const legacyPrompt = buildDshCanonicalPrompt(history, request, this.#requireRuntime().id);
+    if (digest(prompt) !== active.promptDigest && digest(legacyPrompt) !== active.promptDigest) {
+      throw new Error("Active GatherThread request changed during DSH resume");
+    }
+    const recovered = this.#host.snapshotFrom(active.dshFromSequence);
+    const settlement = turnSettlement(recovered);
+    if (settlement === "completed") {
+      await this.#settleActiveRequest(recovered, this.#host.currentSequence());
+      return;
+    }
+    if (settlement !== void 0 && settlement !== "interrupted") {
+      throw new Error(`DSH active request ended with unsupported settlement: ${settlement}`);
+    }
+    if (settlement === void 0 && recovered.length > 0) {
+      throw new Error("DSH active request has an unclosed durable turn after Host resume");
+    }
+    const continuation = settlement === "interrupted" ? "Continue the interrupted GatherThread request using the DSH Session context already restored by the Host. Return only the public final answer." : prompt;
+    const baseline = this.#host.currentSequence();
+    state.activeRequest = {
+      ...active,
+      dshFromSequence: baseline
+    };
+    this.#activeStatuses = [];
+    this.#liveEventSequences.clear();
+    await this.#stateStore.save(state);
+    const result = await this.#host.prompt(continuation);
+    if (result.fromSequence !== baseline || result.toSequence < result.fromSequence) {
+      throw new Error("DSH Host recovery prompt returned an inconsistent durable event range");
+    }
+    this.#assertLiveEventsDurable(result);
+    await this.#settleActiveRequest(result.events, result.toSequence);
+  }
+  async #settleActiveRequest(durableEvents, toSequence) {
+    const state = this.#requireState();
+    const active = state.activeRequest;
+    if (active === void 0)
+      throw new Error("No active GatherThread request to settle");
+    if (turnSettlement(durableEvents) !== "completed") {
+      throw new Error("DSH Agent did not durably complete the active turn");
+    }
+    const mapped = mapDshSessionEvents(durableEvents);
+    const final = finalVisibleAssistant(mapped);
+    if (final === void 0) {
+      throw new Error("DSH Agent completed without a public assistant answer");
+    }
+    if (state.outbox.length > 0)
+      throw new Error("DSH connector outbox was not empty before settlement");
+    state.activeRequest = { ...active, dshToSequence: toSequence };
+    state.outbox = this.#outboxFor(mapped, this.#activeStatuses, active.requestId);
+    await this.#stateStore.save(state);
+    await this.#flushOutbox();
+    await this.#finalizeDeliveredRequest();
+  }
+  async #projectCanonicalBatch(events, throughSequence) {
+    const state = this.#requireState();
+    if (throughSequence <= state.projectionCursor)
+      return;
+    const runtime = this.#requireRuntime();
+    const projections = [];
+    for (const event of events) {
+      if (event.sequence > throughSequence || event.runtime?.runtimeId === runtime.id)
+        continue;
+      const content = boundedPublicText(extractPublicText(event.payload));
+      if (!content)
+        continue;
+      if (event.type === "human_chat" || event.type === "agent_request") {
+        projections.push({
+          eventId: event.id,
+          canonicalSequence: event.sequence,
+          role: "user",
+          content,
+          occurredAt: event.timestamp,
+          ...event.actorDisplayName === void 0 ? {} : {
+            actorDisplayName: event.actorDisplayName
+          }
+        });
+      } else if (event.type === "agent_response") {
+        projections.push({
+          eventId: event.id,
+          canonicalSequence: event.sequence,
+          role: "assistant",
+          content,
+          occurredAt: event.timestamp,
+          ...event.actorDisplayName === void 0 ? {} : {
+            actorDisplayName: event.actorDisplayName
+          },
+          ...event.runtime?.provider === void 0 ? {} : { provider: event.runtime.provider },
+          ...event.runtime?.model === void 0 ? {} : { model: event.runtime.model }
+        });
+      }
+    }
+    if (projections.length > 0) {
+      await this.#host.projectCanonicalEvents(projections);
+    }
+    state.projectionCursor = Math.max(state.projectionCursor, throughSequence);
+    state.serverCursor = Math.max(state.serverCursor, throughSequence);
+    await this.#stateStore.save(state);
+  }
+  async #captureLocalTurns() {
+    const state = this.#requireState();
+    if (state.activeRequest !== void 0 || state.outbox.length > 0)
+      return;
+    const current = this.#host.currentSequence();
+    if (current <= state.publishedDshSequence)
+      return;
+    await this.#host.flush();
+    const snapshot = this.#host.snapshotFrom(state.publishedDshSequence);
+    const capture = captureCompletedLocalTurns(snapshot, state.publishedDshSequence, this.#config.dshSessionId);
+    const runtime = this.#requireRuntime();
+    state.outbox = capture.turns.map((turn) => ({
+      id: turn.localTurnId,
+      kind: "local_turn",
+      dshToSequence: turn.dshToSequence,
+      input: {
+        localTurnId: turn.localTurnId,
+        runtimeId: runtime.id,
+        basedOnSequence: state.serverCursor,
+        occurredAt: turn.occurredAt,
+        observedModel: this.#config.model,
+        requestPayload: {
+          content: turn.request,
+          capture_fidelity: "harness_transcript",
+          source_harness: "deepseek-harness"
+        },
+        responsePayload: {
+          text: turn.response,
+          capture_fidelity: "harness_transcript",
+          source_harness: "deepseek-harness"
+        }
+      }
+    }));
+    if (state.outbox.length === 0) {
+      state.publishedDshSequence = Math.max(state.publishedDshSequence, capture.safeThroughSequence);
+    }
+    await this.#stateStore.save(state);
+  }
+  #outboxFor(events, statuses, requestId) {
+    const runtime = this.#requireRuntime();
+    const prefix = `${this.#config.deviceId}:${digest(requestId).slice(0, 24)}`;
+    const operations = [];
+    for (const [index, status] of statuses.entries()) {
+      const idempotencyKey = `${prefix}:dsh-status-${status}-${index}`;
+      operations.push({
+        id: idempotencyKey,
+        kind: "progress",
+        requestId,
+        input: {
+          runtimeId: runtime.id,
+          idempotencyKey,
+          payload: {
+            content: status === "running" ? "DeepSeek Harness started processing the request." : "DeepSeek Harness returned to idle.",
+            phase: "lifecycle",
+            status,
+            capture_fidelity: "harness_transcript",
+            source_harness: "deepseek-harness"
+          },
+          observedModel: this.#config.model
+        }
+      });
+    }
+    if (this.#config.shareToolEvents) {
+      for (const event of events.filter((item) => item.kind !== "assistant").slice(0, 32)) {
+        const idempotencyKey = `${prefix}:${event.localEventId}`;
+        const payload = event.kind === "tool_call" ? {
+          tool_name: event.toolName,
+          tool_call_id: event.toolCallId,
+          arguments: event.arguments,
+          capture_fidelity: "harness_transcript",
+          source_harness: "deepseek-harness",
+          source_timestamp: event.timestamp,
+          dsh_event_sequence: event.sequence
+        } : {
+          tool_call_id: event.toolCallId,
+          result: event.result,
+          is_error: event.isError,
+          ...event.errorCode === void 0 ? {} : { error_code: event.errorCode },
+          capture_fidelity: "harness_transcript",
+          source_harness: "deepseek-harness",
+          source_timestamp: event.timestamp,
+          dsh_event_sequence: event.sequence
+        };
+        operations.push({
+          id: idempotencyKey,
+          kind: "append",
+          input: {
+            type: event.kind,
+            idempotencyKey,
+            payload: redactValue(payload),
+            replyTo: requestId,
+            runtimeId: runtime.id,
+            observedModel: this.#config.model
+          }
+        });
+      }
+    }
+    const final = finalVisibleAssistant(events);
+    if (final === void 0)
+      throw new Error("No public DSH final answer is available");
+    const completionKey = `${prefix}:dsh-complete`;
+    operations.push({
+      id: completionKey,
+      kind: "complete",
+      requestId,
+      input: {
+        runtimeId: runtime.id,
+        idempotencyKey: completionKey,
+        payload: {
+          text: final.content,
+          capture_fidelity: "harness_transcript",
+          source_harness: "deepseek-harness",
+          source_timestamp: final.timestamp,
+          dsh_event_sequence: final.sequence
+        },
+        observedModel: this.#config.model
+      }
+    });
+    return operations;
+  }
+  async #flushOutbox() {
+    const state = this.#requireState();
+    const runtime = this.#requireRuntime();
+    while (state.outbox.length > 0) {
+      const operation = state.outbox[0];
+      if (operation === void 0)
+        break;
+      if (operation.input.runtimeId !== runtime.id) {
+        throw new Error("DSH connector outbox belongs to a different runtime");
+      }
+      if (operation.kind === "progress") {
+        await this.#api.appendAgentProgress(this.#config.sessionId, operation.requestId, operation.input);
+      } else if (operation.kind === "append") {
+        await this.#api.appendEvent(this.#config.sessionId, operation.input);
+      } else if (operation.kind === "complete") {
+        await this.#api.completeAgentRequest(this.#config.sessionId, operation.requestId, operation.input);
+      } else {
+        const result = await this.#api.commitLocalTurn(this.#config.sessionId, operation.input);
+        if (result.localTurnId !== operation.input.localTurnId || result.runtimeId !== runtime.id) {
+          throw new Error("GatherThread returned an incompatible local-turn acknowledgement");
+        }
+        state.publishedDshSequence = Math.max(state.publishedDshSequence, operation.dshToSequence);
+      }
+      state.outbox.shift();
+      await this.#stateStore.save(state);
+    }
+  }
+  async #finalizeDeliveredRequest() {
+    const state = this.#requireState();
+    const active = state.activeRequest;
+    if (active?.dshToSequence === void 0 || state.outbox.length > 0)
+      return;
+    state.serverCursor = Math.max(state.serverCursor, active.requestSequence);
+    state.projectionCursor = Math.max(state.projectionCursor, active.requestSequence);
+    state.publishedDshSequence = Math.max(state.publishedDshSequence, active.dshToSequence);
+    delete state.activeRequest;
+    this.#activeStatuses = [];
+    this.#liveEventSequences.clear();
+    await this.#stateStore.save(state);
+  }
+  async #readThroughRequest(requestId, requestSequence) {
+    const state = this.#requireState();
+    let cursor = state.projectionCursor;
+    const events = [];
+    while (true) {
+      const page = await this.#api.readEvents(this.#config.sessionId, cursor, this.#config.pollLimit);
+      this.#validatePage(page.events, cursor);
+      for (const event of page.events) {
+        events.push(event);
+        cursor = Math.max(cursor, event.sequence);
+        if (event.id === requestId) {
+          if (event.sequence !== requestSequence) {
+            throw new Error("Active GatherThread request sequence changed during DSH resume");
+          }
+          return events;
+        }
+      }
+      if (!page.hasMore)
+        break;
+      if (page.nextSequence <= cursor && page.events.length === 0) {
+        throw new Error("GatherThread replay did not advance while recovering an active request");
+      }
+      cursor = Math.max(cursor, page.nextSequence);
+    }
+    throw new Error("Active GatherThread request is absent from canonical replay");
+  }
+  async #verifySessionBinding() {
+    const sessions = await this.#api.listProjectSessions(this.#config.projectId);
+    const session = sessions.find((candidate) => candidate.id === this.#config.sessionId);
+    if (session === void 0 || session.projectId !== this.#config.projectId) {
+      throw new Error("Configured GatherThread Session is not in the configured Project");
+    }
+    if (session.state !== "active")
+      throw new Error("Configured GatherThread Session is archived");
+    if (!isSessionWritableBy(session, this.#actorUserId)) {
+      throw new Error("Configured GatherThread Session is not writable by the current actor");
+    }
+    return session;
+  }
+  #withExecutionPermit(operation) {
+    return this.#executionGate?.run(operation, this.#lifecycleAbort.signal) ?? operation();
+  }
+  #reconcileState(stored, mode) {
+    if (stored === void 0) {
+      if (mode === "resumed" && !this.#adoptExistingLocalSession) {
+        throw new Error("Persisted DSH Session exists without connector state; refusing ambiguous resume");
+      }
+      return {
+        version: 2,
+        binding: {
+          projectId: this.#config.projectId,
+          sessionId: this.#config.sessionId,
+          dshSessionId: this.#config.dshSessionId
+        },
+        serverCursor: 0,
+        projectionCursor: 0,
+        publishedDshSequence: 0,
+        outbox: []
+      };
+    }
+    if (mode === "created") {
+      throw new Error("Connector state exists without its persisted DSH Session; refusing identity reuse");
+    }
+    const expected = JSON.stringify([
+      this.#config.projectId,
+      this.#config.sessionId,
+      this.#config.dshSessionId
+    ]);
+    const actual = JSON.stringify([
+      stored.binding.projectId,
+      stored.binding.sessionId,
+      stored.binding.dshSessionId
+    ]);
+    if (actual !== expected)
+      throw new Error("DSH connector state belongs to a different binding");
+    if (stored.publishedDshSequence > this.#host.currentSequence()) {
+      throw new Error("Persisted DSH publication cursor exceeds the native Session head");
+    }
+    return stored;
+  }
+  #assertRuntime(runtime) {
+    if (runtime.sessionId !== this.#config.sessionId || runtime.deviceId !== this.#config.deviceId || runtime.harness !== "deepseek-harness" || runtime.provider !== this.#config.provider || runtime.model !== this.#config.model || runtime.localSessionId !== this.#config.dshSessionId || runtime.captureFidelity !== "harness_transcript" || runtime.purpose !== "execution") {
+      throw new Error("GatherThread returned an incompatible DSH runtime registration");
+    }
+  }
+  #validatePage(events, afterSequence) {
+    let previous = afterSequence;
+    for (const event of events) {
+      if (event.sessionId !== this.#config.sessionId || !Number.isSafeInteger(event.sequence) || event.sequence <= previous) {
+        throw new Error("GatherThread returned an invalid or unordered canonical replay page");
+      }
+      previous = event.sequence;
+    }
+  }
+  #assertLiveEventsDurable(result) {
+    const durable = new Set(result.events.map((event) => event.seq));
+    for (const sequence of this.#liveEventSequences) {
+      if (sequence >= result.fromSequence && sequence < result.toSequence && !durable.has(sequence)) {
+        throw new Error("A live DSH SessionEvent was absent from the flushed durable snapshot");
+      }
+    }
+  }
+  #schedulePoll() {
+    if (this.#stopped)
+      return;
+    this.#timer = setInterval(() => {
+      void this.pollOnce().catch((error) => {
+        this.#onBackgroundError?.(publicError(error));
+      });
+    }, this.#config.pollIntervalMs);
+    this.#timer.unref?.();
+  }
+  #scheduleHeartbeat() {
+    if (this.#stopped)
+      return;
+    this.#heartbeatTimer = setInterval(() => {
+      void this.#heartbeat().catch((error) => {
+        const publicFailure = publicError(error);
+        this.#notifyLifecycle(error instanceof RuntimeIdentityError ? "error" : "offline");
+        this.#onBackgroundError?.(publicFailure);
+        if (error instanceof RuntimeIdentityError) {
+          this.#backgroundFatalError = publicFailure;
+          void this.stop();
+        }
+      });
+    }, this.#heartbeatIntervalMs);
+    this.#heartbeatTimer.unref?.();
+  }
+  #heartbeat() {
+    if (this.#stopped)
+      return Promise.reject(new Error("DSH connector is not running"));
+    if (this.#heartbeatPromise !== void 0)
+      return this.#heartbeatPromise;
+    const current = this.#requireRuntime();
+    this.#heartbeatPromise = (async () => {
+      const refreshed = await this.#api.heartbeatRuntime(current.id);
+      if (refreshed.id !== current.id) {
+        throw new RuntimeIdentityError("GatherThread changed the DSH runtime identity during heartbeat");
+      }
+      try {
+        this.#assertRuntime(refreshed);
+      } catch {
+        throw new RuntimeIdentityError("GatherThread returned incompatible DSH runtime heartbeat data");
+      }
+    })().finally(() => {
+      this.#heartbeatPromise = void 0;
+    });
+    return this.#heartbeatPromise;
+  }
+  #requireState() {
+    if (this.#state === void 0)
+      throw new Error("DSH connector state is unavailable");
+    return this.#state;
+  }
+  #requireRuntime() {
+    if (this.#runtime === void 0)
+      throw new Error("DSH connector runtime is unavailable");
+    return this.#runtime;
+  }
+  #notifyLifecycle(state, synced = false) {
+    this.#visibleState = state;
+    try {
+      this.#onLifecycle?.({
+        state,
+        ...this.#session === void 0 ? {} : { session: this.#session },
+        ...synced ? { synced: true } : {}
+      });
+    } catch {
+    }
+  }
+};
+var RuntimeIdentityError = class extends Error {
+};
+function turnSettlement(events) {
+  const event = events.findLast((candidate) => candidate.type === "turn/end");
+  if (event === void 0)
+    return void 0;
+  const data = asObject3(event.data);
+  const reason = asObject3(data?.reason);
+  return typeof reason?.kind === "string" ? reason.kind : void 0;
+}
+function digest(value) {
+  return createHash3("sha256").update(value).digest("hex");
+}
+function publicError(error) {
+  if (error instanceof Error)
+    return error;
+  return new Error("DeepSeek Harness connector background operation failed");
+}
+function captureCompletedLocalTurns(events, fromSequence, dshSessionId) {
+  const turns = [];
+  let safeThroughSequence = fromSequence;
+  let openTurn;
+  let pendingUser;
+  for (const event of events) {
+    if (openTurn === void 0) {
+      if (event.type === "user/message" && isDirectLocalUserMessage(event)) {
+        pendingUser = event;
+        continue;
+      }
+      if (event.type === "turn/start") {
+        openTurn = pendingUser === void 0 ? [event] : [pendingUser, event];
+        continue;
+      }
+      safeThroughSequence = Math.max(safeThroughSequence, event.seq + 1);
+      continue;
+    }
+    openTurn.push(event);
+    if (event.type !== "turn/end")
+      continue;
+    if (turnSettlement(openTurn) === "completed") {
+      const userEvents = openTurn.filter(isDirectLocalUserMessage);
+      const request = boundedPublicText(userEvents.map(publicMessageText).filter(Boolean).join("\n\n"));
+      const responseEvent = openTurn.findLast(isNativeAssistantMessage);
+      const response = responseEvent === void 0 ? "" : boundedPublicText(publicAssistantText(responseEvent));
+      if (request && response && userEvents[0] !== void 0) {
+        const identity = `${dshSessionId}:${userEvents[0].seq}:${event.seq}`;
+        turns.push({
+          localTurnId: `dsh:${digest(identity)}`,
+          dshToSequence: event.seq + 1,
+          occurredAt: sessionTimestamp(event.time),
+          request,
+          response
+        });
+      }
+    }
+    safeThroughSequence = Math.max(safeThroughSequence, event.seq + 1);
+    openTurn = void 0;
+    pendingUser = void 0;
+  }
+  return { turns, safeThroughSequence };
+}
+function isDirectLocalUserMessage(event) {
+  if (event.type !== "user/message")
+    return false;
+  const message = messageObject(event.data);
+  const source = asObject3(message?.source);
+  return source?.kind === "user" && typeof message?.id === "string" && !message.id.startsWith("gatherthread:");
+}
+function isNativeAssistantMessage(event) {
+  if (event.type !== "assistant/message")
+    return false;
+  const data = asObject3(event.data);
+  const message = asObject3(data?.message);
+  return typeof message?.id !== "string" || !message.id.startsWith("gatherthread:");
+}
+function publicMessageText(value) {
+  return publicContentText(messageObject(value.data)?.content);
+}
+function publicAssistantText(value) {
+  const data = asObject3(value.data);
+  return publicContentText(asObject3(data?.message)?.content);
+}
+function messageObject(value) {
+  const data = asObject3(value);
+  return asObject3(data?.message) ?? data;
+}
+function publicContentText(value) {
+  if (!Array.isArray(value))
+    return "";
+  return value.flatMap((block) => {
+    const item = asObject3(block);
+    return item?.type === "text" && typeof item.text === "string" ? [item.text] : [];
+  }).join("");
+}
+function boundedPublicText(value) {
+  const redacted = redactText(value).trim();
+  const maximumBytes = 64 * 1024;
+  if (Buffer.byteLength(redacted, "utf8") <= maximumBytes)
+    return redacted;
+  const suffix = "\n[TRUNCATED]";
+  const target = maximumBytes - Buffer.byteLength(suffix, "utf8");
+  let low = 0;
+  let high = redacted.length;
+  while (low < high) {
+    const middle = Math.ceil((low + high) / 2);
+    if (Buffer.byteLength(redacted.slice(0, middle), "utf8") <= target)
+      low = middle;
+    else
+      high = middle - 1;
+  }
+  return `${redacted.slice(0, low)}${suffix}`;
+}
+function sessionTimestamp(value) {
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime()))
+    throw new Error("DSH local turn has an invalid timestamp");
+  return date.toISOString();
+}
+function asObject3(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// dist/src/dsh-compat.js
+var DSH_COMPATIBILITY = Object.freeze({
+  tag: "dsh-v0.1.3-alpha.1",
+  version: "0.1.3-alpha.1",
+  commit: "d347e703908d0406b7a7ef80e3a0e594d86b2215",
+  profile: "headless"
+});
+var DSH_NPM_COMPATIBILITY = Object.freeze({
+  package: "@deepseek-ai/dsh",
+  version: "0.1.2-rc.1",
+  profile: "web",
+  persistenceProbe: "list"
+});
+var DSH_COMPATIBILITY_MATRIX = Object.freeze([
+  Object.freeze({
+    distribution: "npm",
+    version: DSH_NPM_COMPATIBILITY.version,
+    profile: DSH_NPM_COMPATIBILITY.profile,
+    persistenceProbe: DSH_NPM_COMPATIBILITY.persistenceProbe
+  }),
+  Object.freeze({
+    distribution: "source",
+    version: DSH_COMPATIBILITY.version,
+    profile: DSH_COMPATIBILITY.profile,
+    persistenceProbe: "stat"
+  })
+]);
+var USER_MESSAGE_MODULE = "@deepseek-ai/dsh-llm";
+function createDshHostFacade(options) {
+  const context = requireContext(options.context);
+  const agents = requireService(context, "agents", ["create", "resume"]);
+  const persistence = requirePersistenceService(context);
+  const sessions = requireService(context, "sessions", ["flush"]);
+  if (options.sessionTitle === void 0 !== (options.workspaceTitle === void 0)) {
+    throw new Error("DSH native workspace integration requires both Session and workspace titles");
+  }
+  const sessionTitle = options.sessionTitle === void 0 ? void 0 : requireService(context, "sessionTitle", ["rename"]);
+  const workspaceRegistry = options.workspaceTitle === void 0 ? void 0 : requireService(context, "workspaceRegistry", ["create"]);
+  const eventSubscribers = /* @__PURE__ */ new Set();
+  const statusSubscribers = /* @__PURE__ */ new Set();
+  const listenerDisposers = [];
+  const lifecycleAbort = new AbortController();
+  let handle;
+  let openPromise;
+  let promptActive = false;
+  let projectionActive = false;
+  let knownProjectionMessageIds;
+  let disposePromise;
+  let disposed = false;
+  listenerDisposers.push(context.on("session/event", (...args) => {
+    const session = asSession(args[0]);
+    const event = asSessionEvent(args[1]);
+    if (session?.id !== options.sessionId || event === void 0)
+      return;
+    for (const subscriber of eventSubscribers)
+      subscriber(event);
+  }, { global: true }));
+  listenerDisposers.push(context.on("agent/status", (...args) => {
+    const payload = asObject4(args[0]);
+    const agent = payload ? asAgent(payload.agent) : void 0;
+    const status = payload?.status;
+    if (agent?.session.id !== options.sessionId || status !== "running" && status !== "idle")
+      return;
+    for (const subscriber of statusSubscribers)
+      subscriber(status);
+  }, { global: true }));
+  const open2 = () => {
+    if (disposed)
+      return Promise.reject(new Error("DSH host facade is disposed"));
+    if (openPromise !== void 0)
+      return openPromise;
+    openPromise = (async () => {
+      const liveCandidate = agents.get?.(options.sessionId);
+      const liveAgent = liveCandidate === void 0 ? void 0 : asAgent(liveCandidate);
+      if (liveCandidate !== void 0 && liveAgent === void 0) {
+        throw new Error("Pinned DSH Agent registry returned an incompatible live Agent");
+      }
+      const stored = liveAgent === void 0 ? await hasPersistedSession(persistence, options.sessionId, lifecycleAbort.signal) : true;
+      throwIfDisposed(disposed, lifecycleAbort.signal, "open");
+      const mode = stored ? "resumed" : "created";
+      let openedHandle;
+      try {
+        openedHandle = liveAgent !== void 0 ? { agent: liveAgent, dispose: async () => void 0 } : stored ? await agents.resume({
+          resumeSessionId: options.sessionId,
+          agentOptions: { provider: options.provider, model: options.model },
+          signal: lifecycleAbort.signal
+        }) : await agents.create({
+          sessionId: options.sessionId,
+          meta: {
+            cwd: options.workspacePath,
+            ...options.agentPreset === void 0 ? {} : { agentPreset: options.agentPreset }
+          },
+          agentOptions: { provider: options.provider, model: options.model },
+          signal: lifecycleAbort.signal
+        });
+      } catch (error) {
+        throwIfDisposed(disposed, lifecycleAbort.signal, "open");
+        throw error;
+      }
+      if (disposed || lifecycleAbort.signal.aborted) {
+        await openedHandle.dispose();
+        throw new Error("DSH host facade was disposed during open");
+      }
+      if (openedHandle.agent.session.id !== options.sessionId) {
+        await openedHandle.dispose();
+        throw new Error("DSH Host returned an agent for an unexpected Session identity");
+      }
+      if (sessionTitle !== void 0 && workspaceRegistry !== void 0 && options.sessionTitle !== void 0 && options.workspaceTitle !== void 0) {
+        try {
+          await sessionTitle.rename(openedHandle.agent.session, options.sessionTitle);
+          ensureNativeSessionListVisibility(openedHandle.agent.session);
+          await sessions.flush(openedHandle.agent.session);
+          const workspace = await workspaceRegistry.create(options.workspacePath, options.workspaceTitle);
+          if (workspace === null || typeof workspace !== "object" || typeof workspace.attachSession !== "function") {
+            throw new Error("Pinned DSH workspace registry returned an incompatible Workspace");
+          }
+          await workspace.attachSession(options.sessionId);
+          if (options.supersededSessionId !== void 0 && options.supersededSessionId !== options.sessionId && workspace.sessionIds.includes(options.supersededSessionId)) {
+            if (typeof workspace.detachSession !== "function") {
+              throw new Error("Pinned DSH Workspace detachSession API is unavailable or incompatible");
+            }
+            await workspace.detachSession(options.supersededSessionId);
+          }
+        } catch (error) {
+          await openedHandle.dispose();
+          throwIfDisposed(disposed, lifecycleAbort.signal, "open");
+          throw error;
+        }
+      }
+      handle = openedHandle;
+      return mode;
+    })();
+    return openPromise;
+  };
+  const snapshotFrom = (sequence) => {
+    if (!Number.isSafeInteger(sequence) || sequence < 0) {
+      throw new Error("DSH snapshot sequence must be a non-negative integer");
+    }
+    const agent = requireAgent(handle);
+    return agent.session.snapshotEvents(sequence).map((event) => {
+      const parsed = asSessionEvent(event);
+      if (parsed === void 0)
+        throw new Error("DSH Host returned an invalid durable SessionEvent");
+      return parsed;
+    });
+  };
+  const prompt = async (text) => {
+    if (disposed)
+      throw new Error("DSH host facade is disposed");
+    if (!text.trim())
+      throw new Error("DSH prompt must not be empty");
+    if (Buffer.byteLength(text, "utf8") > 256 * 1024) {
+      throw new Error("DSH prompt exceeds the 256 KiB connector limit");
+    }
+    if (promptActive)
+      throw new Error("DSH host facade permits only one active prompt");
+    if (projectionActive)
+      throw new Error("DSH host facade permits only one active write");
+    promptActive = true;
+    try {
+      await open2();
+      throwIfDisposed(disposed, lifecycleAbort.signal, "prompt");
+      const agent = requireAgent(handle);
+      if (agent.status !== "idle")
+        throw new Error("DSH Agent must be idle before a GatherThread prompt");
+      const fromSequence = agent.session.seq;
+      const message = await createUserMessage(text, options);
+      throwIfDisposed(disposed, lifecycleAbort.signal, "prompt");
+      agent.followup(message);
+      await agent.whenIdle();
+      throwIfDisposed(disposed, lifecycleAbort.signal, "prompt");
+      await sessions.flush(agent.session);
+      throwIfDisposed(disposed, lifecycleAbort.signal, "prompt");
+      const toSequence = agent.session.seq;
+      return {
+        fromSequence,
+        toSequence,
+        events: snapshotFrom(fromSequence)
+      };
+    } finally {
+      promptActive = false;
+    }
+  };
+  const flush = async () => {
+    if (disposed)
+      throw new Error("DSH host facade is disposed");
+    await open2();
+    throwIfDisposed(disposed, lifecycleAbort.signal, "projection");
+    await sessions.flush(requireAgent(handle).session);
+    throwIfDisposed(disposed, lifecycleAbort.signal, "projection");
+  };
+  const projectCanonicalEvents = async (projections) => {
+    if (disposed)
+      throw new Error("DSH host facade is disposed");
+    if (promptActive || projectionActive)
+      throw new Error("DSH host facade permits only one active write");
+    if (projections.length === 0)
+      return;
+    projectionActive = true;
+    try {
+      await open2();
+      throwIfDisposed(disposed, lifecycleAbort.signal, "projection");
+      const agent = requireAgent(handle);
+      if (agent.status !== "idle") {
+        throw new Error("DSH Agent must be idle before canonical history projection");
+      }
+      const knownIds = knownProjectionMessageIds ??= nativeMessageIds(agent.session.snapshotEvents(0));
+      for (const projection of projections) {
+        const messageId = canonicalMessageId(projection.eventId);
+        if (knownIds.has(messageId))
+          continue;
+        const message = await createProjectionMessage(projection, options);
+        if (projection.role === "user") {
+          agent.session.append("user/message", message, { surfaceOp: "append" });
+        } else {
+          const turn = nextDshTurn(agent.session.snapshotEvents(0));
+          agent.session.append("turn/start", { turn });
+          agent.session.append("step/start", { turn, step: 1 });
+          agent.session.append("assistant/message", {
+            turn,
+            step: 1,
+            message,
+            stream: []
+          }, { surfaceOp: "append" });
+          agent.session.append("step/end", { turn, step: 1 });
+          agent.session.append("turn/end", { turn, reason: { kind: "completed" } });
+        }
+        knownIds.add(messageId);
+      }
+      await sessions.flush(agent.session);
+      throwIfDisposed(disposed, lifecycleAbort.signal, "projection");
+    } finally {
+      projectionActive = false;
+    }
+  };
+  const dispose = () => {
+    disposePromise ??= (async () => {
+      disposed = true;
+      lifecycleAbort.abort(new Error("DSH host facade disposed"));
+      eventSubscribers.clear();
+      statusSubscribers.clear();
+      for (const stop of listenerDisposers.splice(0))
+        stop();
+      try {
+        await handle?.dispose();
+      } finally {
+        handle = void 0;
+      }
+    })();
+    return disposePromise;
+  };
+  return {
+    sessionId: options.sessionId,
+    open: open2,
+    currentSequence() {
+      return requireAgent(handle).session.seq;
+    },
+    snapshotFrom,
+    projectCanonicalEvents,
+    flush,
+    prompt,
+    onSessionEvent(listener) {
+      if (disposed)
+        throw new Error("DSH host facade is disposed");
+      eventSubscribers.add(listener);
+      return () => eventSubscribers.delete(listener);
+    },
+    onStatus(listener) {
+      if (disposed)
+        throw new Error("DSH host facade is disposed");
+      statusSubscribers.add(listener);
+      return () => statusSubscribers.delete(listener);
+    },
+    dispose
+  };
+}
+function ensureNativeSessionListVisibility(session) {
+  const events = session.snapshotEvents(0);
+  if (events.some((event) => asSessionEvent(event)?.type === "turn/start"))
+    return;
+  session.append("turn/start", { turn: 1 });
+  session.append("turn/end", { turn: 1, reason: { kind: "completed" } });
+}
+function throwIfDisposed(disposed, signal, operation) {
+  if (disposed || signal.aborted) {
+    throw new Error(`DSH host facade was disposed during ${operation}`);
+  }
+}
+async function createProjectionMessage(projection, options) {
+  const importer = options.moduleImporter ?? ((specifier) => import(specifier));
+  const imported = asObject4(await importer(USER_MESSAGE_MODULE));
+  if (imported === void 0 || typeof imported.freezeMessage !== "function") {
+    throw new Error("Pinned DSH freezeMessage API is unavailable");
+  }
+  const factory = imported.freezeMessage;
+  return factory({
+    id: canonicalMessageId(projection.eventId),
+    role: projection.role,
+    content: [{ type: "text", text: formatProjectionText(projection) }],
+    source: projection.role === "user" ? { kind: "user" } : {
+      kind: "model",
+      provider: projection.provider ?? "gatherthread",
+      model: projection.model ?? "canonical-relay"
+    }
+  });
+}
+function formatProjectionText(projection) {
+  if (projection.role === "user")
+    return projection.content;
+  const route = [projection.provider, projection.model].filter(Boolean).join(" / ");
+  const attribution = [projection.actorDisplayName, route].filter(Boolean).join(" \xB7 ");
+  return `[GatherThread Agent reply${attribution ? ` \xB7 ${attribution}` : ""}]
+
+${projection.content}`;
+}
+function canonicalMessageId(eventId) {
+  return `gatherthread:${eventId}`;
+}
+function nextDshTurn(events) {
+  let next = 1;
+  for (const eventValue of events) {
+    const event = asSessionEvent(eventValue);
+    if (event?.type !== "turn/start")
+      continue;
+    const data = asObject4(event.data);
+    const turn = data?.turn;
+    if (typeof turn === "number" && Number.isSafeInteger(turn) && turn >= next) {
+      next = turn + 1;
+    }
+  }
+  return next;
+}
+function nativeMessageIds(events) {
+  const ids = /* @__PURE__ */ new Set();
+  for (const eventValue of events) {
+    const event = asObject4(eventValue);
+    const data = asObject4(event?.data);
+    const message = event?.type === "assistant/message" ? asObject4(data?.message) : data;
+    if (typeof message?.id === "string")
+      ids.add(message.id);
+  }
+  return ids;
+}
+function registerDshPluginDisposer(contextValue, dispose) {
+  const context = requireContext(contextValue);
+  context.effect(() => dispose, "gatherthread-dsh-host.connector");
+}
+async function createUserMessage(text, options) {
+  if (options.messageFactory !== void 0)
+    return options.messageFactory(text);
+  const importer = options.moduleImporter ?? ((specifier) => import(specifier));
+  const imported = asObject4(await importer(USER_MESSAGE_MODULE));
+  if (imported === void 0 || typeof imported.createUserMessage !== "function") {
+    throw new Error("Pinned DSH createUserMessage API is unavailable");
+  }
+  const factory = imported.createUserMessage;
+  return factory({
+    content: [{ type: "text", text }],
+    source: { kind: "user" }
+  });
+}
+function requireContext(value) {
+  const context = asObject4(value);
+  if (context === void 0 || typeof context.get !== "function" || typeof context.on !== "function" || typeof context.effect !== "function") {
+    throw new Error("Unsupported DeepSeek Harness Host context");
+  }
+  return context;
+}
+function requireService(context, name2, methods) {
+  const service = asObject4(context.get(name2));
+  if (service === void 0 || methods.some((method) => typeof service[method] !== "function")) {
+    throw new Error(`Pinned DSH Host service ${name2} is unavailable or incompatible`);
+  }
+  return service;
+}
+function requirePersistenceService(context) {
+  const service = asObject4(context.get("sessionPersistence"));
+  if (service === void 0 || typeof service.stat !== "function" && typeof service.list !== "function") {
+    throw new Error("Pinned DSH Host service sessionPersistence is unavailable or incompatible");
+  }
+  return service;
+}
+async function hasPersistedSession(persistence, sessionId, signal) {
+  if (persistence.stat !== void 0) {
+    return await persistence.stat(sessionId, { signal }) !== void 0;
+  }
+  if (persistence.list === void 0) {
+    throw new Error("Pinned DSH persistence probe is unavailable");
+  }
+  const listed = await persistence.list();
+  if (!Array.isArray(listed)) {
+    throw new Error("Pinned DSH persistence list returned an invalid Session collection");
+  }
+  for (const value of listed) {
+    const header = persistenceHeader(value);
+    if (header === void 0 || typeof header.id !== "string") {
+      throw new Error("Pinned DSH persistence list returned an invalid Session snapshot");
+    }
+    if (header.id === sessionId)
+      return true;
+  }
+  return false;
+}
+function persistenceHeader(value) {
+  const item = asObject4(value);
+  return asObject4(item?.header) ?? item;
+}
+function requireAgent(handle) {
+  if (handle === void 0)
+    throw new Error("DSH Agent is not open");
+  return handle.agent;
+}
+function asAgent(value) {
+  const candidate = asObject4(value);
+  const session = candidate ? asSession(candidate.session) : void 0;
+  if (candidate === void 0 || session === void 0 || typeof candidate.id !== "string")
+    return void 0;
+  return candidate;
+}
+function asSession(value) {
+  const candidate = asObject4(value);
+  if (candidate === void 0 || typeof candidate.id !== "string" || !Number.isSafeInteger(candidate.seq) || typeof candidate.snapshotEvents !== "function" || typeof candidate.append !== "function")
+    return void 0;
+  return candidate;
+}
+function asSessionEvent(value) {
+  const candidate = asObject4(value);
+  if (candidate === void 0 || typeof candidate.type !== "string" || !Number.isSafeInteger(candidate.seq) || Number(candidate.seq) < 0 || !Number.isSafeInteger(candidate.time) || !("data" in candidate))
+    return void 0;
+  return {
+    type: candidate.type,
+    seq: Number(candidate.seq),
+    time: Number(candidate.time),
+    data: candidate.data
+  };
+}
+function asObject4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+
+// dist/src/state-store.js
+import { randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat as lstat3, mkdir, open, rename, unlink } from "node:fs/promises";
+import path3 from "node:path";
+var FileConnectorStateStore = class {
+  #path;
+  constructor(statePath) {
+    if (!path3.isAbsolute(statePath))
+      throw new Error("DSH connector state path must be absolute");
+    this.#path = path3.resolve(statePath);
+  }
+  async load() {
+    const directory = path3.dirname(this.#path);
+    const ancestorsBefore = await secureDirectoryChain(directory);
+    let metadata;
+    try {
+      metadata = await lstat3(this.#path);
+    } catch (error) {
+      if (isNodeError3(error) && error.code === "ENOENT")
+        return void 0;
+      throw error;
+    }
+    assertPrivateRegularFile(metadata, "DSH connector state");
+    const noFollow = "O_NOFOLLOW" in constants ? constants.O_NOFOLLOW : 0;
+    const handle = await open(this.#path, constants.O_RDONLY | noFollow);
+    let raw;
+    try {
+      const opened = await handle.stat();
+      if (opened.dev !== metadata.dev || opened.ino !== metadata.ino) {
+        throw new Error("DSH connector state path changed while opening");
+      }
+      raw = await handle.readFile({ encoding: "utf8" });
+      assertSameDirectoryChain(ancestorsBefore, await secureDirectoryChain(directory));
+    } finally {
+      await handle.close();
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw new Error("DSH connector state is not valid JSON");
+    }
+    return validateConnectorState(parsed);
+  }
+  async save(state) {
+    const validated = validateConnectorState(structuredClone(state));
+    const directory = path3.dirname(this.#path);
+    await secureDirectoryChain(directory);
+    await mkdir(directory, { recursive: true, mode: 448 });
+    const ancestorsBefore = await secureDirectoryChain(directory);
+    const directoryBefore = await lstat3(directory);
+    assertSecureDirectory(directoryBefore);
+    const targetBefore = await optionalLstat(this.#path);
+    if (targetBefore !== void 0)
+      assertPrivateRegularFile(targetBefore, "DSH connector state");
+    const temporaryPath = `${this.#path}.tmp-${process.pid}-${randomUUID()}`;
+    const handle = await open(temporaryPath, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify(validated, null, 2)}
+`, { encoding: "utf8" });
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    try {
+      const directoryAfter = await lstat3(directory);
+      if (directoryAfter.isSymbolicLink() || directoryAfter.dev !== directoryBefore.dev || directoryAfter.ino !== directoryBefore.ino) {
+        throw new Error("DSH connector state directory changed during atomic save");
+      }
+      assertSameDirectoryChain(ancestorsBefore, await secureDirectoryChain(directory));
+      const targetAfter = await optionalLstat(this.#path);
+      if (!sameArtifact(targetBefore, targetAfter)) {
+        throw new Error("DSH connector state path changed during atomic save");
+      }
+      await rename(temporaryPath, this.#path);
+      assertSameDirectoryChain(ancestorsBefore, await secureDirectoryChain(directory));
+      assertPrivateRegularFile(await lstat3(this.#path), "DSH connector state");
+    } catch (error) {
+      await unlink(temporaryPath).catch(() => void 0);
+      throw error;
+    }
+  }
+};
+function validateConnectorState(value) {
+  const state = requiredObject3(value, "state");
+  const legacy = state.version === 1;
+  exactKeys(state, /* @__PURE__ */ new Set([
+    "version",
+    "binding",
+    "serverCursor",
+    ...legacy ? [] : ["projectionCursor"],
+    "publishedDshSequence",
+    "activeRequest",
+    "outbox"
+  ]), "state");
+  if (!legacy && state.version !== 2)
+    throw new Error("Unsupported DSH connector state version");
+  const binding = requiredObject3(state.binding, "state.binding");
+  exactKeys(binding, /* @__PURE__ */ new Set(["projectId", "sessionId", "dshSessionId"]), "state.binding");
+  const serverCursor = nonNegativeInteger(state.serverCursor, "state.serverCursor");
+  const publishedDshSequence = nonNegativeInteger(state.publishedDshSequence, "state.publishedDshSequence");
+  const projectionCursor = legacy ? 0 : nonNegativeInteger(state.projectionCursor, "state.projectionCursor");
+  const activeRequest = state.activeRequest === void 0 ? void 0 : parseActiveRequest(state.activeRequest);
+  if (!Array.isArray(state.outbox))
+    throw new Error("state.outbox must be an array");
+  const outbox = state.outbox.map(parseOutboxOperation);
+  const validated = {
+    version: 2,
+    binding: {
+      projectId: safeString(binding.projectId, "state.binding.projectId", 128),
+      sessionId: safeString(binding.sessionId, "state.binding.sessionId", 128),
+      dshSessionId: safeString(binding.dshSessionId, "state.binding.dshSessionId", 128)
+    },
+    serverCursor,
+    projectionCursor,
+    publishedDshSequence,
+    ...activeRequest === void 0 ? {} : { activeRequest },
+    outbox
+  };
+  assertAlreadyRedacted(validated);
+  return validated;
+}
+function parseActiveRequest(value) {
+  const active = requiredObject3(value, "state.activeRequest");
+  exactKeys(active, /* @__PURE__ */ new Set(["requestId", "requestSequence", "dshFromSequence", "dshToSequence", "promptDigest"]), "state.activeRequest");
+  const parsed = {
+    requestId: safeString(active.requestId, "state.activeRequest.requestId", 128),
+    requestSequence: positiveInteger(active.requestSequence, "state.activeRequest.requestSequence"),
+    dshFromSequence: nonNegativeInteger(active.dshFromSequence, "state.activeRequest.dshFromSequence"),
+    ...active.dshToSequence === void 0 ? {} : {
+      dshToSequence: nonNegativeInteger(active.dshToSequence, "state.activeRequest.dshToSequence")
+    },
+    promptDigest: hexDigest(active.promptDigest, "state.activeRequest.promptDigest")
+  };
+  if (parsed.dshToSequence !== void 0 && parsed.dshToSequence < parsed.dshFromSequence) {
+    throw new Error("state.activeRequest.dshToSequence cannot precede dshFromSequence");
+  }
+  return parsed;
+}
+function parseOutboxOperation(value, index) {
+  const label = `state.outbox[${index}]`;
+  const operation = requiredObject3(value, label);
+  const kind = operation.kind;
+  if (kind === "append") {
+    exactKeys(operation, /* @__PURE__ */ new Set(["id", "kind", "input"]), label);
+    return {
+      id: safeString(operation.id, `${label}.id`, 200),
+      kind,
+      input: parseAppendInput(operation.input, `${label}.input`)
+    };
+  }
+  if (kind === "progress" || kind === "complete") {
+    exactKeys(operation, /* @__PURE__ */ new Set(["id", "kind", "requestId", "input"]), label);
+    return {
+      id: safeString(operation.id, `${label}.id`, 200),
+      kind,
+      requestId: safeString(operation.requestId, `${label}.requestId`, 128),
+      input: parseCompletionInput(operation.input, `${label}.input`)
+    };
+  }
+  if (kind === "local_turn") {
+    exactKeys(operation, /* @__PURE__ */ new Set(["id", "kind", "dshToSequence", "input"]), label);
+    return {
+      id: safeString(operation.id, `${label}.id`, 200),
+      kind,
+      dshToSequence: nonNegativeInteger(operation.dshToSequence, `${label}.dshToSequence`),
+      input: parseLocalTurnInput(operation.input, `${label}.input`)
+    };
+  }
+  throw new Error(`${label}.kind is unsupported`);
+}
+function parseLocalTurnInput(value, label) {
+  const input = requiredObject3(value, label);
+  exactKeys(input, /* @__PURE__ */ new Set([
+    "localTurnId",
+    "runtimeId",
+    "basedOnSequence",
+    "occurredAt",
+    "observedModel",
+    "observedReasoningEffort",
+    "requestPayload",
+    "responsePayload",
+    "toolEvents"
+  ]), label);
+  const occurredAt = safeString(input.occurredAt, `${label}.occurredAt`, 64);
+  if (!Number.isFinite(Date.parse(occurredAt)))
+    throw new Error(`${label}.occurredAt must be an ISO timestamp`);
+  if (input.toolEvents !== void 0 && !Array.isArray(input.toolEvents)) {
+    throw new Error(`${label}.toolEvents must be an array`);
+  }
+  return {
+    localTurnId: safeString(input.localTurnId, `${label}.localTurnId`, 200),
+    runtimeId: safeString(input.runtimeId, `${label}.runtimeId`, 128),
+    basedOnSequence: nonNegativeInteger(input.basedOnSequence, `${label}.basedOnSequence`),
+    occurredAt,
+    ...input.observedModel === void 0 ? {} : {
+      observedModel: safeString(input.observedModel, `${label}.observedModel`, 160)
+    },
+    ...input.observedReasoningEffort === void 0 ? {} : {
+      observedReasoningEffort: safeString(input.observedReasoningEffort, `${label}.observedReasoningEffort`, 80)
+    },
+    requestPayload: jsonValue(input.requestPayload, `${label}.requestPayload`),
+    responsePayload: jsonValue(input.responsePayload, `${label}.responsePayload`),
+    ...input.toolEvents === void 0 ? {} : {
+      toolEvents: input.toolEvents.map((event, eventIndex) => jsonValue(event, `${label}.toolEvents[${eventIndex}]`))
+    }
+  };
+}
+function parseAppendInput(value, label) {
+  const input = requiredObject3(value, label);
+  exactKeys(input, /* @__PURE__ */ new Set([
+    "type",
+    "idempotencyKey",
+    "payload",
+    "replyTo",
+    "visibility",
+    "runtimeId",
+    "observedModel",
+    "observedReasoningEffort"
+  ]), label);
+  if (input.type !== "tool_call" && input.type !== "tool_result") {
+    throw new Error(`${label}.type must be tool_call or tool_result`);
+  }
+  return {
+    type: input.type,
+    idempotencyKey: safeString(input.idempotencyKey, `${label}.idempotencyKey`, 200),
+    payload: jsonValue(input.payload, `${label}.payload`),
+    ...input.replyTo === void 0 ? {} : { replyTo: safeString(input.replyTo, `${label}.replyTo`, 128) },
+    ...input.visibility === void 0 ? {} : { visibility: safeString(input.visibility, `${label}.visibility`, 32) },
+    ...input.runtimeId === void 0 ? {} : { runtimeId: safeString(input.runtimeId, `${label}.runtimeId`, 128) },
+    ...input.observedModel === void 0 ? {} : { observedModel: safeString(input.observedModel, `${label}.observedModel`, 160) },
+    ...input.observedReasoningEffort === void 0 ? {} : {
+      observedReasoningEffort: safeString(input.observedReasoningEffort, `${label}.observedReasoningEffort`, 80)
+    }
+  };
+}
+function parseCompletionInput(value, label) {
+  const input = requiredObject3(value, label);
+  exactKeys(input, /* @__PURE__ */ new Set(["runtimeId", "idempotencyKey", "payload", "observedModel", "observedReasoningEffort"]), label);
+  return {
+    runtimeId: safeString(input.runtimeId, `${label}.runtimeId`, 128),
+    idempotencyKey: safeString(input.idempotencyKey, `${label}.idempotencyKey`, 200),
+    payload: jsonValue(input.payload, `${label}.payload`),
+    ...input.observedModel === void 0 ? {} : { observedModel: safeString(input.observedModel, `${label}.observedModel`, 160) },
+    ...input.observedReasoningEffort === void 0 ? {} : {
+      observedReasoningEffort: safeString(input.observedReasoningEffort, `${label}.observedReasoningEffort`, 80)
+    }
+  };
+}
+function assertAlreadyRedacted(state) {
+  const encoded = JSON.stringify(state);
+  const redacted = JSON.stringify(redactValue(state));
+  if (encoded !== redacted) {
+    throw new Error("DSH connector state contains a secret-bearing field or value");
+  }
+}
+function requiredObject3(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function exactKeys(value, allowed, label) {
+  const extra = Object.keys(value).filter((key) => !allowed.has(key));
+  if (extra.length > 0)
+    throw new Error(`${label} contains unsupported keys: ${extra.join(", ")}`);
+}
+function safeString(value, label, maximum) {
+  if (typeof value !== "string" || !value || value.length > maximum || /[\u0000-\u001f\u007f-\u009f]/u.test(value)) {
+    throw new Error(`${label} must be a safe non-empty string`);
+  }
+  return value;
+}
+function jsonValue(value, label) {
+  try {
+    const encoded = JSON.stringify(value);
+    if (encoded === void 0)
+      throw new Error();
+    return JSON.parse(encoded);
+  } catch {
+    throw new Error(`${label} must be a JSON value`);
+  }
+}
+function hexDigest(value, label) {
+  const digest2 = safeString(value, label, 64);
+  if (!/^[a-f0-9]{64}$/.test(digest2))
+    throw new Error(`${label} must be a SHA-256 digest`);
+  return digest2;
+}
+function nonNegativeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || Number(value) < 0) {
+    throw new Error(`${label} must be a non-negative integer`);
+  }
+  return Number(value);
+}
+function positiveInteger(value, label) {
+  const parsed = nonNegativeInteger(value, label);
+  if (parsed === 0)
+    throw new Error(`${label} must be positive`);
+  return parsed;
+}
+function isNodeError3(error) {
+  return error instanceof Error && "code" in error;
+}
+async function optionalLstat(target) {
+  try {
+    return await lstat3(target);
+  } catch (error) {
+    if (isNodeError3(error) && error.code === "ENOENT")
+      return void 0;
+    throw error;
+  }
+}
+function assertPrivateRegularFile(metadata, label) {
+  if (metadata.isSymbolicLink() || !metadata.isFile()) {
+    throw new Error(`${label} must be a regular file, never a symbolic link`);
+  }
+  if (process.platform !== "win32" && (Number(metadata.mode) & 511) !== 384) {
+    throw new Error(`${label} permissions must be 0600`);
+  }
+}
+function assertSecureDirectory(metadata) {
+  if (metadata.isSymbolicLink() || !metadata.isDirectory()) {
+    throw new Error("DSH connector state directory must be a real directory");
+  }
+  if (process.platform !== "win32" && (Number(metadata.mode) & 511) !== 448) {
+    throw new Error("DSH connector state directory permissions must be 0700");
+  }
+}
+function sameArtifact(before, after) {
+  if (before === void 0 || after === void 0)
+    return before === after;
+  return !after.isSymbolicLink() && after.isFile() && before.dev === after.dev && before.ino === after.ino;
+}
+
+// dist/src/project-manager.js
+import path4 from "node:path";
+import { createHash as createHash4 } from "node:crypto";
+
+// dist/src/execution-gate.js
+var BoundedDshExecutionGate = class {
+  #limit;
+  #pending = [];
+  #active = 0;
+  #closed;
+  constructor(limit) {
+    if (!Number.isSafeInteger(limit) || limit < 1) {
+      throw new Error("DSH execution concurrency must be a positive integer");
+    }
+    this.#limit = limit;
+  }
+  get activeCount() {
+    return this.#active;
+  }
+  get pendingCount() {
+    return this.#pending.length;
+  }
+  run(operation, signal) {
+    if (this.#closed !== void 0)
+      return Promise.reject(this.#closed);
+    if (signal?.aborted)
+      return Promise.reject(abortReason(signal));
+    return new Promise((resolve, reject) => {
+      let pending;
+      const onAbort = () => {
+        const index = this.#pending.indexOf(pending);
+        if (index < 0)
+          return;
+        this.#pending.splice(index, 1);
+        pending.detachAbort();
+        reject(abortReason(signal));
+      };
+      pending = {
+        operation,
+        resolve,
+        reject,
+        detachAbort: () => signal?.removeEventListener("abort", onAbort)
+      };
+      signal?.addEventListener("abort", onAbort, { once: true });
+      this.#pending.push(pending);
+      this.#drain();
+    });
+  }
+  close(reason = new Error("DSH project execution gate is closed")) {
+    if (this.#closed !== void 0)
+      return;
+    this.#closed = reason;
+    for (const pending of this.#pending.splice(0)) {
+      pending.detachAbort();
+      pending.reject(reason);
+    }
+  }
+  #drain() {
+    while (this.#closed === void 0 && this.#active < this.#limit) {
+      const pending = this.#pending.shift();
+      if (pending === void 0)
+        return;
+      pending.detachAbort();
+      this.#active += 1;
+      void Promise.resolve().then(pending.operation).then((value) => {
+        this.#active -= 1;
+        this.#drain();
+        pending.resolve(value);
+      }, (error) => {
+        this.#active -= 1;
+        this.#drain();
+        pending.reject(error);
+      });
+    }
+  }
+};
+function abortReason(signal) {
+  return signal?.reason instanceof Error ? signal.reason : new Error("DSH execution permit was canceled");
+}
+
+// dist/src/project-manager.js
+var DshProjectManager = class {
+  #config;
+  #api;
+  #createConnector;
+  #onBackgroundError;
+  #now;
+  #executionGate;
+  #onStatus;
+  #discoverLocalSessions;
+  #canCreateLocalSessions;
+  #subscribeToLocalSessionChanges;
+  #mapCloudSessionId;
+  #managed = /* @__PURE__ */ new Map();
+  #nativeLocalSessionIds = /* @__PURE__ */ new Set();
+  #retries = /* @__PURE__ */ new Map();
+  #actor;
+  #started = false;
+  #stopped = false;
+  #timer;
+  #refreshPromise;
+  #stopPromise;
+  #discoveryFailures = 0;
+  #stopLocalSessionSubscription;
+  constructor(options) {
+    this.#config = options.config;
+    this.#api = options.api;
+    this.#createConnector = options.createConnector;
+    this.#onBackgroundError = options.onBackgroundError;
+    this.#now = options.now ?? Date.now;
+    this.#executionGate = new BoundedDshExecutionGate(options.config.maxConcurrentSessions);
+    this.#onStatus = options.onStatus;
+    this.#discoverLocalSessions = options.discoverLocalSessions;
+    this.#canCreateLocalSessions = options.canCreateLocalSessions === true;
+    this.#subscribeToLocalSessionChanges = options.subscribeToLocalSessionChanges;
+    this.#mapCloudSessionId = options.mapCloudSessionId;
+  }
+  get stopped() {
+    return this.#stopped;
+  }
+  activeSessionIds() {
+    return [...this.#managed].filter(([, binding]) => binding.phase === "active" && !binding.connector.stopped).map(([sessionId]) => sessionId).sort();
+  }
+  async start() {
+    if (this.#started)
+      throw new Error("DSH project manager is already started");
+    if (this.#stopped)
+      throw new Error("DSH project manager cannot restart after disposal");
+    this.#started = true;
+    try {
+      const actor = await this.#api.getCurrentActor();
+      if (actor.deviceId !== this.#config.deviceId) {
+        throw new Error("Configured DSH device identity does not match the authenticated actor");
+      }
+      this.#actor = actor;
+      const initial = await this.#refresh();
+      if (initial.status === "project_inaccessible")
+        throw initial.error;
+      if (initial.status === "transient_failure") {
+        throw publicError2(initial.error, "Initial GatherThread Project discovery failed");
+      }
+      this.#stopLocalSessionSubscription = this.#subscribeToLocalSessionChanges?.(() => {
+        if (this.#stopped)
+          return;
+        void this.refreshOnce().catch((error) => this.#reportError(publicError2(error, "DSH local Session discovery failed")));
+      });
+      this.#scheduleNextRefresh();
+    } catch (error) {
+      await this.stop();
+      throw error;
+    }
+  }
+  refreshOnce() {
+    if (!this.#started || this.#stopped) {
+      return Promise.reject(new Error("DSH project manager is not running"));
+    }
+    return this.#refresh();
+  }
+  stop() {
+    this.#stopPromise ??= (async () => {
+      this.#stopped = true;
+      if (this.#timer !== void 0) {
+        clearTimeout(this.#timer);
+        this.#timer = void 0;
+      }
+      this.#stopLocalSessionSubscription?.();
+      this.#stopLocalSessionSubscription = void 0;
+      this.#executionGate.close(new Error("DSH project manager stopped"));
+      await this.#deactivateAll();
+      const refresh = this.#refreshPromise;
+      if (refresh !== void 0) {
+        try {
+          await refresh;
+        } catch {
+        }
+      }
+      await this.#deactivateAll();
+      this.#retries.clear();
+      this.#notifyStatus({ state: "stopped" });
+    })();
+    return this.#stopPromise;
+  }
+  #refresh() {
+    if (this.#refreshPromise !== void 0)
+      return this.#refreshPromise;
+    this.#refreshPromise = this.#performRefresh().finally(() => {
+      this.#refreshPromise = void 0;
+    });
+    return this.#refreshPromise;
+  }
+  async #performRefresh() {
+    const actor = this.#requireActor();
+    if (this.#stopped)
+      throw new Error("DSH project manager stopped during discovery");
+    for (const [sessionId, binding] of [...this.#managed]) {
+      if (!binding.connector.stopped)
+        continue;
+      this.#managed.delete(sessionId);
+      try {
+        await binding.connector.stop();
+      } catch (error) {
+        this.#reportError(publicError2(error, "Stopped DSH Session connector cleanup failed"));
+      }
+      this.#recordFailure(sessionId);
+    }
+    const permissions = await refreshProjectSessionPermissions({
+      loadSessions: () => this.#api.listProjectSessions(this.#config.projectId),
+      actorUserId: actor.id,
+      managed: this.#managed,
+      harness: {}
+    });
+    if (permissions.status === "project_inaccessible") {
+      this.#stopped = true;
+      if (this.#timer !== void 0) {
+        clearTimeout(this.#timer);
+        this.#timer = void 0;
+      }
+      this.#executionGate.close(new Error("GatherThread Project became inaccessible"));
+      await this.#deactivateAll();
+      this.#reportError(permissions.error);
+      this.#notifyStatus({ state: "error" });
+      return { status: "project_inaccessible", error: permissions.error };
+    }
+    if (permissions.status === "transient_failure") {
+      this.#discoveryFailures += 1;
+      this.#reportError(publicError2(permissions.error, "GatherThread Project discovery failed transiently"));
+      this.#notifyStatus({ state: "offline" });
+      return permissions;
+    }
+    this.#discoveryFailures = 0;
+    for (const error of permissions.errors)
+      this.#reportError(error);
+    const eligibleSessions = [...permissions.eligibleSessions];
+    if (this.#discoverLocalSessions !== void 0) {
+      try {
+        const candidates2 = await this.#discoverLocalSessions();
+        this.#nativeLocalSessionIds.clear();
+        for (const candidate of candidates2)
+          this.#nativeLocalSessionIds.add(candidate.localSessionId);
+        if (this.#canCreateLocalSessions) {
+          const representedIds = new Set(eligibleSessions.map((session) => session.id));
+          for (const candidate of candidates2) {
+            if (representedIds.has(candidate.localSessionId))
+              continue;
+            const created = await this.#api.createSession(this.#config.projectId, {
+              sessionId: candidate.localSessionId,
+              title: candidate.title,
+              mode: "solo",
+              idempotencyKey: nativeSessionCreationKey(this.#config.projectId, candidate.localSessionId)
+            });
+            eligibleSessions.push(created);
+            representedIds.add(created.id);
+          }
+        }
+      } catch (error) {
+        this.#reportError(publicError2(error, "DSH local Session discovery failed"));
+      }
+    }
+    const eligibleIds = new Set(eligibleSessions.map((session) => session.id));
+    for (const sessionId of [...this.#retries.keys()]) {
+      if (!eligibleIds.has(sessionId))
+        this.#retries.delete(sessionId);
+    }
+    const now = this.#now();
+    const candidates = eligibleSessions.filter((session) => {
+      if (this.#managed.has(session.id))
+        return false;
+      return (this.#retries.get(session.id)?.nextAttemptAt ?? 0) <= now;
+    });
+    const attachErrors = await runBounded(candidates, this.#config.maxConcurrentSessions, (session) => this.#attach(session, actor.id));
+    for (const error of attachErrors)
+      this.#reportError(error);
+    const result = {
+      status: "updated",
+      eligibleSessionIds: [...eligibleIds].sort(),
+      activeSessionIds: this.activeSessionIds(),
+      errors: [...permissions.errors, ...attachErrors]
+    };
+    this.#notifyStatus({
+      state: "connected",
+      eligibleSessions,
+      activeSessionIds: result.activeSessionIds
+    });
+    return result;
+  }
+  async #attach(session, actorUserId) {
+    if (this.#stopped || this.#managed.has(session.id))
+      return;
+    let binding;
+    try {
+      const connector = this.#createConnector({
+        config: projectSessionConfig(this.#config, session.id, this.#nativeLocalSessionIds.has(session.id) ? session.id : this.#mapCloudSessionId?.(session.id)),
+        session,
+        actorUserId,
+        executionGate: this.#executionGate,
+        onBackgroundError: (error) => this.#reportError(error)
+      });
+      binding = {
+        connector,
+        phase: "starting",
+        deactivateLocalPublishing: async () => connector.stop()
+      };
+      this.#managed.set(session.id, binding);
+      await connector.start();
+      if (this.#stopped || connector.stopped || this.#managed.get(session.id) !== binding) {
+        await connector.stop();
+        this.#managed.delete(session.id);
+        return;
+      }
+      binding.phase = "active";
+      this.#retries.delete(session.id);
+    } catch (error) {
+      if (binding !== void 0 && this.#managed.get(session.id) === binding) {
+        this.#managed.delete(session.id);
+      }
+      try {
+        await binding?.connector.stop();
+      } catch (stopError) {
+        this.#reportError(publicError2(stopError, "DSH Session connector cleanup failed"));
+      }
+      if (this.#stopped)
+        return;
+      this.#recordFailure(session.id);
+      throw publicError2(error, `DSH Session ${session.id} failed to attach`);
+    }
+  }
+  #recordFailure(sessionId) {
+    const attempts = (this.#retries.get(sessionId)?.attempts ?? 0) + 1;
+    this.#retries.set(sessionId, {
+      attempts,
+      nextAttemptAt: this.#now() + retryDelay(this.#config, attempts)
+    });
+  }
+  #scheduleNextRefresh() {
+    if (this.#stopped || this.#timer !== void 0)
+      return;
+    const now = this.#now();
+    let delay = this.#discoveryFailures > 0 ? retryDelay(this.#config, this.#discoveryFailures) : this.#config.refreshIntervalMs;
+    for (const retry of this.#retries.values()) {
+      delay = Math.min(delay, Math.max(1, retry.nextAttemptAt - now));
+    }
+    this.#timer = setTimeout(() => {
+      this.#timer = void 0;
+      void this.refreshOnce().catch((error) => this.#reportError(publicError2(error, "DSH Project refresh failed"))).finally(() => this.#scheduleNextRefresh());
+    }, delay);
+    this.#timer.unref?.();
+  }
+  async #deactivateAll() {
+    const bindings = [...this.#managed.values()];
+    this.#managed.clear();
+    const results = await Promise.allSettled(bindings.map((binding) => binding.connector.stop()));
+    for (const result of results) {
+      if (result.status === "rejected") {
+        this.#reportError(publicError2(result.reason, "DSH Session connector cleanup failed"));
+      }
+    }
+  }
+  #requireActor() {
+    if (this.#actor === void 0)
+      throw new Error("Authenticated GatherThread actor is unavailable");
+    return this.#actor;
+  }
+  #reportError(error) {
+    this.#onBackgroundError?.(error);
+  }
+  #notifyStatus(update) {
+    try {
+      this.#onStatus?.(update);
+    } catch {
+    }
+  }
+};
+function projectSessionConfig(config, sessionId, nativeSessionId) {
+  const dshSessionId = nativeSessionId ?? deriveDshSessionId(config.projectId, sessionId, config.workspacePath);
+  return {
+    enabled: true,
+    bindingMode: "single",
+    apiUrl: config.apiUrl,
+    credentialReference: config.credentialReference,
+    projectId: config.projectId,
+    ...config.projectName === void 0 ? {} : { projectName: config.projectName },
+    sessionId,
+    deviceId: config.deviceId,
+    workspacePath: config.workspacePath,
+    statePath: path4.join(config.stateRoot, `${dshSessionId}.json`),
+    provider: config.provider,
+    model: config.model,
+    pollIntervalMs: config.pollIntervalMs,
+    pollLimit: config.pollLimit,
+    shareToolEvents: config.shareToolEvents,
+    dshSessionId
+  };
+}
+function nativeSessionCreationKey(projectId, localSessionId) {
+  const identity = createHash4("sha256").update(`${projectId}\0${localSessionId}`).digest("hex");
+  return `dsh-native:${identity}`;
+}
+function retryDelay(config, attempts) {
+  return Math.min(config.retryMaxMs, config.retryBaseMs * 2 ** Math.min(attempts - 1, 30));
+}
+async function runBounded(values, limit, operation) {
+  const errors = [];
+  let index = 0;
+  const workers = Array.from({ length: Math.min(limit, values.length) }, async () => {
+    while (index < values.length) {
+      const current = values[index];
+      index += 1;
+      if (current === void 0)
+        continue;
+      try {
+        await operation(current);
+      } catch (error) {
+        errors.push(publicError2(error, "DSH Session attach failed"));
+      }
+    }
+  });
+  await Promise.all(workers);
+  return errors;
+}
+function publicError2(error, fallback) {
+  return error instanceof Error ? error : new Error(fallback);
+}
+
+// dist/src/status.js
+var DSH_STATUS_PATH = "/api/gatherthread.status";
+var DSH_STATUS_MAX_SESSIONS = 100;
+var DSH_STATUS_MAX_ID_LENGTH = 128;
+var DSH_STATUS_MAX_LABEL_LENGTH = 160;
+var DshStatusController = class {
+  #bindingMode;
+  #projectName;
+  #now;
+  #sessions = /* @__PURE__ */ new Map();
+  #connection = "connecting";
+  #updatedAt;
+  constructor(options) {
+    this.#bindingMode = options.bindingMode;
+    this.#projectName = publicText(options.projectName, "projectName", DSH_STATUS_MAX_LABEL_LENGTH);
+    this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.#updatedAt = timestamp(this.#now());
+  }
+  setConnection(state) {
+    this.#connection = state;
+    this.#touch();
+  }
+  setProjectName(value) {
+    this.#projectName = publicText(value, "projectName", DSH_STATUS_MAX_LABEL_LENGTH);
+    this.#touch();
+  }
+  upsertSession(input) {
+    const sessionId = publicText(input.sessionId, "sessionId", DSH_STATUS_MAX_ID_LENGTH);
+    const existing = this.#sessions.get(sessionId);
+    if (existing === void 0 && this.#sessions.size >= DSH_STATUS_MAX_SESSIONS) {
+      throw new Error(`DSH public status supports at most ${String(DSH_STATUS_MAX_SESSIONS)} Sessions`);
+    }
+    const next = {
+      sessionId,
+      title: publicText(input.title, "session title", DSH_STATUS_MAX_LABEL_LENGTH),
+      state: input.state,
+      ...input.synced === true ? { lastSyncedAt: timestamp(this.#now()) } : existing?.lastSyncedAt === void 0 ? {} : { lastSyncedAt: existing.lastSyncedAt }
+    };
+    this.#sessions.set(sessionId, next);
+    this.#touch();
+  }
+  removeSession(sessionIdValue) {
+    const sessionId = publicText(sessionIdValue, "sessionId", DSH_STATUS_MAX_ID_LENGTH);
+    if (this.#sessions.delete(sessionId))
+      this.#touch();
+  }
+  reconcileProjectSessions(sessions, activeSessionIds) {
+    const visibleSessions = sessions.slice(0, DSH_STATUS_MAX_SESSIONS);
+    const visibleIds = new Set(visibleSessions.map((session) => session.id));
+    const activeIds = new Set(activeSessionIds);
+    for (const sessionId of this.#sessions.keys()) {
+      if (!visibleIds.has(sessionId))
+        this.#sessions.delete(sessionId);
+    }
+    for (const session of visibleSessions) {
+      const existing = this.#sessions.get(session.id);
+      const state = activeIds.has(session.id) ? existing?.state === "running" ? "running" : "idle" : existing?.state === "error" || existing?.state === "offline" ? existing.state : "connecting";
+      this.upsertSession({
+        sessionId: session.id,
+        title: session.name ?? session.id,
+        state
+      });
+    }
+    this.#touch();
+  }
+  markSessionsOffline() {
+    for (const [sessionId, session] of this.#sessions) {
+      this.#sessions.set(sessionId, { ...session, state: "offline" });
+    }
+    this.#touch();
+  }
+  snapshot() {
+    const sessions = [...this.#sessions.values()].sort((left, right) => left.sessionId.localeCompare(right.sessionId)).slice(0, DSH_STATUS_MAX_SESSIONS).map((session) => ({ ...session }));
+    return {
+      schemaVersion: 1,
+      integration: "gatherthread",
+      connection: this.#connection,
+      bindingMode: this.#bindingMode,
+      projectName: this.#projectName,
+      activeSessionCount: sessions.filter((session) => session.state === "idle" || session.state === "running").length,
+      sessions,
+      updatedAt: this.#updatedAt
+    };
+  }
+  #touch() {
+    this.#updatedAt = timestamp(this.#now());
+  }
+};
+function registerDshStatusRoute(contextValue, controller) {
+  const context = asObject5(contextValue);
+  if (context === void 0)
+    throw new Error("Unsupported DeepSeek Harness Host context");
+  const connection = asConnection(Reflect.get(context, "connection"));
+  if (connection === void 0)
+    return void 0;
+  let active = true;
+  const unregister = connection.fetch.register({
+    path: DSH_STATUS_PATH,
+    methods: ["GET", "HEAD"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      if (!active)
+        return new Response("not found", { status: 404 });
+      if (request.method !== "GET" && request.method !== "HEAD") {
+        return new Response(null, {
+          status: 405,
+          headers: { allow: "GET, HEAD", "cache-control": "no-store" }
+        });
+      }
+      const url = new URL(request.url);
+      if (url.pathname !== DSH_STATUS_PATH || url.search !== "") {
+        return minimalResponse("invalid request", 400);
+      }
+      const body = JSON.stringify(controller.snapshot());
+      const headers = statusHeaders();
+      headers.set("content-length", String(Buffer.byteLength(body, "utf8")));
+      return new Response(request.method === "HEAD" ? null : body, {
+        status: 200,
+        headers
+      });
+    }
+  });
+  let disposePromise;
+  return () => {
+    disposePromise ??= (async () => {
+      active = false;
+      await unregister();
+    })();
+    return disposePromise;
+  };
+}
+function bindOptionalDshStatusRoute(contextValue, controller) {
+  const context = asObject5(contextValue);
+  if (context === void 0 || typeof context.inject !== "function") {
+    throw new Error("Unsupported DeepSeek Harness optional service context");
+  }
+  const fiber = context.inject(["connection"], (connectionContextValue) => {
+    const connectionContext = asObject5(connectionContextValue);
+    if (connectionContext === void 0 || typeof connectionContext.effect !== "function") {
+      throw new Error("Unsupported DeepSeek Harness Connection context");
+    }
+    const dispose = registerDshStatusRoute(connectionContextValue, controller);
+    if (dispose === void 0) {
+      throw new Error("Injected DeepSeek Harness Connection service is unavailable");
+    }
+    connectionContext.effect(() => dispose, "gatherthread-dsh-host.status-route");
+  });
+  let disposePromise;
+  return () => {
+    disposePromise ??= Promise.resolve(fiber.dispose()).then(() => void 0);
+    return disposePromise;
+  };
+}
+function statusHeaders() {
+  return new Headers({
+    "cache-control": "no-store",
+    "content-security-policy": "default-src 'none'",
+    "content-type": "application/json; charset=utf-8",
+    "referrer-policy": "no-referrer",
+    "x-content-type-options": "nosniff"
+  });
+}
+function minimalResponse(body, status) {
+  return new Response(body, {
+    status,
+    headers: {
+      "cache-control": "no-store",
+      "content-type": "text/plain; charset=utf-8",
+      "x-content-type-options": "nosniff"
+    }
+  });
+}
+function asConnection(value) {
+  const connection = asObject5(value);
+  const fetch = asObject5(connection?.fetch);
+  return typeof fetch?.register === "function" ? value : void 0;
+}
+function asObject5(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function publicText(value, label, maximum) {
+  const trimmed = value.trim();
+  if (!trimmed || trimmed.length > maximum || hasControlCharacter(trimmed) || looksLikeAbsolutePath(trimmed)) {
+    throw new Error(`${label} is not safe bounded display text`);
+  }
+  return trimmed;
+}
+function looksLikeAbsolutePath(value) {
+  return value.startsWith("/") || value.startsWith("\\\\") || /^[A-Za-z]:[\\/]/u.test(value);
+}
+function hasControlCharacter(value) {
+  for (const character of value) {
+    const code = character.codePointAt(0) ?? 0;
+    if (code < 32 || code >= 127 && code <= 159)
+      return true;
+  }
+  return false;
+}
+function timestamp(value) {
+  if (!Number.isFinite(value.getTime()))
+    throw new Error("DSH status clock returned an invalid date");
+  return value.toISOString();
+}
+
+// dist/src/plugin.js
+var name = "gatherthread-dsh-host";
+var inject = ["agents", "sessions", "sessionPersistence", "llm"];
+async function apply(context, rawConfig) {
+  const config = parseDshHostConfig(rawConfig);
+  if (!config.enabled)
+    return;
+  assertSafeDshEnvironment();
+  if (config.bindingMode === "single")
+    await assertSafeDshPaths(config);
+  else
+    await assertSafeDshStateRoot(config);
+  const status = new DshStatusController({
+    bindingMode: config.bindingMode,
+    projectName: config.projectName ?? config.projectId
+  });
+  let statusDispose;
+  const credential = resolveCredentialReference(config.credentialReference);
+  const abort = new AbortController();
+  let owner;
+  registerDshPluginDisposer(context, async () => {
+    abort.abort(new Error("GatherThread DSH Host plugin unloaded"));
+    await owner?.stop();
+    status.setConnection("stopped");
+    await statusDispose?.();
+  });
+  try {
+    statusDispose = bindOptionalDshStatusRoute(context, status);
+    const api = createHttpDshCollaborationApi({
+      baseUrl: config.apiUrl,
+      credential,
+      signal: abort.signal
+    });
+    if (config.bindingMode === "single") {
+      let sessionTitle = config.sessionId;
+      status.upsertSession({
+        sessionId: config.sessionId,
+        title: sessionTitle,
+        state: "connecting"
+      });
+      const actor = await api.getCurrentActor();
+      assertActorDevice(actor.deviceId, config.deviceId);
+      const host = createDshHostFacade({
+        context,
+        sessionId: config.dshSessionId,
+        workspacePath: config.workspacePath,
+        provider: config.provider,
+        model: config.model
+      });
+      const connector = new DshHostConnector({
+        config,
+        api,
+        host,
+        stateStore: new FileConnectorStateStore(config.statePath),
+        actorUserId: actor.id,
+        onLifecycle: (update) => {
+          sessionTitle = update.session?.name ?? sessionTitle;
+          updateSingleStatus(status, config.sessionId, sessionTitle, update);
+        }
+      });
+      owner = connector;
+      await connector.start();
+      return;
+    }
+    const manager = new DshProjectManager({
+      config,
+      api,
+      createConnector: (input) => createManagedConnector({
+        input,
+        context,
+        credential,
+        rootSignal: abort.signal,
+        status
+      }),
+      onStatus: (update) => {
+        if (update.state === "connected") {
+          status.reconcileProjectSessions(update.eligibleSessions, update.activeSessionIds);
+          status.setConnection("connected");
+        } else if (update.state === "offline") {
+          status.markSessionsOffline();
+          status.setConnection("offline");
+        } else {
+          status.setConnection(update.state);
+        }
+      }
+    });
+    owner = manager;
+    await manager.start();
+  } catch (error) {
+    abort.abort(new Error("GatherThread DSH Host plugin initialization failed"));
+    await Promise.allSettled([
+      owner?.stop(),
+      statusDispose?.()
+    ]);
+    throw error;
+  }
+}
+function createManagedConnector(options) {
+  const sessionAbort = new AbortController();
+  const abortFromRoot = () => sessionAbort.abort(options.rootSignal.reason);
+  if (options.rootSignal.aborted)
+    abortFromRoot();
+  else
+    options.rootSignal.addEventListener("abort", abortFromRoot, { once: true });
+  const api = createHttpDshCollaborationApi({
+    baseUrl: options.input.config.apiUrl,
+    credential: options.credential,
+    signal: sessionAbort.signal
+  });
+  const host = createDshHostFacade({
+    context: options.context,
+    sessionId: options.input.config.dshSessionId,
+    workspacePath: options.input.config.workspacePath,
+    provider: options.input.config.provider,
+    model: options.input.config.model
+  });
+  const connector = new DshHostConnector({
+    config: options.input.config,
+    api,
+    host,
+    stateStore: new FileConnectorStateStore(options.input.config.statePath),
+    actorUserId: options.input.actorUserId,
+    executionGate: options.input.executionGate,
+    onBackgroundError: options.input.onBackgroundError,
+    onLifecycle: (update) => {
+      if (update.state === "stopped") {
+        options.status.removeSession(options.input.session.id);
+        return;
+      }
+      options.status.upsertSession({
+        sessionId: options.input.session.id,
+        title: options.input.session.name ?? options.input.session.id,
+        state: update.state,
+        ...update.synced === true ? { synced: true } : {}
+      });
+    }
+  });
+  let stopPromise;
+  return {
+    get stopped() {
+      return connector.stopped;
+    },
+    async start() {
+      try {
+        await connector.start();
+      } catch (error) {
+        options.status.upsertSession({
+          sessionId: options.input.session.id,
+          title: options.input.session.name ?? options.input.session.id,
+          state: "error"
+        });
+        throw error;
+      }
+    },
+    stop() {
+      stopPromise ??= (async () => {
+        options.rootSignal.removeEventListener("abort", abortFromRoot);
+        sessionAbort.abort(new Error("GatherThread DSH Session binding stopped"));
+        await connector.stop();
+      })();
+      return stopPromise;
+    }
+  };
+}
+function updateSingleStatus(status, sessionId, sessionTitle, update) {
+  if (update.state === "stopped") {
+    status.setConnection("stopped");
+    return;
+  }
+  status.upsertSession({
+    sessionId,
+    title: sessionTitle,
+    state: update.state,
+    ...update.synced === true ? { synced: true } : {}
+  });
+  status.setConnection(update.state === "idle" || update.state === "running" ? "connected" : update.state);
+}
+function assertActorDevice(actual, expected) {
+  if (actual !== expected) {
+    throw new Error("Configured DSH device identity does not match the authenticated actor");
+  }
+}
+export {
+  apply,
+  inject,
+  name
+};