@goodandready/dsh-moa 0.2.71 → 0.2.72

package/README.md

@@ -180,6 +180,12 @@ Seamlessly retains synthesized baseline code from prior turns while pruning inte
 ### 18. Graceful Degradation & Local Fallback Resilience
 When `local_fallback_enabled: true`, candidates that fail due to network outages, timeouts, or rate limits (429/500) automatically recover using configured local models (Ollama / MiniPC). Each fallback model operates with an independent execution budget and an isolated controller linked to the parent turn signal, preventing cloud timeouts from starving fallback models. Additionally, terminal errors and aborted streams are strictly classified, ensuring reliable error propagation and failover.
 
+### 19. Zero-Token Local Pre-Judge Syntax Filter
+Validates markdown code blocks across all candidate outputs locally using JavaScript/TypeScript AST checking, JSON parsing, and bracket/quote balance verification before calling the Judge LLM. When malformed candidates are detected, they are automatically disqualified or annotated with structured syntax error reports, saving judge tokens and preventing syntax errors from propagating. Configured via `local_preflight_check: true` (enabled by default).
+
+### 20. Early Exit upon Semantic Consensus
+Compares normalized candidate proposals using token-level Sørensen-Dice similarity. When models arrive at identical or near-identical solutions (meeting or exceeding `early_exit_threshold`, default: `0.95`), the expensive Judge synthesis phase is automatically bypassed. The consensus solution is promoted directly to the workspace, saving up to 100% of judge token costs while accelerating pipeline latency. Configured via `early_exit_consensus_enabled: true` and `early_exit_threshold: 0.95`.
+
 ### 6. Live Canvas 1-Click Preview (optional)
 If `@goodandready/dsh-live-canvas` is installed in the same profile, `dsh-moa` pushes the promoted HTML file to the Live Canvas REST contract (`POST /dsh-live-canvas/api/preview`, served by the same harness webServer) and appends a one-click preview link (`/dsh-live-canvas/sandbox/<id>`) to the answer. Without the plugin the step is skipped silently — no errors in the log, no dead links.
 
@@ -289,6 +295,9 @@ dsh-moa:
 | `presets[].quorum_enabled` | `boolean` | `false` | Straggler mitigation: proceed with synthesis once >= 60% candidates respond |
 | `presets[].grace_period_sec` | `number` | `10` | Grace period in seconds to wait for stragglers after quorum is reached |
 | `presets[].aggregator_fallbacks` | `array` | `[]` | Ordered fallback judge models tried if primary aggregator encounters transient errors |
+| `presets[].local_preflight_check` | `boolean` | `true` | Zero-token local AST, JSON, and bracket balance verification for candidate code blocks before the Judge panel |
+| `presets[].early_exit_consensus_enabled` | `boolean` | `false` | Bypass Judge evaluation and promote directly when candidate solutions reach high semantic consensus |
+| `presets[].early_exit_threshold` | `number` | `0.95` | Token-level similarity threshold (0.50 to 1.00) required to trigger early exit consensus |
 | `presets[].blind_evaluation` | `boolean` | `false` | Anonymize candidate model names for the judge/curator to eliminate family/brand bias |
 | `presets[].reference_timeout_sec` | `number` | `60` | Per-candidate execution timeout in seconds |
 | `presets[].aggregator_timeout_sec` | `number` | `180` | Aggregator/judge synthesis timeout in seconds |

package/README.ru.md

@@ -180,6 +180,12 @@ graph TD
 ### 18. Плавная деградация и локальный фоллбэк
 Опция `local_fallback_enabled` позволяет задать резервные локальные модели (Ollama, vLLM, MiniPC), к которым плагин бесшовно обращается при сбоях сетевых API, таймаутах или превышении лимитов rate limit (429/500). Каждая фоллбэк-модель запускается с независимым бюджетом времени и изолированным контроллером отмены, связанным с сигналом основного хода, предотвращая исчерпание времени ожидания из-за задержек облачных провайдеров. Стриминговые сбои и терминальные ошибки классифицируются типизированными исключениями с гарантированной защитой от позднего промоушна.
 
+### 19. Локальный синтаксический шлюз кандидатов без расхода токенов
+Локально парсит блоки кода из Markdown-ответов кандидатов и проверяет их синтаксис (JavaScript, TypeScript, JSON, Python) и баланс скобок/кавычек до вызова дорогостоящей модели-судьи. Кандидаты с синтаксическими ошибками дисквалифицируются или помечаются структурированными аннотациями для судьи, полностью исключая лишний расход токенов на заведомо невалидный код. Включается настройкой `local_preflight_check: true` (включена по умолчанию).
+
+### 20. Ранний выход по семантическому консенсусу
+Сравнивает нормализованные решения кандидатов по токенному сходству Сёренсена-Дайса. Если решения моделей совпадают или практически идентичны (достигнут порог `early_exit_threshold`, по умолчанию 0.95), стадия вызова судьи (Judge) пропускается. Согласованный вариант немедленно продвигается в проект, экономя до 100% токенов судейской коллегии и сокращая задержку ответа. Управляется параметрами `early_exit_consensus_enabled: true` и `early_exit_threshold: 0.95`.
+
 ### 6. Live Canvas 1-клик предпросмотр (опционально)
 Если в профиле установлен `@goodandready/dsh-live-canvas`, `dsh-moa` отправляет промоученный HTML-файл в REST-контракт Live Canvas (`POST /dsh-live-canvas/api/preview`, тот же webServer харнесса) и добавляет к ответу ссылку на предпросмотр (`/dsh-live-canvas/sandbox/<id>`). Без плагина шаг пропускается тихо — без ошибок в журнале и без битых ссылок.
 
@@ -289,6 +295,9 @@ dsh-moa:
 | `presets[].quorum_enabled` | `boolean` | `false` | Защита от зависших моделей (stragglers): запуск синтеза при ответе от >= 60% кандидатов |
 | `presets[].grace_period_sec` | `number` | `10` | Грейс-период (в секундах) ожидания оставшихся моделей после достижения кворума |
 | `presets[].aggregator_fallbacks` | `array` | `[]` | Список запасных моделей-судей при сбоях основной модели агрегатора |
+| `presets[].local_preflight_check` | `boolean` | `true` | Локальная проверка AST, JSON и баланса скобок в блоках кода кандидатов без расхода токенов |
+| `presets[].early_exit_consensus_enabled` | `boolean` | `false` | Пропуск этапа судьи и прямое продвижение при достижении семантического консенсуса кандидатов |
+| `presets[].early_exit_threshold` | `number` | `0.95` | Порог токенного сходства (0.50–1.00) для срабатывания раннего выхода по консенсусу |
 | `presets[].blind_evaluation` | `boolean` | `false` | Обезличивание имен кандидатов («Candidate 1», «Candidate 2») для исключения предвзятости судьи |
 | `presets[].reference_timeout_sec` | `number` | `60` | Таймаут опроса каждого кандидата в секундах |
 | `presets[].aggregator_timeout_sec` | `number` | `180` | Таймаут синтеза решения судьей в секундах |

