dsh-loop-engine 0.1.5-rc3 → 0.1.5-rc4

package/lib/client.js

@@ -29,6 +29,36 @@ 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");
+
+// src/agent-preset-ids.ts
+var LOOP_ENGINE_IDS = ["in-process", "claude-code", "codex", "pi", "kimi"];
+var HOSTED_ENGINE_IDS = LOOP_ENGINE_IDS.filter(
+  (id) => id !== "in-process"
+);
+function isHostedEngine(engine) {
+  return engine !== void 0 && engine !== "in-process";
+}
+function isLoopEngineId(value) {
+  return LOOP_ENGINE_IDS.includes(value);
+}
+var LOOP_ENGINE_REFUSAL_CODES = [
+  "session-closed",
+  "turn-running",
+  "subagent-session",
+  "not-driven",
+  "router-unmounted",
+  "record-failed",
+  "rebuild-failed"
+];
+function isLoopEngineRefusalCode(value) {
+  return LOOP_ENGINE_REFUSAL_CODES.includes(value);
+}
+function hostedEngineOf(session) {
+  if (session.kind !== "engine" || session.engine === "in-process") return void 0;
+  return session.engine;
+}
+
+// src/client/LoopEngineSection.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
 var ENGINE_OPTIONS = [
   { value: "in-process", key: "engineInProcess" },
@@ -142,9 +172,7 @@ function LoopEngineSection(props) {
     const value = pending;
     setPending(null);
     if (value !== null) {
-      void controller.setEngine(value).then((landed) => {
-        if (landed) window.location.reload();
-      });
+      void controller.setEngine(value);
     }
   };
   const cancelSwitch = () => {
@@ -187,7 +215,7 @@ 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,
+    isHostedEngine(engine) ? /* @__PURE__ */ (0, import_jsx_runtime.jsx)("p", { style: notice, children: t("hostedEngineModelNotice") }) : null,
     /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("label", { style: toggleRow, children: [
       /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
         "input",
@@ -220,6 +248,316 @@ function LoopEngineSection(props) {
   ] });
 }
 
+// src/client/use-session-engine.ts
+var import_react2 = require("react");
+
+// src/client/turn-status.ts
+var ENGINE_ATTR = "data-loop-engine";
+var PLUGIN_ID = "dsh-loop-engine";
+var STYLESHEET = `
+[class$="_turnStatus"]::before {
+  margin-right: 6px;
+  background: none;
+  -webkit-background-clip: border-box;
+  background-clip: border-box;
+}
+
+/*
+ * The row's own sweep, re-asserted for hosted engines.
+ *
+ * ui-chat disables that animation under \`prefers-reduced-motion: reduce\`
+ * (ChatView.module.css), and a media query carries no specificity \u2014 so this
+ * attribute-gated rule outranks it. That is deliberate here: deployment images
+ * ship with Windows' client-area animation off (SPI_GETCLIENTAREAANIMATION
+ * false), and with the guard in force EVERY indicator on this row is frozen \u2014
+ * the sweep and the glyph alike. Scoped to hosted engines, so in-process
+ * sessions keep the stock reduced-motion behaviour; delete this rule and
+ * restore the guard at the foot of the sheet to hand the decision back to the OS.
+ */
+html[${ENGINE_ATTR}] [class$="_turnStatus"] {
+  background-position: 100% 0;
+  background-size: 250% 100%;
+  animation: le-shimmer 1.8s linear infinite;
+}
+
+@keyframes le-shimmer {
+  to { background-position: 0 0; }
+}
+
+html[${ENGINE_ATTR}="claude-code"] [class$="_turnStatus"] {
+  --dsw-static-deepseek-500: #d97757;
+  --dsw-static-deepseek-200: #f5bda6;
+}
+html[${ENGINE_ATTR}="claude-code"] [class$="_turnStatus"]::before {
+  content: "\u273B";
+  color: #d97757;
+  -webkit-text-fill-color: #d97757;
+  animation: le-bloom 1.6s ease-in-out infinite;
+}
+
+html[${ENGINE_ATTR}="codex"] [class$="_turnStatus"] {
+  --dsw-static-deepseek-500: #a9b1c0;
+  --dsw-static-deepseek-200: #e6eaf2;
+}
+html[${ENGINE_ATTR}="codex"] [class$="_turnStatus"]::before {
+  content: "\u2022";
+  color: #a9b1c0;
+  -webkit-text-fill-color: #a9b1c0;
+  text-shadow: 0 0 6px currentColor;
+  animation: le-pulse 1.4s ease-in-out infinite;
+}
+
+html[${ENGINE_ATTR}="pi"] [class$="_turnStatus"] {
+  --dsw-static-deepseek-500: #8e4ec6;
+  --dsw-static-deepseek-200: #d6bff0;
+}
+html[${ENGINE_ATTR}="pi"] [class$="_turnStatus"]::before {
+  content: "\u280B";
+  color: #8e4ec6;
+  -webkit-text-fill-color: #8e4ec6;
+  font-size: 1.1em;
+  animation: le-braille 1s linear infinite;
+}
+
+html[${ENGINE_ATTR}="kimi"] [class$="_turnStatus"] {
+  --dsw-static-deepseek-500: #e5484d;
+  --dsw-static-deepseek-200: #f5b2b4;
+}
+html[${ENGINE_ATTR}="kimi"] [class$="_turnStatus"]::before {
+  content: "\u{1F317}";
+  color: #e5484d;
+  -webkit-text-fill-color: #e5484d;
+  animation: le-moon 2.5s linear infinite;
+}
+
+/* Grows from small to large each cycle \u2014 the opposite of a twinkle. The range
+   is deliberately wide (3x) because a bare size change on a thin glyph reads
+   weakly otherwise, and the large state is held briefly (50%-62%) so it blooms
+   rather than throbs. 1.35x extends ~2.5px per side at the 14px glyph, inside
+   the 6px ::before margin. */
+@keyframes le-bloom {
+  0%, 100% { transform: scale(0.45); opacity: 0.45; }
+  50%, 62% { transform: scale(1.35); opacity: 1; }
+}
+/* A terminal braille spinner. The glyph is an ordinary text character, not an
+   emoji, so the engine color actually paints \u2014 a colored emoji silently ignores
+   color/-webkit-text-fill-color. Stepping content walks the ten dot frames. */
+@keyframes le-braille {
+  0% { content: "\u280B"; }
+  10% { content: "\u2819"; }
+  20% { content: "\u2839"; }
+  30% { content: "\u2838"; }
+  40% { content: "\u283C"; }
+  50% { content: "\u2834"; }
+  60% { content: "\u2826"; }
+  70% { content: "\u2827"; }
+  80% { content: "\u2807"; }
+  90% { content: "\u280F"; }
+  100% { content: "\u280B"; }
+}
+/* A soft pulse for the codex dot: the glyph breathes between a small, dim
+   point and a larger, full-brightness one \u2014 a light dot, not a spinner. */
+@keyframes le-pulse {
+  0%, 100% { transform: scale(0.5); opacity: 0.35; }
+  50% { transform: scale(1.3); opacity: 1; }
+}
+/* Moon phases rather than a rigid rotation: a spinning moon bitmap can only
+   squash and mirror itself, never show a full or a new moon. Stepping the
+   glyph through the phase set sweeps the lit edge across the disc AND actually
+   reaches \u{1F315} and \u{1F311}. The order runs waning first (full \u2192 new \u2192 full), so the lit
+   edge travels counter-clockwise, and the glyph under the row's first paint
+   (\u{1F317}) is a mid-phase rather than a full or a new moon. */
+@keyframes le-moon {
+  0% { content: "\u{1F315}"; }
+  12.5% { content: "\u{1F316}"; }
+  25% { content: "\u{1F317}"; }
+  37.5% { content: "\u{1F318}"; }
+  50% { content: "\u{1F311}"; }
+  62.5% { content: "\u{1F312}"; }
+  75% { content: "\u{1F313}"; }
+  87.5% { content: "\u{1F314}"; }
+  100% { content: "\u{1F315}"; }
+}
+
+`;
+var focusedSessionId;
+function reflectTurnStatusEngine(sessionId, engine) {
+  if (sessionId === void 0 || sessionId !== focusedSessionId) return;
+  writeTurnStatusEngine(engine);
+}
+function focusTurnStatusSession(sessionId) {
+  focusedSessionId = sessionId;
+}
+function blurTurnStatusSession(sessionId) {
+  if (focusedSessionId === sessionId) focusedSessionId = void 0;
+}
+function writeTurnStatusEngine(engine) {
+  if (typeof document === "undefined") return;
+  const root = document.documentElement;
+  if (engine === void 0 || engine === "in-process") {
+    delete root.dataset.loopEngine;
+    return;
+  }
+  root.dataset.loopEngine = engine;
+}
+function installTurnStatusStyles(ctx) {
+  if (typeof document === "undefined") return;
+  ctx.effect(() => {
+    const tag = document.createElement("style");
+    tag.dataset.plugin = PLUGIN_ID;
+    tag.dataset.pluginCss = `${PLUGIN_ID}/turn-status.css`;
+    tag.textContent = STYLESHEET;
+    document.head.appendChild(tag);
+    return () => {
+      tag.remove();
+      delete document.documentElement.dataset.loopEngine;
+    };
+  }, "loop-engine: per-engine turn status styles");
+}
+
+// src/client/use-session-engine.ts
+function useEngineOfSession(cache, sessionId) {
+  const [, bump] = (0, import_react2.useState)(0);
+  const report = sessionId === void 0 ? void 0 : cache.read(sessionId);
+  (0, import_react2.useEffect)(() => {
+    if (sessionId === void 0) return;
+    return cache.watch(sessionId, () => {
+      bump((count) => count + 1);
+    });
+  }, [cache, sessionId]);
+  const engine = report === void 0 ? void 0 : hostedEngineOf(report.engine);
+  (0, import_react2.useEffect)(() => {
+    if (sessionId === void 0) return;
+    focusTurnStatusSession(sessionId);
+    reflectTurnStatusEngine(sessionId, engine);
+    return () => {
+      blurTurnStatusSession(sessionId);
+    };
+  }, [sessionId, engine]);
+  return report;
+}
+
+// src/client/locales.ts
+var zh = {
+  nav: "\u5FAA\u73AF\u5F15\u64CE",
+  description: "\u9009\u62E9\u65B0\u4F1A\u8BDD\u9ED8\u8BA4\u4F7F\u7528\u7684 Agent \u6267\u884C\u5F15\u64CE\uFF1B\u6BCF\u4E2A\u4F1A\u8BDD\u4E5F\u53EF\u4EE5\u5728\u65B0\u4F1A\u8BDD\u9875\u5355\u72EC\u9009\u62E9\u81EA\u5DF1\u7684\u5F15\u64CE\u3002",
+  engineInProcess: "\u8FDB\u7A0B\u5185\u5F15\u64CE\uFF08\u9ED8\u8BA4\uFF09",
+  engineClaudeCode: "Claude Code CLI",
+  engineCodex: "Codex CLI",
+  enginePi: "Pi CLI",
+  engineKimi: "Kimi Code CLI",
+  engineLegacy: "\u65E7\u7248\u6258\u7BA1\u5F15\u64CE",
+  engineUnrecorded: "\u672A\u8BB0\u5F55",
+  engineLoading: "\u8BFB\u53D6\u4E2D\u2026",
+  showInComposerLabel: "\u5728\u5BF9\u8BDD\u9875\u663E\u793A\u5F15\u64CE\u9009\u62E9\u5668",
+  unavailable: "\u5FAA\u73AF\u5F15\u64CE\u8BBE\u7F6E\u4E0D\u53EF\u7528",
+  switchNotice: "\u8FD9\u4E00\u9009\u62E9\u53EA\u51B3\u5B9A\u65B0\u4F1A\u8BDD\u7528\u54EA\u4E2A\u5F15\u64CE\uFF0C\u5DF2\u7ECF\u5728\u8DD1\u7684\u4F1A\u8BDD\u4E0D\u53D7\u5F71\u54CD\u3002",
+  saving: "\u4FDD\u5B58\u4E2D\u2026",
+  confirmTitle: "\u5207\u6362\u5FAA\u73AF\u5F15\u64CE\uFF1F",
+  confirmBody: "\u6B64\u540E\u65B0\u5EFA\u7684\u4F1A\u8BDD\u4F1A\u4F7F\u7528\u8FD9\u4E2A\u5F15\u64CE\uFF1B\u5DF2\u5B58\u5728\u7684\u4F1A\u8BDD\u4FDD\u6301\u5B83\u4EEC\u5404\u81EA\u7684\u5F15\u64CE\u4E0D\u53D8\uFF0C\u4E5F\u4E0D\u9700\u8981\u5237\u65B0\u9875\u9762\u3002\u786E\u8BA4\u5207\u6362\u5417\uFF1F",
+  confirmAction: "\u5207\u6362",
+  cancelAction: "\u53D6\u6D88",
+  closeLabel: "\u5173\u95ED",
+  hostedEngineModelNotice: "\u672C\u4F1A\u8BDD\u7531\u5916\u90E8\u5F15\u64CE\u9A71\u52A8\uFF1A\u9ED8\u8BA4\u7528\u54EA\u4E2A\u6A21\u578B\u7531\u8BE5\u5F15\u64CE\u81EA\u5DF1\u51B3\u5B9A\u3002\u5728\u6A21\u578B\u83DC\u5355\u91CC\u9009\u4E00\u4E2A\u771F\u5B9E dsh \u6A21\u578B\uFF0C\u4F1A\u628A\u8FD9\u4E2A\u6A21\u578B\u7684\u7AEF\u70B9\u4E0E\u51ED\u636E\u4E00\u5E76\u4EA4\u7ED9\u8BE5\u5F15\u64CE\u4F7F\u7528\uFF0C\u8BA9\u5B83\u771F\u7684\u8D70 dsh \u914D\u7F6E\u7684\u90A3\u4E2A\u7AEF\u70B9\u5BF9\u8BDD\u3002\u80FD\u4E0D\u80FD\u7528\u53D6\u51B3\u4E8E\u8BE5\u5F15\u64CE\u662F\u5426\u652F\u6301\u90A3\u4E2A\u534F\u8BAE\uFF0C\u4E0D\u652F\u6301\u5C31\u4F1A\u7531\u5F15\u64CE\u62A5\u9519\u3002\u6A21\u578B\u83DC\u5355\u91CC\u6240\u6709\u6258\u7BA1\u5F15\u64CE\u5171\u7528\u4E00\u4E2A `external` \u5206\u7EC4\uFF08\u6A21\u578B\u76EE\u5F55\u662F\u6574\u4E2A Host \u4EE3\u9645\u5171\u4EAB\u7684\uFF0C\u4E0D\u6309\u4F1A\u8BDD\u533A\u5206\uFF0C\u6240\u4EE5\u56DB\u4E2A\u5F15\u64CE\u6298\u53E0\u6210\u8FD9\u4E00\u6761\uFF09\uFF0C\u540D\u4E0B\u90A3\u6761\u300Cdefault\u300D\u8868\u793A\u4EA4\u56DE\u5F15\u64CE\u81EA\u5DF1\u7684\u9ED8\u8BA4\uFF0C\u4E0D\u662F dsh \u80FD\u63D0\u4F9B\u7684\u6A21\u578B\u3002",
+  sessionNotice: "\u672C\u4F1A\u8BDD\u5F53\u524D\u8FD0\u884C\u7684\u5F15\u64CE\uFF1A\u6709\u6D3B agent \u65F6\u5C31\u662F\u6B63\u5728\u9A71\u52A8\u5B83\u7684\u90A3\u4E2A\u5F15\u64CE\uFF1B\u6CA1\u6709\u6D3B agent \u65F6\u624D\u770B\u63D2\u4EF6\u7684\u4F1A\u8BDD\u7EA7\u8BB0\u5F55\uFF0C\u6CA1\u6709\u8BB0\u5F55\u518D\u56DE\u9000\u5230\u5B83\u81EA\u5DF1\u7684 agent preset\u3002",
+  legacySessionNotice: "\u8FD9\u662F\u672C\u63D2\u4EF6\u65E9\u671F\u7248\u672C\u521B\u5EFA\u7684\u4F1A\u8BDD\uFF1A\u5B83\u5F53\u65F6\u8DD1\u7684\u6258\u7BA1\u5F15\u64CE\u6CA1\u6709\u88AB\u8BB0\u5F55\u3002\u9009\u4E00\u4E2A\u5F15\u64CE\u5373\u53EF\u5728\u672C\u4F1A\u8BDD\u91CC\u5207\u6362\u3002",
+  enginePendingPrefix: "\u5207\u5230 ",
+  enginePendingSuffix: " \xB7 \u5C1A\u672A\u63A5\u7BA1",
+  engineMenuPendingSuffix: "\uFF08\u5C1A\u672A\u63A5\u7BA1\uFF09",
+  pendingSessionNotice: "\u672C\u4F1A\u8BDD\u7684\u8BB0\u5F55\u5199\u7740\u4E00\u4E2A\u5F15\u64CE\uFF0C\u4F46\u5B83\u6CA1\u80FD\u63A5\u7BA1\uFF1A\u672C\u4F1A\u8BDD\u6B64\u523B\u4ECD\u7531\u53E6\u4E00\u4E2A\u5F15\u64CE\u9A71\u52A8\uFF08\u6240\u4EE5\u8FD9\u91CC\u5148\u5199\u7684\u662F\u6B63\u5728\u8DD1\u7684\u90A3\u4E2A\uFF09\u3002\u51FA\u73B0\u8FD9\u79CD\u60C5\u51B5\u53EA\u6709\u4E00\u79CD\u539F\u56E0\u2014\u2014\u4E0A\u4E00\u6B21\u5207\u6362\u8981\u62C6\u6389\u65E7 agent \u624D\u80FD\u8BA9\u65B0\u5F15\u64CE\u63A5\u7BA1\uFF0C\u800C\u90A3\u6B21\u62C6\u5378\u6CA1\u6709\u5B8C\u6210\u3002\u518D\u9009\u4E00\u6B21\u76EE\u6807\u5F15\u64CE\u5373\u53EF\u91CD\u8BD5\u3002",
+  pendingComposerHint: "\u672C\u4F1A\u8BDD\u7684\u8BB0\u5F55\u5199\u7740\u4E00\u4E2A\u5F15\u64CE\uFF0C\u4F46\u5B83\u6CA1\u80FD\u63A5\u7BA1\uFF1A\u672C\u4F1A\u8BDD\u6B64\u523B\u4ECD\u7531\u53E6\u4E00\u4E2A\u5F15\u64CE\u9A71\u52A8\uFF08\u6807\u7B7E\u4E0A\u5148\u5199\u7684\u662F\u6B63\u5728\u8DD1\u7684\u90A3\u4E2A\uFF09\u3002\u6D89\u53CA\u8FDB\u7A0B\u5185\u5F15\u64CE\u7684\u5207\u6362\u8981\u62C6\u6389\u65E7 agent \u624D\u80FD\u843D\u5230\u4E0B\u4E00\u6B21\u6784\u5EFA\u4E0A\uFF0C\u51FA\u73B0\u8FD9\u79CD\u60C5\u51B5\u8BF4\u660E\u90A3\u6B21\u62C6\u5378\u6CA1\u6709\u6210\u529F\u2014\u2014\u518D\u9009\u4E00\u6B21\u76EE\u6807\u5F15\u64CE\u5373\u53EF\u91CD\u8BD5\uFF1B\u9009\u5F53\u524D\u6B63\u5728\u8DD1\u7684\u90A3\u4E2A\u5F15\u64CE\u5219\u4F1A\u628A\u8BB0\u5F55\u6539\u56DE\u53BB\uFF0C\u8BA9\u5B83\u4FDD\u6301\u539F\u6837\u3002",
+  composerHint: "\u9009\u62E9\u672C\u4F1A\u8BDD\u8FD0\u884C\u7684\u5F15\u64CE\uFF1A\u6258\u7BA1\u5F15\u64CE\u4E4B\u95F4\u9009\u4E2D\u5373\u751F\u6548\uFF0C\u539F\u5730\u6362\u624B\uFF0C\u4F1A\u8BDD\u4FDD\u6301\u6253\u5F00\u3001agent \u88AB\u66FF\u6362\uFF1B\u4E0E\u8FDB\u7A0B\u5185\u5F15\u64CE\u4E4B\u95F4\u7684\u5207\u6362\u65E0\u6CD5\u539F\u5730\u63A5\u7BA1\uFF08harness \u7684 loop \u65E2\u4E0D\u4EA4\u51FA\u6D3B\u4F1A\u8BDD\u3001\u4E5F\u4E0D\u63A5\u7BA1\u522B\u4EBA\u5EFA\u7684\u4F1A\u8BDD\uFF09\uFF0C\u9009\u4E2D\u65F6\u4F1A\u5148\u8BF4\u660E\u4EE3\u4EF7\u5E76\u7B49\u786E\u8BA4\uFF0C\u786E\u8BA4\u540E\u5BBF\u4E3B\u62C6\u6389\u8FD9\u6761\u4F1A\u8BDD\u7684 agent \u5E76\u8BA9\u9875\u9762\u91CD\u65B0\u8F7D\u5165\uFF0C\u56DE\u6765\u65F6\u4ECD\u662F\u8FD9\u6761\u4F1A\u8BDD\uFF0C\u7531\u65B0\u5F15\u64CE\u91CD\u5EFA\uFF08\u90A3\u6B21\u91CD\u8F7D\u4F1A\u4E22\u6389\u8FD9\u4E00\u9875\u7684\u6EDA\u52A8\u4F4D\u7F6E\u4E0E\u672A\u63D0\u4EA4\u7684\u8349\u7A3F\uFF0C\u4F1A\u8BDD\u8BB0\u5F55\u4E0D\u53D7\u5F71\u54CD\uFF09\u3002\u4F1A\u8BDD\u9700\u5DF2\u6253\u5F00\u4E14\u7A7A\u95F2\uFF0C\u5426\u5219\u5BBF\u4E3B\u4F1A\u8BF4\u660E\u539F\u56E0\u3002",
+  switchFailedTitle: "\u5207\u6362\u672A\u751F\u6548",
+  refusedSessionClosed: "\u8FD9\u6761\u4F1A\u8BDD\u8FD8\u6CA1\u6709\u6253\u5F00\u3002\u5148\u6253\u5F00\u5B83\uFF0C\u518D\u5207\u6362\u5F15\u64CE\u3002",
+  refusedTurnRunning: "\u8FD9\u6761\u4F1A\u8BDD\u6B63\u5728\u8FD0\u884C\u4E2D\u2014\u2014\u7B49\u8FD9\u4E00\u8F6E\u7ED3\u675F\u540E\u518D\u5207\u6362\u5F15\u64CE\u3002\u5F53\u524D\u8FD9\u4E00\u8F6E\u4E0D\u4F1A\u88AB\u6253\u65AD\u3002",
+  refusedSubagentSession: "\u8FD9\u662F\u5B50\u4EE3\u7406\u4F1A\u8BDD\uFF1B\u5B83\u7684\u5F15\u64CE\u8DDF\u968F\u6D3E\u53D1\u5B83\u7684\u4E3B\u4F1A\u8BDD\uFF0C\u4E0D\u80FD\u5355\u72EC\u5207\u6362\u3002",
+  refusedRouterNotReady: "\u8FD9\u4E2A\u8FDB\u7A0B\u6682\u65F6\u65E0\u6CD5\u5207\u6362\u5F15\u64CE\uFF08\u5FAA\u73AF\u5F15\u64CE\u8DEF\u7531\u5668\u8FD8\u6CA1\u5C31\u7EEA\uFF09\u3002",
+  refusedRecordFailed: "\u5F15\u64CE\u8BB0\u5F55\u5199\u5165\u5931\u8D25\uFF0C\u5207\u6362\u6CA1\u6709\u751F\u6548\u3002",
+  refusedRebuildFailed: "\u5207\u6362\u6CA1\u6709\u751F\u6548\uFF1A\u65B0\u5F15\u64CE\u6CA1\u80FD\u5EFA\u8D77\u6765\uFF0C\u8FD9\u6761\u4F1A\u8BDD\u7684 agent \u5DF2\u7ECF\u91CA\u653E\u3002\u518D\u6253\u5F00\u4E00\u6B21\u8FD9\u6761\u4F1A\u8BDD\uFF0C\u5B83\u5C31\u4F1A\u7528\u65B0\u5F15\u64CE\u91CD\u5EFA\u3002",
+  switchReloadConfirmTitle: "\u5207\u6362\u9700\u8981\u91CD\u65B0\u8F7D\u5165\u9875\u9762",
+  switchReloadConfirmBody: "\u4E0E\u8FDB\u7A0B\u5185\u5F15\u64CE\u4E4B\u95F4\u7684\u5207\u6362\u65E0\u6CD5\u539F\u5730\u63A5\u7BA1\uFF1A\u5BBF\u4E3B\u4F1A\u91CA\u653E\u8FD9\u6761\u4F1A\u8BDD\u7684 agent\uFF0C\u5E76\u91CD\u65B0\u8F7D\u5165\u9875\u9762\uFF0C\u7531\u65B0\u5F15\u64CE\u91CD\u5EFA\u5B83\u3002\u8FD9\u4E00\u9875\u7684\u6EDA\u52A8\u4F4D\u7F6E\u3001\u8FD8\u6CA1\u53D1\u51FA\u7684\u8349\u7A3F\u4F1A\u4E22\u5931\uFF1B\u4F1A\u8BDD\u8BB0\u5F55\uFF08\u5BF9\u8BDD\u5386\u53F2\uFF09\u4E0D\u53D7\u5F71\u54CD\u3002\u73B0\u5728\u5207\u6362\u5417\uFF1F",
+  switchReloadConfirmAction: "\u5207\u6362\u5E76\u91CD\u8F7D",
+  switchReloadTitle: "\u5207\u6362\u5DF2\u751F\u6548\uFF0C\u6B63\u5728\u91CD\u65B0\u8F7D\u5165\u9875\u9762",
+  switchReloadBody: "\u5DF2\u5207\u5230\u65B0\u5F15\u64CE\uFF0C\u6B63\u5728\u91CD\u65B0\u8F7D\u5165\u9875\u9762\u5E76\u56DE\u5230\u672C\u4F1A\u8BDD\u2026",
+  switchUnavailable: "\u5F53\u524D\u9875\u9762\u62FF\u4E0D\u5230\u5F15\u64CE\u5207\u6362\u670D\u52A1\uFF0C\u65E0\u6CD5\u5207\u6362\u672C\u4F1A\u8BDD\u7684\u5F15\u64CE\u3002"
+};
+var en = {
+  nav: "Loop engine",
+  description: "Choose the agent execution engine NEW sessions start on; each session can also pick its own engine on the new-session screen.",
+  engineInProcess: "In-process engine (default)",
+  engineClaudeCode: "Claude Code CLI",
+  engineCodex: "Codex CLI",
+  enginePi: "Pi CLI",
+  engineKimi: "Kimi Code CLI",
+  engineLegacy: "Legacy hosted engine",
+  engineUnrecorded: "Not recorded",
+  engineLoading: "Reading\u2026",
+  showInComposerLabel: "Show the engine selector in the chat page",
+  unavailable: "Loop engine settings are unavailable",
+  switchNotice: "This only decides what new sessions run; sessions already running keep their own engine.",
+  saving: "Saving\u2026",
+  confirmTitle: "Switch loop engine?",
+  confirmBody: "Sessions created after this point use the new engine. Sessions that already exist keep the engine they were created with, and nothing reloads. Switch now?",
+  confirmAction: "Switch",
+  cancelAction: "Cancel",
+  closeLabel: "Close",
+  hostedEngineModelNotice: `This session is driven by a hosted engine: by default that engine decides the model. Picking a real dsh model in the menu hands the engine that model's endpoint and credential too, so the engine really talks to the endpoint dsh configured. Whether it works depends on whether the engine supports that protocol, and one it does not support reports an error from the engine. Every hosted engine shares one provider group, "external", in the model menu (the model catalog is shared across the whole Host generation rather than per session, so the engines collapse into that one group), whose single entry, "default", means "hand the choice back to the engine's own default" \u2014 not a model dsh can serve.`,
+  sessionNotice: "The engine this session runs right now: the agent driving it, when one is live, and otherwise the plugin's per-session record (falling back to the session's own agent preset when there is no record).",
+  legacySessionNotice: "This session was created by an earlier version of the plugin: the hosted engine it ran was never recorded. Pick any engine to switch it here.",
+  enginePendingPrefix: "\u2192 ",
+  enginePendingSuffix: " \xB7 not in force",
+  engineMenuPendingSuffix: " (not in force)",
+  pendingSessionNotice: "This session's record names an engine that has not taken over: the session is still driven by another engine right now \u2014 which is the one named first. There is exactly one way this happens: a switch had to release the old agent for the new engine to take over, and that release did not complete. Pick the target engine again to retry it.",
+  pendingComposerHint: "This session's record names an engine that has not taken over: the session is still driven by another engine (the label names that one first). A switch involving the in-process engine has to release the old agent for the new engine to take over on the session's next build, and this state means that release did not succeed \u2014 pick the target engine again to retry it, or pick the engine the session is actually running to put the record back and leave it as it is.",
+  composerHint: "Choose the engine this session runs. A pick between two hosted engines applies at once \u2014 the agent is swapped in place and the session stays open. A switch involving the in-process engine cannot be taken over in place (the harness loop neither hands over a live session nor takes over one it did not create), so it says what it costs and waits for a confirmation first; once confirmed, the host releases this session's agent and the page reloads itself, coming back to this same session, rebuilt on the new engine \u2014 that reload drops this page's scroll position and any unsent draft, while the conversation record is unaffected. The session must be open and idle, or the host says why.",
+  switchFailedTitle: "Switch not applied",
+  refusedSessionClosed: "This session is not open yet. Open it, then switch its engine.",
+  refusedTurnRunning: "This session is running \u2014 switch its engine after this turn ends. The turn in flight is not interrupted.",
+  refusedSubagentSession: "This is a subagent session; its engine follows the main session that spawned it and cannot be switched on its own.",
+  refusedRouterNotReady: "This process cannot switch engines right now (the loop engine router is not ready).",
+  refusedRecordFailed: "The engine record could not be written, so the switch did not happen.",
+  refusedRebuildFailed: "The switch did not happen: the new engine could not be started and this session's agent has already been released. Open this session again and it is rebuilt on the new engine.",
+  switchReloadConfirmTitle: "This switch reloads the page",
+  switchReloadConfirmBody: "A switch involving the in-process engine cannot be handed over in place: the host releases this session's agent and reloads the page, which rebuilds the session on the new engine. Your scroll position and any unsent draft in this page are lost; the conversation record is not. Switch now?",
+  switchReloadConfirmAction: "Switch and reload",
+  switchReloadTitle: "Switch applied \u2014 reloading the page",
+  switchReloadBody: "Switched. Reloading the page and returning to this session\u2026",
+  switchUnavailable: "This page cannot reach the engine switch endpoint, so the session engine was not switched."
+};
+function engineLabelKey2(engine) {
+  switch (engine) {
+    case "claude-code":
+      return "engineClaudeCode";
+    case "codex":
+      return "engineCodex";
+    case "pi":
+      return "enginePi";
+    case "kimi":
+      return "engineKimi";
+    default:
+      return "engineInProcess";
+  }
+}
+function engineStateLabelKey(state) {
+  if (state.kind === "engine") return engineLabelKey2(state.engine);
+  return state.kind === "legacy" ? "engineLegacy" : "engineUnrecorded";
+}
+function pendingEngineText(t, engine) {
+  return `${t("enginePendingPrefix")}${t(engineLabelKey2(engine))}${t("enginePendingSuffix")}`;
+}
+var REFUSAL_FACES = {
+  "session-closed": { body: "refusedSessionClosed", detail: false },
+  "turn-running": { body: "refusedTurnRunning", detail: false },
+  "subagent-session": { body: "refusedSubagentSession", detail: false },
+  "not-driven": { body: "refusedRouterNotReady", detail: false },
+  "router-unmounted": { body: "refusedRouterNotReady", detail: false },
+  "record-failed": { body: "refusedRecordFailed", detail: true },
+  "rebuild-failed": { body: "refusedRebuildFailed", detail: true }
+};
+function refusalFace(code) {
+  return code === void 0 ? { detail: false } : REFUSAL_FACES[code];
+}
+
 // src/client/LoopEngineBadge.tsx
 var import_jsx_runtime2 = require("react/jsx-runtime");
 var pill = {
@@ -235,23 +573,431 @@ var pill = {
   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" : engine === "kimi" ? "engineKimi" : "engineInProcess"
-  );
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: pill, title: t("description"), children: [
-    t("nav"),
-    " \xB7 ",
-    label
-  ] });
+function LoopEngineBadge(props) {
+  const { sessionId, sessionEngines, t } = props;
+  const report = useEngineOfSession(sessionEngines, sessionId);
+  if (sessionId === void 0 || report === void 0) return null;
+  const engine = report.engine;
+  if (engine.kind === "unset") return null;
+  const label = t(engineStateLabelKey(engine));
+  const named = engine.kind === "engine" ? engine.engine : void 0;
+  const pending = report.pending;
+  const notice2 = pending === void 0 ? named === void 0 ? t("legacySessionNotice") : t("sessionNotice") : t("pendingSessionNotice");
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("span", { style: pill, title: notice2, children: [
+    t("nav"),
+    " \xB7 ",
+    label,
+    pending === void 0 ? null : ` \xB7 ${pendingEngineText(t, pending)}`
+  ] });
+}
+
+// src/client/LoopEngineComposerSelect.tsx
+var import_react3 = require("react");
+var import_dsh_client_ui_primitives2 = require("@deepseek-ai/dsh-client-ui-primitives");
+
+// src/client/reload.ts
+var RELOAD_RETURN_KEY = "dsh-loop-engine:reload-session";
+function browserPage() {
+  const globals = globalThis;
+  return {
+    stash: globals.sessionStorage,
+    // Off a browser there is no page to reload; the stash is missing there too,
+    // so nothing is ever armed for one.
+    reload: () => {
+      globals.location?.reload();
+    }
+  };
+}
+function armReloadReturn(page, sessionId) {
+  const stash = page.stash;
+  if (stash === void 0) return false;
+  try {
+    stash.setItem(RELOAD_RETURN_KEY, sessionId);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function takeReloadReturn(page) {
+  const stash = page.stash;
+  if (stash === void 0) return void 0;
+  let stashed = null;
+  try {
+    stashed = stash.getItem(RELOAD_RETURN_KEY);
+  } catch {
+    return void 0;
+  }
+  if (stashed === null || stashed.length === 0) return void 0;
+  try {
+    stash.removeItem(RELOAD_RETURN_KEY);
+  } catch {
+  }
+  return stashed;
+}
+function restoreReloadReturn(sessions, page, warn) {
+  const sessionId = takeReloadReturn(page);
+  if (sessionId === void 0) return () => {
+  };
+  let unsubscribe;
+  const settle = () => {
+    const snapshot = sessions.list.getSnapshot();
+    if (snapshot.phase !== "ready") return;
+    unsubscribe?.();
+    unsubscribe = void 0;
+    if (!snapshot.ids.includes(sessionId)) {
+      warn(`loop-engine: the session this page was reloaded for ("${sessionId}") is not in the session list; open it from the list`);
+      return;
+    }
+    try {
+      sessions.open(sessionId);
+    } catch (error2) {
+      warn(`loop-engine: could not reopen session "${sessionId}" after the reload: ${String(error2)}`);
+    }
+  };
+  unsubscribe = sessions.list.subscribe(settle);
+  settle();
+  return () => {
+    unsubscribe?.();
+  };
+}
+function installReloadReturn(ctx, page = browserPage(), warn) {
+  ctx.inject(["sessions"], (scope) => {
+    const sessions = scope.get("sessions");
+    if (sessions === void 0) return;
+    const report = warn ?? ((message) => {
+      scope.logger.warn(message);
+    });
+    scope.effect(
+      () => restoreReloadReturn(sessions, page, report),
+      "loop-engine: reopen the session this page was reloaded for"
+    );
+  });
+}
+
+// src/client/session-engine.ts
+var LOOP_ENGINE_REMOTE_NAMESPACE = "loopEngine";
+var LOOP_ENGINE_REMOTE_METHOD = "engine";
+var LOOP_ENGINE_REMOTE_SELECT_METHOD = "select";
+function engineSwitchReady(report) {
+  return report !== void 0;
+}
+function switchNeedsReload(current, target) {
+  const from = current.kind === "engine" ? current.engine : "in-process";
+  return from === "in-process" !== (target === "in-process");
+}
+var LOOP_ENGINE_PACKAGE = "dsh-loop-engine";
+function parseSessionEngine(value) {
+  const kind = value?.kind;
+  if (kind === "legacy" || kind === "unset") return { kind };
+  const engine = value?.engine;
+  if (kind === "engine" && isLoopEngineId(engine)) return { kind, engine };
+  throw new TypeError(`loop-engine: "${String(kind)}" is not a session engine state`);
+}
+function parseSessionEngineReport(value) {
+  const engine = parseSessionEngine(value?.engine);
+  const pending = value?.pending;
+  if (pending === void 0) return { engine };
+  if (!isLoopEngineId(pending)) {
+    throw new TypeError(`loop-engine: "${String(pending)}" is not a session engine state`);
+  }
+  return { engine, pending };
+}
+function parseSessionId(value) {
+  const sessionId = value?.sessionId;
+  if (typeof sessionId !== "string" || sessionId.length === 0) {
+    throw new TypeError("loop-engine: sessionId must be a non-empty string");
+  }
+  return sessionId;
+}
+function parseSelectRequest(value) {
+  const sessionId = parseSessionId(value);
+  const engine = value?.engine;
+  if (!isLoopEngineId(engine)) {
+    throw new TypeError(`loop-engine: engine must be one of ${LOOP_ENGINE_IDS.join(", ")}`);
+  }
+  return { sessionId, engine };
+}
+function parseSelectResult(value) {
+  const outcome = value ?? {};
+  if (outcome.ok === true && isLoopEngineId(outcome.engine)) {
+    if (outcome.reload !== void 0 && outcome.reload !== true) {
+      throw new TypeError("loop-engine: not an engine switch outcome");
+    }
+    return outcome.reload === true ? { ok: true, engine: outcome.engine, reload: true } : { ok: true, engine: outcome.engine };
+  }
+  if (outcome.ok === false && typeof outcome.reason === "string") {
+    return isLoopEngineRefusalCode(outcome.code) ? { ok: false, code: outcome.code, reason: outcome.reason } : { ok: false, reason: outcome.reason };
+  }
+  throw new TypeError("loop-engine: not an engine switch outcome");
+}
+function descriptor(method, request, result) {
+  return {
+    id: `${LOOP_ENGINE_PACKAGE}#${LOOP_ENGINE_REMOTE_NAMESPACE}/${method}`,
+    service: LOOP_ENGINE_REMOTE_NAMESPACE,
+    namespace: LOOP_ENGINE_REMOTE_NAMESPACE,
+    method,
+    invocation: { kind: "direct" },
+    parameters: [{
+      // The wire name is the HOST method's own parameter name: the Gateway
+      // derives an unregistered endpoint's signature from the live method
+      // (`methodParameterNames`), and refuses args whose fields do not match it.
+      name: "request",
+      wire: "request",
+      source: "json",
+      codec: {
+        mode: "strict",
+        typeSymbol: `${LOOP_ENGINE_PACKAGE}#${LOOP_ENGINE_REMOTE_NAMESPACE}/${method}:request`,
+        schema: request
+      }
+    }],
+    result: {
+      mode: "strict",
+      typeSymbol: `${LOOP_ENGINE_PACKAGE}#${LOOP_ENGINE_REMOTE_NAMESPACE}/${method}:result`,
+      schema: result
+    }
+  };
+}
+var LOOP_ENGINE_REMOTE_CONTRIBUTION = {
+  package: LOOP_ENGINE_PACKAGE,
+  descriptors: [
+    descriptor(
+      LOOP_ENGINE_REMOTE_METHOD,
+      {
+        /** Normalize the one-field request the host's method declares. */
+        parse(value) {
+          return { sessionId: parseSessionId(value) };
+        }
+      },
+      { parse: parseSessionEngineReport }
+    ),
+    descriptor(LOOP_ENGINE_REMOTE_SELECT_METHOD, { parse: parseSelectRequest }, { parse: parseSelectResult })
+  ]
+};
+var SessionEngineCache = class {
+  engines = /* @__PURE__ */ new Map();
+  watchers = /* @__PURE__ */ new Map();
+  reading = /* @__PURE__ */ new Map();
+  /**
+   * Monotonic read generation per session. A read started before an
+   * invalidation describes the session as it was BEFORE the switch, so however
+   * late it settles it must not publish — publishing it would put the old engine
+   * back on screen, which is the very misreport this cache exists to prevent.
+   */
+  generations = /* @__PURE__ */ new Map();
+  remote;
+  disposed = false;
+  /**
+   * Attach the mounted Remote namespace. Values asked for before the mount
+   * settled are re-read, so a surface that mounted first is not left loading.
+   * @param remote - the namespace, or undefined when the mount failed.
+   */
+  attach(remote) {
+    if (this.disposed) return;
+    this.remote = remote;
+    for (const sessionId of [...this.watchers.keys()]) this.readIfUnknown(sessionId);
+  }
+  /**
+   * The engine report cached for one session, or undefined while the first
+   * answer is still in flight (or when the host could not answer at all).
+   * @param sessionId - the session whose engine is asked for.
+   * @returns the authoritative report, cached by session id.
+   */
+  read(sessionId) {
+    return this.engines.get(sessionId);
+  }
+  /**
+   * Follow one session's engine, re-reading it whenever a session's surfaces
+   * appear again.
+   *
+   * A watch is a surface appearing for this session, and that is the moment the
+   * cached answer can be stale in a way nothing else reports: a session whose
+   * surfaces all went away and came back — the page switched to another session
+   * and back — must not render what the page cached before. A re-mount is not
+   * what moves a session's engine (a switch is performed on the host, and either
+   * swaps the agent in place or releases the session and reloads this page), but
+   * the page's answer is old by then, and a surface that rendered it as current
+   * would be the one lying about what runs.
+   *
+   * Only the FIRST watcher of a session triggers the re-read, which is what
+   * makes this "the session's surfaces appeared" rather than "a component
+   * rendered": the chip and the composer are two watchers of one session, and
+   * the second joins the read the first one started instead of sending its own.
+   * While a session keeps its surfaces, nothing here asks again — the answer only
+   * changes through {@link invalidate} (a committed switch) or a later re-mount.
+   * @param sessionId - the session to follow.
+   * @param listener - called whenever that session's cached state changes.
+   * @returns the unsubscribe.
+   */
+  watch(sessionId, listener) {
+    const listeners = this.watchers.get(sessionId) ?? /* @__PURE__ */ new Set();
+    const appearing = listeners.size === 0;
+    listeners.add(listener);
+    this.watchers.set(sessionId, listeners);
+    if (appearing) this.refresh(sessionId);
+    return () => {
+      if (this.watchers.get(sessionId) !== listeners) return;
+      listeners.delete(listener);
+      if (listeners.size === 0) this.watchers.delete(sessionId);
+    };
+  }
+  /**
+   * Ask the host for one session's engine report again, superseding nothing.
+   *
+   * This is the way a surface that has just been rendered asks "is what this page
+   * cached still what runs?" — the answer that can go stale without anyone
+   * invalidating it, because the page is not the only thing that can move a
+   * session (another window, a hot swap elsewhere, a plugin reload).
+   * A read already in flight for that session is joined rather than replaced (it
+   * was started no earlier than this call and describes the same moment), and the
+   * cached answer is kept until the new one lands, so a re-read never blinks the
+   * chip back to "reading". Use {@link invalidate} instead for an answer that is
+   * known to be WRONG.
+   * @param sessionId - the session whose answer should be re-read.
+   */
+  refresh(sessionId) {
+    if (this.disposed) return;
+    if (this.reading.has(sessionId)) return;
+    this.start(sessionId);
+  }
+  /**
+   * Forget one session's cached engine and ask the host again.
+   *
+   * A successful engine switch changes what the host answers for that session,
+   * so the picker MUST come through here: without it the composer would keep
+   * showing the engine the session no longer runs. Any read already in flight
+   * for that session is superseded and can no longer publish.
+   * @param sessionId - the session whose answer is now stale.
+   */
+  invalidate(sessionId) {
+    this.engines.delete(sessionId);
+    this.generations.set(sessionId, (this.generations.get(sessionId) ?? 0) + 1);
+    this.reading.delete(sessionId);
+    this.publish(sessionId);
+    this.readIfUnknown(sessionId);
+  }
+  /** Drop every cached answer and notification (plugin unload). */
+  dispose() {
+    this.disposed = true;
+    this.remote = void 0;
+    this.engines.clear();
+    this.reading.clear();
+    this.generations.clear();
+    this.watchers.clear();
+  }
+  /**
+   * Ask unless the session is already answered, being read, or unanswerable.
+   *
+   * For the paths that need an answer and have none: the plugin's mount settling
+   * (a surface asked before the Remote existed), a session whose cached answer
+   * was just dropped — and never a re-read of an answer this page already holds,
+   * which is {@link refresh}'s job and only a freshly rendered surface may ask
+   * for.
+   */
+  readIfUnknown(sessionId) {
+    if (this.engines.has(sessionId) || this.reading.has(sessionId)) return;
+    this.start(sessionId);
+  }
+  /**
+   * Start one read for a session, unless there is nothing to read it with.
+   * @param sessionId - the session to read.
+   */
+  start(sessionId) {
+    const remote = this.remote;
+    if (this.disposed || remote === void 0) return;
+    const generation = (this.generations.get(sessionId) ?? 0) + 1;
+    this.generations.set(sessionId, generation);
+    const read = this.ask(remote, sessionId, generation);
+    this.reading.set(sessionId, read);
+    void read.then(() => {
+      if (this.reading.get(sessionId) === read) this.reading.delete(sessionId);
+    });
+  }
+  /**
+   * One read, quiet on failure: a session the host cannot answer for stays
+   * unknown, and the surfaces keep their neutral state instead of claiming an
+   * engine. A refusal is not cached as an answer, so the next watch re-asks.
+   * @param remote - the mounted namespace.
+   * @param sessionId - the session asked about.
+   * @param generation - the read generation this answer belongs to.
+   */
+  async ask(remote, sessionId, generation) {
+    let result;
+    try {
+      result = await remote.engine({ sessionId });
+    } catch {
+      return;
+    }
+    if (!result.ok || this.disposed || this.generations.get(sessionId) !== generation) return;
+    let report;
+    try {
+      report = parseSessionEngineReport(result.value);
+    } catch {
+      return;
+    }
+    this.engines.set(sessionId, report);
+    this.publish(sessionId);
+  }
+  /**
+   * Notify one session's watchers.
+   *
+   * Nothing is painted here. The session's engine shows up in the chat
+   * turn-status row too, but that row hangs off a DOCUMENT-level attribute, whose
+   * only entitled owner is the session on screen — and a publish says nothing
+   * about what is on screen (this is called for every session a surface has ever
+   * watched, and for a session the user has already left, when its late answer
+   * lands). So painting here let a background session take the attribute over
+   * from the session on screen. The surfaces reflect instead, with the focus
+   * guard in `./turn-status.ts`; this is the notification the chip and the
+   * composer wake up on.
+   */
+  publish(sessionId) {
+    for (const listener of this.watchers.get(sessionId) ?? []) listener();
+  }
+};
+function createSessionEngineCache(ctx) {
+  const cache = new SessionEngineCache();
+  ctx.inject(["remote"], (remoteCtx) => {
+    const remote = remoteCtx.get("remote");
+    if (remote === void 0) return;
+    remote.$mount(LOOP_ENGINE_REMOTE_CONTRIBUTION).then(
+      () => {
+        cache.attach(remoteCtx.get(`remote.${LOOP_ENGINE_REMOTE_NAMESPACE}`));
+      },
+      (error2) => {
+        ctx.logger.warn(`loop-engine: could not mount the session engine Remote: ${String(error2)}`);
+      }
+    );
+  });
+  ctx.effect(() => () => {
+    cache.dispose();
+  }, "loop-engine: session engine cache");
+  return cache;
+}
+function sessionEngineSwitcher(ctx, onSwitched, page = browserPage()) {
+  return async (sessionId, engine) => {
+    const remote = ctx.get(`remote.${LOOP_ENGINE_REMOTE_NAMESPACE}`);
+    if (remote === void 0) return { ok: false, kind: "unavailable" };
+    let result;
+    try {
+      result = await remote.select({ sessionId, engine });
+    } catch (error2) {
+      return { ok: false, kind: "refused", reason: error2 instanceof Error ? error2.message : String(error2) };
+    }
+    if (!result.ok) {
+      return { ok: false, kind: "refused", reason: result.error.message };
+    }
+    if (!result.value.ok) {
+      return result.value.code === void 0 ? { ok: false, kind: "refused", reason: result.value.reason } : { ok: false, kind: "refused", reason: result.value.reason, code: result.value.code };
+    }
+    onSwitched?.(sessionId);
+    if (result.value.reload !== true) return { ok: true };
+    armReloadReturn(page, sessionId);
+    page.reload();
+    return { ok: true, reload: true };
+  };
 }
 
 // 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" },
@@ -260,19 +1006,14 @@ var ENGINE_OPTIONS2 = [
   { value: "pi", key: "enginePi" },
   { value: "kimi", key: "engineKimi" }
 ];
-function engineLabelKey2(engine) {
-  switch (engine) {
-    case "claude-code":
-      return "engineClaudeCode";
-    case "codex":
-      return "engineCodex";
-    case "pi":
-      return "enginePi";
-    case "kimi":
-      return "engineKimi";
-    default:
-      return "engineInProcess";
-  }
+var READING = { label: "engineLoading", engine: void 0, selectedId: void 0 };
+function triggerFace(report) {
+  const { engine: state, pending } = report;
+  const face = state.kind === "engine" ? { label: engineLabelKey2(state.engine), engine: state.engine, selectedId: state.engine } : { label: engineStateLabelKey(state), engine: void 0, selectedId: void 0 };
+  return pending === void 0 ? face : { ...face, pending };
+}
+function defaultFace(fallback) {
+  return { label: engineLabelKey2(fallback), engine: fallback, selectedId: fallback };
 }
 function engineGlyph(engine, size = 16) {
   switch (engine) {
@@ -331,40 +1072,88 @@ var chevron = {
   transition: "transform 120ms ease"
 };
 var chevronOpen = { ...chevron, transform: "rotate(180deg)" };
-var confirmBody2 = {
+var rowPendingMark = {
+  marginLeft: 4,
+  color: "var(--dsw-alias-label-caption)",
+  fontSize: 12
+};
+var noticeBody = {
   margin: 0,
   fontSize: 13,
   lineHeight: 1.55,
   color: "var(--dsw-alias-label-secondary)"
 };
+var noticeDetail = {
+  margin: 0,
+  fontSize: 12,
+  lineHeight: 1.5,
+  color: "var(--dsw-alias-label-tertiary)",
+  wordBreak: "break-word"
+};
 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 [hovered, setHovered] = (0, import_react2.useState)(false);
-  const [pending, setPending] = (0, import_react2.useState)(null);
-  const triggerRef = (0, import_react2.useRef)(null);
+  const { controller, useSnapshot, sessionId, sessionEngines, switchEngine, t } = props;
+  const { status, engine: defaultEngine, showInComposer, writable } = useSnapshot((snapshot) => snapshot);
+  const resolved = useEngineOfSession(sessionEngines, sessionId);
+  const { label, engine, selectedId, pending } = sessionId === void 0 ? defaultFace(defaultEngine) : resolved === void 0 ? READING : triggerFace(resolved);
+  const switchReady = sessionId === void 0 || engineSwitchReady(resolved);
+  const [open, setOpen] = (0, import_react3.useState)(false);
+  const [hovered, setHovered] = (0, import_react3.useState)(false);
+  const [notice2, setNotice] = (0, import_react3.useState)(null);
+  const [pendingReload, setPendingReload] = (0, import_react3.useState)(null);
+  const triggerRef = (0, import_react3.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 disabled = !writable || !switchReady;
+  const labelText = t(label);
+  const pendingText = pending === void 0 ? void 0 : ` \xB7 ${pendingEngineText(t, pending)}`;
+  const title = pending !== void 0 ? t("pendingComposerHint") : isHostedEngine(engine) ? t("hostedEngineModelNotice") : sessionId === void 0 ? t("description") : t("composerHint");
+  const commitSwitch = (value) => {
+    if (sessionId === void 0) {
+      void controller.setEngine(value);
+      return;
+    }
+    void switchEngine(sessionId, value).then((result) => {
+      if (!result.ok) {
+        if (result.kind === "unavailable") {
+          setNotice({ title: "switchFailedTitle", body: t("switchUnavailable") });
+          return;
+        }
+        const face = refusalFace(result.code);
+        setNotice({
+          title: "switchFailedTitle",
+          body: face.body === void 0 ? result.reason : t(face.body),
+          ...face.detail ? { detail: result.reason } : {}
+        });
+        return;
+      }
+      if (result.reload === true) {
+        setNotice({ title: "switchReloadTitle", body: t("switchReloadBody") });
+        return;
+      }
+    });
+  };
   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();
-      });
+    if (value === selectedId) return;
+    if (sessionId !== void 0) {
+      if (!engineSwitchReady(resolved)) return;
+      if (switchNeedsReload(resolved.engine, value)) {
+        setPendingReload(value);
+        return;
+      }
     }
+    commitSwitch(value);
   };
-  const cancelSwitch = () => {
-    setPending(null);
+  const confirmReload = () => {
+    const value = pendingReload;
+    setPendingReload(null);
+    if (value !== null) commitSwitch(value);
+  };
+  const cancelReload = () => {
+    setPendingReload(null);
+  };
+  const dismissNotice = () => {
+    setNotice(null);
   };
   return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
     /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
@@ -376,10 +1165,18 @@ function LoopEngineComposerSelect(props) {
         },
         items: ENGINE_OPTIONS2.map((option) => ({
           id: option.value,
-          label: t(option.key),
+          // The recorded engine's own row carries the marker too: the trigger may
+          // be truncated to ellipsis, and a user who opens the list has to be
+          // able to see which row was recorded instead of concluding the pick
+          // did nothing. The check mark stays on the row in force (selectedId),
+          // which is never the marked one.
+          label: option.value === pending ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+            t(option.key),
+            /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: rowPendingMark, children: t("engineMenuPendingSuffix") })
+          ] }) : t(option.key),
           icon: engineGlyph(option.value)
         })),
-        selectedId: engine,
+        selectedId,
         onSelect,
         align: "start",
         portal: true,
@@ -404,8 +1201,11 @@ function LoopEngineComposerSelect(props) {
               setOpen(!open);
             },
             children: [
-              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: triggerIcon, "aria-hidden": true, children: engineGlyph(engine, 14) }),
-              /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: triggerLabel, children: label }),
+              engine === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: triggerIcon, "aria-hidden": true, children: engineGlyph(engine, 14) }),
+              /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("span", { style: triggerLabel, children: [
+                labelText,
+                pendingText
+              ] }),
               /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: open ? chevronOpen : chevron, "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.IconChevronDownOutline14, { size: 14 }) })
             ]
           }
