dsh-loop-engine 1.0.0-rc3 → 1.0.0-rc4

package/README.md

@@ -7,23 +7,6 @@ Switch the agent loop engine of **dsh web** the same way you switch a model: a
 built-in in-process loop, the Claude Code CLI, the Codex CLI, or the Pi CLI —
 without changing anything in the main repository.
 
-## What it does
-
-- **Engine chosen from Settings, not from code.** Pick `in-process` (default),
-  `claude-code`, `codex`, or `pi` in the settings page; the choice is stored
-  durably and survives profile edits.
-- **Claude Code execution.** The Claude Code CLI drives agents, with token
-  streaming forwarded into the session log.
-- **Codex execution.** The driver spawns `codex app-server` and streams its
-  token-level deltas into the session log, one turn per step.
-- **Pi execution.** The driver spawns `pi --mode rpc` and streams its
-  `message_update` deltas into the session log, one stateless `new_session` +
-  `prompt` per step.
-- **Extensible.** Adding an engine is one driver module plus one entry in the
-  settings schema.
-- **Zero main-repo changes.** Installed purely as a profile dependency plus one
-  bundle layer, with no edits to the main repository.
-
 ## Install
 
 ```sh
@@ -32,13 +15,12 @@ dsh plugin --profile web add dsh-loop-engine
 
 Restart `dsh web`, then open **Settings → Loop engine**.
 
-`dsh plugin add` installs the package into the web profile and registers it as
-a bundle layer — the package declares `dsh.bundle.patch`, so no manual edit of
-`cordis.patch.yml` is needed. It is published on npm as `dsh-loop-engine`.
+> Switching engines rewrites a small managed block in `cordis.patch.yml`.
+> Everything else you wrote in that file is preserved; only the plugin's own
+> span changes.
 
 ### Requirements
 
-- dsh `0.1.1-rc.2` (or a build whose peer packages match).
 - For the Claude Code engine: the Claude Code CLI installed and logged in on
   the host.
 - For the Codex engine: authenticated either via `codex login` on the host or a
@@ -46,93 +28,33 @@ a bundle layer — the package declares `dsh.bundle.patch`, so no manual edit of
 - For the Pi engine: authenticated the way `pi` expects (its own
   `~/.pi/agent/auth.json` or the provider's API-key environment variable such as
   `ANTHROPIC_API_KEY`).
-- When the harness runs from a **source checkout** (e.g. `pnpm dsh` inside the
-  `deepseek-harness` repository), the profile must resolve this plugin's
-  harness peer packages to the monorepo **sources** via local `file:` shims
-  (the profile's `shims/` directory). A deployed install with one published
-  `node_modules` needs no shims.
-
-> Switching engines rewrites a small managed block in `cordis.patch.yml`.
-> Everything else you wrote in that file is preserved; only the plugin's own
-> span changes.
-
-### Local development
-
-To work against a checkout instead of the published package, add it with a
-`file:` reference (build it first — the package has no `prepare` script, so
-pnpm will not build it for you):
-
-```sh
-cd /path/to/dsh-loop-engine && pnpm install && pnpm run build
-dsh plugin --profile web add file:/path/to/dsh-loop-engine
-```
-
-Or, from inside the checkout: `dsh plugin --profile web add .`
 
 ## Usage
 
-1. Open **Settings → Loop engine**.
-2. Choose an engine:
-   - **In-process** (default) — the built-in loop driver;
-   - **Claude Code CLI** — the Claude Code driver;
-   - **Codex CLI** — the OpenAI Codex driver;
-   - **Pi CLI** — the Pi (earendil-works/pi) driver.
-3. Switching between these applies after restarting `dsh web`. To return
-   to the default, pick **In-process** and restart again.
-4. To remove the plugin: `dsh plugin --profile web remove dsh-loop-engine`, then
+1. Pick an engine in **Settings → Loop engine** — `in-process` (default),
+   `claude-code`, `codex`, or `pi` — then restart `dsh web`.
+2. To return to the default, pick **In-process** and restart again.
+3. To remove the plugin: `dsh plugin --profile web remove dsh-loop-engine`, then
    restart `dsh web`.
 
-### Codex engine details
-
-The driver bypasses the `@openai/codex-sdk` (which only exposes whole-item
-output) and spawns `codex app-server` as a child process, speaking JSON-RPC
-over stdio. The app-server streams **token-level deltas** via
-`item/agentMessage/delta` and `item/reasoning/summaryTextDelta`, so thinking
-and replies paint progressively in the session — like the Claude Code engine.
-
-- **Streaming.** Reasoning deltas and agent-message deltas are forwarded live
-  as `assistant/chunk` events; durable messages land at the correct step
-  boundaries with usage attached on turn completion.
-- **Skills.** The Codex engine registers a skill provider that surfaces
-  `AGENTS.md` (project root and `~/.codex/AGENTS.md`) through the same dsh
-  skill-injection seam as Claude skills.
-- **No interactive tool approval.** Permissions are the declarative
-  `sandboxMode` + `approvalPolicy` pair resolved per query from the session's
-  permission knobs (or pinned via the plugin's `sandboxMode`/`approvalPolicy`
-  config). A session `ask` policy maps to `on-request`, whose CLI prompt
-  degrades to a denial in the unattended dsh runtime.
-- **No dsh subprocess sandbox integration.** The driver spawns `codex
-  app-server` itself; the dsh subprocess service (and its sandbox) does not
-  wrap it.
-- **No engine-specific slash commands** are registered for Codex in this
-  version.
-
-### Pi engine details
-
-The driver spawns `pi --mode rpc` as a child process and speaks the strict-LF
-(`\n`) JSONL protocol over stdio — never a generic line reader, because Pi
-allows Unicode separators like U+2028 inside JSON strings. It runs **one
-stateless session per dsh step**: a fresh `new_session`, then a single `prompt`
-carrying the serialized session history. Like the Codex/Claude drivers, Pi owns
-its own system prompt natively, so the dsh system-prompt assembly is not run —
-the durable session log remains the sole source of model context.
-
-- **Streaming.** `message_update` deltas (`text_delta` / `thinking_delta`) are
-  forwarded live as `assistant/chunk` events; tool calls and results land as
-  `tool/call` + `tool/result`, and usage is attached on `turn_end`.
-- **Sandboxed by the dsh subprocess seam.** Pi has **no permission system** ("it
-  runs with the permissions of the user"), so the driver routes the whole `pi`
-  child through the dsh subprocess service and prunes `--tools` to the resolved
-  sandbox stance — `read-only` (default), `workspace-write`, or
-  `danger-full-access` (no pruning). An `ask` policy degrades to a read-only
-  denial because Pi has no interactive approval callback.
-- **Skills.** The Pi engine registers a skill provider that surfaces
-  `AGENTS.md` (project root and `~/.pi/AGENTS.md`) through the same dsh
-  skill-injection seam.
-- **Model/provider.** Provider and model are passed to the child via
-  `--provider` / `--model` (a pinned `thinkingLevel` is appended as
-  `:<level>`); when omitted, Pi's native settings own the model.
+### Engine notes
+
+- The Claude Code driver runs one SDK query per step; its slash commands are
+  bridged into the web menu (built-ins plus user-level `~/.claude/commands/`)
+  and forwarded to the engine, which expands them natively. Project-level
+  `.claude/commands/` files stay engine-side and also work typed directly.
+- The Codex driver runs `codex app-server` and has no interactive tool
+  approval — permissions come from the session's `sandboxMode` +
+  `approvalPolicy`. Its `AGENTS.md` instruction files are surfaced through the
+  dsh skill-injection seam across every directory from the session cwd up to
+  the git root, plus `~/.codex/AGENTS.md`.
+- The Pi driver runs `pi --mode rpc`; Pi has no permission system, so the whole
+  child is sandboxed through the dsh subprocess service (default `read-only`).
+  Its context files (`AGENTS.md`/`CLAUDE.md` with `AGENTS.override.md`
+  preferred, plus the user-level file under the pi config dir) and its
+  `skills/` catalogs (`~/.pi/agent/skills/` and `.pi/skills/`) are surfaced
+  through the dsh skill-injection seam.
 
 ## License
 
-MIT
+MIT

package/README.zh.md

@@ -4,15 +4,6 @@
 
 像切换模型一样切换 **dsh web** 的 agent 循环引擎:设置页的「Loop engine」下拉选择运行 agent 的驱动——内置 in-process 循环、Claude Code CLI、Codex CLI,或 Pi CLI——**无需改动主仓库**。
 
-## 能做什么
-
-- **引擎由设置决定,而非改代码。** 在设置页选 `in-process`(默认)、`claude-code`、`codex` 或 `pi`,选择持久保存,编辑 profile 也不丢失。
-- **Claude Code 执行。** 由 Claude Code CLI 驱动 agent,并把 token 流式转发进会话日志。
-- **Codex 执行。** 驱动 spawn `codex app-server` 并把其 token 级增量流式转发进会话日志,每一步一个 turn。
-- **Pi 执行。** 驱动 spawn `pi --mode rpc` 并把其 `message_update` 增量流式转发进会话日志,每一步一个无状态 `new_session` + `prompt`。
-- **可扩展。** 新增引擎只需加一个驱动模块 + 设置 schema 里加一个枚举值。
-- **零主仓改动。** 仅作为 profile 依赖 + 一个 bundle 层安装,无需改动主仓库。
-
 ## 安装
 
 ```sh
