@goodandready/dsh-moa 0.2.72 → 0.2.73

package/README.md

@@ -327,6 +327,8 @@ dsh-moa:
 | `/dsh-moa/run` | `POST` | Runs the full MoA pipeline over HTTP (400 when `enabled: false`) |
 | `/dsh-moa/diff` | `GET` | Computes line-by-line diff between candidate runs or curator synthesis |
 | `/dsh-moa/promote` | `POST` | Manually promotes candidate workspace files to project root |
+| `/dsh-moa/cache` | `GET` | Returns semantic cache stats, hit/miss counters, and saved token metrics |
+| `/dsh-moa/cache` | `POST` | Purges cached candidate generations with optional olderThanMs filter |
 | `/api/dsh-moa/update` | `POST` | One-click plugin updater from npm with safe-write verification |
 
 ---

package/README.ru.md

@@ -327,6 +327,8 @@ dsh-moa:
 | `/dsh-moa/run` | `POST` | Запускает полный пайплайн MoA по HTTP (400 при `enabled: false`) |
 | `/dsh-moa/diff` | `GET` | Вычисляет построчный diff между решениями кандидатов или синтезом куратора |
 | `/dsh-moa/promote` | `POST` | Ручной промоушн файлов кандидата в корень проекта с созданием снимка |
+| `/dsh-moa/cache` | `GET` | Статистика семантического кэша, число попаданий и сэкономленные токены |
+| `/dsh-moa/cache` | `POST` | Очистка семантического кэша с опциональным фильтром olderThanMs |
 | `/api/dsh-moa/update` | `POST` | One-click обновление плагина из npm с проверкой безопасности источника |
 
 ---

package/README.zh.md

@@ -257,6 +257,8 @@ dsh-moa:
 | `/dsh-moa/run` | `POST` | 通过 HTTP 运行完整 MoA 管线（`enabled: false` 时返回 400） |
 | `/dsh-moa/diff` | `GET` | 计算候选运行结果或综合输出的行级别差异（支持按 runId 解析工作区） |
 | `/dsh-moa/promote` | `POST` | 手动将候选工作区文件提升到项目根目录（带时间机器快照） |
+| `/dsh-moa/cache` | `GET` | 返回语义缓存统计信息、命中次数与节省 Token 指标 |
+| `/dsh-moa/cache` | `POST` | 清除语义缓存条目，支持 olderThanMs 过滤 |
 | `/api/dsh-moa/update` | `POST` | 从 npm 一键更新插件，带安全写入源校验 |
 
 ---

package/lib/client.js

@@ -167,6 +167,12 @@ window.__ModuleLoader__.load({
       "config.smart_routing_desc": "Analyze task complexity and automatically select the optimal preset.",
       "config.smart_routing_model": "Routing Model:",
       // Multi-Turn Context
+      "aggregator.context_pruning_title": "\u2702\uFE0F Cross-Candidate Context Pruning (Diff-Only Judge Context)",
+      "aggregator.context_pruning_desc": "Replaces unchanged base project files with compact unified diffs (---/+++ hunks) in the Judge prompt, slashing prompt tokens by up to 85%.",
+      "aggregator.context_pruning_lines": "Context lines around changes:",
+      "aggregator.semantic_cache_title": "\u26A1 Semantic Caching for Candidate Generations",
+      "aggregator.semantic_cache_desc": "Persists intermediate candidate outputs locally by deterministic SHA-256 fingerprint, eliminating duplicate API costs on retry or repeat requests.",
+      "aggregator.semantic_cache_ttl": "Cache TTL (hours):",
       "aggregator.multi_turn_title": "Multi-Turn Context & Diff Pruning",
       "aggregator.multi_turn_desc": "Retain conversation context across turns while pruning duplicate code blocks.",
       // UI States & Errors
@@ -365,6 +371,12 @@ window.__ModuleLoader__.load({
       "config.smart_routing_desc": "\u5206\u6790\u4EFB\u52A1\u590D\u6742\u5EA6\u5E76\u81EA\u52A8\u5339\u914D\u6700\u4F73\u9884\u8BBE\u3002",
       "config.smart_routing_model": "\u5206\u6D41\u51B3\u7B56\u6A21\u578B\uFF1A",
       // Multi-Turn Context
+      "aggregator.context_pruning_title": "\u2702\uFE0F \u5019\u9009\u8DE8\u6A21\u578B\u4E0A\u4E0B\u6587\u7CBE\u7B80 (Judge \u4EC5\u5DEE\u5F02\u8865\u4E01)",
+      "aggregator.context_pruning_desc": "\u5728 Judge \u63D0\u793A\u8BCD\u4E2D\u5C06\u672A\u4FEE\u6539\u7684\u57FA\u7840\u9879\u76EE\u6587\u4EF6\u66FF\u6362\u4E3A\u7D27\u51D1\u7684\u7EDF\u4E00\u5DEE\u5F02\u5757 (---/+++)\uFF0C\u5728\u5927\u6587\u4EF6\u573A\u666F\u4E0B\u524A\u51CF\u9AD8\u8FBE 85% \u7684\u63D0\u793A\u8BCD Token\u3002",
+      "aggregator.context_pruning_lines": "\u5DEE\u5F02\u4E0A\u4E0B\u6587\u884C\u6570:",
+      "aggregator.semantic_cache_title": "\u26A1 \u5019\u9009\u751F\u6210\u8BED\u4E49\u7F13\u5B58",
+      "aggregator.semantic_cache_desc": "\u901A\u8FC7\u786E\u5B9A\u7684 SHA-256 \u6307\u7EB9\u5728\u672C\u5730\u6301\u4E45\u5316\u5019\u9009\u6A21\u578B\u4E2D\u95F4\u8F93\u51FA\uFF0C\u5728\u91CD\u8BD5\u6216\u91CD\u590D\u8FED\u4EE3\u4E2D\u6D88\u9664\u5197\u4F59 API \u8D39\u7528\u3002",
+      "aggregator.semantic_cache_ttl": "\u7F13\u5B58\u6709\u6548\u671F (\u5C0F\u65F6):",
       "aggregator.multi_turn_title": "\u591A\u8F6E\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u4E0E\u5DEE\u5F02\u526A\u679D",
       "aggregator.multi_turn_desc": "\u8DE8\u8F6E\u6B21\u4FDD\u7559\u5BF9\u8BDD\u4E0A\u4E0B\u6587\u5E76\u526A\u679D\u91CD\u590D\u4EE3\u7801\u5757\u3002",
       // UI States & Errors
@@ -2378,6 +2390,43 @@ window.__ModuleLoader__.load({
                   t("aggregator.multi_turn_desc") || "Retain conversation context across turns while pruning duplicate code blocks."
                 )
               ),
+              /* Context Pruning (#305) & Semantic Caching (#318) */
+              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: currentPreset.context_pruning_enabled !== false,
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, context_pruning_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.context_pruning_title") || "\u2702\uFE0F Cross-Candidate Context Pruning (Diff-Only Judge Context)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.context_pruning_desc") || "Replaces unchanged base project files with compact unified diffs (---/+++ hunks) in the Judge prompt, slashing prompt tokens by up to 85%."
+                ),
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500, marginTop: 4 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.semantic_cache_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, semantic_cache_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.semantic_cache_title") || "\u26A1 Semantic Caching for Candidate Generations"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.semantic_cache_desc") || "Persists intermediate candidate outputs locally by deterministic SHA-256 fingerprint, eliminating duplicate API costs on retry or repeat requests."
+                )
+              ),
               /* Fallback Judges Chain */
               React.createElement(
                 "div",

package/lib/events.js

@@ -9,6 +9,8 @@ export const MOA_EVENTS = {
   EARLY_CONSENSUS: 'moa/early-consensus',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
+  CONTEXT_PRUNING: 'moa/context-pruning',
+  CACHE_HIT: 'moa/cache-hit',
   RUN_FINISH: 'moa/run-finish',
 }
 
@@ -30,4 +32,4 @@ export function emitEvent(ctx, eventName, payload) {
     /* best-effort event dispatch: listener exceptions must never abort pipeline */
   }
 }
