dsh-syn-config 0.7.2 → 0.8.1

package/README.md

@@ -2,7 +2,7 @@
 
 跨电脑同步 DSH 配置（技能 / profile 设置 / AGENTS.md）的 DeepSeek Harness 插件，**macOS 与 Windows 同一份代码**。
 
-> 状态：**P6（隐私加固）**。六个工具 + 一个斜杠命令 + 一个状态卡 + 随包技能：
+> 状态：**P7（交互）**。六个工具 + 一个斜杠命令 + 一枚状态灯与它的面板 + 随包技能：
 > - `dsh_sync_status`：仓库分支 / 上游 / 领先落后 / 脏文件数（默认不联网）。
 > - `dsh_sync_doctor`：`doctor.sh` 的 Node 移植，六节体检，退出码 0-2-1 与脚本一致。
 > - `dsh_sync_pull`：`git pull --ff-only` + 镜像 skills / agents-skills / weekly；**默认 dry-run**。
@@ -14,9 +14,12 @@
 > 引导（新机第一条命令）仍由 `dsh-config/scripts/apply.sh` 负责——插件装不上时它不在。
 >
 > `/syn-dsh status|doctor|pull|push|secrets`：斜杠命令，宿主半执行、不进模型消息；`/syn-dsh push now` 才真推。
-> 输入框上方的状态圆点：绿=已同步、黄=有漂移（↑领先/↓落后/±脏）、红=不可用；点一下刷新。
+> 输入框上方的状态圆点：绿=已同步、黄=有漂移（↑领先/↓落后/±脏）、红=不可用。
+> 点它打开面板：顶部是体检结论（阻塞/警告数），下面四个动作——**体检 / 拉取计划 / 推送计划 / 密钥扫描**——都是对只读路由的 `GET`，面板只能看、不能写；每个结果旁边有「复制命令」，真正的写操作仍要 `/syn-dsh … now`。
 > `syn-dsh` 技能由插件自带（`assets/syn-dsh.md`，rank 600），不再放在配置仓库里。
 >
+> **密钥只由人注入。** 工具与斜杠命令都拒绝写 `inject`/`refresh`：`/syn-dsh secrets` 只放 `scan`/`fingerprint`，`dsh_sync_secrets` 在 `dry_run:false` 时直接拒绝，并提示自己执行 `bash ~/dsh-config/scripts/apply.sh --yes`。确需让工具代写，本机在插件行加 `allowSecretInject: true`（默认关闭）。
+>
 > 设计理由与后续阶段见主仓库的调研文档：`../research/syn-dsh-plugin/PLAN.md`。
 
 ## 为什么是插件，而不是又一层 shell

package/assets/syn-dsh.md

@@ -221,3 +221,13 @@ cd ~/dsh-config && bash scripts/cross-platform-selftest.sh
 2. **变化**：改动的技能名（超过 10 个只列前 10 + 共几个）；是否动了配置/插件
 3. **生效**：新开会话（技能）/ 重启客户端（插件）
 4. **待办**：缺密钥、冲突未合、推送失败等
+
+## 密钥注入只由人执行
+
+`/syn-dsh secrets` 只支持 `scan` / `fingerprint`（只读）。`inject` / `refresh` 会写真实密钥进已部署配置，**只能由人执行**：
+
+```bash
+bash ~/dsh-config/scripts/apply.sh --yes     # 从 ~/.dsh/secrets.env 注入
+```
+
+要让模型工具代写，需在本机插件行显式加 `allowSecretInject: true`（默认关闭）。

package/client/client.js

@@ -1,10 +1,12 @@
 /**
- * Browser half: one compact chip in the composer dock.
+ * Browser half: a status chip in the composer dock, and a small panel behind it.
  *
- * It reads the host route registered by `lib/core/http.js` — no websocket, no
- * shared state, no second data channel to keep consistent. The chip is
- * deliberately small: a dot whose colour encodes "clean / drift / error", the
- * branch, and the ahead/behind counts. Clicking it re-fetches.
+ * The chip answers "am I in sync?". The panel answers "what should I do next?"
+ * without leaving the input box: one health check, the dry-run plan of a pull
+ * and of a push, and a secret scan. Every one of those is a `GET` on a
+ * read-only route — the panel can *look*, never write. Anything that mutates
+ * still goes through `/syn-dsh … now`, which is the only path that writes, and
+ * the panel gives you that command on one click (copy).
  *
  * Plain JavaScript, no build step: the module table supplies React.
  */