@@ -415,15 +1215,29 @@ function LoopEngineComposerSelect(props) {
     /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
       import_dsh_client_ui_primitives2.Modal,
       {
-        open: pending !== null,
-        onClose: cancelSwitch,
-        title: t("confirmTitle"),
-        closeLabel: t("closeLabel"),
+        open: pendingReload !== null,
+        onClose: cancelReload,
+        title: t("switchReloadConfirmTitle"),
+        closeLabel: t("cancelAction"),
         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") })
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.Button, { variant: "outline", onClick: cancelReload, children: t("cancelAction") }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.Button, { variant: "primary", onClick: confirmReload, children: t("switchReloadConfirmAction") })
         ] }),
-        children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: confirmBody2, children: t("confirmBody") })
+        children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: noticeBody, children: t("switchReloadConfirmBody") })
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+      import_dsh_client_ui_primitives2.Modal,
+      {
+        open: notice2 !== null,
+        onClose: dismissNotice,
+        title: t(notice2?.title ?? "switchFailedTitle"),
+        closeLabel: t("closeLabel"),
+        footer: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_dsh_client_ui_primitives2.Button, { variant: "primary", onClick: dismissNotice, children: t("closeLabel") }),
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: noticeBody, children: notice2?.body }),
+          notice2?.detail === void 0 ? null : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { style: noticeDetail, children: notice2.detail })
+        ]
       }
     )
   ] });
