dsh-loop-engine 1.0.0-rc2

package/README.md

@@ -0,0 +1,151 @@
+# dsh-loop-engine
+
+[![npm version](https://img.shields.io/npm/v/dsh-loop-engine?color=cb3837)](https://www.npmjs.com/package/dsh-loop-engine)
+
+Switch the agent loop engine of **dsh web** the same way you switch a model: a
+"Loop engine" dropdown in Settings chooses which driver runs your agents — the
+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
+  composition row.
+
+## 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
+  `CODEX_API_KEY` environment entry.
+- 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.
+
+## Configuration
+
+1. Build the plugin:
+
+   ```sh
+   pnpm install && pnpm run build
+   ```
+
+2. Add the dependency in `$DSH_HOME/profiles/web/package.json`:
+
+   ```json
+   "dependencies": {
+     "dsh-loop-engine": "1.0.0-rc2",
+     "...keep existing deps"
+   }
+   ```
+
+   The package is published on npm as `dsh-loop-engine`. For local
+   development, use a `file:` reference to your checkout instead of the version
+   string.
+
+3. Append one composition row in `$DSH_HOME/profiles/web/cordis.patch.yml`:
+
+   ```yaml
+   - insert:
+       - id: loop-engine
+         name: 'dsh-loop-engine'
+   ```
+
+4. Install and restart:
+
+   ```sh
+   cd $DSH_HOME/profiles/web && pnpm install
+   ```
+
+   Restart `dsh web` once so the plugin is picked up.
+
+> 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.
+
+## 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: delete the `loop-engine` row from
+   `cordis.patch.yml`, drop the dependency from `package.json`, then
+   `pnpm install` and 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.
+
+## License
+
+MIT

package/README.zh.md

@@ -0,0 +1,93 @@
+# dsh-loop-engine
+
+[![npm version](https://img.shields.io/npm/v/dsh-loop-engine?color=cb3837)](https://www.npmjs.com/package/dsh-loop-engine)
+
+像切换模型一样切换 **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 依赖 + 一行组合配置安装。
+
+## 环境要求
+
+- 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`)则无需垫片。
+
+## 配置方法
+
+1. 构建插件:
+
+   ```sh
+   pnpm install && pnpm run build
+   ```
+
+2. 在 `$DSH_HOME/profiles/web/package.json` 添加依赖:
+
+   ```json
+   "dependencies": {
+     "dsh-loop-engine": "1.0.0-rc2",
+     "...保留其余依赖"
+   }
+   ```
+
+   包已发布到 npm,名称 `dsh-loop-engine`。本地开发时改用指向你本地代码副本的 `file:` 引用。
+
+3. 在 `$DSH_HOME/profiles/web/cordis.patch.yml` 追加一行组合:
+
+   ```yaml
+   - insert:
+       - id: loop-engine
+         name: 'dsh-loop-engine'
+   ```
+
+4. 安装并重启:
+
+   ```sh
+   cd $DSH_HOME/profiles/web && pnpm install
+   ```
+
+   重启一次 `dsh web` 使插件生效。
+
+> 切换引擎会重写 `cordis.patch.yml` 中一小段受管理的内容,文件里你写的其它部分都会保留,只改动插件自己的区间。
+
+## 使用方法
+
+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. 卸载插件:从 `cordis.patch.yml` 删除 `loop-engine` 行,并从 `package.json` 移除依赖,然后 `pnpm install` 并重启 `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 引擎的实现细节
+
+驱动 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 原生设置接管模型。
+
+## License
+
+MIT

package/lib/client.js

@@ -0,0 +1,403 @@
+var module = { exports: {} }; var exports = module.exports; window.__ModuleLoader__.load({ id: "dsh-loop-engine", factory: (require) => {
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var index_exports = {};
+__export(index_exports, {
+  apply: () => apply,
+  inject: () => inject
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/client/LoopEngineSection.tsx
+var import_react = require("react");
+var import_dsh_client_ui_primitives = require("@deepseek-ai/dsh-client-ui-primitives");
+var import_jsx_runtime = require("react/jsx-runtime");
+var ENGINE_OPTIONS = [
+  { value: "in-process", key: "engineInProcess" },
+  { value: "claude-code", key: "engineClaudeCode" },
+  { value: "codex", key: "engineCodex" },
+  { value: "pi", key: "enginePi" }
+];
+function engineLabelKey(engine) {
+  switch (engine) {
+    case "claude-code":
+      return "engineClaudeCode";
+    case "codex":
+      return "engineCodex";
+    case "pi":
+      return "enginePi";
+    default:
+      return "engineInProcess";
+  }
+}
+var shell = {
+  display: "flex",
+  flexDirection: "column",
+  gap: 12,
+  maxWidth: 720,
+  color: "var(--dsw-alias-label-primary)"
+};
+var titleStyle = {
+  margin: 0,
+  fontSize: 18,
+  fontWeight: 600
+};
+var intro = {
+  margin: 0,
+  fontSize: 13,
+  color: "var(--dsw-alias-label-tertiary)"
+};
+var trigger = {
+  appearance: "none",
+  boxSizing: "border-box",
+  display: "inline-flex",
+  alignItems: "center",
+  gap: 8,
+  width: "fit-content",
+  minWidth: 200,
+  padding: "9px 12px",
+  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: 13,
+  cursor: "pointer"
+};
+var triggerDisabled = { ...trigger, opacity: 0.5, cursor: "default" };
+var notice = {
+  margin: 0,
+  fontSize: 12,
+  color: "var(--dsw-alias-label-secondary)"
+};
+var error = {
+  margin: 0,
+  fontSize: 13,
+  color: "var(--dsw-alias-state-error-primary)"
+};
+var confirmBody = {
+  margin: 0,
+  fontSize: 13,
+  lineHeight: 1.55,
+  color: "var(--dsw-alias-label-secondary)"
+};
+function LoopEngineSection(props) {
+  const { controller, useSnapshot, t } = props;
+  const { status, engine, 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)();
+  const triggerRef = (0, import_react.useRef)(null);
+  if (status === "unavailable") {
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("section", { "aria-labelledby": navId, style: shell, children: [
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { id: navId, style: titleStyle, children: t("nav") }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: intro, children: t("description") }),
+      /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { role: "alert", style: error, children: t("unavailable") })
+    ] });
+  }
+  const disabled = status === "saving" || !writable;
+  const label = t(engineLabelKey(engine));
+  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_runtime.jsxs)("section", { "aria-labelledby": navId, style: shell, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { id: navId, style: titleStyle, children: t("nav") }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: intro, children: t("description") }),
+    /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      import_dsh_client_ui_primitives.Menu,
+      {
+        open,
+        onClose: () => {
+          setOpen(false);
+        },
+        items: ENGINE_OPTIONS.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_runtime.jsxs)(
+          "button",
+          {
+            type: "button",
+            ref: triggerRef,
+            "aria-haspopup": "menu",
+            "aria-expanded": open,
+            disabled,
+            style: disabled ? triggerDisabled : trigger,
+            onClick: () => {
+              setOpen(!open);
+            },
+            children: [
+              label,
+              /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.IconChevronDownOutline14, { size: 14 })
+            ]
+          }
+        )
+      }
+    ),
+    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.jsx)(
+      import_dsh_client_ui_primitives.Modal,
+      {
+        open: pending !== null,
+        onClose: cancelSwitch,
+        title: t("confirmTitle"),
+        footer: /* @__PURE__ */ (0, import_jsx_runtime.jsxs)(import_jsx_runtime.Fragment, { children: [
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { variant: "outline", onClick: cancelSwitch, children: t("cancelAction") }),
+          /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_dsh_client_ui_primitives.Button, { variant: "primary", onClick: confirmSwitch, children: t("confirmAction") })
+        ] }),
+        children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: confirmBody, children: t("confirmBody") })
+      }
+    )
+  ] });
+}
+
+// src/client/LoopEngineBadge.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var pill = {
+  display: "inline-flex",
+  alignItems: "center",
+  gap: 4,
+  padding: "2px 8px",
+  border: "1px solid var(--dsw-alias-border-l2)",
+  borderRadius: 999,
+  background: "var(--dsw-alias-bg-layer-1)",
+  color: "var(--dsw-alias-label-secondary)",
+  fontSize: 12,
+  lineHeight: "18px",
+  whiteSpace: "nowrap"
+};
+function LoopEngineBadge(props) {
+  const { useSnapshot, t } = props;
+  const { status, engine } = useSnapshot((state) => state);
+  if (status !== "ready") return null;
+  const label = t(
+    engine === "claude-code" ? "engineClaudeCode" : engine === "codex" ? "engineCodex" : engine === "pi" ? "enginePi" : "engineInProcess"
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: pill, title: t("description"), children: [
+    t("nav"),
+    " \xB7 ",
+    label
+  ] });
+}
+
+// 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;
+}
+var LoopEngineStore = class {
+  /**
+   * @param scope - the loop engine settings namespace scope.
+   */
+  constructor(scope) {
+    this.scope = scope;
+  }
+  scope;
+  /** uSES-safe state source shared by the registered settings section. */
+  store = (0, import_client.createSnapshotStore)({
+    status: "loading",
+    engine: "in-process",
+    writable: false,
+    error: null
+  });
+  following;
+  saving = false;
+  /** Begin following the bound scope and publish its current answer. */
+  load() {
+    this.following ??= this.scope.subscribe(() => {
+      this.derive();
+    });
+    this.derive();
+  }
+  /**
+   * Persist the selected engine. Success is judged against the snapshot the
+   * write left behind, so a refused write reports error after its recovery.
+   * @param engine - the engine to select for future Agent turns.
+   * @returns whether the write landed.
+   */
+  async setEngine(engine) {
+    this.saving = true;
+    this.store.update((state) => {
+      state.status = "saving";
+      state.error = null;
+    });
+    try {
+      await this.scope.set("engine", engine);
+    } finally {
+      this.saving = false;
+    }
+    this.derive();
+    const { engine: settled } = this.store.getSnapshot();
+    const landed = settled === engine;
+    if (!landed) {
+      this.store.update((state) => {
+        state.status = "unavailable";
+        state.error = "the loop engine selection did not persist";
+      });
+    }
+    return landed;
+  }
+  /** Stop following the scope. */
+  dispose() {
+    this.following?.();
+    this.following = void 0;
+  }
+  derive() {
+    if (this.saving) return;
+    const scope = this.scope.getSnapshot();
+    switch (scope.status) {
+      case "loading":
+        this.store.update((state) => {
+          state.status = "loading";
+          state.error = null;
+        });
+        return;
+      case "unavailable":
+        this.store.update((state) => {
+          state.status = "unavailable";
+          state.engine = "in-process";
+          state.error = null;
+        });
+        return;
+      case "ready": {
+        const engine = scope.value?.engine ?? "in-process";
+        this.store.update((state) => {
+          state.status = "ready";
+          state.engine = engine;
+          state.writable = scope.writable;
+          state.error = null;
+        });
+        return;
+      }
+      default: {
+        const exhaustive = scope.status;
+        throw new Error(`unexpected loop engine scope status: ${String(exhaustive)}`);
+      }
+    }
+  }
+};
+
+// src/client/locales.ts
+var zh = {
+  nav: "\u5FAA\u73AF\u5F15\u64CE",
+  description: "\u9009\u62E9\u9A71\u52A8\u4F1A\u8BDD\u7684 Agent \u6267\u884C\u5F15\u64CE\uFF0C\u5207\u6362\u5BF9\u540E\u7EED\u4F1A\u8BDD\u751F\u6548\u3002",
+  engineInProcess: "\u8FDB\u7A0B\u5185\u5F15\u64CE\uFF08\u9ED8\u8BA4\uFF09",
+  engineClaudeCode: "Claude Code CLI",
+  engineCodex: "Codex CLI",
+  enginePi: "Pi CLI",
+  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",
+  confirmTitle: "\u5207\u6362\u5FAA\u73AF\u5F15\u64CE\uFF1F",
+  confirmBody: "\u5207\u6362\u4F1A\u4E2D\u65AD\u5F53\u524D\u4F7F\u7528\u65E7\u5F15\u64CE\u8FD0\u884C\u4E2D\u7684\u4F1A\u8BDD\uFF0C\u786E\u8BA4\u540E\u9875\u9762\u5C06\u81EA\u52A8\u5237\u65B0\uFF0C\u65B0\u5BF9\u8BDD\u4F7F\u7528\u65B0\u5F15\u64CE\u3002\u786E\u8BA4\u5207\u6362\u5417\uFF1F",
+  confirmAction: "\u5207\u6362",
+  cancelAction: "\u53D6\u6D88",
+  claudeModelNotice: "\u5F53\u524D\u4F7F\u7528 Claude Code \u5F15\u64CE\uFF1A\u5B9E\u9645\u6A21\u578B\u7531 Claude Code \u539F\u751F\u51B3\u5B9A\uFF0C\u9875\u9762\u4E0A\u7684\u6A21\u578B\u9009\u62E9\u4E0D\u751F\u6548\u3002"
+};
+var en = {
+  nav: "Loop engine",
+  description: "Choose the agent execution engine that drives sessions; the switch applies to new turns.",
+  engineInProcess: "In-process engine (default)",
+  engineClaudeCode: "Claude Code CLI",
+  engineCodex: "Codex CLI",
+  enginePi: "Pi CLI",
+  unavailable: "Loop engine settings are unavailable",
+  switchNotice: "Switching engines interrupts sessions currently running on the previous engine.",
+  saving: "Saving\u2026",
+  confirmTitle: "Switch loop engine?",
+  confirmBody: "Switching interrupts sessions currently running on the previous engine; the page reloads after the switch and new turns use the new engine. Switch now?",
+  confirmAction: "Switch",
+  cancelAction: "Cancel",
+  claudeModelNotice: "Claude Code engine active: the actual model is decided natively by Claude Code; the model selector in this session has no effect."
+};
+
+// src/namespace.ts
+var LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL = "agent-loop-engine";
+
+// src/client/index.ts
+var NS = "settings.loop-engine";
+var inject = ["slots", "locale", "settingsScope"];
+function apply(ctx) {
+  ctx.effect(() => ctx.locale.register(NS, { zh, en }), "loop-engine: copy dictionaries");
+  const scope = ctx.settingsScope.bind({
+    namespace: LOOP_ENGINE_SETTINGS_NAMESPACE_LITERAL,
+    decode: decodeLoopEngine
+  });
+  const controller = new LoopEngineStore(scope);
+  ctx.effect(() => {
+    controller.load();
+    return () => {
+      controller.dispose();
+    };
+  }, "loop-engine: store lifecycle");
+  const t = ctx.locale.bind(NS);
+  const injected = () => ({
+    controller,
+    hooks: { snapshot: controller.store },
+    t
+  });
+  ctx.slots.inject("settings.section", () => ctx.slots.register({
+    name: "settings.section",
+    id: "loop-engine",
+    order: 30,
+    label: () => t("nav"),
+    inject: injected
+  }, LoopEngineSection));
+  ctx.inject(["slots", "conversation"], (scope2) => {
+    const badgeInjected = () => ({
+      hooks: { snapshot: controller.store },
+      t
+    });
+    scope2.effect(() => {
+      return scope2.slots.register({
+        name: "conversation.session.header.actions",
+        id: "loop-engine",
+        // Static session context precedes interactive actions (agent-preset's
+        // label sits at -10, so the engine chip leads the header).
+        order: -20,
+        locale: NS,
+        inject: badgeInjected
+      }, LoopEngineBadge);
+    }, "loop-engine: session header engine badge");
+  });
+}
+return module.exports; } });
+//# sourceMappingURL=client.js.map