create-windy 0.8.3 → 0.10.0

package/template/apps/agent-server/plugins/parallel.mjs

@@ -0,0 +1,146 @@
+/** Application policy around public DSH events; upstream owns child execution. */
+export const name = "windy-parallel-policy";
+export const inject = ["agents", "subagents", "tools"];
+export function apply(ctx, config = {}) {
+  const maximumCalls = config.maxModelCalls ?? 32;
+  const maximumTools = config.maxToolCalls ?? 64;
+  const maximumChildren = config.maxChildren ?? 8;
+  const durationMs = config.durationMs ?? 300000;
+  const states = new Map();
+  const observed = new WeakSet();
+  // Only the official live activation event establishes a delegation edge.
+  // parentSession alone is also used by ordinary historical conversation forks.
+  const managed = new Map();
+  ctx.on("subagent/start", (info) => {
+    const agent = ctx.agents.get(info.id);
+    const parent = agent && ctx.agents.get(agent.session.header.parentSession);
+    if (agent && parent) managed.set(agent.id, { agent, parent });
+  });
+  ctx.on("subagent/end", (info) => managed.delete(info.id));
+  const rootOf = (agent) => {
+    let root = agent;
+    for (let depth = 0; depth < 8; depth++) {
+      const edge = managed.get(root.id);
+      if (!edge || edge.agent !== root) {
+        if (root.session.header.origin === "subagent")
+          throw new Error("WINDY_UNMANAGED_CHILD");
+        return root;
+      }
+      if (ctx.agents.get(edge.parent.id) !== edge.parent)
+        throw new Error("WINDY_PARENT_UNAVAILABLE");
+      root = edge.parent;
+    }
+    throw new Error("WINDY_DELEGATION_DEPTH");
+  };
+  const children = (root) =>
+    [...managed.values()]
+      .filter(({ agent }) => {
+        try {
+          return rootOf(agent) === root;
+        } catch {
+          return false;
+        }
+      })
+      .map(({ agent }) => agent);
+  const stopChildren = (root) => {
+    const descendants = children(root);
+    for (const child of descendants) child.cancel({ kind: "parent" });
+    void ctx.subagents
+      .drainChildren(
+        root,
+        descendants.map((child) => child.id),
+      )
+      .catch(() => ctx.logger.warn("windy: child teardown failed"));
+  };
+  const close = (root, state) => {
+    if (state.closed) return;
+    state.closed = true;
+    clearTimeout(state.timer);
+    root.cancel({ kind: "user" });
+    stopChildren(root);
+  };
+  const fresh = (root) => {
+    const previous = states.get(root);
+    if (previous) clearTimeout(previous.timer);
+    const state = {
+      calls: 0,
+      tools: 0,
+      spawned: 0,
+      closed: false,
+      timer: undefined,
+    };
+    state.timer = setTimeout(() => close(root, state), durationMs);
+    state.timer.unref?.();
+    states.set(root, state);
+    return state;
+  };
+  const stateOf = (agent) => {
+    const root = rootOf(agent);
+    return { root, state: states.get(root) ?? fresh(root) };
+  };
+  ctx.on("agent/pre-step", async (payload, next) => {
+    const { agent, messages, signal } = payload;
+    const root = rootOf(agent);
+    if (
+      agent === root &&
+      messages.some((message) => message.source.kind === "user") &&
+      !children(root).some((child) => child.status === "running")
+    )
+      fresh(root);
+    if (agent === root && !observed.has(signal)) {
+      observed.add(signal);
+      signal.addEventListener("abort", () => stopChildren(root), {
+        once: true,
+      });
+    }
+    return next();
+  });
+  ctx.on("agent/request", async ({ agent }, next) => {
+    const { root, state } = stateOf(agent);
+    if (state.closed || ++state.calls > maximumCalls) {
+      close(root, state);
+      throw new Error("WINDY_SHARED_MODEL_BUDGET_EXCEEDED");
+    }
+    return next();
+  });
+  ctx.tools.guard((exec) => {
+    if (!exec.agent) return "WINDY_AGENT_REQUIRED";
+    const { root, state } = stateOf(exec.agent);
+    if (state.closed || ++state.tools > maximumTools) {
+      close(root, state);
+      return "WINDY_SHARED_TOOL_BUDGET_EXCEEDED";
+    }
+    if (exec.name === "subagent" && ++state.spawned > maximumChildren)
+      return "WINDY_SHARED_CHILD_BUDGET_EXCEEDED";
+  });
+  // alpha.3 can leave a root idle while children continue. Its public cancel
+  // method otherwise cancels only the root turn, so extend this one UI seam.
+  ctx.inject(["sessionController"], (host) => {
+    const controller = host.sessionController;
+    const original = controller.cancel;
+    const cancel = function (request) {
+      const result = original.call(this, request);
+      const agent = host.agents.get(request.sessionId);
+      if (agent && agent.session.header.origin !== "subagent")
+        stopChildren(agent);
+      return result;
+    };
+    controller.cancel = cancel;
+    host.effect(() => () => {
+      if (controller.cancel === cancel) controller.cancel = original;
+    });
+  });
+  ctx.on("agent/disposed", ({ agent }) => {
+    managed.delete(agent.id);
+    const state = states.get(agent);
+    if (state) {
+      clearTimeout(state.timer);
+      states.delete(agent);
+    }
+  });
+  ctx.effect(() => () => {
+    for (const state of states.values()) clearTimeout(state.timer);
+    states.clear();
+    managed.clear();
+  });
+}

