@goodandready/dsh-moa 0.2.68 → 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/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

@@ -66,6 +66,10 @@ export const PresetSchema = z.object({
   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({
@@ -78,6 +82,10 @@ export const Config = z.object({
   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-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/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.68",
+  "version": "0.2.69",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",