hiwork-core 0.0.11 → 0.0.16

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");
@@ -724,7 +729,7 @@ function BrandMark(props) {
 }
 var brandNameStyle = {
   display: "inline-flex",
-  alignItems: "center",
+  alignItems: "flex-end",
   gap: 8,
   minWidth: 0
 };
@@ -739,7 +744,8 @@ var versionStyle = {
   flex: "none",
   fontSize: 12,
   fontWeight: 400,
-  lineHeight: "24px",
+  lineHeight: "normal",
+  marginBottom: 1,
   whiteSpace: "nowrap",
   color: textTertiary
 };
@@ -3004,6 +3010,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_MESSAGE = "\u6280\u80FD\u6E05\u5355\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var INVALID_RESPONSE_MESSAGE = "\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_MESSAGE);
+  }
+  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_MESSAGE;
+    throw new ManagedSkillsRpcError(code, message);
+  }
+  throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE);
+}
+function toSnapshot2(value) {
+  if (typeof value !== "object" || value === null) {
+    throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE);
+  }
+  const record = value;
+  const rawList = record["assignments"];
+  if (!Array.isArray(rawList)) {
+    throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE);
+  }
+  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_MESSAGE
+    };
+  }
+  return snapshot;
+}
+function toAssignment2(value) {
+  if (typeof value !== "object" || value === null) return void 0;
+  const record = value;
+  const assignmentId = text2(record["assignmentId"]);
+  const skillName = text2(record["skillName"]);
+  const contentSha256 = text2(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: text2(record["slug"]) ?? skillName,
+    displayName: text2(record["displayName"]) ?? skillName,
+    skillName,
+    description: text2(record["description"]) ?? "",
+    contentSha256,
+    sizeBytes: typeof record["sizeBytes"] === "number" ? record["sizeBytes"] : 0,
+    version: text2(record["version"]) ?? "",
+    updatedAt: text2(record["updatedAt"]) ?? ""
+  };
+}
+function text2(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_MESSAGE);
+    }
+    const record = value;
+    const id = text2(record["assignmentId"]);
+    const skillName = text2(record["skillName"]);
+    const contentSha256 = text2(record["contentSha256"]);
+    const archiveBase64 = text2(record["archiveBase64"]);
+    if (id === void 0 || skillName === void 0 || contentSha256 === void 0 || archiveBase64 === void 0) {
+      throw new ManagedSkillsRpcError("internal", INVALID_RESPONSE_MESSAGE);
+    }
+    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_MESSAGE2 = "\u5DE5\u4F5C\u53F0\u5E94\u7528\u6E05\u5355\u6682\u65F6\u65E0\u6CD5\u83B7\u53D6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
+var INVALID_RESPONSE_MESSAGE2 = "\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_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 ManagedWorkbenchRpcError(code, message);
+  }
+  throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+}
+function text3(value) {
+  return typeof value === "string" && value.trim() !== "" ? value : void 0;
+}
+function isRecord(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 (!isRecord(value)) return void 0;
+  const code = text3(value["code"]);
+  const executor = value["executor"];
+  if (code === void 0 || !isRecord(executor)) return void 0;
+  const kind = text3(executor["kind"]);
+  if (kind === void 0) return void 0;
+  const normalizedExecutor = { ...executor, kind };
+  const mode = text3(executor["mode"]);
+  if (mode === void 0) delete normalizedExecutor.mode;
+  else normalizedExecutor.mode = mode;
+  const category = isRecord(value["category"]) ? value["category"] : {};
+  const inputs = [];
+  for (const item of Array.isArray(value["inputs"]) ? value["inputs"] : []) {
+    if (!isRecord(item)) continue;
+    const key = text3(item["key"]);
+    if (key === void 0) continue;
+    inputs.push({
+      ...item,
+      key,
+      type: text3(item["type"]) ?? "",
+      label: text3(item["label"]) ?? key,
+      required: item["required"] === true
+    });
+  }
+  const outputs = [];
+  for (const item of Array.isArray(value["outputs"]) ? value["outputs"] : []) {
+    if (!isRecord(item)) continue;
+    const key = text3(item["key"]);
+    if (key === void 0) continue;
+    outputs.push({ ...item, key, type: text3(item["type"]) ?? "" });
+  }
+  const iconUrl = text3(value["iconUrl"]);
+  const revision = value["revision"];
+  return {
+    code,
+    displayName: text3(value["displayName"]) ?? code,
+    summary: text3(value["summary"]) ?? "",
+    ...iconUrl === void 0 ? {} : { iconUrl },
+    category: { code: text3(category["code"]) ?? "", name: text3(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 (!isRecord(value)) throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+  const rawApps = value["apps"];
+  if (!Array.isArray(rawApps)) throw new ManagedWorkbenchRpcError("internal", INVALID_RESPONSE_MESSAGE2);
+  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 (isRecord(lastError)) {
+    snapshot.lastError = {
+      code: text3(lastError["code"]) ?? "internal",
+      message: typeof lastError["message"] === "string" ? lastError["message"] : GENERIC_FAILURE_MESSAGE2
+    };
+  }
+  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 +3476,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,6 +3506,8 @@ 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);
   ctx.slots.inject("settings.section", () => ctx.slots.register({
     name: "settings.section",
@@ -3060,6 +3526,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({
@@ -3078,9 +3546,9 @@ function apply(ctx) {
   }, 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 +3577,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);