hiwork-core 0.0.11 → 0.0.17

package/lib/client.js

@@ -90,6 +90,11 @@ var hostHideCss = [
   `header [class*="moreButton"] { display: none !important; }`,
   `[class*="settingsArea"] [aria-haspopup="dialog"] { display: none !important; }`
 ].join("\n");
+var composerCss = [
+  `[data-composer-card]:has([data-composer-input]) { --dsw-elevation-stroke-color: var(--dsw-alias-border-l4); }`,
+  `[data-composer-card]:has([data-composer-input]):focus-within { --dsw-elevation-stroke-color: ${brandAccent}; }`,
+  `[data-composer-card]:has([data-composer-input]) > * { --dsw-elevation-stroke-color: var(--dsw-alias-border-l4); }`
+].join("\n");
 var brandCss = [
   `body[data-ds-dark-theme] .hiwork-brand-wordmark { filter: invert(1) brightness(1.35); }`
 ].join("\n");
@@ -345,6 +350,146 @@ function AiRouterSection(props) {
 var import_react2 = require("react");
 var import_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
 
+// src/client/plugin-updates.ts
+var PLUGIN_UPDATES_CHANNEL = "/hiwork-plugin-updates";
+var PLUGIN_UPDATES_POLL_INTERVAL_MS = 5 * 6e4;
+var PluginUpdatesRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "PluginUpdatesRpcError";
+  }
+};
+var GENERIC_FAILURE_MESSAGE = "\u63D2\u4EF6\u66F4\u65B0\u72B6\u6001\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var INVALID_RESPONSE_MESSAGE = "\u63D2\u4EF6\u66F4\u65B0\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function text(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function unwrapPluginUpdatesResult(value) {
+  if (!isRecord(value) || !("ok" in value)) {
+    throw new PluginUpdatesRpcError("internal", INVALID_RESPONSE_MESSAGE);
+  }
+  if (value["ok"] === true) return value["value"];
+  if (value["ok"] === false) {
+    const error = isRecord(value["error"]) ? value["error"] : void 0;
+    const code = text(error?.["code"]) ?? "internal";
+    const message = typeof error?.["message"] === "string" && error["message"].trim() !== "" ? error["message"] : GENERIC_FAILURE_MESSAGE;
+    throw new PluginUpdatesRpcError(code, message);
+  }
+  throw new PluginUpdatesRpcError("internal", INVALID_RESPONSE_MESSAGE);
+}
+function toPackageUpdate(value) {
+  if (!isRecord(value)) return void 0;
+  const packageName = text(value["packageName"]);
+  if (packageName === void 0) return void 0;
+  return {
+    packageName,
+    displayName: text(value["displayName"]) ?? packageName,
+    from: text(value["from"]) ?? "",
+    to: text(value["to"]) ?? ""
+  };
+}
+function toPluginUpdatesSnapshot(value) {
+  if (!isRecord(value)) return void 0;
+  const packages = [];
+  for (const item of Array.isArray(value["packages"]) ? value["packages"] : []) {
+    const normalized = toPackageUpdate(item);
+    if (normalized !== void 0) packages.push(normalized);
+  }
+  const revision = value["revision"];
+  const fetchedAt = value["fetchedAt"];
+  return {
+    packages,
+    fetchedAt: typeof fetchedAt === "number" && Number.isFinite(fetchedAt) ? fetchedAt : 0,
+    revision: typeof revision === "number" && Number.isFinite(revision) ? revision : null
+  };
+}
+var PluginUpdatesStore = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  current;
+  dismissed;
+  version = 0;
+  listeners = /* @__PURE__ */ new Set();
+  /** 最近一次成功取到的快照（同步读，可能比服务端现状旧）。没有 / 不可用时 `undefined`。 */
+  snapshot() {
+    return this.current;
+  }
+  /** 变化计数：`useSyncExternalStore` 的 `getSnapshot`（值变化即重渲染）。 */
+  getVersion = () => this.version;
+  /** 订阅变化（快照更新 / 关闭）。返回退订函数。 */
+  subscribe = (listener) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+  /** 这个 revision 是否已经被用户关掉过（同 revision 不再提示；换 revision 会重新提示）。 */
+  isDismissed(revision) {
+    return this.dismissed !== void 0 && this.dismissed === revision;
+  }
+  /**
+   * 现在是否该渲染提示卡片。
+   *
+   * 三个条件缺一不可：**有快照**（不可用 / 从没取到 → 不渲染）、**`packages` 非空**
+   * （只有降级项时桌面端返回的也是空 `packages`，spec §4.5 明确不弹）、**这个 revision 没被关过**。
+   * ⚠️ 判据里**没有** `held` / `from` / `displayName`（spec §4.3 的 ⚠️）。
+   */
+  shouldPrompt() {
+    const snapshot = this.current;
+    if (snapshot === void 0 || snapshot.packages.length === 0) return false;
+    return !this.isDismissed(snapshot.revision);
+  }
+  /**
+   * 记住「用户关掉了这一个 revision 的提示」。**只记内存**（spec §4.5：本次会话 + 该 revision），
+   * 不落盘、不调任何 apply。
+   */
+  dismiss() {
+    const snapshot = this.current;
+    if (snapshot === void 0) return;
+    if (this.dismissed === snapshot.revision) return;
+    this.dismissed = snapshot.revision;
+    this.bump();
+  }
+  /**
+   * 向 Host 取一次「有没有待生效的更新」。
+   *
+   * 返回 `undefined` 有两种来源，对调用方是同一件事（**不渲染**）：Host 说「不可用」（`null`），
+   * 或响应形状不合法。⚠️ **失败（`ok:false` / 传输异常）一律抛错且不覆写镜像**——提示条不该
+   * 因为一次抖动而消失，而「更新已经在排队」这件事不会因为读不出来就不存在。
+   */
+  async refresh(signal) {
+    const raw = await this.rpc.call(PLUGIN_UPDATES_CHANNEL, "snapshot", {}, signal);
+    const next = toPluginUpdatesSnapshot(unwrapPluginUpdatesResult(raw));
+    this.current = next;
+    this.bump();
+    return next;
+  }
+  /**
+   * 请求「重启并更新」。**这是全链路唯一的回收入口，且只能由用户点击到达。**
+   *
+   * 返回 `true` 表示触发**已经递下去**（最终落到主进程的 `recycleDshForPluginUpdate()`），
+   * **不是**「更新成功」——主进程会重建窗口，客户端那一刻就没了。
+   * `false` 只在「老桌面端上没有 `desktopPlugins`」时出现（Host 回 `requested: false`）。
+   */
+  async requestRestart(signal) {
+    const raw = await this.rpc.call(PLUGIN_UPDATES_CHANNEL, "apply", {}, signal);
+    const value = unwrapPluginUpdatesResult(raw);
+    return isRecord(value) && value["requested"] === true;
+  }
+  bump() {
+    this.version += 1;
+    for (const listener of [...this.listeners]) listener();
+  }
+};
+function createPluginUpdates(rpc) {
+  return new PluginUpdatesStore(rpc);
+}
+
 // src/client/settings-navigation.ts
 function pickSettingsSectionButton(buttons, labels) {
   for (const label of labels) {
@@ -571,6 +716,90 @@ var confirmActionsStyle = {
   gap: 8,
   marginTop: 8
 };
+var UPDATES_CARD_GAP = 8;
+var UPDATES_CARD_FALLBACK_BOTTOM = 64;
+var UPDATES_CARD_MIN_BOTTOM = 8;
+var updatesCardStyle = (bottom) => ({
+  position: "fixed",
+  left: 8,
+  bottom,
+  zIndex: 1200,
+  boxSizing: "border-box",
+  width: 268,
+  maxWidth: "calc(100vw - 16px)",
+  padding: "12px 12px 10px",
+  display: "flex",
+  flexDirection: "column",
+  gap: 6,
+  background: bgLayer2,
+  borderRadius: 12,
+  border: `1px solid ${borderL2}`,
+  boxShadow: "var(--dsw-shadow-lv3, 0 12px 32px rgba(15,17,21,0.18))"
+});
+var updatesTitleStyle = {
+  display: "flex",
+  alignItems: "center",
+  gap: 6,
+  fontSize: 13,
+  fontWeight: 600,
+  color: textPrimary
+};
+var updatesBodyStyle = { fontSize: 12, lineHeight: 1.6, color: textSecondary };
+var updatesErrorStyle = { fontSize: 12, lineHeight: 1.6, color: warnText };
+var updatesActionsStyle = {
+  display: "flex",
+  justifyContent: "flex-end",
+  gap: 8,
+  marginTop: 4
+};
+function PluginUpdatesCard(props) {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
+    "div",
+    {
+      style: updatesCardStyle(props.bottom),
+      "data-hiwork-plugin-updates": true,
+      role: "status",
+      "aria-label": "\u63D2\u4EF6\u66F4\u65B0\u63D0\u793A",
+      children: [
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: updatesTitleStyle, children: "\u63D2\u4EF6\u66F4\u65B0\u5DF2\u5C31\u7EEA" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: updatesBodyStyle, children: "\u91CD\u542F\u540E\u751F\u6548\u3002" }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: updatesBodyStyle, children: [
+          "\u70B9\u300C\u91CD\u542F\u5E76\u66F4\u65B0\u300D\u4F1A\u7ACB\u523B\u91CD\u542F\u5E94\u7528\uFF1A",
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("strong", { children: "\u5F53\u524D\u6B63\u5728\u8F93\u5165\u7684\u5185\u5BB9\u4F1A\u4E22\u5931" }),
+          "\uFF08\u4F1A\u8BDD\u8BB0\u5F55\u4FDD\u5B58\u5728\u78C1\u76D8\u4E0A\uFF0C\u4E0D\u4F1A\u4E22\uFF09\u3002"
+        ] }),
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: updatesBodyStyle, children: "\u4E5F\u53EF\u4EE5\u7A0D\u540E\u624B\u52A8\u91CD\u542F\uFF1A\u9000\u51FA HiWork \u540E\u91CD\u65B0\u6253\u5F00\uFF08macOS \u6309 Cmd+Q\uFF0C\u5173\u95ED\u7A97\u53E3\u4E0D\u7B97\u9000\u51FA\uFF09\u3002" }),
+        props.restartFailed ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("div", { style: updatesErrorStyle, children: "\u6682\u65F6\u65E0\u6CD5\u89E6\u53D1\u91CD\u542F\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5\uFF0C\u6216\u6309\u4E0A\u9762\u7684\u65B9\u5F0F\u624B\u52A8\u9000\u51FA\u540E\u91CD\u65B0\u6253\u5F00\u3002" }) : null,
+        /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: updatesActionsStyle, children: [
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-hiwork-core-secondary": true,
+              "data-hiwork-plugin-updates-dismiss": true,
+              style: secondaryButton,
+              onClick: props.onDismiss,
+              children: "\u5173\u95ED"
+            }
+          ),
+          /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+            "button",
+            {
+              type: "button",
+              "data-hiwork-core-primary": true,
+              "data-hiwork-plugin-updates-restart": true,
+              style: primaryButton,
+              disabled: props.restarting,
+              onClick: props.onRestart,
+              children: props.restarting ? "\u5DF2\u8BF7\u6C42\u91CD\u542F\u2026" : "\u91CD\u542F\u5E76\u66F4\u65B0"
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+var serverUpdatesVersion = () => 0;
 function LogoutIcon() {
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
     "svg",
@@ -626,6 +855,41 @@ function LogoutConfirm(props) {
 function UserBadge(props) {
   const state = props.useAiRouterCard((snapshot) => snapshot);
   const [confirming, setConfirming] = (0, import_react2.useState)(false);
+  const updates = props.pluginUpdates;
+  const [restarting, setRestarting] = (0, import_react2.useState)(false);
+  const [restartFailed, setRestartFailed] = (0, import_react2.useState)(false);
+  const [cardBottom, setCardBottom] = (0, import_react2.useState)(UPDATES_CARD_FALLBACK_BOTTOM);
+  const wideRowRef = (0, import_react2.useRef)(null);
+  const railRowRef = (0, import_react2.useRef)(null);
+  const loggedIn = state.status === "logged-in" && state.username !== void 0;
+  (0, import_react2.useSyncExternalStore)(updates.subscribe, updates.getVersion, serverUpdatesVersion);
+  (0, import_react2.useEffect)(() => {
+    if (!loggedIn) return;
+    const tick = () => {
+      void updates.refresh().catch(() => {
+      });
+    };
+    tick();
+    const timer = setInterval(tick, PLUGIN_UPDATES_POLL_INTERVAL_MS);
+    return () => {
+      clearInterval(timer);
+    };
+  }, [loggedIn, updates]);
+  const showUpdates = loggedIn && updates.shouldPrompt();
+  (0, import_react2.useLayoutEffect)(() => {
+    if (!showUpdates) return;
+    const measure = () => {
+      const node = props.wide ? wideRowRef.current : railRowRef.current;
+      if (node === null) return;
+      const rect = node.getBoundingClientRect();
+      setCardBottom(Math.max(UPDATES_CARD_MIN_BOTTOM, Math.round(window.innerHeight - rect.top + UPDATES_CARD_GAP)));
+    };
+    measure();
+    window.addEventListener("resize", measure);
+    return () => {
+      window.removeEventListener("resize", measure);
+    };
+  }, [showUpdates, props.wide]);
   if (state.status !== "logged-in" || state.username === void 0) return null;
   const displayName = state.displayName ?? state.username;
   const initial = displayName.slice(0, 1).toUpperCase();
@@ -633,22 +897,51 @@ function UserBadge(props) {
     setConfirming(false);
     void props.actions.logout();
   } }) : null;
-  if (!props.wide) {
-    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
-      "button",
-      {
-        type: "button",
-        "data-hiwork-core-icon": true,
-        style: railRowStyle,
-        title: displayName,
-        "aria-label": "\u6253\u5F00\u8BBE\u7F6E",
-        onClick: openGatewaySettings,
-        children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: avatarStyle(24), children: initial })
+  const onRestart = () => {
+    setRestartFailed(false);
+    setRestarting(true);
+    void updates.requestRestart().then((requested) => {
+      if (!requested) {
+        setRestarting(false);
+        setRestartFailed(true);
       }
-    );
+    }).catch(() => {
+      setRestarting(false);
+      setRestartFailed(true);
+    });
+  };
+  const updatesCard = showUpdates ? /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+    PluginUpdatesCard,
+    {
+      bottom: cardBottom,
+      restarting,
+      restartFailed,
+      onRestart,
+      onDismiss: () => {
+        updates.dismiss();
+      }
+    }
+  ) : null;
+  if (!props.wide) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
+      /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(
+        "button",
+        {
+          ref: railRowRef,
+          type: "button",
+          "data-hiwork-core-icon": true,
+          style: railRowStyle,
+          title: displayName,
+          "aria-label": "\u6253\u5F00\u8BBE\u7F6E",
+          onClick: openGatewaySettings,
+          children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { style: avatarStyle(24), children: initial })
+        }
+      ),
+      updatesCard
+    ] });
   }
   return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_jsx_runtime2.Fragment, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { style: wideRowStyle, title: displayName, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("div", { ref: wideRowRef, style: wideRowStyle, title: displayName, children: [
       /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(
         "button",
         {
@@ -689,7 +982,8 @@ function UserBadge(props) {
         }
       )
     ] }),
-    confirm
+    confirm,
+    updatesCard
   ] });
 }
 