package/README.zh.md

@@ -157,6 +157,12 @@ graph TD
 ### 18. 平滑降级与本地容灾恢复 (Local Fallback Resilience)
 当 `local_fallback_enabled: true` 时，因网络中断、超时或速率限制（429/500）而失败的候选模型会自动使用配置的本地模型（Ollama / MiniPC）恢复。每个后备模型都拥有独立的超时执行配额与关联主 turn signal 的隔离取消控制器，防止云端超时耗尽本地恢复时间。同时严格检测终止错误与流中断，确保安全容灾且杜绝已取消 turn 的延迟文件提升。
 
+### 19. 零 Token 本地预审语法网关 (Zero-Token Pre-Judge Syntax Filter)
+在调用裁判模型之前，在本地解析所有候选方案的 Markdown 代码块，进行 JavaScript/TypeScript AST 语法校验、JSON 解析以及括号/引号匹配检查。检测到语法损坏的候选将被自动过滤或附带结构化语法错误注解，无需消耗模型 Token 即可杜绝语法缺陷代码流入最终裁决。通过 `local_preflight_check: true` 配置（默认开启）。
+
+### 20. 语义共识提前退出机制 (Early Exit upon Semantic Consensus)
+基于 Token 级 Sørensen-Dice 相似度算法比对归一化后的候选方案。当多个候选模型给出高度一致的代码方案（达到或超过 `early_exit_threshold` 阈值，默认 0.95）时，自动跳过高耗费的裁判综合评审阶段，直接将共识方案提升至项目，在大幅缩短响应延迟的同时节省多达 100% 的裁判 Token 支出。通过 `early_exit_consensus_enabled: true` 与 `early_exit_threshold: 0.95` 配置。
+
 ### 6. Live Canvas 一键预览（可选）
 若同一 profile 中安装了 `@goodandready/dsh-live-canvas`，`dsh-moa` 会将提升后的 HTML 文件推送到 Live Canvas 的 REST 契约（`POST /dsh-live-canvas/api/preview`，由同一 harness webServer 提供服务），并在回答中附上一键预览链接（`/dsh-live-canvas/sandbox/<id>`）。未安装该插件时此步骤静默跳过——日志无报错，也不会出现死链接。
 
@@ -225,6 +231,9 @@ dsh-moa:
 | `presets[].reference_models` | `array` | `[...]` | 并行提案阶段并发调用的顾问模型列表 |
 | `presets[].aggregator` | `object` | `{...}` | 负责综合评审、代码审查与裁决胜出者的裁判模型 |
 | `presets[].ask_clarifying_questions` | `boolean` | `true` | 针对宽泛需求合成澄清问卷（预设级别开关） |
+| `presets[].local_preflight_check` | `boolean` | `true` | 在裁判评审前本地验证候选代码块的 AST、JSON 与括号平衡（零 Token 消耗） |
+| `presets[].early_exit_consensus_enabled` | `boolean` | `false` | 当候选方案达成高语义共识时跳过裁判评审并直接提升获胜方案 |
+| `presets[].early_exit_threshold` | `number` | `0.95` | 触发语义共识提前退出的 Token 相似度阈值（0.50 至 1.00） |
 | `presets[].reference_temperature` / `.aggregator_temperature` | `number` | `0.6` / `0.4` | 顾问与裁判的采样温度 |
 | `presets[].max_tokens` | `number` | `4096` | 每次模型调用的最大输出 Token 数 |
 | `presets[].judge_criteria` | `string` | `""` | 传给裁判的可选附加评审准则 |

package/lib/client.js