package/template/apps/agent-server/plugins/preset-registry.d.mts

@@ -0,0 +1,2 @@
+import AgentPresetRegistry from "@deepseek-ai/dsh-agent-preset-registry";
+export default class WindyPresetRegistry extends AgentPresetRegistry {}

package/template/apps/agent-server/plugins/preset-registry.mjs

@@ -0,0 +1,41 @@
+import AgentPresetRegistry from "@deepseek-ai/dsh-agent-preset-registry";
+import { RemoteError } from "@deepseek-ai/dsh-typert-protocol";
+
+function requirePreset(expected, id) {
+  if (id !== undefined && id !== expected)
+    throw new RemoteError(
+      "remote-access/denied",
+      "Windy Agent 使用固定业务预设。",
+      {},
+    );
+}
+
+/** The application overlay owns the only executable preset, independently of UI. */
+export default class WindyPresetRegistry extends AgentPresetRegistry {
+  constructor(ctx, config) {
+    const id = config?.default ?? "windy";
+    if (!/^[a-z][a-z0-9-]{0,63}$/.test(id))
+      throw new Error("Invalid deployment preset identity");
+    super(ctx, config);
+    Object.defineProperty(this, "deploymentPresetId", { value: id });
+  }
+  get defaultId() {
+    return this.deploymentPresetId ?? this.config?.default ?? "windy";
+  }
+  async register(definition) {
+    requirePreset(this.defaultId, definition.id);
+    return super.register(definition);
+  }
+  async select(agent, id) {
+    requirePreset(this.defaultId, id);
+    return super.select(agent, this.defaultId);
+  }
+  async mount(ctx, id) {
+    requirePreset(this.defaultId, id);
+    return super.mount(ctx, this.defaultId);
+  }
+  async acquireScope(id) {
+    requirePreset(this.defaultId, id);
+    return super.acquireScope(this.defaultId);
+  }
+}

package/template/apps/agent-server/plugins/preset-registry.test.ts