@@ -21,59 +12,26 @@ dsh plugin --profile web add dsh-loop-engine
 
 重启 `dsh web`,然后打开 **Settings → Loop engine**。
 
-`dsh plugin add` 会把包装进 web profile,并注册为 bundle 层——包声明了 `dsh.bundle.patch`,所以无需手动改 `cordis.patch.yml`。包已发布到 npm,名称 `dsh-loop-engine`。
+> 切换引擎会重写 `cordis.patch.yml` 中一小段受管理的内容,文件里你写的其它部分都会保留,只改动插件自己的区间。
 
 ### 环境要求
 
-- dsh `0.1.1-rc.2`(或 peer 包版本匹配的构建)。
 - 使用 Claude Code 引擎时需要本机已安装并登录 Claude Code CLI。
 - 使用 Codex 引擎时需要完成认证:本机执行过 `codex login`,或配置 `CODEX_API_KEY` 环境变量。
 - 使用 Pi 引擎时需要以 `pi` 要求的方式完成认证(其自身的 `~/.pi/agent/auth.json`,或提供方的 API-key 环境变量,如 `ANTHROPIC_API_KEY`)。
-- 当 harness 以**源码方式**运行(如在 `deepseek-harness` 仓库内执行 `pnpm dsh`)时,profile 需要把本插件的 harness peer 包解析到主仓 **源码**,通过 profile 的 `shims/` 目录里的本地 `file:` 垫片实现;正式部署(单一发布版 `node_modules`)则无需垫片。
-
-> 切换引擎会重写 `cordis.patch.yml` 中一小段受管理的内容,文件里你写的其它部分都会保留,只改动插件自己的区间。
-
-### 本地开发
-
-要加载本地 checkout 而非已发布包时,用 `file:` 引用添加(需先构建——本包没有 `prepare` 脚本,pnpm 不会替你构建):
-
-```sh
-cd /path/to/dsh-loop-engine && pnpm install && pnpm run build
-dsh plugin --profile web add file:/path/to/dsh-loop-engine
-```
-
-或者,在 checkout 目录内直接 `dsh plugin --profile web add .`
 
 ## 使用方法
 