@@ -185,6 +185,10 @@ window.__ModuleLoader__.load({
       "aggregator.workbench_desc": "Judge scores each candidate file from 1 to 10 with pros/cons. Select desired files across candidates; top model harmonizes and glues them, followed by final judge audit.",
       "aggregator.workbench_companion": "Companion Plugin:",
       "aggregator.workbench_companion_note": "safe shadow Git checkpoints before file promotion",
+      "aggregator.preflight_syntax_title": "\u{1F50D} Pre-Judge Local Syntax Gate (Zero-Token Linter)",
+      "aggregator.preflight_syntax_desc": "Validate candidate code syntax locally before judge invocation to filter broken code without token costs.",
+      "aggregator.early_consensus_title": "\u26A1 Early Exit upon Semantic Consensus",
+      "aggregator.early_consensus_desc": "Bypass the expensive judge round when reference models converge on equivalent code solutions.",
       "workbench.title": "\u{1F6E0}\uFE0F Interactive Synthesis Workbench",
       "workbench.desc": "Inspect candidate file quality scores (1\u201310), mix and match files across proposals, harmonize with top-model glue, and run a final judge audit.",
       "workbench.select_run": "MoA Run:",
@@ -379,6 +383,10 @@ window.__ModuleLoader__.load({
       "aggregator.workbench_desc": "\u88C1\u5224\u4E3A\u6BCF\u4E2A\u5019\u9009\u6587\u4EF6\u6253\u5206 (1-10) \u5E76\u6807\u6CE8\u4F18\u7F3A\u70B9\u3002\u5728 UI \u4E2D\u81EA\u7531\u7EC4\u5408\u5404\u5019\u9009\u6587\u4EF6\uFF0C\u7531\u5F53\u8F6E\u6700\u9AD8\u5206\u6A21\u578B\u8FDB\u884C\u4EE3\u7801\u7C98\u5408\u7EDF\u4E00\uFF0C\u6700\u7EC8\u7531\u88C1\u5224\u590D\u5BA1\u3002",
       "aggregator.workbench_companion": "\u914D\u5957\u63D2\u4EF6\uFF1A",
       "aggregator.workbench_companion_note": "\u6587\u4EF6\u63D0\u5347\u524D\u5B89\u5168\u521B\u5EFA\u5F71\u5B50 Git \u5FEB\u7167",
+      "aggregator.preflight_syntax_title": "\u{1F50D} \u8BC4\u5BA1\u524D\u672C\u5730\u8BED\u6CD5\u68C0\u67E5\u95E8\u7981\uFF08\u96F6Token\u5F00\u9500\uFF09",
+      "aggregator.preflight_syntax_desc": "\u5728\u8C03\u7528\u88C1\u5224\u6A21\u578B\u524D\u5BF9\u5019\u9009\u4EE3\u7801\u8FDB\u884C\u672C\u5730\u8BED\u6CD5\u68C0\u67E5\uFF0C\u96F6Token\u5254\u9664\u8BED\u6CD5\u7834\u635F\u4EE3\u7801\u3002",
+      "aggregator.early_consensus_title": "\u26A1 \u8BED\u4E49\u5171\u8BC6\u5FEB\u901F\u76F4\u51FA\uFF08Early Exit\uFF09",
+      "aggregator.early_consensus_desc": "\u5F53\u591A\u5019\u9009\u6A21\u578B\u751F\u6210\u4E00\u81F4\u4EE3\u7801\uFF08\u76F8\u4F3C\u5EA6\u8FBE\u6807\uFF09\u65F6\uFF0C\u76F4\u63A5\u8FD4\u56DE\u5171\u8BC6\u89E3\uFF0C\u8DF3\u8FC7\u88C1\u5224\u9636\u6BB5\u8282\u7EA6Token\u4E0E\u8017\u65F6\u3002",
       "workbench.title": "\u{1F6E0}\uFE0F \u4EA4\u4E92\u5F0F\u5408\u6210\u5DE5\u4F5C\u53F0",
       "workbench.desc": "\u67E5\u770B\u5019\u9009\u6A21\u578B\u7684\u6587\u4EF6\u8D28\u91CF\u6253\u5206 (1\u201310)\uFF0C\u81EA\u7531\u6DF7\u642D\u7EC4\u5408\u76EE\u6807\u6587\u4EF6\uFF0C\u7531\u6700\u9AD8\u5206\u6A21\u578B\u7C98\u5408\u7EDF\u4E00\u5E76\u6267\u884C\u6700\u7EC8\u88C1\u5224\u590D\u5BA1\u3002",
       "workbench.select_run": "MoA \u8FD0\u884C\uFF1A",
@@ -2312,6 +2320,43 @@ window.__ModuleLoader__.load({
                   )
                 )
               ),
+              /* Pre-Judge Local Syntax Gate (#303) & Early Semantic Consensus (#299) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 6, padding: "8px 12px", background: "var(--dsw-alias-bg-layer-2)", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2)", marginTop: 8 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: currentPreset.local_preflight_check !== false,
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, local_preflight_check: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.preflight_syntax_title") || "\u{1F50D} Pre-Judge Local Syntax Gate (Zero-Token Linter)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.preflight_syntax_desc") || "Validate candidate code syntax locally before judge invocation to filter broken code without token costs."
+                ),
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500, marginTop: 4 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.early_exit_consensus_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, early_exit_consensus_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.early_consensus_title") || "\u26A1 Early Exit upon Semantic Consensus"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.early_consensus_desc") || "Bypass the expensive judge round when reference models converge on equivalent code solutions."
+                )
+              ),
               /* Multi-Turn Context & Diff Pruning (#176) */
               React.createElement(
                 "div",

package/lib/events.js

@@ -5,6 +5,8 @@
 export const MOA_EVENTS = {
   RUN_START: 'moa/run-start',
   CANDIDATE_COMPLETE: 'moa/candidate-complete',
+  SYNTAX_VALIDATION: 'moa/syntax-validation',
+  EARLY_CONSENSUS: 'moa/early-consensus',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
   RUN_FINISH: 'moa/run-finish',
@@ -28,3 +30,4 @@ export function emitEvent(ctx, eventName, payload) {
     /* best-effort event dispatch: listener exceptions must never abort pipeline */
   }
 }
+

package/lib/moa-adversarial-tdd.js

@@ -184,7 +184,9 @@ export async function runAdversarialTddLoop({
       try {
         const dest = assertPathContained(candDir, tf.relativePath)
         await fs.rm(dest, { force: true })
-      } catch {}
+      } catch (err) {
+        logger.debug('[dsh-moa:tdd] cleanup test file error:', err?.message || err)
+      }
     }
 
     if (gateRes) {
@@ -217,3 +219,4 @@ export async function runAdversarialTddLoop({
     directive: results.length > 0 ? reportLines.join('\n') : '',
   }
 }
+

package/lib/moa-ast-merge.js

@@ -24,7 +24,9 @@ export function resolveContextLensService(ctx, explicitLens = null) {
       const refl = ctx.reflect.get('contextLens') || ctx.reflect.get('dsh-context-lens')
       if (refl) return refl
     }
-  } catch {}
+  } catch (err) {
+    logger.debug('[dsh-moa:ast] context-lens reflection error:', err?.message || err)
+  }
   return null
 }
 
@@ -228,3 +230,4 @@ export async function buildAstCompositeMergeDirective(candidates = [], options =
     directive,
   }
 }
+

package/lib/moa-schema.js

@@ -76,6 +76,9 @@ export const PresetSchema = z.object({
   speculative_moa_enabled: z.boolean().default(false),
   speculative_draft_model: ModelSlotSchema.default({ provider: "", model: "" }),
   adversarial_tdd_enabled: z.boolean().default(false),
+  local_preflight_check: z.boolean().default(true),
+  early_exit_consensus_enabled: z.boolean().default(false),
+  early_exit_threshold: z.number().default(0.95),
 })
 
 export const Config = z.object({
@@ -98,6 +101,9 @@ export const Config = z.object({
   speculative_moa_enabled: z.boolean().default(false).volatile(),
   speculative_draft_model: ModelSlotSchema.default({ provider: "", model: "" }).volatile(),
   adversarial_tdd_enabled: z.boolean().default(false).volatile(),
+  local_preflight_check: z.boolean().default(true).volatile(),
+  early_exit_consensus_enabled: z.boolean().default(false).volatile(),
+  early_exit_threshold: z.number().default(0.95).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([
@@ -159,3 +165,4 @@ export function plainConfig(value) {
   }
   return value
 }
+

package/lib/moa-swarm.js

@@ -114,17 +114,23 @@ export async function cleanupSwarmWorktrees(cwd, runId, worktrees = []) {
     if (wt.isGitWorktree) {
       try {
         await execFileAsync('git', ['worktree', 'remove', '--force', wt.worktreePath], { cwd, timeout: 8000 })
-      } catch {}
+      } catch (err) {
+        logger.debug('[dsh-moa:swarm] cleanup worktree remove error:', err?.message || err)
+      }
     }
     try {
       await fs.rm(wt.worktreePath, { recursive: true, force: true })
-    } catch {}
+    } catch (err) {
+      logger.debug('[dsh-moa:swarm] cleanup rm error:', err?.message || err)
+    }
   }
 
   if (await isGitRepository(cwd)) {
     try {
       await execFileAsync('git', ['worktree', 'prune'], { cwd, timeout: 5000 })
-    } catch {}
+    } catch (err) {
+      logger.debug('[dsh-moa:swarm] cleanup prune error:', err?.message || err)
+    }
   }
 
   const safeRunId = String(runId || '').replace(/[^a-zA-Z0-9_-]/g, '')
@@ -132,7 +138,9 @@ export async function cleanupSwarmWorktrees(cwd, runId, worktrees = []) {
     const swarmRoot = path.join(cwd, '.moa', `swarm-${safeRunId}`)
     try {
       await fs.rm(swarmRoot, { recursive: true, force: true })
-    } catch {}
+    } catch (err) {
+      logger.debug('[dsh-moa:swarm] cleanup swarmRoot error:', err?.message || err)
+    }
   }
 }
 
@@ -217,3 +225,4 @@ export async function runSubagentSwarm(references, messages, options = {}, callL
     await cleanupSwarmWorktrees(cwd, runId, worktrees)
   }
 }
