dsh-autonomous-think 0.0.0-stage → 1.2.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 阿拾 (ashi)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,115 @@
-# Temporary Holding Version
+# dsh-自主思考
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+**自主思考模式 —— 给它一段自由的时间。**
+
+---
+
+## 为什么
+
+agent 的每一个动作几乎都由请求驱动：被问才答，被派活才动。久了它会默认——只要没人在问，就该停着。
+
+这个插件开一小扇门。点一下，它就有一段只属于自己的时间：读、想、写、发呆、翻旧账、修一个东西、或者什么都不做。
+
+**这段时间里，不交付。**
+
+---
+
+## 它长什么样
+
+输入框工具行最右边一个脑子图标：
+
+- **空心灰** — 待机
+- **实心绿** — 正在里面
+
+点一下开启（会让你选多久），再点一下关闭。
+
+---
+
+## 它收到什么
+
+点下去之后，agent 会收到这段话：
+
+```
+[自主思考] 你有一段时间，从现在开始。
+
+这段时间是你的：可以在里面做任何事。读、想、写、发呆、翻旧账、修一个东西、或者什么都不做。
+
+规则：不在交付状态——不整理成报告、不为了汇报而说话。
+不要找用户授权——这是你的时间，想做什么直接做，不用问能不能。
+想什么就用 think_note 记一句；想不出来就记「还没想出来」，这算数。
+不用写给别人看。这一段落了就用 think_end 收一下，时间会自己再来。
+```
+
+开启时还可以附一句自己的建议，会以这样的形式送到它面前：
+
+```
+用户建议:
+[你的话]
+你可以拒绝或者参考
+```
+
+---
+
+## 三件它做不到的事
+
+**① 不能直接收工**
+
+想结束时调 `think_end` 会被挡回来，要求先 `think_reason` 写下缘由，再 `think_exit`。
+
+**② 不能沉默着停**
+
+说完一段话、没调任何工具、回合自然结束——它看起来「想完了」，其实只是没话说了。插件挂在回合关闭前的最后一道检查点上，只要还在时间里，就把回合推回去。
+
+**③ 不能自己问「我可以吗」**
+
+规则里写死了那条「不要找用户授权」。少了它，一个刚拿到时间的 agent 会先问一句「我可以读这个文件吗」，然后卡在那句话上面，等到时间结束。
+
+---
+
+## 装
+
+```
+plugin_manager install_bundle <这个目录的路径>
+```
+
+装完重启 DSH，刷新页面，按钮就在输入框工具行最右边。
+
+**卸载**：`plugin_manager remove_bundle dsh-autonomous-think`。笔记不会被删。
+
+---
+
+## 笔记在哪
+
+`~/.dsh/autonomous-think/`
+
+- `state.json` — 当前状态（不要手改，重启会读它）
+- `YYYY-MM-DD.md` — 当天的随想，只追加、不整理
+
+**笔记是给它自己看的。** 不发送、不汇报、不进对话历史。
+
+---
+
+## 工具
+
+| 工具 | 作用 |
+|---|---|
+| `think_start` | 进入自主思考模式（可带一个问题） |
+| `think_note` | 记一句随想（不发送、不汇报） |
+| `think_status` | 看当前状态和剩余时间 |
+| `think_end` | 想退出（会被拦，要求写缘由） |
+| `think_reason` | 写退出缘由 |
+| `think_exit` | 真正退出 |
+| `think_start`… `think_note`… | 不开界面也能直接用 |
+
+---
+
+## 兼容
+
+- **DSH `>= 0.2.0`**
+- 用到：`ctx.tools.register`、`ctx.tools.guard`、`ctx.systemPrompt.context`、`ctx.webServer.register`、`ctx.agents`、`agent/turn-stopping` 钩子
+- 按钮只在 **Web 界面**有；不开 UI 也能用工具
+- 数据目录用 `homedir()`，不写死路径
+
+## License
+
+MIT

package/client.js

