@goodandready/dsh-moa 0.2.67 → 0.2.69

package/lib/client.js

@@ -2017,6 +2017,7 @@ window.__ModuleLoader__.load({
                   t("aggregator.report_desc") || "Generate downloadable Markdown & JSON reports detailing candidate latency, agreement, test gate, and cost breakdown."
                 )
               ),
+              // --- src/client/85-card-aggregator-ext.js ---
               /* Interactive Workbench & File Scoring (#251) */
               React.createElement(
                 "div",
@@ -2054,6 +2055,74 @@ window.__ModuleLoader__.load({
                   "(" + (t("aggregator.workbench_companion_note") || "safe shadow Git checkpoints before file promotion") + ")"
                 )
               ),
+              /* Quota-Aware Provider Balancing (#253) */
+              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: Boolean(currentPreset.quota_aware_balancing_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, quota_aware_balancing_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.quota_balancing_title") || "\u2696\uFE0F Quota-Aware Provider Balancing"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.quota_balancing_desc") || "Automatically substitute low-quota candidate models in Layer 1 to preserve rate limits for the final aggregator."
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 11, color: "var(--dsw-alias-label-tertiary)", marginLeft: 22, marginTop: 2, display: "flex", alignItems: "center", gap: 6, flexWrap: "wrap" } },
+                  "\u{1F517} Companion Plugins:",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-key-limits", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-key-limits"
+                  ),
+                  "/",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-subscriptions", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-subscriptions"
+                  )
+                )
+              ),
+              /* Self-Healing Post-Promotion Build Loop (#252) */
+              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: Boolean(currentPreset.self_healing_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, self_healing_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.self_healing_title") || "\u{1FA7A} Self-Healing Post-Promotion Build Loop"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.self_healing_desc") || "Verify promoted files with a test command, request hotfix patches from the aggregator on failure, or auto-rollback to the Time Machine checkpoint."
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 11, color: "var(--dsw-alias-label-tertiary)", marginLeft: 22, marginTop: 2, display: "flex", alignItems: "center", gap: 6 } },
+                  "\u{1F517} Companion Plugin:",
+                  React.createElement(
+                    "a",
+                    { href: "https://github.com/GooDAnDReaDY/dsh-time-machine", target: "_blank", rel: "noopener noreferrer", style: { color: "var(--dsw-alias-state-brand-primary)", textDecoration: "underline" } },
+                    "@goodandready/dsh-time-machine"
+                  )
+                )
+              ),
               /* Graceful Degradation & Local Fallback (#175, #176) */
               React.createElement(
                 "div",

package/lib/index.js

@@ -401,3 +401,15 @@ export {
   analyzeCandidateUncertainty,
   formatUncertaintyAnnotations,
 } from './moa-uncertainty.js'
+export {
+  classifyPromptDomain,
+  assignAdaptivePersonas,
+  DOMAIN_PERSONA_POOLS,
+} from './moa-adaptive-personas.js'
+export {
+  isGitRepository,
+  createSwarmWorktree,
+  collectSwarmWorktreeDiff,
+  cleanupSwarmWorktrees,
+  runSubagentSwarm,
+} from './moa-swarm.js'

package/lib/moa-adaptive-personas.js

@@ -0,0 +1,176 @@
+/**
+ * Prompt-Adaptive Dynamic Persona Synthesis for Reference Models (#254)
+ * Classifies prompt technical domain and synthesizes complementary engineering personas
+ * dynamically so each candidate approaches the task from a distinct expert angle.
+ */
+
+export const DOMAIN_PERSONA_POOLS = {
+  database: [
+    {
+      id: 'dba_index_specialist',
+      title: 'DBA Index Specialist',
+      prompt: 'You are a Principal DBA Index Specialist. Focus on query execution plans, composite indexing, lock contention prevention, and optimal read/write throughput.',
+    },
+    {
+      id: 'zero_downtime_migration_guard',
+      title: 'Zero-Downtime Migration Guard',
+      prompt: 'You are a Zero-Downtime Migration Guard. Ensure backward-compatible schema evolutions, safe expand-and-contract patterns, and rollback safety.',
+    },
+    {
+      id: 'orm_query_architect',
+      title: 'ORM & Query Architect',
+      prompt: 'You are an ORM & Query Architect. Focus on eliminating N+1 queries, clean repository abstractions, transaction isolation levels, and strict data integrity.',
+    },
+  ],
+  frontend: [
+    {
+      id: 'a11y_ux_specialist',
+      title: 'Accessibility & UX Specialist',
+      prompt: 'You are an Accessibility & UX Specialist. Ensure WCAG 2.1 AA compliance, keyboard navigation, ARIA semantics, and responsive user feedback.',
+    },
+    {
+      id: 'css_design_systems_architect',
+      title: 'CSS & Design Systems Architect',
+      prompt: 'You are a CSS & Design Systems Architect. Focus on design tokens, layout resilience, fluid typography, zero layout shift, and clean component composition.',
+    },
+    {
+      id: 'state_rendering_optimizer',
+      title: 'State & Rendering Optimizer',
+      prompt: 'You are a Frontend State & Rendering Optimizer. Focus on minimizing unnecessary re-renders, memoization, deterministic state transitions, and bundle efficiency.',
+    },
+  ],
+  security: [
+    {
+      id: 'offensive_security_auditor',
+      title: 'Offensive Security Auditor',
+      prompt: 'You are an Offensive Security Auditor. Proactively hunt for injection vectors, SSRF, path traversal, auth bypass, and privilege escalation.',
+    },
+    {
+      id: 'defensive_hardening_specialist',
+      title: 'Defensive Hardening Specialist',
+      prompt: 'You are a Defensive Hardening Specialist. Enforce least-privilege access, strict input validation, fail-closed guards, and cryptographic best practices.',
+    },
+    {
+      id: 'runtime_sandbox_guardian',
+      title: 'Runtime & Sandbox Guardian',
+      prompt: 'You are a Runtime & Sandbox Guardian. Focus on resource limits, rate limiting, secret sanitization, and zero-trust boundary enforcement.',
+    },
+  ],
+  performance: [
+    {
+      id: 'algorithmic_optimizer',
+      title: 'Algorithmic Complexity Optimizer',
+      prompt: 'You are an Algorithmic Complexity Optimizer. Replace O(N^2) bottlenecks with optimal data structures, streaming pipelines, and bounded memory usage.',
+    },
+    {
+      id: 'concurrency_profiler',
+      title: 'Memory & Concurrency Profiler',
+      prompt: 'You are a Memory & Concurrency Profiler. Prevent event-loop blocking, race conditions, memory leaks, and unbounded promise queues.',
+    },
+  ],
+  testing: [
+    {
+      id: 'edge_case_fuzzer',
+      title: 'Edge-Case & Fuzzing Specialist',
+      prompt: 'You are an Edge-Case & Fuzzing Specialist. Target boundary conditions, malformed inputs, concurrency races, and failure recovery paths.',
+    },
+    {
+      id: 'contract_test_architect',
+      title: 'Integration & Contract Test Architect',
+      prompt: 'You are an Integration & Contract Test Architect. Build deterministic, isolated, fast-running test suites with zero flakiness.',
+    },
+  ],
+  architecture: [
+    {
+      id: 'ddd_architect',
+      title: 'Domain-Driven Design Architect',
+      prompt: 'You are a Domain-Driven Design Architect. Enforce clean module boundaries, single responsibility, explicit contracts, and low coupling.',
+    },
+    {
+      id: 'resilience_engineer',
+      title: 'Resilience & Fault-Tolerance Engineer',
+      prompt: 'You are a Resilience & Fault-Tolerance Engineer. Design idempotent operations, graceful degradation, circuit breakers, and clear error taxonomy.',
+    },
+  ],
+}
+
+const DOMAIN_RULES = [
+  { domain: 'database', pattern: /\b(sql|postgres|mysql|sqlite|prisma|drizzle|typeorm|migration|index|schema|table|query|database|db|transaction)\b/i },
+  { domain: 'security', pattern: /\b(security|auth|jwt|oauth|csrf|xss|ssrf|injection|traversal|permission|encrypt|hash|token|secret|vulnerability|cve)\b/i },
+  { domain: 'frontend', pattern: /\b(react|vue|svelte|css|tailwind|html|dom|component|ui|ux|button|modal|layout|responsive|aria|accessibility|style)\b/i },
+  { domain: 'performance', pattern: /\b(performance|optimize|latency|throughput|cache|memory|leak|benchmark|bottleneck|fast|profil|concurrent|parallel)\b/i },
+  { domain: 'testing', pattern: /\b(test|unit|integration|e2e|mock|assert|coverage|vitest|jest|playwright|tdd|regression)\b/i },
+]
+
+/**
+ * Classifies a user prompt into a specialized technical domain.
+ *
+ * @param {string} prompt
+ * @returns {{ domain: string, confidence: number, matchedKeywords: string[] }}
+ */
+export function classifyPromptDomain(prompt) {
+  const text = String(prompt || '').trim()
+  if (!text) return { domain: 'architecture', confidence: 0.5, matchedKeywords: [] }
+
+  let bestDomain = 'architecture'
+  let bestCount = 0
+  let bestMatches = []
+
+  for (const rule of DOMAIN_RULES) {
+    const matches = [...text.matchAll(new RegExp(rule.pattern.source, 'gi'))].map((m) => m[0].toLowerCase())
+    const unique = [...new Set(matches)]
+    if (unique.length > bestCount) {
+      bestCount = unique.length
+      bestDomain = rule.domain
+      bestMatches = unique
+    }
+  }
+
+  return {
+    domain: bestDomain,
+    confidence: bestCount > 0 ? Math.min(0.98, Number((0.6 + bestCount * 0.12).toFixed(2))) : 0.55,
+    matchedKeywords: bestMatches,
+  }
+}
+
+/**
+ * Synthesizes and assigns complementary domain-specific personas to reference model slots.
+ *
+ * @param {Array<object>} references
+ * @param {string} prompt
+ * @returns {{ domain: string, references: Array<object>, personasAssigned: Array<object> }}
+ */
+export function assignAdaptivePersonas(references, prompt) {
+  if (!Array.isArray(references) || references.length === 0) {
+    return { domain: 'architecture', references: [], personasAssigned: [] }
+  }
+
+  const { domain } = classifyPromptDomain(prompt)
+  const pool = DOMAIN_PERSONA_POOLS[domain] || DOMAIN_PERSONA_POOLS.architecture
+  const fallbackPool = DOMAIN_PERSONA_POOLS.architecture
+
+  const personasAssigned = []
+  const enrichedRefs = references.map((slot, idx) => {
+    const chosen = pool[idx % pool.length] || fallbackPool[idx % fallbackPool.length]
+    personasAssigned.push({
+      candidateIndex: idx + 1,
+      model: `${slot.provider || ''}:${slot.model || ''}`,
+      domain,
+      personaId: chosen.id,
+      personaTitle: chosen.title,
+    })
+    return {
+      ...slot,
+      adaptive_domain: domain,
+      adaptive_persona_id: chosen.id,
+      adaptive_persona_title: chosen.title,
+      adaptive_persona_prompt: `[ADAPTIVE EXPERT ROLE — ${chosen.title} (${domain.toUpperCase()})]: ${chosen.prompt}`,
+    }
+  })
+
+  return {
+    domain,
+    references: enrichedRefs,
+    personasAssigned,
+  }
+}

package/lib/moa-candidates.js

@@ -85,9 +85,9 @@ export async function runReferencesParallel(references, messages, options = {},
   references.forEach((slot, i) => {
     const label = slotLabel(slot)
     const role = slot?.role_persona || slot?.role || 'general'
-    const persona = (role && ROLE_PERSONA_PROMPTS[role])
-      ? `\n\n${ROLE_PERSONA_PROMPTS[role]}`
-      : ''
+    const basePersona = (role && ROLE_PERSONA_PROMPTS[role]) ? `\n\n${ROLE_PERSONA_PROMPTS[role]}` : ''
+    const adaptiveExtra = slot?.adaptive_persona_prompt ? `\n\n${slot.adaptive_persona_prompt}` : ''
+    const persona = basePersona + adaptiveExtra
     const slotMessages = [{ role: 'system', content: systemPrompt + persona }, ...advisoryMessages]
 
     // Feature 7: Per-candidate temperature or temperature gradient
@@ -140,7 +140,8 @@ export async function runReferencesParallel(references, messages, options = {},
           index: i + 1,
           slot,
           label,
-          role_persona: role,
+          role_persona: slot?.adaptive_persona_title || role,
+          ...(slot?.adaptive_domain ? { adaptive_domain: slot.adaptive_domain } : {}),
           temperature: effectiveTemperature,
           text,
           usage: costInfo,

package/lib/moa-parser.js

@@ -56,12 +56,18 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
     }
   }
 
-  const remainder = text.slice(4).trim()
+  let remainder = text.slice(4).trim()
+  let isSwarm = false
+  if (/^--swarm(?:\s+|$)/i.test(remainder)) {
+    isSwarm = true
+    remainder = remainder.replace(/^--swarm\s*/i, '').trim()
+  }
   if (!remainder) {
     return {
       presetName: defaultPreset,
       prompt: '',
       isExplicit: false,
+      ...(isSwarm ? { isSwarm: true } : {}),
     }
   }
 
@@ -71,6 +77,7 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
       presetName: matchPreset[1],
       prompt: matchPreset[2] || '',
       isExplicit: true,
+      ...(isSwarm ? { isSwarm: true } : {}),
     }
   }
 
@@ -80,6 +87,7 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
       presetName: matchShortPreset[1],
       prompt: matchShortPreset[2] || '',
       isExplicit: true,
+      ...(isSwarm ? { isSwarm: true } : {}),
     }
   }
 
