@goodandready/dsh-moa 0.2.74 → 0.2.75

package/README.md

@@ -195,6 +195,12 @@ Dispatches `moa/judge-escalation` Cordis events and displays escalation decision
 ### 22. Self-Consistency Temperature Sampling for Single Models
 Allows single-model configurations (such as a local Ollama/vLLM instance or a single API key) to leverage Mixture-of-Agents diversity. When enabled on a preset with 1 model slot, the runner expands it into $N$ parallel candidate streams with distinct temperatures (e.g. 0.2, 0.6, 0.9) and complementary personas (`proposer`, `challenger`, `minimalist`), calculates agreement ratio, and performs full MoA consensus synthesis. Dispatches `moa/self-consistency-expand` Cordis events. Configured via `self_consistency_enabled: true`, `self_consistency_samples: 3`, and `self_consistency_temperatures: [0.2, 0.6, 0.9]`.
 
+### 23. Stack-Aware Dynamic Persona Evolution
+Scans project manifests (`package.json`, `Cargo.toml`, `pyproject.toml`, `requirements.txt`, `go.mod`) to detect languages, frameworks, and libraries. Automatically specializes candidate proposers into domain-specific roles (e.g. React Optimization, TypeScript Safety, Accessibility, FastAPI Async) to maximize hypothesis diversity. Emits `moa/stack-detected` Cordis events. Configured via `stack_aware_personas_enabled: true`.
+
+### 24. Self-Learning Developer Preferences Metaprompt
+Maintains a persistent profile of developer coding principles and architectural preferences in `~/.dsh/moa/preferences.json`. Injects active principles into the Judge prompt to bias consensus toward team standards (strict typing, functional immutability, error boundaries). Manageable via `GET/POST/DELETE /dsh-moa/preferences` REST endpoints and preset toggle `developer_preferences_enabled: true`.
+
 ### 6. Live Canvas 1-Click Preview (optional)
 If `@goodandready/dsh-live-canvas` is installed in the same profile, `dsh-moa` pushes the promoted HTML file to the Live Canvas REST contract (`POST /dsh-live-canvas/api/preview`, served by the same harness webServer) and appends a one-click preview link (`/dsh-live-canvas/sandbox/<id>`) to the answer. Without the plugin the step is skipped silently — no errors in the log, no dead links.
 

package/README.ru.md

@@ -195,6 +195,12 @@ graph TD
 ### 22. Самосогласованное температурное сэмплирование для одиночных моделей (Self-Consistency)
 Позволяет пользователям с единственной моделью (локальная Ollama, vLLM или единственный API-ключ) получать преимущества ансамблевой валидации MoA. Автоматически разворачивает одиночный слот на $N$ параллельных запусков с различными температурами (`0.2, 0.6, 0.9`) и дополняющими друг друга инженерными персонами (`proposer`, `challenger`, `minimalist`), вычисляет коэффициент согласия (Self-Consistency Agreement) и синтезирует итоговый результат. Генерирует событие `moa/self-consistency-expand`.
 
+### 23. Динамическая адаптация персон по манифестам проекта (Stack-Aware Personas)
+Автоматически сканирует манифесты проекта (`package.json`, `Cargo.toml`, `pyproject.toml`, `requirements.txt`, `go.mod`) для определения стека технологий и библиотек. Специализирует роли кандидатов под конкретный стек (оптимизация рендера, строгая типизация, доступность, асинхронные интерфейсы), обеспечивая многоаспектный анализ задачи. Генерирует событие `moa/stack-detected`. Включается через `stack_aware_personas_enabled: true`.
+
+### 24. Метапромпт предпочтений разработчика (Developer Preferences)
+Хранит профиль архитектурных стандартов и стилевых предпочтений разработчика в `~/.dsh/moa/preferences.json`. Инжектирует активные принципы в контекст судьи, гарантируя соответствие выбранного решения вкусам команды (строгая типизация, иммутабельность, обработка ошибок). Доступен REST API (`GET/POST/DELETE /dsh-moa/preferences`) и опция пресета `developer_preferences_enabled: true`.
+
 ### 6. Live Canvas 1-клик предпросмотр (опционально)
 Если в профиле установлен `@goodandready/dsh-live-canvas`, `dsh-moa` отправляет промоученный HTML-файл в REST-контракт Live Canvas (`POST /dsh-live-canvas/api/preview`, тот же webServer харнесса) и добавляет к ответу ссылку на предпросмотр (`/dsh-live-canvas/sandbox/<id>`). Без плагина шаг пропускается тихо — без ошибок в журнале и без битых ссылок.
 

package/README.zh.md

@@ -172,6 +172,12 @@ graph TD
 ### 22. 单模型自洽性温度采样 (Self-Consistency Temperature Sampling)
 专为仅配置单模型（如本地 Ollama/vLLM 或单一 API Key）的场景设计。开启后自动将单槽位扩展为 $N$ 个并行采样（分别采用 0.2、0.6、0.9 等递增温度与 `proposer`、`challenger`、`minimalist` 互补提示词），评估自洽一致性比率并进行全流程 MoA 综合聚合，触发 `moa/self-consistency-expand` 事件。
 
