@goodandready/dsh-agent-loop-guard 0.2.3 → 0.2.4

package/README.md

@@ -176,3 +176,12 @@ npm run check
 ## 📄 License
 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+
+
+## Changed in v0.2.4
+
+- **Settings UI**: allow saving `0` for `maxToolAttemptsPerTurn` to cleanly disable aggregate turn budget (#28).
+- **Outcome Analysis**: recognize `{ error: null }` and `{ error: false }` as non-failures in execution outcome evaluation (#28).
+- **Alternating Loop Breaker**: track prior results per tool fingerprint (`state.lastResults`) to block alternating non-productive loops (A ➔ B ➔ A ➔ B) (#28).
+- **Settings Card**: add reactive `settings.plugin.item` card in DSH Settings with live configuration updates (#26).
+- **Test Suite**: expanded to 31 automated tests covering error edge cases and alternating loop enforcement (#28).

package/README.ru.md

@@ -0,0 +1,51 @@
+# @goodandready/dsh-agent-loop-guard 0.2.2
+
+Host-only DeepSeek Harness bundle that prevents tool-call loops without changing DSH core.
+
+## Behaviour
+
+- treats a repeated call as a loop only when no successful result or state
+  change has appeared since the previous attempt;
+- permits legitimate iterations with the same arguments when the result or
+  explicit progress token changes;
+- allows read -> edit -> read -> edit when each step produces new evidence;
+- keeps Gitea/curl operations distinct by their complete operation arguments,
+  including HTTP method and endpoint, even when they share a base URL;
+- uses maxToolAttemptsPerTurn and maxProgressToolCallsPerTurn as budgets
+  since the last productive action, so productive work resets the counters;
+- after a loop or budget denial, enters answer-only mode for the current turn
+  and returns a normal DSH tool denial that requires a text answer; the next
+  turn resets that mode;
+- logs every LOOP_GUARD_STOP, LOOP_GUARD_LIMIT,
+  LOOP_GUARD_PROGRESS_LIMIT, LOOP_GUARD_DUPLICATE, and
+  LOOP_GUARD_REPEAT event with a redacted call summary and progress context;
+- preserves the assistant-output guard: it detects text-only loops across
+  block/step/turn boundaries and cancels with keepInbox: false; both repeated
+  individual lines and repeated multi-line blocks are covered.
+
+The repeat threshold remains controlled by maxCallsPerRepeatGroup (default 5),
+but it is evaluated against the current progress epoch rather than raw call
+count. A successful result is considered productive when its result fingerprint
+or explicit progress token differs from the last successful evidence. Failed or
+unknown results do not reset the guard.
+
+The legacy maxCallsPerToolPerTurn setting remains accepted as a compatibility
+alias. maxToolAttemptsPerTurn: 0 disables only the aggregate no-progress
+budget; repeat, stop, progress, and assistant-output protections remain active.
+Denials use the documented tools.guard API and remain normal structured DSH tool
+results, preserving session persistence.
+
+## Verification
+
+npm test
+npm run check
+
+
+## Assistant output settings
+
+The output guard uses maxRepeatedAssistantLines for single-line repetition and maxRepeatedAssistantBlocks (default 5) for identical multi-line blocks. maxAssistantBlockChars (default 16384) bounds the captured block fingerprint. Streaming chunks and their final assistant/message are deduplicated.
+
+
+## Changed in v0.2.4
+
+#26: `settings.register` + Settings → Plugins card; live config updates. Patch uses `config: {}` (schema defaults). #2: add reviewed `package-lock.json`.

package/README.zh.md

@@ -0,0 +1,51 @@
+# @goodandready/dsh-agent-loop-guard 0.2.2
+
+Host-only DeepSeek Harness bundle that prevents tool-call loops without changing DSH core.
+
+## Behaviour
+
+- treats a repeated call as a loop only when no successful result or state
+  change has appeared since the previous attempt;
+- permits legitimate iterations with the same arguments when the result or
+  explicit progress token changes;
+- allows read -> edit -> read -> edit when each step produces new evidence;
+- keeps Gitea/curl operations distinct by their complete operation arguments,
+  including HTTP method and endpoint, even when they share a base URL;
+- uses maxToolAttemptsPerTurn and maxProgressToolCallsPerTurn as budgets
+  since the last productive action, so productive work resets the counters;
+- after a loop or budget denial, enters answer-only mode for the current turn
+  and returns a normal DSH tool denial that requires a text answer; the next
+  turn resets that mode;
+- logs every LOOP_GUARD_STOP, LOOP_GUARD_LIMIT,
+  LOOP_GUARD_PROGRESS_LIMIT, LOOP_GUARD_DUPLICATE, and
+  LOOP_GUARD_REPEAT event with a redacted call summary and progress context;
+- preserves the assistant-output guard: it detects text-only loops across
+  block/step/turn boundaries and cancels with keepInbox: false; both repeated
+  individual lines and repeated multi-line blocks are covered.
+
+The repeat threshold remains controlled by maxCallsPerRepeatGroup (default 5),
+but it is evaluated against the current progress epoch rather than raw call
+count. A successful result is considered productive when its result fingerprint
+or explicit progress token differs from the last successful evidence. Failed or
+unknown results do not reset the guard.
+
+The legacy maxCallsPerToolPerTurn setting remains accepted as a compatibility
+alias. maxToolAttemptsPerTurn: 0 disables only the aggregate no-progress
+budget; repeat, stop, progress, and assistant-output protections remain active.
+Denials use the documented tools.guard API and remain normal structured DSH tool
+results, preserving session persistence.
+
+## Verification
+
+npm test
+npm run check
+
+
+## Assistant output settings
+
+The output guard uses maxRepeatedAssistantLines for single-line repetition and maxRepeatedAssistantBlocks (default 5) for identical multi-line blocks. maxAssistantBlockChars (default 16384) bounds the captured block fingerprint. Streaming chunks and their final assistant/message are deduplicated.
+
+
+## Changed in v0.2.4
+
+#26: `settings.register` + Settings → Plugins card; live config. Patch `config: {}`. #2/#21: reviewed `package-lock.json`.

package/cordis.patch.yml

@@ -1,15 +1,5 @@
-# Host-only DSH bundle. No dsh.client entry exists because this package has no browser module.
+# Host + optional settings UI. Defaults live in Config schema / Settings card.
 - insert:
     - id: '@goodandready/dsh-agent-loop-guard'
       name: '@goodandready/dsh-agent-loop-guard'
-      config:
-        maxToolAttemptsPerTurn: 64
-        maxProgressToolCallsPerTurn: 16
-        progressToolNames:
-          - todo_write
-        maxCallsPerRepeatGroup: 5
-        blockExactDuplicates: true
-        assistantOutputGuard: true
-        maxRepeatedAssistantLines: 5
-        maxRepeatedAssistantBlocks: 5
-        maxAssistantBlockChars: 16384
+      config: {}

package/docs/README.ru.md

@@ -155,16 +155,26 @@ dsh-agent-loop-guard:
 ---
 
 ## 🧪 Тестирование
-
-Запуск набора из 26 автоматизированных тестов и статической проверки типов:
-
+ 
+Запуск набора из 31 автоматизированного теста и статической проверки типов:
+ 
 ```bash
 npm test
 npm run check
 ```
-
+ 
 ---
-
+ 
 ## 📄 Лицензия
-
+ 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+ 
+---
+ 
+## Изменения в версии v0.2.4
+ 
+- **Интерфейс настроек**: исправлено сохранение `0` для `maxToolAttemptsPerTurn` — теперь общий лимит попыток можно отключить через карточку плагина (#28).
+- **Анализ результатов**: возвращаемые объектами поля `{ error: null }` и `{ error: false }` больше не считаются ошибками и не блокируют продвижение эпохи (#28).
+- **Защита от чередующихся циклов**: добавлено отслеживание результатов по каждому инструменту (`state.lastResults`), исключающее зацикливание агента вида A ➔ B ➔ A ➔ B без изменения состояния (#28).
+- **Карточка настроек**: внедрена стандартная карточка `settings.plugin.item` с динамическим обновлением параметров на лету (#26).
+- **Набор тестов**: расширен до 31 автоматизированного теста.

package/docs/README.zh.md

@@ -153,16 +153,26 @@ dsh-agent-loop-guard:
 ---
 
 ## 🧪 测试与校验
-
-运行全部 26 个单元测试及静态代码检查：
-
+ 
+运行全部 31 个单元测试及静态代码检查：
+ 
 ```bash
 npm test
 npm run check
 ```
-
+ 
 ---
-
+ 
 ## 📄 开源许可证
-
+ 
 MIT © [GooDAnDReaDY](https://github.com/GooDAnDReaDY)
+ 
+---
+ 
+## v0.2.4 更新日志
+ 
+- **设置界面**：修复 `maxToolAttemptsPerTurn` 保存为 `0` 的问题，允许正常禁用单回合工具调用上限 (#28)。
+- **结果解析**：对象中的 `{ error: null }` 与 `{ error: false }` 正确识别为非错误，不再阻碍进展推进 (#28)。
+- **交替循环拦截**：通过 `state.lastResults` 跟踪每个工具的先前结果，有效拦截无实质进展的交替循环调用 (A ➔ B ➔ A ➔ B) (#28)。
+- **设置卡片**：集成标准 `settings.plugin.item` 配置卡片，支持动态热重载 (#26)。
+- **测试用例**：自动化测试扩展至 31 个测试。

package/lib/assistant-output-state.js

@@ -46,6 +46,18 @@ export class AssistantOutputGuardState {
     this.bySession = new Map();
   }
 
+  updateConfig(config = {}) {
+    if (config.maxRepeatedAssistantLines !== undefined) {
+      this.maxRepeatedAssistantLines = positiveOutputLimit(config.maxRepeatedAssistantLines, this.maxRepeatedAssistantLines);
+    }
+    if (config.maxRepeatedAssistantBlocks !== undefined) {
+      this.maxRepeatedAssistantBlocks = positiveOutputLimit(config.maxRepeatedAssistantBlocks, this.maxRepeatedAssistantBlocks);
+    }
+    if (config.maxAssistantBlockChars !== undefined) {
+      this.maxAssistantBlockChars = positiveOutputLimit(config.maxAssistantBlockChars, this.maxAssistantBlockChars);
+    }
+  }
+
   stateFor(session) {
     const key = sessionKey(session);
     let state = this.bySession.get(key);

package/lib/client.js

@@ -0,0 +1,206 @@
+window.__ModuleLoader__.load({
+  id: '@goodandready/dsh-agent-loop-guard',
+  factory: (require) => {
+    var module = { exports: {} };
+    const React = require('react');
+    const NS = '@goodandready/dsh-agent-loop-guard';
+
+    const en = {
+      title: 'Agent Loop Guard',
+      sub: 'Fail-closed tool-call and assistant-output loop limits',
+      maxToolAttemptsPerTurn: 'Max tool attempts per turn',
+      maxProgressToolCallsPerTurn: 'Max progress tool calls per turn',
+      maxCallsPerRepeatGroup: 'Max calls per repeat group',
+      blockExactDuplicates: 'Block exact duplicate tool calls',
+      assistantOutputGuard: 'Assistant output guard',
+      maxRepeatedAssistantLines: 'Max repeated assistant lines',
+      maxRepeatedAssistantBlocks: 'Max repeated assistant blocks',
+      maxAssistantBlockChars: 'Max assistant block chars',
+      progressToolNames: 'Progress tool names (comma-separated)',
+      saving: 'Saving…',
+      ready: 'Save',
+      saved: 'Saved',
+    };
+    const ru = {
+      title: 'Agent Loop Guard',
+      sub: 'Жёсткие лимиты на петли tool-call и повторы ответа ассистента',
+      maxToolAttemptsPerTurn: 'Макс. попыток tool за ход',
+      maxProgressToolCallsPerTurn: 'Макс. progress-tool за ход',
+      maxCallsPerRepeatGroup: 'Макс. вызовов в repeat-группе',
+      blockExactDuplicates: 'Блокировать точные дубликаты tool-call',
+      assistantOutputGuard: 'Охрана повторов ответа ассистента',
+      maxRepeatedAssistantLines: 'Макс. повторов строк',
+      maxRepeatedAssistantBlocks: 'Макс. повторов блоков',
+      maxAssistantBlockChars: 'Макс. символов блока',
+      progressToolNames: 'Progress-инструменты (через запятую)',
+      saving: 'Сохранение…',
+      ready: 'Сохранить',
+      saved: 'Сохранено',
+    };
+
+    const DEFAULTS = {
+      maxToolAttemptsPerTurn: 64,
+      maxProgressToolCallsPerTurn: 16,
+      progressToolNames: ['todo_write'],
+      maxCallsPerRepeatGroup: 5,
+      blockExactDuplicates: true,
+      assistantOutputGuard: true,
+      maxRepeatedAssistantLines: 5,
+      maxRepeatedAssistantBlocks: 5,
+      maxAssistantBlockChars: 16384,
+    };
+
+    function PluginCard({ ctx: _ctx, t }) {
+      const [expanded, setExpanded] = React.useState(false);
+      const [draft, setDraft] = React.useState({ ...DEFAULTS, progressToolNamesText: 'todo_write' });
+      const [status, setStatus] = React.useState('loading');
+      const [saving, setSaving] = React.useState(false);
+      const [msg, setMsg] = React.useState('');
+      const scopeRef = React.useRef(null);
+      if (!scopeRef.current && _ctx && _ctx.settingsScope) {
+        try { scopeRef.current = _ctx.settingsScope.bind({ namespace: NS }); } catch (e) { scopeRef.current = null; }
+      }
+      const scope = scopeRef.current;
+      const tt = t || ((k) => en[k] || k);
+
+      React.useEffect(() => {
+        if (!scope) { setStatus('unavailable'); return; }
+        let cancelled = false;
+        (async () => {
+          try {
+            const snap = await scope.get();
+            if (cancelled) return;
+            if (snap && typeof snap === 'object' && 'status' in snap) {
+              if (snap.status === 'loading') { setStatus('loading'); return; }
+              if (snap.status === 'unavailable') { setStatus('unavailable'); return; }
+            }
+            const vals = snap && snap.values ? snap.values : snap;
+            if (vals && typeof vals === 'object') {
+              const names = Array.isArray(vals.progressToolNames) ? vals.progressToolNames : DEFAULTS.progressToolNames;
+              setDraft((d) => ({ ...d, ...DEFAULTS, ...vals, progressToolNamesText: names.join(', ') }));
+            }
+            setStatus('ready');
+          } catch (e) {
+            if (!cancelled) setStatus('unavailable');
+          }
+        })();
+        return () => { cancelled = true; };
+      }, [scope]);
+
+      async function onSave() {
+        if (!scope) { setMsg('Settings unavailable'); return; }
+        setSaving(true); setMsg('');
+        const names = String(draft.progressToolNamesText || '')
+          .split(',')
+          .map((s) => s.trim())
+          .filter(Boolean);
+        const maxToolAttempts = Number(draft.maxToolAttemptsPerTurn);
+        const payload = {
+          maxToolAttemptsPerTurn: Number.isFinite(maxToolAttempts) && maxToolAttempts >= 0 ? maxToolAttempts : 64,
+          maxProgressToolCallsPerTurn: Number(draft.maxProgressToolCallsPerTurn) || 16,
+          maxCallsPerRepeatGroup: Number(draft.maxCallsPerRepeatGroup) || 5,
+          blockExactDuplicates: !!draft.blockExactDuplicates,
+          assistantOutputGuard: !!draft.assistantOutputGuard,
+          maxRepeatedAssistantLines: Number(draft.maxRepeatedAssistantLines) || 5,
+          maxRepeatedAssistantBlocks: Number(draft.maxRepeatedAssistantBlocks) || 5,
+          maxAssistantBlockChars: Number(draft.maxAssistantBlockChars) || 16384,
+          progressToolNames: names.length ? names : ['todo_write'],
+        };
+        const errs = [];
+        for (const [k, v] of Object.entries(payload)) {
+          try { await scope.set(k, v); } catch (e) { errs.push(k + ': ' + (e && e.message || String(e))); }
+        }
+        setSaving(false);
+        setMsg(errs.length ? errs.join('; ') : tt('saved'));
+      }
+
+      const field = (key, input) => React.createElement('div', {
+        className: 'alg-field',
+        style: { display: 'flex', flexDirection: 'column', gap: 6, padding: '10px 0' }
+      },
+        React.createElement('label', { style: { fontSize: 13, color: 'var(--dsw-alias-label-secondary)' } }, tt(key)),
+        input
+      );
+      const num = (key) => React.createElement('input', {
+        type: 'number', value: draft[key],
+        onChange: (e) => setDraft((d) => ({ ...d, [key]: e.target.value })),
+        style: { height: 34, border: '1px solid var(--dsw-alias-border-l2)', background: 'var(--dsw-alias-bg-layer-3)', color: 'var(--dsw-alias-label-primary)', borderRadius: 8, padding: '0 12px', fontSize: 13 }
+      });
+      const check = (key) => React.createElement('label', { style: { display: 'flex', alignItems: 'center', gap: 8, fontSize: 13 } },
+        React.createElement('input', {
+          type: 'checkbox', checked: !!draft[key],
+          onChange: (e) => setDraft((d) => ({ ...d, [key]: e.target.checked }))
+        }),
+        tt(key)
+      );
+
+      return React.createElement('li', {
+        className: 'alg-card',
+        style: { border: '1px solid var(--dsw-alias-border-l2)', background: 'var(--dsw-alias-bg-layer-3)', borderRadius: 12, listStyle: 'none' }
+      },
+        React.createElement('button', {
+          onClick: () => setExpanded(!expanded),
+          'aria-expanded': expanded,
+          style: { appearance: 'none', width: '100%', font: 'inherit', color: 'inherit', textAlign: 'left', cursor: 'pointer', background: '0 0', border: 0, borderRadius: 12, display: 'flex', alignItems: 'center', gap: 12, padding: '14px 16px' }
+        },
+          React.createElement('span', { style: { display: 'flex', flexDirection: 'column' } },
+            React.createElement('span', { style: { color: 'var(--dsw-alias-label-primary)', fontSize: 15, fontWeight: 600 } }, tt('title')),
+            React.createElement('span', { style: { color: 'var(--dsw-alias-label-secondary)', fontSize: 13 } }, tt('sub'))
+          ),
+          React.createElement('span', { style: { marginLeft: 'auto', color: 'var(--dsw-alias-label-tertiary)' } }, expanded ? '▲' : '▼')
+        ),
+        expanded ? React.createElement('div', { style: { borderTop: '1px solid var(--dsw-alias-border-l2)', margin: '0 16px', paddingBottom: 8 } },
+          status === 'loading' ? React.createElement('div', { style: { padding: 12 } }, 'Loading…') :
+          status === 'unavailable' ? React.createElement('div', { style: { padding: 12 } }, 'Settings unavailable') :
+          React.createElement(React.Fragment, null,
+            field('maxToolAttemptsPerTurn', num('maxToolAttemptsPerTurn')),
+            field('maxProgressToolCallsPerTurn', num('maxProgressToolCallsPerTurn')),
+            field('maxCallsPerRepeatGroup', num('maxCallsPerRepeatGroup')),
+            field('progressToolNames', React.createElement('input', {
+              type: 'text', value: draft.progressToolNamesText || '',
+              onChange: (e) => setDraft((d) => ({ ...d, progressToolNamesText: e.target.value })),
+              style: { height: 34, border: '1px solid var(--dsw-alias-border-l2)', background: 'var(--dsw-alias-bg-layer-3)', color: 'var(--dsw-alias-label-primary)', borderRadius: 8, padding: '0 12px', fontSize: 13 }
+            })),
+            React.createElement('div', { style: { padding: '8px 0' } }, check('blockExactDuplicates')),
+            React.createElement('div', { style: { padding: '8px 0' } }, check('assistantOutputGuard')),
+            field('maxRepeatedAssistantLines', num('maxRepeatedAssistantLines')),
+            field('maxRepeatedAssistantBlocks', num('maxRepeatedAssistantBlocks')),
+            field('maxAssistantBlockChars', num('maxAssistantBlockChars')),
+            msg ? React.createElement('div', { style: { fontSize: 12, color: msg === tt('saved') ? 'var(--dsw-alias-label-secondary)' : '#d73a4a', padding: '4px 0' } }, msg) : null,
+            React.createElement('div', { style: { display: 'flex', justifyContent: 'flex-end', padding: '12px 0 4px', borderTop: '1px solid var(--dsw-alias-border-l2)' } },
+              React.createElement('button', {
+                onClick: onSave, disabled: saving,
+                style: { appearance: 'none', font: 'inherit', cursor: 'pointer', border: '1px solid transparent', borderRadius: 8, padding: '5px 14px', fontSize: 13, background: 'var(--dsw-alias-label-primary)', color: 'var(--dsw-alias-bg-layer-3)', opacity: saving ? 0.6 : 1 }
+              }, saving ? tt('saving') : tt('ready'))
+            )
+          )
+        ) : null
+      );
+    }
+
+    module.exports.inject = ['slots', 'locale'];
+    module.exports.apply = function apply(ctx) {
+      try { ctx.locale.register(NS, { en, ru }); } catch (e) {}
+      if (!ctx.slots) return;
+      const register = () => {
+        try {
+          return ctx.slots.register({
+            name: 'settings.plugin.item',
+            key: NS,
+            locale: NS,
+            inject: () => ({ ctx }),
+          }, PluginCard);
+        } catch (e) {
+          console.warn('[dsh-agent-loop-guard] settings.plugin.item register failed', e && e.message || e);
+        }
+      };
+      if (typeof ctx.slots.inject === 'function') {
+        try { ctx.slots.inject('settings.plugin.item', register); }
+        catch (e) { try { register(); } catch (e2) {} }
+      } else {
+        register();
+      }
+    };
+    return module.exports;
+  },
+});

package/lib/guard-state.js

@@ -88,11 +88,11 @@ function outcomeFromExecution(execution) {
   if (!hasResult) return { known: false, successful: false, resultFingerprint: '<unknown>', progressToken: '<unknown>' };
   const value = execution?.result ?? execution?.output ?? data?.result ?? data?.output
     ?? (hasOwn(execution, 'error') ? { error: execution.error } : undefined);
-  const failed = execution?.error !== undefined
+  const failed = (execution?.error != null && execution?.error !== false)
     || value?.isError === true
     || value?.success === false
     || value?.ok === false
-    || value?.error !== undefined;
+    || (value?.error != null && value?.error !== false);
   const explicitProgress = execution?.progressToken ?? execution?.progress ?? execution?.stateVersion
     ?? data?.progressToken ?? data?.progress ?? data?.stateVersion;
   return {
@@ -123,6 +123,23 @@ export class LoopGuardState {
     this.nextObjectKey = 1;
   }
 
+  updateConfig(config = {}) {
+    const progressToolNames = Array.isArray(config.progressToolNames)
+      ? config.progressToolNames
+        .filter((name) => typeof name === 'string' && name.trim() !== '')
+        .map((name) => name.trim())
+      : ['todo_write'];
+    this.config = {
+      ...this.config,
+      ...config,
+      maxToolAttemptsPerTurn: nonNegativeInteger(config.maxToolAttemptsPerTurn, this.config.maxToolAttemptsPerTurn ?? 64),
+      maxProgressToolCallsPerTurn: positiveInteger(config.maxProgressToolCallsPerTurn, this.config.maxProgressToolCallsPerTurn ?? 16),
+      maxCallsPerRepeatGroup: positiveInteger(config.maxCallsPerRepeatGroup ?? config.maxCallsPerToolPerTurn, this.config.maxCallsPerRepeatGroup ?? 5),
+      blockExactDuplicates: config.blockExactDuplicates !== undefined ? Boolean(config.blockExactDuplicates) : this.config.blockExactDuplicates,
+    };
+    this.progressToolNames = new Set(progressToolNames);
+  }
+
   agentKey(agent) {
     if (agent !== null && typeof agent === 'object') {
       const sessionId = agent.session?.id ?? agent.session?.header?.id ?? agent.id;
@@ -293,7 +310,12 @@ export class LoopGuardState {
     call.resultFingerprint = outcome.resultFingerprint;
     call.progressToken = outcome.progressToken;
     const prior = state.lastEvidence;
+    const priorForCall = state.lastResults.get(call.repeatFingerprint);
+    const resultUnchangedForCall = priorForCall !== undefined
+      && priorForCall.resultFingerprint === outcome.resultFingerprint
+      && priorForCall.progressToken === outcome.progressToken;
     const productive = outcome.known && outcome.successful
+      && !resultUnchangedForCall
       && (prior === undefined
         || prior.resultFingerprint !== outcome.resultFingerprint
         || prior.progressToken !== outcome.progressToken);

package/lib/index.js

@@ -8,7 +8,7 @@ import {
 import { AssistantOutputGuardState, assistantTextFromMessage } from './assistant-output-state.js';
 
 export const name = '@goodandready/dsh-agent-loop-guard';
-export const inject = ['tools', 'agents', 'sessions'];
+export const inject = ['tools', 'agents', 'sessions', 'settings'];
 
 export const Config = Schema.object({
   maxToolAttemptsPerTurn: Schema.number().min(0).default(64),
@@ -85,19 +85,53 @@ function logGuardViolation(ctx, event) {
 }
 
 export function apply(ctx, config = {}) {
-  const raw = Config(config) ?? {};
-  const maxCallsPerRepeatGroup = positiveInteger(raw.maxCallsPerRepeatGroup ?? raw.maxCallsPerToolPerTurn, 5);
+  const NS = name;
+  let getConfig = () => Config(config) ?? {};
+
+  const syncFrom = (raw) => {
+    const maxCallsPerRepeatGroup = positiveInteger(raw.maxCallsPerRepeatGroup ?? raw.maxCallsPerToolPerTurn, 5);
+    return {
+      ...raw,
+      maxToolAttemptsPerTurn: nonNegativeInteger(raw.maxToolAttemptsPerTurn, 64),
+      maxProgressToolCallsPerTurn: positiveInteger(raw.maxProgressToolCallsPerTurn, 16),
+      maxCallsPerRepeatGroup,
+      assistantOutputGuard: raw.assistantOutputGuard !== false,
+      maxRepeatedAssistantLines: positiveInteger(raw.maxRepeatedAssistantLines, 5),
+      maxRepeatedAssistantBlocks: positiveInteger(raw.maxRepeatedAssistantBlocks, 5),
+      maxAssistantBlockChars: positiveInteger(raw.maxAssistantBlockChars, 16_384),
+    };
+  };
+
+  let raw = syncFrom(getConfig());
   const state = new LoopGuardState({
     ...raw,
-    maxToolAttemptsPerTurn: nonNegativeInteger(raw.maxToolAttemptsPerTurn, 64),
-    maxProgressToolCallsPerTurn: positiveInteger(raw.maxProgressToolCallsPerTurn, 16),
-    maxCallsPerRepeatGroup,
     onViolation: (event) => logGuardViolation(ctx, event),
   });
   const assistantState = new AssistantOutputGuardState({
-    maxRepeatedAssistantLines: positiveInteger(raw.maxRepeatedAssistantLines, 5),
-    maxRepeatedAssistantBlocks: positiveInteger(raw.maxRepeatedAssistantBlocks, 5),
-    maxAssistantBlockChars: positiveInteger(raw.maxAssistantBlockChars, 16_384),
+    maxRepeatedAssistantLines: raw.maxRepeatedAssistantLines,
+    maxRepeatedAssistantBlocks: raw.maxRepeatedAssistantBlocks,
+    maxAssistantBlockChars: raw.maxAssistantBlockChars,
+  });
+
+  const applyLiveConfig = () => {
+    raw = syncFrom(getConfig());
+    state.updateConfig(raw);
+    if (typeof assistantState.updateConfig === 'function') assistantState.updateConfig(raw);
+  };
+
+  ctx.inject(['settings'], (sctx) => {
+    const scope = sctx.settings.register(NS, Config, { base: config });
+    getConfig = () => Config(scope.get() ?? config) ?? {};
+    applyLiveConfig();
+    try {
+      if (typeof scope.watch === 'function') {
+        sctx.effect(() => scope.watch(() => applyLiveConfig()));
+      } else if (typeof scope.subscribe === 'function') {
+        sctx.effect(() => scope.subscribe(() => applyLiveConfig()));
+      }
+    } catch (error) {
+      ctx.logger?.warn?.('dsh-agent-loop-guard: settings watch failed: ' + (error instanceof Error ? error.message : String(error)));
+    }
   });
 
   ctx.on('agent/pre-step', async ({ agent, turn, messages, signal }, next) => {
@@ -116,8 +150,9 @@ export function apply(ctx, config = {}) {
     state.recordResult(execution.agent, execution);
   });
 
-  if (raw.assistantOutputGuard !== false) {
+  if (true) {
     ctx.on('session/event', (session, event) => {
+      if (raw.assistantOutputGuard === false) return;
       if (event.type === 'assistant/chunk') {
         const chunk = event.data?.chunk;
         if (chunk?.type === 'text-delta') {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@goodandready/dsh-agent-loop-guard",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "Fail-closed runtime tool-call loop guard for DeepSeek Harness.",
   "type": "module",
   "main": "lib/index.js",
   "exports": {
     ".": "./lib/index.js",
+    "./client": "./lib/client.js",
     "./package.json": "./package.json",
     "./cordis.patch.yml": "./cordis.patch.yml"
   },
@@ -13,6 +14,8 @@
     "lib",
     "cordis.patch.yml",
     "README.md",
+    "README.ru.md",
+    "README.zh.md",
     "docs",
     "LICENSE"
   ],
@@ -23,12 +26,20 @@
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings"
+      ]
     }
   },
   "license": "MIT",
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.1",
-    "@deepseek-ai/schemastery": "^3.18.1"
+    "@deepseek-ai/schemastery": "^3.18.1",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.6"
   },
   "repository": {
     "type": "git",