@@ -100,6 +108,7 @@ export function parseMoACommand(text, presets = [], defaultPreset = undefined) {
     presetName: defaultPreset,
     prompt: remainder,
     isExplicit: false,
+    ...(isSwarm ? { isSwarm: true } : {}),
   }
 }
 

package/lib/moa-quota-balancer.js

@@ -0,0 +1,188 @@
+/**
+ * Quota-Aware Provider Balancing (#253)
+ * Queries provider/model rate limits and quota health via dsh-key-limits and dsh-subscriptions.
+ * Dynamically substitutes exhausted or low-quota reference slots with healthy fallback models
+ * to protect the final aggregator quota and prevent 429 pipeline aborts.
+ */
+
+import { service } from './services.js'
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+
+const DEFAULT_FALLBACK_POOL = [
+  { provider: 'deepseek', model: 'deepseek-reasoner' },
+  { provider: 'deepseek', model: 'deepseek-chat' },
+  { provider: 'qwen', model: 'qwen-2.5-coder-32b-instruct' },
+  { provider: 'openrouter', model: 'deepseek/deepseek-r1' },
+  { provider: 'ollama', model: 'qwen2.5-coder:32b' },
+]
+
+/**
+ * Inspects quota status for a given { provider, model } slot via dsh-key-limits or dsh-subscriptions.
+ *
+ * @param {object} ctx - Cordis context
+ * @param {{ provider: string, model: string }} slot
+ * @param {object} [options]
+ * @returns {Promise<{ exhausted: boolean, remainingRatio: number, reason: string | null }>}
+ */
+export async function checkSlotQuotaStatus(ctx, slot, options = {}) {
+  const provider = String(slot?.provider || '').trim()
+  const model = String(slot?.model || '').trim()
+  if (!provider) return { exhausted: false, remainingRatio: 1, reason: null }
+
+  const minRemainingRatio = Number.isFinite(options.minRemainingRatio) ? options.minRemainingRatio : 0.1
+
+  const keyLimits = options.keyLimitsService || service(ctx, 'keyLimits')
+  if (keyLimits) {
+    try {
+      let status = null
+      if (typeof keyLimits.getQuotaStatus === 'function') {
+        status = await keyLimits.getQuotaStatus(provider, model)
+      } else if (typeof keyLimits.checkLimit === 'function') {
+        status = await keyLimits.checkLimit(provider, model)
+      } else if (typeof keyLimits.getProviderStatus === 'function') {
+        status = await keyLimits.getProviderStatus(provider)
+      }
+
+      if (status) {
+        if (status.exhausted === true || status.rateLimited === true || status.blocked === true) {
+          return {
+            exhausted: true,
+            remainingRatio: 0,
+            reason: status.reason || 'Quota exhausted or rate-limited in dsh-key-limits',
+          }
+        }
+        const rem = Number(status.remaining ?? status.remainingRequests ?? status.remainingTokens)
+        const lim = Number(status.limit ?? status.maxRequests ?? status.maxTokens)
+        if (Number.isFinite(rem) && Number.isFinite(lim) && lim > 0) {
+          const ratio = rem / lim
+          if (ratio < minRemainingRatio) {
+            return {
+              exhausted: true,
+              remainingRatio: ratio,
+              reason: `Low quota remaining (${Math.round(ratio * 100)}%) in dsh-key-limits`,
+            }
+          }
+          return { exhausted: false, remainingRatio: ratio, reason: null }
+        }
+        if (Number.isFinite(status.remainingRatio)) {
+          if (status.remainingRatio < minRemainingRatio) {
+            return {
+              exhausted: true,
+              remainingRatio: status.remainingRatio,
+              reason: `Low quota ratio (${Math.round(status.remainingRatio * 100)}%) in dsh-key-limits`,
+            }
+          }
+          return { exhausted: false, remainingRatio: status.remainingRatio, reason: null }
+        }
+      }
+    } catch (err) {
+      logger.warn(`[dsh-moa:quota] Error querying dsh-key-limits for ${provider}:${model}:`, err?.message || err)
+    }
+  }
+
+  const subscriptions = options.subscriptionsService || service(ctx, 'subscriptions')
+  if (subscriptions) {
+    try {
+      let subStatus = null
+      if (typeof subscriptions.getSubscriptionStatus === 'function') {
+        subStatus = await subscriptions.getSubscriptionStatus(provider, model)
+      } else if (typeof subscriptions.checkQuota === 'function') {
+        subStatus = await subscriptions.checkQuota(provider, model)
+      }
+
+      if (subStatus) {
+        if (subStatus.exhausted === true || subStatus.active === false || subStatus.expired === true) {
+          return {
+            exhausted: true,
+            remainingRatio: 0,
+            reason: subStatus.reason || 'Subscription quota exhausted or inactive in dsh-subscriptions',
+          }
+        }
+        if (Number.isFinite(subStatus.remainingRatio) && subStatus.remainingRatio < minRemainingRatio) {
+          return {
+            exhausted: true,
+            remainingRatio: subStatus.remainingRatio,
+            reason: `Low subscription quota (${Math.round(subStatus.remainingRatio * 100)}%) in dsh-subscriptions`,
+          }
+        }
+      }
+    } catch (err) {
+      logger.warn(`[dsh-moa:quota] Error querying dsh-subscriptions for ${provider}:${model}:`, err?.message || err)
+    }
+  }
+
+  return { exhausted: false, remainingRatio: 1, reason: null }
+}
+
+/**
+ * Balances candidate reference slots before Layer 1 execution.
+ * Preserves quota for the aggregator by substituting low-quota/exhausted slots
+ * with healthy fallback models.
+ *
+ * @param {Array<{ provider: string, model: string }>} references
+ * @param {object} options
+ * @returns {Promise<{ balancedReferences: Array<{ provider: string, model: string }>, substitutions: Array<object> }>}
+ */
+export async function balanceCandidateQuotas(references = [], options = {}) {
+  if (!Array.isArray(references) || references.length === 0) {
+    return { balancedReferences: [], substitutions: [] }
+  }
+
+  const ctx = options.ctx || null
+  const aggregator = options.aggregator || null
+  const customFallbacks = Array.isArray(options.fallbackPool) && options.fallbackPool.length > 0
+    ? options.fallbackPool
+    : DEFAULT_FALLBACK_POOL
+
+  const usedKeys = new Set(references.map((r) => slotLabel(r)))
+  const balancedReferences = []
+  const substitutions = []
+
+  for (let i = 0; i < references.length; i++) {
+    const slot = references[i]
+    const label = slotLabel(slot)
+
+    // Reserve higher threshold (25%) if this candidate uses the exact same provider:model as the final aggregator
+    const isSameAsAggregator = aggregator && slotLabel(aggregator) === label
+    const minRemainingRatio = isSameAsAggregator ? 0.25 : (options.minRemainingRatio ?? 0.1)
+
+    const status = await checkSlotQuotaStatus(ctx, slot, {
+      ...options,
+      minRemainingRatio,
+    })
+
+    if (!status.exhausted) {
+      balancedReferences.push(slot)
+      continue
+    }
+
+    // Find a healthy replacement from customFallbacks
+    let replacement = null
+    for (const candidateFallback of customFallbacks) {
+      const fbLabel = slotLabel(candidateFallback)
+      if (fbLabel === label) continue
+      const fbStatus = await checkSlotQuotaStatus(ctx, candidateFallback, options)
+      if (!fbStatus.exhausted) {
+        replacement = { ...slot, provider: candidateFallback.provider, model: candidateFallback.model, replacedFrom: label }
+        usedKeys.add(fbLabel)
+        break
+      }
+    }
+
+    if (replacement) {
+      balancedReferences.push(replacement)
+      substitutions.push({
+        index: i + 1,
+        original: slot,
+        replacement: { provider: replacement.provider, model: replacement.model },
+        reason: status.reason,
+      })
+      logger.info(`[dsh-moa:quota] Replaced slot #${i + 1} (${label}) -> ${slotLabel(replacement)} (${status.reason})`)
+    } else {
+      balancedReferences.push(slot)
+    }
+  }
+
+  return { balancedReferences, substitutions }
+}