@@ -724,7 +1018,7 @@ function BrandMark(props) {
 }
 var brandNameStyle = {
   display: "inline-flex",
-  alignItems: "center",
+  alignItems: "flex-end",
   gap: 8,
   minWidth: 0
 };
@@ -739,7 +1033,8 @@ var versionStyle = {
   flex: "none",
   fontSize: 12,
   fontWeight: 400,
-  lineHeight: "24px",
+  lineHeight: "normal",
+  marginBottom: 1,
   whiteSpace: "nowrap",
   color: textTertiary
 };
@@ -2870,28 +3165,28 @@ function toAssignment(value) {
   const record = value;
   const authRaw = record["auth"];
   const auth = typeof authRaw === "object" && authRaw !== null ? authRaw : void 0;
-  const assignmentId = text(record["assignmentId"]);
-  const serverName = text(record["serverName"]);
-  const url = text(record["url"]);
-  const kind = text(auth?.["kind"]);
-  const mintUrl = text(auth?.["mintUrl"]);
+  const assignmentId = text2(record["assignmentId"]);
+  const serverName = text2(record["serverName"]);
+  const url = text2(record["url"]);
+  const kind = text2(auth?.["kind"]);
+  const mintUrl = text2(auth?.["mintUrl"]);
   if (assignmentId === void 0 || serverName === void 0 || url === void 0 || kind === void 0 || mintUrl === void 0) {
     return void 0;
   }
   return {
     assignmentId,
     revision: typeof record["revision"] === "number" ? record["revision"] : 0,
-    slug: text(record["slug"]) ?? serverName,
-    displayName: text(record["displayName"]) ?? serverName,
+    slug: text2(record["slug"]) ?? serverName,
+    displayName: text2(record["displayName"]) ?? serverName,
     serverName,
-    transport: text(record["transport"]) ?? "",
+    transport: text2(record["transport"]) ?? "",
     url,
     extraHeaders: stringMap(record["extraHeaders"]),
-    auth: { kind, mintUrl, revokeUrl: text(auth?.["revokeUrl"]) ?? "" },
-    updatedAt: text(record["updatedAt"]) ?? ""
+    auth: { kind, mintUrl, revokeUrl: text2(auth?.["revokeUrl"]) ?? "" },
+    updatedAt: text2(record["updatedAt"]) ?? ""
   };
 }
