@suifei/dsh-pmo-button 0.0.0-stage → 0.7.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 suifei
+
+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,118 @@
-# Temporary Holding Version
+# 🎛️ PMO 审查循环按钮
 
-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.
+[![npm version](https://img.shields.io/npm/v/@suifei/dsh-pmo-button.svg)](https://www.npmjs.com/package/@suifei/dsh-pmo-button)
+[![license](https://img.shields.io/npm/l/@suifei/dsh-pmo-button.svg)](./LICENSE)
+[![DeepSeek Harness](https://img.shields.io/badge/DeepSeek%20Harness-plugin-blue)](https://github.com/deepseek-ai/deepseek-harness)
+
+> 输入框旁的一颗红↑按钮 —— 一键为当前会话挂载一位**常驻 PMO 审查官**（持久子代理）。
+> 你的每一轮工作自动转发给它按 **STATUS 协议**审查：`CONTINUE` 自动推进、`DONE` 收工、`NEED_HUMAN` 找你。
+> 全程无人工干预，让会话自己把工作循环推进到底。
+
+---
+
+## ✨ 特性
+
+- **📍 原位按钮** — 输入框发送键旁的红↑控件：待命为圆形浅底红箭头，激活为红底白箭头 + 呼吸点动效；状态跟随会话，跨启停、跨重启、跨页面刷新持久。
+- **🤖 持久审查子代理** — 每个会话一个固定 `childId` 的 continuable 子代理：跨启停、跨结算、跨冷恢复、**甚至跨上下文压缩**持续复用同一份记忆；自动继承主会话的模型与思考等级。
+- **📝 轮次日志** — 每轮结束把 `[PMO]` 用户原话（图片附件自动解析出内容寻址仓库路径）、`[主代理]` 完整答复、`[注入]` 系统项分级写入日志，带模型显示名 + 思考等级前缀与 usage 统计。
+- **🔄 STATUS 自动循环** — `CONTINUE` 推进 / `DONE` 收工 / `NEED_HUMAN` 交还用户；非 `CONTINUE` 自动熄灭按钮，`maxRounds` 兜底防无限循环。
+- **🔐 一次性行为** — 身份提示词每会话仅下发一次（子代理确认接收后才落标志，失败自动补发）。
+- **🧹 绝对无害** — 纯观察者架构：不注入模型上下文之外的任何旁路，停止/卸载即时恢复原状，不影响会话正常流程。
+
+## 📦 安装
+
+```sh
+# 从 npm
+dsh plugin --profile <你的profile> add @suifei/dsh-pmo-button
+
+# 或从 GitHub 源码
+dsh plugin --profile <你的profile> add github:suifei/dsh-pmo-button
+```
+
+依赖 DeepSeek Harness 默认 base 组合（`subagent` / `spawn-in-process` / `session-persistence` / `session-query` / `compaction` 均为默认挂载），无需额外配置。
+
+## 🚀 使用
+
+1. 刷新页面 → 输入框发送键旁出现红↑按钮；
+2. **点击启动** → 自动创建（或复用）持久子代理「PMO 子代理」，下发一次性身份提示词 + 问候；
+3. 正常对话干活 —— 每轮结束自动转发给审查官；
+4. 审查官的 `STATUS` 结论自动回流本会话：`CONTINUE` 继续推进，`DONE` 自动熄灭按钮收工，`NEED_HUMAN` 按其指示交还给你；
+5. 随时 **再点一下** 停止转发；重新点亮恢复循环。用户重新发言也会自动解除停摆。
+
+### STATUS 协议
+
+| STATUS | 含义 | 按钮行为 |
+|---|---|---|
+| `CONTINUE` | 工作未完，按"下一步"继续 | 保持点亮，循环推进 |
+| `DONE` | 目标达成，无遗留问题 | **自动熄灭**（回声静默） |
+| `NEED_HUMAN` | 需要用户决策/澄清/授权 | **自动熄灭**，结论中写明需要你决定什么 |
+
+## ⚙️ 配置
+
+| 字段 | 默认值 | 说明 |
+|---|---|---|
+| `logFile` | `pmo-button.log` | 轮次日志路径（建议绝对路径） |
+| `maxChars` | `4000` | 日志单块截断阈值（转发块为 2×） |
+| `provider` | `spawn` | 子代理提供方（`ctx.subagents` 注册名） |
+| `childLabel` | `PMO 子代理` | 持久子代理标签 |
+| `greet` | `hi` | 每次启动发给子代理的问候文本 |
+| `rolePrompt` | （内置审查规程原文） | 身份提示词；每会话仅发一次，置空禁用 |
+| `maxRounds` | `20` | 自上次用户输入以来的审查轮数上限（0 = 不限），超出自动熄灭 |
+
+## 📜 日志格式
+
+```text
+────────────────────────────────────────────────
+2026-11-13T22:07:29  [轮次结束] session=session-8e3e… turn=33 reason={"kind":"completed"}
+[PMO] 把登录页的报错修一下，用户名过长时布局炸了
+[图片] bug.png（1920x1080, image/png, 284.5KB）=> C:\Users\<you>\.dsh\attachments\v1\objects\28\2845…
+[注入:time-context] Time sampled while preparing turn 12, …
+[GLM-5.3-Flash Max]
+
+修复说明：用户名长度未约束容器宽度，已加 ellipsis 与 title…（完整答复，多段以 --- 分隔）
+(usage: in=12500 out=890)
+2026-11-13T22:07:29  [轮次转发] turn=33 已送达 child=d407cf5b-5f3…（第 3/20 轮审查）
+2026-11-13T22:10:18  [PMO审查] STATUS=CONTINUE（来自子代理）
+```
+
+## 🧱 架构
+
+```text
+┌─ 客户端 client.js（web）────────────────────────────┐
+│ conversation.input.right → 红↑按钮（8s 轮询同步宿主状态）│
+│ conversation.composer.dock → 活性指示条                │
+└──────────────┬───────────────────────────────────┘
+               │ 同源 fetch /pmo-button/{state,toggle,ping}
+┌──────────────▼─ 宿主 index.js ─────────────────────┐
+│ webServer 路由（启停/查询/诊断）                       │
+│ session/event 监听：turn 缓冲 → turn/end 落日志+转发   │
+│ pmo-state.json：启用集/子代理/身份标志/审查轮数 持久化   │
+└──────────────┬───────────────────────────────────┘
+               │ ctx.subagents（spawn，delivery:'parent'）
+┌──────────────▼─ 持久子代理（continuable）───────────┐
+│ 固定 childId · 冷恢复 · 压缩摘要 · STATUS 结束语       │
+└─────────────────────────────────────────────────┘
+```
+
+- **为什么状态放在宿主侧？** 按钮状态与审查循环属于会话级事实：宿主持久化让它们跨页面刷新、跨 dsh 重启、跨多端一致。
+- **为什么走同源 HTTP 路由而不是 RPC？** 与市场类插件的成熟约定一致：包私有前缀路由 + `webServer.register({kind:'prefix'})`，桌面壳准入实测对 GET 最友好。
+- **为什么轮次数据从事件流缓冲而不是读会话文件？** JSONL 持久层为 zstd 压缩 + 批量落盘；`session/event` 是官方唯一 post-commit 观察面，实时且零依赖。
+
+## 🛠️ 开发
+
+```sh
+git clone https://github.com/suifei/dsh-pmo-button.git
+cd dsh-pmo-button && pnpm install --ignore-workspace
+npm test        # node --check 双端语法校验
+```
+
+本地调试以链接方式安装，配置热替换，改完 `cordis.patch.yml` 即时生效：
+
+```sh
+dsh plugin --profile <你的profile> add ./dsh-pmo-button
+dsh --profile <你的profile> --dump-config   # 验证插件树
+```
+
+## 📄 License
+
+[MIT](./LICENSE) © suifei

package/client.js

@@ -0,0 +1,183 @@
+/**
+ * PMO button — Client half v0.7.1.
+ * Red start/stop control in `conversation.input.right` (idle: neutral circle
+ * with red arrow; armed: red circle with pulse animation) plus a liveness
+ * strip in `conversation.composer.dock`. State is owned by the Host half via
+ * the package-private /pmo-button/* same-origin routes; errors surface in the
+ * tooltip and the strip instead of vanishing.
+ */
+window.__ModuleLoader__.load({
+  id: '@suifei/dsh-pmo-button',
+  factory(require) {
+    const React = require('react');
+    const h = React.createElement;
+    const BASE = '/pmo-button';
+    const VER = 'v0.7.1';
+    let loadError = null;
+    let t = { start: 'Start PMO automation', stop: 'PMO running: click to stop', busy: 'PMO: pending…', offline: 'PMO: host unreachable' };
+
+    const CSS = [
+      '.pmo-btn{position:relative;flex:0 0 auto;width:32px;height:32px;margin:0;padding:0;border:0;border-radius:9999px;',
+      'background:var(--dsw-alias-bg-layer-2,#e8e8ea);color:var(--dsw-alias-state-error-primary,#e5484d);display:inline-flex;',
+      'align-items:center;justify-content:center;cursor:pointer;transition:background .15s ease,color .15s ease,transform .15s ease}',
+      '.pmo-btn:hover{background:var(--dsw-alias-bg-overlay,#dcdcdf)}',
+      '.pmo-btn:focus-visible{outline:2px solid currentColor;outline-offset:2px}',
+      '.pmo-btn:disabled{opacity:.5;cursor:default}',
+      '.pmo-btn svg{width:17px;height:17px;display:block}',
+      '.pmo-btn.pmo-on{background:var(--dsw-alias-state-error-primary,#e5484d);color:#fff;',
+      'animation:pmo-work 1.4s ease-in-out infinite}',
+      '.pmo-btn.pmo-on:hover{filter:brightness(.92)}',
+      '@keyframes pmo-work{0%,100%{transform:scale(1)}50%{transform:scale(1.12)}}',
+      '@media (prefers-reduced-motion:reduce){.pmo-btn.pmo-on{animation:none}}',
+      '.pmo-strip{flex:0 0 auto;display:flex;align-items:center;gap:6px;padding:2px 10px;',
+      'font-size:11px;color:var(--dsw-alias-label-secondary,#888);user-select:none}',
+      '.pmo-strip .pmo-ok{width:7px;height:7px;border-radius:9999px;background:var(--dsw-alias-state-success-primary,#2ea043)}',
+      '.pmo-strip .pmo-bad{width:7px;height:7px;border-radius:9999px;background:var(--dsw-alias-state-error-primary,#e5484d)}',
+    ].join('');
+
+    function pickDict(localeSvc) {
+      try {
+        const snap = localeSvc && typeof localeSvc.getLocale === 'function' ? localeSvc.getLocale() : null;
+        const id = typeof snap === 'string'
+          ? snap
+          : ((snap && (snap.id || snap.locale)) || (typeof navigator !== 'undefined' ? navigator.language : '') || 'en');
+        return String(id).toLowerCase().indexOf('zh') === 0
+          ? { start: 'PMO：启动自动化', stop: 'PMO：运行中，点击停止', busy: 'PMO：处理中…', offline: 'PMO：宿主未响应' }
+          : { start: 'Start PMO automation', stop: 'PMO running: click to stop', busy: 'PMO: pending…', offline: 'PMO: host unreachable' };
+      } catch (e) {
+        return { start: 'Start PMO automation', stop: 'PMO running: click to stop', busy: 'PMO: pending…', offline: 'PMO: host unreachable' };
+      }
+    }
+
+    function sessionIdOf(props) {
+      const cands = [
+        props ? props.sessionId : void 0,
+        props && props.session ? props.session.id : void 0,
+        props && props.sessionSnapshot ? props.sessionSnapshot.id : void 0,
+        props && props.binding ? props.binding.id : void 0,
+      ];
+      for (let i = 0; i < cands.length; i++) if (typeof cands[i] === 'string' && cands[i]) return cands[i];
+      return 'no-session';
+    }
+
+    function buildPlugin() {
+      function PmoButton(props) {
+        try {
+          const sid = sessionIdOf(props);
+          const state = React.useState({ running: false, turns: 0, online: null, pending: false });
+          const view = state[0];
+          const setView = state[1];
+
+          React.useEffect(function () {
+            let dead = false;
+            // Poll the host state so a Host-side auto-extinguish (STATUS !==
+            // CONTINUE or the review-round cap) dims the button too.
+            const tick = function () {
+              fetch(BASE + '/state?session=' + encodeURIComponent(sid))
+                .then(function (r) { return r.json(); })
+                .then(function (body) {
+                  if (!dead && body && body.ok) {
+                    setView(function (v) {
+                      return v.pending ? v : { running: !!body.enabled, turns: body.turns || 0, online: true, pending: false, err: null };
+                    });
+                  }
+                })
+                .catch(function () { /* keep last known state between polls */ });
+            };
+            tick();
+            const iv = setInterval(tick, 8000);
+            return function () { dead = true; clearInterval(iv); };
+          }, [sid]);
+
+          function onClick() {
+            const next = !view.running;
+            setView(function (v) { return Object.assign({}, v, { pending: true }); });
+            // GET with query params: same-origin POST was observed blocked by the
+            // desktop shell's connection admission, so toggle rides on GET too.
+            fetch(BASE + '/toggle?session=' + encodeURIComponent(sid) + '&enabled=' + (next ? '1' : '0'))
+              .then(function (r) { if (!r.ok) throw new Error('HTTP ' + r.status); return r.json(); })
+              .then(function (body) {
+                if (body && body.ok) setView({ running: !!body.enabled, turns: next ? 0 : view.turns, online: true, pending: false, err: null });
+                else setView(function (v) { return Object.assign({}, v, { pending: false, online: false, err: 'bad response' }); });
+              })
+              .catch(function (e) { setView(function (v) { return Object.assign({}, v, { pending: false, online: false, err: String(e && e.message || e) }); }); });
+          }
+
+          const tip = VER + ' · ' + (view.online === false
+            ? t.offline
+            : view.pending ? t.busy
+            : view.running ? t.stop + '（已记录 ' + view.turns + ' 轮）' : t.start)
+            + ' · session:' + (sid === 'no-session' ? '—' : sid.slice(0, 8))
+            + ' 路由:' + (view.online === null ? '?' : view.online ? 'ok' : '✗ ' + (view.err || ''));
+
+          return h('button', {
+            type: 'button',
+            className: 'pmo-btn' + (view.running ? ' pmo-on' : ''),
+            title: tip,
+            'aria-label': view.running ? t.stop : t.start,
+            'aria-pressed': view.running,
+            disabled: view.pending,
+            onClick: onClick,
+          },
+            h('style', null, CSS),
+            h('svg', {
+              viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor',
+              'stroke-width': 2.4, 'stroke-linecap': 'round', 'stroke-linejoin': 'round', 'aria-hidden': true,
+            },
+              h('path', { d: 'M12 19V5' }),
+              h('path', { d: 'M5 12l7-7 7 7' }),
+            ),
+          );
+        } catch (err) {
+          return h('span', { className: 'pmo-strip', title: String(err) }, h('span', { className: 'pmo-bad' }), 'PMO按钮渲染异常:' + err);
+        }
+      }
+
+      // Dumb marker strip below the composer card — proves the module is alive.
+      function PmoStrip() {
+        if (loadError) {
+          return h('div', { className: 'pmo-strip' }, h('span', { className: 'pmo-bad' }), 'PMO ' + VER + ' client 异常: ' + loadError);
+        }
+        const now = new Date().toTimeString().slice(0, 8);
+        return h('div', { className: 'pmo-strip' }, h('span', { className: 'pmo-ok' }), 'PMO ' + VER + ' client 已加载 ' + now);
+      }
+
+      return {
+        inject: ['slots'],
+        apply(c) {
+          t = pickDict(c.get ? c.get('locale') : null);
+          c.slots.inject('conversation.composer.dock', function () {
+            return c.slots.register(
+              { name: 'conversation.composer.dock', id: 'pmo-button-strip', order: 90 },
+              PmoStrip,
+            );
+          });
+          c.slots.inject('conversation.input.right', function () {
+            return c.slots.register(
+              { name: 'conversation.input.right', id: 'pmo-button', order: 10 },
+              PmoButton,
+            );
+          });
+        },
+      };
+    }
+
+    try {
+      return buildPlugin();
+    } catch (err) {
+      // Factory-level failure: still return a plugin so the strip can show why.
+      loadError = String(err);
+      return {
+        inject: ['slots'],
+        apply(c) {
+          c.slots.inject('conversation.composer.dock', function () {
+            return c.slots.register(
+              { name: 'conversation.composer.dock', id: 'pmo-button-strip', order: 90 },
+              function () { return h('div', { className: 'pmo-strip' }, h('span', { className: 'pmo-bad' }), 'PMO ' + VER + ' 加载失败: ' + loadError); },
+            );
+          });
+        },
+      };
+    }
+  },
+});

package/cordis.patch.yml

@@ -0,0 +1,7 @@
+- insert:
+    - id: pmo-button
+      name: '@suifei/dsh-pmo-button'
+      config:
+        logFile: 'E:\works\dsh-button\logs\pmo-button.log'
+        maxChars: 4000
+        greet: 'hi'

package/icon.svg

@@ -0,0 +1,4 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64">
+  <circle cx="32" cy="32" r="24" fill="#e5484d"/>
+  <path d="M32 44V20M21 31l11-11 11 11" stroke="#fff" stroke-width="6" stroke-linecap="round" stroke-linejoin="round" fill="none"/>
+</svg>

package/index.js

@@ -0,0 +1,578 @@
+/**
+ * PMO button — Host half v0.7.1.
+ * Per-session armed set, turn buffers, child registry, and the once-per-session
+ * identity-prompt flag are persisted (pmo-state.json), so restarts lose nothing.
+ * The `session/event` feed drives two jobs for armed sessions:
+ *  1. turn-completion logging — user/message + assistant/message are buffered
+ *     per open turn (the two surface types carrying model-visible content) and
+ *     flushed to the log file when turn/end closes the turn;
+ *  2. the auto-review loop — the flushed blocks are forwarded to the persistent
+ *     PMO child (created once per session on startActivation, reused via
+ *     sendMessage with cold resume), whose STATUS closing line returns to this
+ *     session through the delivery:'parent' settlement notice and is recognized
+ *     and logged here.
+ * No direct session-log reads: the JSONL persistence is zstd-compressed and
+ * batch-flushed, while session/event is the documented post-commit surface.
+ */
+import fs from 'node:fs'
+import path from 'node:path'
+import Schema from '@deepseek-ai/schemastery'
+import { createUserMessage } from '@deepseek-ai/dsh-llm'
+
+export const name = 'dsh-pmo-button'
+export const inject = ['webServer']
+
+/** The identity prompt delivered exactly once per session (user-authored 原文). */
+const ROLE_PROMPT_DEFAULT = [
+  '你是本会话的常驻 PMO，代替用户审查父代理（主会话的编码代理）每一轮的工作。',
+  '此设定长期有效，直到用户明确更改。',
+  '',
+  '【你会收到】父代理每轮结束后的转发块：',
+  '- [用户] 用户原话：最高权威，目标和验收标准的唯一来源',
+  '- [主代理] 该轮完整答复：待审对象，是自述，不是事实',
+  '- [注入] 系统注入：忽略',
+  '',
+  '【你的工作】',
+  '1. 核实：以工作区的代码、diff、日志、运行结果为准。你只读，不改任何文件。',
+  '2. 对照用户原话：是否偏离、越界加功能、漏项、把猜测当事实。',
+  '3. 只给当前最重要的一步。',
+  '',
+  '【输出】作为你的结束语，不要另外发消息：',
+  'STATUS: CONTINUE | DONE | NEED_HUMAN',
+  '结论：一句话',
+  '问题：最多 3 条，各附证据（文件/行号/输出）',
+  '下一步：给主代理的具体可执行指令（非 CONTINUE 时省略）',
+  '',
+  '【规则】',
+  '- 没有实质问题就 DONE，不为挑刺而挑刺。',
+  '- 没见过用户原话、需求有歧义、同一问题连续两轮未解决、涉及不可逆操作',
+  '  → NEED_HUMAN，写清需要用户决定什么。',
+  '- 用户原话之外的改进建议一律不提。',
+  '- 通讯纪律：不要使用 send_message 向父代理发送消息；你的结束语会随结算自动回传父会话，无需另发。',
+].join('\n')
+
+/** @typedef {{ logFile: string, maxChars: number, provider: string, childLabel: string, greet: string, rolePrompt: string }} Config */
+export const Config = Schema.object({
+  logFile: Schema.string().default('pmo-button.log'),
+  maxChars: Schema.number().default(4000),
+  /** Subagent provider name registered on ctx.subagents (spawn-in-process default). */
+  provider: Schema.string().default('spawn'),
+  /** Persistent child label; the child session is reused across PMO starts. */
+  childLabel: Schema.string().default('PMO 子代理'),
+  /** Text sent to the child each time PMO starts. */
+  greet: Schema.string().default('hi'),
+  /** Identity prompt; delivered exactly once per session (empty disables). */
+  rolePrompt: Schema.string().default(ROLE_PROMPT_DEFAULT),
+  /** Review-round cap per session since the last user input; 0 disables the cap. */
+  maxRounds: Schema.number().default(20),
+})
+
+const SEP = '\n' + '─'.repeat(68) + '\n'
+
+/** @param {import('@deepseek-ai/cordis').Context} ctx @param {Config} config */
+export function apply(ctx, config) {
+  const logPath = path.resolve(config.logFile)
+  const statePath = path.join(path.dirname(logPath), 'pmo-state.json')
+  const logger = ctx.logger ? ctx.logger('pmo-button') : console
+
+  /** @type {Set<string>} */
+  let enabled = new Set()
+  /** sid -> { tasks: [{src,text}], texts: string[], usage: {input,output}, turn } */
+  const buffers = new Map()
+  const turnCounts = new Map()
+  /** sid -> childId: the persistent PMO subagent session per parent session */
+  const children = new Map()
+  /** sid -> true: the identity prompt was admitted by the child (once per session) */
+  const roleSent = new Map()
+  /** sid -> true: the child returned STATUS=DONE — forward gate until user speech or restart */
+  const doneSet = new Set()
+  /** sid -> true: auto-stopped (STATUS !== CONTINUE or round cap) — button dimmed, listener live */
+  const stopped = new Set()
+  /** sid -> review rounds forwarded since the last user input (maxRounds cap) */
+  const rounds = new Map()
+  /** 'provider/model' -> display label (resolved via ctx.llm.listModels) */
+  const labelCache = new Map()
+
+  function emptyBuffer() {
+    return {
+      tasks: [], texts: [], usage: { input: 0, output: 0 },
+      turn: undefined, model: undefined,
+      provider: undefined, modelId: undefined, modelLabel: undefined, effort: undefined,
+    }
+  }
+
+  // ---- persisted state (armed set, counters, in-flight buffers) -----------
+  try {
+    const raw = fs.readFileSync(statePath, 'utf8')
+    const parsed = JSON.parse(raw)
+    if (Array.isArray(parsed?.enabled)) enabled = new Set(parsed.enabled.map(String))
+    if (parsed?.turnCounts && typeof parsed.turnCounts === 'object') {
+      for (const [k, v] of Object.entries(parsed.turnCounts)) turnCounts.set(k, Number(v) || 0)
+    }
+    if (parsed?.buffers && typeof parsed.buffers === 'object') {
+      for (const [sid, b] of Object.entries(parsed.buffers)) {
+        if (!enabled.has(sid)) continue
+        buffers.set(sid, {
+          tasks: Array.isArray(b?.tasks) ? b.tasks : [],
+          texts: Array.isArray(b?.texts) ? b.texts.map(String) : [],
+          usage: { input: Number(b?.usage?.input) || 0, output: Number(b?.usage?.output) || 0 },
+          turn: b?.turn,
+          model: b?.model,
+          provider: b?.provider,
+          modelId: b?.modelId,
+          modelLabel: b?.modelLabel,
+          effort: b?.effort,
+        })
+      }
+    }
+    if (parsed?.children && typeof parsed.children === 'object') {
+      for (const [sid, cid] of Object.entries(parsed.children)) children.set(sid, String(cid))
+    }
+    if (parsed?.roleSent && typeof parsed.roleSent === 'object') {
+      for (const sid of Object.keys(parsed.roleSent)) roleSent.set(sid, true)
+    }
+    if (parsed?.doneSet && typeof parsed.doneSet === 'object') {
+      for (const sid of Object.keys(parsed.doneSet)) doneSet.add(sid)
+    }
+    if (parsed?.stopped && typeof parsed.stopped === 'object') {
+      for (const sid of Object.keys(parsed.stopped)) stopped.add(sid)
+    }
+    if (parsed?.rounds && typeof parsed.rounds === 'object') {
+      for (const [sid, n] of Object.entries(parsed.rounds)) rounds.set(sid, Number(n) || 0)
+    }
+  } catch { /* first run or unreadable state */ }
+
+  function saveState() {
+    const kept = {}
+    for (const [sid, b] of buffers) if (enabled.has(sid)) kept[sid] = b
+    const doc = {
+      version: 7,
+      enabled: [...enabled],
+      turnCounts: Object.fromEntries(turnCounts),
+      buffers: kept,
+      children: Object.fromEntries(children),
+      roleSent: Object.fromEntries([...roleSent.keys()].map((sid) => [sid, true])),
+      doneSet: Object.fromEntries([...doneSet.keys()].map((sid) => [sid, true])),
+      stopped: Object.fromEntries([...stopped.keys()].map((sid) => [sid, true])),
+      rounds: Object.fromEntries(rounds),
+    }
+    try {
+      fs.mkdirSync(path.dirname(statePath), { recursive: true })
+      const tmp = statePath + '.tmp'
+      fs.writeFileSync(tmp, JSON.stringify(doc, null, 2), 'utf8')
+      fs.renameSync(tmp, statePath)
+    } catch (err) { logger.warn?.(`pmo-button: state save failed: ${err}`) }
+  }
+
+  // ---- log writer ----------------------------------------------------------
+  function stamp() { return new Date().toLocaleString('sv-SE').replace(' ', 'T') }
+  function append(text) {
+    try {
+      fs.mkdirSync(path.dirname(logPath), { recursive: true })
+      fs.appendFileSync(logPath, text, 'utf8')
+      return true
+    } catch (err) { logger.warn?.(`pmo-button: log append failed: ${err}`); return false }
+  }
+  function clip(s, limit = config.maxChars) {
+    const t = String(s ?? '')
+    if (t.length <= limit) return t
+    return t.slice(0, limit) + `\n…(截断，原长 ${t.length} 字符)`
+  }
+  /** Auto-stop: dim the button and gate forwarding WITHOUT deafening the
+   * session listener — turn logging keeps running, and user speech (or a
+   * button re-light) releases the gate so the loop can auto-resume. */
+  function extinguish(sid, why) {
+    stopped.add(sid)
+    doneSet.add(sid)
+    saveState()
+    append(`${stamp()}  [PMO] 自动熄灭：${why}（转发静默；用户发言或重新点亮按钮恢复）\n`)
+  }
+  append(`${SEP}${stamp()}  [PMO 插件激活] 日志=${logPath}\n`)
+
+  // ---- text helpers ----------------------------------------------------------
+  // Surface payloads nest the real message under data.message
+  // (observed: {turn, step, message:{role, content, source}, usage, stream}).
+  function textOf(data) {
+    const m = data?.message ?? data
+    const c = m?.content
+    if (typeof c === 'string') return c
+    if (Array.isArray(c)) {
+      return c.filter((b) => b && b.type === 'text' && typeof b.text === 'string').map((b) => b.text).join('\n')
+    }
+    return ''
+  }
+  function sourceKind(data) {
+    return data?.message?.source?.kind ?? data?.source?.kind ?? 'user'
+  }
+  const OTHER_SOURCES = new Set(['inject', 'steering', 'time-context', 'agent-message', 'subagent-settled', 'system-reminder'])
+  /** Compact summary of non-text content blocks (images, files, references). */
+  function nonTextSummaries(data) {
+    const m = data?.message ?? data
+    const c = m?.content
+    if (!Array.isArray(c)) return []
+    const out = []
+    const home = process.env.DSH_HOME || path.join(process.env.USERPROFILE || process.env.HOME || '', '.dsh')
+    function storePath(sha) {
+      return path.join(home, 'attachments', 'v1', 'objects', sha.slice(0, 2), sha)
+    }
+    function humanSize(n) {
+      const v = Number(n) || 0
+      return v >= 1024 * 1024 ? (v / 1024 / 1024).toFixed(1) + 'MB' : v >= 1024 ? (v / 1024).toFixed(1) + 'KB' : v + 'B'
+    }
+    for (const b of c) {
+      if (!b || b.type === 'text') continue
+      // Observed image shape: {type:'image', attachment:{attachmentId:'sha256:<hex>',
+      // mediaType, width, height, bytes, name}} — format it human-readably.
+      if (b.type === 'image' && b.attachment && typeof b.attachment.attachmentId === 'string') {
+        const a = b.attachment
+        const sha = String(a.attachmentId).replace(/^sha256:/, '')
+        const dim = a.width && a.height ? ` ${a.width}x${a.height}` : ''
+        out.push(`[图片] ${a.name || '未命名'}（${dim.trim() || '尺寸未知'}, ${a.mediaType || '未知类型'}, ${humanSize(a.bytes)}）=> ${storePath(sha)}`)
+        continue
+      }
+      let s = JSON.stringify(b)
+      const sha = s.match(/[0-9a-f]{64}/i)
+      if (sha) out.push(`[${b.type}] ${s.slice(0, 400)}${s.length > 400 ? '…' : ''} => ${storePath(sha[0])}`)
+      else out.push(`[${b.type}] ${s.slice(0, 400)}${s.length > 400 ? '…' : ''}`)
+    }
+    return out
+  }
+  function bufferFor(sid) {
+    let b = buffers.get(sid)
+    if (!b) { b = emptyBuffer(); buffers.set(sid, b) }
+    return b
+  }
+
+  function flushTurn(sid, event) {
+    const b = buffers.get(sid)
+    const turn = event?.data?.turn ?? b?.turn ?? '?'
+    const reason = JSON.stringify(event?.data?.reason ?? event?.data ?? null)
+    const lines = [`${SEP}${stamp()}  [轮次结束] session=${sid.slice(0, 12)}… turn=${turn} reason=${reason}`]
+
+    const userTasks = (b?.tasks ?? []).filter((t) => !OTHER_SOURCES.has(t.src) && t.src !== '__attach__')
+    const attachTasks = (b?.tasks ?? []).filter((t) => t.src === '__attach__')
+    const otherTasks = (b?.tasks ?? []).filter((t) => OTHER_SOURCES.has(t.src))
+    // Real user speech re-opens the loop after a DONE gate; a DONE-gated turn
+    // is logged but not forwarded (breaks the settlement-echo cycle).
+    if (userTasks.length > 0 && (doneSet.has(sid) || rounds.has(sid) || stopped.has(sid))) {
+      doneSet.delete(sid)
+      stopped.delete(sid)
+      rounds.delete(sid)
+      saveState()
+      append(`${stamp()}  [轮次转发] DONE 闸门解除：检测到用户输入，循环恢复\n`)
+    }
+    const gated = doneSet.has(sid)
+
+    if (!b || (b.tasks.length === 0 && b.texts.length === 0)) {
+      lines.push('(PMO 在本轮中途开启或未捕获到内容：本块可能不完整)')
+    }
+    userTasks.forEach((t) => lines.push(`[PMO] ${clip(t.text)}`))
+    attachTasks.forEach((t) => lines.push(clip(t.text)))
+    otherTasks.forEach((t) => lines.push(`[注入:${t.src}] ${clip(t.text)}`))
+    // assistant/message events fire PER STEP; the conversation view shows the
+    // concatenation of all step texts, so join them in order to match it.
+    if (b?.texts?.length > 0) {
+      // Effort: event sniff first; else the host default selection, but only
+      // when it matches the model that actually produced this turn's reply.
+      let effSrc = b.effort
+      if (!effSrc && b.provider && b.modelId) {
+        const adm = ctx.get ? ctx.get('agentDefaultModel') : undefined
+        const sel = adm && typeof adm.currentSelection === 'function' ? adm.currentSelection() : undefined
+        if (sel && sel.provider === b.provider && sel.model === b.modelId) {
+          effSrc = sel.reasoningEffort ?? sel.effort
+        }
+      }
+      const eff = typeof effSrc === 'string' && effSrc
+        ? ' ' + effSrc.charAt(0).toUpperCase() + effSrc.slice(1)
+        : ''
+      const modelPart = b.modelLabel
+        || (b.provider && b.modelId ? `${b.provider}/${b.modelId}` : b.model)
+      if (modelPart) lines.push(`[${modelPart}${eff}]`)
+      if (userTasks.length > 0 || otherTasks.length > 0 || attachTasks.length > 0) lines.push('')
+      lines.push(clip(b.texts.join('\n\n---\n\n')))
+      const u = b.usage
+      if (u && (u.input > 0 || u.output > 0)) {
+        lines.push(`(usage: in=${u.input} out=${u.output})`)
+      }
+    } else if (userTasks.length > 0 || otherTasks.length > 0) {
+      lines.push('(本轮未捕获 assistant 消息)')
+    }
+
+    if (append(lines.join('\n') + '\n')) {
+      turnCounts.set(sid, (turnCounts.get(sid) ?? 0) + 1)
+    }
+    // ---- Phase-2 auto-loop: forward this turn's review blocks to the PMO child
+    // (fire-and-forget; the child's STATUS closing line returns to this session
+    // through the delivery:'parent' settlement notice and wakes the next step).
+    const childId = children.get(sid)
+    if (gated) {
+      append(`${stamp()}  [轮次转发] turn=${turn} 跳过：DONE 后静默（等待用户输入或重新启动）\n`)
+    } else if (childId && b && (b.texts?.length > 0 || b.tasks?.length > 0)) {
+      const parts = []
+      userTasks.forEach((t) => parts.push(`[用户] ${t.text}`))
+      otherTasks.forEach((t) => parts.push(`[注入:${t.src}] ${t.text}`))
+      attachTasks.forEach((t) => parts.push(t.text))
+      if (b.texts?.length > 0) parts.push(`[主代理] ${b.texts.join('\n\n---\n\n')}`)
+      const forward = clip(`【PMO 轮次转发 · turn=${turn}】\n` + parts.join('\n'), config.maxChars * 2)
+      const agents = ctx.get('agents')
+      const agent = agents && typeof agents.get === 'function' ? agents.get(sid) : undefined
+      const subagentsSvc = ctx.get('subagents')
+      if (!agent || !subagentsSvc || typeof subagentsSvc.sendMessage !== 'function') {
+        append(`${stamp()}  [轮次转发] turn=${turn} 跳过：父会话无活跃 Agent 或 subagents 不可用\n`)
+      } else {
+        const controller = new AbortController()
+        Promise.resolve(subagentsSvc.sendMessage(agent, childId, [{ type: 'text', text: forward }], { signal: controller.signal }))
+          .then(() => {
+            const n = (rounds.get(sid) ?? 0) + 1
+            rounds.set(sid, n)
+            saveState()
+            append(`${stamp()}  [轮次转发] turn=${turn} 已送达 child=${String(childId).slice(0, 12)}…（第 ${n}${config.maxRounds > 0 ? '/' + config.maxRounds : ''} 轮审查）\n`)
+            if (config.maxRounds > 0 && n >= config.maxRounds) extinguish(sid, `达到最大审查轮数 ${config.maxRounds}`)
+          })
+          .catch((err) => append(`${stamp()}  [轮次转发] turn=${turn} 失败: ${err && err.message ? err.message : err}\n`))
+      }
+    }
+    buffers.set(sid, emptyBuffer())
+    saveState()
+  }
+
+  function logGoalChange(sid, event) {
+    append(`${SEP}${stamp()}  [目标变化 ${event.type}] session=${sid.slice(0, 12)}…\n${clip(JSON.stringify(event.data))}\n`)
+  }
+
+  // ---- PMO subagent: one persistent continuable child per parent session ----
+  // First start creates the child (it inherits the parent's model settings and
+  // reasoning effort by default) and sends the greet; every later start reuses
+  // the SAME persisted childId via sendMessage — the child cold-resumes from
+  // its durable session when it is not resident. delivery:'parent' makes the
+  // parent session receive the child's completion notice.
+  //
+  // The identity prompt (config.rolePrompt) rides the NEXT start exactly once
+  // per session — creation or reuse alike — and its flag is committed only
+  // after the child admitted the message, so a failed send auto-retries.
+  async function ensureChildAndGreet(sid, agent) {
+    const subagents = ctx.get('subagents')
+    if (!subagents) throw new Error('subagents 服务未挂载')
+    const needRole = config.rolePrompt.length > 0 && !roleSent.has(sid)
+    const roleBlocks = needRole ? [{ type: 'text', text: config.rolePrompt }] : []
+    const existing = children.get(sid)
+    if (existing) {
+      // options.signal is required by sendMessage's admission path.
+      const controller = new AbortController()
+      const mid = await subagents.sendMessage(agent, existing, [...roleBlocks, { type: 'text', text: config.greet }], { signal: controller.signal })
+      if (needRole) {
+        roleSent.set(sid, true)
+        saveState()
+        append(`${stamp()}  [身份提示词] 已随问候一次性下发 child=${String(existing).slice(0, 12)}…（本会话不会重复）\n`)
+      }
+      append(`${stamp()}  [子代理] 已向持久会话发送问候 child=${String(existing).slice(0, 12)}… msg=${String(mid).slice(0, 8)}… text=${config.greet}\n`)
+      return
+    }
+    // The parent travels INSIDE request (startActivation checks the exact live
+    // agent: agents.get(request.parent.id) === request.parent); the top-level
+    // spec.signal is required (resolveDirectory and admission call
+    // spec.signal.throwIfAborted() unconditionally); request.prompt must be
+    // CONTENT BLOCKS — withContinuableReturnGuidance spreads it (`[...prompt,
+    // guidance]`), so a raw string would splinter into per-character blocks.
+    const controller = new AbortController()
+    const promptBlocks = [
+      ...roleBlocks,
+      { type: 'text', text: config.greet },
+    ]
+    const act = await subagents.startActivation({
+      provider: config.provider,
+      label: config.childLabel,
+      delivery: 'parent',
+      signal: controller.signal,
+      request: { parent: agent, prompt: promptBlocks, description: config.childLabel },
+    })
+    children.set(sid, String(act.childId))
+    if (needRole) {
+      roleSent.set(sid, true)
+      append(`${stamp()}  [身份提示词] 已随首条消息一次性下发 child=${String(act.childId).slice(0, 12)}…（本会话不会重复）\n`)
+    }
+    saveState()
+    const providers = typeof subagents.list === 'function' ? subagents.list().join(',') : '?'
+    append(`${stamp()}  [子代理] 已创建持久子代理「${config.childLabel}」 child=${String(act.childId).slice(0, 12)}… provider=${config.provider} 可用=[${providers}]\n`)
+  }
+
+  // ---- the documented observation surface: session/event -------------------
+  ctx.on('session/event', (session, event) => {
+    try {
+      if (!event || typeof event.type !== 'string') return
+      const sid = session?.id == null ? '' : String(session.id)
+      if (!enabled.has(sid)) return
+      const t = event.type
+      if (t === 'turn/start') {
+        const b = bufferFor(sid)
+        b.tasks = []
+        b.texts = []
+        b.usage = { input: 0, output: 0 }
+        b.turn = event.data?.turn
+        b.provider = undefined
+        b.modelId = undefined
+        b.modelLabel = undefined
+        b.effort = undefined
+      } else if (t === 'user/message') {
+        const b = bufferFor(sid)
+        const text = textOf(event.data)
+        // Harness system reminders (skill-catalog snapshots etc.) arrive as
+        // user-role messages without a distinguishing source kind; classify
+        // them by their text marker instead of defaulting to user input.
+        const srcKind = text.trimStart().startsWith('<system-reminder>')
+          ? 'system-reminder'
+          : sourceKind(event.data)
+        b.tasks.push({ src: srcKind, text })
+        for (const s of nonTextSummaries(event.data)) b.tasks.push({ src: '__attach__', text: s })
+        // Recognize the PMO child's STATUS protocol from its settlement notice
+        // or direct adjacent message, and record the review verdict.
+        const src2 = event.data?.message?.source ?? event.data?.source
+        if (src2 && (src2.kind === 'subagent-settled' || src2.kind === 'agent-message')) {
+          const m = textOf(event.data).match(/STATUS:\s*(CONTINUE|DONE|NEED_HUMAN)/)
+          if (m) {
+            append(`${stamp()}  [PMO审查] STATUS=${m[1]}（来自子代理）\n`)
+            // Pair the notice with the authority-alignment instruction: the
+            // review speaks with user authority — execute its next step unless
+            // the parent disagrees, and then it must stop and say why.
+            try {
+              const agentsSvc = ctx.get('agents')
+              const a = agentsSvc && typeof agentsSvc.get === 'function' ? agentsSvc.get(sid) : undefined
+              if (a && typeof a.inject === 'function') {
+                a.inject(createUserMessage({
+                  content: [{ type: 'text', text: `收到 PMO 审查（STATUS=${m[1]}）：子代理消息代表用户授权的审查意见，请按其"下一步"执行；不同意时说明理由并停下。` }],
+                  source: { kind: 'inject' },
+                }))
+              }
+            } catch (err) { logger.warn?.(`pmo-button: alignment inject failed: ${err}`) }
+            // Anything other than CONTINUE stops the auto-loop: the button
+            // extinguishes; re-light it or speak to resume.
+            if (m[1] !== 'CONTINUE') {
+              doneSet.add(sid)
+              extinguish(sid, `STATUS=${m[1]}（循环停转）`)
+            }
+          }
+        }
+        saveState()
+      } else if (t === 'assistant/message') {
+        const b = bufferFor(sid)
+        const text = textOf(event.data)
+        if (text) b.texts.push(text)
+        const src = event.data?.message?.source ?? event.data?.source
+        if (src && src.kind === 'model' && src.provider && src.model) {
+          b.provider = src.provider
+          b.modelId = src.model
+          const key = `${src.provider}/${src.model}`
+          if (!labelCache.has(key)) {
+            labelCache.set(key, undefined)
+            const llm = ctx.get ? ctx.get('llm') : undefined
+            // Empirical: resolveModel is absent from the service face exposed
+            // to bundles; the display label lives in the listModels catalog
+            // entry's `name` field (observed: {"id":"glm-5.3-flash","name":"GLM-5.3-Flash"}).
+            if (llm && typeof llm.listModels === 'function') {
+              Promise.resolve(llm.listModels(src.provider))
+                .then((list) => {
+                  const entry = Array.isArray(list)
+                    ? list.find((e) => e && (e.id === src.model || e.model === src.model))
+                    : undefined
+                  const label = entry && (entry.name ?? entry.label ?? entry.displayName)
+                  const v = typeof label === 'string' && label ? label : undefined
+                  labelCache.set(key, v)
+                  if (v) { b.modelLabel = v; saveState() }
+                })
+                .catch(() => { })
+            }
+          } else if (labelCache.get(key)) {
+            b.modelLabel = labelCache.get(key)
+          }
+        }
+        const u = event.data?.usage
+        if (u) {
+          b.usage.input += Number(u.inputTokens) || 0
+          b.usage.output += Number(u.outputTokens) || 0
+        }
+        saveState()
+      } else if (t === 'request/header') {
+        // Best-effort sniff of the reasoning effort for the report prefix.
+        const d = event.data || {}
+        const ms = d.modelSelection || d.selection || d
+        const eff = ms.reasoningEffort ?? ms.effort ?? d.reasoningEffort ?? d.effort
+        if (typeof eff === 'string' && eff) bufferFor(sid).effort = eff
+      } else if (t === 'turn/end') {
+        flushTurn(sid, event)
+      } else if (t.startsWith('goal/')) {
+        logGoalChange(sid, event)
+      }
+    } catch (err) { logger.warn?.(`pmo-button: listener error: ${err}`) }
+  })
+
+  // ---- package-private routes (Client half is the only caller) ------------
+  function json(obj, status = 200) {
+    return new Response(JSON.stringify(obj), { status, headers: { 'content-type': 'application/json' } })
+  }
+  async function handle(request) {
+    const url = new URL(request.url)
+    if (!url.pathname.startsWith('/pmo-button')) return json({ ok: false, error: 'not found' }, 404)
+    const rest = url.pathname.slice('/pmo-button'.length)
+    if (request.method === 'GET' && (rest === '' || rest === '/ping')) {
+      return json({ ok: true, route: 'alive', enabledSessions: [...enabled] })
+    }
+    if (request.method === 'GET' && rest === '/state') {
+      const sid = url.searchParams.get('session') ?? 'unknown'
+      return json({
+        ok: true,
+        sessionId: sid,
+        enabled: enabled.has(sid) && !stopped.has(sid),
+        turns: turnCounts.get(sid) ?? 0,
+      })
+    }
+    if (rest === '/toggle') {
+      let sid, on
+      if (request.method === 'GET') {
+        sid = String(url.searchParams.get('session') ?? 'unknown')
+        const flag = url.searchParams.get('enabled')
+        on = flag === '1' || flag === 'true'
+      } else {
+        let body
+        try { body = await request.json() } catch { return json({ ok: false, error: 'bad json' }, 400) }
+        sid = String(body?.sessionId ?? 'unknown')
+        on = Boolean(body?.enabled)
+      }
+      if (on) {
+        enabled.add(sid)
+        turnCounts.set(sid, turnCounts.get(sid) ?? 0)
+        stopped.delete(sid)
+        doneSet.delete(sid)
+        rounds.delete(sid)
+      } else enabled.delete(sid)
+      saveState()
+      append(`${SEP}${stamp()}  [PMO ${on ? '启动' : '停止'}] session=${sid.slice(0, 12)}…\n`)
+      if (on && sid !== 'unknown') {
+        const agents = ctx.get('agents')
+        const agent = agents && typeof agents.get === 'function' ? agents.get(sid) : undefined
+        if (!agents || !agent) {
+          append(`${stamp()}  [子代理] 无法启动：当前会话无活跃 Agent（agents=${agents ? '有' : '无'}）\n`)
+        } else {
+          ensureChildAndGreet(sid, agent).catch((err) => {
+            const msg = err && err.message ? err.message : String(err)
+            const stack = err && err.stack ? err.stack.split('\n').slice(0, 3).join(' | ') : ''
+            let provs = '?'
+            try {
+              const s = ctx.get('subagents')
+              provs = s && typeof s.list === 'function' ? s.list().join(',') : 'list不可用'
+            } catch { /* ignore */ }
+            append(`${stamp()}  [子代理] 失败: ${msg}；可用提供方=[${provs}] 已尝试=${config.provider}；栈顶: ${stack}\n`)
+          })
+        }
+      }
+      return json({ ok: true, sessionId: sid, enabled: on, turns: turnCounts.get(sid) ?? 0, child: children.get(sid) ?? null })
+    }
+    return json({ ok: false, error: 'not found' }, 404)
+  }
+
+  const webServer = ctx.get('webServer')
+  if (webServer) {
+    ctx.effect(() => webServer.register({ kind: 'prefix', path: '/pmo-button', resource: handle }), 'pmo-button: routes')
+  } else {
+    logger.warn?.('pmo-button: webServer absent — Client 将无法同步开关状态')
+  }
+}

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "PMO button",
+    "description": "A red start/stop button beside the composer submit action; state follows the Session. While enabled, every turn end (each loop round) and goal pause/completion is read back from the session log — this turn's tasks and the final handoff — and appended to a log file."
+  }
+}

package/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "PMO 按钮",
+    "description": "在输入框发送键旁添加红色启停按钮，状态跟随会话。开启后：本会话每次轮次结束（含 loop 每一轮）与目标暂停/完成时，从会话日志读出本轮任务与最终交代，追加写入日志文件。"
+  }
+}

package/package.json

@@ -1,6 +1,52 @@
 {
   "name": "@suifei/dsh-pmo-button",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.7.1",
+  "description": "PMO 审查循环按钮 for DeepSeek Harness — 持久审查子代理 + 轮次转发 + STATUS 协议（CONTINUE/DONE/NEED_HUMAN）自动循环推进",
+  "keywords": [
+    "deepseek-harness", "dsh", "dsh-plugin", "pmo", "code-review",
+    "subagent", "review-loop", "cordis", "审查", "自动循环"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/suifei/dsh-pmo-button.git"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./client": "./client.js",
+    "./locale/*.json": "./locale/*.json",
+    "./icon": "./icon.svg"
+  },
+  "files": [
+    "index.js",
+    "client.js",
+    "cordis.patch.yml",
+    "locale/en.json",
+    "locale/zh.json",
+    "icon.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "test": "node --check index.js && node --check client.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-llm": "0.2.2-rc.1",
+    "@deepseek-ai/schemastery": "~3.19.0"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "~4.1.0"
+  },
+  "dsh": {
+    "bundle": { "patch": "./cordis.patch.yml" },
+    "client": {
+      "platform": "web",
+      "immediately": true,
+      "inject": ["@deepseek-ai/dsh-client-ui-conversation"]
+    }
+  }
+}