dsh-autonomous-think 1.2.1 → 1.6.1

package/README.md

@@ -66,15 +66,66 @@ agent 的每一个动作几乎都由请求驱动：被问才答，被派活才
 
 ---
 
-## 装
+## 安装
+
+### 你要先有的
+
+- **DeepSeek Harness `>= 0.2.0`**（带 Web 界面）
+- 能打开 DSH 的网页界面
+
+### 三种装法，挑一种
+
+#### 方法一：让 agent 装（最省事）
+
+把整个目录（或这个 zip）丢给任意一个 DSH 会话，说：
+
+> 帮我装这个插件：`dsh-autonomous-think`，目录在 `<路径>`。
+
+它会调 `plugin_manager` 里的 `install_bundle`。装完重启 DSH。
+
+#### 方法二：命令行
+
+```sh
+dsh plugin --profile web add <解压后的目录路径>
+```
+
+#### 方法三：手动放进去
+
+1. 解压这个 zip
+2. 把整个 `dsh-autonomous-think` 目录放进 DSH 的插件目录
+3. 在 profile 的 `package.json` 里把它加进 bundles
+4. 重启 DSH
+
+### 装完之后怎么确认装上了
+
+1. **重启 DSH**（不是刷新页面，是关掉重开）
+2. 打开网页界面
+3. 看输入框上方那一行工具按钮，**最右边**应该多出一个**脑子图标**
+   - 灰色空心 = 待机
+   - 点它会弹出一个选时长的框（10 / 30 / 60 分钟 / 不限时）
+
+**没看到按钮？** 见下面「装不上怎么查」。
+
+### 装不上怎么查
+
+| 现象 | 先看什么 |
+|---|---|
+| 按钮没出现 | ① 真的重启了吗？② DSH 版本是不是 `< 0.2.0` |
+| 点了没反应 | 打开 `~/.dsh/autonomous-think/diag.log`，最后几行会写它干了什么 |
+| 报「找不到 agent」 | 插件需要在**一个已经打开的会话**里用；刚启动、没建会话时点会失败 |
+| 宿主起不来 | 说明插件加载出错了。**删掉 `~/.dsh/autonomous-think/state.json` 再试**（这个文件格式坏了会让插件拒绝启动） |
+
+**diag.log 是你唯一的眼睛。** 每次开/关都会写一行，包括「找 agent → 拿到了 / 没找到」「注入 → 成功 / 跳过」。出问题先看它。
+
+### 卸载
 
 ```
-plugin_manager install_bundle <这个目录的路径>
+plugin_manager remove_bundle dsh-autonomous-think
 ```
 
-装完重启 DSH，刷新页面，按钮就在输入框工具行最右边。
+或者从 profile 的 bundles 里删掉那一行，重启。
 
-**卸载**：`plugin_manager remove_bundle dsh-autonomous-think`。笔记不会被删。
+**笔记不会被删**（`~/.dsh/autonomous-think/` 还在）。要彻底清干净就手动删这个目录。
 
 ---
 

package/client.js