+

package/lib/pipeline/context.js

@@ -38,6 +38,9 @@ export async function stageProjectContext({
   const isBlindEvaluation = Boolean(preset?.blind_evaluation)
   const isPeerCritiqueEnabled = Boolean(preset?.peer_critique_enabled)
   const allowCandidateOverride = Boolean(preset?.allow_candidate_override)
+  const localPreflightCheck = preset?.local_preflight_check !== false
+  const earlyExitConsensusEnabled = Boolean(preset?.early_exit_consensus_enabled)
+  const earlyExitThreshold = typeof preset?.early_exit_threshold === 'number' ? preset.early_exit_threshold : 0.95
 
   const collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
@@ -123,5 +126,7 @@ export async function stageProjectContext({
     allowCandidateOverride, collectedCtx, isRefinement, projectContext,
     effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
+    localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
   }
 }
+

package/lib/pipeline/early-consensus.js

@@ -0,0 +1,324 @@
+/**
+ * Early Exit upon Semantic Consensus (#299)
+ * Detects convergence between reference candidates and bypasses judge round when consensus >= threshold.
+ * Saves up to 60-80% tokens and latency on requests where candidates converge.
+ */
+
+import { logger } from '../logger.js'
+import { promoteCandidateWorkspace, cleanMoaWorkspaces } from '../workspace/fs.js'
+import { createPromotedPreview } from '../live-canvas.js'
+import { recordMoaRunAsync, candidatesForHistory } from '../history.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
+import { estimateTokenCost } from '../pricing.js'
+
+/**
+ * Normalizes text/code by stripping comments and normalizing whitespace for consensus comparison.
+ * @param {string} text
+ * @returns {string}
+ */
+export function normalizeForConsensus(text = '') {
+  if (typeof text !== 'string') return ''
+  return text
+    // Strip block comments /* ... */
+    .replace(/\/\*[\s\S]*?\*\//g, '')
+    // Strip JS/TS single line comments // ...
+    .replace(/\/\/.*$/gm, '')
+    // Strip Python/Shell comments # ...
+    .replace(/(^|\s)#.*$/gm, '$1')
+    // Normalize newlines
+    .replace(/\r?\n/g, '\n')
+    // Collapse horizontal whitespace
+    .replace(/[ \t]+/g, ' ')
+    // Collapse multi-blank lines
+    .replace(/\n\s*\n/g, '\n')
+    .trim()
+}
+
+/**
+ * Calculates Sørensen-Dice similarity coefficient between two code/text snippets (0.0 to 1.0).
+ * @param {string} textA
+ * @param {string} textB
+ * @returns {number}
+ */
+export function calculateSimilarity(textA = '', textB = '') {
+  const normA = normalizeForConsensus(textA)
+  const normB = normalizeForConsensus(textB)
+
+  if (normA === normB) return 1.0
+  if (!normA || !normB) return 0.0
+
+  const tokensA = normA.match(/[\w$]+|[^\s\w]/g) || []
+  const tokensB = normB.match(/[\w$]+|[^\s\w]/g) || []
+
+  if (tokensA.length === 0 && tokensB.length === 0) return 1.0
+  if (tokensA.length === 0 || tokensB.length === 0) return 0.0
+
+  const freqA = new Map()
+  for (const t of tokensA) freqA.set(t, (freqA.get(t) || 0) + 1)
+
+  const freqB = new Map()
+  for (const t of tokensB) freqB.set(t, (freqB.get(t) || 0) + 1)
+
+  let intersection = 0
+  for (const [token, countA] of freqA.entries()) {
+    const countB = freqB.get(token) || 0
+    intersection += Math.min(countA, countB)
+  }
+
+  const dice = (2 * intersection) / (tokensA.length + tokensB.length)
+  return Number(dice.toFixed(4))
+}
+
+/**
+ * Checks if candidates have reached semantic consensus above threshold.
+ * @param {Array<object>} candidates
+ * @param {number} [threshold=0.95]
+ * @returns {{ reached: boolean, similarity: number, winnerIndex: number, consensusIndices: number[], winnerCandidate: object | null, reason: string }}
+ */
+export function checkSemanticConsensus(candidates = [], threshold = 0.95) {
+  if (!Array.isArray(candidates) || candidates.length < 2) {
+    return {
+      reached: false,
+      similarity: 0,
+      winnerIndex: 0,
+      consensusIndices: [],
+      winnerCandidate: null,
+      reason: 'Insufficient candidates for consensus check',
+    }
+  }
+
+  const n = candidates.length
+  let maxSim = 0
+  let bestPair = [0, 1]
+  const matrix = Array.from({ length: n }, () => new Float32Array(n))
+
+  for (let i = 0; i < n; i++) {
+    matrix[i][i] = 1.0
+    for (let j = i + 1; j < n; j++) {
+      const sim = calculateSimilarity(candidates[i].text || '', candidates[j].text || '')
+      matrix[i][j] = sim
+      matrix[j][i] = sim
+      if (sim > maxSim) {
+        maxSim = sim
+        bestPair = [i, j]
+      }
+    }
+  }
+
+  if (maxSim < threshold) {
+    return {
+      reached: false,
+      similarity: maxSim,
+      winnerIndex: 0,
+      consensusIndices: [],
+      winnerCandidate: null,
+      reason: `Max pairwise similarity ${maxSim} is below consensus threshold ${threshold}`,
+    }
+  }
+
+  // Find consensus cluster matching threshold with the best pair
+  const clusterSet = new Set(bestPair)
+  for (let k = 0; k < n; k++) {
+    if (k === bestPair[0] || k === bestPair[1]) continue
+    if (matrix[k][bestPair[0]] >= threshold && matrix[k][bestPair[1]] >= threshold) {
+      clusterSet.add(k)
+    }
+  }
+
+  const consensusIndices = Array.from(clusterSet).map((idx) => candidates[idx].index ?? idx)
+  const clusterCandidates = Array.from(clusterSet).map((idx) => candidates[idx])
+
+  // Select winner from consensus cluster (prioritize valid syntax, then lowest error count)
+  let winner = clusterCandidates[0]
+  for (const c of clusterCandidates) {
+    if (c.syntaxValidation?.valid && !winner.syntaxValidation?.valid) {
+      winner = c
+    }
+  }
+
+  return {
+    reached: true,
+    similarity: maxSim,
+    winnerIndex: winner.index ?? 1,
+    consensusIndices,
+    winnerCandidate: winner,
+    reason: `Semantic consensus reached (${maxSim} >= ${threshold}) across candidates ${consensusIndices.join(', ')}`,
+  }
+}
+
+/**
+ * Estimates saved tokens and cost from bypassing the judge round.
+ * @param {Array<object>} candidates
+ * @param {string} prompt
+ * @param {number} [maxTokens=4096]
+ * @param {object} [prices={}]
+ * @returns {{ skippedTokens: number, skippedCostUsd: number }}
+ */
+export function estimateSkippedJudgeUsage(candidates = [], prompt = '', maxTokens = 4096, prices = {}) {
+  const promptChars = (prompt?.length || 0) + candidates.reduce((sum, c) => sum + (c.text?.length || 0), 0)
+  const estimatedInputTokens = Math.max(100, Math.round(promptChars / 3.8))
+  const estimatedOutputTokens = Math.min(Math.max(200, Math.round(maxTokens * 0.25)), 1000)
+  const skippedTokens = estimatedInputTokens + estimatedOutputTokens
+
+  const costEst = estimateTokenCost({ provider: 'default', model: 'judge' }, {
+    inputTokens: estimatedInputTokens,
+    outputTokens: estimatedOutputTokens,
+  }, prices)
+
+  return {
+    skippedTokens,
+    skippedCostUsd: Number((costEst?.costUsd || 0.005).toFixed(5)),
+  }
+}
+
+/**
+ * Evaluates candidates for early consensus and executes early exit bypass if reached.
+ * @param {object} params
+ * @returns {Promise<{ ok: boolean, consensusReached: boolean, payload?: object, error?: Error, abort?: boolean }>}
+ */
+export function stageEarlyConsensus({
+  successfulRefs = [],
+  referenceOutputs = [],
+  preset = {},
+  userPrompt = '',
+  prices = {},
+  maxTokens = 4096,
+  cwd = process.cwd(),
+  runId = '',
+  signal = null,
+  promoteOpts = {},
+  allowCandidateOverride = false,
+  isRefinement = false,
+  historyFilePath = null,
+  startTime = Date.now(),
+  collectedCtx = null,
+  liveCanvas = null,
+  ctx = null,
+}) {
+  const enabled = Boolean(preset?.early_exit_consensus_enabled)
+  const threshold = typeof preset?.early_exit_threshold === 'number' ? preset.early_exit_threshold : 0.95
+
+  if (!enabled || successfulRefs.length < 2) {
+    return Promise.resolve({ ok: true, consensusReached: false })
+  }
+
+  const consensus = checkSemanticConsensus(successfulRefs, threshold)
+  if (!consensus.reached || !consensus.winnerCandidate) {
+    return Promise.resolve({ ok: true, consensusReached: false, similarity: consensus.similarity })
+  }
+
+  const winner = consensus.winnerCandidate
+  emitEvent(ctx, MOA_EVENTS.EARLY_CONSENSUS, {
+    runId,
+    similarity: consensus.similarity,
+    threshold,
+    winnerIndex: consensus.winnerIndex,
+    winnerModel: winner.label,
+    consensusCandidates: consensus.consensusIndices,
+  })
+
+  // Promote winning candidate files
+  let promotedFiles = []
+  let promoteErr = null
+  const runPromotion = async () => {
+    if (winner.files?.length > 0) {
+      try {
+        promotedFiles = await promoteCandidateWorkspace(cwd, winner.index, {
+          ...promoteOpts,
+          runId,
+          keepMoa: allowCandidateOverride,
+        })
+      } catch (err) {
+        promoteErr = err
+      }
+    } else if (!allowCandidateOverride) {
+      await cleanMoaWorkspaces(cwd, { runId })
+    }
+
+    if (promoteErr) {
+      if (!allowCandidateOverride) await cleanMoaWorkspaces(cwd, { runId })
+      if (signal?.aborted || promoteErr?.message?.includes('aborted')) {
+        return { ok: false, consensusReached: true, abort: true, error: new Error('Turn aborted') }
+      }
+    }
+
+    const skippedUsage = estimateSkippedJudgeUsage(successfulRefs, userPrompt, maxTokens, prices)
+    const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, {
+      winningIndex: winner.index,
+    })
+
+    const totalTokens = referenceOutputs.reduce((acc, r) => acc + (r.usage?.totalTokens || 0), 0)
+    const totalCostUsd = Number(referenceOutputs.reduce((acc, r) => acc + (r.costUsd || 0), 0).toFixed(5))
+    const durationMs = Date.now() - startTime
+
+    try {
+      await recordMoaRunAsync({
+        id: runId,
+        cwd,
+        prompt: userPrompt,
+        preset: preset?.name || 'default',
+        isRefinement,
+        isEarlyConsensus: true,
+        candidates: candidatesForHistory(referenceOutputs),
+        aggregator: 'Early Consensus (Bypassed)',
+        winnerIndex: winner.index,
+        winnerModel: winner.label,
+        promotedFiles,
+        totalTokens,
+        totalCostUsd,
+        skippedJudgeTokens: skippedUsage.skippedTokens,
+        durationMs,
+      }, historyFilePath || undefined)
+    } catch (histErr) {
+      logger.warn('[dsh-moa] Failed to record early consensus in history:', histErr?.message || histErr)
+    }
+
+    emitEvent(ctx, MOA_EVENTS.RUN_FINISH, {
+      runId,
+      durationMs,
+      totalTokens,
+      totalCostUsd,
+      promotedFiles,
+      winnerIndex: winner.index,
+      isEarlyConsensus: true,
+    })
+
+    return {
+      ok: true,
+      consensusReached: true,
+      payload: {
+        kind: 'synthesis',
+        content: winner.text,
+        aggregator: 'Early Consensus (Bypassed)',
+        references: referenceOutputs,
+        presetName: preset?.name || 'default',
+        isRefinement,
+        isEarlyConsensus: true,
+        winningIndex: winner.index,
+        winnerModel: winner.label,
+        promotedFiles,
+        runId,
+        consensusInfo: {
+          similarity: consensus.similarity,
+          threshold,
+          consensusIndices: consensus.consensusIndices,
+        },
+        ...(livePreview ? { liveCanvas: livePreview } : {}),
+        usage: {
+          totalTokens,
+          totalCostUsd,
+          skippedJudgeTokens: skippedUsage.skippedTokens,
+          skippedJudgeCostUsd: skippedUsage.skippedCostUsd,
+          candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: r.costUsd })),
+          aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+        },
+        skippedFiles: collectedCtx?.skippedFiles || 0,
+        skippedList: collectedCtx?.skippedList || [],
+        durationMs,
+      },
+    }
+  }
+
+  return runPromotion()
+}
+