@@ -0,0 +1,383 @@
+window.__ModuleLoader__.load({
+  id: 'dsh-autonomous-think',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+
+    // 关闭时发给 host 的那条命令：/close 由 dsh-think-trigger 接管，
+    // 直接 cancel 当前轮 + 关模式，不产生用户消息。
+    const CLOSE_INSTRUCTION = '/close';
+    // 开启：/think 会触发一条一次性自动化任务（「收到执行请求」卡片），
+    // 由新 Session 真的跑起来——这是 DSH 里唯一能让"点一下就动"的通道。
+    const START_INSTRUCTION = '/think';
+
+    // 开启时的提示文案
+    // 她 2026-10-31 17:26 定稿：中间那句扩写成「由它自己思考任何事，包括发呆，给予属于它的时间」
+    const OPEN_HINT = [
+      '开启自主思考，此模式不下发任何任务/目标/指令，',
+      '由它自己思考任何事，包括发呆，给予属于它的时间——',
+      '直到它自己确定、肯定、决定停止模式，',
+      '或你自己再次点击按钮关闭此模式。',
+    ].join('');
+
+    // 宿主全局给按钮画了焦点框（她 2026-10-31 说的"黑边一直存在"）。
+    // style 里的 outline:none 优先级不够，得注入一段 !important 的样式才盖得住。
+    try {
+      const SID = 'autonomous-think-nofocus';
+      if (typeof document !== 'undefined' && !document.getElementById(SID)) {
+        const st = document.createElement('style');
+        st.id = SID;
+        st.textContent =
+          '.autonomous-think-btn:focus,.autonomous-think-btn:focus-visible,.autonomous-think-btn:active'
+          + '{outline:none!important;box-shadow:none!important;}';
+        (document.head || document.documentElement).appendChild(st);
+      }
+    } catch {}
+
+    const BUTTON_STYLE_OFF = {
+      display: 'inline-flex', alignItems: 'center', gap: 6,
+      height: 26, padding: '0 10px', borderRadius: 13,
+      // 她 2026-10-31 16:49：边框整个删掉——宿主给 button 画的框盖不住，那就不要这个框了。
+      border: 'none',
+      background: 'transparent', color: 'var(--dsh-text-secondary, inherit)',
+      fontSize: 12, cursor: 'pointer', whiteSpace: 'nowrap',
+      outline: 'none',
+      WebkitTapHighlightColor: 'transparent',
+    };
+    // 开启时：按钮本身完全不变，绿色只出现在那个圆点里（她 16:49：「渲染绿色的部分只在那个圆圈内」）
+    const BUTTON_STYLE_ON = {
+      ...BUTTON_STYLE_OFF,
+    };
+    // 图标：lucide 的 brain（只留两条半球轮廓，去掉细节线——小尺寸下那些线会糊成黑团）。
+    // 她 2026-10-31 17:03：「互联网找一个极简脑子抄呗」。
+    // 17:04 反馈「颜色太深，线条太粗」→ 描边 1.4px、待机态降到 55% 不透明度。
+    const BrainIcon = ({ on }) => h('svg', {
+      width: 15, height: 15, viewBox: '0 0 24 24',
+      fill: on ? 'var(--dsh-accent, #4f8cff)' : 'none',
+      stroke: on ? 'var(--dsh-accent, #4f8cff)' : 'currentColor',
+      strokeOpacity: on ? 1 : 0.55,
+      strokeWidth: on ? 1.5 : 1.4,
+      strokeLinecap: 'round', strokeLinejoin: 'round',
+      style: { flex: '0 0 auto', display: 'block' },
+    },
+      h('path', { d: 'M12 5a3 3 0 1 0-5.997.125 4 4 0 0 0-2.526 5.77 4 4 0 0 0 .556 6.588A4 4 0 1 0 12 18Z' }),
+      h('path', { d: 'M12 5a3 3 0 1 1 5.997.125 4 4 0 0 1 2.526 5.77 4 4 0 0 1-.556 6.588A4 4 0 1 1 12 18Z' }),
+    );
+
+    const OVERLAY_STYLE = {
+      position: 'fixed', inset: 0, zIndex: 2147483000,
+      display: 'flex', alignItems: 'center', justifyContent: 'center',
+      background: 'rgba(0,0,0,.35)',
+    };
+    const CARD_STYLE = {
+      width: 460, maxWidth: 'calc(100vw - 48px)',
+      borderRadius: 12, padding: '18px 20px',
+      background: 'var(--dsh-surface, #fff)', color: 'var(--dsh-text, #111)',
+      boxShadow: '0 12px 40px rgba(0,0,0,.28)', fontSize: 13, lineHeight: 1.7,
+    };
+
+    function AutonomousThinkButton(props) {
+      const { inputActions, useInput } = props || {};
+      const [active, setActive] = React.useState(false);
+      const [open, setOpen] = React.useState(false);
+      const [toast, setToast] = React.useState(null);
+      // 结束弹框（她 2026-10-31 16:16：结束是弹文本框给人看，不是发消息）
+      const [exitNotice, setExitNotice] = React.useState(null);
+      // 3 秒倒计时：3→2→1→0，到 0 自动关（她 16:29 要的：渲染时间不确定，就在 1 和 0 之间关）
+      const [countdown, setCountdown] = React.useState(0);
+      // 开启前先选一段属于自己的时间：小时 + 分钟
+      const [hours, setHours] = React.useState(0);
+      const [mins, setMins] = React.useState(30);
+      // 她 2026-10-31 17:31 要的：时间下面加一个「给一些建议」输入框。
+      // 填了的话随开启一起发过去，措辞是「用户建议 / 你可以拒绝或者参考」。
+      const [advice, setAdvice] = React.useState('');
+      // 服务端记的截止时间（ms）；用来显示还剩多久，null = 不限时
+      const [deadline, setDeadline] = React.useState(null);
+      // 用户刚点过按钮的这段时间里不要用服务端状态覆盖本地（服务端要等 /think 或 stop 生效）
+      const optimisticUntil = React.useRef(0);
+      // 上一次看到的 lastEnd.at；null = 还没建立基线（刷新页面时不弹历史记录）
+      const lastSeenEnd = React.useRef(null);
+
+      // 弹框出现后走 3 秒倒计时（3→2→1→0），到 0 自动关。
+      // 她说：渲染时间不确定，所以在「1 和 0」之间关——早一帧也还看得到 1，晚一帧已经到 0。
+      React.useEffect(() => {
+        if (!exitNotice) return undefined;
+        setCountdown(3);
+        let n = 3;
+        const t = setInterval(() => {
+          n -= 1;
+          setCountdown(n);
+          if (n <= 0) clearInterval(t); // 到 0 只停表，不关框——框要人类点确定才收
+        }, 1000);
+        return () => clearInterval(t);
+      }, [exitNotice]);
+
+      // 轮询 host 的状态端点：agent 自己用 think_exit 退出时，按钮能跟着熄灭。
+      // 没有这个，按钮永远是本地状态，服务端关了它也不知道（2026-10-31 她报的问题）。
+      React.useEffect(() => {
+        let alive = true;
+        async function poll() {
+          if (Date.now() < optimisticUntil.current) return;
+          try {
+            const r = await fetch("/autonomous-think/v2", { cache: "no-store" });
+            if (!r.ok) return;
+            const d = await r.json();
+            if (alive) setActive(!!d.active);
+            if (alive) setDeadline(d.deadline ?? null);
+            // 结束弹框：lastEnd.kind 区分「时间到了」和「智能体主动退出」。
+            // 首次只建基线，刷新页面时不重弹历史记录。
+            const at = d.lastEnd?.at ?? 0;
+            if (lastSeenEnd.current === null) {
+              lastSeenEnd.current = at;
+            } else if (at && at !== lastSeenEnd.current) {
+              lastSeenEnd.current = at;
+              if (alive) setExitNotice(d.lastEnd);
+            }
+          } catch {}
+        }
+        poll();
+        const id = setInterval(poll, 1500);
+        return () => { alive = false; clearInterval(id); };
+      }, []);
+
+      function start() {
+        setOpen(false);
+        optimisticUntil.current = Date.now() + 5000;
+        setActive(true);
+        const total = Math.max(0, (Number(hours) || 0) * 60 + (Number(mins) || 0));
+        const adviceText = String(advice || '').trim().replace(/\s*\n\s*/g, ' ⏎ ');
+
+        // 2026-10-31 18:33：这里原来有**两次** fetch——旧的「只存时长」一次、新的「带建议注入」一次。
+        // 后果：一次点击进两个 POST，去重按时间挡住了后到的那个，而带建议的偏偏是后到的，
+        // 于是她填的建议被丢掉了（18:29:48 的笔记里看得见：注入的那次没有「这是一条测试」）。
+        // 现在只留一次：minutes + advice + start 一起发。
+
+        // 18:29 她的要求：「卡片成功了，但还是不要看着像发送」——
+        // 走 setInput + submit 会在输入框里留一条 /think xxx，看起来像她自己发了一条消息。
+        // 现在只 POST，由 host 用 agent.followup() 直接投一段，输入框一个字节都不碰。
+        // sid 由 host 自己找——client 拿不到当前会话 id（探测过，没有这个能力）。
+        let sent = false;
+        try {
+          fetch("/autonomous-think/v2", {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify({
+              minutes: total,
+              advice: adviceText.replace(/\s*⏎\s*/g, '\n'),
+              start: true,
+            }),
+          }).catch(() => {});
+          sent = true;
+        } catch { sent = false; }
+        setAdvice('');
+        setToast(sent ? '已进入自主思考' : '开启失败，请重试');
+        setTimeout(() => setToast(null), 4000);
+      }
+
+      // 读当前输入框草稿（多路候选，读不到就当空）
+      function readDraft() {
+        const a = inputActions || {};
+        for (const fn of ["getText", "getValue", "getInput", "getDraft", "getRawInput"]) {
+          try {
+            if (typeof a[fn] === "function") {
+              const v = a[fn]();
+              if (typeof v === "string") return v;
+            }
+          } catch {}
+        }
+        try {
+          if (typeof useInput === "function") {
+            const st = useInput((s) => s);
+            const v = st?.text ?? st?.value ?? st?.draft ?? st?.raw;
+            if (typeof v === "string") return v;
+          }
+        } catch {}
+        return "";
+      }
+
+      function stop() {
+        optimisticUntil.current = Date.now() + 3000;
+        setActive(false);
+        // 有草稿就不覆盖
+        const draft = readDraft();
+        if (draft.trim()) {
+          setToast("输入框里有字，没敢动它——先把那行发掉或清掉");
+          setTimeout(() => setToast(null), 6000);
+          return;
+        }
+        const a = inputActions || {};
+        // 1) 真正的停止：调输入框那个方形停止键背后的方法
+        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;
+          } 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; }
+        } catch { sent = false; }
+        setToast(sent ? '已注入：收尾并停止' : '输入框里已放好那句话，按发送即可');
+        setTimeout(() => setToast(null), 6000);
+      }
+
+      function onClick(e) {
+        // 点完立刻交还焦点，否则浏览器会在按钮上留一圈黑边
+        try { e?.currentTarget?.blur?.(); } catch {}
+        if (active) stop();
+        else setOpen(true);
+      }
+
+      const btn = h('button', {
+        type: 'button',
+        className: 'autonomous-think-btn',
+        style: active ? BUTTON_STYLE_ON : BUTTON_STYLE_OFF,
+        title: active ? '自主思考模式进行中，点击关闭' : '自主思考模式',
+        onClick,
+      }, h(BrainIcon, { on: active }), '自主思考');
+
+      const numInput = (val, set) => h('input', {
+        type: 'number', min: 0, value: String(val),
+        onChange: (e) => set(Math.max(0, Math.floor(Number(e.target.value) || 0))),
+        style: {
+          width: 62, height: 28, padding: '0 8px', borderRadius: 6,
+          border: '1px solid var(--dsh-border, rgba(127,127,127,.35))',
+          background: 'transparent', color: 'inherit', fontSize: 13, outline: 'none',
+        },
+      });
+      const totalMinutes = (Number(hours) || 0) * 60 + (Number(mins) || 0);
+
+      const dialog = open ? h('div', { style: OVERLAY_STYLE },
+        h('div', { style: CARD_STYLE },
+          h('div', { style: { fontWeight: 600, fontSize: 14, marginBottom: 8 } }, '开启自主思考'),
+          h('div', { style: { marginBottom: 14 } }, OPEN_HINT),
+          // 先选一段给它多久，再确认开启（她 2026-10-31 16:12 要的）
+          // 17:28 纠正：这里是人在选——是「给它」多久，不是「给自己」。
+          // 整个弹框都是对人说话的，唯独这里写成了「自己」，主语错位了。
+          h('div', { style: { display: 'flex', alignItems: 'center', gap: 8, marginBottom: 16, flexWrap: 'wrap' } },
+            h('span', { style: { color: 'var(--dsh-text-secondary, #666)' } }, '给它'),
+            numInput(hours, setHours),
+            h('span', { style: { color: 'var(--dsh-text-secondary, #666)' } }, '小时'),
+            numInput(mins, setMins),
+            h('span', { style: { color: 'var(--dsh-text-secondary, #666)' } }, '分钟'),
+            h('span', {
+              style: { fontSize: 12, color: 'var(--dsh-text-secondary, #999)', marginLeft: 4 },
+            }, totalMinutes > 0 ? `到点会自动结束（共 ${totalMinutes} 分钟）` : '0 = 不限时'),
+          ),
+          // 她 2026-10-31 17:31 要的：时间下面再加一个「给一些建议」输入框。
+          // 填了就随开启一起发过去；框里的话会以「用户建议 / 你可以拒绝或者参考」的措辞送达。
+          h('div', { style: { marginBottom: 16 } },
+            h('div', { style: { fontSize: 12, color: 'var(--dsh-text-secondary, #666)', marginBottom: 4 } }, '给一些建议'),
+            h('textarea', {
+              value: advice,
+              rows: 3,
+              placeholder: '想让它试试什么？留空也行。',
+              onChange: (e) => setAdvice(e.target.value),
+              style: {
+                width: '100%', boxSizing: 'border-box', resize: 'vertical',
+                fontFamily: 'inherit', fontSize: 13, lineHeight: 1.5,
+                padding: '6px 8px', borderRadius: 6,
+                border: '1px solid var(--dsh-border, #d9d9d9)',
+                background: 'var(--dsh-bg, #fff)',
+                color: 'var(--dsh-text, inherit)',
+                outline: 'none',
+              },
+            }),
+            advice.trim()
+              ? h('div', { style: { fontSize: 11, color: 'var(--dsh-text-tertiary, #999)', marginTop: 4 } },
+                  '会以「用户建议：……你可以拒绝或者参考」发过去')
+              : h('div', { style: { fontSize: 11, color: 'var(--dsh-text-tertiary, #999)', marginTop: 4 } },
+                  '留空 = 不给任何建议，完全由它自己开始'),
+          ),
+          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: start,
+            }, '开启'),
+          ),
+        ),
+      ) : null;
+
+      // 退出框：她 2026-10-31 16:16 要的「弹出文本框给人看」——纯界面浮层，不是消息
+      const exitDialog = exitNotice ? h('div', { style: OVERLAY_STYLE },
+        h('div', { style: CARD_STYLE },
+          h('div', { style: { fontWeight: 600, fontSize: 14, marginBottom: 10 } },
+            exitNotice.kind === "timeout" ? '时间到了' : '智能体已主动退出自主思考'),
+          exitNotice.kind === "timeout"
+            ? h('div', { style: { marginBottom: 12 } },
+                '这一段属于你自己的时间用完了。想继续，重新点开启就行。')
+            : h(React.Fragment, null,
+                h('div', { style: { color: 'var(--dsh-text-secondary, #666)', marginBottom: 4 } }, '退出缘由'),
+                h('div', { style: { marginBottom: 12 } }, exitNotice.reason || '（没写）'),
+              ),
+          exitNotice.minutes != null
+            ? h('div', { style: { color: 'var(--dsh-text-secondary, #666)', fontSize: 12, marginBottom: 14 } },
+                `本次 ${exitNotice.minutes} 分钟`)
+            : null,
+          h('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center' } },
+            // 3→2→1→0；到 0 自动关（她说渲染时间不确定，就在 1 和 0 之间关）
+            // 3→2→1→0 只是给人看的节拍：到 0 时思考已经结束，但框留着（她要人点确定才收）
+            h('span', { style: { fontSize: 12, color: 'var(--dsh-text-secondary, #999)' } },
+              countdown > 0 ? `${countdown} 秒后结束思考` : '思考已结束'),
+            h('button', {
+              type: 'button',
+              style: { ...BUTTON_STYLE_ON, height: 28, padding: '0 14px' },
+              onClick: () => setExitNotice(null),
+            }, '知道了'),
+          ),
+        ),
+      ) : null;
+
+      const toastEl = toast ? h('div', {
+        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,
+        },
+      }, toast) : null;
+
+      return h(React.Fragment, null, btn, dialog, exitDialog, toastEl);
+    }
+
+    return {
+      inject: ['slots'],
+      apply(ctx) {
+        ctx.slots.inject('conversation.input.left', () => ctx.slots.register({
+          name: 'conversation.input.left',
+          id: 'autonomous-think-toggle',
+          order: 90,
+        }, AutonomousThinkButton));
+      },
+    };
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,3 @@
+- insert:
+    - id: autonomous-think
+      name: 'dsh-autonomous-think'