-function text(value) {
+function text2(value) {
   return typeof value === "string" && value.trim() !== "" ? value : void 0;
 }
 function stringMap(raw) {
@@ -2955,17 +3250,17 @@ var ManagedMcpStore = class {
       throw new ManagedMcpRpcError("internal", "MCP \u6E05\u5355\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002");
     }
     const record = value;
-    const assertion = text(record["assertion"]);
-    const mintUrl = text(record["mintUrl"]);
+    const assertion = text2(record["assertion"]);
+    const mintUrl = text2(record["mintUrl"]);
     if (assertion === void 0 || mintUrl === void 0) {
       throw new ManagedMcpRpcError("internal", "MCP \u6E05\u5355\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002");
     }
     return {
       assertion,
       mintUrl,
-      revokeUrl: text(record["revokeUrl"]) ?? "",
-      expiresAt: text(record["expiresAt"]) ?? "",
-      serverName: text(record["serverName"]) ?? ""
+      revokeUrl: text2(record["revokeUrl"]) ?? "",
+      expiresAt: text2(record["expiresAt"]) ?? "",
+      serverName: text2(record["serverName"]) ?? ""
     };
   }
   /** 订阅镜像变化（连接器域据此重渲染 / 重排同步）。返回退订函数。 */
@@ -3004,6 +3299,464 @@ var ManagedMcpStore = class {
   }
 };
 