-
+

package/lib/moa-schema.js

@@ -79,6 +79,10 @@ export const PresetSchema = z.object({
   local_preflight_check: z.boolean().default(true),
   early_exit_consensus_enabled: z.boolean().default(false),
   early_exit_threshold: z.number().default(0.95),
+  context_pruning_enabled: z.boolean().default(true),
+  context_pruning_diff_lines: z.number().default(5),
+  semantic_cache_enabled: z.boolean().default(false),
+  semantic_cache_ttl_hours: z.number().default(168),
 })
 
 export const Config = z.object({
@@ -104,6 +108,10 @@ export const Config = z.object({
   local_preflight_check: z.boolean().default(true).volatile(),
   early_exit_consensus_enabled: z.boolean().default(false).volatile(),
   early_exit_threshold: z.number().default(0.95).volatile(),
+  context_pruning_enabled: z.boolean().default(true).volatile(),
+  context_pruning_diff_lines: z.number().default(5).volatile(),
+  semantic_cache_enabled: z.boolean().default(false).volatile(),
+  semantic_cache_ttl_hours: z.number().default(168).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([
@@ -120,6 +128,10 @@ export const Config = z.object({
       aggregator_temperature: 0.4,
       max_tokens: 4096,
       judge_criteria: '',
+      context_pruning_enabled: true,
+      context_pruning_diff_lines: 5,
+      semantic_cache_enabled: false,
+      semantic_cache_ttl_hours: 168,
     },
     {
       name: 'fast',
@@ -133,6 +145,10 @@ export const Config = z.object({
       aggregator_temperature: 0.2,
       max_tokens: 4096,
       judge_criteria: '',
+      context_pruning_enabled: true,
+      context_pruning_diff_lines: 5,
+      semantic_cache_enabled: false,
+      semantic_cache_ttl_hours: 168,
     },
     {
       name: 'deep-reasoning',
@@ -165,4 +181,4 @@ export function plainConfig(value) {
   }
   return value
 }
-
+

package/lib/pipeline/candidates.js

@@ -1,3 +1,4 @@
+import { createCachingCallLlm } from './semantic-cache.js'
 import { runSpeculativeMoa } from '../moa-speculative.js'
 import { runAdversarialTddLoop } from '../moa-adversarial-tdd.js'
 import { assignAdaptivePersonas } from '../moa-adaptive-personas.js'
@@ -33,7 +34,19 @@ export async function stageCandidateRound1({
   testGateEnabled,
   testCommand,
   execFn,
+  semanticCacheEnabled,
+  semanticCacheTtlHours,
+  ctx = null,
 }) {
+  const isCacheEnabled = Boolean(preset?.semantic_cache_enabled || semanticCacheEnabled)
+  const effectiveCallLlm = isCacheEnabled
+    ? createCachingCallLlm(callLlm, {
+        enabled: true,
+        ttlMs: (semanticCacheTtlHours || preset?.semantic_cache_ttl_hours || 168) * 60 * 60 * 1000,
+        cwd,
+        ctx,
+      })
+    : callLlm
   const lastMsgText = enrichedMessages[enrichedMessages.length - 1]?.content || ''
   const adaptiveRefs = preset?.adaptive_personas_enabled
     ? assignAdaptivePersonas(effectiveReferences, typeof lastMsgText === 'string' ? lastMsgText : '').references
@@ -52,7 +65,7 @@ export async function stageCandidateRound1({
         prices,
         signal,
       },
-      callLlm,
+      effectiveCallLlm,
       onProgress
     )
     if (!specRes.fallbackToStandard && Array.isArray(specRes.referenceOutputs)) {
@@ -62,7 +75,7 @@ export async function stageCandidateRound1({
 
   if (!referenceOutputs) {
     referenceOutputs = preset?.subagent_swarm_enabled
-    ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, callLlm, onProgress)
+    ? await runSubagentSwarm(adaptiveRefs, enrichedMessages, { temperature: refTemp, maxTokens, signal, cwd, runId }, effectiveCallLlm, onProgress)
     : await runReferencesParallel(
     adaptiveRefs,
     enrichedMessages,
@@ -80,7 +93,7 @@ export async function stageCandidateRound1({
       maxRetries: candidateRetries,
       signal,
     },
-    callLlm,
+    effectiveCallLlm,
     onProgress
   )
   }

package/lib/pipeline/context-pruner.js

@@ -0,0 +1,323 @@
+/**
+ * Cross-Candidate Unchanged Base Context Pruning (#305)
+ *
+ * Replaces large, mostly-unchanged candidate file blocks with compact unified diffs
+ * containing only modified hunks and a configurable number of context lines.
+ * This drastically cuts Judge prompt token overhead (often by 70-85%) on large files
+ * while preserving full context for winner promotion.
+ */
+
+import { computeLineDiff } from '../workspace/diff.js'
+import { isSafeRelativePath } from '../workspace/security.js'
+
+/**
+ * Extracts code blocks along with their raw Markdown text from candidate output.
+ *
+ * @param {string} text
+ * @returns {Array<{ relativePath: string, content: string, rawBlock: string }>}
+ */
+export function extractCandidateFileBlocks(text) {
+  if (!text || typeof text !== 'string') return []
+  const blocks = []
+  const seenPaths = new Set()
+
+  const patterns = [
+    /```[\w-]*\s+(?:file|path|filepath)=["']?([^\s"'\n\r]+)["']?[\r\n]+([\s\S]*?)```/gi,
+    /(?:\/\/|#|<!--)\s*(?:File|Path):\s*([^\s\n\r>]+)(?:\s*-->)?[\r\n]+```[\w-]*[\r\n]+([\s\S]*?)```/gi,
+    /#{1,4}\s+(?:File|Path):\s*([^\s\n\r]+)[\r\n]+```[\w-]*[\r\n]+([\s\S]*?)```/gi,
+    /```[\w-]*[\r\n]+(?:\/\/|#|<!--)\s*(?:File|Path):\s*([^\s\n\r>]+)(?:\s*-->)?[\r\n]+([\s\S]*?)```/gi,
+  ]
+
+  for (const regex of patterns) {
+    let match
+    while ((match = regex.exec(text)) !== null) {
+      const rawPath = match[1].trim()
+      if (rawPath && isSafeRelativePath(rawPath) && !seenPaths.has(rawPath)) {
+        seenPaths.add(rawPath)
+        blocks.push({
+          relativePath: rawPath,
+          content: match[2].trimEnd() + '\n',
+          rawBlock: match[0],
+        })
+      }
+    }
+  }
+
+  return blocks
+}
+
+
+/**
+ * Generates unified diff hunks from line diff items with a specified context window.
+ *
+ * @param {string} oldText - Original baseline file content
+ * @param {string} newText - Candidate's proposed file content
+ * @param {object} [options]
+ * @param {number} [options.contextLines=5] - Unchanged lines before and after changes
+ * @param {string} [options.filePath='file'] - Relative file path for header
+ * @returns {string} Standard unified diff representation
+ */
+export function generateUnifiedDiff(oldText = '', newText = '', options = {}) {
+  const { contextLines = 5, filePath = 'file' } = options
+  const trimmedOld = String(oldText || '').replace(/[\r\n]+$/, '')
+  const trimmedNew = String(newText || '').replace(/[\r\n]+$/, '')
+  if (trimmedOld === trimmedNew) return ''
+
+  const diffItems = computeLineDiff(trimmedOld, trimmedNew)
+  if (!diffItems || diffItems.length === 0) return ''
+
+  // Group diff items into hunks with contextLines
+  const changeIndices = []
+  for (let i = 0; i < diffItems.length; i++) {
+    if (diffItems[i].type !== 'same') {
+      changeIndices.push(i)
+    }
+  }
+
+  if (changeIndices.length === 0) return ''
+
+  // Cluster change ranges that are closer than 2 * contextLines
+  const clusters = []
+  let currentCluster = {
+    start: Math.max(0, changeIndices[0] - contextLines),
+    end: Math.min(diffItems.length - 1, changeIndices[0] + contextLines),
+  }
+
+  for (let k = 1; k < changeIndices.length; k++) {
+    const idx = changeIndices[k]
+    const nextStart = Math.max(0, idx - contextLines)
+    const nextEnd = Math.min(diffItems.length - 1, idx + contextLines)
+
+    if (nextStart <= currentCluster.end + 1) {
+      currentCluster.end = Math.max(currentCluster.end, nextEnd)
+    } else {
+      clusters.push(currentCluster)
+      currentCluster = { start: nextStart, end: nextEnd }
+    }
+  }
+  clusters.push(currentCluster)
+
+  const hunkOutputs = []
+  for (const cluster of clusters) {
+    const slice = diffItems.slice(cluster.start, cluster.end + 1)
+    let oldStart = null
+    let newStart = null
+    let oldCount = 0
+    let newCount = 0
+    const hunkLines = []
+
+    for (const item of slice) {
+      if (item.type === 'same') {
+        if (oldStart === null && item.oldNum !== undefined) oldStart = item.oldNum
+        if (newStart === null && item.newNum !== undefined) newStart = item.newNum
+        oldCount++
+        newCount++
+        hunkLines.push(` ${item.line}`)
+      } else if (item.type === 'removed') {
+        if (oldStart === null && item.oldNum !== undefined) oldStart = item.oldNum
+        oldCount++
+        hunkLines.push(`-${item.line}`)
+      } else if (item.type === 'added') {
+        if (newStart === null && item.newNum !== undefined) newStart = item.newNum
+        newCount++
+        hunkLines.push(`+${item.line}`)
+      }
+    }
+
+    const header = `@@ -${oldStart || 1},${oldCount} +${newStart || 1},${newCount} @@`
+    hunkOutputs.push([header, ...hunkLines].join('\n'))
+  }
+
+  const prefix = `--- a/${filePath}\n+++ b/${filePath}`
+  return `${prefix}\n${hunkOutputs.join('\n')}`
+}
+
+/**
+ * Checks whether a candidate's file output qualifies for context pruning.
+ *
+ * @param {string} originalText - Original file content
+ * @param {string} candidateText - Proposed file content
+ * @param {object} [options]
+ * @param {number} [options.minLines=25] - Minimum file length to consider pruning
+ * @param {number} [options.maxChangeRatio=0.65] - Maximum proportion of changed lines
+ * @returns {boolean}
+ */
+export function shouldPruneFile(originalText, candidateText, options = {}) {
+  const { minLines = 25, maxChangeRatio = 0.65 } = options
+  if (typeof originalText !== 'string' || typeof candidateText !== 'string') return false
+  const trimmedOld = originalText.replace(/[\r\n]+$/, '')
+  const trimmedNew = candidateText.replace(/[\r\n]+$/, '')
+  if (trimmedOld === trimmedNew) return false
+
+  const oldLines = trimmedOld.split(/\r?\n/)
+  if (oldLines.length < minLines) return false
+
+  const diffItems = computeLineDiff(trimmedOld, trimmedNew)
+  let changed = 0
+  for (const item of diffItems) {
+    if (item.type !== 'same') changed++
+  }
+
+  const ratio = changed / Math.max(1, diffItems.length)
+  return ratio > 0 && ratio <= maxChangeRatio
+}
+
+/**
+ * Prunes unmodified base context from a single candidate's Markdown output.
+ *
+ * @param {string} candidateText - Raw candidate text containing file blocks
+ * @param {Map<string, string>|Record<string, string>} baseFiles - Map of relative paths to baseline file contents
+ * @param {object} [options]
+ * @param {number} [options.contextLines=5]
+ * @param {number} [options.minLines=25]
+ * @returns {{ text: string, prunedFiles: string[], savedChars: number, originalChars: number }}
+ */
+export function pruneCandidateOutput(candidateText = '', baseFiles = {}, options = {}) {
+  if (typeof candidateText !== 'string' || !candidateText.trim()) {
+    return { text: candidateText, prunedFiles: [], savedChars: 0, originalChars: 0 }
+  }
+
+  const { contextLines = 5, minLines = 25 } = options
+  const baseMap = baseFiles instanceof Map
+    ? baseFiles
+    : new Map(Object.entries(baseFiles || {}))
+
+  if (baseMap.size === 0) {
+    return { text: candidateText, prunedFiles: [], savedChars: 0, originalChars: 0 }
+  }
+
+  const fileBlocks = extractCandidateFileBlocks(candidateText)
+  if (!Array.isArray(fileBlocks) || fileBlocks.length === 0) {
+    return { text: candidateText, prunedFiles: [], savedChars: 0, originalChars: 0 }
+  }
+
+  let prunedText = candidateText
+  const prunedFiles = []
+  let savedChars = 0
+
+  for (const block of fileBlocks) {
+    const relPath = block.relativePath || block.path
+    if (!relPath || !baseMap.has(relPath)) continue
+
+    const baseContent = baseMap.get(relPath)
+    if (!shouldPruneFile(baseContent, block.content, { minLines })) continue
+
+    const unifiedDiff = generateUnifiedDiff(baseContent, block.content, {
+      contextLines,
+      filePath: relPath,
+    })
+
+    if (!unifiedDiff) continue
+
+    const originalBlockText = block.rawBlock || block.block || `\`\`\`${block.language || ''}\n${block.content}\n\`\`\``
+    const replacementBlock = `\`\`\`diff\n// Unified diff patch for ${relPath} (context pruned)\n${unifiedDiff}\n\`\`\``
+
+    if (replacementBlock.length < originalBlockText.length) {
+      prunedText = prunedText.replace(originalBlockText, replacementBlock)
+      savedChars += (originalBlockText.length - replacementBlock.length)
+      prunedFiles.push(relPath)
+    }
+  }
+
+  return {
+    text: prunedText,
+    prunedFiles,
+    savedChars,
+    originalChars: candidateText.length,
+  }
+}
+
+/**
+ * Prunes unmodified context across all successful candidate outputs.
+ *
+ * @param {Array<object>} candidates - List of candidate response objects
+ * @param {Array<object>|Map<string, string>|Record<string, string>} projectFiles - Project context files
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=true]
+ * @param {number} [options.contextLines=5]
+ * @returns {{ candidates: Array<object>, totalSavedChars: number, totalSavedTokens: number, prunedFiles: string[], isPruned: boolean }}
+ */
+export function pruneCandidateEnsemble(candidates = [], projectFiles = [], options = {}) {
+  const { enabled = true, contextLines = 5, minLines = 25 } = options
+  if (!enabled || !Array.isArray(candidates) || candidates.length === 0) {
+    return {
+      candidates,
+      totalSavedChars: 0,
+      totalSavedTokens: 0,
+      prunedFiles: [],
+      isPruned: false,
+    }
+  }
+
+  // Build base files map
+  const baseMap = new Map()
+  if (Array.isArray(projectFiles)) {
+    for (const f of projectFiles) {
+      if (f && f.path && typeof f.content === 'string') {
+        baseMap.set(f.path, f.content)
+      } else if (f && f.relativePath && typeof f.content === 'string') {
+        baseMap.set(f.relativePath, f.content)
+      }
+    }
+  } else if (projectFiles instanceof Map) {
+    for (const [k, v] of projectFiles.entries()) baseMap.set(k, v)
+  } else if (projectFiles && typeof projectFiles === 'object') {
+    for (const [k, v] of Object.entries(projectFiles)) baseMap.set(k, v)
+  }
+
+  if (baseMap.size === 0) {
+    return {
+      candidates,
+      totalSavedChars: 0,
+      totalSavedTokens: 0,
+      prunedFiles: [],
+      isPruned: false,
+    }
+  }
+
+  let totalSavedChars = 0
+  const allPrunedFiles = new Set()
+
+  const prunedCandidates = candidates.map((cand) => {
+    if (!cand || typeof cand.text !== 'string') return cand
+    const result = pruneCandidateOutput(cand.text, baseMap, { contextLines, minLines })
+    if (result.savedChars > 0) {
+      totalSavedChars += result.savedChars
+      result.prunedFiles.forEach((f) => allPrunedFiles.add(f))
+      return {
+        ...cand,
+        text: result.text,
+        prunedStats: {
+          savedChars: result.savedChars,
+          prunedFiles: result.prunedFiles,
+        },
+      }
+    }
+    return cand
+  })
+
+  const totalSavedTokens = Math.round(totalSavedChars / 4)
+  return {
+    candidates: prunedCandidates,
+    totalSavedChars,
+    totalSavedTokens,
+    prunedFiles: Array.from(allPrunedFiles),
+    isPruned: totalSavedChars > 0,
+  }
+}
+
+/**
+ * Emits a structured instruction directive for the Judge when context pruning was applied.
+ *
+ * @param {Array<string>} [prunedFiles=[]] - List of pruned file paths
+ * @param {number} [savedTokens=0] - Estimated token count saved
+ * @returns {string}
+ */
+export function formatPruningDirective(prunedFiles = [], savedTokens = 0) {
+  if (!Array.isArray(prunedFiles) || prunedFiles.length === 0) return ''
+  const fileList = prunedFiles.map((f) => `\`${f}\``).join(', ')
+  return `### Context Pruning Notice
+To minimize token bloat and accelerate evaluation, large baseline files with localized modifications (${fileList}) have been pruned into standard unified diff patches (---/+++ with context hunks).
+Evaluate the precision, correctness, and edge-case safety of the added and removed lines without penalizing candidates for using diff format.`
+}
+

package/lib/pipeline/context.js

@@ -41,6 +41,10 @@ export async function stageProjectContext({
   const localPreflightCheck = preset?.local_preflight_check !== false
   const earlyExitConsensusEnabled = Boolean(preset?.early_exit_consensus_enabled)
   const earlyExitThreshold = typeof preset?.early_exit_threshold === 'number' ? preset.early_exit_threshold : 0.95
+  const contextPruningEnabled = preset?.context_pruning_enabled !== false
+  const contextPruningDiffLines = typeof preset?.context_pruning_diff_lines === 'number' ? preset.context_pruning_diff_lines : 5
+  const semanticCacheEnabled = Boolean(preset?.semantic_cache_enabled)
+  const semanticCacheTtlHours = typeof preset?.semantic_cache_ttl_hours === 'number' ? preset.semantic_cache_ttl_hours : 168
 
   const collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
@@ -127,6 +131,8 @@ export async function stageProjectContext({
     effectiveReferences, quotaSubstitutions, priorTurnBaseline, candidateSystemPrompt,
     needsQuestions, enrichedMessages,
     localPreflightCheck, earlyExitConsensusEnabled, earlyExitThreshold,
+    contextPruningEnabled, contextPruningDiffLines,
+    semanticCacheEnabled, semanticCacheTtlHours,
   }
 }
-
+

package/lib/pipeline/runner.js

@@ -1,3 +1,4 @@
+import { pruneCandidateEnsemble, formatPruningDirective } from './context-pruner.js'
 import { buildAstCompositeMergeDirective } from '../moa-ast-merge.js'
 import { runVisualMoaConsensus } from '../moa-visual-consensus.js'
 import crypto from 'node:crypto'
@@ -65,6 +66,9 @@ export async function runMoAPipeline({
     isFastMode: ctxStage.isFastMode,
     collectedCtx: ctxStage.collectedCtx,
     testGateEnabled, testCommand, execFn,
+    semanticCacheEnabled: ctxStage.semanticCacheEnabled,
+    semanticCacheTtlHours: ctxStage.semanticCacheTtlHours,
+    ctx,
   })
   if (!candStage.ok) {
     if (candStage.abort) return { error: candStage.error }
@@ -218,12 +222,44 @@ export async function runMoAPipeline({
   const rawFileDirective = (preset?.interactive_workbench_enabled)
     ? formatFileScoresDirective()
     : null
-  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective].filter(Boolean).join("\n\n") || null
+
+  // Pre-Judge Stage 6.8: Cross-Candidate Unchanged Base Context Pruning (#305)
+  let synthCandidateRefs = syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs
+  let synthReferenceOutputs = referenceOutputs
+  let pruningDirective = null
+  if (ctxStage.contextPruningEnabled && ctxStage.collectedCtx?.files?.length > 0) {
+    const pruneRes = pruneCandidateEnsemble(synthCandidateRefs, ctxStage.collectedCtx.files, {
+      enabled: true,
+      contextLines: ctxStage.contextPruningDiffLines,
+    })
+    if (pruneRes.isPruned) {
+      synthCandidateRefs = pruneRes.candidates
+      const prunedByLabel = new Map(synthCandidateRefs.map((c) => [c.label, c.text]))
+      synthReferenceOutputs = referenceOutputs.map((r) => {
+        if (prunedByLabel.has(r.label)) {
+          return { ...r, text: prunedByLabel.get(r.label) }
+        }
+        return r
+      })
+      pruningDirective = formatPruningDirective(pruneRes.prunedFiles, pruneRes.totalSavedTokens)
+      emitEvent(ctx, MOA_EVENTS.CONTEXT_PRUNING, {
+        runId,
+        savedTokens: pruneRes.totalSavedTokens,
+        prunedFiles: pruneRes.prunedFiles,
+      })
+      if (typeof onProgress === 'function') {
+        onProgress(`✂️ *Context Pruning: Reduced ~${pruneRes.totalSavedTokens} prompt tokens across ${pruneRes.prunedFiles.length} file block(s)*\n`)
+      }
+    }
+  }
+
+  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, pruningDirective].filter(Boolean).join("\n\n") || null
 
   // Stage 7: Synthesis Phase
   const synthRes = await stageSynthesis({
-    userPrompt, referenceOutputs,
-    successfulRefs: syntaxResult.validCandidates.length > 0 ? syntaxResult.validCandidates : successfulRefs,
+    userPrompt,
+    referenceOutputs: synthReferenceOutputs,
+    successfulRefs: synthCandidateRefs,
     judgeCriteria: ctxStage.judgeCriteria,
     isCuratorSynthesis: ctxStage.isCuratorSynthesis, isBlindEvaluation: ctxStage.isBlindEvaluation,
     priorTurnBaseline: ctxStage.priorTurnBaseline, compositeMergeDirective, fileScoringDirective,
@@ -260,4 +296,4 @@ export async function runMoAPipeline({
   }
   return promRes.payload
 }
-
+

package/lib/pipeline/semantic-cache.js

@@ -0,0 +1,348 @@
+import { bestEffort } from '../best-effort.js'
+import { emitEvent, MOA_EVENTS } from '../events.js'
+/**
+ * Semantic Caching for Intermediate Candidate Generations (#318)
+ *
+ * Persists and resolves candidate generations and similarity fingerprints locally
+ * to eliminate duplicate API costs during iterative development, questionnaire retries,
+ * or recurring benchmark runs.
+ */
+
+import crypto from 'node:crypto'
+import fs from 'node:fs'
+import path from 'node:path'
+
+// Runtime metrics tracking
+let _runtimeHits = 0
+let _runtimeMisses = 0
+let _runtimeSavedTokens = 0
+let _runtimeSavedCostUsd = 0
+
+/**
+ * Resets runtime cache hit/miss statistics (useful for tests).
+ */
+export function resetRuntimeCacheStats() {
+  _runtimeHits = 0
+  _runtimeMisses = 0
+  _runtimeSavedTokens = 0
+  _runtimeSavedCostUsd = 0
+}
+
+/**
+ * Normalizes prompt text to eliminate trivial whitespace or capitalization variations.
+ *
+ * @param {string} prompt
+ * @returns {string}
+ */
+export function normalizePrompt(prompt = '') {
+  if (typeof prompt !== 'string') return ''
+  return prompt
+    .trim()
+    .replace(/\r\n/g, '\n')
+    .split('\n')
+    .map((line) => line.trim().replace(/[ \t]+/g, ' '))
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+}
+
+/**
+ * Computes a deterministic SHA-256 fingerprint for a candidate generation request.
+ *
+ * @param {string} prompt
+ * @param {object} [options]
+ * @param {string} [options.model='']
+ * @param {number} [options.temperature=0.6]
+ * @param {string} [options.systemPrompt='']
+ * @param {string} [options.contextHash='']
+ * @returns {string}
+ */
+export function computePromptFingerprint(prompt = '', options = {}) {
+  const {
+    model = '',
+    temperature = 0.6,
+    systemPrompt = '',
+    contextHash = '',
+  } = options
+
+  const normPrompt = normalizePrompt(prompt)
+  const normSys = normalizePrompt(systemPrompt)
+  const roundedTemp = Number(temperature || 0).toFixed(2)
+
+  const payload = [
+    normPrompt,
+    String(model || '').trim().toLowerCase(),
+    roundedTemp,
+    normSys,
+    String(contextHash || ''),
+  ].join(':::')
+
+  return crypto.createHash('sha256').update(payload, 'utf8').digest('hex')
+}
+
+/**
+ * Resolves the cache directory, ensuring it is created safely.
+ *
+ * @param {string} cwd - Base workspace directory
+ * @param {string} [customDir]
+ * @returns {string}
+ */
+export function resolveCacheDir(cwd = process.cwd(), customDir = null) {
+  const dir = customDir
+    ? path.resolve(cwd, customDir)
+    : path.resolve(cwd, '.moa', 'cache', 'semantic')
+  try {
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+  } catch (_err) {
+    /* ignore directory creation errors */
+  }
+  return dir
+}
+
+/**
+ * Retrieves a cached candidate generation entry.
+ *
+ * @param {string} key - SHA-256 cache fingerprint
+ * @param {object} [options]
+ * @param {string} [options.cacheDir]
+ * @param {number} [options.maxAgeMs=604800000] - 7 days default TTL
+ * @returns {object|null}
+ */
+export function getCacheEntry(key, options = {}) {
+  if (!key || typeof key !== 'string') return null
+  const { cacheDir, maxAgeMs = 7 * 24 * 60 * 60 * 1000 } = options
+  const targetDir = resolveCacheDir(options.cwd, cacheDir)
+  const filePath = path.join(targetDir, `${key}.json`)
+
+  try {
+    if (!fs.existsSync(filePath)) {
+      _runtimeMisses++
+      return null
+    }
+
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const entry = JSON.parse(raw)
+    const now = Date.now()
+
+    if (entry.createdAt && (now - entry.createdAt > (entry.ttlMs || maxAgeMs))) {
+      // Expired entry
+      bestEffort('unlink expired cache entry', () => fs.unlinkSync(filePath))
+      _runtimeMisses++
+      return null
+    }
+
+    _runtimeHits++
+    const tokens = entry.usage?.totalTokens || 0
+    const cost = entry.costUsd || 0
+    _runtimeSavedTokens += tokens
+    _runtimeSavedCostUsd += cost
+
+    // Update access metadata
+    entry.lastAccessedAt = now
+    entry.hitCount = (entry.hitCount || 0) + 1
+    bestEffort('update cache access metadata', () => {
+      fs.writeFileSync(filePath, JSON.stringify(entry, null, 2), 'utf8')
+    })
+
+    return entry
+  } catch (_err) {
+    _runtimeMisses++
+    return null
+  }
+}
+
+/**
+ * Stores a candidate generation output into the semantic cache.
+ *
+ * @param {string} key - Cache fingerprint
+ * @param {object} entryData - Candidate generation payload
+ * @param {object} [options]
+ * @param {string} [options.cacheDir]
+ * @param {number} [options.ttlMs=604800000]
+ * @returns {boolean}
+ */
+export function setCacheEntry(key, entryData = {}, options = {}) {
+  if (!key || typeof key !== 'string') return false
+  const { cacheDir, ttlMs = 7 * 24 * 60 * 60 * 1000 } = options
+  const targetDir = resolveCacheDir(options.cwd, cacheDir)
+  const filePath = path.join(targetDir, `${key}.json`)
+
+  const payload = {
+    key,
+    model: entryData.model || '',
+    output: entryData.output || entryData.text || '',
+    usage: entryData.usage || { totalTokens: 0, promptTokens: 0, completionTokens: 0 },
+    costUsd: entryData.costUsd || 0,
+    createdAt: Date.now(),
+    ttlMs: entryData.ttlMs || ttlMs,
+    hitCount: 0,
+    metadata: entryData.metadata || {},
+  }
+
+  try {
+    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2), 'utf8')
+    return true
+  } catch (_err) {
+    return false
+  }
+}
+
+/**
+ * Clears expired or all entries from the semantic cache.
+ *
+ * @param {object} [options]
+ * @param {string} [options.cacheDir]
+ * @param {number} [options.olderThanMs]
+ * @returns {{ clearedCount: number }}
+ */
+export function clearSemanticCache(options = {}) {
+  const { cacheDir, olderThanMs = null } = options
+  const targetDir = resolveCacheDir(options.cwd, cacheDir)
+  let clearedCount = 0
+
+  try {
+    if (!fs.existsSync(targetDir)) return { clearedCount: 0 }
+    const files = fs.readdirSync(targetDir)
+    const now = Date.now()
+
+    for (const f of files) {
+      if (!f.endsWith('.json')) continue
+      const filePath = path.join(targetDir, f)
+      if (typeof olderThanMs === 'number' && olderThanMs > 0) {
+        try {
+          const raw = fs.readFileSync(filePath, 'utf8')
+          const entry = JSON.parse(raw)
+          if (now - (entry.createdAt || 0) < olderThanMs) {
+            continue
+          }
+        } catch (_err) {
+          /* corrupt file, proceed to unlink */
+        }
+      }
+      bestEffort('unlink cleared cache entry', () => {
+        fs.unlinkSync(filePath)
+        clearedCount++
+      })
+    }
+  } catch (_err) {
+    /* ignore read/delete errors */
+  }
+
+  return { clearedCount }
+}
+
+/**
+ * Returns cache usage metrics and statistics.
+ *
+ * @param {object} [options]
+ * @returns {object}
+ */
+export function getSemanticCacheStats(options = {}) {
+  const { cacheDir } = options
+  const targetDir = resolveCacheDir(options.cwd, cacheDir)
+  let entriesCount = 0
+  let totalSizeBytes = 0
+
+  try {
+    if (fs.existsSync(targetDir)) {
+      const files = fs.readdirSync(targetDir)
+      for (const f of files) {
+        if (!f.endsWith('.json')) continue
+        try {
+          const stat = fs.statSync(path.join(targetDir, f))
+          entriesCount++
+          totalSizeBytes += stat.size
+        } catch (_err) {
+          /* file unlinked concurrently */
+        }
+      }
+    }
+  } catch (_err) {
+    /* ignore dir access errors */
+  }
+
+  return {
+    entriesCount,
+    totalSizeBytes,
+    hits: _runtimeHits,
+    misses: _runtimeMisses,
+    savedTokens: _runtimeSavedTokens,
+    savedCostUsd: Number(_runtimeSavedCostUsd.toFixed(5)),
+  }
+}
+
+
+/**
+ * Wraps callLlm with local semantic caching for intermediate candidate generations (#318).
+ *
+ * @param {Function} callLlm - Raw LLM invocation function
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=false]
+ * @param {number} [options.ttlMs=604800000]
+ * @param {string} [options.cwd]
+ * @param {object} [options.ctx]
+ * @returns {Function}
+ */
+export function createCachingCallLlm(callLlm, options = {}) {
+  const { enabled = false, ttlMs = 7 * 24 * 60 * 60 * 1000, cwd, ctx } = options
+  if (!enabled || typeof callLlm !== 'function') return callLlm
+
+  return async function cachedCallLlm(callArgs) {
+    if (!callArgs || typeof callArgs !== 'object') {
+      return callLlm(callArgs)
+    }
+
+    const messages = Array.isArray(callArgs.messages) ? callArgs.messages : []
+    const promptText = messages
+      .filter((m) => m && m.role === 'user')
+      .map((m) => m.content)
+      .join('\n') || String(callArgs.prompt || '')
+    const systemPrompt = messages
+      .filter((m) => m && m.role === 'system')
+      .map((m) => m.content)
+      .join('\n') || ''
+
+    const modelName = callArgs.model
+      ? (callArgs.provider ? `${callArgs.provider}:${callArgs.model}` : callArgs.model)
+      : ''
+
+    const key = computePromptFingerprint(promptText, {
+      model: modelName,
+      temperature: callArgs.temperature ?? 0.6,
+      systemPrompt,
+    })
+
+    const cached = getCacheEntry(key, { cwd, maxAgeMs: ttlMs })
+    if (cached && typeof cached.output === 'string' && cached.output.length > 0) {
+      emitEvent(ctx, MOA_EVENTS.CACHE_HIT, { key, model: modelName })
+      return {
+        text: cached.output,
+        content: cached.output,
+        usage: cached.usage || { inputTokens: 0, outputTokens: 0, totalTokens: 0 },
+        costUsd: 0,
+        cached: true,
+      }
+    }
+
+    const res = await callLlm(callArgs)
+    const text = typeof res === 'string' ? res : (res?.content || res?.text || '')
+    if (text) {
+      const usage = (typeof res === 'object' && res?.usage) ? res.usage : {
+        inputTokens: Math.max(1, Math.round((promptText.length + systemPrompt.length) / 4)),
+        outputTokens: Math.max(1, Math.round(text.length / 4)),
+        totalTokens: Math.max(2, Math.round((promptText.length + systemPrompt.length + text.length) / 4)),
+      }
+      const costUsd = typeof res === 'object' && typeof res?.costUsd === 'number' ? res.costUsd : 0
+      setCacheEntry(key, {
+        model: modelName,
+        output: text,
+        usage,
+        costUsd,
+        ttlMs,
+      }, { cwd, ttlMs })
+    }
+
+    return res
+  }
+}

package/lib/routes/cache.js

@@ -0,0 +1,42 @@
+/**
+ * Semantic Cache Management Routes (#318)
+ * Exposes inspection and purge endpoints for locally cached candidate generations.
+ */
+
+import { getSemanticCacheStats, clearSemanticCache } from '../pipeline/semantic-cache.js'
+import { writeJson, readBody, assertAuthorizedRequest } from '../access.js'
+import { isSafeWriteRequest } from '../updater.js'
+
+export function registerCacheRoutes(ctx, { workspaceRoot }) {
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-moa/cache',
+      handler: async (req, res) => {
+        if (!assertAuthorizedRequest(req, res, ctx)) return
+        if (req.method === 'GET') {
+          const stats = getSemanticCacheStats({ cwd: workspaceRoot })
+          return writeJson(res, 200, { ok: true, stats })
+        }
+        if (req.method === 'POST') {
+          if (!isSafeWriteRequest(req)) {
+            return writeJson(res, 403, { ok: false, error: 'Forbidden: cross-site request rejected' })
+          }
+          let olderThanMs = null
+          try {
+            const raw = await readBody(req)
+            if (raw) {
+              const body = JSON.parse(raw)
+              if (typeof body.olderThanMs === 'number') olderThanMs = body.olderThanMs
+            }
+          } catch (_err) {
+            /* ignore invalid body for clear */
+          }
+          const result = clearSemanticCache({ cwd: workspaceRoot, olderThanMs })
+          return writeJson(res, 200, { ok: true, clearedCount: result.clearedCount })
+        }
+        return writeJson(res, 405, { ok: false, error: 'GET or POST required' })
+      },
+    })
+  })
+}

package/lib/routes.js

@@ -7,15 +7,18 @@ import { registerPresetRoutes } from './routes/presets.js'
 import { registerHistoryRoutes } from './routes/history.js'
 import { registerWorkbenchRoutes } from './routes/workbench.js'
 import { registerPipelineRoutes } from './routes/pipeline.js'
+import { registerCacheRoutes } from './routes/cache.js'
 
 export { registerPresetRoutes } from './routes/presets.js'
 export { registerHistoryRoutes } from './routes/history.js'
 export { registerWorkbenchRoutes } from './routes/workbench.js'
 export { registerPipelineRoutes } from './routes/pipeline.js'
+export { registerCacheRoutes } from './routes/cache.js'
 
 export function registerMoaRoutes(ctx, deps) {
   registerPresetRoutes(ctx, deps)
   registerHistoryRoutes(ctx, deps)
   registerWorkbenchRoutes(ctx, deps)
   registerPipelineRoutes(ctx, deps)
+  registerCacheRoutes(ctx, deps)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-moa",
-  "version": "0.2.72",
+  "version": "0.2.73",
   "description": "Mixture of Agents (MoA) plugin for DeepSeek Harness with /moa slash command",
   "type": "module",
   "main": "lib/index.js",
@@ -72,4 +72,3 @@
     "react-dom": "^18.3.1"
   }
 }
-