@@ -0,0 +1,46 @@
+import { expect, test } from "bun:test";
+import WindyPresetRegistry from "./preset-registry.mjs";
+import WindySettingsController from "./settings-controller.mjs";
+import { nativeProfile } from "../native/profile.js";
+import { defaultHostFixture } from "../native/host-test-fixture.js";
+
+test("managed preset rejects changes before registry or settings provider access", async () => {
+  const registry = Object.create(WindyPresetRegistry.prototype);
+  expect(registry.defaultId).toBe("windy");
+  for (const action of [
+    () => registry.register({ id: "custom" }),
+    () => registry.select({}, "cordis"),
+    () => registry.mount({}, "standard"),
+    () => registry.acquireScope("custom"),
+  ])
+    await expect(action()).rejects.toMatchObject({
+      code: "remote-access/denied",
+    });
+  const settings = Object.create(WindySettingsController.prototype);
+  for (const method of ["update", "replace", "mutate"]) {
+    await expect(
+      settings[method]("agent-preset-registry", {}),
+    ).rejects.toMatchObject({ code: "remote-access/denied" });
+  }
+});
+
+test("product disables the presentation-only preset UI while retaining its host registry", () => {
+  const rows = nativeProfile(
+    {
+      appRoot: "/app",
+      gateUrl: "http://gate",
+      model: "synthetic",
+      contextWindow: 32768,
+      maxOutputTokens: 4096,
+    },
+    defaultHostFixture,
+  );
+  expect(rows).toContainEqual({ id: "ui-agent-preset", disabled: true });
+  expect(rows).toContainEqual({ id: "agent-preset-registry", disabled: true });
+  const inserted = rows.flatMap((row) => ("insert" in row ? row.insert : []));
+  expect(inserted).toContainEqual({
+    id: "windy-agent-preset-registry",
+    name: "/app/plugins/preset-registry.mjs",
+    config: { default: "windy" },
+  });
+});

package/template/apps/agent-server/plugins/questions.d.mts

@@ -0,0 +1,25 @@
+import type {
+  AskUserQuestionAnswer,
+  AskUserQuestionRequest,
+} from "@deepseek-ai/dsh-user-questions";
+export function validateAnswer(
+  questions: AskUserQuestionRequest["questions"],
+  value: unknown,
+): AskUserQuestionAnswer;
+export function createQuestionBridge(): {
+  close(): void;
+  list(sessionId: string): {
+    id: string;
+    questions: AskUserQuestionRequest["questions"];
+    createdAt: string;
+  }[];
+  answer(sessionId: string, id: string, answer: unknown): void;
+  ask(
+    request: AskUserQuestionRequest,
+    next: () => Promise<AskUserQuestionAnswer>,
+  ): Promise<AskUserQuestionAnswer>;
+};
+export function projectQuestions<T>(
+  conversation: T,
+  bridge?: ReturnType<typeof createQuestionBridge>,
+): T;

package/template/apps/agent-server/plugins/questions.mjs