@@ -14,7 +16,25 @@ window.__ModuleLoader__.load({
   factory(require) {
     const React = require('react')
     const h = React.createElement
-    const STATUS_URL = '/plugins/dsh-syn-config/status'
+    const BASE = '/plugins/dsh-syn-config'
+    const STATUS_URL = `${BASE}/status`
+    const DOCTOR_URL = `${BASE}/doctor`
+    const PLAN_URL = `${BASE}/plan`
+    const SECRETS_URL = `${BASE}/secrets`
+
+    /** The four things the panel can look at, and the command that acts on it. */
+    const ACTIONS = [
+      { id: 'doctor', label: '体检', url: DOCTOR_URL, command: '/syn-dsh doctor' },
+      { id: 'pull', label: '拉取计划', url: `${PLAN_URL}?action=pull`, command: '/syn-dsh pull now' },
+      { id: 'push', label: '推送计划', url: `${PLAN_URL}?action=push`, command: '/syn-dsh push now' },
+      { id: 'secrets', label: '密钥扫描', url: SECRETS_URL, command: '/syn-dsh secrets scan' },
+    ]
+
+    async function getJson(url, signal) {
+      const response = await fetch(url, { signal, headers: { accept: 'application/json' } })
+      if (!response.ok) throw new Error(`HTTP ${response.status}`)
+      return response.json()
+    }
 
     /** Fetch the host status once; abort on unmount. */
     function useStatus() {
@@ -23,8 +43,7 @@ window.__ModuleLoader__.load({
       React.useEffect(() => {
         const controller = new AbortController()
         let alive = true
-        fetch(STATUS_URL, { signal: controller.signal, headers: { accept: 'application/json' } })
-          .then((response) => (response.ok ? response.json() : Promise.reject(new Error(`HTTP ${response.status}`))))
+        getJson(STATUS_URL, controller.signal)
           .then((body) => {
             if (alive) setState({ phase: 'ready', body })
           })
@@ -59,38 +78,201 @@ window.__ModuleLoader__.load({
       return { color: '#51b976', label: `${body.branch || 'HEAD'} 已同步` }
     }
 
+    /** Turn a payload into a few short lines — the panel is not a report. */
+    function describeResult(action, body) {
+      if (body?.ok === false && typeof body.error === 'string') return `失败：${body.error}`
+      if (action === 'doctor') {
+        const head = `体检：${body.fail} 阻塞 / ${body.warn} 警告`
+        const rows = (body.sections ?? []).map((section) => {
+          const mark = section.blocking > 0 ? '❌' : section.status === 'warn' ? '⚠️' : '✅'
+          return `${mark} ${section.title}${section.summary === '' ? '' : ` — ${section.summary}`}`
+        })
+        return [head, ...rows].join('\n')
+      }
+      if (action === 'pull') {
+        const mirrors = (body.mirrors ?? []).map((m) => `${m.name} +${m.added} ~${m.updated} -${m.deleted}`).join(' · ')
+        return [`远端提交：${body.incomingCommits ?? 0}`, `${String(body.before ?? '').slice(0, 7)} → ${String(body.after ?? '').slice(0, 7)}`, mirrors].filter(Boolean).join('\n')
+      }
+      if (action === 'push') {
+        const c = body.changes ?? {}
+        return [
+          `变更：+${c.added ?? 0} ~${c.updated ?? 0} -${c.deleted ?? 0} · 技能 ${body.skills ?? 0}`,
+          `门禁：lint ${body.gates?.lint ? '✅' : '❌'} · redact ${body.gates?.redacted ?? 0} · scan ${body.gates?.scan ? '✅' : '❌'}`,
+          body.commit?.created ? `提交：${body.commit.created}` : body.commit?.unchanged ? '无变更可提交' : 'dry run：未写入',
+        ].join('\n')
+      }
+      return `明文命中：${body.hits ?? 0}`
+    }
+
+    const panelStyle = {
+      position: 'absolute',
+      bottom: 'calc(100% + 8px)',
+      left: 0,
+      zIndex: 40,
+      width: '360px',
+      maxWidth: '80vw',
+      padding: '10px',
+      borderRadius: '10px',
+      border: '0.5px solid var(--dsw-alias-border-l2, #494949)',
+      background: 'var(--dsw-alias-bg-layer-1, #1f1f1f)',
+      boxShadow: '0 8px 24px rgba(0,0,0,0.35)',
+      color: 'var(--dsw-alias-label-primary, #e6e6e6)',
+      fontSize: '12px',
+      lineHeight: '18px',
+    }
+
+    const tabStyle = {
+      padding: '3px 8px',
+      fontSize: '12px',
+      borderRadius: '6px',
+      border: '0.5px solid var(--dsw-alias-border-l2, #494949)',
+      background: 'transparent',
+      color: 'inherit',
+      cursor: 'pointer',
+    }
+
+    function ResultBox({ text, command }) {
+      const [copied, setCopied] = React.useState(false)
+      const copy = async () => {
+        try {
+          await navigator.clipboard.writeText(command)
+          setCopied(true)
+          setTimeout(() => setCopied(false), 1500)
+        } catch {
+          setCopied(false)
+        }
+      }
+      return h('div', { style: { marginTop: '8px' } },
+        h('pre', {
+          style: {
+            margin: 0,
+            padding: '6px 8px',
+            maxHeight: '180px',
+            overflow: 'auto',
+            whiteSpace: 'pre-wrap',
+            wordBreak: 'break-word',
+            fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
+            fontSize: '11px',
+            lineHeight: '16px',
+            background: 'rgba(255,255,255,0.04)',
+            borderRadius: '6px',
+          },
+        }, text),
+        h('div', { style: { display: 'flex', gap: '6px', marginTop: '6px', alignItems: 'center' } },
+          h('button', { type: 'button', onClick: copy, style: tabStyle }, copied ? '已复制' : '复制命令'),
+          h('code', { style: { fontSize: '11px', opacity: 0.75 } }, command),
+        ),
+      )
+    }
+
     function StatusChip() {
       const [state, refresh] = useStatus()
+      const [open, setOpen] = React.useState(false)
+      const [panel, setPanel] = React.useState({ action: '', text: '点一个动作看看现在该做什么', loading: false })
+      const [doctor, setDoctor] = React.useState(null)
+      const boxRef = React.useRef(null)
       const { color, label } = describe(state)
+
+      // Health is the number that decides "should I act today?", so it is
+      // fetched when the panel opens rather than on every render.
+      React.useEffect(() => {
+        if (!open) return undefined
+        const controller = new AbortController()
+        getJson(DOCTOR_URL, controller.signal)
+          .then((body) => setDoctor(body))
+          .catch(() => setDoctor(null))
+        const onKey = (event) => {
+          if (event.key === 'Escape') setOpen(false)
+        }
+        const onClick = (event) => {
+          if (boxRef.current !== null && !boxRef.current.contains(event.target)) setOpen(false)
+        }
+        window.addEventListener('keydown', onKey)
+        window.addEventListener('mousedown', onClick)
+        return () => {
+          controller.abort()
+          window.removeEventListener('keydown', onKey)
+          window.removeEventListener('mousedown', onClick)
+        }
+      }, [open])
+
+      const run = async (action) => {
+        setPanel({ action: action.id, text: '读取中…', loading: true })
+        const controller = new AbortController()
+        try {
+          const body = await getJson(action.url, controller.signal)
+          setPanel({ action: action.id, text: describeResult(action.id, body), loading: false })
+        } catch (error) {
+          setPanel({ action: action.id, text: `读取失败：${String(error?.message ?? error)}`, loading: false })
+        }
+      }
+
+      const health = doctor === null
+        ? null
+        : doctor.fail > 0
+          ? `体检 ${doctor.fail} 阻塞`
+          : doctor.warn > 0 ? `体检 ${doctor.warn} 警告` : '体检通过'
+      const active = ACTIONS.find((action) => action.id === panel.action)
+
       const title = state.phase === 'ready'
-        ? `${state.body.repoPath ?? ''}\n${label}\n点击刷新`
+        ? `${state.body.repoPath ?? ''}\n${label}\n点击查看可做的动作`
         : state.phase === 'error'
           ? '状态接口在本组合不可用；用 /syn-dsh status 查看'
           : label
-      return h('button', {
-        type: 'button',
-        onClick: refresh,
-        title,
-        style: {
-          display: 'inline-flex',
-          alignItems: 'center',
-          gap: '6px',
-          padding: '3px 9px',
-          font: 'inherit',
-          fontSize: '12px',
-          lineHeight: '16px',
-          color: 'var(--dsw-alias-label-secondary, #b9b9b9)',
-          background: 'transparent',
-          border: '0.5px solid var(--dsw-alias-border-l2, #494949)',
-          borderRadius: '999px',
-          cursor: 'pointer',
+
+      return h('div', { ref: boxRef, style: { position: 'relative', display: 'inline-block' } },
+        h('button', {
+          type: 'button',
+          onClick: () => {
+            setOpen((value) => !value)
+            refresh()
+          },
+          title,
+          style: {
+            display: 'inline-flex',
+            alignItems: 'center',
+            gap: '6px',
+            padding: '3px 9px',
+            font: 'inherit',
+            fontSize: '12px',
+            lineHeight: '16px',
+            color: 'var(--dsw-alias-label-secondary, #b9b9b9)',
+            background: 'transparent',
+            border: '0.5px solid var(--dsw-alias-border-l2, #494949)',
+            borderRadius: '999px',
+            cursor: 'pointer',
+          },
         },
-      },
-        h('span', {
-          'aria-hidden': true,
-          style: { width: '7px', height: '7px', borderRadius: '50%', background: color, display: 'inline-block' },
-        }),
-        h('span', null, label),
+          h('span', {
+            'aria-hidden': true,
+            style: { width: '7px', height: '7px', borderRadius: '50%', background: color, display: 'inline-block' },
+          }),
+          h('span', null, label),
+          health === null ? null : h('span', { style: { opacity: 0.7 } }, `· ${health}`),
+        ),
+        open ? h('div', { style: panelStyle },
+          h('div', { style: { display: 'flex', justifyContent: 'space-between', alignItems: 'baseline', gap: '8px' } },
+            h('strong', { style: { fontSize: '12px' } }, 'DSH 配置同步'),
+            h('code', { style: { fontSize: '10px', opacity: 0.6 } }, state.phase === 'ready' ? (state.body.branch || 'HEAD') : '—'),
+          ),
+          state.phase === 'ready'
+            ? h('div', { style: { opacity: 0.75, marginTop: '2px', wordBreak: 'break-all' } }, state.body.repoPath ?? '')
+            : null,
+          h('div', { style: { display: 'flex', flexWrap: 'wrap', gap: '6px', marginTop: '8px' } },
+            ...ACTIONS.map((action) => h('button', {
+              key: action.id,
+              type: 'button',
+              onClick: () => run(action),
+              style: {
+                ...tabStyle,
+                borderColor: panel.action === action.id ? 'var(--dsw-alias-brand-primary, #4f8cff)' : tabStyle.borderColor,
+              },
+            }, action.label)),
+          ),
+          h(ResultBox, { text: panel.text, command: active === undefined ? '/syn-dsh status' : active.command }),
+          h('div', { style: { marginTop: '6px', opacity: 0.6, fontSize: '11px' } },
+            '面板只读；真正的写操作要用上面的命令加 now。'),
+        ) : null,
       )
     }
 

package/docs/RELEASE.md

@@ -93,3 +93,16 @@ icon: https://raw.githubusercontent.com/Dreamaniax/dsh-syn-config/main/assets/ic
 - **历史扫描不再因体积失败**：单次 diff 超过缓冲时，自动收窄到 `profiles/ scripts/ AGENTS.md weekly/` 重试。
 - **定时任务标签**：不再硬编码个人反域名——读 `DSH_WEEKLY_LAUNCHD_LABEL` / `learning/schedule.env`，都没有就按 `*.dsh.weekly-retro` 后缀匹配。
 - 复检结果：`publish-check` 0 命中；`dsh_sync_doctor` 0 阻塞、2 警告（都是本机与仓库的正常漂移）。
+
+## 8. 只读路由与面板（0.8.0）
+
+浏览器这一半只读，所有写操作仍走 `/syn-dsh … now`：
+
+| 路由 | 回答 | 缓存 |
+| --- | --- | --- |
+| `GET /plugins/dsh-syn-config/status` | 分支 / 上游 / ahead / behind / dirty | 不缓存 |
+| `GET /plugins/dsh-syn-config/doctor` | 六节体检的计数与最差一条 | 60 s |
+| `GET /plugins/dsh-syn-config/secrets` | 明文命中数与掩码样本 | 60 s |
+| `GET /plugins/dsh-syn-config/plan?action=pull|push` | dry-run 的变更计数（不是 diff 正文） | 60 s |
+
+服务端只放行 `GET`/`HEAD`，所以任何跨站请求都写不了东西；每个载荷都不含文件名与密钥值。面板的四个按钮（体检 / 拉取计划 / 推送计划 / 密钥扫描）就是这四条路由，结果旁有「复制命令」——真正的写操作仍是 `/syn-dsh pull now` / `push now`。

package/lib/core/commands.js

@@ -20,24 +20,82 @@ import { pushRepo } from './push.js'
 import { runSecretsAction } from './secrets-ops.js'
 import { readRepoStatus } from './status.js'
 
-/** One-line status summary. */
+/** Status icons: the command output is Markdown, so the scan is visual. */
+const ICON = { ok: '✅', warn: '⚠️', error: '❌', skip: '➖' }
+
+/** Escape a cell so a path or a message cannot break the table. */
+function cell(value) {
+  return String(value ?? '').replace(/\|/gu, '\\|').replace(/\r?\n/gu, ' ').trim()
+}
+
+/**
+ * Status as a two-column table.
+ *
+ * A slash command's output is Markdown, and a table reads faster than a line
+ * with five separators in it — the card and the command then agree at a glance.
+ */
 function formatStatus(status) {
-  if (!status.repoPresent) return `${status.repoPath}: no repository found`
-  if (!status.ok) return `${status.repoPath}: ${status.notes[0] ?? 'cannot read status'}`
-  const tracking = status.upstream === '' ? 'no upstream' : `${status.ahead} ahead / ${status.behind} behind ${status.upstream}`
-  const tree = status.dirty === 0 ? 'clean worktree' : `${status.dirty} changed file(s)`
-  return `${status.branch || '(detached)'} · ${tracking} · ${tree}`
+  if (!status.repoPresent) return `**${cell(status.repoPath)}**: no repository found`
+  if (!status.ok) {
+    return `**${cell(status.repoPath)}**\n\n| 项 | 值 |\n| --- | --- |\n| 状态 | ${ICON.error} 无法读取 |\n| 原因 | ${cell(status.notes[0] ?? 'unknown')} |`
+  }
+  const tracking = status.upstream === '' ? 'no upstream' : cell(status.upstream)
+  return [
+    '| 项 | 值 |',
+    '| --- | --- |',
+    `| 仓库 | \`${cell(status.repoPath)}\` |`,
+    `| 分支 | ${cell(status.branch) || '(detached)'} |`,
+    `| 上游 | ${tracking} |`,
+    `| 领先 / 落后 | ${status.ahead} / ${status.behind} |`,
+    `| 工作树 | ${status.dirty === 0 ? `${ICON.ok} clean worktree` : `${ICON.warn} ${status.dirty} changed file(s)`} |`,
+  ].join('\n')
 }
 
-/** Doctor summary: one line per section, only the worst finding. */
+/**
+ * Doctor as a table: one row per section, the worst finding in the last column.
+ *
+ * The blocking line stays above the table because it is the number that decides
+ * whether anything else is worth reading.
+ */
 function formatDoctor(result) {
-  const lines = [`health: ${result.fail} blocking / ${result.warn} warnings · exit ${result.exitCode}`]
-  for (const section of result.sections) {
+  const head = result.fail === 0
+    ? `${ICON.ok} health: 0 blocking / ${result.warn} warnings · exit ${result.exitCode}`
+    : `${ICON.error} health: ${result.fail} blocking / ${result.warn} warnings · exit ${result.exitCode}`
+  const rows = result.sections.map((section, index) => {
     const finding = section.items.find((entry) => entry.level === 'error')
       ?? section.items.find((entry) => entry.level === 'warn')
-    lines.push(`${section.status.toUpperCase().padEnd(5)} ${section.title}${finding === undefined ? '' : ` — ${finding.text.trim()}`}`)
+    const icon = ICON[section.status] ?? section.status
+    return `| ${index + 1} | ${cell(section.title)} | ${icon} ${cell(section.status)} | ${cell(finding?.text ?? '')} |`
+  })
+  return [
+    head,
+    '',
+    '| # | 检查 | 状态 | 最差一处 |',
+    '| --- | --- | --- | --- |',
+    ...rows,
+  ].join('\n')
+}
+
+/** A dry-run plan as a table, so "what would change" is scannable. */
+function formatPlan(action, result) {
+  if (action === 'pull') {
+    const mirrors = result.mirrors.map((mirror) => `${cell(mirror.name)} +${mirror.planned.added.length} ~${mirror.planned.updated.length} -${mirror.planned.deleted.length}`).join('<br>')
+    const rows = [
+      ['远端提交', `${result.incomingCommits}`],
+      ['before → after', `${cell(result.before).slice(0, 7)} → ${cell(result.after).slice(0, 7)}`],
+      ['镜像变更', mirrors || '(none)'],
+    ]
+    if (result.warnings.length > 0) rows.push(['注意', result.warnings.map(cell).join('<br>')])
+    return ['| 项 | 值 |', '| --- | --- |', ...rows.map(([key, value]) => `| ${key} | ${value} |`)].join('\n')
   }
-  return lines.join('\n')
+  const rows = [
+    ['变更', `+${result.changes.added.length} ~${result.changes.updated.length} -${result.changes.deleted.length}`],
+    ['技能数', `${result.manifest.skills}`],
+    ['门禁', `lint ${result.gates.lint.ok ? ICON.ok : ICON.error} · redact ${result.gates.redact.changed.length} · scan ${result.gates.scan.ok ? ICON.ok : ICON.error}`],
+    ['提交', result.commit.created ? `created ${cell(result.commit.sha)}` : result.commit.unchanged ? '无变更可提交' : 'dry run：未写入'],
+  ]
+  if (result.warnings.length > 0) rows.push(['注意', result.warnings.slice(0, 5).map(cell).join('<br>')])
+  return ['| 项 | 值 |', '| --- | --- |', ...rows.map(([key, value]) => `| ${key} | ${value} |`)].join('\n')
 }
 
 /**
@@ -86,14 +144,11 @@ export function registerCommands(ctx, settings) {
             dryRun: !real,
             timeoutMs: settings.gitTimeoutMs,
           })
-          const mirrors = result.mirrors
-            .map((mirror) => `${mirror.name} +${mirror.planned.added.length} ~${mirror.planned.updated.length} -${mirror.planned.deleted.length}`)
-            .join(' · ')
+          const table = formatPlan('pull', result)
           const head = real
-            ? `${result.pulled ? 'pulled' : 'already up to date'} ${result.before.slice(0, 7)} → ${result.after.slice(0, 7)}`
-            : `dry run: ${result.incomingCommits} incoming commit(s)`
-          const warnings = result.warnings.length === 0 ? '' : `\n${result.warnings.join('\n')}`
-          return { kind: result.ok ? 'success' : 'error', text: `${head}\n${mirrors}${warnings}` }
+            ? `**${result.pulled ? 'pulled' : 'already up to date'}** ${result.before.slice(0, 7)} → ${result.after.slice(0, 7)}`
+            : `**dry run** — ${result.incomingCommits} incoming commit(s)`
+          return { kind: result.ok ? 'success' : 'error', text: `${head}\n\n${table}${real ? '' : '\n\n要执行就加 `now`：`/syn-dsh pull now`'}` }
         }
 
         if (subcommand === 'push') {
@@ -105,20 +160,28 @@ export function registerCommands(ctx, settings) {
             dryRun: !real,
             timeoutMs: settings.gitTimeoutMs,
           })
-          const gates = `lint ${result.gates.lint.ok ? 'ok' : 'FAIL'} · redact ${result.gates.redact.changed.length} · scan ${result.gates.scan.ok ? 'ok' : 'FAIL'}`
-          const summary = result.commit.created
-            ? `commit ${result.commit.sha}${result.commit.pushed ? ' pushed' : ' NOT pushed'}`
-            : result.commit.unchanged ? 'no changes to commit' : (real ? 'not committed' : 'dry run: nothing written')
-          const warnings = result.warnings.length === 0 ? '' : `\n${result.warnings.slice(0, 5).join('\n')}`
+          const table = formatPlan('push', result)
+          const head = real
+            ? `**${result.commit.created ? `committed ${result.commit.sha}` : 'nothing to commit'}**${result.commit.pushed ? ' · pushed' : ''}`
+            : '**dry run** — nothing written'
           return {
             kind: result.ok ? 'success' : 'error',
-            text: `changes +${result.changes.added.length} ~${result.changes.updated.length} -${result.changes.deleted.length} · skills ${result.manifest.skills}\n${gates}\n${summary}${warnings}`,
+            text: `${head}\n\n${table}${real ? '' : '\n\n要执行就加 `now`：`/syn-dsh push now`'}`,
           }
         }
 
         if (subcommand === 'secrets') {
           const action = (tokens[1] ?? 'scan').toLowerCase()
-          const readOnly = action === 'scan' || action === 'fingerprint'
+          // The slash command cannot inject: writing a real value into the live
+          // configuration stays a human action (`apply.sh`), so a command that
+          // is easy to type cannot be the thing that leaks a key.
+          if (action !== 'scan' && action !== 'fingerprint') {
+            return {
+              kind: 'error',
+              text: `secrets ${action}: 只读命令只支持 scan / fingerprint；注入真值请自己执行 \`bash ~/dsh-config/scripts/apply.sh --yes\``,
+            }
+          }
+          const readOnly = true
           const result = await runSecretsAction({
             action,
             repoPath,
@@ -143,4 +206,4 @@ export function registerCommands(ctx, settings) {
 }
 
 /** Re-exported for callers that only need the formatter. */
-export { formatDoctor, formatStatus }
+export { formatDoctor, formatPlan, formatStatus }

package/lib/core/http.js

@@ -1,22 +1,37 @@
 /**
- * The one HTTP route the status card reads.
+ * The read-only HTTP surface the status chip (and its panel) reads.
  *
- * `ctx.webServer.register({ resource })` maps a Fetch `Request` to a
- * `Response`; the server only lets `GET`/`HEAD` through, so one function is
- * all that is needed. The payload is the same read-only status the model tool
- * returns minus every secret: branch, upstream, ahead/behind, dirty count and
- * the file names (which are configuration paths, not secrets).
+ * Three GET routes, one shape of answer each. They exist so a browser card can
+ * show state without calling a model: `ctx.webServer.register({ resource })`
+ * maps a Fetch `Request` to a `Response`, and the server only lets `GET`/`HEAD`
+ * through — which is the safety property this whole surface relies on. No
+ * route here can write, so no cross-site request can either.
  *
- * The route answers only on the loopback-bound GUI server and sets
- * `Cache-Control: no-store`, so a stale card cannot outlive a real state
- * change.
+ * - `/status` branch, upstream, ahead/behind, dirty count
+ * - `/doctor` the six-section health check, cached for a minute: it spawns git
+ *   and reads the filesystem, and a card does not need second-level freshness
+ * - `/plan?action=pull|push` the dry-run plan of a real operation: the same
+ *   computation `pull now` / `push now` would do, with nothing written
+ *
+ * Every payload is the read-only projection of the tool result minus every
+ * secret and minus file names (a config file name can itself be sensitive).
  *
  * @module dsh-syn-config/core/http
  */
 
+import { runDoctor } from './doctor.js'
+import { pullRepo } from './pull.js'
+import { pushRepo } from './push.js'
+import { runSecretsAction } from './secrets-ops.js'
 import { readRepoStatus } from './status.js'
 
 export const STATUS_PATH = '/plugins/dsh-syn-config/status'
+export const DOCTOR_PATH = '/plugins/dsh-syn-config/doctor'
+export const PLAN_PATH = '/plugins/dsh-syn-config/plan'
+export const SECRETS_PATH = '/plugins/dsh-syn-config/secrets'
+
+/** How long a doctor or plan answer may be reused. */
+const CACHE_MS = 60_000
 
 /** JSON response with no-store caching. */
 function json(body, status = 200) {
@@ -26,45 +41,237 @@ function json(body, status = 200) {
   })
 }
 
+/** Method gate shared by every route; the server also rejects writes upstream. */
+function methodAllowed(request) {
+  return request.method === 'GET' || request.method === 'HEAD'
+}
+
+/**
+ * Build the cached reader.
+ *
+ * A card that polls every few seconds must not spawn `git` every time: the
+ * doctor alone runs a handful of commands. The cache is per-route and holds
+ * the *projection*, so nothing secret lingers in memory longer than the answer.
+ *
+ * @param {() => Promise<object>} read
+ * @param {number} ttlMs
+ */
+export function cached(read, ttlMs = CACHE_MS) {
+  let at = 0
+  let value
+  let inflight
+  return async () => {
+    const now = Date.now()
+    if (value !== undefined && now - at < ttlMs) return { body: value, cached: true }
+    if (inflight !== undefined) return { body: await inflight, cached: true }
+    inflight = read().then((body) => {
+      value = body
+      at = Date.now()
+      inflight = undefined
+      return body
+    }, (error) => {
+      inflight = undefined
+      throw error
+    })
+    return { body: await inflight, cached: false }
+  }
+}
+
+/** Project a doctor run down to what a card may see. */
+export function doctorPayload(result) {
+  return {
+    ok: result.fail === 0,
+    fail: result.fail,
+    warn: result.warn,
+    exitCode: result.exitCode,
+    profile: result.profile,
+    checkedAt: new Date().toISOString(),
+    sections: result.sections.map((section) => {
+      const blocking = section.items.filter((entry) => entry.level === 'error')
+      const warnings = section.items.filter((entry) => entry.level === 'warn')
+      const worst = blocking[0] ?? warnings[0]
+      return {
+        title: section.title,
+        status: section.status,
+        blocking: blocking.length,
+        warnings: warnings.length,
+        // The message text is already sanitised by the doctor: paths are
+        // shortened and secret values are masked.
+        summary: worst === undefined ? '' : String(worst.text).trim().slice(0, 160),
+      }
+    }),
+  }
+}
+
+/** Project a dry-run push/pull down to a plan a card may see. */
+export function planPayload(action, result) {
+  if (action === 'pull') {
+    return {
+      action,
+      ok: result.ok,
+      incomingCommits: result.incomingCommits,
+      before: String(result.before ?? '').slice(0, 12),
+      after: String(result.after ?? '').slice(0, 12),
+      mirrors: result.mirrors.map((mirror) => ({
+        name: mirror.name,
+        added: mirror.planned.added.length,
+        updated: mirror.planned.updated.length,
+        deleted: mirror.planned.deleted.length,
+      })),
+      warnings: result.warnings.slice(0, 5).map((line) => String(line).slice(0, 160)),
+      checkedAt: new Date().toISOString(),
+    }
+  }
+  return {
+    action,
+    ok: result.ok,
+    changes: {
+      added: result.changes.added.length,
+      updated: result.changes.updated.length,
+      deleted: result.changes.deleted.length,
+    },
+    gates: {
+      lint: result.gates.lint.ok,
+      redacted: result.gates.redact.changed.length,
+      scan: result.gates.scan.ok,
+    },
+    commit: { created: result.commit.created, unchanged: result.commit.unchanged === true },
+    skills: result.manifest.skills,
+    warnings: result.warnings.slice(0, 5).map((line) => String(line).slice(0, 160)),
+    checkedAt: new Date().toISOString(),
+  }
+}
+
 /**
- * Register the status route when the composition has a web server.
+ * Register every read-only route when the composition has a web server.
  *
  * @param {{ get?: (name: string) => unknown, webServer?: object }} ctx
- * @param {{ repoPath: string, gitTimeoutMs: number }} settings
+ * @param {{ repoPath: string, profile: string, dshHome?: string, gitTimeoutMs: number }} settings
+ * @returns {boolean} whether the routes were registered
  */
 export function registerStatusRoute(ctx, settings) {
   const server = ctx.webServer ?? (typeof ctx.get === 'function' ? ctx.get('webServer') : undefined)
   if (server === undefined || server === null || typeof server.register !== 'function') return false
 
-  server.register({
-    path: STATUS_PATH,
-    resource: async (request) => {
-      if (request.method !== 'GET' && request.method !== 'HEAD') {
-        return new Response('method not allowed', { status: 405, headers: { allow: 'GET, HEAD' } })
-      }
-      try {
-        const status = await readRepoStatus({
+  const readStatus = async () => {
+    const status = await readRepoStatus({
+      repoPath: settings.repoPath,
+      timeoutMs: settings.gitTimeoutMs,
+      fetch: false,
+    })
+    return {
+      ok: status.ok,
+      repoPath: status.repoPath,
+      repoPresent: status.repoPresent,
+      branch: status.branch,
+      upstream: status.upstream,
+      ahead: status.ahead,
+      behind: status.behind,
+      dirty: status.dirty,
+      checkedAt: new Date().toISOString(),
+    }
+  }
+
+  const readDoctor = cached(async () => doctorPayload(await runDoctor({
+    repoPath: settings.repoPath,
+    dshHome: settings.dshHome,
+    profile: settings.profile,
+    offline: true,
+    timeoutMs: settings.gitTimeoutMs,
+  })))
+
+  const readPlan = (action) => {
+    if (action !== 'pull' && action !== 'push') return undefined
+    return cached(async () => {
+      const result = action === 'pull'
+        ? await pullRepo({
           repoPath: settings.repoPath,
+          dshHome: settings.dshHome,
+          dryRun: true,
           timeoutMs: settings.gitTimeoutMs,
-          fetch: false,
         })
-        return json({
-          ok: status.ok,
-          repoPath: status.repoPath,
-          repoPresent: status.repoPresent,
-          branch: status.branch,
-          upstream: status.upstream,
-          ahead: status.ahead,
-          behind: status.behind,
-          dirty: status.dirty,
-          // File names stay out of the browser payload: any local process can
-          // read this route, and a config file name can itself be sensitive.
-          checkedAt: new Date().toISOString(),
+        : await pushRepo({
+          repoPath: settings.repoPath,
+          dshHome: settings.dshHome,
+          profile: settings.profile,
+          dryRun: true,
+          timeoutMs: settings.gitTimeoutMs,
         })
-      } catch (error) {
-        return json({ ok: false, error: String(error?.message ?? error) }, 500)
-      }
-    },
+      return planPayload(action, result)
+    })
+  }
+
+  const plans = { pull: readPlan('pull'), push: readPlan('push') }
+
+  // Read-only: a scan never mutates, and it returns counts plus masked previews.
+  const readSecrets = cached(async () => {
+    const result = await runSecretsAction({
+      action: 'scan',
+      repoPath: settings.repoPath,
+      dshHome: settings.dshHome,
+      profile: settings.profile,
+      dryRun: true,
+    })
+    return {
+      ok: result.ok,
+      hits: result.hits.length,
+      samples: result.hits.slice(0, 5).map((hit) => ({
+        file: String(hit.file).split('/').slice(-2).join('/'),
+        line: hit.line,
+        masked: String(hit.match).slice(0, 4) + '…',
+      })),
+      note: result.note ?? '',
+      checkedAt: new Date().toISOString(),
+    }
+  })
+
+  const route = (path, resource) => {
+    server.register({ path, resource })
+  }
+
+  route(STATUS_PATH, async (request) => {
+    if (!methodAllowed(request)) return new Response('method not allowed', { status: 405, headers: { allow: 'GET, HEAD' } })
+    try {
+      return json(await readStatus())
+    } catch (error) {
+      return json({ ok: false, error: String(error?.message ?? error) }, 500)
+    }
   })
+
+  route(DOCTOR_PATH, async (request) => {
+    if (!methodAllowed(request)) return new Response('method not allowed', { status: 405, headers: { allow: 'GET, HEAD' } })
+    try {
+      const answer = await readDoctor()
+      return json({ ...answer.body, cached: answer.cached })
+    } catch (error) {
+      return json({ ok: false, error: String(error?.message ?? error) }, 500)
+    }
+  })
+
+  route(SECRETS_PATH, async (request) => {
+    if (!methodAllowed(request)) return new Response('method not allowed', { status: 405, headers: { allow: 'GET, HEAD' } })
+    try {
+      const answer = await readSecrets()
+      return json({ ...answer.body, cached: answer.cached })
+    } catch (error) {
+      return json({ ok: false, error: String(error?.message ?? error) }, 500)
+    }
+  })
+
+  route(PLAN_PATH, async (request) => {
+    if (!methodAllowed(request)) return new Response('method not allowed', { status: 405, headers: { allow: 'GET, HEAD' } })
+    const action = new URL(request.url).searchParams.get('action') ?? ''
+    const reader = plans[action]
+    if (reader === undefined) {
+      return json({ ok: false, error: 'action must be pull or push' }, 400)
+    }
+    try {
+      const answer = await reader()
+      return json({ ...answer.body, cached: answer.cached })
+    } catch (error) {
+      return json({ ok: false, error: String(error?.message ?? error) }, 500)
+    }
+  })
+
   return true
 }

package/lib/index.js

@@ -172,7 +172,11 @@ export function resolveSettings(config = {}) {
   const dshHome = typeof config.dshHome === 'string' && config.dshHome.trim() !== ''
     ? config.dshHome.trim()
     : undefined
-  return { repoPath, gitTimeoutMs, fetchOnStatus: config.fetchOnStatus === true, profile, dshHome }
+  // Injecting a real secret into the live configuration is a human action.
+  // The model-callable tool refuses it unless this machine explicitly opts in,
+  // so an agent can never turn "sync my config" into "write my API key".
+  const allowSecretInject = config.allowSecretInject === true
+  return { repoPath, gitTimeoutMs, fetchOnStatus: config.fetchOnStatus === true, profile, dshHome, allowSecretInject }
 }
 
 /** Result shape of the health-check tool. */
@@ -519,7 +523,7 @@ function apply(ctx, config = {}) {
     if (skills === undefined || skills === null) throw new Error('skills service not provided')
     registerSkill({ skills })
   })
-  tryRegister('status route', ctx, () => {
+  tryRegister('http routes', ctx, () => {
     if (webServer === undefined || webServer === null) throw new Error('webServer service not provided')
     if (registerStatusRoute({ webServer }, settings) !== true) throw new Error('webServer.register is missing')
   })
@@ -741,13 +745,35 @@ function apply(ctx, config = {}) {
     async execute(args, exec) {
       const requested = typeof args?.repo === 'string' && args.repo.trim() !== '' ? args.repo.trim() : settings.repoPath
       const profile = typeof args?.profile === 'string' && args.profile.trim() !== '' ? args.profile.trim() : settings.profile
+      const action = String(args?.action ?? '')
+      const dryRun = typeof args?.dry_run === 'boolean' ? args.dry_run : true
+      // Human-only gate: `inject` and `refresh` write the real value into the
+      // deployed configuration. Refuse them from the tool unless the machine
+      // opted in, and say where the human path is.
+      if ((action === 'inject' || action === 'refresh') && dryRun === false && settings.allowSecretInject !== true) {
+        return {
+          action,
+          ok: false,
+          dryRun: false,
+          changed: [],
+          leftover: [],
+          hits: [],
+          fingerprints: [],
+          historyHits: [],
+          notes: [
+            'refused: secrets are injected by the human, not by the agent',
+            'run it yourself: `bash ~/dsh-config/scripts/apply.sh --yes`',
+            'or set `allowSecretInject: true` in this plugin row if you want the tool to do it',
+          ],
+        }
+      }
       try {
         const result = await runSecretsAction({
-          action: args?.action,
+          action,
           repoPath: requested,
           dshHome: settings.dshHome,
           profile,
-          dryRun: typeof args?.dry_run === 'boolean' ? args.dry_run : true,
+          dryRun,
           deep: args?.deep === true,
         })
         return { ...result, historyHits: result.historyHits ?? [] }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-syn-config",
-  "version": "0.7.2",
+  "version": "0.8.1",
   "private": false,
   "description": "Cross-platform (macOS + Windows) DeepSeek Harness plugin that syncs DSH config — skills, profile settings, AGENTS.md — with a private dsh-config repository.",
   "type": "module",