+### 23. 基于项目清单的感知角色演化 (Stack-Aware Personas)
+自动扫描工作区清单 (`package.json`, `Cargo.toml`, `pyproject.toml`, `go.mod`) 识别编程语言、框架与核心依赖，动态为各候选槽位分派互补的领域专家角色（如 React 渲染优化、TypeScript 严格类型安全、可访问性审查、FastAPI 异步架构），触发 `moa/stack-detected` 事件。通过 `stack_aware_personas_enabled: true` 配置。
+
+### 24. 自学习开发者代码偏好元提示词 (Developer Preferences)
+在本地 `~/.dsh/moa/preferences.json` 持久化存储团队编码规范与架构偏好，将启用的规则动态注入裁判评审阶段，使综合方案贴合开发者个人习惯（严格类型、函数不可变性、防御性错误边界）。提供 `GET/POST/DELETE /dsh-moa/preferences` REST 端点，通过 `developer_preferences_enabled: true` 开启。
+
 ### 6. Live Canvas 一键预览（可选）
 若同一 profile 中安装了 `@goodandready/dsh-live-canvas`，`dsh-moa` 会将提升后的 HTML 文件推送到 Live Canvas 的 REST 契约（`POST /dsh-live-canvas/api/preview`，由同一 harness webServer 提供服务），并在回答中附上一键预览链接（`/dsh-live-canvas/sandbox/<id>`）。未安装该插件时此步骤静默跳过——日志无报错，也不会出现死链接。
 

package/lib/client.js

