@goodandready/dsh-moa 0.2.44 → 0.2.46

package/lib/file-workspace.js

@@ -254,6 +254,18 @@ export async function writeCandidateWorkspace(baseDir, candidateIndex, files = [
   }
 }
 
+export function isLoopbackUrl(urlStr) {
+  if (!urlStr || typeof urlStr !== 'string') return false
+  try {
+    const u = new URL(urlStr)
+    if (u.protocol !== 'http:' && u.protocol !== 'https:') return false
+    const h = u.hostname.replace(/^\[|\]$/g, '')
+    return h === 'localhost' || h === '127.0.0.1' || h === '::1' || /^127\.\d+\.\d+\.\d+$/.test(h)
+  } catch {
+    return false
+  }
+}
+
 /**
  * Best-effort integration with dsh-time-machine to create a shadow Git checkpoint
  * before candidate promotion overwrites files in the project workspace.
@@ -261,8 +273,7 @@ export async function writeCandidateWorkspace(baseDir, candidateIndex, files = [
 export async function createPrePromotionCheckpoint(baseDir, candidateTarget, options = {}) {
   if (!baseDir || options.checkpoint === false) return null
   if (typeof options.checkpointFn === 'function') {
-    const res = await bestEffort('custom checkpointFn', () => options.checkpointFn(baseDir, candidateTarget))
-    return res || null
+    return (await bestEffort('custom checkpointFn', () => options.checkpointFn(baseDir, candidateTarget))) || null
   }
 
   const label = options.checkpointLabel || `moa-pre-promotion: candidate-${candidateTarget}`
@@ -279,6 +290,11 @@ export async function createPrePromotionCheckpoint(baseDir, candidateTarget, opt
     return null
   }
 
+  if (options.timeMachineUrl && !isLoopbackUrl(options.timeMachineUrl)) {
+    logger.warn(`[dsh-moa] Blocked non-loopback timeMachineUrl: ${options.timeMachineUrl}`)
+    return null
+  }
+
   const endpoint = options.timeMachineUrl || `http://127.0.0.1:${port}/dsh-time-machine/create`
   const snap = await bestEffort('dsh-time-machine pre-promotion checkpoint', async () => {
     const res = await fetch(endpoint, {
@@ -286,6 +302,7 @@ export async function createPrePromotionCheckpoint(baseDir, candidateTarget, opt
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify({ label, cwd: baseDir }),
       signal: AbortSignal.timeout(options.timeoutMs ?? 1500),
+      redirect: 'error',
     })
     if (res.ok) {
       const data = await res.json()
@@ -327,9 +344,7 @@ async function doPromoteCandidateWorkspace(baseDir, winningIndex, options = { ke
   try {
     const entries = await getFilesRecursively(winningDir)
     if (entries.length === 0) {
-      if (!options.keepMoa) {
-        await bestEffort('clean empty candidate folder', () => fs.rm(cleanupTarget, { recursive: true, force: true }))
-      }
+      if (!options.keepMoa) await bestEffort('clean empty candidate folder', () => fs.rm(cleanupTarget, { recursive: true, force: true }))
       return []
     }
 
@@ -490,8 +505,7 @@ export async function readCandidateFiles(baseDir, candidateTarget, options = {})
   if (!baseDir || candidateTarget === undefined || candidateTarget === null) return []
   let targetDir
   try {
-    const resolved = resolveCandidateFolder(baseDir, candidateTarget, options)
-    targetDir = resolved.candidateDir
+    targetDir = resolveCandidateFolder(baseDir, candidateTarget, options).candidateDir
   } catch {
     return []
   }
@@ -508,9 +522,7 @@ export async function readCandidateFiles(baseDir, candidateTarget, options = {})
         const st = await fs.lstat(fullPath)
         if (st.isSymbolicLink()) {
           const realFile = await fs.realpath(fullPath)
-          if (realFile !== realTarget && !realFile.startsWith(realTarget + path.sep)) {
-            continue
-          }
+          if (realFile !== realTarget && !realFile.startsWith(realTarget + path.sep)) continue
         }
         const content = await fs.readFile(fullPath, 'utf8')
         result.push({ relativePath: rel, content, size: Buffer.byteLength(content, 'utf8') })
@@ -545,25 +557,22 @@ export function computeLineDiff(oldText = '', newText = '') {
     newEnd--
   }
 
-  const prefixItems = []
-  for (let k = 0; k < start; k++) prefixItems.push({ type: 'same', line: oldLines[k], oldNum: k + 1, newNum: k + 1 })
-
-  const suffixItems = []
+  const prefixItems = oldLines.slice(0, start).map((line, k) => ({ type: 'same', line, oldNum: k + 1, newNum: k + 1 }))
   const suffixLen = (n - 1) - oldEnd
-  for (let k = 0; k < suffixLen; k++) {
-    suffixItems.push({ type: 'same', line: oldLines[oldEnd + 1 + k], oldNum: oldEnd + 2 + k, newNum: newEnd + 2 + k })
-  }
+  const suffixItems = oldLines.slice(oldEnd + 1, oldEnd + 1 + suffixLen).map((line, k) => ({ type: 'same', line, oldNum: oldEnd + 2 + k, newNum: newEnd + 2 + k }))
 
   const subOld = oldLines.slice(start, oldEnd + 1)
   const subNew = newLines.slice(start, newEnd + 1)
   const subN = subOld.length, subM = subNew.length
-  const middleItems = []
-
-  if (subN === 0) for (let j = 0; j < subM; j++) middleItems.push({ type: 'added', line: subNew[j], newNum: start + j + 1 })
-  else if (subM === 0) for (let i = 0; i < subN; i++) middleItems.push({ type: 'removed', line: subOld[i], oldNum: start + i + 1 })
-  else if (subN > 2000 || subM > 2000) {
-    for (let i = 0; i < subN; i++) middleItems.push({ type: 'removed', line: subOld[i], oldNum: start + i + 1 })
-    for (let j = 0; j < subM; j++) middleItems.push({ type: 'added', line: subNew[j], newNum: start + j + 1 })
+  let middleItems
+  if (subN === 0) {
+    middleItems = subNew.map((line, j) => ({ type: 'added', line, newNum: start + j + 1 }))
+  } else if (subM === 0) {
+    middleItems = subOld.map((line, i) => ({ type: 'removed', line, oldNum: start + i + 1 }))
+  } else if (subN > 2000 || subM > 2000) {
+    middleItems = new Array(subN + subM)
+    for (let i = 0; i < subN; i++) middleItems[i] = { type: 'removed', line: subOld[i], oldNum: start + i + 1 }
+    for (let j = 0; j < subM; j++) middleItems[subN + j] = { type: 'added', line: subNew[j], newNum: start + j + 1 }
   } else {
     const dp = Array.from({ length: subN + 1 }, () => new Uint16Array(subM + 1))
     for (let i = 0; i < subN; i++) {
@@ -579,8 +588,7 @@ export function computeLineDiff(oldText = '', newText = '') {
         stack.push({ type: 'removed', line: subOld[--i], oldNum: start + i + 1 })
       }
     }
-    middleItems.push(...stack.reverse())
+    middleItems = stack.reverse()
   }
-
-  return [...prefixItems, ...middleItems, ...suffixItems]
+  return prefixItems.concat(middleItems, suffixItems)
 }

package/lib/history.js

@@ -125,6 +125,7 @@ function normalizeRunRecord(record) {
     durationMs: Number(record.durationMs || 0),
     benchmarkReport: record.benchmarkReport || null,
     consensus: record.consensus || null,
+    error: record.error ? String(record.error) : null,
   }
 }
 

package/lib/index.js

@@ -95,10 +95,21 @@ export function apply(ctx, config) {
 
   const saveConfig = async (newFields) => {
     const plain = plainConfig(newFields)
+    let persisted = false
     if (settingsService && typeof settingsService.replace === 'function') {
       await settingsService.replace(NS, plain)
+      persisted = true
     } else if (settingsService && typeof settingsService.update === 'function') {
       await settingsService.update(NS, plain)
+      persisted = true
+    }
+    if (config && typeof config === 'object') {
+      for (const [k, v] of Object.entries(plain)) {
+        if (config[k] && typeof config[k] === 'object' && typeof config[k].get === 'function') continue
+        const desc = Object.getOwnPropertyDescriptor(config, k)
+        if (desc && desc.get && !desc.set) continue
+        try { config[k] = v } catch {}
+      }
     }
     let liveCandidate = ctx.fiber?.config
     if (!liveCandidate && ('config' in ctx)) {
@@ -110,7 +121,7 @@ export function apply(ctx, config) {
       baseAtOverride[key] = JSON.stringify(currentLive[key])
     }
     localOverrides = { ...(localOverrides || {}), ...plain }
-    return live()
+    return { ok: true, persisted, ...live() }
   }
 
   const callLlm = createLlmCaller(ctx)

package/lib/moa-budget.js

@@ -29,6 +29,72 @@ export function estimateCandidateRunCost(slots = [], prices = {}, promptTokens =
   }
 }
 
+/**
+ * Estimates downstream synthesis costs for Round 2 and Judge panel.
+ */
+export function estimateDownstreamCost(aggregator, judgeModels = [], numCandidates = 1, prices = {}, expectedOutputTokens = 2048, promptTokens = 500, peerCritiqueEnabled = false) {
+  let downstream = 0
+  const aggInput = promptTokens + (expectedOutputTokens * numCandidates) + 200
+  const aggOutput = Math.min(expectedOutputTokens, 2048)
+
+  if (aggregator?.provider && aggregator?.model) {
+    const aggCost = estimateTokenCost(aggregator, { inputTokens: aggInput, outputTokens: aggOutput }, prices)
+    downstream += aggCost?.costUsd || 0
+  }
+  if (Array.isArray(judgeModels) && judgeModels.length > 0) {
+    for (const jm of judgeModels) {
+      if (jm?.provider && jm?.model) {
+        const jCost = estimateTokenCost(jm, { inputTokens: aggInput, outputTokens: aggOutput }, prices)
+        downstream += jCost?.costUsd || 0
+      }
+    }
+  }
+  return downstream
+}
+
+export function estimateRound2Cost(candidates = [], prices = {}, expectedOutputTokens = 2048, promptTokens = 500) {
+  let r2Total = 0
+  const numCandidates = candidates.length
+  if (numCandidates <= 1) return 0
+  // Each candidate reviews proposals from opponents (numCandidates - 1)
+  const r2Input = promptTokens + (expectedOutputTokens * (numCandidates - 1)) + 150
+  for (const c of candidates) {
+    const slot = c.slot || { provider: c.provider, model: c.model }
+    const cost = estimateTokenCost(slot, { inputTokens: r2Input, outputTokens: expectedOutputTokens }, prices)?.costUsd || 0
+    r2Total += cost
+  }
+  return r2Total
+}
+
+/**
+ * Phase-by-phase runtime budget check (#158).
+ * Checks if current spent + next phase estimate would exceed budget.
+ */
+export function checkPhaseBudget({
+  phaseName = '',
+  currentSpentUsd = 0,
+  nextPhaseCostUsd = 0,
+  maxBudgetUsd = 0,
+  action = 'abort',
+  enabled = true,
+}) {
+  if (!enabled || typeof maxBudgetUsd !== 'number' || maxBudgetUsd <= 0) {
+    return { allowed: true }
+  }
+  const projectedTotal = Number((currentSpentUsd + nextPhaseCostUsd).toFixed(6))
+  if (projectedTotal <= maxBudgetUsd) {
+    return { allowed: true, projectedTotal }
+  }
+  return {
+    allowed: false,
+    action,
+    currentSpentUsd,
+    projectedTotal,
+    maxBudgetUsd,
+    reason: `Projected cost ($${projectedTotal.toFixed(4)}) before ${phaseName} exceeds max budget ($${maxBudgetUsd.toFixed(4)}). Current spent: $${currentSpentUsd.toFixed(4)}.`,
+  }
+}
+
 /**
  * Applies budget guardrails before initiating parallel candidate execution.
  * Evaluates candidate runs, peer critique (Round 2) and downstream synthesis phases.
@@ -56,7 +122,7 @@ export function applyBudgetGuardrails({
     }
   }
 
-  // Calculate full input tokens from userPrompt length + messages context
+  // Calculate full input tokens from userPrompt length + messages context + system prompt overhead
   let contextChars = Number(promptLength) || 1000
   if (typeof projectContext === 'string' && projectContext.length > 0 && !String(promptLength).includes(String(projectContext.length))) {
     contextChars += projectContext.length
@@ -72,36 +138,27 @@ export function applyBudgetGuardrails({
       }
     }
   }
-  const promptTokens = Math.max(50, Math.round(contextChars / 4))
+  // System prompt and framing template overhead (~600 chars = ~150 tokens)
+  const promptTokens = Math.max(50, Math.round((contextChars + 600) / 4))
   const expectedOutputTokens = typeof maxTokens === 'number' && maxTokens > 0 ? maxTokens : 2048
 
   // Base candidate cost per slot (Round 1)
   const { totalEstimatedUsd, slotEstimates } = estimateCandidateRunCost(references, prices, promptTokens, expectedOutputTokens)
 
-  // Estimate cost for downstream phases (Aggregator / Judge panel)
+  // Calculate downstream cost with specific candidate count
   function calcDownstreamUsd(numCandidates) {
-    let downstream = 0
-    if (aggregator?.provider && aggregator?.model) {
-      const aggInput = promptTokens + expectedOutputTokens * numCandidates
-      const aggCost = estimateTokenCost(aggregator, { inputTokens: aggInput, outputTokens: expectedOutputTokens }, prices)
-      downstream += aggCost?.costUsd || 0
-    }
-    if (Array.isArray(judgeModels) && judgeModels.length > 0) {
-      for (const jm of judgeModels) {
-        if (jm?.provider && jm?.model) {
-          const jInput = promptTokens + expectedOutputTokens * numCandidates
-          const jCost = estimateTokenCost(jm, { inputTokens: jInput, outputTokens: expectedOutputTokens }, prices)
-          downstream += jCost?.costUsd || 0
-        }
-      }
-    }
-    return downstream
+    return estimateDownstreamCost(aggregator, judgeModels, numCandidates, prices, expectedOutputTokens, promptTokens, peerCritiqueEnabled)
   }
 
-  // Multiplier if peer critique (Round 2) is enabled: each candidate runs another turn with input from all peers
-  const roundMultiplier = peerCritiqueEnabled ? 2 : 1
+  // Calculate Round 2 (Peer Critique) cost if enabled
+  function calcRound2Usd(candidates) {
+    if (!peerCritiqueEnabled || candidates.length <= 1) return 0
+    return estimateRound2Cost(candidates, prices, expectedOutputTokens, promptTokens)
+  }
+
+  const r2Usd = calcRound2Usd(references)
   const downstreamUsd = calcDownstreamUsd(references.length)
-  const fullEstimatedUsd = Number(((totalEstimatedUsd * roundMultiplier) + downstreamUsd).toFixed(6))
+  const fullEstimatedUsd = Number((totalEstimatedUsd + r2Usd + downstreamUsd).toFixed(6))
 
   if (fullEstimatedUsd <= maxBudgetUsd) {
     return {
@@ -124,22 +181,25 @@ export function applyBudgetGuardrails({
   }
 
   // Action is 'trim': Sort by estimated cost ascending (cheapest first)
-  // Factor downstream synthesis cost into candidate selection (#158)
+  // Factor downstream synthesis cost and peer critique cost into candidate selection (#158)
   const sorted = [...slotEstimates].sort((a, b) => a.costUsd - b.costUsd)
   const kept = []
-  let cumulativeCandidateCost = 0
 
   for (const item of sorted) {
-    const candidateCost = item.costUsd * roundMultiplier
-    const nextDownstream = calcDownstreamUsd(kept.length + 1)
-    if (cumulativeCandidateCost + candidateCost + nextDownstream <= maxBudgetUsd) {
+    const candidatePool = [...kept, item.slot]
+    const candR1 = candidatePool.reduce((acc, c) => {
+      const e = slotEstimates.find((s) => s.slot === c)
+      return acc + (e?.costUsd || 0)
+    }, 0)
+    const candR2 = calcRound2Usd(candidatePool)
+    const nextDownstream = calcDownstreamUsd(candidatePool.length)
+    if (candR1 + candR2 + nextDownstream <= maxBudgetUsd) {
       kept.push(item.slot)
-      cumulativeCandidateCost += candidateCost
     }
   }
 
   if (kept.length === 0) {
-    const minCandidateCost = (sorted[0]?.costUsd || 0) * roundMultiplier
+    const minCandidateCost = sorted[0]?.costUsd || 0
     const minTotal = minCandidateCost + calcDownstreamUsd(1)
     return {
       allowed: false,
@@ -153,7 +213,13 @@ export function applyBudgetGuardrails({
     }
   }
 
-  const finalEstimatedUsd = Number((cumulativeCandidateCost + calcDownstreamUsd(kept.length)).toFixed(6))
+  const finalR1 = kept.reduce((acc, c) => {
+    const e = slotEstimates.find((s) => s.slot === c)
+    return acc + (e?.costUsd || 0)
+  }, 0)
+  const finalR2 = calcRound2Usd(kept)
+  const finalEstimatedUsd = Number((finalR1 + finalR2 + calcDownstreamUsd(kept.length)).toFixed(6))
+
   return {
     allowed: true,
     references: kept,
@@ -165,3 +231,41 @@ export function applyBudgetGuardrails({
     reason: `Trimmed candidate pool from ${references.length} to ${kept.length} models to stay within budget ($${maxBudgetUsd.toFixed(4)}).`,
   }
 }
+
+/**
+ * Constructs a structured budget abort failure payload (#158).
+ */
+export function createBudgetAbortPayload({
+  reason,
+  primaryJudge,
+  referenceOutputs = [],
+  currentSpentUsd = 0,
+  preset = {},
+  isRefinement = false,
+  isFastMode = false,
+  collectedCtx = {},
+  startTime = Date.now(),
+}) {
+  const aggLabel = (primaryJudge?.provider && primaryJudge?.model) ? `${primaryJudge.provider}:${primaryJudge.model}` : "none";
+  return {
+    kind: "failure",
+    content: `🛑 Budget Guardrail Abort: ${reason}`,
+    aggregator: aggLabel,
+    references: referenceOutputs,
+    presetName: preset?.name || "default",
+    isRefinement,
+    isFastMode,
+    winningIndex: 0,
+    winnerModel: "none",
+    promotedFiles: [],
+    usage: {
+      totalTokens: referenceOutputs.reduce((acc, r) => acc + (r.usage?.totalTokens || 0), 0),
+      totalCostUsd: Number(currentSpentUsd.toFixed(5)),
+      candidates: referenceOutputs.map((r) => ({ label: r.label, usage: r.usage, costUsd: r.costUsd })),
+      aggregator: { inputTokens: 0, outputTokens: 0, totalTokens: 0, costUsd: 0 },
+    },
+    skippedFiles: collectedCtx?.skippedFiles || 0,
+    skippedList: collectedCtx?.skippedList || [],
+    durationMs: Date.now() - startTime,
+  };
+}