package/lib/moa-schema.js

@@ -64,6 +64,12 @@ export const PresetSchema = z.object({
   local_fallback_models: z.array(ModelSlotSchema).default([]),
   interactive_workbench_enabled: z.boolean().default(false),
   uncertainty_scoring_enabled: z.boolean().default(false),
+  subagent_swarm_enabled: z.boolean().default(false),
+  adaptive_personas_enabled: z.boolean().default(false),
+  quota_aware_balancing_enabled: z.boolean().default(false),
+  self_healing_enabled: z.boolean().default(false),
+  self_healing_max_retries: z.number().default(2),
+  self_healing_command: z.string().default("npm test"),
 })
 
 export const Config = z.object({
@@ -74,6 +80,12 @@ export const Config = z.object({
   ask_clarifying_questions: z.boolean().default(true).volatile(),
   test_gate_enabled: z.boolean().default(false).volatile(),
   uncertainty_scoring_enabled: z.boolean().default(false).volatile(),
+  subagent_swarm_enabled: z.boolean().default(false).volatile(),
+  adaptive_personas_enabled: z.boolean().default(false).volatile(),
+  quota_aware_balancing_enabled: z.boolean().default(false).volatile(),
+  self_healing_enabled: z.boolean().default(false).volatile(),
+  self_healing_max_retries: z.number().default(2).volatile(),
+  self_healing_command: z.string().default("npm test").volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/moa-self-healing.js

@@ -0,0 +1,258 @@
+/**
+ * Self-Healing Post-Promotion Build Loop with dsh-time-machine Auto-Rollback (#252)
+ * Executes verification command after file promotion, dispatches compiler/test error logs
+ * to the MoA aggregator for hotfix generation up to maxRetries times, and automatically
+ * rolls back to the pre-promotion dsh-time-machine snapshot if verification still fails.
+ */
+
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { logger } from './logger.js'
+import { bestEffort } from './best-effort.js'
+import { extractFileBlocks } from './workspace/fs.js'
+import { isSafeRelativePath, assertPathContained, isLoopbackUrl } from './workspace/security.js'
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Runs a verification command in the target workspace.
+ *
+ * @param {string} cwd
+ * @param {string} commandStr
+ * @param {object} [options]
+ * @returns {Promise<{ passed: boolean, exitCode: number, output: string }>}
+ */
+export async function runVerificationCommand(cwd, commandStr = 'npm test', options = {}) {
+  if (typeof options.execFn === 'function') {
+    return await options.execFn(cwd, commandStr)
+  }
+
+  const trimmed = String(commandStr || 'npm test').trim()
+  const isWin = process.platform === 'win32'
+  const shell = isWin ? 'cmd.exe' : '/bin/sh'
+  const shellArgs = isWin ? ['/d', '/s', '/c', trimmed] : ['-c', trimmed]
+
+  try {
+    const { stdout, stderr } = await execFileAsync(shell, shellArgs, {
+      cwd,
+      timeout: (options.timeoutSec ?? 60) * 1000,
+      maxBuffer: 4 * 1024 * 1024,
+      signal: options.signal,
+    })
+    return {
+      passed: true,
+      exitCode: 0,
+      output: `${stdout || ''}\n${stderr || ''}`.trim(),
+    }
+  } catch (err) {
+    const out = `${err?.stdout || ''}\n${err?.stderr || ''}\n${err?.message || ''}`.trim()
+    return {
+      passed: false,
+      exitCode: typeof err?.code === 'number' ? err.code : 1,
+      output: out.slice(0, 12000),
+    }
+  }
+}
+
+/**
+ * Triggers an automatic rollback to a pre-promotion dsh-time-machine snapshot.
+ *
+ * @param {string} baseDir
+ * @param {object} snapshot
+ * @param {object} [options]
+ * @returns {Promise<{ rolledBack: boolean, snapshotId: string | null }>}
+ */
+export async function rollbackToTimeMachineSnapshot(baseDir, snapshot, options = {}) {
+  const snapshotId = typeof snapshot === 'string'
+    ? snapshot
+    : (snapshot?.id || snapshot?.snapshotId || snapshot?.commit || snapshot?.hash || null)
+
+  if (typeof options.rollbackFn === 'function') {
+    const res = await bestEffort('custom rollbackFn', () => options.rollbackFn(baseDir, snapshotId, snapshot))
+    return { rolledBack: Boolean(res), snapshotId }
+  }
+
+  if (options.timeMachineEngine) {
+    const fn = options.timeMachineEngine.restoreSnapshot || options.timeMachineEngine.rollback
+    if (typeof fn === 'function') {
+      const res = await bestEffort('dsh-time-machine direct restoreSnapshot', () =>
+        fn.call(options.timeMachineEngine, snapshotId, { cwd: baseDir })
+      )
+      if (res) return { rolledBack: true, snapshotId }
+    }
+  }
+
+  const port = options.port || options.webServerPort || process.env.DSH_PORT || process.env.PORT
+  if (!port && !options.timeMachineRollbackUrl) {
+    logger.warn('[dsh-moa:self-healing] Cannot rollback: webServerPort is unknown and no timeMachineEngine/rollbackFn provided')
+    return { rolledBack: false, snapshotId }
+  }
+
+  const endpoint = options.timeMachineRollbackUrl || `http://127.0.0.1:${port}/dsh-time-machine/restore`
+  if (!isLoopbackUrl(endpoint)) {
+    logger.warn(`[dsh-moa:self-healing] Blocked non-loopback rollback URL: ${endpoint}`)
+    return { rolledBack: false, snapshotId }
+  }
+
+  const restored = await bestEffort('dsh-time-machine HTTP rollback', async () => {
+    const res = await fetch(endpoint, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id: snapshotId, snapshotId, cwd: baseDir }),
+      signal: AbortSignal.timeout(options.timeoutMs ?? 5000),
+      redirect: 'error',
+    })
+    return res.ok
+  })
+
+  return { rolledBack: Boolean(restored), snapshotId }
+}
+
+/**
+ * Applies extracted hotfix files directly to the workspace directory.
+ */
+async function applyHotfixFiles(cwd, files = []) {
+  const written = []
+  for (const f of files) {
+    const rel = f.relativePath || f.path
+    if (!rel || !isSafeRelativePath(rel)) continue
+    const targetPath = assertPathContained(cwd, rel)
+    await fs.mkdir(path.dirname(targetPath), { recursive: true })
+    await fs.writeFile(targetPath, f.content, 'utf8')
+    written.push(rel)
+  }
+  return written
+}
+
+/**
+ * Runs the post-promotion self-healing build loop.
+ *
+ * @param {object} params
+ * @returns {Promise<{
+ *   enabled: boolean,
+ *   passed: boolean,
+ *   attempts: number,
+ *   rolledBack: boolean,
+ *   snapshotId: string | null,
+ *   hotfixFiles: string[],
+ *   lastOutput: string
+ * }>}
+ */
+export async function runSelfHealingLoop({
+  cwd,
+  command = 'npm test',
+  maxRetries = 2,
+  aggregatorSlot,
+  callLlm,
+  userPrompt = '',
+  promotedFiles = [],
+  checkpoint = null,
+  promoteOpts = {},
+  onProgress = null,
+  signal = null,
+  execFn = null,
+  rollbackFn = null,
+}) {
+  const retries = Math.max(0, Math.min(5, Number(maxRetries ?? 2)))
+  const hotfixFiles = new Set()
+
+  if (typeof onProgress === 'function') {
+    onProgress(`🩺 *Self-Healing Verification: Running \`${command}\`...*\n`)
+  }
+
+  let check = await runVerificationCommand(cwd, command, { execFn, signal })
+  if (check.passed) {
+    return {
+      enabled: true,
+      passed: true,
+      attempts: 0,
+      rolledBack: false,
+      snapshotId: null,
+      hotfixFiles: [],
+      lastOutput: check.output,
+    }
+  }
+
+  let attempts = 0
+  while (!check.passed && attempts < retries) {
+    if (signal?.aborted) break
+    attempts++
+
+    if (typeof onProgress === 'function') {
+      onProgress(`🔧 *Self-Healing Attempt ${attempts}/${retries}: Requesting hotfix patch from aggregator...*\n`)
+    }
+
+    const fileList = Array.isArray(promotedFiles)
+      ? promotedFiles.map((f) => (typeof f === 'string' ? f : f.relativePath || f.path)).filter(Boolean)
+      : []
+
+    const hotfixPrompt = [
+      `The promoted MoA changes failed the verification command \`${command}\` (exit code ${check.exitCode}).`,
+      `Original User Task: ${userPrompt}`,
+      `Promoted Files: ${fileList.join(', ') || 'workspace files'}`,
+      `\n### Compiler / Test Failure Output:\n\`\`\`\n${check.output}\n\`\`\``,
+      `\nProvide a minimal hotfix patch using markdown code blocks with \`path=<relative/path>\` header so the build and tests pass.`,
+    ].join('\n')
+
+    const llmRes = await callLlm({
+      provider: aggregatorSlot?.provider || 'default',
+      model: aggregatorSlot?.model || 'default',
+      messages: [
+        {
+          role: 'system',
+          content: 'You are an expert automated build healer. Fix compilation or unit test errors by outputting complete corrected files with ```lang path=relative/path.ext fences.',
+        },
+        { role: 'user', content: hotfixPrompt },
+      ],
+      temperature: 0.2,
+      maxTokens: 4096,
+      signal,
+    })
+
+    const patchText = typeof llmRes === 'string' ? llmRes : (llmRes?.content || llmRes?.text || '')
+    const extracted = extractFileBlocks(patchText)
+    if (extracted.length > 0) {
+      const applied = await applyHotfixFiles(cwd, extracted)
+      for (const f of applied) hotfixFiles.add(f)
+    }
+
+    check = await runVerificationCommand(cwd, command, { execFn, signal })
+    if (check.passed) {
+      if (typeof onProgress === 'function') {
+        onProgress(`✅ *Self-Healing Succeeded on attempt ${attempts}/${retries}!*\n`)
+      }
+      return {
+        enabled: true,
+        passed: true,
+        attempts,
+        rolledBack: false,
+        snapshotId: null,
+        hotfixFiles: [...hotfixFiles],
+        lastOutput: check.output,
+      }
+    }
+  }
+
+  // Verification still failed after maxRetries -> unconditional Time Machine rollback
+  const snapshotObj = checkpoint || promoteOpts?.checkpointSnapshot || (Array.isArray(promotedFiles) && promotedFiles._checkpoint) || null
+  if (typeof onProgress === 'function') {
+    onProgress(`⏪ *Self-Healing exhausted (${attempts}/${retries}). Rolling back workspace via dsh-time-machine...*\n`)
+  }
+
+  const rb = await rollbackToTimeMachineSnapshot(cwd, snapshotObj, {
+    ...promoteOpts,
+    rollbackFn,
+  })
+
+  return {
+    enabled: true,
+    passed: false,
+    attempts,
+    rolledBack: rb.rolledBack,
+    snapshotId: rb.snapshotId,
+    hotfixFiles: [...hotfixFiles],
+    lastOutput: check.output,
+  }
+}

package/lib/moa-swarm.js

@@ -0,0 +1,219 @@
+/**
+ * MoA-to-Subagents Swarm with Isolated Git Worktrees (#255)
+ * Provisions isolated git worktrees (or workspace sandboxes) per candidate,
+ * dispatches autonomous subagent/candidate execution, collects git diffs,
+ * and guarantees worktree cleanup in finally blocks.
+ */
+
+import fs from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
+import { logger } from './logger.js'
+import { slotLabel } from './moa-prompts.js'
+import { extractFileBlocks } from './workspace/fs.js'
+
+const execFileAsync = promisify(execFile)
+
+/**
+ * Checks if a directory is inside a valid git repository.
+ */
+export async function isGitRepository(cwd) {
+  try {
+    const { stdout } = await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd, timeout: 5000 })
+    return stdout.trim() === 'true'
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Creates an isolated git worktree (or directory sandbox if not a git repo) for a swarm candidate.
+ *
+ * @param {string} cwd
+ * @param {string} runId
+ * @param {number} candidateIndex
+ * @returns {Promise<{ worktreePath: string, branchName: string, isGitWorktree: boolean }>}
+ */
+export async function createSwarmWorktree(cwd, runId, candidateIndex) {
+  const safeRunId = String(runId || Date.now()).replace(/[^a-zA-Z0-9_-]/g, '')
+  const worktreePath = path.join(cwd, '.moa', `swarm-${safeRunId}`, `candidate-${candidateIndex}`)
+  const branchName = `moa-swarm/${safeRunId}/cand-${candidateIndex}`
+
+  await fs.mkdir(path.dirname(worktreePath), { recursive: true })
+
+  if (await isGitRepository(cwd)) {
+    try {
+      await execFileAsync('git', ['worktree', 'add', '--detach', worktreePath, 'HEAD'], { cwd, timeout: 10000 })
+      return { worktreePath, branchName, isGitWorktree: true }
+    } catch (err) {
+      logger.warn(`[dsh-moa] git worktree add failed for candidate-${candidateIndex}, using isolated directory sandbox: ${err?.message || err}`)
+    }
+  }
+
+  await fs.mkdir(worktreePath, { recursive: true })
+  return { worktreePath, branchName, isGitWorktree: false }
+}
+
+/**
+ * Collects git diff and modified files from a candidate's swarm worktree.
+ *
+ * @param {string} worktreePath
+ * @param {boolean} isGitWorktree
+ * @returns {Promise<{ diffText: string, modifiedFiles: string[] }>}
+ */
+export async function collectSwarmWorktreeDiff(worktreePath, isGitWorktree = false) {
+  if (!existsSync(worktreePath)) {
+    return { diffText: '', modifiedFiles: [] }
+  }
+
+  if (isGitWorktree) {
+    try {
+      const { stdout: statusOut } = await execFileAsync('git', ['status', '--porcelain'], { cwd: worktreePath, timeout: 5000 })
+      const modifiedFiles = statusOut
+        .split('\n')
+        .map((line) => line.slice(3).trim())
+        .filter(Boolean)
+
+      const { stdout: diffOut } = await execFileAsync('git', ['diff', 'HEAD'], { cwd: worktreePath, timeout: 5000 })
+      return { diffText: diffOut.trim(), modifiedFiles }
+    } catch {
+      // Fallback to directory scan
+    }
+  }
+
+  const modifiedFiles = []
+  async function scanDir(dir, prefix = '') {
+    const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => [])
+    for (const entry of entries) {
+      if (entry.name === '.git') continue
+      const rel = prefix ? `${prefix}/${entry.name}` : entry.name
+      const full = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        await scanDir(full, rel)
+      } else {
+        modifiedFiles.push(rel)
+      }
+    }
+  }
+  await scanDir(worktreePath)
+  return { diffText: '', modifiedFiles }
+}
+
+/**
+ * Guarantees removal of all swarm worktrees and temporary directories.
+ *
+ * @param {string} cwd
+ * @param {string} runId
+ * @param {Array<{ worktreePath: string, isGitWorktree: boolean }>} worktrees
+ */
+export async function cleanupSwarmWorktrees(cwd, runId, worktrees = []) {
+  for (const wt of worktrees) {
+    if (!wt?.worktreePath) continue
+    if (wt.isGitWorktree) {
+      try {
+        await execFileAsync('git', ['worktree', 'remove', '--force', wt.worktreePath], { cwd, timeout: 8000 })
+      } catch {}
+    }
+    try {
+      await fs.rm(wt.worktreePath, { recursive: true, force: true })
+    } catch {}
+  }
+
+  if (await isGitRepository(cwd)) {
+    try {
+      await execFileAsync('git', ['worktree', 'prune'], { cwd, timeout: 5000 })
+    } catch {}
+  }
+
+  const safeRunId = String(runId || '').replace(/[^a-zA-Z0-9_-]/g, '')
+  if (safeRunId) {
+    const swarmRoot = path.join(cwd, '.moa', `swarm-${safeRunId}`)
+    try {
+      await fs.rm(swarmRoot, { recursive: true, force: true })
+    } catch {}
+  }
+}
+
+/**
+ * Runs candidates as a swarm with isolated worktrees.
+ * Uses ctx.subagent.run if available on Cordis context, falling back to callLlm + worktree materialization.
+ */
+export async function runSubagentSwarm(references, messages, options = {}, callLlm, onProgress) {
+  const cwd = options.cwd || process.cwd()
+  const runId = options.runId || `run-${Date.now()}`
+  const worktrees = []
+
+  try {
+    if (typeof onProgress === 'function') {
+      onProgress(`🐝 *Launching MoA Subagent Swarm across ${references.length} isolated worktrees...*\n`)
+    }
+
+    const tasks = references.map(async (slot, idx) => {
+      const candidateIndex = idx + 1
+      const label = slotLabel(slot)
+      const wt = await createSwarmWorktree(cwd, runId, candidateIndex)
+      worktrees.push(wt)
+
+      const start = Date.now()
+      let responseText = ''
+      let usage = { inputTokens: 100, outputTokens: 100, totalTokens: 200, costUsd: 0 }
+
+      if (options.ctx?.subagent && typeof options.ctx.subagent.run === 'function') {
+        const subRes = await options.ctx.subagent.run({
+          provider: slot.provider,
+          model: slot.model,
+          cwd: wt.worktreePath,
+          messages,
+          signal: options.signal,
+        })
+        responseText = typeof subRes === 'string' ? subRes : (subRes?.content || subRes?.text || '')
+        if (subRes?.usage) usage = subRes.usage
+      } else {
+        const llmRes = await callLlm({
+          provider: slot.provider,
+          model: slot.model,
+          messages,
+          temperature: options.temperature ?? 0.6,
+          maxTokens: options.maxTokens ?? 4096,
+          signal: options.signal,
+        })
+        responseText = typeof llmRes === 'string' ? llmRes : (llmRes?.content || llmRes?.text || '')
+        if (llmRes?.usage) usage = llmRes.usage
+      }
+
+      // Materialize any extracted file blocks inside the isolated worktree
+      const files = extractFileBlocks(responseText)
+      for (const f of files) {
+        const targetFile = path.join(wt.worktreePath, f.relativePath || f.path || "")
+        await fs.mkdir(path.dirname(targetFile), { recursive: true })
+        await fs.writeFile(targetFile, f.content, 'utf8')
+      }
+
+      const diffInfo = await collectSwarmWorktreeDiff(wt.worktreePath, wt.isGitWorktree)
+      const enrichedText = diffInfo.diffText
+        ? `${responseText}\n\n#### Git Worktree Diff (${wt.branchName}):\n\`\`\`diff\n${diffInfo.diffText}\n\`\`\``
+        : responseText
+
+      return {
+        index: candidateIndex,
+        slot,
+        label,
+        text: enrichedText,
+        files,
+        swarmWorktree: wt.worktreePath,
+        swarmBranch: wt.branchName,
+        modifiedFiles: diffInfo.modifiedFiles,
+        usage,
+        costUsd: usage.costUsd || 0,
+        durationMs: Date.now() - start,
+        ok: true,
+      }
+    })
+
+    return await Promise.all(tasks)
+  } finally {
+    await cleanupSwarmWorktrees(cwd, runId, worktrees)
+  }
+}