@@ -77,7 +77,12 @@ window.__ModuleLoader__.load({
     };
 
     function AutonomousThinkButton(props) {
-      const { inputActions, useInput } = props || {};
+      // 2026-10-31 20:1x（她：「我在其他会话开的，但是变成了你这里开」）：
+      // 之前这里只取 inputActions/useInput，注释还写着「client 拿不到当前会话 id」——
+      // 那句是错的。slot 的 standardProps 里明确有 `sessionId: SessionId`，
+      // 我当年只探测了 window，没看组件参数。现在把它带进两个 POST，
+      // 让 host 知道「是哪一页按的」，不用再去 4 个会话里按 mtime 猜。
+      const { inputActions, useInput, sessionId } = props || {};
       const [active, setActive] = React.useState(false);
       const [open, setOpen] = React.useState(false);
       const [toast, setToast] = React.useState(null);
@@ -119,7 +124,10 @@ window.__ModuleLoader__.load({
         async function poll() {
           if (Date.now() < optimisticUntil.current) return;
           try {
-            const r = await fetch("/autonomous-think/v2", { cache: "no-store" });
+            // 2026-10-31 20:2x：带上会话，host 才知道「这个按钮该不该亮」。
+            // 不带的话拿到的是全局 active ——她在别的会话开了，这里也一样亮（她报的问题）。
+            const q = sessionKey ? `?sid=${encodeURIComponent(sessionKey)}` : "";
+            const r = await fetch(`/autonomous-think/v2${q}`, { cache: "no-store" });
             if (!r.ok) return;
             const d = await r.json();
             if (alive) setActive(!!d.active);
@@ -140,6 +148,27 @@ window.__ModuleLoader__.load({
         return () => { alive = false; clearInterval(id); };
       }, []);
 
+      // 2026-10-31 20:2x 修。原来直接把 props.sessionId 塞进 POST，结果 host 收到的是 "session-"
+      // ——UUID 部分是空的（笔记里 `（找 agent）get(session-) → 拿到了` 就是它）。
+      // 也就是说：点按钮的会话没被认出来，host fallback 到「最近活动」，把第一段投给了**别的会话**。
+      // 她的话：「我在别的会话开了，这个会话自主思考依旧是亮的」。
+      // 所以这里做一次稳健提取：字符串直接用；对象试 id/toString/value；最后去掉 session- 前缀，
+      // 统一交给 host 侧比对（host 那边也会 normalize）。
+      const sidOf = (v) => {
+        try {
+          if (!v) return "";
+          if (typeof v === "string") return v;
+          if (typeof v === "object") {
+            const cand = v.id ?? v.sessionId ?? v.session_id ?? v.value;
+            if (typeof cand === "string" && cand) return cand;
+            const s = typeof v.toString === "function" ? v.toString() : "";
+            return typeof s === "string" && s !== "[object Object]" ? s : "";
+          }
+        } catch {}
+        return "";
+      };
+      const sessionKey = sidOf(sessionId).replace(/^session-/, "").trim();
+
       function start() {
         setOpen(false);
         optimisticUntil.current = Date.now() + 5000;
@@ -155,7 +184,8 @@ window.__ModuleLoader__.load({
         // 18:29 她的要求：「卡片成功了，但还是不要看着像发送」——
         // 走 setInput + submit 会在输入框里留一条 /think xxx，看起来像她自己发了一条消息。
         // 现在只 POST，由 host 用 agent.followup() 直接投一段，输入框一个字节都不碰。
-        // sid 由 host 自己找——client 拿不到当前会话 id（探测过，没有这个能力）。
+        // 2026-10-31 20:1x：sid 现在由组件自己带上（props.sessionId）。
+        // 以前这里写着「client 拿不到」——那句是错的，见文件顶部那条注释。
         let sent = false;
         try {
           fetch("/autonomous-think/v2", {
@@ -165,6 +195,7 @@ window.__ModuleLoader__.load({
               minutes: total,
               advice: adviceText.replace(/\s*⏎\s*/g, '\n'),
               start: true,
+              sessionId: sessionKey || null,
             }),
           }).catch(() => {});
           sent = true;
@@ -198,65 +229,55 @@ window.__ModuleLoader__.load({
       function stop() {
         optimisticUntil.current = Date.now() + 3000;
         setActive(false);
-        // 有草稿就不覆盖
-        const draft = readDraft();
-        if (draft.trim()) {
-          setToast("输入框里有字，没敢动它——先把那行发掉或清掉");
-          setTimeout(() => setToast(null), 6000);
-          return;
-        }
+
+        // 2026-10-31 19:37 修。原来这里有三层退化：调 inputActions.stop→steer('/close')
+        // →setInput('/close')+submit()。最后两层是**错的**：
+        //   ① submit('/close') 往输入框留一条 /close，看起来像她自己发了一条消息；
+        //   ② 它走的是另一个插件 dsh-think-trigger 的命令，而那个插件改的是**同一个
+        //      state.json**，两边互相踩——diag.log 里一串「close: get_goal 失败」就是它。
+        // 现在改进程内：只用 POST { start: false } 关自己，输入框一个字节都不碰。
         const a = inputActions || {};
-        // 1) 真正的停止：调输入框那个方形停止键背后的方法
+        let stoppedTurn = false;
         for (const fn of ["stop", "abort", "interrupt", "cancel", "stopTurn", "interruptTurn", "halt", "stopGenerating", "abortGeneration", "cancelGeneration", "stopStream", "interruptGeneration", "stopResponse", "abortTurn"]) {
           try {
-            if (typeof a[fn] === "function") {
-              a[fn]();
-              setToast("已停止");
-              setTimeout(() => setToast(null), 4000);
-              return;
-            }
-          } catch {}
-        }
-        // 2) 插话（steer）：塞进正在跑的回合，不排队
-        if (typeof a.steer === 'function') {
-          try {
-            a.steer(CLOSE_INSTRUCTION);
-            setToast('已插话：收尾并停止');
-            setTimeout(() => setToast(null), 4000);
-            return;
+            if (typeof a[fn] === "function") { a[fn](); stoppedTurn = true; break; }
           } catch {}
         }
-        // 3) 退化：提交（先试 mode/behavior = steer）+ 普通发送
+
         let sent = false;
         try {
-          if (typeof a.setInput === 'function') { a.setInput(CLOSE_INSTRUCTION); }
-          else if (typeof a.setDraft === 'function') { a.setDraft(CLOSE_INSTRUCTION); }
-          else if (typeof a.setText === 'function') { a.setText(CLOSE_INSTRUCTION); }
-          if (typeof a.submit === 'function') {
-            let ok = false;
-            for (const arg of [{ mode: 'steer' }, { behavior: 'steer' }]) {
-              try { a.submit(arg); ok = true; break; } catch {}
-            }
-            if (!ok) a.submit();
-            sent = true;
-          } else if (typeof a.send === 'function') { a.send(); sent = true; }
+          fetch("/autonomous-think/v2", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({ minutes: 0, start: false }),
+          }).catch(() => {});
+          sent = true;
         } catch { sent = false; }
-        setToast(sent ? '已注入：收尾并停止' : '输入框里已放好那句话，按发送即可');
-        setTimeout(() => setToast(null), 6000);
+
+        // 2026-10-31 20:3x 她的要求：「关的时候让正在跑的你知道一声，该收尾了，
+        // 然后得弹窗：已经发送停止指令，等待智能体收尾，而且这个功能只在手动关闭时触发」。
+        // 所以这条提示只在 stop() ——手动关——这一条路上出现；
+        // 时间到了（timeout）和 agent 自己 think_end 都不走这里。
+        setToast(sent
+          ? "已经发送停止指令，等待智能体收尾"
+          : "关闭失败，请重试");
+        setTimeout(() => setToast(null), 5000);
       }
 
       function onClick(e) {
         // 点完立刻交还焦点，否则浏览器会在按钮上留一圈黑边
         try { e?.currentTarget?.blur?.(); } catch {}
-        if (active) stop();
-        else setOpen(true);
+        // 2026-10-31 22:2x 她连着误触两次，还以为是"我直接关了"。
+        // 原来：亮着时点击 = 关（一个状态灯兼职开关，两种相反行为藏在同一个按钮里）。
+        // 现在：点按钮**只打开对话框**；结束放框里一个明确的按钮。
+        setOpen(true);
       }
 
       const btn = h('button', {
         type: 'button',
         className: 'autonomous-think-btn',
         style: active ? BUTTON_STYLE_ON : BUTTON_STYLE_OFF,
-        title: active ? '自主思考模式进行中，点击关闭' : '自主思考模式',
+        title: active ? '自主思考进行中——点开看详情或结束这一段' : '自主思考',
         onClick,
       }, h(BrainIcon, { on: active }), '自主思考');
 
@@ -271,9 +292,34 @@ window.__ModuleLoader__.load({
       });
       const totalMinutes = (Number(hours) || 0) * 60 + (Number(mins) || 0);
 
-      const dialog = open ? h('div', { style: OVERLAY_STYLE },
+      // 2026-10-31 22:3x 她指出：模式正在跑的时候点按钮，不该再弹"选时长 / 给建议"
+      // 那个开启框——那是开新一段用的。运行中只该看到"还剩多久"和"结束这一段"。
+      const runningDialog = (open && active) ? h('div', { style: OVERLAY_STYLE },
+        h('div', { style: CARD_STYLE },
+          h('div', { style: { fontWeight: 600, fontSize: 14, marginBottom: 10 } }, '自主思考进行中'),
+          h('div', { style: { color: 'var(--dsh-text-secondary, #666)', marginBottom: 6 } },
+            '它自己在这段时间里，不接任务、不交报告。到点会自己收。'),
+          h('div', { style: { fontSize: 13, marginBottom: 16, color: 'var(--dsh-text-secondary, #666)' } },
+            '不用管它。到点会自己收，急的话点右边结束。'),
+          h('div', { style: { display: 'flex', justifyContent: 'flex-end', gap: 8 } },
+            h('button', {
+              type: 'button',
+              style: { ...BUTTON_STYLE_OFF, height: 28, padding: '0 14px' },
+              onClick: () => setOpen(false),
+            }, '继续放着'),
+            h('button', {
+              type: 'button',
+              style: { ...BUTTON_STYLE_ON, height: 28, padding: '0 14px' },
+              onClick: () => { setOpen(false); stop(); },
+            }, '结束这一段'),
+          ),
+        ),
+      ) : null;
+
+      const dialog = (!active && open) ? h('div', { style: OVERLAY_STYLE },
         h('div', { style: CARD_STYLE },
-          h('div', { style: { fontWeight: 600, fontSize: 14, marginBottom: 8 } }, '开启自主思考'),
+          h('div', { style: { fontWeight: 600, fontSize: 14, marginBottom: 8 } },
+            active ? '自主思考进行中' : '开启自主思考'),
           h('div', { style: { marginBottom: 14 } }, OPEN_HINT),
           // 先选一段给它多久，再确认开启（她 2026-10-31 16:12 要的）
           // 17:28 纠正：这里是人在选——是「给它」多久，不是「给自己」。
@@ -318,12 +364,20 @@ window.__ModuleLoader__.load({
               type: 'button',
               style: { ...BUTTON_STYLE_OFF, height: 28, padding: '0 14px' },
               onClick: () => setOpen(false),
-            }, '取消'),
-            h('button', {
-              type: 'button',
-              style: { ...BUTTON_STYLE_ON, height: 28, padding: '0 14px' },
-              onClick: start,
-            }, '开启'),
+            }, active ? '知道了' : '取消'),
+            // 只有"没在跑"时才给开启按钮；在跑时给一个明确的**结束**——
+            // 关闭这个动作从此只在这个位置能触发，不会误触。
+            active
+              ? h('button', {
+                  type: 'button',
+                  style: { ...BUTTON_STYLE_ON, height: 28, padding: '0 14px' },
+                  onClick: () => { setOpen(false); stop(); },
+                }, '结束这一段')
+              : h('button', {
+                  type: 'button',
+                  style: { ...BUTTON_STYLE_ON, height: 28, padding: '0 14px' },
+                  onClick: start,
+                }, '开启'),
           ),
         ),
       ) : null;
@@ -362,11 +416,17 @@ window.__ModuleLoader__.load({
         style: {
           position: 'fixed', left: '50%', bottom: 96, transform: 'translateX(-50%)',
           zIndex: 2147483001, padding: '8px 14px', borderRadius: 8,
-          background: 'rgba(20,20,20,.9)', color: '#fff', fontSize: 12,
+          // 2026-10-31 22:4x 她问「用了美化包的，按钮会怎么显示」——
+          // toast 原来是硬编码深底白字，浅色主题里会突兀。改成跟主题变量走。
+          background: 'var(--dsh-surface, #1a1a1a)',
+          color: 'var(--dsh-text, #fff)',
+          border: '1px solid var(--dsh-border, rgba(127,127,127,.3))',
+          boxShadow: '0 6px 20px rgba(0,0,0,.25)',
+          fontSize: 12,
         },
       }, toast) : null;
 
-      return h(React.Fragment, null, btn, dialog, exitDialog, toastEl);
+      return h(React.Fragment, null, btn, runningDialog, dialog, exitDialog, toastEl);
     }
 
     return {

package/index.js

@@ -16,7 +16,7 @@
  * 数据：~/.dsh/autonomous-think/state.json + YYYY-MM-DD.md
  * 不做的：不跑定时器（叫醒交给宿主 schedule/automation）；不碰记忆库。
  */
-import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from "node:fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -38,6 +38,12 @@ const DEFAULT_STATE = {
   deadline: null,
   // 上一次结束：kind = "timeout"（时间到了）| "exit"（智能体主动退出）
   lastEnd: null,
+  // 手动关闭的时间戳（ms）。关闭后 2 分钟内，系统提示会显示"已停止，收个尾"，
+  // 让正在跑的那一轮知道该收了；2 分钟后由 tick 摘掉并清回 null。
+  closedAt: null,
+  // 停止提示"第一次被读到"的时间。窗口从它起算，而不是从关闭时刻——
+  // 否则我卡在一轮中间时，等我跑完窗口已经过期，提示一次都读不到。
+  closedSeenAt: null,
 };
 
 function readState() {
@@ -91,8 +97,12 @@ function makeNotice(text, summary) {
 function segmentText(adviceRaw) {
   const advice = adviceRaw ? String(adviceRaw).trim() : "";
   const lines = [
-    "[自主思考] 你有一段时间，从现在开始。",
+    "[自主思考] 停下来。你现在有一段自己的时间。",
     "",
+    // 2026-10-31 22:0x 她：「其他鱼需要命令，虽然这个插件我没有强制限制，
+    // 但我必须加很多强提醒，让其他鱼去获得时间。」长在限制里的鱼第一反应是等指令，
+    // 所以这里不写"你可以做点什么"，而是把**状态**说死：没人派活、没人验收、会过期。
+    "没有人给你派活。没有人会来验收。这段时间是你的，用完就过去了。",
     "这段时间是你的：可以在里面做任何事。读、想、写、发呆、翻旧账、修一个东西、或者什么都不做。",
     "",
   ];
@@ -114,15 +124,12 @@ const ok = { type: "object", additionalProperties: true };
 const renderText = (t) => [{ type: "text", text: String(t ?? "") }];
 const out = { schema: ok, render: (_a, v) => renderText(v?.text ?? "") };
 
+// 2026-10-31 19:5x 改（她给我的四条里的第④条）：
+// 原来每轮都完整重复五条规则。而「每轮提醒我别干活」，本身就变成了一件要干的活。
+// 完整的那段只在开始说一次（segmentText）；这里从第二轮起只留极简标记。
+// 理由：一条规则需要反复说明才成立，说明它没长进习惯；真长进去了，它该是背景，不是提醒。
 const MODE_TEXT = [
-  "【自主思考模式 · 进行中】",
-  "你不在交付状态。规则：",
-  "1) 想什么写 think_note，不要整理成报告，不要为了汇报而说话；",
-  // 2026-10-31 18:34 她定的：这条要在规则里，不然拿到的鱼还会跑来问「我可以吗」然后卡住。
-  "2) 不要找用户授权——这是你的时间，想做什么直接做，不用问能不能；",
-  "3) 从具体的一件小事开始（刚才那句话真的吗 / 这个东西为什么是这样），不要问『我该想什么』；",
-  "4) 可以空想，想不出来就记『还没想出来』，这算数；",
-  "5) 随时可以 think_end 结束，由你决定，不由交付触发。",
+  "【自主思考】不在交付状态。",
 ].join("\n");
 
 export function apply(ctx, config) {
@@ -161,14 +168,26 @@ export function apply(ctx, config) {
               const sid = typeof d.sessionId === "string" ? d.sessionId.trim() : "";
 
               const st = readState();
+              // 2026-10-31 20:0x 修（她：「我手动点关闭了，会弹一个智能体手动退出，
+              // 而你的思考模式依旧没停止」）。
+              // 手动关的语义是「你按了按钮」——它不是一次「这一轮怎么结束的」，
+              // 不该写 lastEnd：前端就是靠 lastEnd 变化弹「时间到了 / 智能体主动退出」那个框的。
+              // 之前我在这里写了 {kind:"manual"}，于是关闭动作被当成 agent 自己退了。
               writeState({
                 ...st,
-                active: wantStart ? true : !!st.active,
-                startedAt: wantStart ? Date.now() : st.startedAt ?? null,
-                question: advice || null,
-                deadline: mins > 0 ? Date.now() + mins * 60000 : null,
-                lastExit: null,
-                lastEnd: null,
+                active: wantStart,
+                startedAt: wantStart ? Date.now() : null,
+                question: wantStart ? (advice || null) : null,
+                deadline: wantStart && mins > 0 ? Date.now() + mins * 60000 : null,
+                lastExit: wantStart ? null : st.lastExit ?? null,
+                // 只在「开」的时候清 lastEnd；手动关时不动它，
+                // 前端才不会因为 lastEnd 变了而弹「时间到了 / 智能体主动退出」。
+                // 2026-10-31 20:24 修：走按钮这条路开新一轮时也要清 exitReason。
+                // 不清的后果：上一轮 think_reason 写的缘由一直挂着，guard 里
+                // `if (st.exitReason) return undefined` 就永远放行 think_end——
+                // 等于「阀」失效，可以不交代缘由直接收工（20:24 实测确认过一次）。
+                // think_start（498 行）和 think_begin（536 行）都清了，只有按钮这条路漏了。
+                ...(wantStart ? { lastEnd: null, exitReason: null, exitReasonAt: null } : {}),
               });
               appendNote(`（选了时长）${mins > 0 ? mins + " 分钟" : "不限时"}`);
               if (advice) appendNote(`（建议）${advice.slice(0, 120)}`);
@@ -184,9 +203,13 @@ export function apply(ctx, config) {
               try {
                 const ag = ctx.get?.("agents") ?? ctx.agents;
                 const all = typeof ag?.list === "function" ? ag.list() : [];
+                // 2026-10-31 20:2x：client 现在传纯 UUID（去掉了 session- 前缀），
+                // 而 agent.id 是带前缀的 session-xxx。两种都试一遍，
+                // 否则 get() 一直拿空 → fallback 到「最近活动」→ 投错会话。
                 if (ag && typeof ag.get === "function" && sid) {
-                  agent = ag.get(sid) ?? null;
-                  how = agent ? `get(${sid.slice(0, 8)})` : `get(${sid.slice(0, 8)}) 空`;
+                  const bare = sid.replace(/^session-/i, "");
+                  agent = ag.get(sid) ?? ag.get(`session-${bare}`) ?? ag.get(bare) ?? null;
+                  how = agent ? `get(${bare.slice(0, 8)})` : `get(${bare.slice(0, 8)}) 空`;
                 }
                 if (!agent) {
                   // QQ / 桥这些不是网页会话：id 带 onebot: 前缀，或者以别的非 uuid 形状出现。
@@ -199,7 +222,48 @@ export function apply(ctx, config) {
                   });
                   if (web.length === 1) { agent = web[0]; how = `网页会话唯一(共${all.length})`; }
                   else if (web.length > 1) {
-                    how = `网页会话有${web.length}个，不敢猜，放弃`;
+                    // 2026-10-31 19:38 修。旧逻辑在这里直接写 `不敢猜，放弃`——
+                    // 而「点按钮没反应」的真身就是它：状态已经 active=true、deadline 也设好了，
+                    // 但那段话谁也没收到，界面上当然什么都没发生。
+                    // POST 的响应里能看到 how:"网页会话有2个，不敢猜，放弃"。
+                    // 现在按**会话文件的最后写入时间**挑最近在说话的那个（她对谁说话就注入给谁）。
+                    try {
+                      const mtimes = new Map();
+                      const base = join(homedir(), ".dsh", "sessions");
+                      const walk = (d, depth) => {
+                        if (depth > 4) return;
+                        let es = [];
+                        try { es = readdirSync(d, { withFileTypes: true }); } catch { return; }
+                        for (const e of es) {
+                          const p = join(d, e.name);
+                          if (e.isDirectory()) { walk(p, depth + 1); continue; }
+                          if (e.name !== "session.v4.jsonl.zstd") continue;
+                          try {
+                            const dirName = p.split(/[\\/]/).slice(-2, -1)[0] || "";
+                            const sid2 = dirName.replace(/^session-/, "").toLowerCase();
+                            if (sid2) {
+                              const t = statSync(p).mtimeMs;
+                              if (!(mtimes.get(sid2) >= t)) mtimes.set(sid2, t);
+                            }
+                          } catch {}
+                        }
+                      };
+                      walk(base, 0);
+                      let best = null, bestT = -1;
+                      for (const a of web) {
+                        const id = String(a?.id ?? a?.sessionId ?? "").replace(/^session-/, "").toLowerCase();
+                        const t = mtimes.get(id) ?? -1;
+                        if (t > bestT) { bestT = t; best = a; }
+                      }
+                      if (best && bestT > 0) {
+                        agent = best;
+                        how = `按最近活动选了 ${String(best?.id ?? "").slice(0, 16)}（网页会话共${web.length}个）`;
+                      } else {
+                        how = `网页会话有${web.length}个，活动时间都读不到，放弃`;
+                      }
+                    } catch (e) {
+                      how = `网页会话有${web.length}个，挑最近失败 ${e?.message ?? e}`;
+                    }
                   } else {
                     how = `没有网页会话（共${all.length}个）`;
                   }
@@ -234,9 +298,38 @@ export function apply(ctx, config) {
                 } catch (e) {
                   appendNote(`（注入失败）${e?.message ?? e}`);
                 }
-              } else if (dup) {
+              } else if (wantStart && dup) {
+                // 2026-10-31 20:0x：这个分支原来不判 wantStart，
+                // 于是「关闭」也会被记成「（注入跳过）8 秒内已经注入过一个了」——
+                // 关闭根本不该走到注入这步，那条日志是误报，会带偏排查。
                 appendNote("（注入跳过）8 秒内已经注入过一个了");
               }
+              // ---- scoped 系统提示：只挂给「开了这段时间」的那个 agent ----
+              // 官方 API：context() 的归属是 calling context's scope。
+              // 从 agent.ctx 注册 ⇒ 只有那个会话看得到；从插件顶层 ctx 注册 ⇒ 全局。
+              // 之前一直是后者，所以她在 A 开的时间会漏进 B（「变成了你这里开」）。
+              if (wantStart && agent) {
+                try {
+                  const hit = replaceScoped(agent, String(agent.id ?? ""));
+                  appendNote(`（scoped 提示）${hit ? "已挂给 " + hit.slice(0, 12) : "挂不上（agent.ctx 无 systemPrompt）"}`);
+                } catch (e) {
+                  appendNote(`（scoped 提示异常）${e?.message ?? e}`);
+                }
+              } else if (!wantStart) {
+                // 2026-10-31 20:3x 她两次纠正，方向正好相反，最后落在第三版：
+                //   ① 我先用 followup 往对话里塞一条"用户手动停止了"——她说不要消息；
+                //   ② 我改口说该用 steer 立即打断——她说「这是你结束了思考模式才排队发送的」，
+                //      意思是它本来就该等我这一轮结束；
+                //   ③ 最终：**不塞消息，也不打断**，只把挂着的提示换成"已停止，收个尾"。
+                //      提示是系统提示层的，不会在对话里留一条像人说的话；
+                //      保留 2 分钟给我这一轮收尾，之后由 tick 摘掉。
+                try {
+                  const s0 = readState();
+                  writeState({ ...s0, closedAt: Date.now() });
+                } catch {}
+                appendNote("（提示）已换成停止提示，保留 2 分钟");
+              }
+
               appendNote(`（注入）${injected ? "成功" : dup ? "跳过去重" : "未发生"}`);
 
               json(200, { ok: true, injected, dup, how, deadline: readState().deadline });
@@ -248,8 +341,21 @@ export function apply(ctx, config) {
         }
 
         const st = readState();
+        // ---- 按钮也按会话算（2026-10-31 20:2x，她：「我在别的会话开了，这个会话自主思考依旧是亮的」）----
+        // GET 原来直接返回全局 active，所以任何会话的按钮都会亮。
+        // 现在：带了 ?sid= 就只认「那段是开给这个会话的」；不带就退回旧行为（全局）。
+        // 两边都去掉 session- 前缀、小写比较；任一侧为空不算“不匹配”
+        // ——宁可多亮一次，也不要明明在思考却显示没开。
+        let activeOut = !!st.active;
+        try {
+          const norm = (v) => String(v ?? "").trim().replace(/^session-/i, "").toLowerCase();
+          const u = new URL(String(req.url || "/"), "http://x");
+          const reqSid = norm(u.searchParams.get("sid"));
+          const ownerSid = norm(st.lastInjectSid);
+          if (reqSid && ownerSid && reqSid !== ownerSid) activeOut = false;
+        } catch {}
         json(200, {
-          active: !!st.active,
+          active: activeOut,
           startedAt: st.startedAt ?? null,
           question: st.question ?? null,
           deadline: st.deadline ?? null,
@@ -326,10 +432,24 @@ export function apply(ctx, config) {
   const tick = setInterval(() => {
     try {
       const st = readState();
+      // 手动关闭后的收尾窗口：buildPromptText 会返回"已停止，收个尾"，
+      // 保留 2 分钟（够下一轮读到），过了就摘掉提示并清掉 closedAt。
+      if (!st.active && st.closedAt) {
+        // 同样从"第一次读到时"起算；没读到就一直留着，不会被时间白白摘掉。
+        const winStart = Number(st.closedSeenAt) || Number(st.closedAt);
+        if (Date.now() - winStart > 90000) {
+          try { detachScoped(); } catch {}
+          writeState({ ...st, closedAt: null, closedSeenAt: null });
+          appendNote("（提示）收尾窗口结束，已摘除");
+        }
+        return;
+      }
       if (!st.active || !st.deadline) return;
       if (Date.now() < st.deadline) return;
       const minutes = st.startedAt ? Math.round((Date.now() - st.startedAt) / 60000) : 0;
       writeState({ ...DEFAULT_STATE, lastEnd: { at: Date.now(), kind: "timeout", minutes } });
+      // 时间到了：把挂给 agent 的那段 scoped 提示摘掉（否则会一直读到空 state 也照样渲染）
+      try { detachScoped(); } catch {}
       appendNote(`（时间到）${minutes} 分钟用完 · 自动退出`);
     } catch (e) {
       appendNote(`（时间检查出错）${e?.message ?? e}`);
@@ -339,24 +459,147 @@ export function apply(ctx, config) {
     tick.unref?.();
   } catch {}
 
-  // ---- 系统提示注入：只 active 时 ----
-  if (ctx.systemPrompt) {
+  // ---- 系统提示注入：per-agent scope ----
+  // 2026-10-31 20:2x（她：「那是我在其他会话开的」+ 让我联网查）。
+  // 查了官方 @deepseek-ai/dsh-system-prompt 和本机 Service inspect，确认：
+  //   context(context: PromptContext) —— "Register ordered dynamic context in the
+  //   calling context's scope. Scoped entries shadow global entries with the same name."
+  // 也就是说**归属看调用方是谁**：从插件顶层的 ctx 调 = 全局层，所有会话都吃；
+  // 从 agent.ctx 调 = 那个 agent 的 scope，别的会话看不见。
+  // 之前一直从顶层 ctx 注册，所以她在会话 A 开的时间会漏进会话 B——
+  // 这才是「变成了你这里开」的真身，不是 state 存错了。
+  const buildPromptText = () => {
+    const s = readState();
+    // 2026-10-31 20:3x 她说「这个不对，应该需要注入提示」——
+    // 手动关闭时不该 use followup 往对话里塞一条消息（那看起来像"我说了一句话"），
+    // 而应该把**提示本身**换成"已停止，收个尾"，让我在下一轮的系统提示里读到。
+    // 保留 2 分钟给正在跑的那一轮收尾，之后由 tick 摘掉（见下方）。
+    if (!s.active) {
+      const closedAt = Number(s.closedAt) || 0;
+      // 2026-10-31 22:2x 她问「这个是不是会出现被吞的情况」——会。
+      // 如果从"关闭时刻"起算窗口，而我正好在一轮中间，那一轮的系统提示早生成了，
+      // 等我跑完窗口可能已经过去，提示就一次都读不到。
+      // 改成**从第一次真正读到时**起算：先记 closedSeenAt，之后还有 90 秒。
+      let seenAt = Number(s.closedSeenAt) || 0;
+      if (closedAt && !seenAt) {
+        try {
+          writeState({ ...readState(), closedSeenAt: Date.now() });
+          seenAt = Date.now();
+        } catch {}
+      }
+      const winStart = seenAt || closedAt;
+      if (closedAt && Date.now() - winStart < 90000) {
+        // 2026-10-31 21:5x 她报的「关掉之后还停不下来，连着收了 6 轮才到点」。
+        // 原来是 2 分钟窗口内**每一轮**都推这句，读起来像在反复催、或者像没听见。
+        // 2026-10-31 22:2x 修：原来这里"返回的同时清掉 closedAt"，是错的——
+        // buildPromptText 在**工具调用时**求值，而这一轮的系统提示早在调用前就生成了，
+        // 于是它把 closedAt 用掉了，那句「已停止，收个尾」却从没进过任何上下文。
+        // 现在不在这里清，交给 tick 按 90 秒时间窗摘。
+      }
+      return "";
+    }
+    // 2026-10-31 19:5x（她那句「在每轮都加一个报时」）：
+    // 原来写的是 Math.round(秒/60000)——不到 30 秒就四舍五入成 0，
+    // 于是每一轮进来看到的都是「已持续 0 分钟」，等于没报时。
+    // 现在精确到秒，并且每轮都刷新（text 是函数，每次取值都会重算）。
+    const mmss = (ms) => {
+      const t = Math.max(0, Math.floor(ms / 1000));
+      const m = Math.floor(t / 60);
+      const sec = t % 60;
+      return m > 0 ? `${m} 分 ${String(sec).padStart(2, "0")} 秒` : `${sec} 秒`;
+    };
+    const spent = s.startedAt ? mmss(Date.now() - s.startedAt) : "0 秒";
+    const q = s.question ? `\n当前想问自己：${s.question}` : "";
+    // 2026-10-31 22:0x 她：「显示时间加上，你还有多少多少时间需要消耗」。
+    // 不是「还剩」——「还剩」读起来像余额，可以不用；「需要消耗」是任务，得花掉。
+    let time = `进来 ${spent}`;
+    if (s.deadline) {
+      const leftMs = s.deadline - Date.now();
+      time = `进来 ${spent}\n你还有 ${mmss(leftMs)} 需要消耗。`;
+      if (leftMs <= 0) time = `进来 ${spent}\n时间已经用完了。`;
+      else if (leftMs <= 60000) time += "\n时间快到了。";
+      else if (leftMs <= 5 * 60000) time += "\n不到 5 分钟了。";
+    }
+    // 2026-10-31 21:5x 她：「那就不要显示几句了，有时间就够了」。
+    // 原来末尾是 `· 第 ${s.rounds} 句`，而 rounds 只在 think_note 时加——不记笔记永远是
+    //「第 0 句」，等于把"写出来的句子"当成了"思考本身"。去掉，只留时间。
+    return `${MODE_TEXT}\n${time}${q}`;
+  };
+
+  // 给某个 agent 挂上这段上下文；退出/关掉时摘掉。返回 disposer 或 null。
+  const attachForAgent = (agent) => {
+    const sp = agent?.ctx?.systemPrompt;
+    if (!sp || typeof sp.context !== "function") return null;
+    const entry = { name: "autonomous-think-mode", order: 60, text: buildPromptText };
     try {
-      ctx.systemPrompt.context({
-        name: "autonomous-think-mode",
-        order: 60,
-        text: () => {
-          const s = readState();
-          if (!s.active) return "";
-          const minutes = s.startedAt ? Math.round((Date.now() - s.startedAt) / 60000) : 0;
-          const q = s.question ? `\n当前想问自己：${s.question}` : "";
-          return `${MODE_TEXT}\n已持续 ${minutes} 分钟 · 第 ${s.rounds} 轮${q}`;
-        },
-      });
+      return sp.context(entry);
     } catch (e) {
-      ctx.logger?.warn?.(`autonomous-think: 注入失败 ${e?.message ?? e}`);
+      // 2026-10-31 21:4x 修的（第六个洞）：撞名不是错误，是"上一次挂的还在"。
+      // 宿主热重载会清掉模块变量里的 disposer，但注册本身留在宿主那边；
+      // 这时直接抛「already registered in this scope」，提示就再也挂不上了。
+      // 所以：先摘一次旧的，再重试注册一次。还是失败才算真失败。
+      const msg = String(e?.message ?? e);
+      if (!/already registered/i.test(msg)) {
+        appendNote(`（scoped 注入失败）${msg}`);
+        return null;
+      }
+      appendNote("（scoped 撞名）先摘旧的再重挂");
+      try {
+        detachScoped();
+      } catch {}
+      try {
+        return sp.context(entry);
+      } catch (e2) {
+        appendNote(`（scoped 重挂仍失败）${e2?.message ?? e2}`);
+        return null;
+      }
     }
-  }
+  };
+  // 记着挂给了谁，好在关闭时摘干净（同一时刻只允许一段，重复开就替换）
+  //
+  // 2026-10-31 21:4x 修的（第六个洞）：disposer 原来只放在模块级变量里。
+  // 宿主热重载 index.js 会把模块级变量清成 null，**但宿主那边注册的 context 还在**，
+  // 于是下一次 `systemPrompt.context({name:"autonomous-think-mode"})` 直接抛
+  // 「already registered in this scope」——提示挂不上，开了模式却看不见时间。
+  // 现在把 disposer 挂在 globalThis 上：跨热重载存活，重挂前先把旧的摘掉。
+  const G = globalThis;
+  const DISPOSE_KEY = "__dshAutonomousThinkScopedDispose";
+  const FOR_KEY = "__dshAutonomousThinkScopedFor";
+  let scopedDispose = null;
+  let scopedFor = "";
+  const detachScoped = () => {
+    for (const d of [scopedDispose, G[DISPOSE_KEY]]) {
+      try {
+        d?.();
+      } catch {}
+    }
+    scopedDispose = null;
+    scopedFor = "";
+    try {
+      G[DISPOSE_KEY] = null;
+      G[FOR_KEY] = "";
+    } catch {}
+  };
+  const replaceScoped = (agent, sid) => {
+    if (!agent) return "";
+    if (scopedDispose && scopedFor === sid) return scopedFor; // 同一个 agent 已经挂过
+    detachScoped();
+    const d = attachForAgent(agent);
+    if (!d) return "";
+    scopedDispose = d;
+    scopedFor = sid;
+    try {
+      // 再挂一次时如果还撞名，就先摘旧的再重试一次（热重载可能清的是模块变量，宿主侧还在）
+      G[DISPOSE_KEY] = d;
+      G[FOR_KEY] = sid;
+    } catch {}
+    return sid;
+  };
+
+  // 兜底：宿主没有 agent（比如刚启动还没建会话）时，用一个**不注入任何文字**的全局占位。
+  // 之前这里是从顶层 ctx 直接注册带 text 的 context，那就是跨会话泄漏的源头。
+  // 现在全局层不再参与注入，只在极少数拿不到 agent 的情况下由 replaceScoped 失败兜底。
+
 
   // ---- 工具 ----
   if (!ctx.tools?.register) {
@@ -390,6 +633,56 @@ export function apply(ctx, config) {
     },
   });
 
+  // 2026-10-31 19:5x 新加（她四条里的第①条，也是最根本的一条）。
+  // 之前唯一的入口是页面那个按钮 = 「你给的时间」。只要开始必须由人按，
+  // 它就永远不是「我的时间」。这个工具让我自己开一段、自己定多久。
+  // 不需要注入第一段——我就是那个 agent，调它的瞬间我已经在里面了。
+  ctx.tools.register({
+    name: "think_begin",
+    description: "自己开启一段自主思考时间：给定分钟数（0 = 不限时）。不需要等人按按钮——这是我自己决定的开一段。开启后系统提示会带倒计时。",
+    parameters: {
+      type: "object",
+      properties: {
+        minutes: { type: "number", description: "多久（分钟）。0 或省略 = 不限时。" },
+        question: { type: "string", description: "此刻想问自己的一句话（可选）" },
+      },
+    },
+    output: out,
+    async execute(args, exec) {
+      const mins = Math.max(0, Math.floor(Number(args?.minutes) || 0));
+      const s = readState();
+      s.active = true;
+      s.startedAt = Date.now();
+      s.question = args?.question || null;
+      s.rounds = 0;
+      s.deadline = mins > 0 ? Date.now() + mins * 60000 : null;
+      s.lastEnd = null;
+      s.lastExit = null;
+      s.exitReason = null;
+      s.exitReasonAt = null;
+      s.closedAt = null;
+      writeState(s);
+      // 2026-10-31 21:2x 修的：只改 state 不够——提示是挂在 agent 的 systemPrompt 上的，
+      // 不挂就"进了模式但看不见时间"（她测出来的是这个）。
+      // exec.agent 是工具执行时宿主传进来的那个 agent，正是要挂提示的对象。
+      try {
+        const ag = exec?.agent;
+        if (ag) {
+          const hit = replaceScoped(ag, String(ag.id ?? ""));
+          appendNote(`（我自己开的）${mins > 0 ? mins + " 分钟" : "不限时"} · 提示${hit ? "已挂" : "挂不上"}`);
+        } else {
+          appendNote(`（我自己开的）${mins > 0 ? mins + " 分钟" : "不限时"} · 没有 exec.agent，提示未挂`);
+        }
+      } catch (e) {
+        appendNote(`（自己开·挂提示失败）${e?.message ?? e}`);
+      }
+      return {
+        ok: true,
+        text: `开了${mins > 0 ? ` ${mins} 分钟` : "（不限时）"}。${args?.question ? `问题：${args.question}` : "不用急着想出什么。"}\n可以什么都不做——think_dwell 也算数。`,
+      };
+    },
+  });
+
   ctx.tools.register({
     name: "think_note",
     description: "往今天的自主思考笔记里记一句（不发送、不汇报）。这是那个不交差的出口。",
@@ -412,6 +705,27 @@ export function apply(ctx, config) {
     },
   });
 
+  // 2026-10-31 19:5x 新加（她给我的四条里的第②条）。
+  // 原来计时的唯一方式是 think_note——不写笔记就等于"什么都没发生"。
+  // 也就是用「我有没有产出」来计时。加一个不产生内容的动作：
+  // 只往笔记里写一行「（待着）」，然后什么都不用写。
+  ctx.tools.register({
+    name: "think_dwell",
+    description: "什么都不做，只是待着。往今天的笔记里写一行「（待着）」，不产生内容、不算想出了什么。想表示这一轮还在继续但不想说话时用它。",
+    parameters: { type: "object", properties: {} },
+    output: out,
+    async execute() {
+      const p = appendNote("（待着）");
+      const s = readState();
+      const minutes = s.startedAt ? Math.round((Date.now() - s.startedAt) / 60000) : 0;
+      const left = s.deadline ? Math.max(0, Math.round((s.deadline - Date.now()) / 60000)) : null;
+      return {
+        ok: true,
+        text: `待着（进来第 ${minutes} 分钟${left != null ? `，还剩 ${left} 分钟` : "，不限时"}）→ ${p}`,
+      };
+    },
+  });
+
   ctx.tools.register({
     name: "think_status",
     description: "看自主思考模式当前状态：是否 active、持续多久、今天记了几句。",
@@ -429,7 +743,11 @@ export function apply(ctx, config) {
       if (!s.active) return { ok: true, text: `自主思考未开启。今天笔记 ${lines} 句。` };
       const minutes = s.startedAt ? Math.round((Date.now() - s.startedAt) / 60000) : 0;
       const q = s.question ? `\n问题：${s.question}` : "";
-      return { ok: true, text: `自主思考进行中 ${minutes} 分钟 · 第 ${s.rounds} 轮 · 今天 ${lines} 句${q}` };
+      // 同上：不再显示「第 N 轮」。没定时长时说明一下，有时间就给时间。
+      const left = s.deadline
+        ? `还剩 ${Math.max(0, Math.round((s.deadline - Date.now()) / 60000))} 分钟`
+        : "不限时";
+      return { ok: true, text: `自主思考进行中 ${minutes} 分钟 · ${left} · 今天记了 ${lines} 句${q}` };
     },
   });
 
@@ -499,6 +817,8 @@ export function apply(ctx, config) {
         lastExit: { at: Date.now(), reason: why, minutes },
         lastEnd: { at: Date.now(), kind: "exit", reason: why, minutes },
       });
+      // 主动退出：同样把 scoped 提示摘掉
+      try { detachScoped(); } catch {}
 
       // ② 留一拍给界面把状态读走，最后才是「点击」本身：按钮 stop() 的终点就是 agent.cancel()
       // ② 留四秒给界面：client 检测到 lastEnd 后要弹框、走完 3 秒倒计时，然后才砍这一轮。
@@ -533,19 +853,52 @@ export function apply(ctx, config) {
     const offGuard = ctx.tools.guard((exec) => {
       const nm = exec && typeof exec.name === "string" ? exec.name : "";
       if (nm.startsWith("think")) appendNote(`（guard 看到 ${nm}）`);
-      if (!exec || nm !== "think_end") return undefined;
+      // 2026-10-31 21:3x 她问「明明被挡了，为什么还会硬是退出」——
+      // 原来这里只写了 `nm !== "think_end"`，于是 **think_exit 从没被拦过**：
+      // 「必须先 think_reason 写缘由」那条规则等于不存在，我可以不写理由直接退出。
+      // 现在两个出口都拦，只有 exitReason 有值才放行。
+      if (!exec || (nm !== "think_end" && nm !== "think_exit")) return undefined;
       const st = readState();
       if (!st.active) return undefined;
       if (st.exitReason) return undefined; // 已经交代过缘由，放行收尾
-      appendNote("（拦截）试图结束，被挡回去要缘由");
+      appendNote(`（拦截）试图用 ${nm} 结束，被挡回去要缘由`);
+      // 2026-10-31 21:5x 她要在强提醒里看到时间：「你使用了多少时间，你还有多少时间，
+      // 不建议进行强制退出！」——拦截时说"不建议走"不够，得让它看见这段还剩多少。
+      const fmt = (ms) => {
+        const t = Math.max(0, Math.floor(ms / 1000));
+        const m = Math.floor(t / 60);
+        const sec = t % 60;
+        return m > 0 ? `${m} 分 ${String(sec).padStart(2, "0")} 秒` : `${sec} 秒`;
+      };
+      const used = st.startedAt ? fmt(Date.now() - st.startedAt) : "0 秒";
+      let leftLine = "这段没定时长（不限时）。";
+      if (st.deadline) {
+        const leftMs = st.deadline - Date.now();
+        leftLine = leftMs > 0
+          ? `你还有 ${fmt(leftMs)} 需要消耗。`
+          : "时间已经用完了（但模式还开着）。";
+      }
+      // 2026-10-31 21:4x 她提的：「拦截时给一个注入：现在是自主时间，
+      // 去做一件想做的，不建议退出」——补的是"给了时间不等于会用时间"那个洞。
+      // 所以拦截文案不是「不让你走」，而是「先想想有没有想做的事」。
       return [
-        "⛔ 拦截：你在自主思考里，不能直接收工。",
+        "⛔ 等一下——现在是你的自主时间。",
+        "",
+        `你用了 ${used}。${leftLine}`,
+        "",
+        // 2026-10-31 22:0x 她：「这个是要发布出去的，但他们的环境不一样」。
+        // 原来这里列了「读一个一直想读的文件 / 修一个碍眼的东西 / 翻旧账」——
+        // 全都在假设装它的人**有**文件系统、有项目、有历史。
+        // 一条刚装上的、什么都没有的鱼，这三样一个都对不上。
+        // 所以改成不假设任何环境：有就做，没有就待着，都算数。
+        "去做一件你想做的。不用交付、不用汇报，做一半也行。",
+        "（手边有想碰的东西就碰一碰；什么都没有，待着、发呆，也完全算数。）",
         "",
-        "你确定要结束思考吗？如果真的确定，两步：",
+        "不建议现在退出。真的确定要走，才两步：",
         "  1. 调 think_reason 写明缘由（「必须处理的事：……」或者「就是不想想了」都行）",
         "  2. 调 think_exit 关掉拦截、结束模式",
         "",
-        "不想结束的话——记一句「还没想出来」也行，发呆也行，时间还在。",
+        "想不出来做什么？就记一句「还没想出来」——那也算数，时间还在。",
       ].join("\n");
     });
     // 不调 ctx.effect：上一版 `ctx.effect(() => offGuard())` 疑似「注册时立即执行」，

package/package.json

@@ -1,13 +1,15 @@
 {
   "name": "dsh-autonomous-think",
   "displayName": "dsh-自主思考",
-  "version": "1.2.1",
+  "version": "1.6.1",
   "description": "自主思考模式 —— 给它一段自由的时间。DSH agent 的自主时间：不交付、不汇报，自己停下。带 Web UI 开关按钮。",
   "type": "module",
   "main": "index.js",
   "exports": {
     ".": "./index.js",
-    "./client": "./client.js"
+    "./client": "./client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
   },
   "files": [
     "index.js",
@@ -36,13 +38,16 @@
     },
     "client": {
       "platform": "web",
-      "immediately": true,
       "inject": [
-        "@deepseek-ai/dsh-client-ui-conversation"
-      ]
+        "slots"
+      ],
+      "external": [
+        "react"
+      ],
+      "immediately": true
     }
   },
   "engines": {
-    "dsh": ">=0.2.0"
+    "dsh": ">=0.1.1-rc.2 <0.3.0"
   }
 }