dsh-math-modeling-agent 0.5.1 → 0.5.2

package/README.md

@@ -155,7 +155,7 @@ LEGACY_UNVERIFIED → DERIVED → EXECUTED → VERIFIED → INDEPENDENTLY_VERIFI
 
 **SOLVED 硬门禁**：范围冻结 + 必选 verification 通过并聚合为 `SATISFIED` 的 obligations + `SUPPORTED` claims + 关键对抗检查通过 + 可复现材料齐全 + 局限已声明；High-Assurance 还需独立审计（审计器只读产物，不依赖求解过程的私有推理）。
 
-## 当前版本：v0.5.1 Evidence-driven pipeline
+## 当前版本：v0.5.2 Evidence-driven pipeline
 
 本版本新增：v3 run/ledger evidence graph；独立的 verification / obligation / claim / run 状态；inputs/raw 冻结快照和 SHA-256 校验；typed verification recipes；真实输出量化后的硬约束复检；九段科学报告、symbols 和 Answer Coverage；结构化失败启发；PROJECT_INITIAL_REVIEW 与 PAPER_FINAL_REVIEW 两种论文质量评审；以及不修改父 run 的 correction lineage。
 
@@ -212,7 +212,7 @@ D3 方向/D4 裁决），`run-state.mjs gate` 在每次状态转移前强制校
 安装：
 
 ```bash
-dsh plugin --profile web add github:yohanchen1/MathModelingAgent#v0.5.1
+dsh plugin --profile web add github:yohanchen1/MathModelingAgent#v0.5.2
 dsh --profile web --dump-config   # 检查组合层（应看到 dsh-math-modeling-agent-skills 行）
 dsh web                          # 重启以加载插件
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-math-modeling-agent",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Evidence-driven mathematical modeling and verification skills for DeepSeek Harness",
   "type": "module",
   "files": [

package/skills/math-modeling-agent/schemas/ledger.schema.json

@@ -48,6 +48,10 @@
           "type": "boolean",
           "description": "Require complete chat presentation and user confirmation before each major phase transition."
         },
+        "structuredQuestionsRequired": {
+          "type": "boolean",
+          "description": "Require each L1 decision to originate from the ask_user_question tool."
+        },
         "presentations": {
           "type": "array",
           "description": "Chat-first records: complete text presented, content hash, user confirmation and presentation order.",

package/skills/math-modeling-agent/scripts/evidence-store.mjs

@@ -258,7 +258,7 @@ export function createGraph(taskId) {
   return {
     schemaVersion: 3,
     taskId,
-    scope: { independentAuditPassed: false, interactions: [], decisionStack: [], robustnessExempt: false, chatFirstRequired: true, presentations: [] },
+    scope: { independentAuditPassed: false, interactions: [], decisionStack: [], robustnessExempt: false, chatFirstRequired: true, structuredQuestionsRequired: true, presentations: [] },
     requirements: [],
     assumptions: [],
     claims: [],

package/skills/math-modeling-agent/scripts/run-state.mjs

@@ -20,6 +20,9 @@ export const CHAT_PHASE_REQUIREMENTS = Object.freeze({
   EVALUATE: 'EVALUATION', CORRECTION_REQUIRED: 'CORRECTION', REVISE: 'CORRECTION',
   SOLVED: 'D4', CONDITIONAL: 'D4', PARTIAL: 'D4', INCONCLUSIVE: 'D4', REFUTED: 'D4',
 })
+export const CHAT_DECISION_REQUIREMENTS = Object.freeze({
+  D1: 'D1', 'D-R': 'D-R', D0: 'D0', 'D2-G': 'D2-G', D2: 'D2', "D2'": "D2'", D3: 'D3', D4: 'D4',
+})
 
 const NON_FINAL_STATES = ['TRIAGE', 'SCOPE_FROZEN', 'INPUT_PROFILED', 'CLAIMS_REGISTERED', 'CANDIDATES_READY', 'ATTEMPT', 'EXECUTE', 'VERIFY', 'EVALUATE', 'CORRECTION_REQUIRED', 'REVISE', 'RESEARCH', 'FORK']
 const FINAL_STATES = ['SOLVED', 'PARTIAL', 'CONDITIONAL', 'INCONCLUSIVE', 'REFUTED', 'INFEASIBLE', 'UNIDENTIFIABLE', 'BLOCKED', 'CANCELLED']
@@ -404,7 +407,7 @@ export async function initRun(root, { taskId, mode = 'standard', budget, budgets
     }
     const ledger = {
       schemaVersion: SCHEMA_VERSION, taskId,
-      scope: { independentAuditPassed: false, interactions: [], decisionStack: [], robustnessExempt: false, chatFirstRequired: chatFirstRequired === true, presentations: [], ...(contract === false ? { contractExempt: true } : {}) },
+      scope: { independentAuditPassed: false, interactions: [], decisionStack: [], robustnessExempt: false, chatFirstRequired: chatFirstRequired === true, structuredQuestionsRequired: chatFirstRequired === true, presentations: [], ...(contract === false ? { contractExempt: true } : {}) },
       assumptions: [], claims: [], obligations: [], subproblems: [], candidates: [], issues: [],
       requirements: [], evidence: [], verifications: [], failures: [],
     }
@@ -506,13 +509,46 @@ export function classifyGate(graph, targetState) {
   return { allowed: blockers.length === 0 && (targetState !== 'SOLVED' || conditionals.length === 0), blockers, conditionals, requiredNextState: blockers.length > 0 ? 'REVISE' : (conditionals.length > 0 ? 'CONDITIONAL' : targetState) }
 }
 
-/** The v3 interaction contract: decision records, layered verdicts, and the robustness gate. */
+function hasStructuredAnswer(value) {
+  if (typeof value === 'string') return value.trim() !== ''
+  if (Array.isArray(value)) return value.length > 0
+  return isObject(value) && Object.keys(value).length > 0
+}
+
+function decisionPresentationMatches(presentation, decisionPoint, subproblem) {
+  if (!presentationIsValid(presentation, presentation?.stage, presentation?.subproblem)) return false
+  if (decisionPoint === 'D2' || decisionPoint === "D2'") return presentation.stage === decisionPoint || presentation.stage === subproblem
+  return presentation.stage === CHAT_DECISION_REQUIREMENTS[decisionPoint]
+}
+
+function structuredDecisionIsValid(scope, record, decisionPoint, subproblem) {
+  if (!record || record.decisionPoint !== decisionPoint || record.answerSource !== 'ask_user_question') return false
+  for (const field of ['id', 'questionId', 'responseId', 'userAnswer', 'presentationId', 'presentedAt', 'userConfirmedAt']) {
+    if (typeof record[field] !== 'string' || record[field].trim() === '') return false
+  }
+  if (!hasStructuredAnswer(record.structuredAnswer)) return false
+  if ((decisionPoint === 'D2' || decisionPoint === "D2'") && (typeof subproblem !== 'string' || record.subproblem !== subproblem)) return false
+  const presentation = Array.isArray(scope?.presentations) ? scope.presentations.find(value => value?.id === record.presentationId) : null
+  return decisionPresentationMatches(presentation, decisionPoint, record.subproblem)
+}
+
+function hasStructuredDecision(scope, decisionPoint, subproblem) {
+  return Array.isArray(scope?.interactions) && scope.interactions.some(record => structuredDecisionIsValid(scope, record, decisionPoint, subproblem))
+}
+
+function structuredDecisionViolations(scope, target, subproblem) {
+  if (scope?.structuredQuestionsRequired !== true) return []
+  const required = target === 'SCOPE_FROZEN' ? ['D1', 'D-R', 'D0'] : (target === 'CLAIMS_REGISTERED' ? ['D2-G'] : (target === 'CANDIDATES_READY' ? ['D3'] : (target === 'ATTEMPT' ? ['D2'] : (['SOLVED', 'CONDITIONAL', 'PARTIAL', 'INCONCLUSIVE', 'REFUTED', 'INFEASIBLE', 'UNIDENTIFIABLE'].includes(target) ? ['D4'] : []))))
+  return required.filter(point => !hasStructuredDecision(scope, point, point === 'D2' ? subproblem : undefined)).map(point => 'structured ask_user_question decision for ' + point + (subproblem ? ' / ' + subproblem : '') + ' is required before ' + target)
+}
+
 function hasDecisionRecord(scope, decisionPoint, { allowAuto = true } = {}) {
   return Array.isArray(scope?.interactions) && scope.interactions.some(entry =>
     entry && (entry.decisionPoint === decisionPoint || (allowAuto && entry.auto === true)))
 }
 /** D4 verdict records carry the attempt number they adjudicate: {decisionPoint:'D4', attempt: 2, ...} */
 function hasD4ForAttempt(scope, attempt) {
+  if (scope?.structuredQuestionsRequired === true) return hasStructuredDecision(scope, 'D4') && scope.interactions.some(entry => entry.decisionPoint === 'D4' && entry.attempt === attempt)
   return Array.isArray(scope?.interactions) && scope.interactions.some(entry =>
     entry && (entry.auto === true || (entry.decisionPoint === 'D4' && entry.attempt === attempt)))
 }
@@ -556,6 +592,7 @@ function interactionContractViolations(run, ledger, to, reason, subproblem) {
   const transitional = to !== undefined
   const presentationTarget = transitional ? to : run.status
   violations.push(...chatPresentationViolations(scope, presentationTarget, subproblem))
+  violations.push(...structuredDecisionViolations(scope, presentationTarget, subproblem))
   const earlyStop = ['BLOCKED', 'CANCELLED'].includes(run.status)
   const statusOrder = ['TRIAGE', 'RESEARCH', 'SCOPE_FROZEN', 'INPUT_PROFILED', 'CLAIMS_REGISTERED', 'CANDIDATES_READY', 'ATTEMPT', 'EXECUTE', 'VERIFY', 'EVALUATE', 'CORRECTION_REQUIRED', 'REVISE', 'FORK']
   const reached = (target) => transitional
@@ -652,7 +689,7 @@ function validateAuthoritativeState(run, ledger, events) {
   if (diagnostics.length > 0) throw new Error(`invalid run state: ${diagnostics.join('; ')}`)
 }
 
-const PRESENTATION_STAGES = new Set(['D-R', ...new Set(Object.values(CHAT_PHASE_REQUIREMENTS))])
+const PRESENTATION_STAGES = new Set(['D-R', ...new Set(Object.values(CHAT_PHASE_REQUIREMENTS)), ...new Set(Object.values(CHAT_DECISION_REQUIREMENTS))])
 
 function validateChatPresentationRecord(record) {
   if (!isObject(record)) throw new TypeError('chat presentation must be an object')
@@ -685,6 +722,34 @@ export async function recordChatPresentation(root, record, runtime = {}) {
   }, runtime)
 }
 
+function validateStructuredDecisionRecord(record, ledger) {
+  if (!isObject(record)) throw new TypeError('structured decision must be an object')
+  const decisionPoint = record.decisionPoint
+  if (!Object.hasOwn(CHAT_DECISION_REQUIREMENTS, decisionPoint)) throw new TypeError('decisionPoint is not a structured decision point')
+  if (decisionPoint === 'D2' || decisionPoint === "D2'") {
+    if (typeof record.subproblem !== 'string' || record.subproblem.trim() === '') throw new TypeError(decisionPoint + ' requires subproblem')
+  }
+  if (decisionPoint === 'D4' && (!Number.isInteger(record.attempt) || record.attempt < 1)) throw new TypeError('D4 requires a positive attempt')
+  if (!structuredDecisionIsValid(ledger.scope, record, decisionPoint, record.subproblem)) throw new TypeError('structured decision must come from ask_user_question and link a valid chat presentation')
+  return record
+}
+
+export async function recordStructuredDecision(root, record, runtime = {}) {
+  return withLock(root, MUTATION_LOCK_FILE, 'structured-decision', async () => {
+    const p = paths(root)
+    const ledger = await readJson(p.ledger)
+    if (ledger.schemaVersion !== SCHEMA_VERSION) throw new Error('structured decisions require a v3 ledger')
+    validateStructuredDecisionRecord(record, ledger)
+    ledger.scope ??= {}
+    ledger.scope.interactions ??= []
+    if (!Array.isArray(ledger.scope.interactions)) throw new Error('ledger.scope.interactions must be an array')
+    if (ledger.scope.interactions.some(value => value?.id === record.id)) throw new Error('duplicate structured decision id: ' + record.id)
+    ledger.scope.interactions.push(clone(record))
+    await atomicWrite(p.ledger, ledger, runtime)
+    return clone(record)
+  }, runtime)
+}
+
 export async function transitionRun(root, input, runtime = {}) {
   validateTransitionInput(input)
   return withLock(root, MUTATION_LOCK_FILE, 'transition', async () => {