package/lib/moa-workbench.js

@@ -27,6 +27,18 @@ export const COMPANION_PLUGINS = [
     url: 'https://github.com/goodandready/dsh-time-machine',
     description: 'Pre-promotion shadow Git checkpoints and rollback points',
   },
+  {
+    id: 'dsh-key-limits',
+    name: 'DSH Key Limits',
+    url: 'https://github.com/GooDAnDReaDY/dsh-key-limits',
+    description: 'Provider API key rate-limit and quota telemetry',
+  },
+  {
+    id: 'dsh-subscriptions',
+    name: 'DSH Subscriptions',
+    url: 'https://github.com/GooDAnDReaDY/dsh-subscriptions',
+    description: 'Subscription tier and quota tracking for LLM providers',
+  },
 ]
 
 /**

package/lib/pipeline/candidates.js

@@ -1,3 +1,5 @@
+import { assignAdaptivePersonas } from '../moa-adaptive-personas.js'
+import { runSubagentSwarm } from '../moa-swarm.js'
 import { runReferencesParallel } from '../moa-candidates.js'
 import { extractFileBlocks, writeCandidateWorkspace, cleanMoaWorkspaces } from '../workspace/fs.js'
 import { verifyFileSyntax } from '../workspace/diff.js'
@@ -30,8 +32,15 @@ export async function stageCandidateRound1({
   testCommand,
   execFn,
 }) {
-  const referenceOutputs = await runReferencesParallel(
-    effectiveReferences,
+  const lastMsgText = enrichedMessages[enrichedMessages.length - 1]?.content || ''
+  const adaptiveRefs = preset?.adaptive_personas_enabled
+    ? assignAdaptivePersonas(effectiveReferences, typeof lastMsgText === 'string' ? lastMsgText : '').references
+    : effectiveReferences
+
+  const referenceOutputs = preset?.subagent_swarm_enabled
+    ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, callLlm, onProgress)
+    : await runReferencesParallel(
+    adaptiveRefs,
     enrichedMessages,
     {
       systemPrompt: candidateSystemPrompt,

package/lib/pipeline/context.js

@@ -1,3 +1,4 @@
+import { balanceCandidateQuotas } from '../moa-quota-balancer.js'
 import { collectProjectContext, formatProjectContext, isRefinementTask } from '../workspace/scanner.js'
 import { applyBudgetGuardrails, createBudgetAbortPayload } from '../moa-budget.js'
 import { extractPriorTurnBaseline, pruneMultiTurnMessages } from '../moa-context.js'
@@ -13,6 +14,7 @@ export async function stageProjectContext({
   maxTokens,
   startTime,
   onProgress,
+  ctx = null,
 }) {
   const rawRefs = (Array.isArray(preset?.reference_models) && preset.reference_models.length > 0)
     ? preset.reference_models
@@ -79,7 +81,23 @@ export async function stageProjectContext({
     return { ok: false, abortPayload }
   }
 
-  const effectiveReferences = budgetCheck.references
+  let effectiveReferences = budgetCheck.references
+  let quotaSubstitutions = []
+  if (preset?.quota_aware_balancing_enabled) {
+    const fallbackPool = Array.isArray(preset?.local_fallback_models) && preset.local_fallback_models.length > 0
+      ? preset.local_fallback_models
+      : undefined
+    const bal = await balanceCandidateQuotas(effectiveReferences, {
+      ctx,
+      aggregator: primaryJudge,
+      fallbackPool,
+    })
+    effectiveReferences = bal.balancedReferences
+    quotaSubstitutions = bal.substitutions
+    if (quotaSubstitutions.length > 0 && typeof onProgress === "function") {
+      onProgress(`⚖️ *Quota-Aware Balancing: Replaced ${quotaSubstitutions.length} low-quota slot(s) to preserve aggregator budget.*\n`)
+    }
+  }
   if (effectiveReferences.length === 1 && !preset?.curator_synthesis) {
     isFastMode = true
   }
@@ -103,7 +121,7 @@ export async function stageProjectContext({
     isStreamAggregator, isQuorumEnabled, gracePeriodSec, candidateRetries,
     refTimeoutSec, aggTimeoutSec, isBlindEvaluation, isPeerCritiqueEnabled,
     allowCandidateOverride, collectedCtx, isRefinement, projectContext,
-    effectiveReferences, priorTurnBaseline, candidateSystemPrompt,
+    effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
   }
 }

package/lib/pipeline/promotion.js

@@ -1,3 +1,4 @@
+import { runSelfHealingLoop } from '../moa-self-healing.js'
 import { logger } from '../logger.js'
 import { parseWinnerIndex, parseRecommendedAssembler } from '../moa-parser.js'
 import { extractFileBlocks, writeCandidateWorkspace, promoteCandidateWorkspace, cleanMoaWorkspaces } from '../workspace/fs.js'
@@ -33,6 +34,9 @@ export async function stagePromotion({
   historyFilePath,
   collectedCtx,
   ctx = null,
+  callLlm = null,
+  onProgress = null,
+  execFn = null,
 }) {
   const winningIndex = (multiJudgeResult?.consensus && multiJudgeResult?.winningCandidateIndex)
     ? multiJudgeResult.winningCandidateIndex
@@ -69,6 +73,24 @@ export async function stagePromotion({
     throw promoteErr
   }
 
+  let selfHealingResult = null
+  if (preset?.self_healing_enabled && promotedFiles.length > 0 && typeof callLlm === "function") {
+    selfHealingResult = await runSelfHealingLoop({
+      cwd,
+      command: preset.self_healing_command || "npm test",
+      maxRetries: preset.self_healing_max_retries ?? 2,
+      aggregatorSlot: chosenJudge,
+      callLlm,
+      userPrompt,
+      promotedFiles,
+      checkpoint: promotedFiles.checkpoint || null,
+      promoteOpts,
+      onProgress,
+      signal,
+      execFn,
+    })
+  }
+
   const livePreview = await createPromotedPreview(liveCanvas, cwd, promotedFiles, referenceOutputs, { winningIndex, synthesizedFiles })
   const durationMs = Date.now() - startTime
   const usageSummary = summarizeMoAUsage(referenceOutputs, aggUsage, multiJudgeResult?.totalUsage)
@@ -125,7 +147,7 @@ export async function stagePromotion({
       kind: 'synthesis', content: synthesizedText, aggregator: isFastMode ? 'Fast Mode (Direct)' : finalAggLabel,
       references: referenceOutputs, presetName: preset?.name || 'default', isRefinement, isFastMode, isCuratorSynthesis,
       recommendedAssembler, winningIndex, winnerModel, promotedFiles, runId, allowCandidateOverride,
-      benchmarkReport, consensus: multiJudgeResult, fileScores, ...(livePreview ? { liveCanvas: livePreview } : {}),
+      benchmarkReport, consensus: multiJudgeResult, fileScores, ...(selfHealingResult ? { selfHealing: selfHealingResult } : {}), ...(livePreview ? { liveCanvas: livePreview } : {}),
       usage: usageSummary, skippedFiles: collectedCtx?.skippedFiles || 0, skippedList: collectedCtx?.skippedList || [], durationMs,
     }
   }

package/lib/pipeline/runner.js

@@ -40,7 +40,7 @@ export async function runMoAPipeline({
 
   // Stage 1: Context & Configuration
   const ctxStage = await stageProjectContext({
-    userPrompt, messages, preset, cwd, prices, maxTokens: preset?.max_tokens, startTime, onProgress,
+    userPrompt, messages, preset, cwd, prices, maxTokens: preset?.max_tokens, startTime, onProgress, ctx,
   })
   if (!ctxStage.ok) return ctxStage.abortPayload
 
@@ -189,7 +189,7 @@ export async function runMoAPipeline({
     promoteOpts, cwd, runId, signal, liveCanvas, startTime, chosenJudge, aggUsage,
     userPrompt, preset, isRefinement: ctxStage.isRefinement, isFastMode: ctxStage.isFastMode,
     effectiveReferences: ctxStage.effectiveReferences, referenceModels: ctxStage.referenceModels,
-    historyFilePath, collectedCtx: ctxStage.collectedCtx, ctx,
+    historyFilePath, collectedCtx: ctxStage.collectedCtx, ctx, callLlm, onProgress, execFn,
   })
   if (!promRes.ok) {
     if (promRes.abort) return { error: promRes.error }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.67",
+  "version": "0.2.69",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",