@@ -224,7 +224,11 @@ window.__ModuleLoader__.load({
       "aggregator.escalation_policy_upgrade": "Auto-Upgrade to Senior Judge on Divergence",
       "aggregator.escalation_policy_council": "Convene 3-Judge Majority Council on Divergence",
       "aggregator.escalation_threshold": "Divergence Threshold:",
-      "aggregator.escalation_judge_label": "Senior Judge:"
+      "aggregator.escalation_judge_label": "Senior Judge:",
+      "aggregator.stack_personas_title": "\u{1F4E6} Stack-Aware Dynamic Persona Evolution (Project Manifests)",
+      "aggregator.stack_personas_desc": "Scans project manifests (package.json, Cargo.toml, pyproject.toml, go.mod) and assigns specialized engineering roles to candidate slots.",
+      "aggregator.preferences_title": "\u{1F9E0} Developer Coding Principles & Preferences Metaprompt",
+      "aggregator.preferences_desc": "Injects learned developer preferences (strict typing, functional immutability, error boundaries) to guide Judge synthesis."
     };
     const zh = {
       title: "\u667A\u80FD\u4F53\u6DF7\u5408 (MoA)",
@@ -439,7 +443,11 @@ window.__ModuleLoader__.load({
       "aggregator.escalation_policy_upgrade": "\u5206\u6B67\u65F6\u81EA\u52A8\u5347\u7EA7\u81F3\u9AD8\u9636\u88C1\u5224",
       "aggregator.escalation_policy_council": "\u5206\u6B67\u65F6\u7EC4\u5EFA 3 \u88C1\u5224\u591A\u6570\u51B3\u7B56\u5E2D",
       "aggregator.escalation_threshold": "\u5206\u6B67\u9608\u503C:",
-      "aggregator.escalation_judge_label": "\u9AD8\u9636\u88C1\u5224\u6A21\u578B:"
+      "aggregator.escalation_judge_label": "\u9AD8\u9636\u88C1\u5224\u6A21\u578B:",
+      "aggregator.stack_personas_title": "\u{1F4E6} \u57FA\u4E8E\u9879\u76EE\u914D\u7F6E\u6E05\u5355\u7684\u611F\u77E5\u89D2\u8272\u6F14\u5316 (Stack-Aware Personas)",
+      "aggregator.stack_personas_desc": "\u81EA\u52A8\u626B\u63CF\u9879\u76EE\u6E05\u5355 (package.json, Cargo.toml, pyproject.toml, go.mod) \u5E76\u4E3A\u5404\u5019\u9009\u69FD\u4F4D\u6307\u6D3E\u4E13\u5C5E\u4E13\u4E1A\u89D2\u8272\u3002",
+      "aggregator.preferences_title": "\u{1F9E0} \u81EA\u5B66\u4E60\u5F00\u53D1\u8005\u4EE3\u7801\u504F\u597D\u5143\u63D0\u793A\u8BCD (Developer Preferences)",
+      "aggregator.preferences_desc": "\u5C06\u5F00\u53D1\u8005\u504F\u597D\uFF08\u4E25\u683C\u7C7B\u578B\u3001\u51FD\u6570\u4E0D\u53EF\u53D8\u6027\u3001\u9632\u5FA1\u6027\u9519\u8BEF\u5904\u7406\u7B49\uFF09\u6CE8\u5165\u88C1\u5224\u7EFC\u5408\u8BC4\u5BA1\u9636\u6BB5\u3002"
     };
     function makeT(dict, fallback) {
       return function t(key, vars) {
@@ -2354,6 +2362,7 @@ window.__ModuleLoader__.load({
                   )
                 )
               ),
+              // --- src/client/86-card-aggregator-ext2.js ---
               /* Pre-Judge Local Syntax Gate (#303) & Early Semantic Consensus (#299) */
               React.createElement(
                 "div",
@@ -2559,6 +2568,48 @@ window.__ModuleLoader__.load({
                   )
                 )
               ),
+              /* Stack-Aware Dynamic Persona Evolution (#308) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 6, padding: "8px 12px", background: "var(--dsw-alias-bg-layer-2)", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2)", marginTop: 8 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.stack_aware_personas_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, stack_aware_personas_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.stack_personas_title") || "\u{1F4E6} Stack-Aware Dynamic Persona Evolution (Project Manifests)"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.stack_personas_desc") || "Scans project manifests (package.json, Cargo.toml, pyproject.toml, go.mod) and assigns specialized engineering roles to candidate slots."
+                )
+              ),
+              /* Self-Learning Developer Preferences Metaprompt (#309) */
+              React.createElement(
+                "div",
+                { style: { display: "flex", flexDirection: "column", gap: 6, padding: "8px 12px", background: "var(--dsw-alias-bg-layer-2)", borderRadius: 8, border: "1px solid var(--dsw-alias-border-l2)", marginTop: 8 } },
+                React.createElement(
+                  "label",
+                  { style: { display: "flex", alignItems: "center", gap: 8, cursor: "pointer", fontSize: 13, fontWeight: 500 } },
+                  React.createElement("input", {
+                    type: "checkbox",
+                    checked: Boolean(currentPreset.developer_preferences_enabled),
+                    onChange: (e) => updateCurrentPreset((p) => ({ ...p, developer_preferences_enabled: e.target.checked })),
+                    style: { accentColor: "var(--dsw-alias-state-brand-primary, var(--dsw-alias-label-primary))", cursor: "pointer" }
+                  }),
+                  t("aggregator.preferences_title") || "\u{1F9E0} Developer Coding Principles & Preferences Metaprompt"
+                ),
+                React.createElement(
+                  "div",
+                  { style: { fontSize: 12, color: "var(--dsw-alias-label-secondary)", marginLeft: 22 } },
+                  t("aggregator.preferences_desc") || "Injects learned developer preferences (strict typing, functional immutability, error boundaries) to guide Judge synthesis."
+                )
+              ),
               /* Fallback Judges Chain */
               React.createElement(
                 "div",

package/lib/events.js

@@ -9,6 +9,8 @@ export const MOA_EVENTS = {
   EARLY_CONSENSUS: 'moa/early-consensus',
   JUDGE_ESCALATION: 'moa/judge-escalation',
   SELF_CONSISTENCY_EXPAND: 'moa/self-consistency-expand',
+  STACK_DETECTED: 'moa/stack-detected',
+  PREFERENCES_APPLIED: 'moa/preferences-applied',
   CRITIQUE_COMPLETE: 'moa/critique-complete',
   JUDGE_VERDICT: 'moa/judge-verdict',
   CONTEXT_PRUNING: 'moa/context-pruning',

package/lib/moa-schema.js

@@ -89,6 +89,8 @@ export const PresetSchema = z.object({
   escalation_policy: z.string().default('single'),
   escalation_disagreement_threshold: z.number().default(0.40),
   escalation_judge: ModelSlotSchema.default({ provider: '', model: '' }),
+  stack_aware_personas_enabled: z.boolean().default(false),
+  developer_preferences_enabled: z.boolean().default(false),
 })
 
 export const Config = z.object({
@@ -124,6 +126,8 @@ export const Config = z.object({
   escalation_policy: z.string().default('single').volatile(),
   escalation_disagreement_threshold: z.number().default(0.40).volatile(),
   escalation_judge: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
+  stack_aware_personas_enabled: z.boolean().default(false).volatile(),
+  developer_preferences_enabled: z.boolean().default(false).volatile(),
   smart_routing_model: ModelSlotSchema.default({ provider: '', model: '' }).volatile(),
   prices: z.dict(PriceRow).default({}).volatile(),
   presets: z.array(PresetSchema).default([

package/lib/pipeline/context.js

@@ -1,3 +1,5 @@
+import { detectProjectStack, assignStackAwarePersonas, formatStackAwareDirective } from './manifest-stack.js'
+import { formatPreferencesDirective } from './developer-preferences.js'
 import { expandSelfConsistencySlots } from './self-consistency.js'
 import { emitEvent, MOA_EVENTS } from '../events.js'
 import { balanceCandidateQuotas } from '../moa-quota-balancer.js'
@@ -81,6 +83,34 @@ export async function stageProjectContext({
   const semanticCacheEnabled = Boolean(preset?.semantic_cache_enabled)
   const semanticCacheTtlHours = typeof preset?.semantic_cache_ttl_hours === 'number' ? preset.semantic_cache_ttl_hours : 168
 
+  const stackInfo = detectProjectStack(cwd)
+  if (stackInfo.manifestFound) {
+    emitEvent(ctx, MOA_EVENTS.STACK_DETECTED, {
+      primaryLanguage: stackInfo.primaryLanguage,
+      frameworks: stackInfo.frameworks,
+      libraries: stackInfo.libraries,
+      stackSummary: stackInfo.stackSummary,
+    })
+    if (typeof onProgress === 'function' && stackInfo.stackSummary) {
+      onProgress(`📦 *Project Stack: Detected ${stackInfo.stackSummary}*\n`)
+    }
+  }
+
+  const stackAwarePersonasEnabled = Boolean(preset?.stack_aware_personas_enabled)
+  if (stackAwarePersonasEnabled && !selfConsistencyExpanded) {
+    const stackRes = assignStackAwarePersonas(effectiveReferenceModels, stackInfo, { enabled: true })
+    if (stackRes.isSpecialized) {
+      effectiveReferenceModels = stackRes.references
+    }
+  }
+
+  const developerPreferencesEnabled = Boolean(preset?.developer_preferences_enabled)
+  const developerPreferencesDirective = formatPreferencesDirective(null, { enabled: developerPreferencesEnabled })
+  if (developerPreferencesDirective) {
+    emitEvent(ctx, MOA_EVENTS.PREFERENCES_APPLIED, { enabled: true })
+  }
+  const stackAwareDirective = formatStackAwareDirective(stackInfo)
+
   const collectedCtx = await collectProjectContext(cwd, 16000)
   const isRefinement = Boolean(collectedCtx?.files?.length > 0 && isRefinementTask(userPrompt, collectedCtx.files))
   let projectContext = ''
@@ -170,6 +200,7 @@ export async function stageProjectContext({
     semanticCacheEnabled, semanticCacheTtlHours,
     selfConsistencyEnabled, selfConsistencyExpanded, selfConsistencySamples, selfConsistencyTemperatures,
     escalationPolicy, escalationDisagreementThreshold, escalationJudge,
+    stackInfo, stackAwareDirective, developerPreferencesDirective,
   }
 }
 

package/lib/pipeline/developer-preferences.js

@@ -0,0 +1,196 @@
+/**
+ * Self-Learning Developer Preferences Metaprompt (#309)
+ *
+ * Tracks developer coding principles, architectural standards, and preferred idioms
+ * in a persistent local store (~/.dsh/moa/preferences.json).
+ * Injects a concise "Developer Coding Principles" directive into the Judge
+ * synthesis phase (and candidate prompts) to bias consensus toward the engineer's tastes.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+
+export const DEFAULT_PREFERENCES = Object.freeze([
+  {
+    id: 'strict-typing',
+    title: 'Strict Types & Explicit Contracts',
+    rule: "Never use loose 'any' types or unchecked type casts. Explicitly define interfaces, return types, and input validation schemas.",
+    category: 'typing',
+    enabled: true,
+  },
+  {
+    id: 'functional-purity',
+    title: 'Functional Immutability',
+    rule: 'Prefer pure functions, immutable data transforms, and explicit return values over hidden global state mutations.',
+    category: 'architecture',
+    enabled: true,
+  },
+  {
+    id: 'defensive-errors',
+    title: 'Defensive Error Handling',
+    rule: 'Never swallow exceptions silently. Use structured error types, descriptive messages, and clean fallback strategies.',
+    category: 'reliability',
+    enabled: true,
+  },
+])
+
+/**
+ * Resolves the persistent preferences file path.
+ *
+ * @param {string} [customPath]
+ * @returns {string}
+ */
+export function getPreferencesFilePath(customPath = null) {
+  if (customPath && typeof customPath === 'string' && customPath.trim()) {
+    return path.resolve(customPath.trim())
+  }
+  return path.join(os.homedir(), '.dsh', 'moa', 'preferences.json')
+}
+
+/**
+ * Loads developer preferences from disk with default fallback.
+ *
+ * @param {string} [customPath]
+ * @returns {Array<object>}
+ */
+export function loadDeveloperPreferences(customPath = null) {
+  const filePath = getPreferencesFilePath(customPath)
+  if (!fs.existsSync(filePath)) {
+    // Seed default preferences file
+    try {
+      const dir = path.dirname(filePath)
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+      fs.writeFileSync(filePath, JSON.stringify(DEFAULT_PREFERENCES, null, 2), 'utf8')
+    } catch {
+      // safe fallback if filesystem is read-only
+    }
+    return [...DEFAULT_PREFERENCES]
+  }
+
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8')
+    const parsed = JSON.parse(raw)
+    if (Array.isArray(parsed)) {
+      return parsed.filter((p) => p && typeof p === 'object' && p.id && p.rule)
+    }
+  } catch {
+    // safe fallback
+  }
+
+  return [...DEFAULT_PREFERENCES]
+}
+
+/**
+ * Atomically saves developer preferences to disk.
+ *
+ * @param {Array<object>} preferences
+ * @param {string} [customPath]
+ * @returns {boolean}
+ */
+export function saveDeveloperPreferences(preferences, customPath = null) {
+  if (!Array.isArray(preferences)) return false
+  const filePath = getPreferencesFilePath(customPath)
+
+  try {
+    const dir = path.dirname(filePath)
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+    const tmp = `${filePath}.tmp.${Date.now()}`
+    fs.writeFileSync(tmp, JSON.stringify(preferences, null, 2), 'utf8')
+    fs.renameSync(tmp, filePath)
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Adds a new developer preference rule.
+ *
+ * @param {object} item - { title, rule, category, enabled }
+ * @param {string} [customPath]
+ * @returns {object|null}
+ */
+export function addDeveloperPreference(item = {}, customPath = null) {
+  if (!item || !item.rule || typeof item.rule !== 'string') return null
+  const current = loadDeveloperPreferences(customPath)
+
+  const id = item.id || `pref-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`
+  const newPref = {
+    id,
+    title: (item.title && String(item.title).trim()) || 'Custom Coding Standard',
+    rule: String(item.rule).trim(),
+    category: (item.category && String(item.category).trim()) || 'general',
+    enabled: item.enabled !== false,
+    createdAt: new Date().toISOString(),
+  }
+
+  current.push(newPref)
+  saveDeveloperPreferences(current, customPath)
+  return newPref
+}
+
+/**
+ * Updates an existing developer preference.
+ *
+ * @param {string} id
+ * @param {object} updates
+ * @param {string} [customPath]
+ * @returns {object|null}
+ */
+export function updateDeveloperPreference(id, updates = {}, customPath = null) {
+  if (!id) return null
+  const current = loadDeveloperPreferences(customPath)
+  const idx = current.findIndex((p) => p.id === id)
+  if (idx === -1) return null
+
+  const target = current[idx]
+  if (typeof updates.title === 'string') target.title = updates.title.trim()
+  if (typeof updates.rule === 'string') target.rule = updates.rule.trim()
+  if (typeof updates.category === 'string') target.category = updates.category.trim()
+  if (typeof updates.enabled === 'boolean') target.enabled = updates.enabled
+
+  saveDeveloperPreferences(current, customPath)
+  return target
+}
+
+/**
+ * Deletes a developer preference by ID.
+ *
+ * @param {string} id
+ * @param {string} [customPath]
+ * @returns {boolean}
+ */
+export function deleteDeveloperPreference(id, customPath = null) {
+  if (!id) return false
+  const current = loadDeveloperPreferences(customPath)
+  const filtered = current.filter((p) => p.id !== id)
+  if (filtered.length === current.length) return false
+
+  return saveDeveloperPreferences(filtered, customPath)
+}
+
+/**
+ * Formats active developer preferences into an injected prompt directive.
+ *
+ * @param {Array<object>} [preferences] - Array of preferences (loads from disk if omitted)
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=true]
+ * @returns {string|null}
+ */
+export function formatPreferencesDirective(preferences = null, options = {}) {
+  const { enabled = true, customPath = null } = options
+  if (!enabled) return null
+
+  const list = Array.isArray(preferences) ? preferences : loadDeveloperPreferences(customPath)
+  const active = list.filter((p) => p && p.enabled !== false && p.rule)
+
+  if (active.length === 0) return null
+
+  const lines = active.map((p) => `- [${p.title}]: ${p.rule}`)
+
+  return `### Developer Coding Principles & Preferred Conventions
+The developer has established the following coding standards for this project:
+${lines.join('\n')}
+Evaluate all proposals against these principles and favor implementations adhering to them.`
+}

package/lib/pipeline/manifest-stack.js

@@ -0,0 +1,287 @@
+/**
+ * Stack-Aware Dynamic Persona Evolution from Project Manifests (#308)
+ *
+ * Scans project manifests (package.json, Cargo.toml, pyproject.toml, requirements.txt, go.mod)
+ * in the workspace root to infer primary programming languages, frameworks, ORMs,
+ * and test suites. Evolves candidate proposers into specialized domain experts
+ * (e.g. React Optimization, TypeScript Strict Safety, Accessibility, FastAPI Async)
+ * to maximize architectural hypothesis diversity.
+ */
+
+import fs from 'node:fs'
+import path from 'node:path'
+
+/**
+ * Scans workspace root manifests to detect project languages and dependencies.
+ *
+ * @param {string} cwd - Workspace root directory
+ * @returns {object} Detected stack information
+ */
+export function detectProjectStack(cwd = process.cwd()) {
+  const stack = {
+    primaryLanguage: 'unknown',
+    frameworks: [],
+    libraries: [],
+    manifestFound: false,
+    stackSummary: '',
+  }
+
+  if (!cwd || typeof cwd !== 'string') return stack
+
+  // 1. Node / JavaScript / TypeScript (package.json)
+  const pkgPath = path.join(cwd, 'package.json')
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const raw = fs.readFileSync(pkgPath, 'utf8')
+      const pkg = JSON.parse(raw)
+      stack.manifestFound = true
+      stack.primaryLanguage = 'javascript'
+
+      const allDeps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {}),
+        ...(pkg.peerDependencies || {}),
+      }
+
+      if (allDeps.typescript || fs.existsSync(path.join(cwd, 'tsconfig.json'))) {
+        stack.primaryLanguage = 'typescript'
+        stack.libraries.push('typescript')
+      }
+
+      // Frameworks
+      if (allDeps.next) stack.frameworks.push('next.js')
+      else if (allDeps.react) stack.frameworks.push('react')
+
+      if (allDeps.nuxt) stack.frameworks.push('nuxt')
+      else if (allDeps.vue) stack.frameworks.push('vue')
+
+      if (allDeps['@sveltejs/kit']) stack.frameworks.push('sveltekit')
+      else if (allDeps.svelte) stack.frameworks.push('svelte')
+
+      if (allDeps['@angular/core']) stack.frameworks.push('angular')
+      if (allDeps['@nestjs/core']) stack.frameworks.push('nestjs')
+      if (allDeps.fastify) stack.frameworks.push('fastify')
+      if (allDeps.express) stack.frameworks.push('express')
+
+      // Styling & UI
+      if (allDeps.tailwindcss) stack.libraries.push('tailwindcss')
+
+      // ORM & Data
+      if (allDeps.prisma || allDeps['@prisma/client']) stack.libraries.push('prisma')
+      if (allDeps['drizzle-orm']) stack.libraries.push('drizzle')
+      if (allDeps.typeorm) stack.libraries.push('typeorm')
+      if (allDeps.mongoose) stack.libraries.push('mongoose')
+
+      // Validation
+      if (allDeps.zod) stack.libraries.push('zod')
+      if (allDeps.valibot) stack.libraries.push('valibot')
+
+      // Testing
+      if (allDeps.vitest) stack.libraries.push('vitest')
+      if (allDeps.jest) stack.libraries.push('jest')
+      if (allDeps.playwright || allDeps['@playwright/test']) stack.libraries.push('playwright')
+    } catch {
+      // safe fallback on corrupted package.json
+    }
+  }
+
+  // 2. Rust (Cargo.toml)
+  const cargoPath = path.join(cwd, 'Cargo.toml')
+  if (fs.existsSync(cargoPath)) {
+    try {
+      const content = fs.readFileSync(cargoPath, 'utf8')
+      stack.manifestFound = true
+      stack.primaryLanguage = 'rust'
+
+      if (content.includes('axum')) stack.frameworks.push('axum')
+      if (content.includes('actix-web')) stack.frameworks.push('actix-web')
+      if (content.includes('tokio')) stack.libraries.push('tokio')
+      if (content.includes('serde')) stack.libraries.push('serde')
+      if (content.includes('sqlx')) stack.libraries.push('sqlx')
+      if (content.includes('diesel')) stack.libraries.push('diesel')
+    } catch {
+      // safe fallback
+    }
+  }
+
+  // 3. Python (pyproject.toml, requirements.txt)
+  const pyprojectPath = path.join(cwd, 'pyproject.toml')
+  const reqPath = path.join(cwd, 'requirements.txt')
+  if (fs.existsSync(pyprojectPath) || fs.existsSync(reqPath)) {
+    try {
+      const pyContent = (fs.existsSync(pyprojectPath) ? fs.readFileSync(pyprojectPath, 'utf8') : '') +
+        '\n' + (fs.existsSync(reqPath) ? fs.readFileSync(reqPath, 'utf8') : '')
+      stack.manifestFound = true
+      if (stack.primaryLanguage === 'unknown') stack.primaryLanguage = 'python'
+
+      if (pyContent.includes('fastapi')) stack.frameworks.push('fastapi')
+      if (pyContent.includes('django')) stack.frameworks.push('django')
+      if (pyContent.includes('flask')) stack.frameworks.push('flask')
+      if (pyContent.includes('pydantic')) stack.libraries.push('pydantic')
+      if (pyContent.includes('sqlalchemy')) stack.libraries.push('sqlalchemy')
+      if (pyContent.includes('pytest')) stack.libraries.push('pytest')
+      if (pyContent.includes('torch')) stack.libraries.push('pytorch')
+      if (pyContent.includes('pandas')) stack.libraries.push('pandas')
+    } catch {
+      // safe fallback
+    }
+  }
+
+  // 4. Go (go.mod)
+  const goModPath = path.join(cwd, 'go.mod')
+  if (fs.existsSync(goModPath)) {
+    try {
+      const goContent = fs.readFileSync(goModPath, 'utf8')
+      stack.manifestFound = true
+      if (stack.primaryLanguage === 'unknown') stack.primaryLanguage = 'go'
+
+      if (goContent.includes('gin-gonic/gin')) stack.frameworks.push('gin')
+      if (goContent.includes('gofiber/fiber')) stack.frameworks.push('fiber')
+      if (goContent.includes('labstack/echo')) stack.frameworks.push('echo')
+      if (goContent.includes('gorm.io/gorm')) stack.libraries.push('gorm')
+      if (goContent.includes('stretchr/testify')) stack.libraries.push('testify')
+    } catch {
+      // safe fallback
+    }
+  }
+
+  // Build summary string
+  const parts = []
+  if (stack.primaryLanguage !== 'unknown') parts.push(stack.primaryLanguage)
+  if (stack.frameworks.length > 0) parts.push(`framework: ${stack.frameworks.join(', ')}`)
+  if (stack.libraries.length > 0) parts.push(`libs: ${stack.libraries.slice(0, 4).join(', ')}`)
+  stack.stackSummary = parts.join(' | ')
+
+  return stack
+}
+
+/**
+ * Returns specialized domain personas based on detected stack.
+ *
+ * @param {object} stackInfo
+ * @returns {Array<string>} Array of specialized persona role descriptions
+ */
+export function getStackPersonaSpecialties(stackInfo = {}) {
+  const lang = stackInfo.primaryLanguage || 'unknown'
+  const frameworks = Array.isArray(stackInfo.frameworks) ? stackInfo.frameworks : []
+  const libs = Array.isArray(stackInfo.libraries) ? stackInfo.libraries : []
+
+  // React / Next.js / Frontend
+  if (frameworks.includes('react') || frameworks.includes('next.js') || frameworks.includes('vue') || frameworks.includes('svelte')) {
+    return [
+      'Component Architecture, Hooks & Re-render Optimization Specialist',
+      libs.includes('typescript') || lang === 'typescript'
+        ? 'TypeScript Strict Typing, Generic Invariants & Defensive Schema Expert'
+        : 'State Management, Data Flow & Edge-Case Specialist',
+      'Accessibility (a11y), Semantic UI & Modern CSS Performance Reviewer',
+    ]
+  }
+
+  // Python / FastAPI / Django
+  if (lang === 'python') {
+    return [
+      frameworks.includes('fastapi')
+        ? 'FastAPI Async Concurrency & High-Throughput REST Architect'
+        : 'Pythonic Clean Architecture & Idiomatic Object Design Specialist',
+      libs.includes('pydantic')
+        ? 'Pydantic V2 Schema Validation & Type-Safe Domain Modeler'
+        : 'Defensive Data Integrity & Error Boundary Engineer',
+      libs.includes('pytest')
+        ? 'Pytest Fixtures, Mocking & Comprehensive Edge-Case Test Engineer'
+        : 'Performance Profiling & Memory Leak Auditor',
+    ]
+  }
+
+  // Rust
+  if (lang === 'rust') {
+    return [
+      'Rust Zero-Cost Abstractions & Concurrency Architect',
+      'Rust Memory Safety, Error Handling & Lifetime Specialist',
+      'Rust Idiomatic API & Performance Specialist',
+    ]
+  }
+
+  // Go
+  if (lang === 'go') {
+    return [
+      'Go Idiomatic Concurrency & Channel Synchronization Architect',
+      'Go Interface Design, Error Wrapping & Zero-Allocation Specialist',
+      'Go Production Reliability & Table-Driven Unit Testing Specialist',
+    ]
+  }
+
+  // General TypeScript / Node
+  if (lang === 'typescript') {
+    return [
+      'TypeScript Strict Type Safety & Clean Architecture Specialist',
+      'Async Flow, Micro-Optimization & Error Boundary Engineer',
+      'Maintainability, Modularity & Test Coverage Auditor',
+    ]
+  }
+
+  // Universal Default
+  return [
+    'System Architecture & Core Correctness Engineer',
+    'Edge-Case Analysis & Defensive Error Handling Specialist',
+    'Clean Code, Maintainability & Documentation Specialist',
+  ]
+}
+
+/**
+ * Assigns stack-aware specialized personas to candidate proposer slots.
+ *
+ * @param {Array<object>} references - Proposer slots
+ * @param {object} stackInfo - Output of detectProjectStack
+ * @param {object} [options]
+ * @param {boolean} [options.enabled=true] - Whether stack-aware personas are enabled
+ * @returns {{ references: Array<object>, isSpecialized: boolean, stackSummary: string }}
+ */
+export function assignStackAwarePersonas(references = [], stackInfo = {}, options = {}) {
+  const { enabled = true } = options
+
+  if (!enabled || !Array.isArray(references) || references.length === 0) {
+    return {
+      references: Array.isArray(references) ? references : [],
+      isSpecialized: false,
+      stackSummary: stackInfo.stackSummary || '',
+    }
+  }
+
+  const specialties = getStackPersonaSpecialties(stackInfo)
+  const evolved = references.map((slot, idx) => {
+    // If user already specified a custom non-default persona, preserve it
+    const hasCustom = slot.role_persona && slot.role_persona !== 'general' && slot.role_persona !== 'proposer'
+    if (hasCustom) {
+      return { ...slot }
+    }
+
+    const specialty = specialties[idx % specialties.length]
+    return {
+      ...slot,
+      role_persona: specialty,
+      stackSpecialization: specialty,
+    }
+  })
+
+  return {
+    references: evolved,
+    isSpecialized: Boolean(stackInfo.manifestFound),
+    stackSummary: stackInfo.stackSummary || '',
+  }
+}
+
+/**
+ * Formats a directive summarizing the project stack for injection into judge or synthesis prompts.
+ *
+ * @param {object} stackInfo
+ * @returns {string|null}
+ */
+export function formatStackAwareDirective(stackInfo = {}) {
+  if (!stackInfo || !stackInfo.manifestFound || !stackInfo.stackSummary) {
+    return null
+  }
+
+  return `### Project Stack & Architecture Context
+- Detected Environment: ${stackInfo.stackSummary}
+- Verification Requirement: All proposals must adhere to the conventions and idiomatic idioms of this technology stack.`
+}

package/lib/pipeline/runner.js

@@ -307,7 +307,7 @@ export async function runMoAPipeline({
     }
   }
 
-  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, pruningDirective].filter(Boolean).join("\n\n") || null
+  const fileScoringDirective = [rawFileDirective, visualResult?.directive, adversarialTddResult?.directive, syntaxDirective, pruningDirective, ctxStage.stackAwareDirective, ctxStage.developerPreferencesDirective].filter(Boolean).join("\n\n") || null
 
   // Stage 7: Synthesis Phase
   const synthRes = await stageSynthesis({

package/lib/routes/preferences.js

@@ -0,0 +1,108 @@
+/**
+ * Developer Preferences Management Routes (#309)
+ * Exposes endpoints to inspect, add, toggle, and delete developer coding preferences.
+ */
+
+import {
+  loadDeveloperPreferences,
+  addDeveloperPreference,
+  updateDeveloperPreference,
+  deleteDeveloperPreference,
+} from '../pipeline/developer-preferences.js'
+import { writeJson, readBody, assertAuthorizedRequest } from '../access.js'
+import { isSafeWriteRequest } from '../updater.js'
+
+export function registerPreferencesRoutes(ctx) {
+  // 1. Exact route: /dsh-moa/preferences
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'exact',
+      path: '/dsh-moa/preferences',
+      handler: async (req, res) => {
+        if (!assertAuthorizedRequest(req, res, ctx)) return
+
+        if (req.method === 'GET') {
+          const preferences = loadDeveloperPreferences()
+          return writeJson(res, 200, { ok: true, preferences })
+        }
+
+        if (req.method === 'POST') {
+          if (!isSafeWriteRequest(req)) {
+            return writeJson(res, 403, { ok: false, error: 'Forbidden: cross-site request rejected' })
+          }
+
+          let body = {}
+          try {
+            const raw = await readBody(req)
+            if (raw) body = JSON.parse(raw)
+          } catch (_err) {
+            return writeJson(res, 400, { ok: false, error: 'Malformed JSON payload' })
+          }
+
+          if (body.action === 'delete' && body.id) {
+            const deleted = deleteDeveloperPreference(body.id)
+            return writeJson(res, 200, { ok: true, deleted, id: body.id })
+          }
+
+          if (body.action === 'update' && body.id) {
+            const updated = updateDeveloperPreference(body.id, body.updates || body)
+            if (!updated) return writeJson(res, 404, { ok: false, error: 'Preference not found' })
+            return writeJson(res, 200, { ok: true, preference: updated })
+          }
+
+          const created = addDeveloperPreference(body)
+          if (!created) {
+            return writeJson(res, 400, { ok: false, error: 'Missing required rule field' })
+          }
+          return writeJson(res, 201, { ok: true, preference: created })
+        }
+
+        return writeJson(res, 405, { ok: false, error: 'GET or POST required' })
+      },
+    })
+  })
+
+  // 2. Prefix route: /dsh-moa/preferences/ for REST ID operations
+  ctx.effect(() => {
+    return ctx.webServer.register({
+      kind: 'prefix',
+      path: '/dsh-moa/preferences/',
+      handler: async (req, res) => {
+        if (!assertAuthorizedRequest(req, res, ctx)) return
+
+        const url = new URL(req.url, 'http://127.0.0.1')
+        const id = url.pathname.replace(/^\/dsh-moa\/preferences\//, '').trim()
+
+        if (!id) {
+          return writeJson(res, 400, { ok: false, error: 'Missing preference ID in URL path' })
+        }
+
+        if (req.method === 'DELETE') {
+          if (!isSafeWriteRequest(req)) {
+            return writeJson(res, 403, { ok: false, error: 'Forbidden: cross-site request rejected' })
+          }
+          const deleted = deleteDeveloperPreference(id)
+          return writeJson(res, 200, { ok: true, deleted, id })
+        }
+
+        if (req.method === 'PATCH' || req.method === 'POST') {
+          if (!isSafeWriteRequest(req)) {
+            return writeJson(res, 403, { ok: false, error: 'Forbidden: cross-site request rejected' })
+          }
+          let body = {}
+          try {
+            const raw = await readBody(req)
+            if (raw) body = JSON.parse(raw)
+          } catch {
+            return writeJson(res, 400, { ok: false, error: 'Malformed JSON payload' })
+          }
+          const updated = updateDeveloperPreference(id, body)
+          if (!updated) return writeJson(res, 404, { ok: false, error: 'Preference not found' })
+          return writeJson(res, 200, { ok: true, preference: updated })
+        }
+
+        return writeJson(res, 405, { ok: false, error: 'DELETE or PATCH required' })
+      },
+    })
+  })
+}

package/lib/routes.js

@@ -8,12 +8,14 @@ import { registerHistoryRoutes } from './routes/history.js'
 import { registerWorkbenchRoutes } from './routes/workbench.js'
 import { registerPipelineRoutes } from './routes/pipeline.js'
 import { registerCacheRoutes } from './routes/cache.js'
+import { registerPreferencesRoutes } from './routes/preferences.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 { registerPreferencesRoutes } from './routes/preferences.js'
 
 export function registerMoaRoutes(ctx, deps) {
   registerPresetRoutes(ctx, deps)
@@ -21,4 +23,5 @@ export function registerMoaRoutes(ctx, deps) {
   registerWorkbenchRoutes(ctx, deps)
   registerPipelineRoutes(ctx, deps)
   registerCacheRoutes(ctx, deps)
+  registerPreferencesRoutes(ctx, deps)
 }

package/package.json

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