-1. 打开 **Settings → Loop engine**。
-2. 选择引擎:
-   - **In-process**(默认)——内置循环驱动;
-   - **Claude Code CLI** —— Claude Code 驱动;
-   - **Codex CLI** —— OpenAI Codex 驱动;
-   - **Pi CLI** —— Pi(earendil-works/pi)驱动。
-3. 引擎之间切换在**重启 `dsh web` 后生效**;切回默认时选择 **In-process** 并再次重启即可。
-4. 卸载插件:`dsh plugin --profile web remove dsh-loop-engine`,然后重启 `dsh web`。
-
-### Codex 引擎的实现细节
-
-驱动绕过 `@openai/codex-sdk`(它只输出整条 item),改为 spawn `codex app-server` 子进程,通过 stdio 走 JSON-RPC。app-server 会流式输出 **token 级增量**(`item/agentMessage/delta` 与 `item/reasoning/summaryTextDelta`),因此思考与回复会在会话里逐步呈现——与 Claude Code 引擎一致。
-
-- **流式。** 推理增量与回复增量实时转发为 `assistant/chunk` 事件;持久化消息在正确的 step 边界落盘,turn 结束时附加用量。
-- **技能。** Codex 引擎注册了一个技能提供者,把 `AGENTS.md`(项目根与 `~/.codex/AGENTS.md`)通过与 Claude 技能相同的 dsh 技能注入接口暴露出来。
-- **无交互式工具审批。** 权限是声明式的 `sandboxMode` + `approvalPolicy` 组合,每次查询按会话的权限开关解析(也可通过插件的 `sandboxMode`/`approvalPolicy` 配置固定)。会话的 `ask` 策略映射为 `on-request`,其 CLI 交互提示在无人值守的 dsh 运行时会退化为拒绝。
-- **不接入 dsh subprocess 沙箱。** 驱动自行 spawn `codex app-server`,dsh 的 subprocess 服务(及其沙箱)不会包裹它。
-- **本版本不为 Codex 注册引擎专属斜杠命令。**
-
-### Pi 引擎的实现细节
+1. 在 **Settings → Loop engine** 选择引擎——`in-process`(默认)、`claude-code`、`codex` 或 `pi`——然后重启 `dsh web`。
+2. 要切回默认,选 **In-process** 再重启即可。
+3. 卸载插件:`dsh plugin --profile web remove dsh-loop-engine`,然后重启 `dsh web`。
 
