@goodandready/dsh-moa 0.2.63 → 0.2.65

package/lib/commands.js

@@ -0,0 +1,83 @@
+/**
+ * Official Slash Command Registration for /moa via dsh-commands service (#275)
+ */
+
+import { service } from './services.js'
+
+export function registerMoaCommands(ctx, { live, moaService }) {
+  const registerWithService = (cmdCtx) => {
+    if (!cmdCtx) return
+    const commands = service(cmdCtx, 'commands')
+    if (!commands || typeof commands.register !== 'function') return
+
+    const formatPresetsList = (cfg) => {
+      const presets = Array.isArray(cfg?.presets) ? cfg.presets : []
+      if (presets.length === 0) return 'No presets configured in dsh-moa.'
+      return '### 🧠 Configured MoA Presets:\n' + presets.map((p, i) =>
+        `- **${p.name}** (${p.id || `preset-${i + 1}`}): ${p.description || 'Consensus preset'} | ${p.references?.length || p.reference_models?.length || 0} advisors`
+      ).join('\n')
+    }
+
+    const commandHandler = async (invocation) => {
+      const rawText = typeof invocation === 'string' ? invocation : (invocation?.text || invocation?.raw || invocation?.args || '')
+      const trimmed = String(rawText).trim()
+
+      if (!trimmed || trimmed === 'help' || trimmed === '--help') {
+        return {
+          text: '🧠 **MoA Command Guide**:\n- `/moa presets` — list configured presets\n- `/moa history` — view recent runs\n- `/moa status` — check plugin status\n- `/moa [--preset <name>] <prompt>` — run MoA consensus in chat',
+        }
+      }
+
+      if (trimmed === 'presets' || trimmed === 'list') {
+        const cfg = typeof live === 'function' ? live() : {}
+        return { text: formatPresetsList(cfg) }
+      }
+
+      if (trimmed === 'status') {
+        const cfg = typeof live === 'function' ? live() : {}
+        return {
+          text: `🧠 **MoA Plugin Status**: ${cfg?.enabled !== false ? 'Enabled' : 'Disabled'} | Default preset: \`${cfg?.default_preset || 'default'}\``,
+        }
+      }
+
+      if (trimmed === 'history') {
+        const hist = moaService?.getHistory ? moaService.getHistory(5, 0) : { runs: [] }
+        if (!hist?.runs?.length) return { text: 'No MoA runs recorded in history.' }
+        return {
+          text: '### 📜 Recent MoA Runs:\n' + hist.runs.slice(0, 5).map((r) =>
+            `- \`${r.id?.slice(0, 8)}\` (${r.preset || 'default'}): "${r.prompt?.slice(0, 40)}..." (Winner: ${r.winnerModel || 'none'}, $${(r.totalCostUsd || 0).toFixed(4)})`
+          ).join('\n'),
+        }
+      }
+
+      return {
+        text: `🧠 MoA turn dispatched: "${trimmed}". The turn will execute with live consensus streaming.`,
+      }
+    }
+
+    const unregister = commands.register({
+      definitionId: '@goodandready/dsh-moa',
+      name: 'moa',
+      description: 'Run Mixture of Agents consensus or inspect presets (/moa [presets|history|status|<prompt>])',
+      input: { hint: '[presets|history|status|<prompt>]' },
+      handler: commandHandler,
+      execute: async (rawArgs, invocation = null) => {
+        const res = await commandHandler(invocation || rawArgs)
+        return res?.text || String(res || '')
+      },
+    })
+
+    const eff = typeof cmdCtx.effect === 'function' ? cmdCtx.effect : (fn) => fn()
+    eff(() => () => {
+      try {
+        if (typeof unregister === 'function') unregister()
+      } catch (_e) {}
+    }, 'dsh-moa: slash command registration')
+  }
+
+  if (service(ctx, 'commands')?.register) {
+    registerWithService(ctx)
+  } else if (typeof ctx.inject === 'function') {
+    ctx.inject(['commands'], registerWithService)
+  }
+}

package/lib/errors.js

