dsh-done-sound 0.1.3 → 0.1.5

package/README.md

@@ -9,6 +9,9 @@ DeepSeek Harness Web GUI 的「对话完成音效」插件：你在设置里选
 - **触发开关**：
   - `中断时也响`（默认**关**）：手动停止生成时是否也播放。
   - `出错时也响`（默认**开**）：对话以错误结束（turn-error / 超长截断）时是否也播放。
+- **确认等待提醒**：对话中出现等待确认 / 提问时播放提示音。
+- **出错自动重连**：对话报错后自动发送「继续」重试（可配置等待秒数）。
+- **版本检查**：设置卡片显示当前版本与更新状态。
 - 音频文件保存在 profile 目录 `.dsh-done-sound/`，经 Host 路由 `/dsh-done-sound/audio/<fileId>` 播放，配置持久化在设置中。
 
 ## 安装
@@ -27,14 +30,14 @@ dsh plugin --profile web add link:F:\0.AI-CodeProject\DSHProject\0.日常聊天\
 
 ## 架构
 
-- **Host 半区**（`src/index.js` → 构建产物 `lib/index.js`）：`dsh-done-sound` 设置作用域（`ctx.settings`）、音频文件存储、`webServer` 路由与同源 JSON API（`/dsh-done-sound/api/status|config|audio|clear`）、`dsh-done-sound` 命令。路由经 `ctx.inject(['webServer'], cb)` 延迟挂载；构建时用 esbuild 内联 `@deepseek-ai/schemastery`，产物自包含（link 安装时无需依赖 profile 的模块解析）。
-- **Client 半区**（`lib/client.js`）：`settings.section` 设置卡片（**fetch 调 HTTP API，不依赖会话/命令 RPC**）+ `conversation.session.header.utilities` 完成检测器（`useSession` 订阅 `ConversationSnapshot`，`partial/running → 空闲` 转移触发，按最后节点 seq 去重）。
+- **Host 半区**（`src/index.js` → 构建产物 `lib/index.js`）：`dsh-done-sound` 设置作用域（`ctx.settings`）、音频文件存储、`webServer` 路由与同源 JSON API（`/dsh-done-sound/api/status|config|audio|clear`）、`dsh-done-sound` 命令。路由经 `ctx.inject(['webServer'], cb)` 延迟挂载；构建时由 esbuild 内联 `@deepseek-ai/schemastery`，产物自包含（link 安装时无需依赖 profile 的模块解析）。
+- **Client 半区**（`lib/client.js`）：`settings.section` 设置卡片，以 fetch 调用 HTTP API，不依赖会话/命令 RPC；`conversation.session.header.utilities` 完成检测器（`useSession` 订阅 `ConversationSnapshot`，由 `partial/running → 空闲` 转移触发，按最后节点 `seq` 去重）。
 
 ## 开发
 
 ```sh
 pnpm install        # 安装 esbuild
-pnpm run build      # 打包 src/index.js -> lib/index.js（自包含）
+pnpm run build      # 打包 src/index.js -> lib/index.js（自带）
 pnpm run check      # 语法检查两个产物
 ```
 

package/lib/client.js

