@axiom-lattice/core 6.3.3 → 6.4.0

package/dist/index.mjs

@@ -1688,6 +1688,9 @@ var InMemoryProjectStore = class {
         workspaceId,
         name: data.name,
         description: data.description,
+        // Persist `kind` like the Local/PostgreSQL stores so `public`/`personal`/
+        // `training` project semantics survive in in-memory deployments.
+        ...data.kind === void 0 ? {} : { kind: data.kind },
         config: data.config === void 0 && Object.keys(capabilityBundleIds).length === 0 ? void 0 : { ...data.config ?? {}, ...capabilityBundleIds },
         createdAt: existing?.createdAt ?? now,
         updatedAt: now
@@ -3307,6 +3310,93 @@ var InMemoryOutboxStore = class {
   }
 };
 
+// src/store_lattice/InMemoryPluginDeploymentStore.ts
+var InMemoryPluginDeploymentStore = class {
+  constructor() {
+    this.entries = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Lists every deployment for a tenant.
+   *
+   * @param tenantId - Tenant whose deployments are listed
+   * @returns Defensive copies of the tenant's deployments
+   */
+  async listByTenant(tenantId2) {
+    return [...this.entries.values()].filter((entry) => entry.tenantId === tenantId2).map((entry) => structuredClone(entry));
+  }
+  /**
+   * Returns the deployment for a tenant + plugin type.
+   *
+   * @param tenantId - Owning tenant
+   * @param pluginType - Plugin type key
+   * @returns Defensive copy of the deployment, or undefined when absent
+   */
+  async get(tenantId2, pluginType) {
+    const entry = this.entries.get(entryKey2(tenantId2, pluginType));
+    return entry ? structuredClone(entry) : void 0;
+  }
+  /**
+   * Inserts or replaces a deployment keyed by tenant + plugin type.
+   *
+   * On conflict the existing `id` and `createdAt` are preserved while every
+   * other field (including `updatedAt`, when supplied) is updated — mirroring
+   * the PostgreSQL store's `ON CONFLICT` semantics.
+   *
+   * @param deployment - Deployment record to persist
+   * @returns Defensive copy of the stored deployment
+   */
+  async upsert(deployment) {
+    const key5 = entryKey2(deployment.tenantId, deployment.pluginType);
+    const existing = this.entries.get(key5);
+    const next = {
+      ...structuredClone(deployment),
+      id: existing?.id ?? deployment.id,
+      createdAt: existing?.createdAt ?? deployment.createdAt,
+      updatedAt: deployment.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.entries.set(key5, next);
+    return structuredClone(next);
+  }
+  /**
+   * Applies a partial update to a deployment.
+   *
+   * `patch.createdAt` is ignored (immutable) and `updatedAt` is taken from the
+   * patch when supplied, otherwise set to the current time — matching the
+   * PostgreSQL store.
+   *
+   * @param tenantId - Owning tenant
+   * @param pluginType - Plugin type key
+   * @param patch - Mutable fields to apply
+   * @returns Defensive copy of the updated deployment, or undefined when absent
+   */
+  async updateStatus(tenantId2, pluginType, patch) {
+    const key5 = entryKey2(tenantId2, pluginType);
+    const existing = this.entries.get(key5);
+    if (!existing) return void 0;
+    const next = {
+      ...existing,
+      ...patch,
+      createdAt: existing.createdAt,
+      updatedAt: patch.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.entries.set(key5, next);
+    return structuredClone(next);
+  }
+  /**
+   * Deletes a deployment by tenant + plugin type.
+   *
+   * @param tenantId - Owning tenant
+   * @param pluginType - Plugin type key
+   * @returns Whether a record was removed
+   */
+  async delete(tenantId2, pluginType) {
+    return this.entries.delete(entryKey2(tenantId2, pluginType));
+  }
+};
+function entryKey2(tenantId2, pluginType) {
+  return JSON.stringify([tenantId2, pluginType]);
+}
+
 // src/store_lattice/InMemoryUserStore.ts
 var InMemoryUserStore = class {
   constructor() {
@@ -4977,6 +5067,7 @@ var defaultProjectRoomReadStateStore = new InMemoryProjectRoomReadStateStore();
 var defaultUserPushSubscriptionStore = new InMemoryUserPushSubscriptionStore();
 var defaultLeaseStore = new InMemoryLeaseStore();
 var defaultOutboxStore = new InMemoryOutboxStore();
+var defaultPluginDeploymentStore = new InMemoryPluginDeploymentStore();
 storeLatticeManager.registerLattice("default", "thread", defaultThreadStore);
 storeLatticeManager.registerLattice(
   "default",
@@ -5000,6 +5091,7 @@ storeLatticeManager.registerLattice("default", "projectRoomReadState", defaultPr
 storeLatticeManager.registerLattice("default", "userPushSubscription", defaultUserPushSubscriptionStore);
 storeLatticeManager.registerLattice("default", "lease", defaultLeaseStore);
 storeLatticeManager.registerLattice("default", "outbox", defaultOutboxStore);
+storeLatticeManager.registerLattice("default", "pluginDeployment", defaultPluginDeploymentStore);
 var defaultUserStore = new InMemoryUserStore();
 var defaultTenantStore = new InMemoryTenantStore();
 var defaultUserTenantLinkStore = new InMemoryUserTenantLinkStore();
@@ -13062,6 +13154,82 @@ var evalPlugin = {
   })
 };
 
+// src/sandbox_plugin/residentTransport.ts
+var DEFAULT_RESIDENT_INVOKE_TIMEOUT_MS = 6e4;
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEnvelope(value) {
+  return isRecord3(value) && typeof value.ok === "boolean";
+}
+function errorFromBody(value) {
+  if (isRecord3(value) && typeof value.error === "string" && value.error.length > 0) {
+    return value.error;
+  }
+  return void 0;
+}
+async function readJson(response) {
+  try {
+    return await response.json();
+  } catch {
+    return void 0;
+  }
+}
+async function invokeResident(args) {
+  const {
+    baseUrl,
+    endpointPath,
+    serviceKey,
+    payload,
+    timeoutMs = DEFAULT_RESIDENT_INVOKE_TIMEOUT_MS
+  } = args;
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const url = `${baseUrl.replace(/\/$/, "")}${endpointPath}/invoke`;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (serviceKey) {
+    headers["Authorization"] = `Bearer ${serviceKey}`;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetchImpl(url, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ ...payload, timeoutMs: payload.timeoutMs ?? timeoutMs }),
+      signal: controller.signal
+    });
+    const parsed = await readJson(response);
+    if (!response.ok) {
+      return {
+        ok: false,
+        error: errorFromBody(parsed) ?? `resident service responded with HTTP ${response.status}`,
+        status: response.status
+      };
+    }
+    if (!isEnvelope(parsed)) {
+      return {
+        ok: false,
+        error: "resident service returned an invalid envelope",
+        status: response.status
+      };
+    }
+    if (!parsed.ok) {
+      return {
+        ok: false,
+        error: errorFromBody(parsed) ?? "resident handler reported failure",
+        status: response.status
+      };
+    }
+    return { ok: true, result: parsed.result, status: response.status };
+  } catch (error) {
+    return { ok: false, error: error instanceof Error ? error.message : String(error) };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
 // src/sandbox_plugin/SandboxPluginExecutor.ts
 var PLUGINS_ROOT = "/root/.agents/plugins";
 var INLINE_INPUT_LIMIT_BYTES = 48 * 1024;
@@ -13074,11 +13242,11 @@ var MAX_MAX_RESULT_BYTES = 1048576;
 function encode(value) {
   return Buffer.from(JSON.stringify(value ?? null), "utf8").toString("base64");
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isEnvelope(value) {
-  return isRecord3(value) && typeof value.ok === "boolean";
+function isEnvelope2(value) {
+  return isRecord4(value) && typeof value.ok === "boolean";
 }
 function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
@@ -13099,7 +13267,7 @@ function parseEnvelope(stdout) {
   const trimmed = stdout.trim();
   try {
     const parsed = JSON.parse(trimmed || "null");
-    if (isEnvelope(parsed)) return parsed;
+    if (isEnvelope2(parsed)) return parsed;
   } catch {
   }
   const lines = stdout.split("\n");
@@ -13108,7 +13276,7 @@ function parseEnvelope(stdout) {
     if (!line) continue;
     try {
       const parsed = JSON.parse(line);
-      if (isEnvelope(parsed)) return parsed;
+      if (isEnvelope2(parsed)) return parsed;
     } catch {
     }
   }
@@ -13121,26 +13289,258 @@ function truncate(value, cap) {
   while (end > 0 && (buf[end] & 192) === 128) end -= 1;
   return buf.subarray(0, end).toString("utf8") + "\n...[truncated]";
 }
+function capResult(result, cap) {
+  const serialized = typeof result === "string" ? result : JSON.stringify(result ?? null);
+  return Buffer.byteLength(serialized, "utf8") <= cap ? result : truncate(serialized, cap);
+}
 function errorFromStdout(stdout) {
   let text = stdout;
   try {
     const parsed = JSON.parse(stdout);
-    if (isRecord3(parsed)) {
+    if (isRecord4(parsed)) {
       text = JSON.stringify(sanitize(parsed)) ?? stdout;
     }
   } catch {
   }
   return text.slice(0, 4096);
 }
+function buildResidentPayload(args, timeoutMs) {
+  return {
+    handler: args.handler,
+    input: args.input,
+    ...args.connection === void 0 ? {} : { connection: args.connection },
+    ...args.connections === void 0 ? {} : { connections: args.connections },
+    context: args.context,
+    timeoutMs
+  };
+}
 var SandboxPluginExecutor = class {
   /**
-   * @param deps - Sandbox resolver and optional logger
+   * @param deps - Sandbox resolver, optional logger, and optional resident routing
    */
   constructor(deps) {
     this.deps = deps;
   }
   /**
-   * Invoke a plugin handler inside the tenant sandbox shell.
+   * Invoke a plugin handler.
+   *
+   * Routes to the published plugin's resident service when {@link
+   * SandboxPluginExecutorDeps.resident} is configured and a deployment is
+   * routable (`running` with an endpoint, or a resumed `onDemand` deployment).
+   * Otherwise, or when the resident call fails and degradation is enabled, runs
+   * the handler as a short `node <handler>` process inside the tenant sandbox.
+   *
+   * @param args - Invocation arguments including manifest, handler, and input
+   * @returns The normalized handler result, exit code, timing, and raw stdout
+   * @throws When `args.handler` is not a safe relative path
+   */
+  async invoke(args) {
+    const started = Date.now();
+    validateRelativePath(args.handler, "handler");
+    if (this.deps.resident) {
+      const resident = await this.tryResident(args, this.deps.resident, started);
+      if (resident) return resident;
+    }
+    return this.invokeShortProcess(args, started);
+  }
+  /**
+   * Attempt to route an invocation to a published plugin's resident service.
+   *
+   * @param args - Invocation arguments
+   * @param resident - Resident routing dependencies
+   * @param started - Invocation start timestamp used for `durationMs`
+   * @returns A terminal result (success, or failure with degradation disabled),
+   *   or `undefined` when the caller should fall back to the short-process path
+   */
+  async tryResident(args, resident, started) {
+    const tenantId2 = args.runConfig?.tenantId ?? args.context.tenantId;
+    const pluginType = args.manifest.type;
+    if (!tenantId2) return void 0;
+    const deployment = await this.lookupDeployment(resident, tenantId2, pluginType);
+    if (!deployment) return void 0;
+    const timeoutMs = clamp(args.timeoutMs ?? DEFAULT_TIMEOUT_MS, MIN_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    const payload = buildResidentPayload(args, timeoutMs);
+    if (deployment.status === "running" && deployment.endpoint) {
+      let outcome = await this.callResident(resident, deployment.endpoint, payload, timeoutMs);
+      if (!outcome.ok && deployment.mode === "onDemand" && resident.ensureRunning) {
+        outcome = await this.ensureRunningAndRetry(
+          resident,
+          tenantId2,
+          pluginType,
+          deployment.endpoint,
+          payload,
+          timeoutMs,
+          outcome
+        );
+      }
+      return this.finalizeResident(outcome, args, resident, pluginType, tenantId2, started);
+    }
+    if (deployment.mode === "onDemand" && resident.ensureRunning) {
+      const outcome = await this.wakeOnDemand(resident, tenantId2, pluginType, payload, timeoutMs);
+      if (outcome) {
+        return this.finalizeResident(outcome, args, resident, pluginType, tenantId2, started);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Normalize a resident invocation outcome into the caller-facing result.
+   *
+   * @param outcome - Normalized resident transport result
+   * @param args - Invocation arguments (for the result-size cap)
+   * @param resident - Resident routing dependencies (degradation policy)
+   * @param pluginType - Plugin type, for diagnostics
+   * @param tenantId - Tenant owning the plugin, for diagnostics
+   * @param started - Invocation start timestamp used for `durationMs`
+   * @returns The normalized result, or `undefined` when the caller should fall
+   *   back to the short-process path
+   */
+  finalizeResident(outcome, args, resident, pluginType, tenantId2, started) {
+    if (outcome.ok) {
+      const cap = clamp(
+        args.maxResultBytes ?? DEFAULT_MAX_RESULT_BYTES,
+        MIN_MAX_RESULT_BYTES,
+        MAX_MAX_RESULT_BYTES
+      );
+      return {
+        ok: true,
+        result: capResult(outcome.result, cap),
+        exitCode: 0,
+        httpStatus: outcome.status,
+        durationMs: Date.now() - started,
+        stdout: "",
+        stderr: ""
+      };
+    }
+    const error = outcome.error ?? "resident plugin invocation failed";
+    if (resident.degradeToShortProcess ?? true) {
+      this.deps.logger?.info(
+        { event: "sandbox-plugin.resident.degrade", pluginType, tenantId: tenantId2, error },
+        "resident plugin invocation failed; falling back to short process"
+      );
+      return void 0;
+    }
+    return {
+      ok: false,
+      error,
+      exitCode: 1,
+      httpStatus: outcome.status,
+      durationMs: Date.now() - started,
+      stdout: "",
+      stderr: ""
+    };
+  }
+  /**
+   * Look up a deployment, degrading to `undefined` when the lookup throws.
+   *
+   * @param resident - Resident routing dependencies
+   * @param tenantId - Tenant owning the plugin
+   * @param pluginType - Plugin type addressed by the invocation
+   * @returns The deployment, or `undefined` when absent or lookup failed
+   */
+  async lookupDeployment(resident, tenantId2, pluginType) {
+    try {
+      return await resident.getDeployment(tenantId2, pluginType);
+    } catch (error) {
+      this.deps.logger?.info(
+        {
+          event: "sandbox-plugin.resident.lookup.failed",
+          pluginType,
+          tenantId: tenantId2,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "resident deployment lookup failed; falling back to short process"
+      );
+      return void 0;
+    }
+  }
+  /**
+   * Resume a non-running `onDemand` deployment once, then invoke it.
+   *
+   * Re-reads the deployment after the resume so a cold-started endpoint is
+   * picked up. Never throws: a failed resume or a deployment that is still not
+   * `running` with an endpoint resolves to `undefined`, letting the caller use
+   * the short-process path.
+   *
+   * @param resident - Resident routing dependencies
+   * @param tenantId - Tenant owning the plugin
+   * @param pluginType - Plugin type addressed by the invocation
+   * @param payload - Invocation payload
+   * @param timeoutMs - Clamped per-call timeout
+   * @returns The resident outcome when routed, or `undefined` to short-process
+   */
+  async wakeOnDemand(resident, tenantId2, pluginType, payload, timeoutMs) {
+    try {
+      await resident.ensureRunning?.(tenantId2, pluginType);
+    } catch (error) {
+      this.deps.logger?.info(
+        {
+          event: "sandbox-plugin.resident.ensure.failed",
+          pluginType,
+          tenantId: tenantId2,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "resident service resume failed; falling back to short process"
+      );
+      return void 0;
+    }
+    const refreshed = await this.lookupDeployment(resident, tenantId2, pluginType);
+    if (!refreshed || refreshed.status !== "running" || !refreshed.endpoint) {
+      return void 0;
+    }
+    return this.callResident(resident, refreshed.endpoint, payload, timeoutMs);
+  }
+  /**
+   * Resume an `onDemand` deployment once and retry the resident call once.
+   *
+   * @param resident - Resident routing dependencies
+   * @param tenantId - Tenant owning the plugin
+   * @param pluginType - Plugin type addressed by the invocation
+   * @param endpoint - Endpoint used by the first attempt
+   * @param payload - Invocation payload
+   * @param timeoutMs - Clamped per-call timeout
+   * @param firstOutcome - Failed first attempt, returned when resume fails
+   * @returns The retry outcome, or `firstOutcome` when resume itself failed
+   */
+  async ensureRunningAndRetry(resident, tenantId2, pluginType, endpoint, payload, timeoutMs, firstOutcome) {
+    try {
+      await resident.ensureRunning?.(tenantId2, pluginType);
+    } catch (error) {
+      this.deps.logger?.info(
+        {
+          event: "sandbox-plugin.resident.ensure.failed",
+          pluginType,
+          tenantId: tenantId2,
+          error: error instanceof Error ? error.message : String(error)
+        },
+        "resident service resume failed"
+      );
+      return firstOutcome;
+    }
+    const refreshed = await this.lookupDeployment(resident, tenantId2, pluginType);
+    return this.callResident(resident, refreshed?.endpoint ?? endpoint, payload, timeoutMs);
+  }
+  /**
+   * Invoke the resident host over the sandbox-service proxy path.
+   *
+   * @param resident - Resident routing dependencies
+   * @param endpointPath - Relative proxy path
+   * @param payload - Invocation payload matching the host contract
+   * @param timeoutMs - Clamped per-call timeout
+   * @returns The normalized resident invocation result
+   */
+  callResident(resident, endpointPath, payload, timeoutMs) {
+    return invokeResident({
+      baseUrl: resident.baseUrl,
+      endpointPath,
+      serviceKey: resident.serviceKey,
+      payload,
+      timeoutMs,
+      fetchImpl: resident.fetchImpl
+    });
+  }
+  /**
+   * Invoke a plugin handler as a short `node <handler>` process.
    *
    * Resolves the sandbox, injects small input as a base64 env var (or writes a
    * temp `input.json` for large input), writes connection credentials to a temp
@@ -13150,12 +13550,10 @@ var SandboxPluginExecutor = class {
    * in all cases, including setup failures.
    *
    * @param args - Invocation arguments including manifest, handler, and input
+   * @param started - Invocation start timestamp used for `durationMs`
    * @returns The normalized handler result, exit code, timing, and raw stdout
-   * @throws When `args.handler` is not a safe relative path
    */
-  async invoke(args) {
-    const started = Date.now();
-    validateRelativePath(args.handler, "handler");
+  async invokeShortProcess(args, started) {
     const pluginDir = `${PLUGINS_ROOT}/${args.manifest.type}`;
     const handlerAbs = `${pluginDir}/${args.handler}`;
     const tenantId2 = args.runConfig?.tenantId ?? args.context.tenantId;
@@ -13243,11 +13641,9 @@ var SandboxPluginExecutor = class {
       }
       const parsed = parseEnvelope(stdout);
       if (parsed) {
-        const result = parsed.ok ? parsed.result : void 0;
-        const serialized = typeof result === "string" ? result : JSON.stringify(result ?? null);
         return {
           ok: parsed.ok,
-          result: Buffer.byteLength(serialized, "utf8") <= cap ? result : truncate(serialized, cap),
+          result: capResult(parsed.ok ? parsed.result : void 0, cap),
           error: typeof parsed.error === "string" ? parsed.error : void 0,
           exitCode,
           durationMs,
@@ -13258,7 +13654,7 @@ var SandboxPluginExecutor = class {
       const text = stdout.trim();
       return {
         ok: true,
-        result: truncate(text, cap),
+        result: capResult(text, cap),
         exitCode,
         durationMs,
         stdout,
@@ -13275,24 +13671,33 @@ var SandboxPluginExecutor = class {
   }
 };
 
+// src/sandbox_plugin/pluginDeploymentServiceRuntime.ts
+var service2 = null;
+function setPluginDeploymentService(instance) {
+  service2 = instance ?? null;
+}
+function getPluginDeploymentService() {
+  return service2;
+}
+
 // src/sandbox_plugin/TenantPluginCatalog.ts
 import { createHash as createHash3 } from "crypto";
 
 // src/sandbox_plugin/jsonSchemaToZod.ts
 import { z as z43 } from "zod";
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function withDescription(schema6, raw) {
-  const description = isRecord4(raw) ? raw.description : void 0;
+  const description = isRecord5(raw) ? raw.description : void 0;
   return typeof description === "string" ? schema6.describe(description) : schema6;
 }
 function jsonSchemaToZod(schema6) {
-  if (!isRecord4(schema6)) throw new Error("schema must be an object");
+  if (!isRecord5(schema6)) throw new Error("schema must be an object");
   const type = schema6.type;
   switch (type) {
     case "object": {
-      const props = isRecord4(schema6.properties) ? schema6.properties : {};
+      const props = isRecord5(schema6.properties) ? schema6.properties : {};
       const required = Array.isArray(schema6.required) ? schema6.required.filter((x) => typeof x === "string") : [];
       const shape = {};
       for (const [key5, sub] of Object.entries(props)) {
@@ -13332,7 +13737,7 @@ var DISPLAY_MODES = ["inline", "fullscreen", "pip"];
 var MAX_MANIFEST_BYTES = 262144;
 var MAX_TOOLS = 32;
 var MAX_PLUGINS_PER_TENANT = 50;
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isSafeHandler(path8) {
@@ -13357,7 +13762,7 @@ function validateSandboxPluginManifest(args) {
   const diagnostics = [];
   const error = (code, message, pluginType, tool68) => diagnostics.push({ level: "error", code, message, pluginType, tool: tool68 });
   const raw = args.raw;
-  if (!isRecord5(raw)) {
+  if (!isRecord6(raw)) {
     error("MANIFEST_NOT_OBJECT", "manifest must be a JSON object", args.dirName);
     return { tools: [], diagnostics };
   }
@@ -13410,7 +13815,7 @@ function validateSandboxPluginManifest(args) {
   const tools = [];
   const seenToolNames = /* @__PURE__ */ new Set();
   for (const candidate of toolCandidates.slice(0, MAX_TOOLS)) {
-    if (!isRecord5(candidate)) {
+    if (!isRecord6(candidate)) {
       error("TOOL_INVALID", "tool must be an object", type);
       continue;
     }
@@ -13427,7 +13832,7 @@ function validateSandboxPluginManifest(args) {
       error("HANDLER_MISSING", `handler "${String(candidate.handler)}" not found`, type, name);
       continue;
     }
-    if (!isRecord5(candidate.schema)) {
+    if (!isRecord6(candidate.schema)) {
       error("TOOL_SCHEMA", `tool "${name}" schema must be an object`, type, name);
       continue;
     }
@@ -13441,17 +13846,17 @@ function validateSandboxPluginManifest(args) {
     let ui;
     if (candidate.ui !== void 0) {
       const rawUi = candidate.ui;
-      if (!isRecord5(rawUi) || !isSafeUiPath(rawUi.resource) || !args.handlerExists(rawUi.resource)) {
+      if (!isRecord6(rawUi) || !isSafeUiPath(rawUi.resource) || !args.handlerExists(rawUi.resource)) {
         error("TOOL_UI", `tool "${name}" ui.resource must be an existing .html file within the plugin dir`, type, name);
       } else {
-        const csp = isRecord5(rawUi.csp) ? {
+        const csp = isRecord6(rawUi.csp) ? {
           connectDomains: Array.isArray(rawUi.csp.connectDomains) ? rawUi.csp.connectDomains.filter((d) => typeof d === "string") : void 0,
           resourceDomains: Array.isArray(rawUi.csp.resourceDomains) ? rawUi.csp.resourceDomains.filter((d) => typeof d === "string") : void 0,
           frameDomains: Array.isArray(rawUi.csp.frameDomains) ? rawUi.csp.frameDomains.filter((d) => typeof d === "string") : void 0,
           baseUriDomains: Array.isArray(rawUi.csp.baseUriDomains) ? rawUi.csp.baseUriDomains.filter((d) => typeof d === "string") : void 0
         } : void 0;
         const displayMode = DISPLAY_MODES.includes(rawUi.displayMode) ? rawUi.displayMode : void 0;
-        const permissions = isRecord5(rawUi.permissions) ? {
+        const permissions = isRecord6(rawUi.permissions) ? {
           camera: rawUi.permissions.camera === true ? true : void 0,
           microphone: rawUi.permissions.microphone === true ? true : void 0,
           geolocation: rawUi.permissions.geolocation === true ? true : void 0,
@@ -13481,7 +13886,7 @@ function validateSandboxPluginManifest(args) {
   }
   const skills = {};
   if (raw.skills !== void 0) {
-    if (!isRecord5(raw.skills)) {
+    if (!isRecord6(raw.skills)) {
       error("SKILLS_INVALID", "skills must be an object", type);
     } else {
       const prefix = `${type}-`;
@@ -13496,12 +13901,12 @@ function validateSandboxPluginManifest(args) {
           error("SKILL_NAME", `skill "${name}" must be a safe relative path prefixed with "${prefix}"`, type);
           continue;
         }
-        if (!isRecord5(definition) || typeof definition.version !== "string" || typeof definition.content !== "string") {
+        if (!isRecord6(definition) || typeof definition.version !== "string" || typeof definition.content !== "string") {
           error("SKILL_INVALID", `skill "${name}" requires string version and content`, type);
           continue;
         }
         if (definition.resources !== void 0) {
-          if (!isRecord5(definition.resources)) {
+          if (!isRecord6(definition.resources)) {
             error("SKILL_RESOURCES", `skill "${name}" resources must be an object`, type);
             continue;
           }
@@ -13513,7 +13918,7 @@ function validateSandboxPluginManifest(args) {
               resourcesOk = false;
               break;
             }
-            if (!isRecord5(resource) || typeof resource.content !== "string") {
+            if (!isRecord6(resource) || typeof resource.content !== "string") {
               resourcesOk = false;
               break;
             }
@@ -13529,11 +13934,11 @@ function validateSandboxPluginManifest(args) {
   }
   const agents = {};
   if (raw.agents !== void 0) {
-    if (!isRecord5(raw.agents)) {
+    if (!isRecord6(raw.agents)) {
       error("AGENTS_INVALID", "agents must be an object", type);
     } else {
       for (const [key5, config] of Object.entries(raw.agents)) {
-        if (!isRecord5(config)) {
+        if (!isRecord6(config)) {
           error("AGENT_INVALID", `agent "${key5}" must be an object`, type);
           continue;
         }
@@ -13554,7 +13959,7 @@ function validateSandboxPluginManifest(args) {
     }
   }
   let connection;
-  if (isRecord5(raw.connection)) {
+  if (isRecord6(raw.connection)) {
     const fields = raw.connection.fields;
     if (!Array.isArray(fields)) {
       error("CONNECTION_INVALID", "connection.fields must be an array", type);
@@ -13568,7 +13973,7 @@ function validateSandboxPluginManifest(args) {
       for (const key5 of ["test", "discover"]) {
         const entry = raw.connection[key5];
         if (entry === void 0) continue;
-        const handler = isRecord5(entry) ? entry.handler : void 0;
+        const handler = isRecord6(entry) ? entry.handler : void 0;
         if (!isSafeHandler(handler) || !args.handlerExists(handler)) {
           error("CONNECTION_HANDLER", `connection.${key5} handler "${String(handler)}" not found`, type);
           continue;
@@ -13586,8 +13991,8 @@ function validateSandboxPluginManifest(args) {
     version: raw.version,
     icon: typeof raw.icon === "string" ? raw.icon : void 0,
     category: typeof raw.category === "string" ? raw.category : void 0,
-    configSchema: isRecord5(raw.configSchema) ? raw.configSchema : void 0,
-    defaultConfig: isRecord5(raw.defaultConfig) ? raw.defaultConfig : void 0,
+    configSchema: isRecord6(raw.configSchema) ? raw.configSchema : void 0,
+    defaultConfig: isRecord6(raw.defaultConfig) ? raw.defaultConfig : void 0,
     connection,
     tools,
     skills: Object.keys(skills).length > 0 ? skills : void 0,
@@ -13767,7 +14172,7 @@ var STANDARD_CONNECTION_DEFAULT_CONFIG = Object.freeze({
   connectAll: false
 });
 var EMPTY_DEFAULT_CONFIG = Object.freeze({});
-function isRecord6(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function runConfigFrom(exeConfig) {
@@ -13857,11 +14262,11 @@ async function runConnectionHandler(executor, manifest, handler, config, tenantI
     return { ok: false, message: result.error ?? "connection test failed" };
   }
   const value = result.result;
-  if (isRecord6(value) && typeof value.ok === "boolean" && typeof value.message === "string") {
+  if (isRecord7(value) && typeof value.ok === "boolean" && typeof value.message === "string") {
     return {
       ok: value.ok,
       message: value.message,
-      details: isRecord6(value.details) ? value.details : void 0
+      details: isRecord7(value.details) ? value.details : void 0
     };
   }
   return { ok: false, message: result.error ?? "connection test returned an invalid result" };
@@ -14214,13 +14619,29 @@ var TenantPluginCatalog = class {
 
 // src/sandbox_plugin/sandboxPluginRuntime.ts
 var catalog = null;
+function buildResidentRouting() {
+  const baseUrl = process.env.MICROSANDBOX_SERVICE_URL;
+  if (!baseUrl) return void 0;
+  return {
+    getDeployment: async (tenantId2, pluginType) => await getPluginDeploymentService()?.getDeployment(tenantId2, pluginType) ?? void 0,
+    ensureRunning: async (tenantId2, pluginType) => {
+      await getPluginDeploymentService()?.ensureRunning(tenantId2, pluginType);
+    },
+    baseUrl,
+    serviceKey: process.env.MICROSANDBOX_API_KEY
+  };
+}
+function buildExecutor(resolveSandbox) {
+  const resident = buildResidentRouting();
+  return new SandboxPluginExecutor({ resolveSandbox, ...resident ? { resident } : {} });
+}
 function emptyCatalog() {
   const resolveSandbox = async () => {
     throw new Error("sandbox manager not configured");
   };
   return new TenantPluginCatalog({
     resolveSandbox,
-    executor: new SandboxPluginExecutor({ resolveSandbox }),
+    executor: buildExecutor(resolveSandbox),
     reservedTypes: () => new Set(PluginRegistry.list())
   });
 }
@@ -14237,7 +14658,7 @@ function getSandboxPluginCatalog() {
   const resolveSandbox = createSandboxResolver((config) => manager.getSandboxFromConfig(config));
   catalog = new TenantPluginCatalog({
     resolveSandbox,
-    executor: new SandboxPluginExecutor({ resolveSandbox }),
+    executor: buildExecutor(resolveSandbox),
     reservedTypes: () => new Set(PluginRegistry.list())
   });
   return catalog;
@@ -14384,23 +14805,23 @@ function toolName(tool68) {
   return typeof tool68.name === "string" ? tool68.name : void 0;
 }
 function schemaHasConnectionKey(schema6) {
-  const definition = isRecord7(schema6._def) ? schema6._def : void 0;
+  const definition = isRecord8(schema6._def) ? schema6._def : void 0;
   const shape = definition?.shape;
   const fields = typeof shape === "function" ? shape() : shape;
-  return isRecord7(fields) && Object.prototype.hasOwnProperty.call(fields, "connectionKey");
+  return isRecord8(fields) && Object.prototype.hasOwnProperty.call(fields, "connectionKey");
 }
 function hasConnectionKeySchema(tool68) {
-  if (!isRecord7(tool68) || !isRecord7(tool68.schema)) return false;
+  if (!isRecord8(tool68) || !isRecord8(tool68.schema)) return false;
   if (schemaHasConnectionKey(tool68.schema)) return true;
-  const definition = isRecord7(tool68.schema._def) ? tool68.schema._def : void 0;
+  const definition = isRecord8(tool68.schema._def) ? tool68.schema._def : void 0;
   if (Array.isArray(definition?.options) && definition.options.length > 0) {
     return definition.options.every(
-      (option) => isRecord7(option) && schemaHasConnectionKey(option)
+      (option) => isRecord8(option) && schemaHasConnectionKey(option)
     );
   }
   return false;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 var CapabilityToolRegistry = class {
@@ -14492,17 +14913,17 @@ var CapabilityToolRegistry = class {
 // src/middlewares/capabilityGuardMiddleware.ts
 import { ToolMessage as ToolMessage5 } from "@langchain/core/messages";
 import { createMiddleware as createMiddleware13 } from "langchain";
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function capabilityRuntimeFromRequest(request) {
-  if (!isRecord8(request) || !isRecord8(request.runtime)) return void 0;
+  if (!isRecord9(request) || !isRecord9(request.runtime)) return void 0;
   const configurable = request.runtime.configurable;
   const context = request.runtime.context;
-  const runConfig = isRecord8(configurable) && isRecord8(configurable.runConfig) ? configurable.runConfig : isRecord8(context) && isRecord8(context.runConfig) ? context.runConfig : void 0;
+  const runConfig = isRecord9(configurable) && isRecord9(configurable.runConfig) ? configurable.runConfig : isRecord9(context) && isRecord9(context.runConfig) ? context.runConfig : void 0;
   if (!runConfig) return void 0;
   const value = runConfig.capabilityRuntime;
-  if (!isRecord8(value) || typeof value.revision !== "string" || !isRecord8(value.middleware)) {
+  if (!isRecord9(value) || typeof value.revision !== "string" || !isRecord9(value.middleware)) {
     return void 0;
   }
   return value;
@@ -14514,10 +14935,10 @@ function hasActiveRuntimePolicy(runtime) {
   return Object.keys(runtime.middleware).length > 0;
 }
 function tenantIdFromRequest(request) {
-  if (!isRecord8(request) || !isRecord8(request.runtime)) return void 0;
+  if (!isRecord9(request) || !isRecord9(request.runtime)) return void 0;
   const configurable = request.runtime.configurable;
   const context = request.runtime.context;
-  const runConfig = isRecord8(configurable) && isRecord8(configurable.runConfig) ? configurable.runConfig : isRecord8(context) && isRecord8(context.runConfig) ? context.runConfig : void 0;
+  const runConfig = isRecord9(configurable) && isRecord9(configurable.runConfig) ? configurable.runConfig : isRecord9(context) && isRecord9(context.runConfig) ? context.runConfig : void 0;
   return runConfig && typeof runConfig.tenantId === "string" ? runConfig.tenantId : void 0;
 }
 async function standardConnectionAllowed(request, capabilityType, config) {
@@ -14525,8 +14946,8 @@ async function standardConnectionAllowed(request, capabilityType, config) {
   const hasConnectAll = Object.prototype.hasOwnProperty.call(config, "connectAll");
   if (!hasConnections && (!hasConnectAll || config.connectAll !== true)) return false;
   const tenantId2 = tenantIdFromRequest(request);
-  const resource = isRecord8(request.toolCall) && isRecord8(request.toolCall.args) ? request.toolCall.args.connectionKey : void 0;
-  const hasConnectionKey = isRecord8(request.toolCall) && isRecord8(request.toolCall.args) && Object.prototype.hasOwnProperty.call(
+  const resource = isRecord9(request.toolCall) && isRecord9(request.toolCall.args) ? request.toolCall.args.connectionKey : void 0;
+  const hasConnectionKey = isRecord9(request.toolCall) && isRecord9(request.toolCall.args) && Object.prototype.hasOwnProperty.call(
     request.toolCall.args,
     "connectionKey"
   );
@@ -14592,10 +15013,10 @@ function createCapabilityGuardMiddleware(registry4) {
           toolName: toolName2
         });
       }
-      const standardConfig = isRecord8(policy.config) ? policy.config : {};
+      const standardConfig = isRecord9(policy.config) ? policy.config : {};
       if (registry4.isStandardConnectionTool(toolName2) && !await standardConnectionAllowed(request, metadata.capabilityType, standardConfig)) {
         const args2 = request.toolCall.args;
-        const resource = isRecord8(args2) && typeof args2.connectionKey === "string" ? args2.connectionKey : void 0;
+        const resource = isRecord9(args2) && typeof args2.connectionKey === "string" ? args2.connectionKey : void 0;
         return denialMessage(request.toolCall, {
           code: "RESOURCE_NOT_ALLOWED",
           message: typeof resource === "string" ? `Resource '${resource}' is not allowed by the capability policy` : "Resource selector 'connectionKey' must be a permitted string",
@@ -14608,8 +15029,8 @@ function createCapabilityGuardMiddleware(registry4) {
       const selector = metadata.resourceSelector;
       const args = request.toolCall.args;
       if (selector) {
-        const resource = isRecord8(args) ? args[selector.argumentField] : void 0;
-        const config = isRecord8(policy.config) ? policy.config : {};
+        const resource = isRecord9(args) ? args[selector.argumentField] : void 0;
+        const config = isRecord9(policy.config) ? policy.config : {};
         const hasExplicitResources = Object.prototype.hasOwnProperty.call(config, selector.configField);
         const allowsAll = !hasExplicitResources && selector.allowAllField !== void 0 && config[selector.allowAllField] === true;
         const allowedResources = config[selector.configField];
@@ -30396,6 +30817,7 @@ function assistantToConfig(assistant) {
     prompt: typeof assistant.graphDefinition === "string" ? assistant.graphDefinition : JSON.stringify(assistant.graphDefinition)
   };
   Object.assign(config, graphDef);
+  if (assistant.ownerUserId !== void 0) config.ownerUserId = assistant.ownerUserId;
   return config;
 }
 var _AgentLatticeManager = class _AgentLatticeManager extends BaseLatticeManager {
@@ -32788,6 +33210,9 @@ var MicrosandboxRemoteInstance = class {
     }
     return "unknown";
   }
+  async getEndpoint(port) {
+    return this.client.getEndpoint(this.name, port);
+  }
   /**
    * Pack a sandbox folder into a sibling ZIP through the microsandbox shell.
    *
@@ -32854,6 +33279,19 @@ var MicrosandboxServiceClient = class {
       method: "GET"
     });
   }
+  /**
+   * Resolve the endpoint for a published guest port of a sandbox.
+   *
+   * @param name - Sandbox name
+   * @param port - Guest port published via `ensureSandbox({ exposePorts })`
+   * @returns The scheme-less endpoint string and optional headers
+   */
+  async getEndpoint(name, port) {
+    return this.request(
+      `/api/sandboxes/${encodeURIComponent(name)}/endpoints/${port}`,
+      { method: "GET" }
+    );
+  }
   async readFile(sandboxName, path8) {
     return this.request("/api/files/read", {
       method: "POST",
@@ -33118,9 +33556,9 @@ var MicrosandboxRemoteProvider = class {
   }
   buildEnsureInput(config) {
     const defaultMicrosandboxRemoteConfig = getDefaultMicrosandboxRemoteConfig();
-    const image = this.config.image ?? defaultMicrosandboxRemoteConfig.image;
+    const image = config.image ?? this.config.image ?? defaultMicrosandboxRemoteConfig.image;
     console.log(
-      `[MicrosandboxRemote] buildEnsureInput image=${image} from=${this.config.image ? "providerConfig" : "defaultConfig"}`
+      `[MicrosandboxRemote] buildEnsureInput image=${image} from=${config.image ? "runConfig" : this.config.image ? "providerConfig" : "defaultConfig"}`
     );
     return {
       image,
@@ -33130,7 +33568,10 @@ var MicrosandboxRemoteProvider = class {
         ...this.config.env,
         ...buildSandboxMetadataEnv(config)
       },
-      volumes: config?.volumes ?? this.buildDefaultVolumes(config)
+      volumes: config?.volumes ?? this.buildDefaultVolumes(config),
+      entrypoint: config.entrypoint,
+      timeoutSeconds: config.timeoutSeconds,
+      exposePorts: config.exposePorts
     };
   }
   buildDefaultVolumes(config) {
@@ -34856,6 +35297,157 @@ async function connectAllChannels(getAdapter, options = {}) {
     }
   }
 }
+async function disconnectAllChannels(getAdapter) {
+  const store = getStoreLattice("default", "channelInstallation").store;
+  const installations = await store.getAllInstallations();
+  console.log(`[disconnectAllChannels] total=${installations.length} enabled=${installations.filter((i) => i.enabled).length}`);
+  for (const inst of installations) {
+    if (!inst.enabled) continue;
+    const adapter = getAdapter(inst.channel);
+    if (!adapter?.disconnect) continue;
+    try {
+      await adapter.disconnect(inst.id);
+    } catch (error) {
+      console.error(`[disconnectAllChannels] disconnect failed: channel=${inst.channel} tenant=${inst.tenantId} id=${inst.id}`, error);
+    }
+  }
+}
+
+// src/channel/ChannelConnectionLeader.ts
+import { randomUUID as randomUUID8 } from "crypto";
+var LEASE_KEY = "leader:channel-connections";
+var ChannelConnectionLeader = class {
+  constructor(deps) {
+    this.holder = null;
+    this.connected = false;
+    this.attempted = false;
+    this.inFlight = null;
+    this.timer = null;
+    this.running = false;
+    this.stopped = false;
+    this.deps = deps;
+    this.ttlMs = deps.ttlMs ?? 6e4;
+    this.retryMs = deps.retryMs ?? Math.max(5e3, Math.floor(this.ttlMs / 3));
+  }
+  /** Starts the ownership loop (immediate tick, then every `retryMs`). */
+  start() {
+    if (this.timer || this.stopped) return;
+    void this.tickOnce();
+    this.timer = setInterval(() => {
+      void this.tickOnce();
+    }, this.retryMs);
+    this.timer.unref?.();
+  }
+  /**
+   * Releases ownership (if held) and disconnects.
+   *
+   * @returns A promise that settles after teardown completes.
+   * @remarks Terminal: a stopped leader does not restart.
+   */
+  async stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.inFlight) await this.inFlight.catch(() => void 0);
+    if (this.holder) {
+      const holder = this.holder;
+      this.holder = null;
+      await this.deps.leaseStore.release(LEASE_KEY, holder).catch((error) => {
+        this.deps.log?.warn("Channel leader lease release failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      });
+    }
+    await this.disconnectChannels();
+  }
+  /**
+   * Runs one ownership/health step. Public for deterministic tests.
+   *
+   * @returns A promise that settles when this step completes.
+   */
+  async tickOnce() {
+    if (this.running || this.stopped) return;
+    this.running = true;
+    const run = this.runTick();
+    this.inFlight = run;
+    try {
+      await run;
+    } finally {
+      if (this.inFlight === run) this.inFlight = null;
+      this.running = false;
+    }
+  }
+  /**
+   * Performs one acquire/renew/step decision.
+   *
+   * @remarks A transient lease-store error while renewing keeps the current
+   * holder and connections intact (retry next tick); only a confirmed
+   * `renewed === false` triggers teardown.
+   */
+  async runTick() {
+    if (this.holder) {
+      let renewed = false;
+      let renewFailed = false;
+      try {
+        renewed = await this.deps.leaseStore.renew(LEASE_KEY, this.holder, this.ttlMs);
+      } catch (error) {
+        renewFailed = true;
+        this.deps.log?.warn("Channel leader lease renew failed", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if (renewFailed) return;
+      if (renewed) {
+        if (!this.connected) await this.connectChannels();
+        return;
+      }
+      await this.loseLeadership();
+    }
+    await this.tryAcquire();
+  }
+  async tryAcquire() {
+    const holder = `${this.deps.owner}#${randomUUID8()}`;
+    const acquired = await this.deps.leaseStore.tryAcquire(LEASE_KEY, holder, this.ttlMs).catch((error) => {
+      this.deps.log?.warn("Channel leader lease acquire failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return false;
+    });
+    if (!acquired) return;
+    this.holder = holder;
+    await this.connectChannels();
+  }
+  async loseLeadership() {
+    this.holder = null;
+    await this.disconnectChannels();
+  }
+  async connectChannels() {
+    this.attempted = true;
+    try {
+      await this.deps.connect();
+      this.connected = true;
+    } catch (error) {
+      this.connected = false;
+      this.deps.log?.warn("Channel leader connect failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  async disconnectChannels() {
+    if (!this.attempted) return;
+    this.attempted = false;
+    this.connected = false;
+    try {
+      await this.deps.disconnect();
+    } catch (error) {
+      this.deps.log?.warn("Channel leader disconnect failed", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+};
 
 // src/eval_lattice/LatticeEval.ts
 import { HumanMessage as HumanMessage5 } from "@langchain/core/messages";
@@ -36316,7 +36908,7 @@ function getCoordinationLeaseStore() {
 }
 
 // src/services/withLease.ts
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 var LeaseAcquisitionTimeoutError = class extends Error {
   /**
    * @param key Lease key that could not be acquired.
@@ -36341,7 +36933,7 @@ async function withLease(store, key5, ownerLabel, fn, options = {}) {
   const acquireTimeoutMs = options.acquireTimeoutMs ?? 1e4;
   const retryDelayMs = options.retryDelayMs ?? 50;
   const heartbeatMs = options.heartbeatMs ?? Math.max(1e3, Math.floor(ttlMs / 3));
-  const holder = `${ownerLabel}#${randomUUID8()}`;
+  const holder = `${ownerLabel}#${randomUUID9()}`;
   const deadline = Date.now() + acquireTimeoutMs;
   for (; ; ) {
     if (await store.tryAcquire(key5, holder, ttlMs)) break;
@@ -36440,7 +37032,7 @@ function createTrustedAgentMessageDispatcher(resolve4) {
 }
 
 // src/services/RoomAgentMessageService.ts
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import { snapshotExactArray, snapshotExactRecord as snapshotExactRecord5 } from "@axiom-lattice/protocols";
 var INPUT_KEYS = [
   "tenantId",
@@ -36528,7 +37120,7 @@ var RoomAgentMessageService = class {
       throw new Error("Invalid project room membership");
     }
     const candidate = {
-      id: (this.deps.idFactory ?? randomUUID9)(),
+      id: (this.deps.idFactory ?? randomUUID10)(),
       tenantId: input.tenantId,
       workspaceId: input.workspaceId,
       projectId: input.projectId,
@@ -39115,7 +39707,7 @@ function createTaskLifecycleService(deps) {
 }
 
 // src/services/TaskExecutionService.ts
-import { randomUUID as randomUUID11 } from "crypto";
+import { randomUUID as randomUUID12 } from "crypto";
 import { isDeepStrictEqual as isDeepStrictEqual2 } from "util";
 import { isExecutionResultEventKey as isExecutionResultEventKey2 } from "@axiom-lattice/protocols";
 
@@ -39438,13 +40030,13 @@ async function reconcileAllTenantTaskRuns(input) {
 }
 
 // src/services/taskRunLease.ts
-import { randomUUID as randomUUID10 } from "crypto";
+import { randomUUID as randomUUID11 } from "crypto";
 function taskRunLeaseKey(taskId) {
   return `task-run:${taskId}`;
 }
 async function tryAcquireTaskRun(input) {
   const key5 = taskRunLeaseKey(input.taskId);
-  const holder = `${input.owner}#${randomUUID10()}`;
+  const holder = `${input.owner}#${randomUUID11()}`;
   if (!await input.store.tryAcquire(key5, holder, input.ttlMs)) return null;
   const heartbeatMs = input.heartbeatMs ?? Math.max(1e3, Math.floor(input.ttlMs / 3));
   let released = false;
@@ -39811,11 +40403,11 @@ function createTaskExecutionService(deps) {
     let threadId;
     let runId;
     try {
-      threadId = storedThreadId ?? (deps.createThreadId ?? randomUUID11)();
+      threadId = storedThreadId ?? (deps.createThreadId ?? randomUUID12)();
       if (task.status === "interrupted" && reuseCurrentRun) {
         runId = storedRunId;
       } else if (task.status === "interrupted" || task.status === "failed") {
-        runId = (deps.createRunId ?? randomUUID11)();
+        runId = (deps.createRunId ?? randomUUID12)();
       }
     } catch (error) {
       return {
@@ -40074,11 +40666,11 @@ function createTaskExecutionService(deps) {
 }
 
 // src/services/leadership.ts
-import { randomUUID as randomUUID12 } from "crypto";
+import { randomUUID as randomUUID13 } from "crypto";
 async function runAsLeader(store, name, fn, options = {}) {
   const key5 = `leader:${name}`;
   const owner2 = options.owner ?? getReplicaId();
-  const holder = `${owner2}#${randomUUID12()}`;
+  const holder = `${owner2}#${randomUUID13()}`;
   const ttlMs = options.ttlMs ?? 6e4;
   if (!await store.tryAcquire(key5, holder, ttlMs)) return { ran: false };
   const heartbeat = setInterval(() => {
@@ -41311,16 +41903,16 @@ function createAskUserToClarifyTool() {
 }
 
 // src/middlewares/askUserClarifyMiddleware.ts
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isProjectRoomRun(request) {
-  if (!isRecord9(request) || !isRecord9(request.runtime)) return false;
+  if (!isRecord10(request) || !isRecord10(request.runtime)) return false;
   const runtime = request.runtime;
-  const configurable = isRecord9(runtime.configurable) ? runtime.configurable.runConfig : void 0;
-  const context = isRecord9(runtime.context) ? runtime.context.runConfig : void 0;
-  const runConfig = isRecord9(configurable) ? configurable : isRecord9(context) ? context : void 0;
-  return isRecord9(runConfig?.projectRoom);
+  const configurable = isRecord10(runtime.configurable) ? runtime.configurable.runConfig : void 0;
+  const context = isRecord10(runtime.context) ? runtime.context.runConfig : void 0;
+  const runConfig = isRecord10(configurable) ? configurable : isRecord10(context) ? context : void 0;
+  return isRecord10(runConfig?.projectRoom);
 }
 function createAskUserClarifyMiddleware() {
   return createMiddleware21({
@@ -42765,15 +43357,16 @@ function executorString(value) {
 }
 async function renderAvailableExecutors(rc, tenantId2) {
   const authority = classifyTaskAuthority(rc);
-  const governed = authority.kind === "projectRoom" || authority.kind === "projectTask";
-  const projectId = governed ? (authority.trusted.projectTask ?? authority.trusted.projectRoom)?.projectId : void 0;
-  const cacheKey = `${tenantId2}:${governed ? `project:${projectId ?? ""}` : "ordinary"}`;
+  const trusted = authority.kind === "projectRoom" || authority.kind === "projectTask" ? authority.trusted : void 0;
+  const useRoster = trusted !== void 0 && !trustedRosterExempt(trusted);
+  const projectId = trusted ? (trusted.projectTask ?? trusted.projectRoom)?.projectId : void 0;
+  const cacheKey = `${tenantId2}:${useRoster ? `project:${projectId ?? ""}` : "tenant"}`;
   const cached2 = executorCache.get(cacheKey);
   const now = Date.now();
   if (cached2 && now - cached2.at < EXECUTOR_CACHE_TTL_MS) return cached2.text;
   const lines = [];
   try {
-    if (governed && projectId) {
+    if (useRoster && projectId) {
       const store = getStoreLattice("default", "projectBotMembership").store;
       if (typeof store.list === "function") {
         const bots = await store.list(tenantId2, projectId);
@@ -42788,11 +43381,15 @@ async function renderAvailableExecutors(rc, tenantId2) {
         }
       }
     } else {
+      const exempt = trusted !== void 0 && trustedRosterExempt(trusted) ? trusted : void 0;
+      const excluded = exempt ? await excludedRosterExecutors(exempt) : /* @__PURE__ */ new Set();
       const configs = await agentLatticeManager.getAllAgentConfigsByTenant(tenantId2);
       for (const config of configs.slice(0, 40)) {
         const row = config;
         const id = executorString(row.key);
         if (!id) continue;
+        if (row.ownerUserId !== void 0) continue;
+        if (excluded.has(id)) continue;
         const name = executorString(row.name);
         const description = executorString(row.description);
         lines.push(`- ${id}${name ? ` \u2014 ${name}` : ""}${description ? ` (${description.slice(0, 120)})` : ""}`);
@@ -42804,7 +43401,7 @@ async function renderAvailableExecutors(rc, tenantId2) {
     executorCache.set(cacheKey, { at: now, text: "" });
     return "";
   }
-  const header = governed ? "## Available task executors (Project roster)" : "## Available task executors";
+  const header = useRoster ? "## Available task executors (Project roster)" : "## Available task executors";
   const text = `
 
 ${header}
@@ -42816,6 +43413,22 @@ ${lines.join("\n")}
   executorCache.set(cacheKey, { at: now, text });
   return text;
 }
+async function excludedRosterExecutors(trusted) {
+  const excluded = /* @__PURE__ */ new Set();
+  const context = trusted.projectTask ?? trusted.projectRoom;
+  if (!context) return excluded;
+  try {
+    const store = getStoreLattice("default", "projectBotMembership").store;
+    if (typeof store.list !== "function") return excluded;
+    const rows = await store.list(context.tenantId, context.projectId);
+    for (const row of Array.isArray(rows) ? rows : []) {
+      const record = row;
+      if (record.status !== "active" && typeof record.assistantId === "string") excluded.add(record.assistantId);
+    }
+  } catch {
+  }
+  return excluded;
+}
 function delegatedTaskScopeError(taskId) {
   return JSON.stringify({
     success: false,
@@ -42865,7 +43478,7 @@ function trustedRosterScope(trusted) {
   };
 }
 function trustedRosterExempt(trusted) {
-  return trusted.projectTask?.rosterExempt === true;
+  return trusted.projectTask?.rosterExempt === true || trusted.projectRoom?.rosterExempt === true;
 }
 async function requireTrustedOwner(trusted, targetAssistantId) {
   const context = trusted.projectTask ?? trusted.projectRoom;
@@ -42881,6 +43494,17 @@ async function requireTrustedOwner(trusted, targetAssistantId) {
     targetAssistantId
   });
 }
+async function rosterExemptOwnerError(tenantId2, targetAssistantId) {
+  try {
+    const lattice = await agentLatticeManager.getOrLoadWithTenant(tenantId2, targetAssistantId);
+    if (lattice && lattice.config.ownerUserId === void 0) return void 0;
+  } catch {
+  }
+  return projectPolicyError(new ProjectTaskOwnerPolicyError(
+    "PROJECT_TASK_OWNER_INACTIVE",
+    "Target Project task owner is not a shared agent of this tenant."
+  ));
+}
 function trustedTaskContextFailure(task, trusted) {
   if (task.tenantId === trusted.tenantId && task.workspaceId === trusted.workspaceId && task.projectId === trusted.projectId) return void 0;
   return JSON.stringify({
@@ -43485,6 +44109,12 @@ function createTaskMiddleware(options = {}) {
                 "Target Project task owner is not active in the exact roster."
               ));
             }
+          } else {
+            const ownerError = await rosterExemptOwnerError(
+              (trustedProject.projectTask ?? trustedProject.projectRoom)?.tenantId ?? tenantId2,
+              ownerId
+            );
+            if (ownerError) return ownerError;
           }
         }
         if (!delegatedTaskId && (typeof effectiveOwnerId !== "string" || effectiveOwnerId.length === 0)) {
@@ -43546,6 +44176,12 @@ function createTaskMiddleware(options = {}) {
               } catch (error) {
                 return projectPolicyError(error);
               }
+            } else {
+              const ownerError = await rosterExemptOwnerError(
+                (trustedProject.projectTask ?? trustedProject.projectRoom)?.tenantId ?? tenantId2,
+                ownerId
+              );
+              if (ownerError) return ownerError;
             }
           }
           return store.create({
@@ -44593,7 +45229,7 @@ function createTaskMiddleware(options = {}) {
     }
     const callerAssistantId = rc.assistant_id;
     const agentId = input.agentId === "general-purpose" && callerAssistantId ? `${callerAssistantId}-general-purpose` : input.agentId;
-    const service2 = createTaskExecutionService({
+    const service3 = createTaskExecutionService({
       taskStore: getTaskStore(),
       workItemStore: getTaskWorkItemStore(),
       resolveAgent: async (targetTenantId, agentId2) => !!await agentLatticeManager.getOrLoadWithTenant(targetTenantId, agentId2),
@@ -44618,7 +45254,7 @@ function createTaskMiddleware(options = {}) {
       }
     });
     const trustedCaller = authority.kind === "projectTask" || authority.kind === "projectRoom" ? authority.trusted.projectTask ?? authority.trusted.projectRoom : void 0;
-    return JSON.stringify(await service2.start({
+    return JSON.stringify(await service3.start({
       tenantId: tenantId2,
       workspaceId: rc.workspaceId,
       projectId: rc.projectId,
@@ -46140,6 +46776,24 @@ function snapshotMembership3(value) {
 function snapshotRows(value) {
   return snapshotExactArray2(value) ?? [];
 }
+async function rosterExemptMembershipProjection(scope) {
+  const excluded = /* @__PURE__ */ new Set();
+  const roles = /* @__PURE__ */ new Map();
+  try {
+    const rows = snapshotRows(await getStoreLattice("default", "projectBotMembership").store.list(scope.tenantId, scope.projectId));
+    for (const row of rows) {
+      const member = snapshotMembership3(row);
+      if (!member) continue;
+      if (member.status !== "active") {
+        excluded.add(member.assistantId);
+        continue;
+      }
+      roles.set(member.assistantId, member.role);
+    }
+  } catch {
+  }
+  return { excluded, roles };
+}
 async function hasActiveCurrentMembership(scope) {
   const memberships = getStoreLattice("default", "projectBotMembership").store;
   const member = snapshotMembership3(await memberships.findById(scope.tenantId, scope.membershipId));
@@ -46156,11 +46810,11 @@ function createProjectRoomMiddleware() {
         if (!scope) return CONTEXT_REQUIRED;
         const digest = createHash7("sha256").update(text).digest("hex");
         try {
-          const service2 = new RoomAgentMessageService({
+          const service3 = new RoomAgentMessageService({
             memberships: getStoreLattice("default", "projectBotMembership").store,
             messages: getStoreLattice("default", "projectRoomMessage").store
           });
-          await service2.post({
+          await service3.post({
             tenantId: scope.tenantId,
             workspaceId: scope.workspaceId,
             projectId: scope.projectId,
@@ -46186,6 +46840,25 @@ function createProjectRoomMiddleware() {
         if (!scope) return CONTEXT_REQUIRED;
         try {
           if (!await hasActiveCurrentMembership(scope)) return CONTEXT_REQUIRED;
+          if (scope.rosterExempt === true) {
+            const { excluded, roles } = await rosterExemptMembershipProjection(scope);
+            const configs = await agentLatticeManager.getAllAgentConfigsByTenant(scope.tenantId);
+            const members2 = configs.filter((entry) => entry.ownerUserId === void 0).filter((entry) => {
+              const key5 = entry.key;
+              return typeof key5 === "string" && !excluded.has(key5);
+            }).map((entry) => {
+              const row = entry;
+              const name = typeof row.name === "string" ? row.name : "";
+              const assistantId = typeof row.key === "string" ? row.key : "";
+              return {
+                assistantId,
+                mentionName: name,
+                title: name,
+                role: roles.get(assistantId) ?? "specialist"
+              };
+            }).filter((member) => member.assistantId !== "" && member.mentionName !== "").sort((left, right) => left.assistantId < right.assistantId ? -1 : left.assistantId > right.assistantId ? 1 : 0);
+            return JSON.stringify({ success: true, members: members2 });
+          }
           const rows = await getStoreLattice("default", "projectBotMembership").store.list(scope.tenantId, scope.projectId);
           const members = snapshotRows(rows).map(snapshotMembership3).filter((member) => member !== void 0 && member.status === "active" && member.tenantId === scope.tenantId && member.workspaceId === scope.workspaceId && member.projectId === scope.projectId && member.roomId === scope.roomId).sort((left, right) => left.joinedAt.getTime() - right.joinedAt.getTime() || (left.id < right.id ? -1 : left.id > right.id ? 1 : 0)).map((member) => ({
             assistantId: member.assistantId,
@@ -46933,6 +47606,70 @@ Fall back to \`execute_code\`/\`shell\` to run \`node handlers/x.js\` manually w
 \`PLUGIN_INPUT\` and a synthetic \`PLUGIN_CONNECTION_FILE\` to reproduce logic bugs.
 A synthetic fixture only verifies plumbing \u2014 a real upstream call requires a real
 \`connectionKey\` configured by a human.
+`,
+    resources: {}
+  },
+  "sandbox-plugins-deploy": {
+    version: "1.0.0",
+    content: `---
+name: sandbox-plugins-deploy
+description: Deploy a validated tenant plugin as a resident service (alwaysOn vs onDemand), check its status, and undeploy it. Trigger: after a plugin's tests pass and it should run as a long-lived service, or when inspecting/removing a deployment.
+---
+
+# Deploying a Plugin as a Resident Service
+
+By default a plugin handler runs as a short-lived process on each tool call.
+Optionally, you can **deploy** the plugin as a **resident service**: one
+long-lived sandbox per plugin that serves every call. This is faster for
+frequent or heavy calls, but costs a running sandbox.
+
+## Precondition: tests must pass first
+Deploy ONLY after the plugin is validated AND its tests pass:
+1. \`manage_plugin validate\` \u2014 no diagnostics.
+2. \`manage_plugin create\`/\`update\` \u2014 written and reloaded.
+3. \`manage_plugin test\` \u2014 every tool/connection test returns \`ok: true\`
+   (a real \`connectionKey\` test for credentialed tools).
+Never deploy a plugin you have not tested: a resident service wraps the same
+handlers, so an untested handler fails identically \u2014 just in a service you now
+have to undeploy.
+
+## Choose a mode
+- \`"onDemand"\` (default) \u2014 the service is paused when idle and resumed on the
+  next call. Best for plugins used occasionally. Lower steady cost.
+- \`"alwaysOn"\` \u2014 the service stays resident and is restarted if it becomes
+  unhealthy. Best for plugins on a hot path or with expensive startup.
+
+## Deploy
+\`\`\`jsonc
+{ "action": "deploy", "type": "my-plugin", "mode": "alwaysOn" }
+\`\`\`
+Returns \`{ deployed, status, endpoint, mode }\`. \`status\` is \`"running"\` when
+the service answered its health check. On failure you get
+\`{ deployed: false, error }\` \u2014 report it, do not treat it as success.
+Deploying again is idempotent: it reuses the same service.
+
+## Check status
+\`\`\`jsonc
+{ "action": "status", "type": "my-plugin" }
+\`\`\`
+Returns \`{ status, endpoint?, mode?, lastHealthAt?, lastError? }\`. \`"absent"\`
+means no deployment exists; \`"failed"\` (with \`lastError\`) means the service is
+down. Inspect this before reporting the plugin as serving.
+
+## Undeploy
+\`\`\`jsonc
+{ "action": "undeploy", "type": "my-plugin" }
+\`\`\`
+Returns \`{ undeployed }\`. Undeploy removes the resident sandbox and its
+deployment record; the plugin files and manifest are untouched, so tool calls
+fall back to the short-process path. Use it to stop paying for a service you no
+longer need.
+
+## When resident services are unavailable
+If the environment has no deployment service registered, deploy/undeploy/status
+return a diagnostic (\`{ deployed: false, error }\` etc.) instead of throwing.
+That is not a plugin defect: the plugin still works through the default
+short-process path, so report it as not-deployed rather than broken.
 `,
     resources: {}
   }
@@ -46969,9 +47706,197 @@ the connector and give you its key. Only after a real \`connectionKey\` test
 passes may you call the tool verified; without it, report functionality as
 unverified (missing credentials), not as passing. Use \`shell_exec\` (the tool
 provided by the \`code_eval\` middleware) to run \`node handlers/x.js\` for manual
-checks when reproducing a failure.`;
+checks when reproducing a failure.
+
+After the plugin passes \`validate\` and its tests, deploy it as a resident
+service: load "sandbox-plugins-deploy" and follow it. Choose \`onDemand\`
+(default) or \`alwaysOn\` for hot paths, call \`manage_plugin deploy\` with the
+chosen \`mode\`, then confirm with \`manage_plugin status\` (\`running\`). Only claim
+the plugin is deployed and serving once \`status\` reports \`running\`; if the
+environment reports no deployment service, say so and treat deployment as
+unavailable \u2014 do NOT claim success. \`undeploy\` removes the service without
+touching the plugin files.`;
+
+// src/middlewares/sandboxPluginsUi.ts
+var SANDBOX_PLUGINS_UI_RESOURCE = "ui://sandbox-plugins/app";
+var SANDBOX_PLUGINS_APP_HTML = `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Plugin Deployments</title>
+    <style>
+      :root { color-scheme: light dark; }
+      * { box-sizing: border-box; }
+      body {
+        margin: 0;
+        padding: 14px 16px;
+        font-family: Inter, -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+        font-size: 13px;
+        color: #1f2430;
+        background: transparent;
+      }
+      h1 { font-size: 14px; font-weight: 600; margin: 0 0 2px; }
+      .subtitle { color: #6b7280; font-size: 12px; margin: 0 0 12px; }
+      table { width: 100%; border-collapse: collapse; }
+      th, td { text-align: left; padding: 8px 10px; border-bottom: 1px solid #eceef2; vertical-align: top; }
+      th { font-size: 11px; text-transform: uppercase; letter-spacing: 0.04em; color: #6b7280; font-weight: 600; }
+      td.type { font-family: ui-monospace, SFMono-Regular, Menlo, monospace; font-weight: 600; white-space: nowrap; }
+      td.mode { white-space: nowrap; color: #4b5563; }
+      td.detail { color: #4b5563; word-break: break-word; max-width: 280px; }
+      .muted { color: #9ca3af; }
+      .status { display: inline-flex; align-items: center; gap: 6px; white-space: nowrap; }
+      .dot { width: 8px; height: 8px; border-radius: 50%; flex: 0 0 auto; background: #9ca3af; }
+      .dot.running { background: #22c55e; }
+      .dot.failed { background: #ef4444; }
+      .dot.requested, .dot.provisioning, .dot.stopping { background: #f59e0b; }
+      .dot.paused, .dot.stopped { background: #94a3b8; }
+      .state { color: #6b7280; padding: 14px 2px; }
+      .error { margin: 0 0 10px; padding: 8px 10px; border-radius: 8px; background: #fef2f2; color: #b91c1c; }
+    </style>
+  </head>
+  <body>
+    <h1>Plugin Deployments</h1>
+    <p class="subtitle">Resident services deployed for this tenant. Read-only.</p>
+    <div id="root"><p class="state">Loading\u2026</p></div>
+    <script>
+      (function () {
+        var root = document.getElementById("root");
+
+        function post(message) {
+          window.parent.postMessage(message, "*");
+        }
+        function notify(method, params) {
+          post({ jsonrpc: "2.0", method: method, params: params });
+        }
+        var nextId = 1;
+        function rpc(method, params) {
+          var id = nextId++;
+          return new Promise(function (resolve, reject) {
+            function onMessage(event) {
+              var data = event.data;
+              if (!data || data.id !== id) return;
+              window.removeEventListener("message", onMessage);
+              if (data.error) reject(new Error((data.error && data.error.message) || "rpc error"));
+              else resolve(data.result);
+            }
+            window.addEventListener("message", onMessage);
+            post({ jsonrpc: "2.0", id: id, method: method, params: params });
+          });
+        }
+
+        function sendSize() {
+          var width = Math.ceil(document.documentElement.scrollWidth || document.body.scrollWidth);
+          var height = Math.ceil(document.documentElement.scrollHeight || document.body.scrollHeight);
+          notify("ui/notifications/size-changed", { width: width, height: height });
+        }
+
+        function esc(value) {
+          return String(value === null || value === undefined ? "" : value).replace(/[&<>"']/g, function (ch) {
+            return { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" }[ch];
+          });
+        }
+
+        function statusClass(status) {
+          switch (status) {
+            case "running": return "running";
+            case "failed": return "failed";
+            case "requested":
+            case "provisioning":
+            case "stopping": return "requested";
+            case "paused":
+            case "stopped": return "paused";
+            default: return "";
+          }
+        }
+
+        function healthCell(item) {
+          if (item.lastError) return '<span style="color:#b91c1c">' + esc(item.lastError) + "</span>";
+          if (item.lastHealthAt) return '<span class="muted">' + esc(item.lastHealthAt) + "</span>";
+          return '<span class="muted">\u2014</span>';
+        }
+
+        function render(payload) {
+          var deployments = payload && Array.isArray(payload.deployments) ? payload.deployments : [];
+          var error = payload && payload.error ? String(payload.error) : "";
+          var html = "";
+          if (error) html += '<div class="error">' + esc(error) + "</div>";
+          if (deployments.length === 0) {
+            html += '<p class="state">' + (error ? "No deployments available." : "No resident plugin deployments.") + "</p>";
+            root.innerHTML = html;
+            sendSize();
+            return;
+          }
+          html += "<table><thead><tr><th>Plugin</th><th>Status</th><th>Mode</th><th>Endpoint</th><th>Health</th></tr></thead><tbody>";
+          deployments.forEach(function (item) {
+            var status = item && item.status ? String(item.status) : "unknown";
+            html += "<tr>";
+            html += '<td class="type">' + esc(item && item.pluginType) + "</td>";
+            html += '<td><span class="status"><span class="dot ' + statusClass(status) + '"></span>' + esc(status) + "</span></td>";
+            html += '<td class="mode">' + esc(item && item.mode) + "</td>";
+            html += '<td class="detail">' + (item && item.endpoint ? esc(item.endpoint) : '<span class="muted">\u2014</span>') + "</td>";
+            html += '<td class="detail">' + healthCell(item || {}) + "</td>";
+            html += "</tr>";
+          });
+          html += "</tbody></table>";
+          root.innerHTML = html;
+          sendSize();
+        }
+
+        function readResult(params) {
+          if (!params || typeof params !== "object") return null;
+          if (params.structuredContent && typeof params.structuredContent === "object") {
+            return params.structuredContent;
+          }
+          var content = params.content;
+          var text = content && content[0] && typeof content[0].text === "string" ? content[0].text : "";
+          if (!text) return null;
+          try { return JSON.parse(text); } catch (err) { return null; }
+        }
+
+        // 1) Register the tool-result listener BEFORE initializing so the data
+        // the host pushes right after the handshake is never missed.
+        window.addEventListener("message", function (event) {
+          var data = event.data;
+          if (!data || typeof data !== "object" || typeof data.method !== "string") return;
+          if (data.method === "ui/notifications/tool-result") {
+            render(readResult(data.params));
+          }
+        });
+
+        if (typeof ResizeObserver !== "undefined") {
+          new ResizeObserver(sendSize).observe(document.documentElement);
+        } else {
+          window.addEventListener("resize", sendSize);
+        }
+
+        // 2) MCP Apps lifecycle: initialize, then signal readiness. The host
+        // pushes tool data only after this completes.
+        rpc("ui/initialize", {
+          protocolVersion: "2025-06-18",
+          capabilities: {},
+          clientInfo: { name: "sandbox-plugins-ui", version: "1.0.0" },
+          appCapabilities: { availableDisplayModes: ["inline"] }
+        }).then(function () {
+          notify("ui/notifications/initialized", {});
+          sendSize();
+        }).catch(function (err) {
+          root.innerHTML = '<p class="state">Failed to initialize: ' + esc((err && err.message) || err) + "</p>";
+          sendSize();
+        });
+      })();
+    </script>
+  </body>
+</html>
+`;
 
 // src/middlewares/sandboxPluginsMiddleware.ts
+var SANDBOX_PLUGINS_UI_REF = {
+  kind: "plugin",
+  pluginType: "sandbox-plugins",
+  resource: SANDBOX_PLUGINS_UI_RESOURCE,
+  displayMode: "inline"
+};
 var PLUGIN_BUILDER_SKILLS = [...Object.keys(SANDBOX_PLUGIN_SKILLS), "task-tracking"];
 function tenantIdFrom(exeConfig) {
   const c = exeConfig;
@@ -46989,6 +47914,15 @@ function collectSecretValues(connection, fields) {
 function errorText(err) {
   return err instanceof Error ? err.message : String(err);
 }
+function deploymentUnavailable(action) {
+  const error = `plugin deployment service is not configured; cannot ${action}. Resident plugin services are unavailable in this environment.`;
+  if (action === "undeploy") return JSON.stringify({ undeployed: false, error });
+  if (action === "status") return JSON.stringify({ status: "unavailable", error });
+  return JSON.stringify({ deployed: false, error });
+}
+function deploymentsResult(payload) {
+  return appendUiFence(JSON.stringify(payload), SANDBOX_PLUGINS_UI_REF);
+}
 function redactString(value, secrets) {
   let out = value;
   for (const secret of secrets) out = out.split(secret).join("[redacted]");
@@ -47009,10 +47943,24 @@ function redactSecretValues(payload, secrets) {
   return walk(payload);
 }
 var managePluginSchema = z73.object({
-  action: z73.enum(["list", "get", "validate", "create", "update", "delete", "reload", "test"]),
+  action: z73.enum([
+    "list",
+    "get",
+    "validate",
+    "create",
+    "update",
+    "delete",
+    "reload",
+    "test",
+    "deploy",
+    "undeploy",
+    "status",
+    "deployments"
+  ]),
   type: z73.string().optional(),
   manifest: z73.record(z73.unknown()).optional(),
   handlers: z73.record(z73.string()).optional(),
+  mode: z73.enum(["onDemand", "alwaysOn"]).optional(),
   target: z73.object({
     kind: z73.enum(["tool", "connection-test", "connection-discover"]),
     name: z73.string().optional(),
@@ -47025,9 +47973,18 @@ var sandboxPluginsPlugin = {
     type: "sandbox-plugins",
     category: "execution",
     name: "Sandbox Plugins",
-    description: "Author and manage tenant plugins stored in the sandbox: list/validate/create/update/delete/reload/test. Tools are agent-callable JS handlers and may declare an optional interactive HTML UI (rendered as a sandboxed MCP App). Pairs with the Skill plugin for authoring guidance.",
+    description: "Author and manage tenant plugins stored in the sandbox: list/validate/create/update/delete/reload/test, and deploy/undeploy/status/deployments to run a plugin as a resident service. Tools are agent-callable JS handlers and may declare an optional interactive HTML UI (rendered as a sandboxed MCP App). Pairs with the Skill plugin for authoring guidance.",
     recommends: ["skill"],
-    tools: [{ name: "manage_plugin", description: "Author and manage tenant sandbox plugins (tools, optional per-tool HTML UI, connections, and Open/MCP exposure)" }],
+    tools: [
+      {
+        name: "manage_plugin",
+        description: "Author and manage tenant sandbox plugins (tools, optional per-tool HTML UI, connections, Open/MCP exposure, and resident deployment). Actions: list/get/validate/create/update/delete/reload/test, deploy/undeploy/status, and `deployments` to list every resident deployment for the tenant.",
+        ui: { resource: SANDBOX_PLUGINS_UI_RESOURCE, displayMode: "inline" }
+      }
+    ],
+    uiResources: {
+      [SANDBOX_PLUGINS_UI_RESOURCE]: { html: SANDBOX_PLUGINS_APP_HTML }
+    },
     configSchema: { type: "object", properties: {} },
     defaultConfig: {}
   },
@@ -47048,7 +48005,7 @@ var sandboxPluginsPlugin = {
           id: "sandbox-plugins",
           type: "sandbox-plugins",
           name: "Sandbox Plugins",
-          description: "Author and manage tenant plugins (list/validate/create/update/delete/reload/test)",
+          description: "Author and manage tenant plugins (list/validate/create/update/delete/reload/test/deploy/undeploy/status)",
           enabled: true,
           config: {}
         },
@@ -47244,13 +48201,74 @@ var sandboxPluginsPlugin = {
                 return JSON.stringify(redactSecretValues({ ok: false, error: errorText(err) }, secrets));
               }
             }
+            case "deploy": {
+              if (!input.type) return "type is required";
+              const service3 = getPluginDeploymentService();
+              if (!service3) return deploymentUnavailable("deploy");
+              try {
+                const result = await service3.deploy(tenantId2, input.type, {
+                  ...input.mode === void 0 ? {} : { mode: input.mode }
+                });
+                return JSON.stringify({
+                  deployed: true,
+                  status: result.status,
+                  endpoint: result.endpoint,
+                  mode: result.mode
+                });
+              } catch (err) {
+                return JSON.stringify({ deployed: false, error: errorText(err) });
+              }
+            }
+            case "undeploy": {
+              if (!input.type) return "type is required";
+              const service3 = getPluginDeploymentService();
+              if (!service3) return deploymentUnavailable("undeploy");
+              try {
+                const result = await service3.undeploy(tenantId2, input.type);
+                return JSON.stringify({ undeployed: result.undeployed });
+              } catch (err) {
+                return JSON.stringify({ undeployed: false, error: errorText(err) });
+              }
+            }
+            case "status": {
+              if (!input.type) return "type is required";
+              const service3 = getPluginDeploymentService();
+              if (!service3) return deploymentUnavailable("status");
+              try {
+                const result = await service3.status(tenantId2, input.type);
+                return JSON.stringify({
+                  status: result.status,
+                  endpoint: result.endpoint,
+                  mode: result.mode,
+                  lastHealthAt: result.lastHealthAt,
+                  lastError: result.lastError
+                });
+              } catch (err) {
+                return JSON.stringify({ status: "unavailable", error: errorText(err) });
+              }
+            }
+            case "deployments": {
+              const service3 = getPluginDeploymentService();
+              if (!service3) {
+                return deploymentsResult({
+                  deployments: [],
+                  error: "plugin deployment service is not configured; cannot list deployments. Resident plugin services are unavailable in this environment."
+                });
+              }
+              try {
+                const deployments = await service3.list(tenantId2);
+                return deploymentsResult({ deployments });
+              } catch (err) {
+                return deploymentsResult({ deployments: [], error: errorText(err) });
+              }
+            }
             default:
               return `unsupported action: ${input.action}`;
           }
         },
         {
           name: "manage_plugin",
-          description: "Author and manage tenant sandbox plugins (list/get/validate/create/update/delete/reload/test).",
+          description: "Author and manage tenant sandbox plugins (list/get/validate/create/update/delete/reload/test) and deploy/undeploy/status a plugin as a resident service.",
           schema: managePluginSchema
         }
       )
@@ -47305,6 +48323,526 @@ function buildBundleFromDist(distDir, version) {
   };
 }
 
+// src/sandbox_plugin/PluginDeploymentRuntimeRegistry.ts
+var PluginDeploymentRuntimeRegistry = class {
+  /**
+   * @param options - Optional injectable clock for deterministic health timestamps.
+   */
+  constructor(options = {}) {
+    this.entries = /* @__PURE__ */ new Map();
+    this.inFlight = /* @__PURE__ */ new Map();
+    this.now = options.now ?? Date.now;
+  }
+  /**
+   * Cache the resolved proxy endpoint for a deployment.
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   * @param endpoint - Relative proxy path, e.g. `/api/sandboxes/plugin-abc/proxy/8080`.
+   */
+  setEndpoint(id, endpoint) {
+    this.entry(id).endpoint = endpoint;
+  }
+  /**
+   * Read the cached endpoint for a deployment.
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   * @returns The cached endpoint, or `undefined` when none is known.
+   */
+  getEndpoint(id) {
+    return this.entries.get(id)?.endpoint;
+  }
+  /**
+   * Record a successful health observation and clear any prior error.
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   */
+  markHealthy(id) {
+    const entry = this.entry(id);
+    entry.lastHealthAt = this.now();
+    delete entry.lastError;
+  }
+  /**
+   * Record a failed health observation.
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   * @param error - Human-readable failure description.
+   */
+  markUnhealthy(id, error) {
+    const entry = this.entry(id);
+    entry.lastHealthAt = this.now();
+    entry.lastError = error;
+  }
+  /**
+   * Read the last observed health for a deployment.
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   * @returns The cached health, or `undefined` when the id is unknown.
+   */
+  getHealth(id) {
+    const entry = this.entries.get(id);
+    if (!entry) return void 0;
+    const health = {};
+    if (entry.lastHealthAt !== void 0) health.lastHealthAt = entry.lastHealthAt;
+    if (entry.lastError !== void 0) health.lastError = entry.lastError;
+    return health;
+  }
+  /**
+   * Run a cold start/resume factory at most once per id at a time.
+   *
+   * Concurrent calls for the same id return the same in-flight promise and run
+   * `factory` exactly once. The in-flight entry is cleared when the factory
+   * settles, so a later call runs it again (retry after failure is allowed).
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   * @param factory - Idempotent start/resume operation for the resident service.
+   * @returns A promise that settles with the factory outcome.
+   */
+  ensureRunning(id, factory) {
+    const existing = this.inFlight.get(id);
+    if (existing) return existing;
+    let started;
+    try {
+      started = factory();
+    } catch (error) {
+      started = Promise.reject(error);
+    }
+    const tracked = started.finally(() => {
+      if (this.inFlight.get(id) === tracked) {
+        this.inFlight.delete(id);
+      }
+    });
+    this.inFlight.set(id, tracked);
+    return tracked;
+  }
+  /**
+   * Drop cached endpoint and health for one deployment.
+   *
+   * @param id - Composed key `${tenantId}:${pluginType}`.
+   */
+  clear(id) {
+    this.entries.delete(id);
+  }
+  /** Drop all cached endpoints, health, and in-flight coordination entries. */
+  reset() {
+    this.entries.clear();
+    this.inFlight.clear();
+  }
+  entry(id) {
+    const existing = this.entries.get(id);
+    if (existing) return existing;
+    const created = {};
+    this.entries.set(id, created);
+    return created;
+  }
+};
+
+// src/sandbox_plugin/host/pluginHostProtocol.ts
+var INLINE_INPUT_LIMIT_BYTES2 = 48 * 1024;
+var DEFAULT_HANDLER_TIMEOUT_MS = 6e4;
+var MIN_HANDLER_TIMEOUT_MS = 1e3;
+var MAX_HANDLER_TIMEOUT_MS = 3e5;
+function isRecord11(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isEnvelope3(value) {
+  return isRecord11(value) && typeof value.ok === "boolean";
+}
+function parseHostArgs(argv) {
+  let type;
+  let port;
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--type" && index + 1 < argv.length) {
+      type = argv[index + 1];
+      index += 1;
+    } else if (token.startsWith("--type=")) {
+      type = token.slice("--type=".length);
+    } else if (token === "--port" && index + 1 < argv.length) {
+      port = argv[index + 1];
+      index += 1;
+    } else if (token.startsWith("--port=")) {
+      port = token.slice("--port=".length);
+    }
+  }
+  const parsedPort = Number(port);
+  if (typeof type !== "string" || type.length === 0) {
+    throw new Error("parseHostArgs: missing or empty --type");
+  }
+  if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
+    throw new Error("parseHostArgs: invalid --port");
+  }
+  return { type, port: parsedPort };
+}
+function resolveHandlerTimeoutMs(value) {
+  if (value === null || value === void 0 || value === "") return DEFAULT_HANDLER_TIMEOUT_MS;
+  const numeric = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(numeric)) return DEFAULT_HANDLER_TIMEOUT_MS;
+  return Math.min(Math.max(Math.round(numeric), MIN_HANDLER_TIMEOUT_MS), MAX_HANDLER_TIMEOUT_MS);
+}
+function parseHandlerEnvelope(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) return { ok: false, error: "empty handler output" };
+  const whole = tryParse(trimmed);
+  if (isEnvelope3(whole)) return normalizeEnvelope(whole);
+  const lines = stdout.split("\n");
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]?.trim();
+    if (!line) continue;
+    const candidate = tryParse(line);
+    if (isEnvelope3(candidate)) return normalizeEnvelope(candidate);
+  }
+  return { ok: true, result: trimmed };
+}
+function buildHandlerCommand(handlerPath) {
+  return `node ${quotePosixShellArg2(handlerPath)}`;
+}
+function encodeInput(input) {
+  return Buffer.from(JSON.stringify(input ?? null), "utf8").toString("base64");
+}
+function buildConnectionPayload2(args) {
+  if (Array.isArray(args.connections) && args.connections.length > 0) {
+    return {
+      connection: args.connection ?? args.connections[0]?.config,
+      connections: args.connections
+    };
+  }
+  if (args.connection) {
+    return { connection: args.connection };
+  }
+  return null;
+}
+function quotePosixShellArg2(value) {
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+function tryParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function normalizeEnvelope(parsed) {
+  if (parsed.ok) return { ok: true, result: parsed.result };
+  return { ok: false, error: typeof parsed.error === "string" ? parsed.error : void 0 };
+}
+
+// src/sandbox_plugin/host/pluginHostSource.ts
+import { createHash as createHash8 } from "crypto";
+var PLUGIN_HOST_VERSION = "1.1.0";
+var PLUGIN_HOST_SERVER_SOURCE = String.raw`#!/usr/bin/env node
+"use strict";
+
+var http = require("node:http");
+var fs = require("node:fs");
+var os = require("node:os");
+var path = require("node:path");
+var crypto = require("node:crypto");
+var execFile = require("node:child_process").execFile;
+
+var VERSION = "${PLUGIN_HOST_VERSION}";
+var PLUGINS_ROOT = "/root/.agents/plugins";
+var INLINE_INPUT_LIMIT_BYTES = 48 * 1024;
+var MAX_BODY_BYTES = 8 * 1024 * 1024;
+var MAX_RESULT_BYTES = 16 * 1024 * 1024;
+var DEFAULT_HANDLER_TIMEOUT_MS = 60000;
+var MIN_HANDLER_TIMEOUT_MS = 1000;
+var MAX_HANDLER_TIMEOUT_MS = 300000;
+
+function resolveHandlerTimeoutMs(value) {
+  if (value === null || value === undefined || value === "") {
+    return DEFAULT_HANDLER_TIMEOUT_MS;
+  }
+  var numeric = typeof value === "number" ? value : Number(value);
+  if (!isFinite(numeric)) {
+    return DEFAULT_HANDLER_TIMEOUT_MS;
+  }
+  return Math.min(Math.max(Math.round(numeric), MIN_HANDLER_TIMEOUT_MS), MAX_HANDLER_TIMEOUT_MS);
+}
+
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isEnvelope(value) {
+  return isRecord(value) && typeof value.ok === "boolean";
+}
+
+function tryParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch (err) {
+    return undefined;
+  }
+}
+
+function normalizeEnvelope(parsed) {
+  if (parsed.ok) {
+    return { ok: true, result: parsed.result };
+  }
+  return { ok: false, error: typeof parsed.error === "string" ? parsed.error : undefined };
+}
+
+function parseHandlerEnvelope(stdout) {
+  var text = String(stdout == null ? "" : stdout);
+  var trimmed = text.trim();
+  if (!trimmed) {
+    // Deliberate divergence from SandboxPluginExecutor, which returns
+    // { ok: true, result: "" } for empty stdout; the resident host treats empty
+    // output as a handler failure so a crashed/no-op handler is not a "success".
+    return { ok: false, error: "empty handler output" };
+  }
+  var whole = tryParse(trimmed);
+  if (isEnvelope(whole)) {
+    return normalizeEnvelope(whole);
+  }
+  var lines = text.split("\n");
+  for (var index = lines.length - 1; index >= 0; index -= 1) {
+    var line = lines[index].trim();
+    if (!line) {
+      continue;
+    }
+    var candidate = tryParse(line);
+    if (isEnvelope(candidate)) {
+      return normalizeEnvelope(candidate);
+    }
+  }
+  return { ok: true, result: trimmed };
+}
+
+function quotePosixShellArg(value) {
+  return "'" + String(value).replace(/'/g, "'\"'\"'") + "'";
+}
+
+function buildHandlerCommand(handlerPath) {
+  return "node " + quotePosixShellArg(handlerPath);
+}
+
+function parseHostArgs(argv) {
+  var type;
+  var port;
+  for (var index = 0; index < argv.length; index += 1) {
+    var token = argv[index];
+    if (token === "--type" && index + 1 < argv.length) {
+      type = argv[index + 1];
+      index += 1;
+    } else if (token.indexOf("--type=") === 0) {
+      type = token.slice("--type=".length);
+    } else if (token === "--port" && index + 1 < argv.length) {
+      port = argv[index + 1];
+      index += 1;
+    } else if (token.indexOf("--port=") === 0) {
+      port = token.slice("--port=".length);
+    }
+  }
+  var parsedPort = Number(port);
+  if (typeof type !== "string" || type.length === 0) {
+    throw new Error("parseHostArgs: missing or empty --type");
+  }
+  if (!Number.isInteger(parsedPort) || parsedPort <= 0 || parsedPort > 65535) {
+    throw new Error("parseHostArgs: invalid --port");
+  }
+  return { type: type, port: parsedPort };
+}
+
+function encodeInput(input) {
+  return Buffer.from(JSON.stringify(input === undefined ? null : input), "utf8").toString("base64");
+}
+
+function buildConnectionPayload(body) {
+  if (Array.isArray(body.connections) && body.connections.length > 0) {
+    return {
+      connection: body.connection !== undefined ? body.connection : body.connections[0].config,
+      connections: body.connections,
+    };
+  }
+  if (body.connection) {
+    return { connection: body.connection };
+  }
+  return null;
+}
+
+function resolveHandlerPath(type, handler) {
+  if (typeof handler !== "string" || handler.length === 0) {
+    throw new Error("missing handler");
+  }
+  if (handler.charAt(0) === "/" || handler.split("/").indexOf("..") !== -1) {
+    throw new Error("invalid handler path");
+  }
+  return path.join(PLUGINS_ROOT, type, handler);
+}
+
+function readJsonBody(req) {
+  return new Promise(function (resolve, reject) {
+    var chunks = [];
+    var size = 0;
+    req.on("data", function (chunk) {
+      size += chunk.length;
+      if (size > MAX_BODY_BYTES) {
+        reject(new Error("request body too large"));
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+    req.on("end", function () {
+      try {
+        var text = Buffer.concat(chunks).toString("utf8");
+        resolve(text ? JSON.parse(text) : {});
+      } catch (err) {
+        reject(new Error("invalid JSON body"));
+      }
+    });
+    req.on("error", reject);
+  });
+}
+
+function runNode(handlerPath, pluginDir, env, timeoutMs) {
+  return new Promise(function (resolve) {
+    execFile(
+      process.execPath,
+      [handlerPath],
+      { cwd: pluginDir, env: env, timeout: timeoutMs, maxBuffer: MAX_RESULT_BYTES },
+      function (error, stdout, stderr) {
+        resolve({ error: error, stdout: stdout || "", stderr: stderr || "" });
+      }
+    );
+  });
+}
+
+function failureFromExec(exec, command) {
+  var parsed = parseHandlerEnvelope(exec.stdout);
+  if (!parsed.ok) {
+    return parsed;
+  }
+  var code = exec.error && typeof exec.error.code === "number" ? exec.error.code : "n/a";
+  var detail = exec.stdout ? exec.stdout.slice(0, 4096) : exec.error ? String(exec.error.message) : "";
+  return { ok: false, error: "handler failed (exit " + code + "): " + detail + " [" + command + "]" };
+}
+
+async function runHandler(body) {
+  var pluginDir = path.join(PLUGINS_ROOT, config.type);
+  var handlerPath = resolveHandlerPath(config.type, body.handler);
+  var command = buildHandlerCommand(handlerPath);
+  var inputJson = JSON.stringify(body.input === undefined ? null : body.input);
+  var connectionPayload = buildConnectionPayload(body);
+  var inputIsLarge = Buffer.byteLength(inputJson, "utf8") > INLINE_INPUT_LIMIT_BYTES;
+  var needsTempDir = inputIsLarge || connectionPayload !== null;
+  var tempDir = null;
+  var env = Object.assign({}, process.env);
+  try {
+    if (needsTempDir) {
+      tempDir = path.join(os.tmpdir(), "plugin-run-" + Date.now() + "-" + Math.random().toString(36).slice(2));
+      fs.mkdirSync(tempDir, { recursive: true });
+    }
+    if (inputIsLarge) {
+      var inputFile = path.join(tempDir, "input.json");
+      fs.writeFileSync(inputFile, inputJson);
+      env.PLUGIN_INPUT_FILE = inputFile;
+    } else {
+      env.PLUGIN_INPUT = encodeInput(body.input);
+    }
+    if (connectionPayload !== null) {
+      var connectionFile = path.join(tempDir, "connection.json");
+      fs.writeFileSync(connectionFile, JSON.stringify(connectionPayload));
+      env.PLUGIN_CONNECTION_FILE = connectionFile;
+    }
+    env.PLUGIN_CONTEXT = encodeInput(body.context || {});
+    var handlerTimeoutMs = resolveHandlerTimeoutMs(body.timeoutMs);
+    var exec = await runNode(handlerPath, pluginDir, env, handlerTimeoutMs);
+    if (exec.error) {
+      return failureFromExec(exec, command);
+    }
+    return parseHandlerEnvelope(exec.stdout);
+  } finally {
+    if (tempDir) {
+      try {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+      } catch (err) {
+        // best-effort cleanup
+      }
+    }
+  }
+}
+
+function manifestHash() {
+  try {
+    var content = fs.readFileSync(path.join(PLUGINS_ROOT, config.type, "plugin.json"), "utf8");
+    return crypto.createHash("sha256").update(content).digest("hex").slice(0, 16);
+  } catch (err) {
+    return "";
+  }
+}
+
+function sendJson(res, status, payload) {
+  var body = JSON.stringify(payload);
+  res.writeHead(status, {
+    "content-type": "application/json",
+    "content-length": Buffer.byteLength(body),
+  });
+  res.end(body);
+}
+
+function handleRequest(req, res) {
+  var url = String(req.url || "").split("?")[0];
+  if (req.method === "GET" && url === "/health") {
+    sendJson(res, 200, { ok: true, version: VERSION });
+    return;
+  }
+  if (req.method === "GET" && url === "/meta") {
+    sendJson(res, 200, { type: config.type, manifestHash: manifestHash() });
+    return;
+  }
+  if (req.method === "POST" && url === "/invoke") {
+    readJsonBody(req)
+      .then(function (body) {
+        if (!isRecord(body)) {
+          sendJson(res, 400, { ok: false, error: "invalid body" });
+          return;
+        }
+        return runHandler(body).then(function (result) {
+          sendJson(res, 200, result);
+        });
+      })
+      .catch(function (err) {
+        sendJson(res, 400, { ok: false, error: String(err && err.message ? err.message : err) });
+      });
+    return;
+  }
+  sendJson(res, 404, { ok: false, error: "not found" });
+}
+
+var config = parseHostArgs(process.argv);
+var server = http.createServer(handleRequest);
+server.listen(config.port, "0.0.0.0", function () {
+  process.stdout.write(
+    "[plugin-host] listening type=" + config.type + " port=" + config.port + " version=" + VERSION + "\n"
+  );
+});
+`;
+function pluginHostContentHash() {
+  return createHash8("sha256").update(`${PLUGIN_HOST_VERSION}:${PLUGIN_HOST_SERVER_SOURCE}`).digest("hex").slice(0, 16);
+}
+
+// src/sandbox_plugin/host/pluginHostInstaller.ts
+var PLUGIN_HOST_DIR = "/root/.agents/.plugin-host";
+var SERVER_PATH = `${PLUGIN_HOST_DIR}/server.js`;
+var VERSION_PATH = `${PLUGIN_HOST_DIR}/version.json`;
+async function installPluginHost(sandbox) {
+  const hash = pluginHostContentHash();
+  try {
+    const existing = await sandbox.file.readFile(VERSION_PATH);
+    const parsed = JSON.parse(existing.content);
+    if (parsed.hash === hash) {
+      return { path: SERVER_PATH, version: PLUGIN_HOST_VERSION, hash, changed: false };
+    }
+  } catch {
+  }
+  await sandbox.file.createDirectory(PLUGIN_HOST_DIR).catch(() => void 0);
+  await sandbox.file.writeFile(SERVER_PATH, PLUGIN_HOST_SERVER_SOURCE);
+  await sandbox.file.writeFile(VERSION_PATH, JSON.stringify({ version: PLUGIN_HOST_VERSION, hash }, null, 2));
+  return { path: SERVER_PATH, version: PLUGIN_HOST_VERSION, hash, changed: true };
+}
+
 // src/personal_assistant/PersonalAssistantConfig.ts
 function deepClone(obj) {
   return JSON.parse(JSON.stringify(obj));
@@ -47689,16 +49227,16 @@ var IdRemapper = class {
 };
 
 // src/util/directRoomId.ts
-import { createHash as createHash8 } from "crypto";
+import { createHash as createHash9 } from "crypto";
 function generateDirectHumanProjectId(tenantId2, workspaceId, userId1, userId2) {
   const sortedUserIds = [userId1, userId2].sort();
   const parts = [tenantId2, workspaceId, ...sortedUserIds];
-  const hash = createHash8("sha256").update(parts.join(":")).digest("hex");
+  const hash = createHash9("sha256").update(parts.join(":")).digest("hex");
   return `direct_human_${hash}`;
 }
 function generateDirectBotProjectId(tenantId2, workspaceId, userId, assistantId) {
   const parts = [tenantId2, workspaceId, userId, assistantId];
-  const hash = createHash8("sha256").update(parts.join(":")).digest("hex");
+  const hash = createHash9("sha256").update(parts.join(":")).digest("hex");
   return `direct_bot_${hash}`;
 }
 function parseDirectRoomType(projectId) {
@@ -47727,6 +49265,7 @@ export {
   CapabilityBundleValidationError,
   CapabilityToolNameConflictError,
   CapabilityToolRegistry,
+  ChannelConnectionLeader,
   ChunkBuffer,
   ChunkBufferLatticeManager,
   CollectionLatticeManager,
@@ -47738,7 +49277,9 @@ export {
   DEFAULT_CALIBRATION_PROBES,
   DEFAULT_CONNECT_TIMEOUT_MS,
   DEFAULT_DELAY_MS,
+  DEFAULT_HANDLER_TIMEOUT_MS,
   DEFAULT_MAX_ATTEMPTS,
+  DEFAULT_RESIDENT_INVOKE_TIMEOUT_MS,
   DaytonaInstance,
   DaytonaProvider,
   DefaultScheduleClient,
@@ -47756,6 +49297,7 @@ export {
   HEALTH_CHECK_INTERVAL_MS,
   HEALTH_CHECK_TIMEOUT_MS,
   HumanMessage7 as HumanMessage,
+  INLINE_INPUT_LIMIT_BYTES2 as INLINE_INPUT_LIMIT_BYTES,
   IdRemapper,
   InMemoryA2AApiKeyStore,
   InMemoryAgentWebAppStore,
@@ -47796,10 +49338,12 @@ export {
   LocalSandboxProvider,
   LoggerLatticeManager,
   MAX_BACKOFF_MS,
+  MAX_HANDLER_TIMEOUT_MS,
   MAX_LINE_LENGTH,
   MAX_PACK_ENTRIES,
   MAX_PACK_FILE_BYTES,
   MAX_PACK_TOTAL_BYTES,
+  MIN_HANDLER_TIMEOUT_MS,
   ManagedTaskStartError,
   McpLatticeManager,
   MemoryBackend,
@@ -47818,8 +49362,12 @@ export {
   PACK_DIRECTORY_TIMEOUT_SECONDS,
   PLATFORM_SECRET_ENV_VARS,
   PLUGIN_CATALOG_CHANGED_TOPIC,
+  PLUGIN_HOST_DIR,
+  PLUGIN_HOST_SERVER_SOURCE,
+  PLUGIN_HOST_VERSION,
   PersonalAssistantConfig,
   PinoLoggerClient,
+  PluginDeploymentRuntimeRegistry,
   PluginRegistry,
   PostgresDatabase,
   ProjectBotMembershipIdConflictError,
@@ -47881,7 +49429,9 @@ export {
   appendUiFence,
   assertSafeUpstreamUrl,
   buildBundleFromDist,
+  buildConnectionPayload2 as buildConnectionPayload,
   buildGrepResultsDict,
+  buildHandlerCommand,
   buildInput,
   buildNamedVolumeName,
   buildRemotePackDirectoryCommand,
@@ -47949,9 +49499,11 @@ export {
   decrypt,
   decryptConfigFields,
   describeCronExpression,
+  disconnectAllChannels,
   documentLearningPlugin,
   documentParserPlugin,
   embeddingsLatticeManager,
+  encodeInput,
   encrypt,
   encryptConfigFields,
   ensureBuiltinAgentsForTenant,
@@ -47995,6 +49547,7 @@ export {
   getModelLattice,
   getNextCronTime,
   getOrCreateCollectionVectorStore,
+  getPluginDeploymentService,
   getPluginSkillManifestVersion,
   getQueueLattice,
   getReplicaId,
@@ -48023,6 +49576,8 @@ export {
   hasChunkBuffer,
   hasDelegatedWorkerToken,
   hasRuntimeCapabilityPolicy,
+  installPluginHost,
+  invokeResident,
   invokeWithRetry,
   isBuiltInSkill,
   isDirectRoom,
@@ -48050,6 +49605,8 @@ export {
   parallelLimit,
   parseCronExpression,
   parseDirectRoomType,
+  parseHandlerEnvelope,
+  parseHostArgs,
   parseJudgeVerdict,
   parsePackSize,
   parseQueuedExecutionMode,
@@ -48058,6 +49615,7 @@ export {
   parseTrustedRunContext,
   parseYaml,
   performStringReplacement,
+  pluginHostContentHash,
   postProcessTaskMutationResponse,
   prepareTaskDispatch,
   projectMutationMutex,
@@ -48096,6 +49654,7 @@ export {
   renderTemplate,
   resetReplicaIdForTests,
   resolveEnabledPluginSkill,
+  resolveHandlerTimeoutMs,
   resolveJudgeModelKey,
   resolvePath,
   resolvePluginConnections,
@@ -48115,6 +49674,7 @@ export {
   setBindingRegistry,
   setEvalRunService,
   setMenuRegistry,
+  setPluginDeploymentService,
   setSandboxPluginCatalog,
   skillLatticeManager,
   sqlDatabaseManager,