feat(hermes): add kanban dispatcher controls

2026-06-21 07:23:56 +08:00 · 2026-05-27 00:12:20 +08:00
parent 425fcd847f
commit 80ed2d0e8c
7 changed files with 263 additions and 6 deletions
--- a/scripts/dev-api.js
+++ b/scripts/dev-api.js
@@ -3758,6 +3758,32 @@ export function buildHermesKanbanConfigValues(config = {}) {
    ? root.kanban
    : {}
  return {
+    dispatchInGateway: readHermesBool(kanban.dispatch_in_gateway, true),
+    dispatchIntervalSeconds: parseHermesInteger(
+      kanban.dispatch_interval_seconds,
+      'kanban.dispatch_interval_seconds',
+      60,
+      1,
+      86400,
+      false,
+    ),
+    failureLimit: parseHermesInteger(
+      kanban.failure_limit,
+      'kanban.failure_limit',
+      2,
+      1,
+      100,
+      false,
+    ),
+    autoDecompose: readHermesBool(kanban.auto_decompose, true),
+    autoDecomposePerTick: parseHermesInteger(
+      kanban.auto_decompose_per_tick,
+      'kanban.auto_decompose_per_tick',
+      3,
+      1,
+      1000,
+      false,
+    ),
    dispatchStaleTimeoutSeconds: parseHermesInteger(
      kanban.dispatch_stale_timeout_seconds,
      'kanban.dispatch_stale_timeout_seconds',
@@ -3776,6 +3802,32 @@ export function mergeHermesKanbanConfig(config = {}, form = {}) {
    ? mergeConfigsPreservingFields(next.kanban, {})
    : {}

+  kanban.dispatch_in_gateway = formHermesBool(form, 'dispatchInGateway', currentValues.dispatchInGateway)
+  kanban.dispatch_interval_seconds = parseHermesInteger(
+    Object.hasOwn(form, 'dispatchIntervalSeconds') ? form.dispatchIntervalSeconds : currentValues.dispatchIntervalSeconds,
+    'kanban.dispatch_interval_seconds',
+    60,
+    1,
+    86400,
+    true,
+  )
+  kanban.failure_limit = parseHermesInteger(
+    Object.hasOwn(form, 'failureLimit') ? form.failureLimit : currentValues.failureLimit,
+    'kanban.failure_limit',
+    2,
+    1,
+    100,
+    true,
+  )
+  kanban.auto_decompose = formHermesBool(form, 'autoDecompose', currentValues.autoDecompose)
+  kanban.auto_decompose_per_tick = parseHermesInteger(
+    Object.hasOwn(form, 'autoDecomposePerTick') ? form.autoDecomposePerTick : currentValues.autoDecomposePerTick,
+    'kanban.auto_decompose_per_tick',
+    3,
+    1,
+    1000,
+    true,
+  )
  kanban.dispatch_stale_timeout_seconds = parseHermesInteger(
    Object.hasOwn(form, 'dispatchStaleTimeoutSeconds') ? form.dispatchStaleTimeoutSeconds : currentValues.dispatchStaleTimeoutSeconds,
    'kanban.dispatch_stale_timeout_seconds',
--- a/src-tauri/src/commands/hermes.rs
+++ b/src-tauri/src/commands/hermes.rs
@@ -6543,6 +6543,36 @@ fn build_hermes_kanban_config_values(config: &serde_yaml::Value) -> Value {
    let root = config.as_mapping();
    let kanban = root.and_then(|map| yaml_get_mapping(map, "kanban"));
    serde_json::json!({
+        "dispatchInGateway": kanban
+            .and_then(|map| yaml_bool_field(map, "dispatch_in_gateway"))
+            .unwrap_or(true),
+        "dispatchIntervalSeconds": kanban
+            .map(|map| bounded_hermes_i64(
+                yaml_i64_field(map, "dispatch_interval_seconds"),
+                60,
+                1,
+                86400,
+            ))
+            .unwrap_or(60),
+        "failureLimit": kanban
+            .map(|map| bounded_hermes_i64(
+                yaml_i64_field(map, "failure_limit"),
+                2,
+                1,
+                100,
+            ))
+            .unwrap_or(2),
+        "autoDecompose": kanban
+            .and_then(|map| yaml_bool_field(map, "auto_decompose"))
+            .unwrap_or(true),
+        "autoDecomposePerTick": kanban
+            .map(|map| bounded_hermes_i64(
+                yaml_i64_field(map, "auto_decompose_per_tick"),
+                3,
+                1,
+                1000,
+            ))
+            .unwrap_or(3),
        "dispatchStaleTimeoutSeconds": kanban
            .map(|map| bounded_hermes_i64(
                yaml_i64_field(map, "dispatch_stale_timeout_seconds"),
@@ -6556,6 +6586,34 @@ fn build_hermes_kanban_config_values(config: &serde_yaml::Value) -> Value {

 fn merge_hermes_kanban_config(config: &mut serde_yaml::Value, form: &Value) -> Result<(), String> {
    let current = build_hermes_kanban_config_values(config);
+    let dispatch_in_gateway = form_bool(form, "dispatchInGateway")
+        .or_else(|| current["dispatchInGateway"].as_bool())
+        .unwrap_or(true);
+    let dispatch_interval_seconds = validate_hermes_i64(
+        form_i64(form, "dispatchIntervalSeconds")
+            .or_else(|| current["dispatchIntervalSeconds"].as_i64()),
+        "kanban.dispatch_interval_seconds",
+        60,
+        1,
+        86400,
+    )?;
+    let failure_limit = validate_hermes_i64(
+        form_i64(form, "failureLimit").or_else(|| current["failureLimit"].as_i64()),
+        "kanban.failure_limit",
+        2,
+        1,
+        100,
+    )?;
+    let auto_decompose = form_bool(form, "autoDecompose")
+        .or_else(|| current["autoDecompose"].as_bool())
+        .unwrap_or(true);
+    let auto_decompose_per_tick = validate_hermes_i64(
+        form_i64(form, "autoDecomposePerTick").or_else(|| current["autoDecomposePerTick"].as_i64()),
+        "kanban.auto_decompose_per_tick",
+        3,
+        1,
+        1000,
+    )?;
    let stale_timeout = validate_hermes_i64(
        form_i64(form, "dispatchStaleTimeoutSeconds")
            .or_else(|| current["dispatchStaleTimeoutSeconds"].as_i64()),
@@ -6566,6 +6624,26 @@ fn merge_hermes_kanban_config(config: &mut serde_yaml::Value, form: &Value) -> R
    )?;

    let kanban = yaml_child_object(ensure_yaml_object(config)?, "kanban")?;
+    kanban.insert(
+        yaml_key("dispatch_in_gateway"),
+        serde_yaml::Value::Bool(dispatch_in_gateway),
+    );
+    kanban.insert(
+        yaml_key("dispatch_interval_seconds"),
+        serde_yaml::Value::Number(serde_yaml::Number::from(dispatch_interval_seconds)),
+    );
+    kanban.insert(
+        yaml_key("failure_limit"),
+        serde_yaml::Value::Number(serde_yaml::Number::from(failure_limit)),
+    );
+    kanban.insert(
+        yaml_key("auto_decompose"),
+        serde_yaml::Value::Bool(auto_decompose),
+    );
+    kanban.insert(
+        yaml_key("auto_decompose_per_tick"),
+        serde_yaml::Value::Number(serde_yaml::Number::from(auto_decompose_per_tick)),
+    );
    kanban.insert(
        yaml_key("dispatch_stale_timeout_seconds"),
        serde_yaml::Value::Number(serde_yaml::Number::from(stale_timeout)),
@@ -19329,6 +19407,11 @@ mod hermes_kanban_config_tests {
    fn kanban_values_have_upstream_defaults() {
        let config: serde_yaml::Value = serde_yaml::from_str("{}").unwrap();
        let values = build_hermes_kanban_config_values(&config);
+        assert_eq!(values["dispatchInGateway"], true);
+        assert_eq!(values["dispatchIntervalSeconds"], 60);
+        assert_eq!(values["failureLimit"], 2);
+        assert_eq!(values["autoDecompose"], true);
+        assert_eq!(values["autoDecomposePerTick"], 3);
        assert_eq!(values["dispatchStaleTimeoutSeconds"], 14400);
    }

@@ -19337,11 +19420,21 @@ mod hermes_kanban_config_tests {
        let config: serde_yaml::Value = serde_yaml::from_str(
            r#"
 kanban:
+  dispatch_in_gateway: false
+  dispatch_interval_seconds: "120"
+  failure_limit: "5"
+  auto_decompose: false
+  auto_decompose_per_tick: "7"
  dispatch_stale_timeout_seconds: "7200"
 "#,
        )
        .unwrap();
        let values = build_hermes_kanban_config_values(&config);
+        assert_eq!(values["dispatchInGateway"], false);
+        assert_eq!(values["dispatchIntervalSeconds"], 120);
+        assert_eq!(values["failureLimit"], 5);
+        assert_eq!(values["autoDecompose"], false);
+        assert_eq!(values["autoDecomposePerTick"], 7);
        assert_eq!(values["dispatchStaleTimeoutSeconds"], 7200);
    }

@@ -19363,6 +19456,11 @@ memory:
        merge_hermes_kanban_config(
            &mut config,
            &json!({
+                "dispatchInGateway": false,
+                "dispatchIntervalSeconds": 15,
+                "failureLimit": 4,
+                "autoDecompose": false,
+                "autoDecomposePerTick": 2,
                "dispatchStaleTimeoutSeconds": 0,
            }),
        )
@@ -19370,11 +19468,21 @@ memory:

        assert_eq!(config["model"]["provider"].as_str(), Some("anthropic"));
        assert_eq!(config["memory"]["memory_enabled"].as_bool(), Some(true));
+        assert_eq!(config["kanban"]["custom_flag"].as_str(), Some("keep-me"));
+        assert_eq!(
+            config["kanban"]["dispatch_in_gateway"].as_bool(),
+            Some(false)
+        );
        assert_eq!(
            config["kanban"]["dispatch_interval_seconds"].as_i64(),
-            Some(30)
+            Some(15)
+        );
+        assert_eq!(config["kanban"]["failure_limit"].as_i64(), Some(4));
+        assert_eq!(config["kanban"]["auto_decompose"].as_bool(), Some(false));
+        assert_eq!(
+            config["kanban"]["auto_decompose_per_tick"].as_i64(),
+            Some(2)
        );
-        assert_eq!(config["kanban"]["custom_flag"].as_str(), Some("keep-me"));
        assert_eq!(
            config["kanban"]["dispatch_stale_timeout_seconds"].as_i64(),
            Some(0)
@@ -19384,6 +19492,18 @@ memory:
    #[test]
    fn merge_kanban_config_rejects_invalid_timeout() {
        let mut config = serde_yaml::Value::Mapping(serde_yaml::Mapping::new());
+        let err = merge_hermes_kanban_config(&mut config, &json!({ "dispatchIntervalSeconds": 0 }))
+            .unwrap_err();
+        assert!(err.contains("kanban.dispatch_interval_seconds"));
+
+        let err =
+            merge_hermes_kanban_config(&mut config, &json!({ "failureLimit": 0 })).unwrap_err();
+        assert!(err.contains("kanban.failure_limit"));
+
+        let err = merge_hermes_kanban_config(&mut config, &json!({ "autoDecomposePerTick": 0 }))
+            .unwrap_err();
+        assert!(err.contains("kanban.auto_decompose_per_tick"));
+
        let err =
            merge_hermes_kanban_config(&mut config, &json!({ "dispatchStaleTimeoutSeconds": -1 }))
                .unwrap_err();
--- a/src/engines/hermes/pages/config.js
+++ b/src/engines/hermes/pages/config.js
@@ -174,6 +174,11 @@ const HUMAN_DELAY_DEFAULTS = {
 }

 const KANBAN_DEFAULTS = {
+  dispatchInGateway: true,
+  dispatchIntervalSeconds: 60,
+  failureLimit: 2,
+  autoDecompose: true,
+  autoDecomposePerTick: 3,
  dispatchStaleTimeoutSeconds: 14400,
 }

@@ -1486,6 +1491,30 @@ export function render() {
        <div class="hm-panel-body">
          ${renderError(kanbanError)}
          <div class="hm-config-runtime-grid hm-config-kanban-grid">
+            <label class="hm-field hm-field--checkbox">
+              <input id="hm-kanban-dispatch-in-gateway" type="checkbox" ${kanbanValues.dispatchInGateway ? 'checked' : ''} ${disabled ? 'disabled' : ''}>
+              <span>
+                <span class="hm-field-label">${t('engine.hermesKanbanConfigDispatchInGateway')}</span>
+              </span>
+            </label>
+            <label class="hm-field">
+              <span class="hm-field-label">${t('engine.hermesKanbanConfigDispatchIntervalSeconds')}</span>
+              <input id="hm-kanban-dispatch-interval-seconds" class="hm-input" type="number" inputmode="numeric" min="1" max="86400" step="1" value="${esc(kanbanValues.dispatchIntervalSeconds)}" ${disabled ? 'disabled' : ''}>
+            </label>
+            <label class="hm-field">
+              <span class="hm-field-label">${t('engine.hermesKanbanConfigFailureLimit')}</span>
+              <input id="hm-kanban-failure-limit" class="hm-input" type="number" inputmode="numeric" min="1" max="100" step="1" value="${esc(kanbanValues.failureLimit)}" ${disabled ? 'disabled' : ''}>
+            </label>
+            <label class="hm-field hm-field--checkbox">
+              <input id="hm-kanban-auto-decompose" type="checkbox" ${kanbanValues.autoDecompose ? 'checked' : ''} ${disabled ? 'disabled' : ''}>
+              <span>
+                <span class="hm-field-label">${t('engine.hermesKanbanConfigAutoDecompose')}</span>
+              </span>
+            </label>
+            <label class="hm-field">
+              <span class="hm-field-label">${t('engine.hermesKanbanConfigAutoDecomposePerTick')}</span>
+              <input id="hm-kanban-auto-decompose-per-tick" class="hm-input" type="number" inputmode="numeric" min="1" max="1000" step="1" value="${esc(kanbanValues.autoDecomposePerTick)}" ${disabled ? 'disabled' : ''}>
+            </label>
            <label class="hm-field">
              <span class="hm-field-label">${t('engine.hermesKanbanConfigDispatchStaleTimeoutSeconds')}</span>
              <input id="hm-kanban-dispatch-stale-timeout-seconds" class="hm-input" type="number" inputmode="numeric" min="0" max="604800" step="60" value="${esc(kanbanValues.dispatchStaleTimeoutSeconds)}" ${disabled ? 'disabled' : ''}>
@@ -3484,6 +3513,11 @@ export function render() {

  async function saveKanbanConfig() {
    const form = {
+      dispatchInGateway: el.querySelector('#hm-kanban-dispatch-in-gateway')?.checked ?? true,
+      dispatchIntervalSeconds: el.querySelector('#hm-kanban-dispatch-interval-seconds')?.value || '60',
+      failureLimit: el.querySelector('#hm-kanban-failure-limit')?.value || '2',
+      autoDecompose: el.querySelector('#hm-kanban-auto-decompose')?.checked ?? true,
+      autoDecomposePerTick: el.querySelector('#hm-kanban-auto-decompose-per-tick')?.value || '3',
      dispatchStaleTimeoutSeconds: el.querySelector('#hm-kanban-dispatch-stale-timeout-seconds')?.value || '14400',
    }
    kanbanSaving = true
--- a/src/engines/hermes/style/hermes.css
+++ b/src/engines/hermes/style/hermes.css
@@ -741,6 +741,11 @@
  gap: 8px;
 }

+[data-engine="hermes"] .hm-field--checkbox {
+  min-height: 44px;
+  justify-content: center;
+}
+
 [data-engine="hermes"] .hm-field-label {
  font-family: var(--hm-font-serif);
  font-style: italic;
--- a/src/locales/modules/engine.js
+++ b/src/locales/modules/engine.js
@@ -1029,14 +1029,19 @@ export default {
  hermesHumanDelayConfigMaxMs: _('最大延迟 ms', 'Maximum delay ms', '最大延遲 ms'),
  hermesHumanDelayConfigFootnote: _('natural 使用 800-2500ms；custom 使用下方范围。Signal 等平台可能忽略或仅部分支持该设置。', 'natural uses 800-2500ms; custom uses the range below. Platforms such as Signal may ignore or only partially support this setting.', 'natural 使用 800-2500ms；custom 使用下方範圍。Signal 等平台可能忽略或僅部分支援此設定。'),
  hermesKanbanConfigTitle: _('Kanban 调度稳定性', 'Kanban dispatch reliability', 'Kanban 調度穩定性'),
-  hermesKanbanConfigDesc: _('控制 Kanban Worker 多久没有心跳后被自动回收，避免长任务卡在运行中。', 'Control how long a Kanban worker may go without a heartbeat before it is reclaimed, preventing long tasks from staying stuck as running.', '控制 Kanban Worker 多久沒有心跳後被自動回收，避免長任務卡在執行中。'),
+  hermesKanbanConfigDesc: _('控制 Gateway 是否自动派发 Kanban 任务、派发频率、失败上限和无心跳回收策略。', 'Control whether Gateway dispatches Kanban work, its interval, failure limit, and heartbeat reclaim policy.', '控制 Gateway 是否自動派發 Kanban 任務、派發頻率、失敗上限和無心跳回收策略。'),
  hermesKanbanConfigStatusReady: _('结构化配置', 'structured settings', '結構化設定'),
  hermesKanbanConfigSave: _('保存 Kanban 设置', 'Save Kanban settings', '儲存 Kanban 設定'),
  hermesKanbanConfigSaveSuccess: _('Kanban 调度配置已保存，建议重启 Hermes Gateway 生效', 'Kanban dispatch settings saved. Restart Hermes Gateway to take effect.', 'Kanban 調度設定已儲存，建議重啟 Hermes Gateway 生效'),
  hermesKanbanConfigLoadFailed: _('加载 Kanban 调度配置失败', 'Load Kanban dispatch settings failed', '載入 Kanban 調度設定失敗'),
  hermesKanbanConfigSaveFailed: _('保存 Kanban 调度配置失败', 'Save Kanban dispatch settings failed', '儲存 Kanban 調度設定失敗'),
+  hermesKanbanConfigDispatchInGateway: _('由 Gateway 自动派发任务', 'Dispatch tasks in Gateway', '由 Gateway 自動派發任務'),
+  hermesKanbanConfigDispatchIntervalSeconds: _('派发检查间隔（秒）', 'Dispatch interval (s)', '派發檢查間隔（秒）'),
+  hermesKanbanConfigFailureLimit: _('失败重试上限', 'Failure retry limit', '失敗重試上限'),
+  hermesKanbanConfigAutoDecompose: _('自动拆解待办任务', 'Auto decompose tasks', '自動拆解待辦任務'),
+  hermesKanbanConfigAutoDecomposePerTick: _('每轮自动拆解数量', 'Auto decompose per tick', '每輪自動拆解數量'),
  hermesKanbanConfigDispatchStaleTimeoutSeconds: _('无心跳回收时间（秒）', 'Heartbeat reclaim timeout (s)', '無心跳回收時間（秒）'),
-  hermesKanbanConfigFootnote: _('写入 kanban.dispatch_stale_timeout_seconds。默认 14400 秒；设为 0 会关闭无心跳自动回收。建议只在确认 Worker 会长时间离线且由外部系统接管时关闭。', 'Writes kanban.dispatch_stale_timeout_seconds. Default is 14400 seconds; set 0 to disable heartbeat-based reclaim. Disable it only when workers may stay offline for long periods and an external supervisor handles recovery.', '寫入 kanban.dispatch_stale_timeout_seconds。預設 14400 秒；設為 0 會關閉無心跳自動回收。建議只在確認 Worker 會長時間離線且由外部系統接管時關閉。'),
+  hermesKanbanConfigFootnote: _('写入 kanban.dispatch_in_gateway、dispatch_interval_seconds、failure_limit、auto_decompose、auto_decompose_per_tick、dispatch_stale_timeout_seconds。无心跳回收默认 14400 秒；设为 0 会关闭自动回收。', 'Writes kanban.dispatch_in_gateway, dispatch_interval_seconds, failure_limit, auto_decompose, auto_decompose_per_tick, and dispatch_stale_timeout_seconds. Heartbeat reclaim defaults to 14400 seconds; set 0 to disable automatic reclaim.', '寫入 kanban.dispatch_in_gateway、dispatch_interval_seconds、failure_limit、auto_decompose、auto_decompose_per_tick、dispatch_stale_timeout_seconds。無心跳回收預設 14400 秒；設為 0 會關閉自動回收。'),
  hermesSecurityConfigTitle: _('Tirith 安全扫描', 'Tirith security scanning', 'Tirith 安全掃描'),
  hermesSecurityConfigDesc: _('控制终端命令执行前的 Tirith 内容扫描，拦截明显的 URL 伪装、管道执行和注入风险。', 'Control Tirith content scanning before terminal commands run to catch obvious URL spoofing, pipe-to-shell, and injection risks.', '控制終端命令執行前的 Tirith 內容掃描，攔截明顯的 URL 偽裝、管道執行和注入風險。'),
  hermesSecurityConfigStatusReady: _('结构化配置', 'structured settings', '結構化設定'),
--- a/tests/hermes-config-page-ui.test.js
+++ b/tests/hermes-config-page-ui.test.js
@@ -428,6 +428,11 @@ test('Hermes 配置页会暴露语音转写结构化配置字段', () => {
 test('Hermes 配置页会暴露 Kanban 调度稳定性结构化配置字段', () => {
  for (const id of [
    'hm-kanban-config-save',
+    'hm-kanban-dispatch-in-gateway',
+    'hm-kanban-dispatch-interval-seconds',
+    'hm-kanban-failure-limit',
+    'hm-kanban-auto-decompose',
+    'hm-kanban-auto-decompose-per-tick',
    'hm-kanban-dispatch-stale-timeout-seconds',
  ]) {
    assert.match(source, new RegExp(`id="${id}"`), `缺少 ${id}`)
--- a/tests/hermes-kanban-config.test.js
+++ b/tests/hermes-kanban-config.test.js
@@ -10,6 +10,11 @@ test('Hermes Kanban 配置读取会提供上游默认值', () => {
  const values = buildHermesKanbanConfigValues({})

  assert.deepEqual(values, {
+    dispatchInGateway: true,
+    dispatchIntervalSeconds: 60,
+    failureLimit: 2,
+    autoDecompose: true,
+    autoDecomposePerTick: 3,
    dispatchStaleTimeoutSeconds: 14400,
  })
 })
@@ -17,10 +22,20 @@ test('Hermes Kanban 配置读取会提供上游默认值', () => {
 test('Hermes Kanban 配置读取会规范化已有字段', () => {
  const values = buildHermesKanbanConfigValues({
    kanban: {
+      dispatch_in_gateway: false,
+      dispatch_interval_seconds: '120',
+      failure_limit: '5',
+      auto_decompose: false,
+      auto_decompose_per_tick: '7',
      dispatch_stale_timeout_seconds: '7200',
    },
  })

+  assert.equal(values.dispatchInGateway, false)
+  assert.equal(values.dispatchIntervalSeconds, 120)
+  assert.equal(values.failureLimit, 5)
+  assert.equal(values.autoDecompose, false)
+  assert.equal(values.autoDecomposePerTick, 7)
  assert.equal(values.dispatchStaleTimeoutSeconds, 7200)
 })

@@ -33,17 +48,38 @@ test('Hermes Kanban 配置保存会保留未知 YAML 并写入 kanban', () => {
    },
    memory: { memory_enabled: true },
  }, {
+    dispatchInGateway: false,
+    dispatchIntervalSeconds: '15',
+    failureLimit: '4',
+    autoDecompose: false,
+    autoDecomposePerTick: '2',
    dispatchStaleTimeoutSeconds: '0',
  })

  assert.deepEqual(next.model, { provider: 'anthropic' })
  assert.deepEqual(next.memory, { memory_enabled: true })
-  assert.equal(next.kanban.dispatch_interval_seconds, 30)
  assert.equal(next.kanban.custom_flag, 'keep-me')
+  assert.equal(next.kanban.dispatch_in_gateway, false)
+  assert.equal(next.kanban.dispatch_interval_seconds, 15)
+  assert.equal(next.kanban.failure_limit, 4)
+  assert.equal(next.kanban.auto_decompose, false)
+  assert.equal(next.kanban.auto_decompose_per_tick, 2)
  assert.equal(next.kanban.dispatch_stale_timeout_seconds, 0)
 })

-test('Hermes Kanban 配置保存会拒绝非法超时', () => {
+test('Hermes Kanban 配置保存会拒绝非法调度参数', () => {
+  assert.throws(
+    () => mergeHermesKanbanConfig({}, { dispatchIntervalSeconds: '0' }),
+    /kanban\.dispatch_interval_seconds/,
+  )
+  assert.throws(
+    () => mergeHermesKanbanConfig({}, { failureLimit: '0' }),
+    /kanban\.failure_limit/,
+  )
+  assert.throws(
+    () => mergeHermesKanbanConfig({}, { autoDecomposePerTick: '0' }),
+    /kanban\.auto_decompose_per_tick/,
+  )
  assert.throws(
    () => mergeHermesKanbanConfig({}, { dispatchStaleTimeoutSeconds: '-1' }),
    /kanban\.dispatch_stale_timeout_seconds/,