@@ -35,6 +35,16 @@ window.__ModuleLoader__.load({
       '.dtc-slider{flex:1;max-width:220px}',
       '.dtc-vol{min-width:44px;text-align:right;font-variant-numeric:tabular-nums}',
       '.dtc-toggle{display:flex;align-items:center;gap:6px;cursor:pointer}',
+      '.dtc-update{color:var(--dsw-alias-state-error-primary);font-weight:600}',
+      '.dtc-uptodate{color:var(--dsw-alias-state-success-primary)}',
+      '.dtc-num{width:72px;border:1px solid var(--dsw-alias-border-l2);color:var(--dsw-alias-label-primary);background:0 0;border-radius:6px;padding:2px 6px;font-size:12px;font-family:inherit}',
+      '.dtc-saved{color:var(--dsw-alias-state-success-primary);font-size:12px;white-space:nowrap}',
+      '@keyframes dtc-pulse{0%,100%{transform:scale(1);box-shadow:0 0 0 0 rgba(245,158,11,.5)}50%{transform:scale(1.06);box-shadow:0 0 0 8px rgba(245,158,11,0)}}',
+      '.dtc-retry-chip{display:inline-flex;align-items:center;gap:8px;border:2px solid #f59e0b;border-radius:999px;padding:7px 18px;font-size:15px;font-weight:700;color:#fff;background:linear-gradient(135deg,#f59e0b,#ea580c);white-space:nowrap;font-variant-numeric:tabular-nums;line-height:1.2;animation:dtc-pulse 1.2s ease-in-out infinite}',
+      '.dtc-retry-chip .dtc-retry-ico{font-size:17px;line-height:1}',
+      '.dtc-retry-chip .dtc-retry-num{font-size:19px;font-weight:800;margin-left:2px}',
+      '.dtc-cooldown-line{color:var(--dsw-alias-state-warn-primary,#f59e0b);font-weight:600}',
+      '.dtc-logpath{word-break:break-all;text-align:right;max-width:70%;line-height:1.4}',
     ].join('');
     if (typeof document !== 'undefined' && document.querySelector('style[data-plugin-css=' + JSON.stringify(CSS_ID) + ']') === null) {
       const tag = document.createElement('style');
@@ -62,7 +72,25 @@ window.__ModuleLoader__.load({
         errorHint: '对话以错误结束时也播放（默认开启）',
         pending: '等待确认时提醒',
         pendingHint: 'Agent 需要你确认操作（如审批）而停住等待时播放提醒（默认开启）',
-        saved: '已保存：',
+        autoRetry: '报错自动重连',
+        autoRetryHint: '模型重试耗尽、报错结束后自动发送「继续」恢复（默认开启）',
+        retryDelay: '自动重连等待（秒）',
+        retryDelayHint: '报错后等待多久再自动重连；期间恢复则取消（10-300 秒）',
+        confirm: '确定',
+        retrying: '自动重连',
+        retryChipTitle: '报错后自动重连等待中，期间恢复则自动取消',
+        secondsUnit: '秒',
+        retryCooldown: '自动重连冷却中：{s} 秒后可用',
+        retryArmed: '等待 {s} 秒后自动发送「继续」',
+        retrySent: '已自动发送「继续」',
+        retryFailed: '自动发送「继续」失败',
+        logPath: '日志文件',
+        version: '当前版本',
+        updateAvailable: '有新版本',
+        upToDate: '已是最新',
+        updateCheckFailed: '无法检查更新',
+        saved: '已保存 ✓',
+        saveMismatch: '保存未生效，当前值仍为 {v} 秒',
         readFailed: '读取文件失败',
         apiFailed: '无法连接插件服务（Host 未加载？），请重启 dsh web',
         noSession: '打开一个会话后配置',
@@ -91,7 +119,25 @@ window.__ModuleLoader__.load({
         errorHint: 'Also play when a turn ends in error (default on)',
         pending: 'Alert on approval wait',
         pendingHint: 'Play a reminder when the agent is waiting for your confirmation (default on)',
-        saved: 'Saved:',
+        autoRetry: 'Auto-retry on error',
+        autoRetryHint: 'After the model exhausts its retries and the turn ends in error, automatically send "continue" to resume (default on)',
+        retryDelay: 'Auto-retry wait (seconds)',
+        retryDelayHint: 'How long to wait before auto-retrying; cancelled if it recovers meanwhile (10-300s)',
+        confirm: 'OK',
+        retrying: 'Retry',
+        retryChipTitle: 'Auto-retrying after error; auto-cancelled if it recovers',
+        secondsUnit: 's',
+        retryCooldown: 'auto-retry cooling down: {s}s',
+        retryArmed: 'will auto-send "continue" in {s}s',
+        retrySent: 'auto-sent "continue"',
+        retryFailed: 'failed to auto-send "continue"',
+        logPath: 'Log file',
+        version: 'Version',
+        updateAvailable: 'Update available',
+        upToDate: 'Up to date',
+        updateCheckFailed: 'Update check failed',
+        saved: 'Saved ✓',
+        saveMismatch: 'Save did not take effect; current value is still {v}s',
         readFailed: 'Failed to read file',
         apiFailed: 'Cannot reach the plugin host service (host not loaded?), restart dsh web',
         noSession: 'Open a session to configure',
@@ -128,6 +174,15 @@ window.__ModuleLoader__.load({
         return '';
       }
     }
+    function compareVersions(a, b) {
+      const pa = String(a || '0').split('.').map((n) => parseInt(n, 10) || 0);
+      const pb = String(b || '0').split('.').map((n) => parseInt(n, 10) || 0);
+      for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const diff = (pa[i] || 0) - (pb[i] || 0);
+        if (diff !== 0) return diff > 0 ? 1 : -1;
+      }
+      return 0;
+    }
 
     // ---- tiny shared config store (card writes, detector reads) ----
     const configStore = {
@@ -137,6 +192,12 @@ window.__ModuleLoader__.load({
         playOnInterrupt: false,
         playOnError: true,
         playOnPending: true,
+        autoRetryOnError: true,
+        retryDelaySeconds: 60,
+        version: null,
+        latestVersion: null,
+        updateStatus: null, // 'update' | 'uptodate' | 'error' | null
+        retryCooldownUntil: null, // timestamp until which auto-retry is cooling down
         url: null,
         defaultUrl: null,
         fileName: '',
@@ -166,16 +227,144 @@ window.__ModuleLoader__.load({
       react.useEffect(() => subscribeConfig(setCfg), []);
       return cfg;
     }
+    // ---- browser -> host log reporting ----
+    // Mirrors console output into the host's daily log file
+    // (<pluginRoot>/logs/<YYYYMMDD>/dsh-done-sound.log) so issues survive a
+    // closed DevTools. Must never call console itself (avoids recursion) and
+    // must never break the plugin when the report fails.
+    function reportLog(level, args) {
+      try {
+        const parts = [];
+        for (let i = 0; i < args.length; i++) {
+          const a = args[i];
+          try {
+            if (typeof a === 'string') parts.push(a);
+            else if (a instanceof Error) parts.push(a.stack || 'Error: ' + (a.message || String(a)));
+            else parts.push(JSON.stringify(a));
+          } catch {
+            parts.push(String(a));
+          }
+        }
+        const message = parts.join(' ');
+        if (!message) return;
+        fetch('/dsh-done-sound/api/log', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ level: level, source: 'client', message: message }),
+        }).catch(() => {});
+      } catch {
+        // reporting must never break the plugin
+      }
+    }
+
     function playChime(cfg) {
       const url = cfg.url || cfg.defaultUrl;
       if (!cfg.enabled || !url) return;
       try {
         const audio = new Audio(url);
         audio.volume = cfg.volume;
-        audio.play().catch(() => {});
+        const p = audio.play();
+        if (p && typeof p.catch === 'function') {
+          p.catch((err) => {
+            try {
+              console.warn('[dsh-done-sound] audio play failed (browser blocked it?):', err && err.message ? err.message : err);
+              reportLog('warn', ['audio play failed (browser blocked it?):', err && err.message ? err.message : err]);
+            } catch {
+              // ignore
+            }
+          });
+        }
+      } catch (err) {
+        try {
+          console.warn('[dsh-done-sound] audio play failed:', err && err.message ? err.message : err);
+          reportLog('warn', ['audio play failed:', err && err.message ? err.message : err]);
+        } catch {
+          // ignore playback failures (autoplay policy, missing audio device)
+        }
+      }
+    }
+
+    // ---- module-level deferred auto-retry ----
+    // Lives outside the component so the "continue" still fires even if the
+    // user navigates away and the header (and its timers) unmount.
+    let pluginCtx = null;
+    const retryState = { armed: false, sessionId: null, endTurnAtError: 0, deadline: 0, timer: null };
+    function cancelModuleRetry() {
+      if (retryState.timer !== null) {
+        clearTimeout(retryState.timer);
+        retryState.timer = null;
+      }
+      retryState.armed = false;
+      retryState.sessionId = null;
+      retryState.endTurnAtError = 0;
+      retryState.deadline = 0;
+    }
+    function fireModuleRetry() {
+      retryState.timer = null;
+      if (!retryState.armed) return;
+      retryState.armed = false;
+      const sid = retryState.sessionId;
+      retryState.sessionId = null;
+      retryState.deadline = 0;
+      // Real send path: the browser→host RPC client (same route the composer's
+      // "send" uses). ctx.connection is provided by @deepseek-ai/dsh-client-connection;
+      // its api.sessions.prompt carries an RpcResponse whose `.result` is {ok} |
+      // {ok:false,error}. Failures are surfaced (console + settings-card row) —
+      // the old remote.sessions guess was silently skipped because no such
+      // namespace exists on the client context.
+      const prompt = pluginCtx && pluginCtx.connection && pluginCtx.connection.api && pluginCtx.connection.api.sessions
+        ? pluginCtx.connection.api.sessions.prompt
+        : null;
+      const fail = (why) => {
+        try {
+          console.error('[dsh-done-sound] auto-retry could not send "继续":', why);
+          reportLog('error', ['auto-retry could not send "继续":', why]);
+        } catch {
+          // console may be gone during teardown
+        }
+        setConfig({
+          retryCooldownUntil: null,
+          lastEvent: { at: Date.now(), kind: 'error', reason: 'error', play: false, retried: true, retryFailed: true },
+        });
+      };
+      if (typeof prompt !== 'function') {
+        fail('connection.api.sessions.prompt unavailable');
+        return;
+      }
+      let tz = 'UTC';
+      try {
+        tz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
       } catch {
-        // ignore playback failures (autoplay policy, missing audio device)
+        // keep UTC
       }
+      Promise.resolve(prompt({ sessionId: sid, mode: 'queue', content: [{ type: 'text', text: '继续' }], clientTimeZone: tz }))
+        .then((res) => {
+          const result = res && res.result;
+          if (result && result.ok) {
+            try {
+              console.log('[dsh-done-sound] auto-retry sent "继续" to session', sid);
+              reportLog('info', ['auto-retry sent "继续" to session', sid]);
+            } catch {
+              // ignore
+            }
+            setConfig({
+              retryCooldownUntil: null,
+              lastEvent: { at: Date.now(), kind: 'error', reason: 'error', play: false, retried: true, retryFailed: false },
+            });
+          } else {
+            const err = result && result.error ? result.error.message : JSON.stringify(result);
+            fail(err || 'prompt not accepted');
+          }
+        })
+        .catch((err) => fail(err && err.message ? err.message : String(err)));
+    }
+    function armModuleRetry(sessionId, endTurnAtError, delayMs) {
+      cancelModuleRetry();
+      retryState.armed = true;
+      retryState.sessionId = sessionId;
+      retryState.endTurnAtError = endTurnAtError;
+      retryState.deadline = Date.now() + delayMs;
+      retryState.timer = setTimeout(fireModuleRetry, delayMs);
     }
 
     // ---- same-origin JSON API transport (no session needed) ----
@@ -205,6 +394,7 @@ window.__ModuleLoader__.load({
     }
 
     function apply(ctx) {
+      pluginCtx = ctx;
       const syncConfig = (payload) => {
         if (!payload || typeof payload !== 'object') return;
         setConfig({
@@ -213,6 +403,10 @@ window.__ModuleLoader__.load({
           playOnInterrupt: payload.playOnInterrupt === true,
           playOnError: payload.playOnError !== false,
           playOnPending: payload.playOnPending !== false,
+          autoRetryOnError: payload.autoRetryOnError !== false,
+          retryDelaySeconds: typeof payload.retryDelaySeconds === 'number' ? payload.retryDelaySeconds : 60,
+          version: typeof payload.version === 'string' ? payload.version : null,
+          logPath: typeof payload.logPath === 'string' && payload.logPath ? payload.logPath : null,
           url: typeof payload.url === 'string' && payload.url ? payload.url : null,
           defaultUrl: typeof payload.defaultUrl === 'string' && payload.defaultUrl ? payload.defaultUrl : null,
           fileName: payload.audio && typeof payload.audio.fileName === 'string' ? payload.audio.fileName : '',
@@ -229,13 +423,59 @@ window.__ModuleLoader__.load({
         const [busy, setBusy] = react.useState(false);
         const [lang] = react.useState(resolveLang());
         const L = (key) => t(lang, key);
+        const [cardTick, setCardTick] = react.useState(Date.now());
+        react.useEffect(() => {
+          const timer = setInterval(() => setCardTick(Date.now()), 1000);
+          return () => clearInterval(timer);
+        }, []);
+        // Auto-retry delay: local draft while editing, committed on blur/Enter.
+        const delayDraftRef = react.useRef(null);
+        const [delayDraft, setDelayDraft] = react.useState(cfg.retryDelaySeconds || 60);
+        react.useEffect(() => {
+          if (delayDraftRef.current !== document.activeElement) {
+            setDelayDraft(cfg.retryDelaySeconds || 60);
+          }
+        }, [cfg.retryDelaySeconds]);
+        const commitDelay = async () => {
+          const v = Number(delayDraft);
+          if (!Number.isFinite(v)) {
+            setDelayDraft(cfg.retryDelaySeconds || 60);
+            return;
+          }
+          const rounded = Math.min(300, Math.max(10, Math.round(v / 5) * 5));
+          if (rounded !== Number(cfg.retryDelaySeconds)) {
+            setDelayDraft(String(rounded));
+            const payload = await run('/dsh-done-sound/api/config', { retryDelaySeconds: rounded });
+            if (!payload) return;
+            // Verify the host actually persisted it (a 200 alone is not proof).
+            if (payload.retryDelaySeconds !== rounded) {
+              setError(L('saveMismatch').replace('{v}', String(payload.retryDelaySeconds)));
+              return;
+            }
+          }
+          // Save feedback (also confirms the current value without changes).
+          setDelaySaved(true);
+          if (delaySavedTimer.current) clearTimeout(delaySavedTimer.current);
+          delaySavedTimer.current = setTimeout(() => setDelaySaved(false), 2000);
+        };
+        const [delaySaved, setDelaySaved] = react.useState(false);
+        const delaySavedTimer = react.useRef(null);
+        react.useEffect(
+          () => () => {
+            if (delaySavedTimer.current) clearTimeout(delaySavedTimer.current);
+          },
+          [],
+        );
 
         react.useEffect(() => {
           let disposed = false;
           (async () => {
             try {
               const payload = await api('/dsh-done-sound/api/status');
-              if (!disposed) syncConfig(payload);
+              if (!disposed) {
+                syncConfig(payload);
+                checkLatestVersion(typeof payload.version === 'string' ? payload.version : null);
+              }
             } catch (e) {
               if (!disposed) {
                 setError(L('apiFailed') + ' (' + (e && e.message ? e.message : String(e)) + ')');
@@ -248,6 +488,26 @@ window.__ModuleLoader__.load({
           };
         }, []);
 
+        // Query the npm registry for the latest published version and compare
+        // with the installed one (red if an update exists, green if up to date).
+        const checkLatestVersion = (currentVersion) => {
+          if (typeof currentVersion !== 'string' || currentVersion.length === 0) return;
+          fetch('https://registry.npmjs.org/dsh-done-sound/latest')
+            .then((res) => (res.ok ? res.json() : Promise.reject(new Error('http ' + res.status))))
+            .then((data) => {
+              const latest = data && typeof data.version === 'string' ? data.version : null;
+              if (latest === null) {
+                setConfig({ updateStatus: 'error' });
+                return;
+              }
+              setConfig({
+                latestVersion: latest,
+                updateStatus: compareVersions(latest, currentVersion) > 0 ? 'update' : 'uptodate',
+              });
+            })
+            .catch(() => setConfig({ updateStatus: 'error' }));
+        };
+
         const run = async (pathname, body) => {
           setBusy(true);
           setError(null);
@@ -328,6 +588,33 @@ window.__ModuleLoader__.load({
             ),
           ),
 
+          // version + update status row (red when an update is available)
+          react.createElement(
+            'div',
+            { className: 'dtc-row' },
+            react.createElement(
+              'span',
+              null,
+              L('version') + '：' + (cfg.version || '—'),
+            ),
+            cfg.updateStatus === 'update'
+              ? react.createElement('span', { className: 'dtc-update' }, L('updateAvailable') + (cfg.latestVersion ? ' v' + cfg.latestVersion : ''))
+              : cfg.updateStatus === 'uptodate'
+                ? react.createElement('span', { className: 'dtc-uptodate' }, L('upToDate'))
+                : cfg.updateStatus === 'error'
+                  ? react.createElement('span', { className: 'dtc-muted' }, L('updateCheckFailed'))
+                  : null,
+          ),
+
+          cfg.logPath
+            ? react.createElement(
+                'div',
+                { className: 'dtc-row' },
+                react.createElement('span', { className: 'dtc-muted' }, L('logPath') + '：'),
+                react.createElement('span', { className: 'dtc-muted dtc-logpath' }, cfg.logPath),
+              )
+            : null,
+
           react.createElement(
             'div',
             { className: 'dtc-row' },
@@ -424,9 +711,82 @@ window.__ModuleLoader__.load({
             ),
             react.createElement('span', { className: 'dtc-muted' }, L('pendingHint')),
           ),
+          react.createElement(
+            'div',
+            { className: 'dtc-row' },
+            react.createElement(
+              'label',
+              { className: 'dtc-toggle' },
+              react.createElement('input', {
+                type: 'checkbox',
+                checked: cfg.autoRetryOnError,
+                disabled: busy,
+                onChange: (e) => {
+                  run('/dsh-done-sound/api/config', { autoRetryOnError: e.target.checked });
+                },
+              }),
+              react.createElement('span', null, L('autoRetry')),
+            ),
+            react.createElement('span', { className: 'dtc-muted' }, L('autoRetryHint')),
+          ),
+          react.createElement(
+            'div',
+            { className: 'dtc-row' },
+            react.createElement('span', null, L('retryDelay')),
+            react.createElement('input', {
+              className: 'dtc-num',
+              type: 'number',
+              min: 10,
+              max: 300,
+              step: 5,
+              ref: delayDraftRef,
+              value: delayDraft,
+              disabled: busy,
+              onChange: (e) => setDelayDraft(e.target.value),
+              onBlur: () => {
+                commitDelay();
+              },
+              onKeyDown: (e) => {
+                if (e.key === 'Enter') {
+                  e.preventDefault();
+                  commitDelay();
+                }
+              },
+            }),
+            react.createElement('span', { className: 'dtc-muted' }, L('secondsUnit')),
+            react.createElement(
+              'button',
+              {
+                className: 'dtc-btn',
+                type: 'button',
+                disabled: busy,
+                onClick: () => {
+                  commitDelay();
+                },
+              },
+              L('confirm'),
+            ),
+            delaySaved && react.createElement('span', { className: 'dtc-saved' }, L('saved')),
+          ),
+          react.createElement('span', { className: 'dtc-muted' }, L('retryDelayHint')),
 
           error !== null && react.createElement('div', { className: 'dtc-err' }, error),
           !cfg.loaded && react.createElement('div', { className: 'dtc-muted' }, L('loading')),
+          cfg.retryCooldownUntil && cfg.retryCooldownUntil > Date.now()
+            ? react.createElement(
+                'div',
+                { className: 'dtc-muted dtc-cooldown-line' },
+                '🔄 ' + L('retryCooldown').replace('{s}', String(Math.ceil((cfg.retryCooldownUntil - cardTick) / 1000))),
+              )
+            : null,
+          retryState.armed && retryState.deadline > cardTick
+            ? react.createElement(
+                'div',
+                { className: 'dtc-muted dtc-cooldown-line' },
+                '🔄 ' +
+                  L('retryArmed').replace('{s}', String(Math.max(0, Math.ceil((retryState.deadline - cardTick) / 1000)))),
+              )
+            : null,
           cfg.lastEvent &&
             react.createElement(
               'div',
@@ -443,7 +803,13 @@ window.__ModuleLoader__.load({
                       ? L('evPending')
                       : L('evNormal')) +
                 ' → ' +
-                (cfg.lastEvent.play ? L('evPlayed') : L('evNotPlayed')),
+                (cfg.lastEvent.retried === true
+                  ? cfg.lastEvent.retryFailed
+                    ? L('retryFailed')
+                    : L('retrySent')
+                  : cfg.lastEvent.play
+                    ? L('evPlayed')
+                    : L('evNotPlayed')),
             ),
         );
       };
@@ -461,7 +827,8 @@ window.__ModuleLoader__.load({
         const pendingReasonRef = react.useRef(null);
         const lastEndTurnRef = react.useRef(0);
         const lastSessionRef = react.useRef(null);
-        const prevPendingRef = react.useRef(false);
+        const prevPendingKeysRef = react.useRef('');
+        const seededRef = react.useRef(false);
 
         const snap =
           typeof useSession === 'function'
@@ -480,11 +847,28 @@ window.__ModuleLoader__.load({
                 }
                 return {
                   sessionId: s && typeof s.sessionId === 'string' ? s.sessionId : null,
+                  openState: s && typeof s.openState === 'string' ? s.openState : null,
                   streaming: s.partial !== null || s.running === true,
                   endReason,
                   endTurn,
                   // agent is waiting for human intervention (approval etc.)
                   pendingCount: s && Array.isArray(s.pending) ? s.pending.length : 0,
+                  // Stable fingerprint of the items currently waiting, so a
+                  // replacement wait (one approval resolved while the next is
+                  // requested — count stays at 1) is still detected as a NEW
+                  // wait. The old 0->N edge detector missed those, which is the
+                  // "sometimes no sound" cause.
+                  pendingKey:
+                    s && Array.isArray(s.pending) && s.pending.length
+                      ? s.pending
+                          .map((it) => {
+                            const p = it && it.payload;
+                            if (p && typeof p.approvalId === 'string') return 'a:' + p.approvalId;
+                            if (p && typeof p.questionRpcId === 'string') return 'q:' + p.questionRpcId;
+                            return 'i:' + JSON.stringify(it || null);
+                          })
+                          .join('|')
+                      : '',
                 };
               })
             : null;
@@ -492,28 +876,98 @@ window.__ModuleLoader__.load({
         react.useEffect(() => {
           if (snap === null) return;
 
-          // New session (or first mount): seed with its current state; never
-          // play history or a completion that happened before we mounted.
+          // Fire the "waiting for human input" reminder for the current config
+          // view. When no audio URL is known yet (status fetch still in flight,
+          // or the audio was changed elsewhere), re-fetch status once and play
+          // with the fresh view instead of silently skipping.
+          const notifyPending = () => {
+            const canPlay = (view) => view.enabled && view.playOnPending && (view.url || view.defaultUrl);
+            const record = (value) => setConfig({ lastEvent: { at: Date.now(), kind: 'pending', reason: 'pending', play: value } });
+            if (canPlay(cfg)) {
+              playChime(cfg);
+              record(true);
+              return;
+            }
+            api('/dsh-done-sound/api/status')
+              .then((payload) => {
+                if (!payload || typeof payload !== 'object') return;
+                syncConfig(payload);
+                const fresh = {
+                  ...cfg,
+                  enabled: payload.enabled === true,
+                  playOnPending: payload.playOnPending !== false,
+                  url: typeof payload.url === 'string' && payload.url ? payload.url : null,
+                  defaultUrl: typeof payload.defaultUrl === 'string' && payload.defaultUrl ? payload.defaultUrl : null,
+                };
+                if (canPlay(fresh)) {
+                  playChime(fresh);
+                  record(true);
+                }
+              })
+              .catch(() => {});
+            record(false);
+          };
+
+          // New session (or first mount): reset and wait for the history to
+          // settle before listening.
           if (snap.sessionId !== lastSessionRef.current) {
             lastSessionRef.current = snap.sessionId;
+            seededRef.current = false;
             pendingReasonRef.current = null;
-            lastEndTurnRef.current = snap.endTurn;
-            prevPendingRef.current = snap.pendingCount > 0;
-            return;
+            lastEndTurnRef.current = 0;
+            prevPendingKeysRef.current = '';
+            cancelModuleRetry();
+            setConfig({ retryCooldownUntil: null });
           }
 
-          // Agent entered a waiting-for-human state (rising edge only).
-          if (snap.pendingCount > 0 && !prevPendingRef.current) {
-            prevPendingRef.current = true;
-            let played = false;
-            if (cfg.enabled && cfg.playOnPending && (cfg.url || cfg.defaultUrl)) {
-              playChime(cfg);
-              played = true;
+          // Before the session window is open, the timeline fills with the
+          // conversation history (replayed turn/end events). Do NOT treat that
+          // replay as new completions: seed only once openState reaches 'open'
+          // (the latest tail is loaded; older pages only add lower turn
+          // numbers, which never move endTurn).
+          if (!seededRef.current) {
+            if (snap.openState === 'open') {
+              seededRef.current = true;
+              lastEndTurnRef.current = snap.endTurn;
+              // Seed with the current key so the pending detector only fires
+              // for NEW waiting items, but still notify once if we mounted
+              // into an already-waiting conversation (e.g. refresh mid-approval).
+              prevPendingKeysRef.current = snap.pendingKey || '';
+              if (snap.pendingCount > 0) notifyPending();
             }
-            setConfig({ lastEvent: { at: Date.now(), kind: 'pending', reason: 'pending', play: played } });
             return;
           }
-          prevPendingRef.current = snap.pendingCount > 0;
+
+          // Cancel a pending auto-retry when the session recovers on its own
+          // (agent runs again, a new turn closes, it waits for human input, or
+          // we switched sessions) — no need to send "继续" then.
+          if (retryState.armed) {
+            const cancel =
+              snap.sessionId !== retryState.sessionId ||
+              snap.streaming === true ||
+              snap.endTurn > retryState.endTurnAtError ||
+              snap.pendingCount > 0;
+            if (cancel) {
+              cancelModuleRetry();
+              setConfig({ retryCooldownUntil: null });
+            }
+          }
+
+          // Agent entered a waiting-for-human state. Notify on ANY new waiting item:
+// the first pending, a replacement approval (one resolved, next requested —
+// count stays 1, which the old 0->N rising-edge detector missed, i.e. the
+// "sometimes no sound" bug), or an additional item stacking on top.
+if (snap.pendingCount > 0) {
+            const prevKeys = new Set((prevPendingKeysRef.current || '').split('|').filter(Boolean));
+            const curKeys = (snap.pendingKey || '').split('|').filter(Boolean);
+            const hasNew = curKeys.some((k) => !prevKeys.has(k));
+            if (hasNew) {
+              prevPendingKeysRef.current = snap.pendingKey || '';
+              notifyPending();
+              return;
+            }
+          }
+          prevPendingKeysRef.current = snap.pendingKey || '';
 
           // A newly-closed turn is the authoritative "a turn ended" signal.
           if (snap.endTurn > lastEndTurnRef.current) {
@@ -586,8 +1040,42 @@ window.__ModuleLoader__.load({
           } else {
             record(played);
           }
+
+          // Arm the deferred auto-retry: after a real 'error' end, wait the
+          // configured window; if the session recovers during the window
+          // (streaming, new turn, approval wait) the retry is cancelled above,
+          // otherwise the module-level timer fires "继续" when it expires.
+          if (reason === 'error' && cfg.enabled && cfg.autoRetryOnError && snap.sessionId) {
+            if (!retryState.armed) {
+              const delayMs = (cfg.retryDelaySeconds || 60) * 1000;
+              armModuleRetry(snap.sessionId, snap.endTurn, delayMs);
+              setConfig({ retryCooldownUntil: retryState.deadline });
+              setConfig({ lastEvent: { at: Date.now(), kind, reason, play: played, retryPending: true } });
+            }
+          }
         }, [snap, cfg]);
 
+        // Countdown chip display only (the actual fire is a module-level timer
+        // that survives navigation away from the conversation).
+        const [nowTick, setNowTick] = react.useState(Date.now());
+        react.useEffect(() => {
+          const timer = setInterval(() => setNowTick(Date.now()), 1000);
+          return () => clearInterval(timer);
+        }, []);
+        const cooldownLeft =
+          cfg.retryCooldownUntil && cfg.retryCooldownUntil > Date.now()
+            ? Math.ceil((cfg.retryCooldownUntil - nowTick) / 1000)
+            : 0;
+        if (cooldownLeft > 0) {
+          const chipLang = resolveLang();
+          return react.createElement(
+            'span',
+            { className: 'dtc-retry-chip', title: t(chipLang, 'retryChipTitle') },
+            react.createElement('span', { className: 'dtc-retry-ico' }, '🔄'),
+            react.createElement('span', null, t(chipLang, 'retrying')),
+            react.createElement('span', { className: 'dtc-retry-num' }, cooldownLeft + 's'),
+          );
+        }
         return null;
       };
 
@@ -617,7 +1105,7 @@ window.__ModuleLoader__.load({
     }
 
     exports.name = 'dsh-done-sound';
-    exports.inject = ['slots', 'remote', 'remote.commands'];
+    exports.inject = ['slots', 'remote', 'remote.commands', 'connection'];
     exports.apply = apply;
     return module.exports;
   },

package/lib/index.js

@@ -1,5 +1,6 @@
-// dsh-done-sound/src/index.js
+// src/index.js
 import { fileURLToPath } from "node:url";
+import { readFileSync, mkdirSync, appendFileSync } from "node:fs";
 import { mkdir, readFile, writeFile, unlink } from "node:fs/promises";
 import { join, dirname } from "node:path";
 import { randomUUID } from "node:crypto";
@@ -792,10 +793,40 @@ defineMethod("transform", [
   "preserve"
 ], ({ inner }, isInner) => inner.toString(isInner));
 
-// dsh-done-sound/src/index.js
+// src/index.js
 var name = "dsh-done-sound";
 var inject = ["settings", "commands", "webServer"];
-var MAX_BYTES = 2 * 1024 * 1024;
+var cachedPluginVersion = null;
+function pluginVersion() {
+  if (cachedPluginVersion !== null) return cachedPluginVersion;
+  try {
+    const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+    cachedPluginVersion = typeof pkg.version === "string" ? pkg.version : "unknown";
+  } catch {
+    cachedPluginVersion = "unknown";
+  }
+  return cachedPluginVersion;
+}
+var LOGS_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..", "logs");
+function datedLogPath(now = /* @__PURE__ */ new Date()) {
+  const y = now.getFullYear();
+  const m = String(now.getMonth() + 1).padStart(2, "0");
+  const d = String(now.getDate()).padStart(2, "0");
+  return join(LOGS_ROOT, `${y}${m}${d}`, "dsh-done-sound.log");
+}
+function writeLog(level, message) {
+  try {
+    const now = /* @__PURE__ */ new Date();
+    const stamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}:${String(now.getSeconds()).padStart(2, "0")}`;
+    const file = datedLogPath(now);
+    mkdirSync(dirname(file), { recursive: true });
+    appendFileSync(file, `[${stamp}] [${level}] ${message}
+`, "utf8");
+  } catch {
+  }
+}
+var MAX_BYTES = 10 * 1024 * 1024;
 var DEFAULT_AUDIO_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "assets", "turn-done.wav");
 var DEFAULT_AUDIO_URL = "/dsh-done-sound/audio/default";
 var DEFAULT_AUDIO_MIME = "audio/wav";
@@ -820,6 +851,8 @@ var TurnChimeSchema = Schema.object({
   playOnInterrupt: Schema.boolean().default(false),
   playOnError: Schema.boolean().default(true),
   playOnPending: Schema.boolean().default(true),
+  autoRetryOnError: Schema.boolean().default(true),
+  retryDelaySeconds: Schema.number().min(10).max(300).step(5).default(60),
   audio: Schema.object({
     fileId: Schema.string().default(""),
     fileName: Schema.string().default(""),
@@ -840,11 +873,14 @@ function apply(ctx) {
     const fileId = value.audio?.fileId ?? "";
     return {
       ok: true,
+      version: pluginVersion(),
       enabled: value.enabled,
       volume: value.volume,
       playOnInterrupt: value.playOnInterrupt,
       playOnError: value.playOnError,
       playOnPending: value.playOnPending,
+      autoRetryOnError: value.autoRetryOnError,
+      retryDelaySeconds: value.retryDelaySeconds,
       audio: {
         fileId,
         fileName: value.audio?.fileName ?? "",
@@ -852,7 +888,8 @@ function apply(ctx) {
         size: value.audio?.size ?? 0
       },
       url: fileId ? `${ROUTE_PREFIX}/audio/${fileId}` : null,
-      defaultUrl: DEFAULT_AUDIO_URL
+      defaultUrl: DEFAULT_AUDIO_URL,
+      logPath: datedLogPath()
     };
   };
   const clearAudio = async () => {
@@ -865,6 +902,7 @@ function apply(ctx) {
       }
     }
     await scope.update({ audio: { fileId: "", fileName: "", mime: "", size: 0 } });
+    writeLog("INFO", "audio cleared");
   };
   const setAudio = async (dataUrl, fileName) => {
     const match = /^data:([^;,]+);base64,([A-Za-z0-9+/=]+)$/.exec(dataUrl);
@@ -874,7 +912,7 @@ function apply(ctx) {
     if (!ext) throw new Error(`unsupported audio type: ${mime} (mp3/wav/ogg/webm/m4a/aac/flac only)`);
     const buffer = Buffer.from(match[2], "base64");
     if (buffer.length === 0) throw new Error("empty audio content");
-    if (buffer.length > MAX_BYTES) throw new Error(`audio exceeds 2MB (got ${buffer.length} bytes)`);
+    if (buffer.length > MAX_BYTES) throw new Error(`audio exceeds 10MB (got ${buffer.length} bytes)`);
     const fileId = randomUUID();
     await mkdir(dataDir, { recursive: true });
     await writeFile(audioPath(fileId), buffer);
@@ -888,6 +926,7 @@ function apply(ctx) {
       } catch {
       }
     }
+    writeLog("INFO", `audio stored: ${fileName || "chime"} (${buffer.length} bytes, ${mime})`);
     return fileId;
   };
   ctx.commands.register({
@@ -944,6 +983,7 @@ function apply(ctx) {
             return { kind: "error", text: `\u672A\u77E5\u64CD\u4F5C\uFF1A${action}` };
         }
       } catch (error) {
+        writeLog("ERROR", `command failed: ${error instanceof Error ? error.message : String(error)}`);
         return { kind: "error", text: error instanceof Error ? error.message : String(error) };
       }
     }
@@ -1031,6 +1071,10 @@ function apply(ctx) {
         if (typeof body.playOnInterrupt === "boolean") patch.playOnInterrupt = body.playOnInterrupt;
         if (typeof body.playOnError === "boolean") patch.playOnError = body.playOnError;
         if (typeof body.playOnPending === "boolean") patch.playOnPending = body.playOnPending;
+        if (typeof body.autoRetryOnError === "boolean") patch.autoRetryOnError = body.autoRetryOnError;
+        if (typeof body.retryDelaySeconds === "number" && body.retryDelaySeconds >= 10 && body.retryDelaySeconds <= 300) {
+          patch.retryDelaySeconds = Math.round(body.retryDelaySeconds / 5) * 5;
+        }
         if (Object.keys(patch).length > 0) await scope.update(patch);
         sendJson(res, 200, statusPayload());
         return;
@@ -1046,7 +1090,22 @@ function apply(ctx) {
         sendJson(res, 200, statusPayload());
         return;
       }
+      if (pathname === "/dsh-done-sound/api/log" && method === "POST") {
+        const body = await readJsonBody(req);
+        const message = typeof body.message === "string" ? body.message : "";
+        if (message) {
+          const level = typeof body.level === "string" && /^[A-Za-z]+$/.test(body.level) ? body.level.toUpperCase() : "INFO";
+          writeLog(body.source === "client" ? `CLIENT-${level}` : level, message.slice(0, 4e3));
+        }
+        sendJson(res, 200, { ok: true });
+        return;
+      }
+      if (pathname === "/dsh-done-sound/api/log" && method === "GET") {
+        sendJson(res, 200, { ok: true, logPath: datedLogPath() });
+        return;
+      }
     } catch (error) {
+      writeLog("ERROR", `api ${method} ${pathname} failed: ${error instanceof Error ? error.message : String(error)}`);
       sendJson(res, 400, { ok: false, error: error instanceof Error ? error.message : String(error) });
       return;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-done-sound",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Play a user-chosen sound whenever a conversation finishes in the DeepSeek Harness web GUI",
   "license": "MIT",
   "type": "module",