-驱动 spawn `pi --mode rpc` 子进程,通过 stdio 走 strict-LF(`\n`)JSONL 协议——从不用通用行读取器,因为 Pi 允许在 JSON 字符串里使用 U+2028 等 Unicode 分隔符。它**每个 dsh step 运行一个无状态会话**:先 `new_session`,再发一条携带序列化会话历史的 `prompt`。与 Codex/Claude 驱动一样,Pi 原生拥有自己的 system prompt,因此不会运行 dsh 的 system-prompt 组装——持久化会话日志仍是模型上下文的唯一来源。
+### 引擎说明
 
-- **流式。** `message_update` 增量(`text_delta` / `thinking_delta`)实时转发为 `assistant/chunk` 事件;工具调用与结果落为 `tool/call` + `tool/result`,用量在 `turn_end` 附加。
-- **由 dsh subprocess 接口做沙箱化。** Pi **没有权限系统**("以用户权限运行"),因此驱动把整个 `pi` 子进程经由 dsh subprocess 服务转发,并把 `--tools` 裁剪到已解析的沙箱立场——`read-only`(默认)、`workspace-write` 或 `danger-full-access`(不裁剪)。`ask` 策略退化为只读拒绝,因为 Pi 没有交互式审批回调。
-- **技能。** Pi 引擎注册了一个技能提供者,把 `AGENTS.md`(项目根与 `~/.pi/AGENTS.md`)通过与 Claude 技能相同的 dsh 技能注入接口暴露出来。
-- **模型/提供方。** 通过 `--provider` / `--model` 传给子进程(固定的 `thinkingLevel` 会追加为 `:<level>`);省略时由 Pi 原生设置接管模型。
+- Codex 驱动运行 `codex app-server`,没有交互式工具审批——权限来自会话的 `sandboxMode` + `approvalPolicy`。
+- Pi 驱动运行 `pi --mode rpc`;Pi 没有权限系统,所以整个子进程经 dsh subprocess 服务做沙箱化(默认 `read-only`)。
+- 两者都往会话日志流式输出,并通过 dsh 技能注入接口暴露 `AGENTS.md`。
 
 ## License
 
-MIT
+MIT

package/lib/client.js

@@ -93,6 +93,20 @@ var error = {
   fontSize: 13,
   color: "var(--dsw-alias-state-error-primary)"
 };
+var toggleRow = {
+  display: "flex",
+  alignItems: "center",
+  gap: 8,
+  fontSize: 13,
+  color: "var(--dsw-alias-label-primary)",
+  cursor: "pointer"
+};
+var toggleCheckbox = {
+  width: 16,
+  height: 16,
+  accentColor: "var(--dsw-alias-brand-primary, var(--dsw-alias-label-primary))",
+  cursor: "pointer"
+};
 var confirmBody = {
   margin: 0,
   fontSize: 13,
@@ -101,7 +115,7 @@ var confirmBody = {
 };
 function LoopEngineSection(props) {
   const { controller, useSnapshot, t } = props;
-  const { status, engine, writable } = useSnapshot((snapshot) => snapshot);
+  const { status, engine, showInComposer, writable } = useSnapshot((snapshot) => snapshot);
   const [open, setOpen] = (0, import_react.useState)(false);
   const [pending, setPending] = (0, import_react.useState)(null);
   const navId = (0, import_react.useId)();
@@ -171,6 +185,21 @@ function LoopEngineSection(props) {
     ),
     status === "saving" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: notice, children: t("saving") }) : /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: notice, children: t("switchNotice") }),
     engine === "claude-code" ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: notice, children: t("claudeModelNotice") }) : null,