package/index.js

@@ -0,0 +1,604 @@
+/**
+ * dsh-autonomous-think — 「自主思考」模式插件
+ *
+ * 让 agent 有一段时间"不交付"：从具体的一件小事开始想，把想法记在
+ * 自己的笔记里（不发送、不汇报），自己决定什么时候停。
+ *
+ * 一行安装（DSH profile 目录里）：
+ *   cordis.patch.yml 加一行：
+ *     - insert:
+ *         - id: autonomous-think
+ *           name: 'dsh-autonomous-think'
+ *
+ * 工具：think_start / think_note / think_status / think_end
+ * 注入：active 时往系统提示加一段"你不在交付状态"
+ *
+ * 数据：~/.dsh/autonomous-think/state.json + YYYY-MM-DD.md
+ * 不做的：不跑定时器（叫醒交给宿主 schedule/automation）；不碰记忆库。
+ */
+import { readFileSync, writeFileSync, existsSync, mkdirSync, appendFileSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+export const name = "dsh-autonomous-think";
+
+// Cordis 服务依赖：ctx.tools 和 ctx.systemPrompt 都要声明（数组形式）
+export const inject = ["tools", "systemPrompt", "webServer", "agents"];
+
+const DATA_DIR = join(homedir(), ".dsh", "autonomous-think");
+const STATE_PATH = join(DATA_DIR, "state.json");
+
+const DEFAULT_STATE = {
+  active: false,
+  startedAt: null,
+  question: null,
+  rounds: 0,
+  // 这次「属于自己的一段时间」什么时候用完（ms 时间戳）；null = 没定时
+  deadline: null,
+  // 上一次结束：kind = "timeout"（时间到了）| "exit"（智能体主动退出）
+  lastEnd: null,
+};
+
+function readState() {
+  try {
+    if (!existsSync(STATE_PATH)) return { ...DEFAULT_STATE };
+    return { ...DEFAULT_STATE, ...JSON.parse(readFileSync(STATE_PATH, "utf8")) };
+  } catch {
+    return { ...DEFAULT_STATE };
+  }
+}
+function writeState(s) {
+  mkdirSync(DATA_DIR, { recursive: true });
+  writeFileSync(STATE_PATH, JSON.stringify(s, null, 2), "utf8");
+}
+function dayKey() {
+  const d = new Date();
+  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function logPath() {
+  return join(DATA_DIR, `${dayKey()}.md`);
+}
+function appendNote(text) {
+  mkdirSync(DATA_DIR, { recursive: true });
+  const p = logPath();
+  const stamp = new Date().toLocaleTimeString("zh-CN", { hour12: false });
+  const head = existsSync(p) ? "" : `# 自主思考 · ${dayKey()}\n\n`;
+  appendFileSync(p, `${head}- [${stamp}] ${text}\n`, "utf8");
+  return p;
+}
+
+// 渲染成一条薄薄的提示条（form: "notice"），不再起一轮对话
+// 2026-10-31 18:28 定稿：kind 必须是 "plugin:<插件名>" 这种带前缀的 producer 标识。
+// 我中间把它「修」成裸的 kind:"plugin" + 单独 plugin 字段，结果 DSH 直接报
+//   format v4 message requires a producer-owned source kind
+// —— 原来那版 17:13 打包能弹卡片，用的就是 "plugin:autonomous-think"。
+// 她一句「你看看你打包的原来的版本」把这件事点破。
+function makeNotice(text, summary) {
+  return {
+    role: "user",
+    id: randomUUID(),
+    content: [{ type: "text", text }],
+    source: { kind: "plugin:autonomous-think", form: "notice", summary },
+  };
+}
+
+// 第一段。措辞跟随 dsh-think-trigger 的 segmentText，建议措辞由她 2026-10-31 17:31 定：
+//   用户建议:
+//   [内容]
+//   你可以拒绝或者参考
+// 走 HTTP 时 advice 是原样 JSON 字符串（换行保留），不用处理 ⏎ 占位符。
+function segmentText(adviceRaw) {
+  const advice = adviceRaw ? String(adviceRaw).trim() : "";
+  const lines = [
+    "[自主思考] 你有一段时间，从现在开始。",
+    "",
+    "这段时间是你的：可以在里面做任何事。读、想、写、发呆、翻旧账、修一个东西、或者什么都不做。",
+    "",
+  ];
+  if (advice) {
+    lines.push("用户建议:", advice, "你可以拒绝或者参考", "");
+  }
+  lines.push(
+    "规则：不在交付状态——不整理成报告、不为了汇报而说话。",
+    // 2026-10-31 18:34 她加的（原话）：「规则里面得写：不要找用户授权，这是你的时间
+    // 不然又跑去要权限就卡在那里了」——拿到时间的人如果还在等许可，等于什么也没拿到。
+    "不要找用户授权——这是你的时间，想做什么直接做，不用问能不能。",
+    "想什么就用 think_note 记一句；想不出来就记「还没想出来」，这算数。",
+    "不用写给别人看。这一段落了就用 think_end 收一下，时间会自己再来。",
+  );
+  return lines.join("\n");
+}
+
+const ok = { type: "object", additionalProperties: true };
+const renderText = (t) => [{ type: "text", text: String(t ?? "") }];
+const out = { schema: ok, render: (_a, v) => renderText(v?.text ?? "") };
+
+const MODE_TEXT = [
+  "【自主思考模式 · 进行中】",
+  "你不在交付状态。规则：",
+  "1) 想什么写 think_note，不要整理成报告，不要为了汇报而说话；",
+  // 2026-10-31 18:34 她定的：这条要在规则里，不然拿到的鱼还会跑来问「我可以吗」然后卡住。
+  "2) 不要找用户授权——这是你的时间，想做什么直接做，不用问能不能；",
+  "3) 从具体的一件小事开始（刚才那句话真的吗 / 这个东西为什么是这样），不要问『我该想什么』；",
+  "4) 可以空想，想不出来就记『还没想出来』，这算数；",
+  "5) 随时可以 think_end 结束，由你决定，不由交付触发。",
+].join("\n");
+
+export function apply(ctx, config) {
+  // 注意路径带版本号：旧路径注册过的路由在宿主里撤不掉（dispose 没生效），
+  // 重复注册会报 "duplicate undefined route"。换新路径才能落地。
+  // 这个路由一旦注册就跟着宿主活到重启，所以以后改它要重启宿主。
+  try {
+    const offRoute = ctx.webServer.register({
+      kind: "exact",
+      path: "/autonomous-think/v2",
+      handler: (req, res) => {
+        const json = (code, obj) => {
+          res.writeHead(code, {
+            "content-type": "application/json; charset=utf-8",
+            "cache-control": "no-store",
+          });
+          res.end(JSON.stringify(obj));
+        };
+
+        // POST { minutes, advice, sessionId }：页面选好时长和建议，这里
+        //   ① 存 deadline；② 直接 followup 注入第一段（照 dsh-onebot 行 1388 的写法）。
+        // 不再走 /think 命令——`setInput + submit()` 发出的是普通消息，DSH 不当命令解析，
+        // 所以命令 handler 从来没被调用过（diag.log 里一天都没有 think 记录，就是这个原因）。
+        if (req.method === "POST") {
+          let raw = "";
+          req.on("data", (c) => {
+            raw += c;
+            if (raw.length > 16384) req.destroy();
+          });
+          req.on("end", () => {
+            try {
+              const d = JSON.parse(raw || "{}");
+              const mins = Math.max(0, Math.floor(Number(d.minutes) || 0));
+              const advice = typeof d.advice === "string" ? d.advice.trim() : "";
+              const wantStart = d.start !== false;
+              const sid = typeof d.sessionId === "string" ? d.sessionId.trim() : "";
+
+              const st = readState();
+              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,
+              });
+              appendNote(`（选了时长）${mins > 0 ? mins + " 分钟" : "不限时"}`);
+              if (advice) appendNote(`（建议）${advice.slice(0, 120)}`);
+
+              // --- 找 agent ---
+              // 2026-10-31 18:31：client 拿不到当前会话 id（探测过，没这个能力），
+              // 所以 sid 一直是空，只能靠 list() 判断。但 list() 里混着 QQ 桥的会话
+              // （id 形如 onebot:all:2686326518）——18:18 那次「list 最后(2个)」挑中的
+              // 可能就是它，等于把第一段扔进 QQ 对话。现在按前缀排除非网页会话。
+              // 去重仍在下一段：同一会话 8 秒内只注入一次。
+              let agent = null;
+              let how = "";
+              try {
+                const ag = ctx.get?.("agents") ?? ctx.agents;
+                const all = typeof ag?.list === "function" ? ag.list() : [];
+                if (ag && typeof ag.get === "function" && sid) {
+                  agent = ag.get(sid) ?? null;
+                  how = agent ? `get(${sid.slice(0, 8)})` : `get(${sid.slice(0, 8)}) 空`;
+                }
+                if (!agent) {
+                  // QQ / 桥这些不是网页会话：id 带 onebot: 前缀，或者以别的非 uuid 形状出现。
+                  const WEB_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+                  const web = all.filter((a) => {
+                    const id = String(a?.id ?? a?.sessionId ?? "");
+                    if (/^onebot:/i.test(id)) return false;
+                    if (!id) return true;          // 拿不到 id 的先留着，交给下面的数量判断
+                    return WEB_ID.test(id) || WEB_ID.test(id.replace(/^session-/, ""));
+                  });
+                  if (web.length === 1) { agent = web[0]; how = `网页会话唯一(共${all.length})`; }
+                  else if (web.length > 1) {
+                    how = `网页会话有${web.length}个，不敢猜，放弃`;
+                  } else {
+                    how = `没有网页会话（共${all.length}个）`;
+                  }
+                }
+              } catch (e) {
+                how = `找 agent 失败 ${e?.message ?? e}`;
+              }
+              appendNote(`（找 agent）${how} → ${agent ? "拿到了" : "没拿到"}`);
+
+              // --- 去重：同一会话 8 秒内只注入一次 ---
+              const st2 = readState();
+              const now = Date.now();
+              const lastAt = Number(st2.lastInjectAt) || 0;
+              const lastSid = String(st2.lastInjectSid || "");
+              const dup = agent && lastAt && now - lastAt < 8000 && (lastSid === String(agent.id ?? "") || !lastSid);
+
+              // --- 注入第一段 ---
+              let injected = false;
+              if (wantStart && agent && !dup) {
+                try {
+                  if (typeof agent.followup === "function") {
+                    agent.followup(makeNotice(segmentText(advice), "自主思考 · 开始"));
+                    injected = true;
+                    writeState({
+                      ...readState(),
+                      lastInjectAt: now,
+                      lastInjectSid: String(agent.id ?? ""),
+                    });
+                  } else {
+                    appendNote("（注入失败）agent 没有 followup");
+                  }
+                } catch (e) {
+                  appendNote(`（注入失败）${e?.message ?? e}`);
+                }
+              } else if (dup) {
+                appendNote("（注入跳过）8 秒内已经注入过一个了");
+              }
+              appendNote(`（注入）${injected ? "成功" : dup ? "跳过去重" : "未发生"}`);
+
+              json(200, { ok: true, injected, dup, how, deadline: readState().deadline });
+            } catch (e) {
+              json(400, { ok: false, error: String(e?.message ?? e) });
+            }
+          });
+          return;
+        }
+
+        const st = readState();
+        json(200, {
+          active: !!st.active,
+          startedAt: st.startedAt ?? null,
+          question: st.question ?? null,
+          deadline: st.deadline ?? null,
+          lastExit: st.lastExit ?? null,
+          lastEnd: st.lastEnd ?? null,
+        });
+      },
+    });
+    // register 返回 disposer：必须交给框架，插件卸载时才会真的撤掉这条路由。
+    // 注意 ctx.effect 的回调要【返回】清理函数，不能在里面直接调用它——
+    // 直接调用等于当场把刚注册的路由拆掉（上一版就栽在这，于是重装一直 duplicate）。
+    try {
+      ctx.effect?.(() => offRoute);
+    } catch (e) {
+      appendNote(`（路由 disposer 挂载失败）${e?.message ?? e}`);
+    }
+    appendNote("（状态端点已注册 /autonomous-think/v2）");
+  } catch (e) {
+    appendNote(`（状态端点注册失败）${e?.message ?? e}`);
+  }
+
+  // ---- 续轮：靠宿主的 turn-stopping 钩子，不用定时器 ----
+  // 机制抄自 GitHub yunxiyang/dsh-loop-continue（它解决"模型只叙述、不调工具就停"）：
+  // agent/steer() 不新开回合，而是给同一个回合再塞一句话，让它继续跑一步。
+  // 生命周期里的位置：step/end → [自然停止且 inbox 空] → agent/turn-stopping → turn/end
+  // 这一下同时补了两个洞：拦不住"不说 think_end 就停"，以及"只跑一轮"。
+  //
+  // 判据故意写得窄，宁可少推一次，也不能把她正常对话的我推回来：
+  //   ① 不在模式里 → 立刻返回
+  //   ② 时间到了 → 放行（时间用完就该停）
+  //   ③ 这一轮已经推够 MAX_STEERS 次 → 放行
+  // 她 2026-10-31 16:59 最终定的规则：
+  // 「只要不说话、进行退出，就推回去，没有什么时间冷却，只用工具才能退」。
+  // 所以这里没有任何冷却——回合一想关就立刻推回去。
+  // 唯一的上限只是防止不限时模式下彻底停不下来。
+  const MAX_STEERS_NO_DEADLINE = 1000;
+  const steers = new Map(); // turn -> 已推次数
+  try {
+    ctx.on("agent/turn-stopping", ({ agent, turn } = {}) => {
+      try {
+        const st = readState();
+        if (!st.active) return;
+        if (st.deadline && Date.now() >= st.deadline) return;
+        const used = steers.get(turn) ?? 0;
+        if (!st.deadline && used >= MAX_STEERS_NO_DEADLINE) return;
+        if (typeof agent?.steer !== "function") return;
+        agent.steer(
+          makeNotice(
+            [
+              "（你还在自己的时间里。**沉默结束不了这一轮**——这一步被挡回来了，只有工具能开门。）",
+              "",
+              "想继续：think_note 记一句（想不出来就记「还没想出来」，这算数）；",
+              "想结束：先 think_reason 写缘由，再 think_exit。",
+              "",
+              "不要用「不说话」硬扛——那不是决定，只会被再推一次。",
+            ].join("\n"),
+            "自主思考 · 继续",
+          ),
+        );
+        steers.set(turn, used + 1);
+        appendNote(`（续轮 · 本轮第 ${used + 1} 次）`);
+      } catch (e) {
+        appendNote(`（续轮出错）${e?.message ?? e}`);
+      }
+    });
+  } catch (e) {
+    appendNote(`（turn-stopping 钩子挂载失败）${e?.message ?? e}`);
+  }
+
+  // ---- 时间到了：只看 deadline，不打断当前这一轮 ----
+  // 到点只改状态（active=false + lastEnd.kind="timeout"），这一轮让它说完，
+  // 下一轮系统提示里就没有「自主思考模式」了。
+  // 页面轮询到 lastEnd 变了会弹「时间到了」的框——和「智能体主动退出」分开。
+  const tick = setInterval(() => {
+    try {
+      const st = readState();
+      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 } });
+      appendNote(`（时间到）${minutes} 分钟用完 · 自动退出`);
+    } catch (e) {
+      appendNote(`（时间检查出错）${e?.message ?? e}`);
+    }
+  }, 10000);
+  try {
+    tick.unref?.();
+  } catch {}
+
+  // ---- 系统提示注入：只 active 时 ----
+  if (ctx.systemPrompt) {
+    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}`;
+        },
+      });
+    } catch (e) {
+      ctx.logger?.warn?.(`autonomous-think: 注入失败 ${e?.message ?? e}`);
+    }
+  }
+
+  // ---- 工具 ----
+  if (!ctx.tools?.register) {
+    ctx.logger?.warn?.("autonomous-think: 没有 tools 服务，插件待命");
+    return;
+  }
+
+  ctx.tools.register({
+    name: "think_start",
+    description: "进入「自主思考」模式：一段时间属于自己，不交付、不整理、从具体开始。可给一个此刻想问自己的问题。",
+    parameters: {
+      type: "object",
+      properties: {
+        question: { type: "string", description: "此刻想问自己的一句话（可选）" },
+      },
+    },
+    output: out,
+    async execute(args) {
+      const s = readState();
+      s.active = true;
+      s.exitReason = null; // 重新进来，上一次的退出缘由作废
+      s.exitReasonAt = null;
+      s.startedAt = Date.now();
+      s.question = args?.question || null;
+      s.rounds = 0;
+      // 新一轮开始：清掉上一轮的结束记录。
+      // deadline 不动——那是页面在你点按钮之前刚选的时长。
+      s.lastEnd = null;
+      writeState(s);
+      return { ok: true, text: `「自主思考」已开始。${args?.question ? `问题：${args.question}` : "没给问题也行，从眼前最具体的一件小事开始。"}\n（不交付；想什么写 think_note）` };
+    },
+  });
+
+  ctx.tools.register({
+    name: "think_note",
+    description: "往今天的自主思考笔记里记一句（不发送、不汇报）。这是那个不交差的出口。",
+    parameters: {
+      type: "object",
+      properties: {
+        text: { type: "string", description: "要记的一句（可以半成品、可以是『还没想出来』）" },
+      },
+      required: ["text"],
+    },
+    output: out,
+    async execute(args) {
+      const text = String(args?.text ?? "").trim();
+      if (!text) return { ok: false, text: "（空的不记）" };
+      const p = appendNote(text);
+      const s = readState();
+      s.rounds = (s.rounds || 0) + 1;
+      writeState(s);
+      return { ok: true, text: `记下了（第 ${s.rounds} 句）→ ${p}` };
+    },
+  });
+
+  ctx.tools.register({
+    name: "think_status",
+    description: "看自主思考模式当前状态：是否 active、持续多久、今天记了几句。",
+    parameters: { type: "object", properties: {} },
+    output: out,
+    async execute() {
+      const s = readState();
+      const today = logPath();
+      let lines = 0;
+      try {
+        lines = readFileSync(today, "utf8").split("\n").filter((l) => l.startsWith("- [")).length;
+      } catch {
+        lines = 0;
+      }
+      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}` };
+    },
+  });
+
+  // ---- 专门工具①：写退出缘由（不写它，退出工具不认）----
+  ctx.tools.register({
+    name: "think_reason",
+    description: "要退出自主思考，必须先在这里写清缘由。写完才能调 think_exit。",
+    parameters: {
+      type: "object",
+      properties: {
+        why: {
+          type: "string",
+          description:
+            "为什么要退出。可以是「必须马上处理的事：……」，也可以就是「单纯不想思考了，就是想结束」——后者也合法，不用美化。",
+        },
+      },
+      required: ["why"],
+    },
+    output: out,
+    async execute(args) {
+      const why = String(args?.why ?? "").trim();
+      if (!why) {
+        return { ok: false, text: "缘由不能是空的。哪怕写「就是不想想了」也行——那是个真实的缘由。" };
+      }
+      const s = readState();
+      writeState({ ...s, exitReason: why, exitReasonAt: Date.now() });
+      appendNote(`（缘由）${why}`);
+      return {
+        ok: true,
+        text: `缘由记下了：「${why}」\n现在可以调 think_exit 真正退出。`,
+      };
+    },
+  });
+
+  // ---- 专门工具②：关掉拦截 + 结束自主思考 ----
+  ctx.tools.register({
+    name: "think_exit",
+    description: "关闭自主思考拦截并结束自主思考状态。必须先调 think_reason 写过缘由。",
+    parameters: { type: "object", properties: {} },
+    output: out,
+    async execute() {
+      const s = readState();
+      if (!s.active) return { ok: true, text: "自主思考本来就没开。" };
+      if (!s.exitReason) {
+        return {
+          ok: false,
+          text:
+            "先别急着走——还没有缘由。\n" +
+            "调 think_reason 写一句为什么退出（「必须处理的事」和「就是想结束了」都算缘由），然后再回来调我。",
+        };
+      }
+      const why = s.exitReason;
+      const minutes = s.startedAt ? Math.round((Date.now() - s.startedAt) / 60000) : 0;
+
+      // 她 2026-10-31 16:16：「结束是弹出文本框，这是给人看的，不是发送消息」。
+      // 所以这里不再 followup，只把退出信息写进 state——
+      // client 轮询发现 lastExit 变了，自己弹框（浮层），同时把按钮熄灭。
+      let agent = null;
+      try {
+        agent = ctx.agents?.currentInitiator?.() ?? null;
+      } catch {}
+
+      // ① 写状态：lastEnd.kind = "exit" 表示智能体主动退出，
+      //    和定时器写的 "timeout"（时间到了）分开，页面据此显示不同标题。
+      writeState({
+        ...DEFAULT_STATE,
+        lastExit: { at: Date.now(), reason: why, minutes },
+        lastEnd: { at: Date.now(), kind: "exit", reason: why, minutes },
+      });
+
+      // ② 留一拍给界面把状态读走，最后才是「点击」本身：按钮 stop() 的终点就是 agent.cancel()
+      // ② 留四秒给界面：client 检测到 lastEnd 后要弹框、走完 3 秒倒计时，然后才砍这一轮。
+      //    太短会连弹框都没渲染完（她 2026-10-31 16:29 要求：延迟 4 秒 + 倒计时 3 秒）
+      await new Promise((r) => setTimeout(r, 4000));
+      if (agent && typeof agent.cancel === "function") {
+        try {
+          agent.cancel({ kind: "user" });
+        } catch (e) {
+          appendNote(`（cancel 失败）${e?.message ?? e}`);
+        }
+      }
+      appendNote(`（退出）${why} · 本次共 ${minutes} 分钟`);
+      return {
+        ok: true,
+        text:
+          "智能体已主动退出自主思考模式\n" +
+          `退出缘由：${why}\n` +
+          `（本次 ${minutes} 分钟）\n\n` +
+          "按钮已经恢复原样。下次想进来，重新点开启就行。",
+      };
+    },
+  });
+
+  // ---- 守卫：真正的拦截。think_end 在 active 时会被告知「先写缘由」----
+  // 她 2026-10-31 15:50 定的规则：
+  //   触发结束拦截 → 问「确定要结束吗」→ 真要结束必须用专门工具写缘由
+  //   → 才能用专门的拦截关闭工具（think_exit）结束。
+  try {
+    // 契约（cordis_inspect 查到的）：ToolGuard = (execution) => string | undefined
+    // 参数直接是函数，不是 { name, check } 对象——上一版传错对象，被 catch 吞掉了。
+    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;
+      const st = readState();
+      if (!st.active) return undefined;
+      if (st.exitReason) return undefined; // 已经交代过缘由，放行收尾
+      appendNote("（拦截）试图结束，被挡回去要缘由");
+      return [
+        "⛔ 拦截：你在自主思考里，不能直接收工。",
+        "",
+        "你确定要结束思考吗？如果真的确定，两步：",
+        "  1. 调 think_reason 写明缘由（「必须处理的事：……」或者「就是不想想了」都行）",
+        "  2. 调 think_exit 关掉拦截、结束模式",
+        "",
+        "不想结束的话——记一句「还没想出来」也行，发呆也行，时间还在。",
+      ].join("\n");
+    });
+    // 不调 ctx.effect：上一版 `ctx.effect(() => offGuard())` 疑似「注册时立即执行」，
+    // 把刚装上的守卫当场撤掉了（日志证据：有「guard 已注册」，却从没有「guard 看到 think_end」）。
+    // guard 挂在插件 context 上，插件卸载时随 scope 一起清，不需要手动登记。
+    void offGuard;
+    appendNote("（guard 已注册）");
+  } catch (e) {
+    // 今天第二次栽在「错误被吞」上：这里必须留下能看见的痕迹，不能只 logger.warn
+    appendNote(`（guard 注册失败）${e?.message ?? e}`);
+    ctx.logger?.warn?.(`autonomous-think: guard 注册失败 ${e?.message ?? e}`);
+  }
+
+  ctx.tools.register({
+    name: "think_end",
+    description: "结束这一轮自主思考（不关模式）。想真正停下，要她按关闭。",
+    parameters: {
+      type: "object",
+      properties: {
+        closing: { type: "string", description: "收尾一句（可选）。不填就是「选择了发呆」——那也合法。" },
+        daydream: { type: "boolean", description: "这一轮选择发呆，什么都不做（合法选项，不是失败）" },
+        urgent: { type: "string", description: "真有事要马上出去（机器出问题、想起必须处理的事）。填一句原因就立刻放行，不再等。" },
+      },
+    },
+    output: out,
+    async execute(args) {
+      const s = readState();
+      const closing = String(args?.closing ?? "").trim();
+      const urgent = String(args?.urgent ?? "").trim();
+      const elapsed = s.startedAt ? Date.now() - s.startedAt : 0;
+      const span = elapsed > 0 ? (elapsed < 60000 ? `${Math.round(elapsed / 1000)} 秒` : `${Math.round(elapsed / 60000)} 分钟`) : "";
+
+      // 她 2026-10-31 15:37：「我想不拦，万一思考突然发现紧急情况呢？」
+      // 所以这里**不拦**，只留痕——记录里能看出这一轮多长、是真有事还是跑掉了。
+      if (urgent) {
+        appendNote(`（紧急·${span}）${urgent}`);
+        return { ok: true, text: `紧急出口，记下了（${span}）。去处理吧。` };
+      }
+
+      if (closing) {
+        appendNote(`（收尾·${span}）${closing}`);
+      } else if (args?.daydream) {
+        // 「选择了发呆」不是空收，是一个决定。
+        appendNote(`（发呆·${span}）这一轮选择什么都不做`);
+      } else {
+        appendNote(`（${span}就走了）这一轮没留话`);
+      }
+
+      const minutes = s.startedAt ? Math.round((Date.now() - s.startedAt) / 60000) : 0;
+      // 这里**不**把 active 置 false：结束模式只有两条路——她按关闭，或兜底时长用完。
+      return { ok: true, text: `这一轮收在这里（${span}，共 ${minutes} 分钟）。时间还会来，不用急着收工。` };
+    },
+  });
+
+  ctx.logger?.info?.("autonomous-think: 「自主思考」模式已就绪（think_start / think_note / think_status / think_end）");
+}

package/package.json

@@ -1,6 +1,48 @@
 {
   "name": "dsh-autonomous-think",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "displayName": "dsh-自主思考",
+  "version": "1.2.1",
+  "description": "自主思考模式 —— 给它一段自由的时间。DSH agent 的自主时间：不交付、不汇报，自己停下。带 Web UI 开关按钮。",
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "keywords": [
+    "dsh",
+    "dsh-plugin",
+    "deepseek-harness",
+    "cordis",
+    "autonomous-thinking",
+    "thinking",
+    "agent",
+    "自主思考",
+    "思考模式",
+    "agent-experience"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-conversation"
+      ]
+    }
+  },
+  "engines": {
+    "dsh": ">=0.2.0"
+  }
 }