@goodandready/dsh-moa 0.2.63 → 0.2.64

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

@@ -22,6 +22,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 +135,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
@@ -284,6 +304,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 +358,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,

package/lib/moa-candidates.js

@@ -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,
         }
 

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.64",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",