@@ -0,0 +1,142 @@
+import { randomUUID } from "node:crypto";
+
+function invalid(message = "请完整回答当前问题。", status = 400) {
+  throw Object.assign(new Error(message), { status });
+}
+export function validateAnswer(questions, value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    Object.keys(value).some((key) => key !== "answers") ||
+    !Array.isArray(value.answers) ||
+    value.answers.length !== questions.length
+  )
+    invalid();
+  const seen = new Set();
+  for (const item of value.answers) {
+    if (
+      !item ||
+      typeof item !== "object" ||
+      Array.isArray(item) ||
+      Object.keys(item).some(
+        (key) => !["id", "selected", "custom"].includes(key),
+      )
+    )
+      invalid();
+    const question = questions.find((entry) => entry.id === item.id);
+    if (
+      !question ||
+      seen.has(item.id) ||
+      !Array.isArray(item.selected) ||
+      new Set(item.selected).size !== item.selected.length ||
+      item.selected.some(
+        (label) => !question.options?.some((option) => option.label === label),
+      ) ||
+      (item.custom !== undefined &&
+        (typeof item.custom !== "string" || item.custom.length > 4000)) ||
+      (!item.selected.length && !item.custom?.trim()) ||
+      (!question.multiSelect &&
+        item.selected.length + Number(Boolean(item.custom?.trim())) > 1)
+    )
+      invalid();
+    seen.add(item.id);
+  }
+  return value;
+}
+
+/** One live request, two answer surfaces; whichever human answers first settles it. */
+export function createQuestionBridge() {
+  const pending = new Map();
+  return {
+    close() {
+      for (const item of pending.values()) item.cancel();
+      pending.clear();
+    },
+    list(sessionId) {
+      return [...pending.values()]
+        .filter((item) => item.sessionId === sessionId)
+        .map(({ id, questions, createdAt }) => ({ id, questions, createdAt }));
+    },
+    answer(sessionId, id, answer) {
+      const item = pending.get(id);
+      if (!item || item.sessionId !== sessionId)
+        invalid("问题已结束，请刷新会话。", 409);
+      validateAnswer(item.questions, answer);
+      pending.delete(id);
+      item.resolve(answer);
+    },
+    async ask(request, next) {
+      const sessionId = request.agent?.session?.id;
+      if (!sessionId) return next();
+      if (
+        new Set(request.questions.map((question) => question.id)).size !==
+        request.questions.length
+      )
+        invalid("问题标识重复，请重新组织追问。");
+      // Provider call IDs are not globally unique across sessions or child agents.
+      const id = randomUUID();
+      const controller = new AbortController();
+      const originalSignal = request.signal;
+      const signal = originalSignal
+        ? AbortSignal.any([originalSignal, controller.signal])
+        : controller.signal;
+      signal.throwIfAborted();
+      // The public waterfall payload is separate from the service request. The
+      // same lifetime closes the official UI when the floating surface answers.
+      request.signal = signal;
+      let abort;
+      const local = new Promise((resolve, reject) => {
+        abort = () =>
+          reject(
+            Object.assign(new Error("Question cancelled"), {
+              code: "ASK_ABORTED",
+            }),
+          );
+        signal.addEventListener("abort", abort, { once: true });
+        pending.set(id, {
+          id,
+          sessionId,
+          questions: structuredClone(request.questions),
+          createdAt: new Date().toISOString(),
+          resolve,
+          cancel: () => controller.abort(),
+        });
+      });
+      const official = Promise.resolve()
+        .then(next)
+        .catch((error) => {
+          if (error?.code === "NO_PROVIDER") return local;
+          throw error;
+        });
+      try {
+        return await Promise.race([local, official]);
+      } finally {
+        pending.delete(id);
+        signal.removeEventListener("abort", abort);
+        controller.abort();
+      }
+    },
+  };
+}
+
+export function projectQuestions(conversation, bridge) {
+  const questions = bridge?.list(conversation.id) ?? [];
+  if (!questions.length) return conversation;
+  return {
+    ...conversation,
+    messages: [
+      ...conversation.messages.filter(
+        (message) => message.id !== `pending-${conversation.id}`,
+      ),
+      ...questions.map((question) => ({
+        id: `question-${question.id}`,
+        role: "assistant",
+        content: "",
+        createdAt: question.createdAt,
+        status: "pending",
+        clarification: question,
+      })),
+    ],
+  };
+}

package/template/apps/agent-server/plugins/questions.test.ts