+// src/client/managed-skills.ts
+var MANAGED_SKILLS_CHANNEL = "/hiwork-managed-skills";
+var MANAGED_SKILLS_STALE_MS = 5 * 6e4;
+var ManagedSkillsRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ManagedSkillsRpcError";
+  }
+};
+var GENERIC_FAILURE_MESSAGE2 = "\u6280\u80FD\u6E05\u5355\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var INVALID_RESPONSE_MESSAGE2 = "\u6280\u80FD\u6E05\u5355\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002";
+function unwrapManagedSkillsResult(value) {
+  if (typeof value !== "object" || value === null || !("ok" in value)) {
+    throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+  }
+  const result = value;
+  if (result.ok === true) return result.value;
+  if (result.ok === false) {
+    const code = typeof result.error?.code === "string" ? result.error.code : "internal";
+    const message = typeof result.error?.message === "string" && result.error.message.trim() !== "" ? result.error.message : GENERIC_FAILURE_MESSAGE2;
+    throw new ManagedSkillsRpcError(code, message);
+  }
+  throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+}
+function toSnapshot2(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+  }
+  const record = value;
+  const rawList = record["assignments"];
+  if (!Array.isArray(rawList)) {
+    throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+  }
+  const assignments = [];
+  for (const item of rawList) {
+    const normalized = toAssignment2(item);
+    if (normalized !== void 0) assignments.push(normalized);
+  }
+  const lastError = record["lastError"];
+  const snapshot = {
+    revision: typeof record["revision"] === "number" ? record["revision"] : 0,
+    fetchedAt: typeof record["fetchedAt"] === "string" ? record["fetchedAt"] : "",
+    assignments,
+    stale: record["stale"] === true
+  };
+  if (typeof lastError === "object" && lastError !== null) {
+    const detail = lastError;
+    snapshot.lastError = {
+      code: typeof detail.code === "string" ? detail.code : "internal",
+      message: typeof detail.message === "string" ? detail.message : GENERIC_FAILURE_MESSAGE2
+    };
+  }
+  return snapshot;
+}
+function toAssignment2(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const assignmentId = text3(record["assignmentId"]);
+  const skillName = text3(record["skillName"]);
+  const contentSha256 = text3(record["contentSha256"]);
+  if (assignmentId === void 0 || skillName === void 0 || contentSha256 === void 0) return void 0;
+  return {
+    assignmentId,
+    revision: typeof record["revision"] === "number" ? record["revision"] : 0,
+    slug: text3(record["slug"]) ?? skillName,
+    displayName: text3(record["displayName"]) ?? skillName,
+    skillName,
+    description: text3(record["description"]) ?? "",
+    contentSha256,
+    sizeBytes: typeof record["sizeBytes"] === "number" ? record["sizeBytes"] : 0,
+    version: text3(record["version"]) ?? "",
+    updatedAt: text3(record["updatedAt"]) ?? ""
+  };
+}
+function text3(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+var ManagedSkillsStore = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  current;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * 在飞请求**连同它所属的世代**一起记账：只有同一世代的那条才可以被复用。
+   *
+   * 光记 promise 不够——`clear()`（登出 / 换账号）之后，账上那条是**上一个人**发起的，
+   * 它的清单属于上一个人。复用它等于让新账号的同步拿到旧账号的清单，而 `refresh` 的返回值
+   * 是技能域唯一被允许用来删本地受管技能的依据（spec §6 的唯一安全不变量）⇒ 会把新账号
+   * 被分配的技能**硬删掉**。所以要有一个「这条账还算不算数」的判据，见 {@link clear}。
+   */
+  inFlight;
+  /** 世代号：`clear()` 每调用一次 +1，用来作废它之前发起的在飞请求。 */
+  generation = 0;
+  /** 本地镜像（同步）。从没成功同步过返回 undefined。**不要拿它做删除决策**（见文件头）。 */
+  snapshot() {
+    return this.current;
+  }
+  /** 本地镜像是否已经陈旧（或从未同步过）。 */
+  isStale(ttlMs = MANAGED_SKILLS_STALE_MS, now = Date.now()) {
+    if (this.current === void 0 || this.current.fetchedAt === "") return true;
+    const fetchedAt = Date.parse(this.current.fetchedAt);
+    if (Number.isNaN(fetchedAt)) return true;
+    return now - fetchedAt >= ttlMs;
+  }
+  /**
+   * 强制同步一次并返回**刚拉到的**清单。
+   *
+   * 返回值（而不是让人随后去读 `snapshot()`）是刻意的：只有这个返回值保证「这一次
+   * 网络请求成功了」，用它做删除决策才是安全的；读镜像可能读到上一次的结果。
+   * 失败时抛错且**不动镜像**——调用方据此保持现有的受管技能一条不删（spec §6 的
+   * 唯一安全不变量）。
+   */
+  async refresh(signal) {
+    return await this.dedupe(async (generation) => {
+      const raw = await this.rpc.call(MANAGED_SKILLS_CHANNEL, "refresh", {}, signal);
+      return this.adopt(unwrapManagedSkillsResult(raw), generation);
+    });
+  }
+  /**
+   * 取一份清单，**能用 Host 的预热缓存就用**（Host 后台每 30 分钟拉一次）。
+   *
+   * 与 {@link refresh} 的分工：这里是「启动时先把界面填上」的便宜入口——命中缓存时
+   * 一次网络请求都不发；Host 缓存也是冷的才会真的去拉。返回值仍保证是「某一次成功
+   * 拉取的结果」，但**可能比服务端现状旧**，所以调用方按 `stale` / `isStale()` 判定它
+   * 够不够权威，不够就再 `refresh()` 一次。
+   */
+  async warm(signal) {
+    return await this.dedupe(async (generation) => {
+      const raw = await this.rpc.call(MANAGED_SKILLS_CHANNEL, "snapshot", {}, signal);
+      return this.adopt(unwrapManagedSkillsResult(raw), generation);
+    });
+  }
+  /**
+   * 取一条分配的技能包（base64 字节）。
+   *
+   * **本层不缓存包体、也不解码**：它是一条分配的内容，不是「服务端此刻认什么」的投影；
+   * 缓存下来等于把每次同步装过的所有技能包都钉在内存里（base64 后每条约 5 MiB）。
+   * 校验与落盘在技能域（spec §4.6）。
+   */
+  async package(assignmentId, signal) {
+    const raw = await this.rpc.call(MANAGED_SKILLS_CHANNEL, "package", { assignmentId }, signal);
+    const value = unwrapManagedSkillsResult(raw);
+    if (typeof value !== "object" || value === null) {
+      throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+    }
+    const record = value;
+    const id = text3(record["assignmentId"]);
+    const skillName = text3(record["skillName"]);
+    const contentSha256 = text3(record["contentSha256"]);
+    const archiveBase64 = text3(record["archiveBase64"]);
+    if (id === void 0 || skillName === void 0 || contentSha256 === void 0 || archiveBase64 === void 0) {
+      throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+    }
+    return { assignmentId: id, skillName, contentSha256, archiveBase64 };
+  }
+  /** 订阅镜像变化（技能域据此重渲染 / 重排同步）。返回退订函数。 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * 清空镜像（登出 / 换账号：清单是按人的，留着会串号），并**作废在飞的请求**。
+   *
+   * 只清镜像是不够的：清空那一刻正有一次拉取在飞时，那次拉取是**上一个人**发起的，它的
+   * 清单属于上一个人——清空之后到来的调用者若复用了它，就会拿旧账号的清单去对账本地受管
+   * 技能，把新账号被分配的技能全删掉（`refresh` 的返回值是唯一被允许用来删的那条路，
+   * spec §6）。所以世代 +1：那之后的调用者一律不复用旧世代的那条，自己重新发一次 RPC。
+   *
+   * 用世代号而**不是**把 `inFlight` 直接抹成 undefined：旧 promise 的 `finally` 会回头把
+   * **新**发起的那条记账清掉，于是「清空后重新发起」与「又在飞的旧请求」互相踩。世代判据
+   * 天然避开这一格——收尾只在「自己还是账上那一条」时才发生（与 Host 侧 `src/managed-skills.ts`
+   * 的 `load()` 同形）。
+   *
+   * ⚠️ 这条修复**刻意只落在技能这半**：`src/client/managed-mcp.ts` 是逐字同形的既有缺口，
+   * **用户已裁定 MCP 那半本轮不动**。别为了「两半对齐」把这里改回原样。
+   */
+  clear() {
+    this.generation += 1;
+    this.current = void 0;
+    this.emit();
+  }
+  /**
+   * 并发去重：`warm` 与 `refresh` 撞在一起（启动同步与定时同步常常同拍）时共用一次
+   * 请求，且**共用同一个返回值**——两边对「这一次拉到了什么」的判断必须一致。
+   *
+   * 合并只会让清单更旧（`warm` 可能命中 Host 缓存）、**不会让它更空**：旧清单里条目更多，
+   * 于是删除得更少——偏差落在「该删的这次没删」这一侧，正是 spec §6 允许的那一侧。
+   *
+   * 上面这条讲的是**新旧次序**，管不到**身份**：并发合并还有第二个维度——「这几次调用是不是
+   * 同一个人的」。世代号（{@link clear}）负责的就是这一格：换账号之后账上那条属于上一个人，
+   * 谁都不许复用，必须各自重新发起。
+   *
+   * 传给 `task` 的 `generation` 是**发起这一次请求时**的世代号，由它决定这次结果能不能写进镜像
+   * （见 {@link adopt}）——晚到的旧世代结果照旧返回给它自己的调用方，但不许覆盖新世代的镜像。
+   */
+  async dedupe(task) {
+    const inFlight = this.inFlight;
+    if (inFlight !== void 0 && inFlight.generation === this.generation) return await inFlight.task;
+    const generation = this.generation;
+    const promise = task(generation);
+    this.inFlight = { generation, task: promise };
+    try {
+      return await promise;
+    } finally {
+      if (this.inFlight?.task === promise) this.inFlight = void 0;
+    }
+  }
+  /**
+   * 采纳一份成功响应：写镜像 + 通知订阅者（失败路径永远不会走到这里）。
+   *
+   * 世代不符的那一份**不写镜像**（但仍原样返回给调用方）：它是 `clear()` 之前发起的请求，
+   * 属于上一个人。允许它写回等于「清空之后又被上一个人的清单占住」，而换账号时下一次同步
+   * 就靠 `snapshot()` / `isStale()` 判「要不要拉」——镜像被别人的清单占着，这一页会既不显示
+   * 新账号的技能，也不触发同步。
+   */
+  adopt(value, generation) {
+    const snapshot = toSnapshot2(value);
+    if (generation !== this.generation) return snapshot;
+    this.current = snapshot;
+    this.emit();
+    return snapshot;
+  }
+  emit() {
+    for (const listener of [...this.listeners]) listener();
+  }
+};
+
+// src/client/managed-workbench.ts
+var MANAGED_WORKBENCH_CHANNEL = "/hiwork-workbench";
+var MANAGED_WORKBENCH_STALE_MS = 5 * 6e4;
+var ManagedWorkbenchRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ManagedWorkbenchRpcError";
+  }
+};
+var GENERIC_FAILURE_MESSAGE3 = "\u5DE5\u4F5C\u53F0\u5E94\u7528\u6E05\u5355\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var INVALID_RESPONSE_MESSAGE3 = "\u5DE5\u4F5C\u53F0\u6E05\u5355\u4E3B\u673A\u8FD4\u56DE\u4E86\u65E0\u6548\u54CD\u5E94\u3002";
+function unwrapManagedWorkbenchResult(value) {
+  if (typeof value !== "object" || value === null || !("ok" in value)) {
+    throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE3);
+  }
+  const result = value;
+  if (result.ok === true) return result.value;
+  if (result.ok === false) {
+    const code = typeof result.error?.code === "string" ? result.error.code : "internal";
+    const message = typeof result.error?.message === "string" && result.error.message.trim() !== "" ? result.error.message : GENERIC_FAILURE_MESSAGE3;
+    throw new ManagedWorkbenchRpcError(code, message);
+  }
+  throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE3);
+}
+function text4(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string");
+}
+function toApp(value) {
+  if (!isRecord2(value)) return void 0;
+  const code = text4(value["code"]);
+  const executor = value["executor"];
+  if (code === void 0 || !isRecord2(executor)) return void 0;
+  const kind = text4(executor["kind"]);
+  if (kind === void 0) return void 0;
+  const normalizedExecutor = { ...executor, kind };
+  const mode = text4(executor["mode"]);
+  if (mode === void 0) delete normalizedExecutor.mode;
+  else normalizedExecutor.mode = mode;
+  const category = isRecord2(value["category"]) ? value["category"] : {};
+  const inputs = [];
+  for (const item of Array.isArray(value["inputs"]) ? value["inputs"] : []) {
+    if (!isRecord2(item)) continue;
+    const key = text4(item["key"]);
+    if (key === void 0) continue;
+    inputs.push({
+      ...item,
+      key,
+      type: text4(item["type"]) ?? "",
+      label: text4(item["label"]) ?? key,
+      required: item["required"] === true
+    });
+  }
+  const outputs = [];
+  for (const item of Array.isArray(value["outputs"]) ? value["outputs"] : []) {
+    if (!isRecord2(item)) continue;
+    const key = text4(item["key"]);
+    if (key === void 0) continue;
+    outputs.push({ ...item, key, type: text4(item["type"]) ?? "" });
+  }
+  const iconUrl = text4(value["iconUrl"]);
+  const revision = value["revision"];
+  return {
+    code,
+    displayName: text4(value["displayName"]) ?? code,
+    summary: text4(value["summary"]) ?? "",
+    ...iconUrl === void 0 ? {} : { iconUrl },
+    category: { code: text4(category["code"]) ?? "", name: text4(category["name"]) ?? "" },
+    tags: stringArray(value["tags"]),
+    featured: value["featured"] === true,
+    revision: typeof revision === "number" && Number.isFinite(revision) ? revision : 0,
+    executor: normalizedExecutor,
+    inputs,
+    outputs,
+    effects: stringArray(value["effects"])
+  };
+}
+function toSnapshot3(value) {
+  if (!isRecord2(value)) throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE3);
+  const rawApps = value["apps"];
+  if (!Array.isArray(rawApps)) throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE3);
+  const apps = [];
+  for (const item of rawApps) {
+    const app = toApp(item);
+    if (app !== void 0) apps.push(app);
+  }
+  const snapshot = {
+    revision: typeof value["revision"] === "number" && Number.isFinite(value["revision"]) ? value["revision"] : 0,
+    fetchedAt: typeof value["fetchedAt"] === "string" ? value["fetchedAt"] : "",
+    apps,
+    stale: value["stale"] === true
+  };
+  const lastError = value["lastError"];
+  if (isRecord2(lastError)) {
+    snapshot.lastError = {
+      code: text4(lastError["code"]) ?? "internal",
+      message: typeof lastError["message"] === "string" ? lastError["message"] : GENERIC_FAILURE_MESSAGE3
+    };
+  }
+  return snapshot;
+}
+var ManagedWorkbenchStore = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  current;
+  listeners = /* @__PURE__ */ new Set();
+  /**
+   * 在飞请求**连同它所属的世代**一起记账：只有同一世代的那条才可以被复用。
+   *
+   * 光记 promise 不够——`clear()`（登出 / 换账号）之后，账上那条是**上一个人**发起的，它的清单
+   * 属于上一个人。复用它等于让新账号的货架显示旧账号的应用（管理员给谁分配是按人的）。
+   * 所以要有一个「这条账还算不算数」的判据，见 {@link clear}。
+   */
+  inFlight;
+  /** 世代号：`clear()` 每调用一次 +1，用来作废它之前发起的在飞请求。 */
+  generation = 0;
+  /** 本地镜像（同步）。从没成功同步过返回 undefined。**不要拿它做下架决策**（见文件头）。 */
+  snapshot() {
+    return this.current;
+  }
+  /** 本地镜像是否已经陈旧（或从未同步过）。 */
+  isStale(ttlMs = MANAGED_WORKBENCH_STALE_MS, now = Date.now()) {
+    if (this.current === void 0 || this.current.fetchedAt === "") return true;
+    const fetchedAt = Date.parse(this.current.fetchedAt);
+    if (Number.isNaN(fetchedAt)) return true;
+    return now - fetchedAt >= ttlMs;
+  }
+  /**
+   * 强制同步一次并返回**刚拉到的**清单。
+   *
+   * 返回值（而不是让人随后去读 `snapshot()`）是刻意的：只有这个返回值保证「这一次网络请求成功了」，
+   * 用它判断「这个应用还在不在」才是安全的；读镜像可能读到上一次的结果。失败时抛错且**不动镜像**
+   * ——调用方据此保持货架原样（离线态显示上次成功缓存 + 「可能不是最新」）。
+   */
+  async refresh(signal) {
+    return await this.dedupe(async (generation) => {
+      const raw = await this.rpc.call(MANAGED_WORKBENCH_CHANNEL, "refresh", {}, signal);
+      return this.adopt(unwrapManagedWorkbenchResult(raw), generation);
+    });
+  }
+  /**
+   * 取一份清单，**能用 Host 的预热缓存就用**（Host 后台每 30 分钟拉一次）。
+   *
+   * 与 {@link refresh} 的分工：这里是「挂载时先把界面填上」的便宜入口——命中缓存时一次网络请求
+   * 都不发；Host 缓存也是冷的才会真的去拉。返回值仍保证是「某一次成功拉取的结果」，但**可能比
+   * 服务端现状旧**，所以调用方按 `stale` / `isStale()` 判定它够不够权威，不够就再 `refresh()`。
+   */
+  async warm(signal) {
+    return await this.dedupe(async (generation) => {
+      const raw = await this.rpc.call(MANAGED_WORKBENCH_CHANNEL, "snapshot", {}, signal);
+      return this.adopt(unwrapManagedWorkbenchResult(raw), generation);
+    });
+  }
+  /** 订阅镜像变化（货架页据此重渲染）。返回退订函数。 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  /**
+   * 清空镜像（登出 / 换账号：清单是按人的，留着会串号），并**作废在飞的请求**。
+   *
+   * 只清镜像是不够的：清空那一刻正有一次拉取在飞时，那次拉取是**上一个人**发起的，它的清单
+   * 属于上一个人——清空之后到来的调用者若复用了它，新账号的货架就会显示旧账号的应用。所以
+   * 世代 +1：那之后的调用者一律不复用旧世代的那条，自己重新发一次 RPC。
+   *
+   * 用世代号而**不是**把 `inFlight` 直接抹成 undefined：旧 promise 的 `finally` 会回头把**新**
+   * 发起的那条记账清掉，于是「清空后重新发起」与「又在飞的旧请求」互相踩。世代判据天然避开
+   * 这一格——收尾只在「自己还是账上那一条」时才发生（与 Host 侧 `src/workbench-bridge.ts`
+   * 的 `load()` 同形，也与 `src/client/managed-skills.ts` 的同名方法逐字同款）。
+   */
+  clear() {
+    this.generation += 1;
+    this.current = void 0;
+    this.emit();
+  }
+  /**
+   * 并发去重：`warm` 与 `refresh` 撞在一起（挂载预热与手动刷新常常同拍）时共用一次请求，
+   * 且**共用同一个返回值**——两边对「这一次拉到了什么」的判断必须一致。
+   *
+   * 合并只会让清单更旧（`warm` 可能命中 Host 缓存）、**不会让它更空**：旧清单里条目更多，
+   * 于是「该消失的这次没消失」——偏差落在保守的那一侧。
+   *
+   * 上面这条讲的是**新旧次序**，管不到**身份**：世代号（{@link clear}）负责的就是这一格——
+   * 换账号之后账上那条属于上一个人，谁都不许复用，必须各自重新发起。
+   */
+  async dedupe(task) {
+    const inFlight = this.inFlight;
+    if (inFlight !== void 0 && inFlight.generation === this.generation) return await inFlight.task;
+    const generation = this.generation;
+    const promise = task(generation);
+    this.inFlight = { generation, task: promise };
+    try {
+      return await promise;
+    } finally {
+      if (this.inFlight?.task === promise) this.inFlight = void 0;
+    }
+  }
+  /**
+   * 采纳一份成功响应：写镜像 + 通知订阅者（失败路径永远不会走到这里）。
+   *
+   * 世代不符的那一份**不写镜像**（但仍原样返回给调用方）：它是 `clear()` 之前发起的请求，
+   * 属于上一个人。允许它写回等于「清空之后又被上一个人的清单占住」，而换账号时下一次同步就靠
+   * `snapshot()` / `isStale()` 判「要不要拉」——镜像被别人的清单占着，这一页会既不显示新账号的
+   * 应用，也不触发同步。
+   */
+  adopt(value, generation) {
+    const snapshot = toSnapshot3(value);
+    if (generation !== this.generation) return snapshot;
+    this.current = snapshot;
+    this.emit();
+    return snapshot;
+  }
+  emit() {
+    for (const listener of [...this.listeners]) listener();
+  }
+};
+
 // src/client/index.ts
 var inject = ["slots", "locale", "remote", "remote.credentials", "settingsScope", "connection"];
 var INTERACTION_STYLE_ID = "hiwork-core-interaction-styles";