@@ -0,0 +1,176 @@
+/**
+ * Centralized LLM and MoA Pipeline Error Taxonomy and Classification
+ */
+
+export class MoaError extends Error {
+  /**
+   * @param {string} message
+   * @param {object} [options]
+   */
+  constructor(message, options = {}) {
+    super(message)
+    this.name = new.target.name || 'MoaError'
+    this.code = options.code || 'MOA_ERROR'
+    this.status = typeof options.status === 'number' ? options.status : undefined
+    this.isRetryable = Boolean(options.isRetryable)
+    this.fallbackEligible = options.fallbackEligible !== false
+    this.cause = options.cause
+  }
+}
+
+export class RateLimitError extends MoaError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'RATE_LIMIT_EXCEEDED',
+      status: 429,
+      isRetryable: true,
+      fallbackEligible: true,
+      ...options,
+    })
+  }
+}
+
+export class ContextOverflowError extends MoaError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'CONTEXT_WINDOW_EXCEEDED',
+      status: 400,
+      isRetryable: false,
+      fallbackEligible: true,
+      ...options,
+    })
+  }
+}
+
+export class AuthenticationError extends MoaError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'AUTHENTICATION_FAILED',
+      status: options.status || 401,
+      isRetryable: false,
+      fallbackEligible: false,
+      ...options,
+    })
+  }
+}
+
+export class ModelNotFoundError extends MoaError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'MODEL_NOT_FOUND',
+      status: 404,
+      isRetryable: false,
+      fallbackEligible: true,
+      ...options,
+    })
+  }
+}
+
+export class TransientNetworkError extends MoaError {
+  constructor(message, options = {}) {
+    super(message, {
+      code: 'TRANSIENT_NETWORK_ERROR',
+      status: options.status || 503,
+      isRetryable: true,
+      fallbackEligible: true,
+      ...options,
+    })
+  }
+}
+
+/**
+ * Classifies an unknown error or exception into a structured MoA domain error.
+ *
+ * @param {unknown} err
+ * @returns {MoaError}
+ */
+export function classifyLlmError(err) {
+  if (!err) return new MoaError('Unknown error')
+  if (err instanceof MoaError) return err
+
+  const msg = String(err.message || err).toLowerCase()
+  const status = Number(err.status || err.statusCode || (msg.match(/\b(401|403|404|429|500|502|503|504)\b/)?.[1])) || undefined
+  const code = String(err.code || '').toUpperCase()
+
+  // Rate limit / Quota
+  if (
+    status === 429 ||
+    msg.includes('rate limit') ||
+    msg.includes('too many requests') ||
+    msg.includes('tpm') ||
+    msg.includes('rpm') ||
+    msg.includes('quota exceeded') ||
+    code.includes('RATE_LIMIT') ||
+    code.includes('QUOTA')
+  ) {
+    return new RateLimitError(err.message || String(err), { status: 429, cause: err })
+  }
+
+  // Context window overflow
+  if (
+    msg.includes('context window') ||
+    msg.includes('context length') ||
+    msg.includes('maximum context') ||
+    msg.includes('too long') ||
+    msg.includes('token limit') ||
+    code.includes('CONTEXT_WINDOW')
+  ) {
+    return new ContextOverflowError(err.message || String(err), { status: 400, cause: err })
+  }
+
+  // Authentication & permissions
+  if (
+    status === 401 ||
+    status === 403 ||
+    msg.includes('unauthorized') ||
+    msg.includes('invalid api key') ||
+    msg.includes('forbidden') ||
+    msg.includes('authentication') ||
+    code.includes('AUTH') ||
+    code.includes('INVALID_CREDENTIAL')
+  ) {
+    return new AuthenticationError(err.message || String(err), { status: status || 401, cause: err })
+  }
+
+  // Model not found / unavailable
+  if (
+    status === 404 ||
+    msg.includes('model not found') ||
+    msg.includes('does not exist') ||
+    msg.includes('unknown model') ||
+    code.includes('MODEL_NOT_FOUND')
+  ) {
+    return new ModelNotFoundError(err.message || String(err), { status: 404, cause: err })
+  }
+
+  // Transient network / gateway / timeout
+  if (
+    status === 502 ||
+    status === 503 ||
+    status === 504 ||
+    msg.includes('timeout') ||
+    msg.includes('econnreset') ||
+    msg.includes('etimedout') ||
+    msg.includes('network') ||
+    msg.includes('socket hang up') ||
+    msg.includes('service unavailable') ||
+    msg.includes('bad gateway') ||
+    code.includes('TIMEOUT') ||
+    code.includes('ECONNRESET')
+  ) {
+    return new TransientNetworkError(err.message || String(err), { status: status || 503, cause: err })
+  }
+
+  return new MoaError(err.message || String(err), { status, cause: err })
+}
+
+/**
+ * Returns true if the error qualifies for candidate failover to a reserve model.
+ *
+ * @param {unknown} err
+ * @returns {boolean}
+ */
+export function isFailoverEligible(err) {
+  const classified = classifyLlmError(err)
+  return classified.fallbackEligible
+}