@@ -0,0 +1,105 @@
+import { expect, test } from "bun:test";
+import type { Agent } from "@deepseek-ai/dsh-agent";
+import { SessionId } from "@deepseek-ai/dsh-session";
+import { ToolCallId } from "@deepseek-ai/dsh-llm";
+import { createQuestionBridge, validateAnswer } from "./questions.mjs";
+
+const questions = [
+  {
+    id: "format",
+    question: "需要哪种格式？",
+    options: [{ label: "HTML" }, { label: "PPT" }],
+  },
+];
+const answer = { answers: [{ id: "format", selected: ["HTML"] }] };
+const agent = { session: { id: SessionId("own-session") } } as Agent;
+const noProvider = async () => {
+  throw Object.assign(new Error(), { code: "NO_PROVIDER" });
+};
+
+test("answers settle only the owning session exactly once", async () => {
+  const bridge = createQuestionBridge();
+  const waiting = bridge.ask(
+    { agent, questions, signal: new AbortController().signal },
+    noProvider,
+  );
+  const question = bridge.list("own-session")[0]!;
+  expect(bridge.list("other-session")).toEqual([]);
+  expect(() => bridge.answer("other-session", question.id, answer)).toThrow();
+  bridge.answer("own-session", question.id, answer);
+  expect(await waiting).toEqual(answer);
+  expect(() => bridge.answer("own-session", question.id, answer)).toThrow();
+});
+
+test("official workbench response wins without duplicate floating reply; cancellation and disposal clear pending", async () => {
+  const bridge = createQuestionBridge();
+  expect(await bridge.ask({ agent, questions }, async () => answer)).toEqual(
+    answer,
+  );
+  expect(bridge.list("own-session")).toEqual([]);
+  for (const dispose of [false, true]) {
+    const controller = new AbortController();
+    const waiting = bridge.ask(
+      { agent, questions, signal: controller.signal },
+      noProvider,
+    );
+    const rejected = waiting.catch((error: unknown) => error);
+    if (dispose) bridge.close();
+    else controller.abort();
+    expect(await rejected).toMatchObject({ code: "ASK_ABORTED" });
+    expect(bridge.list("own-session")).toEqual([]);
+  }
+});
+
+test("server rejects omitted, duplicated, unknown and contradictory choices before settling", () => {
+  for (const invalid of [
+    {},
+    { answers: [] },
+    { answers: [{ id: "other", selected: ["HTML"] }] },
+    { answers: [{ id: "format", selected: ["forged"] }] },
+    { answers: [{ id: "format", selected: ["HTML", "PPT"] }] },
+    { answers: [{ id: "format", selected: ["HTML"], custom: "different" }] },
+    { answers: [{ id: "format", selected: [], custom: " " }] },
+    { answers: [{ id: "format", selected: [], custom: "x".repeat(4001) }] },
+    { answers: [{ id: "format", selected: ["HTML"], approved: true }] },
+  ])
+    expect(() => validateAnswer(questions, invalid)).toThrow();
+  expect(
+    validateAnswer(questions, {
+      answers: [{ id: "format", selected: [], custom: "Word" }],
+    }),
+  ).toBeDefined();
+  expect(
+    validateAnswer([{ ...questions[0]!, multiSelect: true }], {
+      answers: [{ id: "format", selected: ["HTML", "PPT"], custom: "附来源" }],
+    }),
+  ).toBeDefined();
+});
+
+test("duplicate question identities fail before creating an impossible answer form", async () => {
+  const bridge = createQuestionBridge();
+  await expect(
+    bridge.ask(
+      { agent, questions: [questions[0]!, questions[0]!] },
+      noProvider,
+    ),
+  ).rejects.toThrow("问题标识重复");
+  expect(bridge.list("own-session")).toEqual([]);
+});
+
+test("concurrent sessions do not share a question identity or answer", async () => {
+  const bridge = createQuestionBridge();
+  const other = { session: { id: SessionId("other-session") } } as Agent;
+  const wait = { callId: ToolCallId("same-provider-call") };
+  const first = bridge.ask({ agent, questions, wait }, noProvider);
+  const second = bridge.ask({ agent: other, questions, wait }, noProvider);
+  const a = bridge.list("own-session")[0]!,
+    b = bridge.list("other-session")[0]!;
+  expect(a.id).not.toBe(b.id);
+  expect(() => bridge.answer("own-session", b.id, answer)).toThrow();
+  bridge.answer("own-session", a.id, answer);
+  expect(await first).toEqual(answer);
+  expect(bridge.list("other-session")).toHaveLength(1);
+  bridge.answer("other-session", b.id, answer);
+  expect(await second).toEqual(answer);
+});

package/template/apps/agent-server/plugins/settings/README.md