@@ -3012,7 +3765,7 @@ function injectInteractionStyles() {
   if (document.getElementById(INTERACTION_STYLE_ID) !== null) return;
   const style = document.createElement("style");
   style.id = INTERACTION_STYLE_ID;
-  style.textContent = [interactionCss, brandCss, frameCss, hostHideCss].join("\n");
+  style.textContent = [interactionCss, brandCss, frameCss, hostHideCss, composerCss].join("\n");
   document.head.appendChild(style);
 }
 function apply(ctx) {
@@ -3042,7 +3795,10 @@ function apply(ctx) {
   const sessionCost = new SessionCostStore(connection.rpc);
   const dailyQuotes = new DailyDataStore(connection.rpc);
   const managedMcp = new ManagedMcpStore(connection.rpc);
+  const managedSkills = new ManagedSkillsStore(connection.rpc);
+  const managedWorkbench = new ManagedWorkbenchStore(connection.rpc);
   const appVersion = createAppVersion(connection.rpc);
+  const pluginUpdates = createPluginUpdates(connection.rpc);
   ctx.slots.inject("settings.section", () => ctx.slots.register({
     name: "settings.section",
     id: "hiwork-usage",
@@ -3060,6 +3816,8 @@ function apply(ctx) {
     usage.clear();
     sessionCost.clear();
     managedMcp.clear();
+    managedSkills.clear();
+    managedWorkbench.clear();
   }), "hiwork-core: \u7528\u91CF\u7F13\u5B58\u968F\u8D26\u53F7 / Key \u53D8\u5316\u6E05\u7A7A");
   ctx.effect(() => observeAboutNavIcon(), "hiwork-core: about nav icon");
   ctx.slots.inject("sidebar.brand.mark", () => ctx.slots.register({
@@ -3074,13 +3832,13 @@ function apply(ctx) {
   ctx.slots.inject("sidebar.footer.action", () => ctx.slots.register({
     name: "sidebar.footer.action",
     id: AI_ROUTER_NS,
-    inject: () => controller.inject()
+    inject: () => ({ ...controller.inject(), pluginUpdates })
   }, UserBadge));
   ctx.effect(() => mountLoginGate(scope, storeCredential), "hiwork-core: login gate");
   ctx.effect(() => observeHeroDecorations(document, dailyQuotes), "hiwork-core: hero decorations");
-  installFeatureCenter(ctx, managedMcp);
+  installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench);
 }
-function installFeatureCenter(ctx, managedMcp) {
+function installFeatureCenter(ctx, managedMcp, managedSkills, managedWorkbench) {
   const featureRegistry = createFeatureRegistry();
   let center;
   const sessions = ctx.get("sessions");
@@ -3109,6 +3867,27 @@ function installFeatureCenter(ctx, managedMcp) {
       refresh: async (signal) => await managedMcp.refresh(signal),
       assertion: async (assignmentId, signal) => await managedMcp.assertion(assignmentId, signal),
       subscribe: (listener) => managedMcp.subscribe(listener)
+    },
+    // 受管技能面：技能域（hiwork-capabilities）按这个成员判断「有没有这个能力」，老 core 上
+    // 它是 undefined，能力中心照常工作、只是没有受管技能那一块（可选解耦，见 contracts.ts）。
+    // 六项与 spec §4.5 逐字对应；核心不落盘、不解包、不持有会话 cookie——包体由 Host 取。
+    managedSkills: {
+      snapshot: () => managedSkills.snapshot(),
+      isStale: (ttlMs) => managedSkills.isStale(ttlMs),
+      warm: async (signal) => await managedSkills.warm(signal),
+      refresh: async (signal) => await managedSkills.refresh(signal),
+      package: async (assignmentId, signal) => await managedSkills.package(assignmentId, signal),
+      subscribe: (listener) => managedSkills.subscribe(listener)
+    },
+    // 工作台应用清单面：工作台域（hiwork-workbench）按这个成员判断「有没有这个能力」，老 core 上
+    // 它是 undefined，货架按「本部署尚未启用工作台」降级（spec §10 的降级矩阵）。M0 只有清单
+    // 相关的方法——`submit` / `poll` / `cancel` / `materialize` 属 M1（见 contracts.ts）。
+    managedWorkbench: {
+      snapshot: () => managedWorkbench.snapshot(),
+      isStale: (ttlMs) => managedWorkbench.isStale(ttlMs),
+      warm: async (signal) => await managedWorkbench.warm(signal),
+      refresh: async (signal) => await managedWorkbench.refresh(signal),
+      subscribe: (listener) => managedWorkbench.subscribe(listener)
     }
   };
   ctx.provide(HIWORK_FEATURE_CENTER_SERVICE, face);