package/lib/events.js

@@ -0,0 +1,30 @@
+/**
+ * Cordis Event Bus Definitions and Helpers for dsh-moa
+ */
+
+export const MOA_EVENTS = {
+  RUN_START: 'moa/run-start',
+  CANDIDATE_COMPLETE: 'moa/candidate-complete',
+  CRITIQUE_COMPLETE: 'moa/critique-complete',
+  JUDGE_VERDICT: 'moa/judge-verdict',
+  RUN_FINISH: 'moa/run-finish',
+}
+
+/**
+ * Dispatches an event onto the Cordis event bus with best-effort error isolation.
+ * If ctx or ctx.emit is not available, or an event listener throws, the pipeline is not interrupted.
+ *
+ * @param {object} [ctx] - Cordis context or mock context
+ * @param {string} eventName - One of MOA_EVENTS
+ * @param {object} payload - Event data payload
+ */
+export function emitEvent(ctx, eventName, payload) {
+  if (!ctx || !eventName) return
+  try {
+    if (typeof ctx.emit === 'function') {
+      ctx.emit(eventName, payload)
+    }
+  } catch (_err) {
+    /* best-effort event dispatch: listener exceptions must never abort pipeline */
+  }
+}

package/lib/index.js

@@ -1,3 +1,4 @@
+import { registerMoaCommands } from './commands.js'
 import { service, getWebServerPort } from './services.js'
 import crypto from 'node:crypto'
 import path from 'node:path'
@@ -22,6 +23,9 @@ import { createLiveCanvasClient } from './live-canvas.js'
 import { registerPluginUpdater } from './updater.js'
 import { bestEffort } from './best-effort.js'
 import { getMoaHistory } from './history.js'
+import { runMoAPipeline } from './moa-runner.js'
+import { MoaService } from './moa-service.js'
+import { MOA_EVENTS, emitEvent } from './events.js'
 
 export const name = '@goodandready/dsh-moa'
 export { collectProjectContext, formatProjectContext } from './file-workspace.js'