@@ -0,0 +1,17 @@
+# Windy工作台设置策略
+
+使用官方 Host profile 禁用账号/API 登录 UI、官方 Session Log 上传实现和对应设置 UI，以及服务端打开本机应用能力。Windy统一认证和模型代理保持产品管理；独立的 SettingsController Adapter 在 RPC 层拒绝打开服务器配置文件。
+
+Client 使用公开 slot 的 priority shadowing 隐藏 `settings.action/open-document` 与 `settings.general.item/current-version`。换行图标按钮位于配置预览框右上方，不占设置页标题栏；保留 `aria-pressed`、Tooltip 与 `Alt+Z`。默认换行，关闭后横向滚动。alpha.3 未提供预览工具栏插槽，因此适配器仅观察语义 `[role="dialog"] pre`，在代码块前插入自有工具栏，不移动或复制上游 React 节点，不匹配中文文案或打包类名。关闭对话框或卸载时清理按钮、快捷键与样式；升级 DSH 后需要核对这个窄 DOM 边界。
+
+默认预设显示名为「Windy Agent」，内部 ID 仍为 `windy`，历史会话与子任务配置继续兼容。输入框的轮次/步数、用量及上下文状态沿用上游原位布局，不再挪到模型选择旁；输入区域使用公开 `data-composer-seat` 增加至少 16px 的底部留白，并兼容设备安全区。
+
+“权限”是 DSH 对工作目录文件写入、命令执行以及执行前确认的权限预设，不是Windy业务 RBAC。业务数据仍逐次经过当前用户的Windy MCP 授权；选择 DSH 权限模式不会提高业务数据权限。Host 未连接时权限目录不可用，应恢复连接，而不是放宽模式。
+
+“内置插件”是上游只读运行清单，显示停用通常来自部署 profile 或缺少依赖，不提供任意开关。用户安装/管理扩展由独立插件管理入口承载；部署禁用的模型、联网和上传插件不能靠该清单开启。
+
+## 固定业务预设
+
+`native/profile.ts` 禁用官方纯展示插件 `ui-agent-preset`，因此首页不提供预设选择，设置页也不登记预设导航；不以空组件 shadow 留下空白导航。服务端 `preset-registry.mjs` 将默认值固定为 `windy`，拒绝选择、注册或挂载其它 ID；`settings-controller.mjs` 拒绝写入 `agent-preset-registry` 命名空间。界面隐藏和 RPC 策略分别验证。
+
+`windy` 是产品自定义业务预设，复用标准任务执行工具并按业务收敛，叠加当前用户获准的业务查询、文件处理、受治理协作与中文摘要。它既不是上游 `standard` 的别名，也不开放 `cordis` 创造模式的运行时检查和预设创作能力。个人技能与可信插件管理沿用原权限边界，不能通过设置写入改变固定默认值。

package/template/apps/agent-server/plugins/settings/client.js