@@ -565,203 +1379,6 @@ var LoopEngineStore = class {
   }
 };
 
-// src/client/turn-status.ts
-var ENGINE_ATTR = "data-loop-engine";
-var PLUGIN_ID = "dsh-loop-engine";
-var STYLESHEET = `
-[class$="_turnStatus"]::before {
-  margin-right: 6px;
-  background: none;
-  -webkit-background-clip: border-box;
-  background-clip: border-box;
-}
-
-/*
- * The row's own sweep, re-asserted for hosted engines.
- *
- * ui-chat disables that animation under \`prefers-reduced-motion: reduce\`
- * (ChatView.module.css), and a media query carries no specificity \u2014 so this
- * attribute-gated rule outranks it. That is deliberate here: deployment images
- * ship with Windows' client-area animation off (SPI_GETCLIENTAREAANIMATION
- * false), and with the guard in force EVERY indicator on this row is frozen \u2014
- * the sweep and the glyph alike. Scoped to hosted engines, so in-process
- * sessions keep the stock reduced-motion behaviour; delete this rule and
- * restore the guard at the foot of the sheet to hand the decision back to the OS.
- */
-html[${ENGINE_ATTR}] [class$="_turnStatus"] {
-  background-position: 100% 0;
-  background-size: 250% 100%;
-  animation: le-shimmer 1.8s linear infinite;
-}
-
-@keyframes le-shimmer {
-  to { background-position: 0 0; }
-}
-
-html[${ENGINE_ATTR}="claude-code"] [class$="_turnStatus"] {
-  --dsw-static-deepseek-500: #d97757;
-  --dsw-static-deepseek-200: #f5bda6;
-}
-html[${ENGINE_ATTR}="claude-code"] [class$="_turnStatus"]::before {
-  content: "\u273B";
-  color: #d97757;
-  -webkit-text-fill-color: #d97757;
-  animation: le-bloom 1.6s ease-in-out infinite;
-}
-
-html[${ENGINE_ATTR}="codex"] [class$="_turnStatus"] {
-  --dsw-static-deepseek-500: #a9b1c0;
-  --dsw-static-deepseek-200: #e6eaf2;
-}
-html[${ENGINE_ATTR}="codex"] [class$="_turnStatus"]::before {
-  content: "\u2022";
-  color: #a9b1c0;
-  -webkit-text-fill-color: #a9b1c0;
-  text-shadow: 0 0 6px currentColor;
-  animation: le-pulse 1.4s ease-in-out infinite;
-}
-
-html[${ENGINE_ATTR}="pi"] [class$="_turnStatus"] {
-  --dsw-static-deepseek-500: #8e4ec6;
-  --dsw-static-deepseek-200: #d6bff0;
-}
-html[${ENGINE_ATTR}="pi"] [class$="_turnStatus"]::before {
-  content: "\u280B";
-  color: #8e4ec6;
-  -webkit-text-fill-color: #8e4ec6;
-  font-size: 1.1em;
-  animation: le-braille 1s linear infinite;
-}
-
-html[${ENGINE_ATTR}="kimi"] [class$="_turnStatus"] {
-  --dsw-static-deepseek-500: #e5484d;
-  --dsw-static-deepseek-200: #f5b2b4;
-}
-html[${ENGINE_ATTR}="kimi"] [class$="_turnStatus"]::before {
-  content: "\u{1F317}";
-  color: #e5484d;
-  -webkit-text-fill-color: #e5484d;
-  animation: le-moon 2.5s linear infinite;
-}
-
-/* Grows from small to large each cycle \u2014 the opposite of a twinkle. The range
-   is deliberately wide (3x) because a bare size change on a thin glyph reads
-   weakly otherwise, and the large state is held briefly (50%-62%) so it blooms
-   rather than throbs. 1.35x extends ~2.5px per side at the 14px glyph, inside
-   the 6px ::before margin. */
-@keyframes le-bloom {
-  0%, 100% { transform: scale(0.45); opacity: 0.45; }
-  50%, 62% { transform: scale(1.35); opacity: 1; }
-}
-/* A terminal braille spinner. The glyph is an ordinary text character, not an
-   emoji, so the engine color actually paints \u2014 a colored emoji silently ignores
-   color/-webkit-text-fill-color. Stepping content walks the ten dot frames. */
-@keyframes le-braille {
-  0% { content: "\u280B"; }
-  10% { content: "\u2819"; }
-  20% { content: "\u2839"; }
-  30% { content: "\u2838"; }
-  40% { content: "\u283C"; }
-  50% { content: "\u2834"; }
-  60% { content: "\u2826"; }
-  70% { content: "\u2827"; }
-  80% { content: "\u2807"; }
-  90% { content: "\u280F"; }
-  100% { content: "\u280B"; }
-}
-/* A soft pulse for the codex dot: the glyph breathes between a small, dim
-   point and a larger, full-brightness one \u2014 a light dot, not a spinner. */
-@keyframes le-pulse {
-  0%, 100% { transform: scale(0.5); opacity: 0.35; }
-  50% { transform: scale(1.3); opacity: 1; }
-}
-/* Moon phases rather than a rigid rotation: a spinning moon bitmap can only
-   squash and mirror itself, never show a full or a new moon. Stepping the
-   glyph through the phase set sweeps the lit edge across the disc AND actually
-   reaches \u{1F315} and \u{1F311}. The order runs waning (full \u2192 new), so the lit edge
-   retreats right-to-left \u2014 the direction the user picked. */
-@keyframes le-moon {
-  0% { content: "\u{1F315}"; }
-  12.5% { content: "\u{1F314}"; }
-  25% { content: "\u{1F313}"; }
-  37.5% { content: "\u{1F312}"; }
-  50% { content: "\u{1F311}"; }
-  62.5% { content: "\u{1F318}"; }
-  75% { content: "\u{1F317}"; }
-  87.5% { content: "\u{1F316}"; }
-  100% { content: "\u{1F315}"; }
-}
-
-`;
-function reflect(engine, settled) {
-  const root = document.documentElement;
-  if (!settled || engine === "in-process") {
-    delete root.dataset.loopEngine;
-    return;
-  }
-  root.dataset.loopEngine = engine;
-}
-function installTurnStatusStyles(ctx, store) {
-  if (typeof document === "undefined") return;
-  ctx.effect(() => {
-    const tag = document.createElement("style");
-    tag.dataset.plugin = PLUGIN_ID;
-    tag.dataset.pluginCss = `${PLUGIN_ID}/turn-status.css`;
-    tag.textContent = STYLESHEET;
-    document.head.appendChild(tag);
-    return () => {
-      tag.remove();
-      delete document.documentElement.dataset.loopEngine;
-    };
-  }, "loop-engine: per-engine turn status styles");
-  const sync = () => {
-    const { status, engine } = store.getSnapshot();
-    reflect(engine, status === "ready");
-  };
-  ctx.effect(() => store.subscribe(sync), "loop-engine: turn status engine reflection");
-  sync();
-}
-
-// 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",
-  engineKimi: "Kimi Code 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",
-  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",
-  closeLabel: "\u5173\u95ED",
-  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",
-  engineKimi: "Kimi Code 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",
-  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",
-  closeLabel: "Close",
-  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";
 