@@ -132,6 +136,23 @@ export function apply(ctx, config) {
   // required to be installed).
   const liveCanvas = createLiveCanvasClient({ getPort: () => getWebServerPort(ctx) })
 
+  // Native Cordis service: ctx.moa
+  const moaService = new MoaService(ctx, {
+    live,
+    runMoAPipeline,
+    resolvePresetForPrompt,
+    getMoaHistory,
+    callLlm,
+    liveCanvas,
+    get webServerPort() { return getWebServerPort(ctx) },
+    get timeMachineEngine() { return service(ctx, 'timeMachineEngine') },
+  })
+
+  if (typeof ctx.provide === 'function') {
+    ctx.provide('moa', moaService)
+  }
+  ctx.moa = moaService
+
   // Route: /dsh-moa/status & one-click updater
   const registerWebSurfaces = (webCtx) => {
     if (!webCtx) return
@@ -165,6 +186,9 @@ export function apply(ctx, config) {
     ctx.inject(['webServer'], registerWebSurfaces)
   }
 
+  // Official slash command /moa registration via dsh-commands (#275)
+  registerMoaCommands(ctx, { live, moaService })
+
   // Session turn interceptor: route turn to real aggregator model & stream MoA synthesis
   ctx.effect(() => {
     return () => {
@@ -284,6 +308,7 @@ export function apply(ctx, config) {
             liveCanvas,
             webServerPort: getWebServerPort(ctx),
             timeMachineEngine: service(ctx, 'timeMachineEngine') || ctx.reflect?.get?.('timeMachineEngine', false),
+            ctx,
           }
 
           if (event.signal) {
@@ -337,6 +362,8 @@ export function apply(ctx, config) {
 }
 
 export { runMoAPipeline } from './moa-runner.js'
+export { MoaService } from './moa-service.js'
+export { MOA_EVENTS, emitEvent } from './events.js'
 export { executeTestGateForCandidates, runCandidateTestGate } from './moa-test-gate.js'
 export {
   COMPANION_PLUGINS,
@@ -347,3 +374,14 @@ export {
   handleWorkbenchGet,
   handleWorkbenchAssemble,
 } from './moa-workbench.js'
+export { registerMoaCommands } from './commands.js'
+export {
+  MoaError,
+  RateLimitError,
+  ContextOverflowError,
+  AuthenticationError,
+  ModelNotFoundError,
+  TransientNetworkError,
+  classifyLlmError,
+  isFailoverEligible,
+} from './errors.js'

package/lib/moa-candidates.js

@@ -1,3 +1,4 @@
+import { classifyLlmError, isFailoverEligible } from './errors.js'
 import { logger } from './logger.js'
 /**
  * DeepSeek Harness Mixture of Agents (MoA) — Candidate Fan-Out & Retry
@@ -18,14 +19,13 @@ export async function callWithTransientRetry(callLlmFn, callArgs, maxRetries = 0
       return await callLlmFn(callArgs)
     } catch (err) {
       attempt++
-      const msg = err?.message || String(err)
-      const isTransient = /429|rate limit|502|503|504|econnreset|etimedout|socket hang up/i.test(msg)
-      if (attempt <= maxRetries && isTransient && !callArgs?.signal?.aborted) {
+      const classified = classifyLlmError(err)
+      if (attempt <= maxRetries && classified.isRetryable && !callArgs?.signal?.aborted) {
         await new Promise((r) => setTimeout(r, retryDelayMs))
         if (callArgs?.signal?.aborted) throw new Error('Aborted')
         continue
       }
-      throw err
+      throw classified
     }
   }
 }
@@ -100,6 +100,7 @@ export async function runReferencesParallel(references, messages, options = {},
 
     const runOne = async () => {
       let candidateTimer = null
+      const candidateStart = Date.now()
       try {
         const callPromise = callWithTransientRetry(
           callLlm,
@@ -144,6 +145,8 @@ export async function runReferencesParallel(references, messages, options = {},
           text,
           usage: costInfo,
           costUsd: costInfo.costUsd,
+          durationMs: Date.now() - candidateStart,
+          model: slot?.model ? (slot.provider ? (slot.provider + ":" + slot.model) : slot.model) : label,
           ok: true,
         }
 
@@ -173,10 +176,29 @@ export async function runReferencesParallel(references, messages, options = {},
           return
         }
 
-        // Feature 10: Local fallback models if online candidate fails
+        const classified = classifyLlmError(err)
+        const canFailover = isFailoverEligible(classified)
+
+        // Reserve model failover: checks slot.fallbacks, options.fallback_models, or options.local_fallback_models
         let fallbackRecovered = false
-        if (options.local_fallback_enabled && Array.isArray(options.local_fallback_models) && options.local_fallback_models.length > 0) {
-          for (const fbSlot of options.local_fallback_models) {
+        const fallbackCandidates = [
+          ...(Array.isArray(slot?.fallbacks) ? slot.fallbacks : []),
+          ...(Array.isArray(options.fallback_models) ? options.fallback_models : []),
+          ...(options.local_fallback_enabled && Array.isArray(options.local_fallback_models) ? options.local_fallback_models : []),
+        ].filter(Boolean)
+
+        const seenFb = new Set([`${slot.provider}:${slot.model}`])
+        const eligibleFallbacks = []
+        for (const fb of fallbackCandidates) {
+          const key = `${fb.provider}:${fb.model}`
+          if (!seenFb.has(key)) {
+            seenFb.add(key)
+            eligibleFallbacks.push(fb)
+          }
+        }
+
+        if (canFailover && eligibleFallbacks.length > 0) {
+          for (const fbSlot of eligibleFallbacks) {
             if (options.signal?.aborted) break
             const fbLabel = slotLabel(fbSlot)
             const fbAbortCtrl = new AbortController()
@@ -195,7 +217,7 @@ export async function runReferencesParallel(references, messages, options = {},
 
             try {
               if (typeof onProgress === 'function') {
-                onProgress(`🔄 *Candidate ${i + 1} (${label}) failed, attempting local fallback to ${fbLabel}...*\n`)
+                onProgress(`🔄 *Candidate ${i + 1} (${label}) hit ${classified.name}, failover to ${fbLabel}...*\n`)
               }
               const fbCallPromise = callWithTransientRetry(
                 callLlm,
@@ -240,14 +262,15 @@ export async function runReferencesParallel(references, messages, options = {},
                 ok: true,
                 was_fallback: true,
                 original_model: label,
+                failoverReason: classified.code,
               }
               fallbackRecovered = true
               if (typeof onProgress === 'function') {
-                onProgress(`✅ *Candidate ${i + 1}/${total} recovered using fallback (${fbLabel})*\n`)
+                onProgress(`✅ *Candidate ${i + 1}/${total} recovered using failover (${fbLabel})*\n`)
               }
               break
             } catch (fbErr) {
-              logger.warn(`[dsh-moa] Fallback ${fbLabel} also failed:`, fbErr?.message || fbErr)
+              logger.warn(`[dsh-moa] Reserve model ${fbLabel} also failed:`, fbErr?.message || fbErr)
             } finally {
               if (fbTimer) clearTimeout(fbTimer)
               if (removeParentAbort) removeParentAbort()
@@ -257,7 +280,7 @@ export async function runReferencesParallel(references, messages, options = {},
 
         if (!fallbackRecovered) {
           finishedCount++
-          const errMsg = err?.message || String(err)
+          const errMsg = classified?.message || err?.message || String(err)
           logger.warn(`[dsh-moa] Reference ${label} failed:`, errMsg)
           if (typeof onProgress === 'function') {
             onProgress(`⚠️ *Candidate ${i + 1}/${total} (${label}) error: ${errMsg}*\n`)
@@ -273,6 +296,8 @@ export async function runReferencesParallel(references, messages, options = {},
             costUsd: 0,
             ok: false,
             error: errMsg,
+            errorClass: classified.name,
+            errorCode: classified.code,
           }
         }
       } finally {

package/lib/moa-service.js

@@ -0,0 +1,155 @@
+/**
+ * Native Cordis Service: ctx.moa
+ * Allows in-process MoA consensus pipeline execution and telemetry by peer plugins.
+ */
+
+import { emitEvent, MOA_EVENTS } from './events.js'
+
+export class MoaService {
+  /**
+   * @param {import('@deepseek-ai/cordis').Context} ctx
+   * @param {object} [deps={}]
+   */
+  constructor(ctx, deps = {}) {
+    this.ctx = ctx
+    this.deps = deps
+  }
+
+  get live() {
+    return typeof this.deps.live === 'function' ? this.deps.live() : (this.deps.live || {})
+  }
+
+  /**
+   * Get all active configured presets
+   * @returns {Array<object>}
+   */
+  getPresets() {
+    const cfg = this.live
+    return Array.isArray(cfg?.presets) ? [...cfg.presets] : []
+  }
+
+  /**
+   * Get preset by ID or name
+   * @param {string} [idOrName]
+   * @returns {object|null}
+   */
+  getPreset(idOrName) {
+    const presets = this.getPresets()
+    if (!idOrName) return presets[0] || null
+    return presets.find((p) => p.id === idOrName || p.name === idOrName) || presets[0] || null
+  }
+
+  /**
+   * Get historical MoA runs
+   * @param {number} [limit=20]
+   * @param {number} [offset=0]
+   * @returns {object}
+   */
+  getHistory(limit = 20, offset = 0) {
+    const getHistoryFn = this.deps.getMoaHistory
+    if (typeof getHistoryFn === 'function') {
+      return getHistoryFn(limit, offset)
+    }
+    return { runs: [], total: 0 }
+  }
+
+  /**
+   * Resolve best preset for a given user prompt
+   * @param {string} prompt
+   * @returns {Promise<object>}
+   */
+  async resolvePresetForPrompt(prompt) {
+    const resolveFn = this.deps.resolvePresetForPrompt
+    if (typeof resolveFn === 'function') {
+      return resolveFn({ prompt, live: () => this.live, callLlm: this.deps.callLlm })
+    }
+    return { preset: this.getPreset() }
+  }
+
+  /**
+   * Run MoA consensus pipeline in-process
+   * @param {object} options
+   * @returns {Promise<object>}
+   */
+  async run(options = {}) {
+    const runFn = this.deps.runMoAPipeline
+    if (typeof runFn !== 'function') {
+      throw new Error('[dsh-moa] runMoAPipeline is not available in MoaService')
+    }
+
+    const {
+      prompt,
+      userPrompt,
+      messages = [],
+      preset: customPreset,
+      presetId,
+      cwd = process.cwd(),
+      signal,
+      onProgress,
+      onStreamDelta,
+      checkpoint,
+      force,
+      testGateEnabled,
+      testCommand,
+    } = options
+
+    const effectivePrompt = prompt || userPrompt || (messages[messages.length - 1]?.content) || ''
+    if (!effectivePrompt && messages.length === 0) {
+      throw new Error('[dsh-moa] prompt or userPrompt is required to run MoA')
+    }
+
+    let preset = customPreset
+    if (!preset) {
+      if (presetId) {
+        preset = this.getPreset(presetId)
+      } else {
+        const routed = await this.resolvePresetForPrompt(effectivePrompt)
+        preset = routed?.preset || this.getPreset()
+      }
+    }
+
+    const cfg = this.live
+    return runFn({
+      userPrompt: effectivePrompt,
+      messages,
+      preset,
+      callLlm: options.callLlm || this.deps.callLlm,
+      cwd,
+      prices: options.prices || cfg?.prices || this.deps.prices || {},
+      onProgress,
+      onStreamDelta,
+      signal,
+      checkpoint,
+      force,
+      testGateEnabled,
+      testCommand,
+      liveCanvas: options.liveCanvas || this.deps.liveCanvas,
+      webServerPort: options.webServerPort || this.deps.webServerPort,
+      timeMachineEngine: options.timeMachineEngine || this.deps.timeMachineEngine,
+      historyFilePath: options.historyFilePath || this.deps.historyFilePath,
+      ctx: this.ctx,
+    })
+  }
+
+  /**
+   * Attach listener to MoA events on the underlying Cordis Context
+   * @param {string} event
+   * @param {Function} listener
+   * @returns {Function|undefined}
+   */
+  on(event, listener) {
+    if (typeof this.ctx?.on === 'function') {
+      return this.ctx.on(event, listener)
+    }
+    return undefined
+  }
+
+  /**
+   * Emit an event on the Cordis event bus
+   * @param {string} event
+   * @param {any} payload
+   */
+  emit(event, payload) {
+    emitEvent(this.ctx, event, payload)
+  }
+}

package/lib/moa-stream.js

@@ -11,7 +11,7 @@ import { runMoAPipeline } from './moa-runner.js'
 /**
  * Streams a full MoA turn into chat with live aggregator tokens and progress feedback.
  */
-export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd, prices, historyFilePath, liveCanvas, webServerPort, timeMachineEngine, force }, options = {}) {
+export async function* streamMoATurn({ targetPreset, userPrompt, messages, callLlm, cwd, prices, historyFilePath, liveCanvas, webServerPort, timeMachineEngine, force, ctx }, options = {}) {
   const signal = options?.signal
   const runId = options?.runId || null
   if (signal?.aborted) return
@@ -58,6 +58,7 @@ export async function* streamMoATurn({ targetPreset, userPrompt, messages, callL
       force,
       signal: combinedSignal,
       runId,
+      ctx,
     })
       .catch((err) => ({ error: err }))
       .finally(() => {

package/lib/pipeline/context.js

@@ -14,8 +14,10 @@ export async function stageProjectContext({
   startTime,
   onProgress,
 }) {
-  const referenceModels = Array.isArray(preset?.reference_models) && preset.reference_models.length > 0
-    ? preset.reference_models : [{ provider: '', model: '' }]
+  const rawRefs = (Array.isArray(preset?.reference_models) && preset.reference_models.length > 0)
+    ? preset.reference_models
+    : (Array.isArray(preset?.references) && preset.references.length > 0 ? preset.references : [])
+  const referenceModels = rawRefs.length > 0 ? rawRefs : [{ provider: '', model: '' }]
   const primaryJudge = preset?.aggregator?.provider && preset?.aggregator?.model
     ? preset.aggregator : { provider: '', model: '' }
   const fallbackJudges = Array.isArray(preset?.aggregator_fallbacks) ? preset.aggregator_fallbacks : []

package/lib/pipeline/fast-mode.js

@@ -2,6 +2,7 @@ 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'
 
 export async function stageFastMode({
   successfulRefs,
@@ -18,6 +19,7 @@ export async function stageFastMode({
   startTime,
   collectedCtx,
   liveCanvas,
+  ctx = null,
 }) {
   if (signal?.aborted) {
     await cleanMoaWorkspaces(cwd, { runId })
@@ -51,6 +53,9 @@ export async function stageFastMode({
     } catch (histErr) {
       logger.warn('[dsh-moa] Failed to record fast synthesis failure in history:', histErr?.message || histErr)
     }
+    emitEvent(ctx, MOA_EVENTS.RUN_FINISH, {
+      runId, durationMs, totalTokens, totalCostUsd, promotedFiles: [], winnerIndex: 0, error: promoteErr?.message || String(promoteErr),
+    })
     return {
       ok: false,
       payload: {
@@ -87,6 +92,9 @@ export async function stageFastMode({
     logger.warn('[dsh-moa] Failed to record fast synthesis run in history:', histErr?.message || histErr)
   }
 
+  emitEvent(ctx, MOA_EVENTS.RUN_FINISH, {
+    runId, durationMs, totalTokens, totalCostUsd, promotedFiles, winnerIndex: single.index,
+  })
   return {
     ok: true,
     payload: {

package/lib/pipeline/peer-critique.js

@@ -109,5 +109,5 @@ export async function stagePeerCritique({
     })
   }
 
-  return { ok: true }
+  return { ok: true, critiquesCount: runRound2 ? successfulRefs.length : 0 }
 }

package/lib/pipeline/promotion.js

@@ -7,6 +7,7 @@ import { generateMoABenchmarkReport } from '../moa-report.js'
 import { parseFileScores } from '../moa-workbench.js'
 import { recordMoaRunAsync, candidatesForHistory } from '../history.js'
 import { slotLabel } from '../moa-prompts.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
 
 export async function stagePromotion({
   synthesizedText,
@@ -31,6 +32,7 @@ export async function stagePromotion({
   referenceModels,
   historyFilePath,
   collectedCtx,
+  ctx = null,
 }) {
   const winningIndex = (multiJudgeResult?.consensus && multiJudgeResult?.winningCandidateIndex)
     ? multiJudgeResult.winningCandidateIndex
@@ -89,6 +91,13 @@ export async function stagePromotion({
     ? parseFileScores(synthesizedText, referenceOutputs)
     : null
 
+  emitEvent(ctx, MOA_EVENTS.JUDGE_VERDICT, {
+    runId,
+    winningIndex,
+    winningModel: winnerModel,
+    scores: fileScores || multiJudgeResult?.scores || null,
+  })
+
   try {
     await recordMoaRunAsync({
       id: runId, cwd, prompt: userPrompt, preset: preset?.name || 'default', isRefinement,
@@ -101,6 +110,15 @@ export async function stagePromotion({
     logger.warn('[dsh-moa] Failed to record run in history:', histErr)
   }
 
+  emitEvent(ctx, MOA_EVENTS.RUN_FINISH, {
+    runId,
+    durationMs,
+    totalTokens: usageSummary.totalTokens,
+    totalCostUsd: usageSummary.totalCostUsd,
+    promotedFiles,
+    winnerIndex: winningIndex,
+  })
+
   return {
     ok: true,
     payload: {

package/lib/pipeline/runner.js

@@ -11,6 +11,7 @@ import { stagePeerCritique } from './peer-critique.js'
 import { stageMultiJudge } from './multi-judge.js'
 import { stageSynthesis } from './synthesis.js'
 import { stagePromotion } from './promotion.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
 
 export async function runMoAPipeline({
   userPrompt,
@@ -22,12 +23,21 @@ export async function runMoAPipeline({
   testGateEnabled = null, testCommand = null, execFn = null,
   webServerPort = null, timeMachineEngine = null, timeMachineUrl = null,
   force = isTestEnvironment() ? true : false, checkpoint = true, checkpointFn = null, runId: customRunId = null,
+  ctx = null,
 }) {
   const runId = (customRunId && String(customRunId).trim()) || crypto.randomUUID()
   const promoteOpts = { webServerPort, timeMachineEngine, timeMachineUrl, force: Boolean(force), checkpoint, checkpointFn, signal }
   if (signal?.aborted) return { error: new Error('Turn aborted') }
   const startTime = Date.now()
 
+  emitEvent(ctx, MOA_EVENTS.RUN_START, {
+    runId,
+    prompt: userPrompt,
+    preset: preset?.name || preset?.id || 'default',
+    candidatesCount: Array.isArray(preset?.references) ? preset.references.length : 0,
+    timestamp: new Date(startTime).toISOString(),
+  })
+
   // Stage 1: Context & Configuration
   const ctxStage = await stageProjectContext({
     userPrompt, messages, preset, cwd, prices, maxTokens: preset?.max_tokens, startTime, onProgress,
@@ -54,10 +64,30 @@ export async function runMoAPipeline({
   })
   if (!candStage.ok) {
     if (candStage.abort) return { error: candStage.error }
+    emitEvent(ctx, MOA_EVENTS.RUN_FINISH, {
+      runId,
+      durationMs: Date.now() - startTime,
+      totalTokens: candStage.failurePayload?.usage?.totalTokens || 0,
+      totalCostUsd: candStage.failurePayload?.usage?.totalCostUsd || 0,
+      promotedFiles: [],
+      winnerIndex: 0,
+      error: candStage.failurePayload?.content,
+    })
     return candStage.failurePayload
   }
   const { referenceOutputs, successfulRefs } = candStage
 
+  for (const ref of referenceOutputs) {
+    emitEvent(ctx, MOA_EVENTS.CANDIDATE_COMPLETE, {
+      runId,
+      round: 1,
+      model: ref.model || ref.label,
+      success: Boolean(ref.ok),
+      durationMs: ref.durationMs || 0,
+      tokens: ref.usage?.totalTokens || 0,
+    })
+  }
+
   // Stage 3: Clarifying Questions Branch
   if (ctxStage.needsQuestions) {
     return await stageClarifyingQuestions({
@@ -75,7 +105,7 @@ export async function runMoAPipeline({
       allowCandidateOverride: ctxStage.allowCandidateOverride,
       promoteOpts, cwd, runId, signal, userPrompt, preset,
       isRefinement: ctxStage.isRefinement, historyFilePath, startTime,
-      collectedCtx: ctxStage.collectedCtx, liveCanvas,
+      collectedCtx: ctxStage.collectedCtx, liveCanvas, ctx,
     })
     if (!fastRes.ok) {
       if (fastRes.abort) return { error: fastRes.error }
@@ -102,6 +132,12 @@ export async function runMoAPipeline({
     options: { testGateEnabled, testCommand, execFn },
   })
   if (!peerRes.ok) return peerRes.abortPayload
+  if (ctxStage.isPeerCritiqueEnabled && peerRes.ok && peerRes.critiquesCount > 0) {
+    emitEvent(ctx, MOA_EVENTS.CRITIQUE_COMPLETE, {
+      runId,
+      critiquesCount: peerRes.critiquesCount,
+    })
+  }
 
   if (signal?.aborted) {
     await cleanMoaWorkspaces(cwd, { runId })
@@ -153,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,
+    historyFilePath, collectedCtx: ctxStage.collectedCtx, ctx,
   })
   if (!promRes.ok) {
     if (promRes.abort) return { error: promRes.error }

package/lib/routes/pipeline.js

@@ -73,6 +73,7 @@ export function registerPipelineRoutes(ctx, { live, callLlm, liveCanvas, webServ
             timeMachineUrl: payload.timeMachineUrl, force: false,
             checkpoint: true,
             runId: payload.runId,
+            ctx,
           })
 
           if (result?.skippedFiles > 0) {

package/package.json

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