@@ -0,0 +1,102 @@
+window.__ModuleLoader__.load({
+  id: "@southwind-ai/dsh-settings",
+  factory() {
+    // alpha.3 has no preset viewer toolbar slot. Bind to semantic dialog/pre
+    // boundaries and add only our own sibling; React still owns its code node.
+    function mountConfigurationWrap(pre) {
+      let wrap = true;
+      const toolbar = document.createElement("div");
+      toolbar.className = "windy-config-toolbar";
+      const button = document.createElement("button");
+      button.type = "button";
+      button.className = "windy-config-wrap";
+      button.setAttribute("aria-label", "配置换行");
+      button.setAttribute("aria-keyshortcuts", "Alt+Z");
+      button.innerHTML =
+        '<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.7" aria-hidden="true"><path d="M3 5h18M3 10h13a4 4 0 0 1 0 8h-4m3-3-3 3 3 3M3 15h4"/></svg>';
+      toolbar.append(button);
+      pre.before(toolbar);
+      pre.classList.add("windy-config-code");
+      function render() {
+        button.setAttribute("aria-pressed", String(wrap));
+        button.title = `配置换行：${wrap ? "开" : "关"}（Alt+Z）`;
+        pre.style.whiteSpace = wrap ? "pre-wrap" : "pre";
+        pre.style.overflowWrap = wrap ? "anywhere" : "normal";
+      }
+      const before = {
+        whiteSpace: pre.style.whiteSpace,
+        overflowWrap: pre.style.overflowWrap,
+      };
+      const toggle = () => {
+        wrap = !wrap;
+        render();
+      };
+      const onKey = (event) => {
+        if (
+          !event.altKey ||
+          event.ctrlKey ||
+          event.metaKey ||
+          event.shiftKey ||
+          event.repeat ||
+          event.isComposing ||
+          event.code !== "KeyZ"
+        )
+          return;
+        const previews = document.querySelectorAll('[role="dialog"] pre');
+        if (previews[previews.length - 1] !== pre) return;
+        event.preventDefault();
+        event.stopPropagation();
+        toggle();
+      };
+      button.addEventListener("click", toggle);
+      window.addEventListener("keydown", onKey, true);
+      render();
+      return () => {
+        button.removeEventListener("click", toggle);
+        window.removeEventListener("keydown", onKey, true);
+        toolbar.remove();
+        pre.classList.remove("windy-config-code");
+        Object.assign(pre.style, before);
+      };
+    }
+    function observeConfiguration() {
+      const bound = new Map();
+      function reconcile() {
+        for (const [pre, dispose] of bound) {
+          if (!pre.isConnected || !pre.closest('[role="dialog"]')) {
+            dispose();
+            bound.delete(pre);
+          }
+        }
+        for (const pre of document.querySelectorAll('[role="dialog"] pre')) {
+          if (!bound.has(pre)) bound.set(pre, mountConfigurationWrap(pre));
+        }
+      }
+      const observer = new MutationObserver(reconcile);
+      observer.observe(document.body, { childList: true, subtree: true });
+      reconcile();
+      return () => {
+        observer.disconnect();
+        for (const dispose of bound.values()) dispose();
+        bound.clear();
+      };
+    }
+    function apply(ctx) {
+      for (const [name, id] of [
+        ["settings.general.item", "current-version"],
+        ["settings.action", "open-document"],
+      ]) {
+        ctx.slots.inject(name, () =>
+          ctx.slots.register({ name, id, priority: -100 }, () => null),
+        );
+      }
+      ctx.effect(observeConfiguration, "windy-settings.configuration-wrap");
+    }
+    return {
+      inject: ["slots"],
+      apply,
+      mountConfigurationWrap,
+      observeConfiguration,
+    };
+  },
+});

package/template/apps/agent-server/plugins/settings/index.mjs

@@ -0,0 +1,17 @@
+export const name = "windy-settings";
+export const inject = ["webServer"];
+
+export function apply(ctx) {
+  ctx.on("webserver/index-inject", (table) => {
+    table.push({
+      kind: "style",
+      text: `
+.windy-config-toolbar { display:flex; justify-content:flex-end; margin-bottom:6px; }
+.windy-config-wrap { display:inline-flex; align-items:center; justify-content:center; width:32px; height:32px; padding:0; border:0; border-radius:var(--dsw-radius-sm); background:transparent; color:var(--dsw-alias-label-tertiary); cursor:pointer; }
+.windy-config-wrap:hover, .windy-config-wrap[aria-pressed="true"] { background:var(--dsw-alias-interactive-bg-hover); color:var(--dsw-alias-label-primary); }
+.windy-config-wrap:focus-visible { outline:var(--dsw-focus-ring-width, 2px) solid var(--dsw-focus-ring-color, currentColor); outline-offset:2px; }
+.windy-config-code { min-width:0; overflow:auto; }
+`,
+    });
+  });
+}

package/template/apps/agent-server/plugins/settings/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "@southwind-ai/dsh-settings",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./index.mjs",
+    "./client": "./client.js",
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-settings-general"
+      ]
+    }
+  }
+}