+    /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { style: toggleRow, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+        "input",
+        {
+          type: "checkbox",
+          checked: showInComposer,
+          disabled,
+          style: toggleCheckbox,
+          onChange: (event) => {
+            void controller.setShowInComposer(event.currentTarget.checked);
+          }
+        }
+      ),
+      t("showInComposerLabel")
+    ] }),
     /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
       import_dsh_client_ui_primitives.Modal,
       {
@@ -216,12 +245,140 @@ function LoopEngineBadge(props) {
   ] });
 }
 
+// src/client/LoopEngineComposerSelect.tsx
+var import_react2 = require("react");
+var import_dsh_client_ui_primitives2 = require("@deepseek-ai/dsh-client-ui-primitives");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var ENGINE_OPTIONS2 = [
+  { value: "in-process", key: "engineInProcess" },
+  { value: "claude-code", key: "engineClaudeCode" },
+  { value: "codex", key: "engineCodex" },
+  { value: "pi", key: "enginePi" }
+];
+function engineLabelKey2(engine) {
+  switch (engine) {
+    case "claude-code":
+      return "engineClaudeCode";
+    case "codex":
+      return "engineCodex";
+    case "pi":
+      return "enginePi";
+    default:
+      return "engineInProcess";
+  }
+}
+var trigger2 = {
+  appearance: "none",
+  boxSizing: "border-box",
+  display: "inline-flex",
+  alignItems: "center",
+  gap: 6,
+  padding: "4px 8px",
+  border: "1px solid var(--dsw-alias-border-l2)",
+  borderRadius: 10,
+  background: "var(--dsw-alias-bg-layer-1)",
+  color: "var(--dsw-alias-label-primary)",
+  font: "inherit",
+  fontSize: 12,
+  lineHeight: "20px",
+  whiteSpace: "nowrap",
+  cursor: "pointer"
+};
+var triggerDisabled2 = { ...trigger2, opacity: 0.5, cursor: "default" };
+var confirmBody2 = {
+  margin: 0,
+  fontSize: 13,
+  lineHeight: 1.55,
+  color: "var(--dsw-alias-label-secondary)"
+};
+function LoopEngineComposerSelect(props) {
+  const { controller, useSnapshot, t } = props;
+  const { status, engine, showInComposer, writable } = useSnapshot((snapshot) => snapshot);
+  const [open, setOpen] = (0, import_react2.useState)(false);
+  const [pending, setPending] = (0, import_react2.useState)(null);
+  const triggerRef = (0, import_react2.useRef)(null);
+  if (status !== "ready" || !showInComposer) return null;
+  const disabled = !writable;
+  const label = t(engineLabelKey2(engine));
+  const title = engine === "claude-code" ? t("claudeModelNotice") : t("description");
+  const onSelect = (next) => {
+    setOpen(false);
+    const value = next;
+    if (value === engine) return;
+    setPending(value);
+  };
+  const confirmSwitch = () => {
+    const value = pending;
+    setPending(null);
+    if (value !== null) {
+      void controller.setEngine(value).then((landed) => {
+        if (landed) window.location.reload();
+      });
+    }
+  };
+  const cancelSwitch = () => {
+    setPending(null);
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_dsh_client_ui_primitives2.Menu,
+      {
+        open,
+        onClose: () => {
+          setOpen(false);
+        },
+        items: ENGINE_OPTIONS2.map((option) => ({ id: option.value, label: t(option.key) })),
+        selectedId: engine,
+        onSelect,
+        align: "start",
+        portal: true,
+        getAnchorRect: () => triggerRef.current?.getBoundingClientRect() ?? null,
+        anchor: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+          "button",
+          {
+            type: "button",
+            ref: triggerRef,
+            "aria-haspopup": "menu",
+            "aria-expanded": open,
+            disabled,
+            style: disabled ? triggerDisabled2 : trigger2,
+            title,
+            onClick: () => {
+              setOpen(!open);
+            },
+            children: [
+              label,
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.IconChevronDownOutline14, { size: 14 })
+            ]
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      import_dsh_client_ui_primitives2.Modal,
+      {
+        open: pending !== null,
+        onClose: cancelSwitch,
+        title: t("confirmTitle"),
+        footer: /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.Button, { variant: "outline", onClick: cancelSwitch, children: t("cancelAction") }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.Button, { variant: "primary", onClick: confirmSwitch, children: t("confirmAction") })
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: confirmBody2, children: t("confirmBody") })
+      }
+    )
+  ] });
+}
+
 // src/client/store.ts
 var import_client = require("@deepseek-ai/dsh-client-runtime/client");
 function decodeLoopEngine(section) {
   if (typeof section !== "object" || section === null || Array.isArray(section)) return void 0;
-  const engine = section.engine;
-  return engine === "in-process" || engine === "claude-code" || engine === "codex" || engine === "pi" ? { engine } : void 0;
+  const { engine, showInComposer } = section;
+  if (engine !== "in-process" && engine !== "claude-code" && engine !== "codex" && engine !== "pi") {
+    return void 0;
+  }
+  return { engine, showInComposer: showInComposer !== false };
 }
 var LoopEngineStore = class {
   /**
@@ -235,6 +392,7 @@ var LoopEngineStore = class {
   store = (0, import_client.createSnapshotStore)({
     status: "loading",
     engine: "in-process",
+    showInComposer: true,
     writable: false,
     error: null
   });
@@ -275,6 +433,36 @@ var LoopEngineStore = class {
     }
     return landed;
   }
+  /**
+   * Persist whether the composer shows the engine picker. Success is judged
+   * against the snapshot the write left behind, so a refused write reports
+   * error after its recovery. Unlike {@link setEngine}, landing does not reload
+   * the page — the toggle only changes composer visibility.
+   * @param show - whether the chat page composer reveals the engine picker.
+   * @returns whether the write landed.
+   */
+  async setShowInComposer(show) {
+    this.saving = true;
+    this.store.update((state) => {
+      state.status = "saving";
+      state.error = null;
+    });
+    try {
+      await this.scope.set("showInComposer", show);
+    } finally {
+      this.saving = false;
+    }
+    this.derive();
+    const { showInComposer: settled } = this.store.getSnapshot();
+    const landed = settled === show;
+    if (!landed) {
+      this.store.update((state) => {
+        state.status = "unavailable";
+        state.error = "the loop engine display setting did not persist";
+      });
+    }
+    return landed;
+  }
   /** Stop following the scope. */
   dispose() {
     this.following?.();
@@ -294,14 +482,17 @@ var LoopEngineStore = class {
         this.store.update((state) => {
           state.status = "unavailable";
           state.engine = "in-process";
+          state.showInComposer = true;
           state.error = null;
         });
         return;
       case "ready": {
         const engine = scope.value?.engine ?? "in-process";
+        const showInComposer = scope.value?.showInComposer ?? true;
         this.store.update((state) => {
           state.status = "ready";
           state.engine = engine;
+          state.showInComposer = showInComposer;
           state.writable = scope.writable;
           state.error = null;
         });
@@ -323,6 +514,7 @@ var zh = {
   engineClaudeCode: "Claude Code CLI",
   engineCodex: "Codex CLI",
   enginePi: "Pi CLI",
+  showInComposerLabel: "\u5728\u5BF9\u8BDD\u9875\u663E\u793A\u5F15\u64CE\u9009\u62E9\u5668",
   unavailable: "\u5FAA\u73AF\u5F15\u64CE\u8BBE\u7F6E\u4E0D\u53EF\u7528",
   switchNotice: "\u5207\u6362\u5F15\u64CE\u4F1A\u4E2D\u65AD\u5F53\u524D\u4F7F\u7528\u65E7\u5F15\u64CE\u8FD0\u884C\u4E2D\u7684\u4F1A\u8BDD\u3002",
   saving: "\u4FDD\u5B58\u4E2D\u2026",
@@ -339,6 +531,7 @@ var en = {
   engineClaudeCode: "Claude Code CLI",
   engineCodex: "Codex CLI",
   enginePi: "Pi CLI",
+  showInComposerLabel: "Show the engine selector in the chat page",
   unavailable: "Loop engine settings are unavailable",
   switchNotice: "Switching engines interrupts sessions currently running on the previous engine.",
   saving: "Saving\u2026",
@@ -398,6 +591,22 @@ function apply(ctx) {
       }, LoopEngineBadge);
     }, "loop-engine: session header engine badge");
   });
+  ctx.inject(["slots", "conversation"], (scope2) => {
+    const composerInjected = () => ({
+      controller,
+      hooks: { snapshot: controller.store },
+      t
+    });
+    scope2.effect(() => {
+      return scope2.slots.register({
+        name: "conversation.input.right",
+        id: "loop-engine",
+        order: 0,
+        locale: NS,
+        inject: composerInjected
+      }, LoopEngineComposerSelect);
+    }, "loop-engine: composer engine select");
+  });
 }
 return module.exports; } });
 //# sourceMappingURL=client.js.map