@@ -781,7 +1398,9 @@ function apply(ctx) {
       controller.dispose();
     };
   }, "loop-engine: store lifecycle");
-  installTurnStatusStyles(ctx, controller.store);
+  installTurnStatusStyles(ctx);
+  const sessionEngines = createSessionEngineCache(ctx);
+  installReloadReturn(ctx);
   const t = ctx.locale.bind(NS);
   const injected = () => ({
     controller,
@@ -796,10 +1415,7 @@ function apply(ctx) {
     inject: injected
   }, LoopEngineSection));
   ctx.inject(["slots", "conversation"], (scope2) => {
-    const badgeInjected = () => ({
-      hooks: { snapshot: controller.store },
-      t
-    });
+    const badgeInjected = () => ({ sessionEngines, t });
     scope2.effect(() => {
       return scope2.slots.register({
         name: "conversation.session.header.actions",
@@ -812,10 +1428,15 @@ function apply(ctx) {
       }, LoopEngineBadge);
     }, "loop-engine: session header engine badge");
   });
+  const switchEngine = sessionEngineSwitcher(ctx, (sessionId) => {
+    sessionEngines.invalidate(sessionId);
+  });
   ctx.inject(["slots", "conversation"], (scope2) => {
     const composerInjected = () => ({
       controller,
       hooks: { snapshot: controller.store },
+      sessionEngines,
+      switchEngine,
       t
     });
     scope2.effect(() => {