package/lib/pipeline/runner.js

@@ -13,6 +13,8 @@ import { stagePeerCritique } from './peer-critique.js'
 import { stageMultiJudge } from './multi-judge.js'
 import { stageSynthesis } from './synthesis.js'
 import { stagePromotion } from './promotion.js'
+import { applySyntaxFilter, formatSyntaxDirective } from './syntax-filter.js'
+import { stageEarlyConsensus } from './early-consensus.js'
 import { emitEvent, MOA_EVENTS } from '../events.js'
 
 export async function runMoAPipeline({
@@ -90,6 +92,16 @@ export async function runMoAPipeline({
     })
   }
 
+  // Pre-Judge Stage 2.5: Zero-Token Local Syntax Gate (#303)
+  const syntaxResult = applySyntaxFilter(successfulRefs, { enabled: ctxStage.localPreflightCheck })
+  emitEvent(ctx, MOA_EVENTS.SYNTAX_VALIDATION, {
+    runId,
+    filterApplied: syntaxResult.filterApplied,
+    validCount: syntaxResult.validCandidates.length,
+    invalidCount: syntaxResult.invalidCandidates.length,
+  })
+  const syntaxDirective = syntaxResult.filterApplied ? formatSyntaxDirective(referenceOutputs, { blind: ctxStage.isBlindEvaluation }) : null
+
   // Stage 3: Clarifying Questions Branch
   if (ctxStage.needsQuestions) {
     return await stageClarifyingQuestions({
@@ -103,7 +115,8 @@ export async function runMoAPipeline({
   // Stage 4: Fast Mode (1 candidate bypass)
   if (ctxStage.isFastMode) {
     const fastRes = await stageFastMode({
-      successfulRefs, referenceOutputs,
+      successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+      referenceOutputs,
       allowCandidateOverride: ctxStage.allowCandidateOverride,
       promoteOpts, cwd, runId, signal, userPrompt, preset,
       isRefinement: ctxStage.isRefinement, historyFilePath, startTime,
@@ -116,6 +129,32 @@ export async function runMoAPipeline({
     return fastRes.payload
   }
 
+  // Pre-Judge Stage 4.5: Early Exit upon Semantic Consensus (#299)
+  if (ctxStage.earlyExitConsensusEnabled && successfulRefs.length > 1) {
+    const earlyRes = await stageEarlyConsensus({
+      successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+      referenceOutputs,
+      preset,
+      userPrompt,
+      prices,
+      maxTokens: ctxStage.maxTokens,
+      cwd,
+      runId,
+      signal,
+      promoteOpts,
+      allowCandidateOverride: ctxStage.allowCandidateOverride,
+      isRefinement: ctxStage.isRefinement,
+      historyFilePath,
+      startTime,
+      collectedCtx: ctxStage.collectedCtx,
+      liveCanvas,
+      ctx,
+    })
+    if (earlyRes.consensusReached) {
+      return earlyRes.payload
+    }
+  }
+
   if (signal?.aborted) {
     await cleanMoaWorkspaces(cwd, { runId })
     return { error: new Error('Turn aborted') }
@@ -124,7 +163,8 @@ export async function runMoAPipeline({
   // Stage 5: Consilium Round 2 (Peer Critique)
   const peerRes = await stagePeerCritique({
     isPeerCritiqueEnabled: ctxStage.isPeerCritiqueEnabled,
-    successfulRefs, referenceOutputs, preset, prices,
+    successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+    referenceOutputs, preset, prices,
     maxTokens: ctxStage.maxTokens, primaryJudge: ctxStage.primaryJudge,
     userPrompt, isBlindEvaluation: ctxStage.isBlindEvaluation,
     refTemp: ctxStage.refTemp, refTimeoutSec: ctxStage.refTimeoutSec,
@@ -148,7 +188,9 @@ export async function runMoAPipeline({
 
   // Stage 6: Multi-Judge Panel
   const mjRes = await stageMultiJudge({
-    preset, successfulRefs, referenceOutputs, primaryJudge: ctxStage.primaryJudge,
+    preset,
+    successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+    referenceOutputs, primaryJudge: ctxStage.primaryJudge,
     userPrompt, judgeCriteria: ctxStage.judgeCriteria, prices, maxTokens: ctxStage.maxTokens,
     callLlm, signal, onProgress, cwd, runId, isRefinement: ctxStage.isRefinement,
     isFastMode: ctxStage.isFastMode, collectedCtx: ctxStage.collectedCtx, startTime,
@@ -176,11 +218,13 @@ export async function runMoAPipeline({
   const rawFileDirective = (preset?.interactive_workbench_enabled)
     ? formatFileScoresDirective()
     : null
-  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive].filter(Boolean).join("\n\n") || null
+  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective].filter(Boolean).join("\n\n") || null
 
   // Stage 7: Synthesis Phase
   const synthRes = await stageSynthesis({
-    userPrompt, referenceOutputs, successfulRefs, judgeCriteria: ctxStage.judgeCriteria,
+    userPrompt, referenceOutputs,
+    successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+    judgeCriteria: ctxStage.judgeCriteria,
     isCuratorSynthesis: ctxStage.isCuratorSynthesis, isBlindEvaluation: ctxStage.isBlindEvaluation,
     priorTurnBaseline: ctxStage.priorTurnBaseline, compositeMergeDirective, fileScoringDirective,
     multiJudgeResult, preset, prices, maxTokens: ctxStage.maxTokens, isFastMode: ctxStage.isFastMode,
@@ -200,7 +244,9 @@ export async function runMoAPipeline({
 
   // Stage 8: Evaluation, Winner & Promotion
   const promRes = await stagePromotion({
-    synthesizedText, referenceOutputs, successfulRefs, multiJudgeResult,
+    synthesizedText, referenceOutputs,
+    successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+    multiJudgeResult,
     isCuratorSynthesis: ctxStage.isCuratorSynthesis,
     allowCandidateOverride: ctxStage.allowCandidateOverride,
     promoteOpts, cwd, runId, signal, liveCanvas, startTime, chosenJudge, aggUsage,
@@ -214,3 +260,4 @@ export async function runMoAPipeline({
   }
   return promRes.payload
 }
+

package/lib/pipeline/syntax-filter.js

@@ -0,0 +1,324 @@
+/**
+ * Zero-Token Local Pre-Judge Linter & Syntax Filter (#303)
+ * Inspects candidate proposals locally before LLM judge invocation.
+ * Disqualifies or penalizes candidates with fatal syntax errors without spending judge tokens.
+ */
+
+import vm from 'node:vm'
+import path from 'node:path'
+
+/**
+ * Extracts markdown fenced code blocks.
+ * @param {string} text
+ * @returns {Array<{ language: string, code: string }>}
+ */
+export function extractCodeBlocks(text = '') {
+  if (typeof text !== 'string') return []
+  const blocks = []
+  const regex = /(?:^|\n)```([a-zA-Z0-9_-]*)\r?\n([\s\S]*?)\r?\n```/g
+  let match
+  while ((match = regex.exec(text)) !== null) {
+    blocks.push({
+      language: (match[1] || '').trim().toLowerCase(),
+      code: match[2] || '',
+    })
+  }
+  return blocks
+}
+
+/**
+ * Checks basic bracket and parenthesis balance.
+ * @param {string} code
+ * @returns {{ balanced: boolean, error?: string }}
+ */
+function checkBracketBalance(code = '') {
+  const stack = []
+  const pairs = { '(': ')', '{': '}', '[': ']' }
+  let inSingleQuote = false
+  let inDoubleQuote = false
+  let inTemplateLiteral = false
+  let inLineComment = false
+  let inBlockComment = false
+
+  for (let i = 0; i < code.length; i++) {
+    const ch = code[i]
+    const next = code[i + 1]
+
+    if (inLineComment) {
+      if (ch === '\n') inLineComment = false
+      continue
+    }
+    if (inBlockComment) {
+      if (ch === '*' && next === '/') {
+        inBlockComment = false
+        i++
+      }
+      continue
+    }
+    if (ch === '/' && next === '/' && !inSingleQuote && !inDoubleQuote && !inTemplateLiteral) {
+      inLineComment = true
+      i++
+      continue
+    }
+    if (ch === '/' && next === '*' && !inSingleQuote && !inDoubleQuote && !inTemplateLiteral) {
+      inBlockComment = true
+      i++
+      continue
+    }
+
+    if (ch === "'" && !inDoubleQuote && !inTemplateLiteral && code[i - 1] !== '\\') {
+      inSingleQuote = !inSingleQuote
+      continue
+    }
+    if (ch === '"' && !inSingleQuote && !inTemplateLiteral && code[i - 1] !== '\\') {
+      inDoubleQuote = !inDoubleQuote
+      continue
+    }
+    if (ch === '`' && !inSingleQuote && !inDoubleQuote && code[i - 1] !== '\\') {
+      inTemplateLiteral = !inTemplateLiteral
+      continue
+    }
+
+    if (inSingleQuote || inDoubleQuote || inTemplateLiteral) continue
+
+    if (ch === '(' || ch === '{' || ch === '[') {
+      stack.push({ ch, pos: i })
+    } else if (ch === ')' || ch === '}' || ch === ']') {
+      if (stack.length === 0) {
+        return { balanced: false, error: `Unmatched closing bracket '${ch}' at index ${i}` }
+      }
+      const top = stack.pop()
+      if (pairs[top.ch] !== ch) {
+        return { balanced: false, error: `Mismatched bracket: expected '${pairs[top.ch]}', found '${ch}'` }
+      }
+    }
+  }
+
+  if (stack.length > 0) {
+    const top = stack[stack.length - 1]
+    return { balanced: false, error: `Unclosed bracket '${top.ch}' opened at index ${top.pos}` }
+  }
+  return { balanced: true }
+}
+
+/**
+ * Validates syntax of a single code block.
+ * @param {string} code
+ * @param {string} language
+ * @returns {{ valid: boolean, error: string | null }}
+ */
+export function validateCodeBlockSyntax(code = '', language = '') {
+  const lang = (language || '').toLowerCase().trim()
+  const trimmed = code.trim()
+  if (!trimmed) return { valid: true, error: null }
+
+  // 1. JSON validation
+  if (lang === 'json') {
+    try {
+      JSON.parse(trimmed)
+      return { valid: true, error: null }
+    } catch (err) {
+      return { valid: false, error: `JSON Parse Error: ${err.message}` }
+    }
+  }
+
+  // 2. JavaScript / TypeScript validation
+  if (['js', 'javascript', 'mjs', 'cjs', 'ts', 'typescript', 'jsx', 'tsx'].includes(lang)) {
+    // Check bracket balance
+    const bracketCheck = checkBracketBalance(trimmed)
+    if (!bracketCheck.balanced) {
+      return { valid: false, error: bracketCheck.error }
+    }
+
+    // Try vm.Script for JS (stripping import/export and TypeScript type annotations)
+    try {
+      const sanitized = trimmed
+        .replace(/^([ \t]*)export\s+default\s+/gm, '$1')
+        .replace(/^([ \t]*)export\s*\{[^}]*\}\s*;?/gm, '$1')
+        .replace(/^([ \t]*)export\s+(const|let|var|function|class|async\s+function)\s+/gm, '$1$2 ')
+        .replace(/^([ \t]*)import\s+[^;\n]+;?/gm, '$1')
+        .replace(/^([ \t]*)export\s+\*\s+from\s+[^;\n]+;?/gm, '$1')
+        // Strip TS interface / type declarations
+        .replace(/^([ \t]*)interface\s+\w+(\s*<[^>]+>)?(\s+extends\s+[^{]+)?\s*\{[\s\S]*?\}/gm, '')
+        .replace(/^([ \t]*)type\s+\w+(\s*<[^>]+>)?\s*=[\s\S]*?;/gm, '')
+
+      // Wrap in async IIFE to allow top-level await and return statements
+      const wrapped = `(async function() {\n${sanitized}\n});`
+      new vm.Script(wrapped)
+      return { valid: true, error: null }
+    } catch (err) {
+      // In TS code, type annotations might trigger syntax error in raw vm.Script
+      if (['ts', 'typescript', 'tsx'].includes(lang)) {
+        // If bracket check passed, treat as valid TS fallback
+        return { valid: true, error: null }
+      }
+      return { valid: false, error: `JS Syntax Error: ${err.message}` }
+    }
+  }
+
+  // 3. Python validation
+  if (['py', 'python'].includes(lang)) {
+    const bracketCheck = checkBracketBalance(trimmed)
+    if (!bracketCheck.balanced) {
+      return { valid: false, error: `Python syntax error: ${bracketCheck.error}` }
+    }
+
+    const lines = trimmed.split(/\r?\n/)
+    for (let idx = 0; idx < lines.length; idx++) {
+      const line = lines[idx].trim()
+      if (!line || line.startsWith('#')) continue
+      // Lines starting with block keywords must end with ':'
+      const blockKeywords = /^(def\s+\w+|class\s+\w+|if\s+|elif\s+|else:|while\s+|for\s+|try:|except(\s+.*)?:|finally:|with\s+)/
+      if (blockKeywords.test(line)) {
+        // If line is incomplete or doesn't end with ':' (accounting for trailing comments)
+        const codePart = line.split('#')[0].trim()
+        if (!codePart.endsWith(':') && !codePart.endsWith('\\') && !codePart.endsWith('(')) {
+          return { valid: false, error: `Python Syntax Error at line ${idx + 1}: expected ':' at end of '${codePart}'` }
+        }
+      }
+    }
+    return { valid: true, error: null }
+  }
+
+  // Generic fallback: check balanced brackets
+  const bracketCheck = checkBracketBalance(trimmed)
+  if (!bracketCheck.balanced) {
+    return { valid: false, error: bracketCheck.error }
+  }
+  return { valid: true, error: null }
+}
+
+/**
+ * Validates all code blocks and files in a candidate proposal.
+ * @param {object} candidate
+ * @returns {{ valid: boolean, errors: string[], warnings: string[], blocksCount: number, validCount: number }}
+ */
+export function validateCandidateSyntax(candidate = {}) {
+  const errors = []
+  const warnings = []
+  let blocksCount = 0
+  let validCount = 0
+
+  // 1. Check markdown code blocks
+  if (typeof candidate.text === 'string') {
+    const blocks = extractCodeBlocks(candidate.text)
+    for (const b of blocks) {
+      blocksCount++
+      const res = validateCodeBlockSyntax(b.code, b.language)
+      if (res.valid) {
+        validCount++
+      } else {
+        errors.push(`[Block ${blocksCount} (${b.language || 'code'})]: ${res.error}`)
+      }
+    }
+  }
+
+  // 2. Check candidate workspace files
+  if (Array.isArray(candidate.files)) {
+    for (const file of candidate.files) {
+      if (!file || typeof file.content !== 'string' || !file.relativePath) continue
+      blocksCount++
+      const ext = path.extname(file.relativePath).toLowerCase().replace('.', '')
+      const res = validateCodeBlockSyntax(file.content, ext)
+      if (res.valid) {
+        validCount++
+      } else {
+        errors.push(`[File ${file.relativePath}]: ${res.error}`)
+      }
+    }
+  }
+
+  const valid = errors.length === 0
+  return {
+    valid,
+    errors,
+    warnings,
+    blocksCount,
+    validCount,
+  }
+}
+
+/**
+ * Applies local zero-token syntax filter across all candidate outputs.
+ * @param {Array<object>} candidates
+ * @param {object} [options]
+ * @returns {{ candidates: Array<object>, validCandidates: Array<object>, invalidCandidates: Array<object>, filterApplied: boolean }}
+ */
+export function applySyntaxFilter(candidates = [], options = {}) {
+  if (!Array.isArray(candidates) || candidates.length === 0) {
+    return { candidates: [], validCandidates: [], invalidCandidates: [], filterApplied: false }
+  }
+
+  const enabled = options.enabled !== false
+  if (!enabled) {
+    return { candidates, validCandidates: candidates, invalidCandidates: [], filterApplied: false }
+  }
+
+  const validCandidates = []
+  const invalidCandidates = []
+
+  for (const cand of candidates) {
+    const syntax = validateCandidateSyntax(cand)
+    cand.syntaxValidation = syntax
+
+    if (syntax.valid) {
+      validCandidates.push(cand)
+    } else {
+      invalidCandidates.push(cand)
+    }
+  }
+
+  // If we have at least one valid candidate and some broken candidates,
+  // disqualify broken candidates from winning
+  if (validCandidates.length > 0 && invalidCandidates.length > 0) {
+    for (const invalid of invalidCandidates) {
+      invalid.disqualified = true
+      invalid.disqualificationReason = `Failed local pre-judge syntax filter (${invalid.syntaxValidation.errors.length} error(s))`
+    }
+  }
+
+  return {
+    candidates,
+    validCandidates: validCandidates.length > 0 ? validCandidates : candidates,
+    invalidCandidates,
+    filterApplied: true,
+  }
+}
+
+/**
+ * Formats an advisory syntax report directive for the judge.
+ * @param {Array<object>} candidates
+ * @param {object} [options]
+ * @param {boolean} [options.blind=false]
+ * @returns {string}
+ */
+export function formatSyntaxDirective(candidates = [], options = {}) {
+  if (!Array.isArray(candidates) || candidates.length === 0) return ''
+  const isBlind = Boolean(options.blind)
+  const lines = ['### Pre-Judge Local Syntax Gate Results (0 Tokens Spent):']
+
+  for (let i = 0; i < candidates.length; i++) {
+    const cand = candidates[i]
+    const v = cand.syntaxValidation
+    const label = isBlind ? `Candidate ${cand.index ?? (i + 1)}` : (cand.label || `Candidate ${cand.index ?? (i + 1)}`)
+    if (!v) {
+      lines.push(`- **${label}**: Not evaluated`)
+      continue
+    }
+
+    if (v.valid) {
+      lines.push(`- **${label}**: PASSED (${v.validCount}/${v.blocksCount} code block(s) syntactically valid)`)
+    } else {
+      lines.push(`- **${label}**: FAILED (${v.errors.length} syntax error(s)):`)
+      for (const err of v.errors.slice(0, 3)) {
+        lines.push(`    * ${err}`)
+      }
+      if (v.errors.length > 3) {
+        lines.push(`    * ...and ${v.errors.length - 3} more syntax error(s)`)
+      }
+    }
+  }
+
+  return lines.join('\n')
+}
+

package/lib/tui-settings.js

@@ -130,7 +130,7 @@ export function applyTuiSettings(ctx, { live }) {
       const eff = typeof tuiCtx.effect === 'function' ? tuiCtx.effect : (typeof ctx?.effect === 'function' ? ctx.effect : null)
       if (eff) {
         eff(() => () => {
-          try { if (typeof dispose === 'function') dispose() } catch {}
+          try { if (typeof dispose === 'function') dispose() } catch (err) { /* best-effort dispose */ }
         }, 'dsh-moa: tui settings')
       }
     } catch (err) {
@@ -144,3 +144,4 @@ export function applyTuiSettings(ctx, { live }) {
     ctx.inject(['tuiSettingsSections'], registerWithService)
   }
 }
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.71",
+  "version": "0.2.72",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",
@@ -72,3 +72,4 @@
     "react-dom": "^18.3.1"
   }
 }
+