dsh-math-modeling-agent 0.3.1 → 0.5.0

package/skills/math-modeling-audit/scripts/mcm-score.mjs

@@ -1,218 +1,293 @@
-import { readFile } from 'node:fs/promises'
-import { pathToFileURL } from 'node:url'
-
-export const RUBRIC = {
-  '1.summary': 4,
-  '1.understanding': 3,
-  '1.assumptions': 3,
-  '2.data-source': 3,
-  '2.preprocessing': 2,
-  '2.bias-leakage': 2,
-  '2.parameter-calibration': 3,
-  '2.consistency': 2,
-  '3.mechanism': 5,
-  '3.innovation': 4,
-  '3.formulation': 4,
-  '3.internal-consistency': 3,
-  '3.complexity-explainability': 3,
-  '3.multi-problem-unity': 3,
-  '4.derivation': 4,
-  '4.algorithm-numerics': 4,
-  '4.reproducibility': 3,
-  '4.complexity-convergence-optimality': 3,
-  '4.sanity': 2,
-  '5.task-completion': 4,
-  '5.numerical-consistency': 4,
-  '5.baselines': 3,
-  '5.sensitivity': 4,
-  '5.robustness-uncertainty': 4,
-  '5.independent-validation': 3,
-  '5.failure-cases': 2,
-  '6.conclusions': 3,
-  '6.actionability': 2,
-  '6.limitations': 2,
-  '6.transferability': 1,
-  '7.structure': 2,
-  '7.figures': 2,
-  '7.language': 1,
-  '7.notation': 1,
-  '7.citations': 1,
-  '7.page-efficiency': 1,
-}
-
-const CAP_VALUES = {
-  MATH_ERROR: 69,
-  CORE_UNVALIDATED: 84,
-  UNSUPPORTED_SENSITIVE_PARAMETERS: 79,
-  NOT_REPRODUCIBLE: 79,
-  DATA_LEAKAGE: 69,
-  CONCLUSION_CONFLICT: 74,
-  NO_QUANTITATIVE_RESULTS: 59,
-}
-
-const CEILING_VALUES = {
-  MISSING_CORE_TASK: 'Meritorious',
-}
-
-const OUTSTANDING_GATES = [
-  'taskComplete',
-  'noMajorError',
-  'coreValidated',
-  'meaningfulSensitivity',
-  'parametersSupported',
-  'summaryStrong',
-  'nonTemplateModeling',
-  'closedLoop',
-  'reproducible',
-  'memorableContribution',
-]
-
-const BAND_ORDER = [
-  'Unsuccessful Risk',
-  'Successful Participant',
-  'Honorable Mention',
-  'Meritorious',
-  'Finalist',
-  'Outstanding Candidate',
-]
-
-function requireEvidence(value, label) {
-  const items = Array.isArray(value) ? value : [value]
-  if (!items.length || items.some((item) => typeof item !== 'string' || !item.trim())) {
-    throw new TypeError(label + ' requires evidence')
-  }
-}
-
-function scoreBand(score) {
-  if (score >= 93) return 'Outstanding Candidate'
-  if (score >= 87) return 'Finalist'
-  if (score >= 78) return 'Meritorious'
-  if (score >= 68) return 'Honorable Mention'
-  if (score >= 55) return 'Successful Participant'
-  return 'Unsuccessful Risk'
-}
-
-function lowerBand(left, right) {
-  return BAND_ORDER[Math.min(BAND_ORDER.indexOf(left), BAND_ORDER.indexOf(right))]
-}
-
-function validateScores(scores) {
-  const expected = Object.keys(RUBRIC).sort()
-  const actual = Object.keys(scores ?? {}).sort()
-  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
-    throw new TypeError('scores must contain every rubric subcriterion exactly once')
-  }
-
-  let total = 0
-  const categories = {}
-  for (const [id, maximum] of Object.entries(RUBRIC)) {
-    const entry = scores[id]
-    if (!Number.isFinite(entry.score) || entry.score < 0 || entry.score > maximum) {
-      throw new TypeError(id + ' score must be between 0 and ' + maximum)
-    }
-    requireEvidence(entry.evidence, id)
-    total += entry.score
-    const category = id.split('.')[0]
-    categories[category] = (categories[category] ?? 0) + entry.score
-  }
-  return { total, categories }
-}
-
-function validateRubricTotal() {
-  const maximum = Object.values(RUBRIC).reduce((sum, value) => sum + value, 0)
-  if (maximum !== 100) throw new TypeError('rubric maxima must total 100')
-}
-
-function validateOutstandingGates(gates) {
-  for (const gate of OUTSTANDING_GATES) {
-    if (typeof gates?.[gate] !== 'boolean') {
-      throw new TypeError('missing Outstanding gate: ' + gate)
-    }
-  }
-  return OUTSTANDING_GATES.every((gate) => gates[gate])
-}
-
-export function scoreReview(input) {
-  if (input.schemaVersion !== 1) throw new TypeError('unsupported schemaVersion')
-  validateRubricTotal()
-
-  if (input.disqualificationRisk) {
-    requireEvidence(input.disqualificationRisk.evidence, 'disqualification risk')
-    return {
-      schemaVersion: 1,
-      disqualification: true,
-      disqualificationRisk: input.disqualificationRisk,
-      categoryScores: null,
-      rawScore: null,
-      caps: [],
-      strictestCap: null,
-      cappedScore: null,
-      awardCeiling: null,
-      outstandingGatePassed: null,
-      finalBand: 'Disqualification Risk',
-    }
-  }
-
-  const { total: rawScore, categories } = validateScores(input.scores)
-  const outstandingGatePassed = validateOutstandingGates(input.outstandingGates)
-
-  const caps = (input.caps ?? []).map((entry) => {
-    if (!(entry.code in CAP_VALUES)) throw new TypeError('unknown cap code: ' + entry.code)
-    requireEvidence(entry.evidence, 'cap ' + entry.code)
-    return { ...entry, maximum: CAP_VALUES[entry.code] }
-  })
-  const strictestCap = caps.length
-    ? Math.min(...caps.map((entry) => entry.maximum))
-    : 100
-  const cappedScore = Math.min(rawScore, strictestCap)
-
-  const ceilings = (input.awardCeilings ?? []).map((entry) => {
-    if (!(entry.code in CEILING_VALUES)) {
-      throw new TypeError('unknown award ceiling code: ' + entry.code)
-    }
-    requireEvidence(entry.evidence, 'award ceiling ' + entry.code)
-    return { ...entry, maximumBand: CEILING_VALUES[entry.code] }
-  })
-
-  let awardCeiling = ceilings.length
-    ? ceilings
-      .map((entry) => entry.maximumBand)
-      .reduce((current, value) => lowerBand(current, value), 'Outstanding Candidate')
-    : 'Outstanding Candidate'
-  if (!outstandingGatePassed) awardCeiling = lowerBand(awardCeiling, 'Finalist')
-
-  const rawBand = scoreBand(rawScore)
-  const cappedBand = scoreBand(cappedScore)
-  const finalBand = lowerBand(cappedBand, awardCeiling)
-
-  return {
-    schemaVersion: 1,
-    disqualification: false,
-    disqualificationRisk: null,
-    categoryScores: categories,
-    rawScore,
-    caps,
-    strictestCap,
-    cappedScore,
-    rawBand,
-    cappedBand,
-    awardCeiling,
-    outstandingGatePassed,
-    finalBand,
-  }
-}
-
-async function main() {
-  const path = process.argv[2]
-  if (!path) throw new Error('usage: mcm-score.mjs <review-score.json>')
-  const input = JSON.parse(await readFile(path, 'utf8'))
-  process.stdout.write(JSON.stringify(scoreReview(input), null, 2) + '\n')
-}
-
-const invokedPath = process.argv[1]
-if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) {
-  main().catch((error) => {
-    process.stderr.write(error.message + '\n')
-    process.exitCode = 1
-  })
-}
+import { readFile } from 'node:fs/promises'
+import { pathToFileURL } from 'node:url'
+
+export const RUBRIC = {
+  '1.summary': 4,
+  '1.understanding': 3,
+  '1.assumptions': 3,
+  '2.data-source': 3,
+  '2.preprocessing': 2,
+  '2.bias-leakage': 2,
+  '2.parameter-calibration': 3,
+  '2.consistency': 2,
+  '3.mechanism': 5,
+  '3.innovation': 4,
+  '3.formulation': 4,
+  '3.internal-consistency': 3,
+  '3.complexity-explainability': 3,
+  '3.multi-problem-unity': 3,
+  '4.derivation': 4,
+  '4.algorithm-numerics': 4,
+  '4.reproducibility': 3,
+  '4.complexity-convergence-optimality': 3,
+  '4.sanity': 2,
+  '5.task-completion': 4,
+  '5.numerical-consistency': 4,
+  '5.baselines': 3,
+  '5.sensitivity': 4,
+  '5.robustness-uncertainty': 4,
+  '5.independent-validation': 3,
+  '5.failure-cases': 2,
+  '6.conclusions': 3,
+  '6.actionability': 2,
+  '6.limitations': 2,
+  '6.transferability': 1,
+  '7.structure': 2,
+  '7.figures': 2,
+  '7.language': 1,
+  '7.notation': 1,
+  '7.citations': 1,
+  '7.page-efficiency': 1,
+}
+
+const CAP_VALUES = {
+  MATH_ERROR: 69,
+  CORE_UNVALIDATED: 84,
+  UNSUPPORTED_SENSITIVE_PARAMETERS: 79,
+  NOT_REPRODUCIBLE: 79,
+  DATA_LEAKAGE: 69,
+  CONCLUSION_CONFLICT: 74,
+  NO_QUANTITATIVE_RESULTS: 59,
+}
+
+const CEILING_VALUES = {
+  MISSING_CORE_TASK: 'Meritorious',
+}
+
+const OUTSTANDING_GATES = [
+  'taskComplete',
+  'noMajorError',
+  'coreValidated',
+  'meaningfulSensitivity',
+  'parametersSupported',
+  'summaryStrong',
+  'nonTemplateModeling',
+  'closedLoop',
+  'reproducible',
+  'memorableContribution',
+]
+
+const BAND_ORDER = [
+  'Unsuccessful Risk',
+  'Successful Participant',
+  'Honorable Mention',
+  'Meritorious',
+  'Finalist',
+  'Outstanding Candidate',
+]
+
+function requireEvidence(value, label) {
+  const items = Array.isArray(value) ? value : [value]
+  if (!items.length || items.some((item) => typeof item !== 'string' || !item.trim())) {
+    throw new TypeError(label + ' requires evidence')
+  }
+}
+
+function scoreBand(score) {
+  if (score >= 93) return 'Outstanding Candidate'
+  if (score >= 87) return 'Finalist'
+  if (score >= 78) return 'Meritorious'
+  if (score >= 68) return 'Honorable Mention'
+  if (score >= 55) return 'Successful Participant'
+  return 'Unsuccessful Risk'
+}
+
+function lowerBand(left, right) {
+  return BAND_ORDER[Math.min(BAND_ORDER.indexOf(left), BAND_ORDER.indexOf(right))]
+}
+
+function validateScores(scores) {
+  const expected = Object.keys(RUBRIC).sort()
+  const actual = Object.keys(scores ?? {}).sort()
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) {
+    throw new TypeError('scores must contain every rubric subcriterion exactly once')
+  }
+
+  let total = 0
+  const categories = {}
+  for (const [id, maximum] of Object.entries(RUBRIC)) {
+    const entry = scores[id]
+    if (!Number.isFinite(entry.score) || entry.score < 0 || entry.score > maximum) {
+      throw new TypeError(id + ' score must be between 0 and ' + maximum)
+    }
+    requireEvidence(entry.evidence, id)
+    total += entry.score
+    const category = id.split('.')[0]
+    categories[category] = (categories[category] ?? 0) + entry.score
+  }
+  return { total, categories }
+}
+
+function validateRubricTotal() {
+  const maximum = Object.values(RUBRIC).reduce((sum, value) => sum + value, 0)
+  if (maximum !== 100) throw new TypeError('rubric maxima must total 100')
+}
+
+function validateOutstandingGates(gates) {
+  for (const gate of OUTSTANDING_GATES) {
+    if (typeof gates?.[gate] !== 'boolean') {
+      throw new TypeError('missing Outstanding gate: ' + gate)
+    }
+  }
+  return OUTSTANDING_GATES.every((gate) => gates[gate])
+}
+
+function validateV2EvidenceRecords(records) {
+  if (!Array.isArray(records)) throw new TypeError('evidence records are required')
+  const ids = new Set()
+  for (const record of records) {
+    if (!record || typeof record !== 'object' || Array.isArray(record)) throw new TypeError('evidence record must be an object')
+    if (typeof record.id !== 'string' || !record.id.trim() || ids.has(record.id)) throw new TypeError('evidence record ids must be unique nonempty strings')
+    if (typeof record.artifactPath !== 'string' || !record.artifactPath.trim()) throw new TypeError('evidence record artifactPath is required')
+    if (typeof record.artifactHash !== 'string' || !/^[a-f0-9]{64}$/i.test(record.artifactHash)) throw new TypeError('evidence record artifactHash must be a SHA-256 hex string')
+    if (record.stale === true || ['STALE', 'WAIVED', 'REFUTED'].includes(record.claimVerdict)) throw new TypeError('stale or unsupported evidence cannot support a score')
+    ids.add(record.id)
+  }
+  return new Map(records.map(record => [record.id, record]))
+}
+
+function requireEvidenceRefs(refs, label, records) {
+  if (!Array.isArray(refs) || refs.length === 0 || refs.some(ref => typeof ref !== 'string' || !ref.trim())) throw new TypeError(label + ' requires evidenceRefs')
+  for (const ref of refs) {
+    const record = records.get(ref)
+    if (!record) throw new TypeError(label + ' references missing evidence artifact: ' + ref)
+    if (record.claimVerdict === 'INCONCLUSIVE' || record.claimVerdict === 'CONDITIONAL') throw new TypeError(label + ' cannot use conditional or inconclusive evidence as PASS')
+  }
+}
+
+function validateV2Scores(scores, records) {
+  const expected = Object.keys(RUBRIC).sort()
+  const actual = Object.keys(scores ?? {}).sort()
+  if (JSON.stringify(actual) !== JSON.stringify(expected)) throw new TypeError('scores must contain every rubric subcriterion exactly once')
+  let total = 0
+  const categories = {}
+  for (const [id, maximum] of Object.entries(RUBRIC)) {
+    const entry = scores[id]
+    if (!Number.isFinite(entry?.score) || entry.score < 0 || entry.score > maximum) throw new TypeError(id + ' score must be between 0 and ' + maximum)
+    requireEvidenceRefs(entry.evidenceRefs, id, records)
+    if (!['SUPPORTED', 'CONDITIONAL', 'INCONCLUSIVE', 'REFUTED'].includes(entry.verdict)) throw new TypeError(id + ' verdict is invalid')
+    if (typeof entry.comment !== 'string' || !entry.comment.trim()) throw new TypeError(id + ' comment is required')
+    total += entry.score
+    const category = id.split('.')[0]
+    categories[category] = (categories[category] ?? 0) + entry.score
+  }
+  return { total, categories }
+}
+
+function scoreReviewV2(input) {
+  if (input.rubricId !== 'mcm-icm-final-judge') throw new TypeError('unsupported rubricId')
+  if (typeof input.rubricVersion !== 'string' || !input.rubricVersion.trim()) throw new TypeError('rubricVersion is required')
+  if (typeof input.rubricHash !== 'string' || !/^[a-f0-9]{64}$/i.test(input.rubricHash)) throw new TypeError('rubricHash must be a SHA-256 hex string')
+  validateRubricTotal()
+  const records = validateV2EvidenceRecords(input.evidence)
+  if (input.disqualificationRisk) {
+    requireEvidenceRefs(input.disqualificationRisk.evidenceRefs, 'disqualification risk', records)
+    return { schemaVersion: 2, rubricId: input.rubricId, rubricVersion: input.rubricVersion, rubricHash: input.rubricHash, disqualification: true, disqualificationRisk: input.disqualificationRisk, categoryScores: null, rawScore: null, caps: [], strictestCap: null, cappedScore: null, awardCeiling: null, outstandingGatePassed: null, finalBand: 'Disqualification Risk' }
+  }
+  const { total: rawScore, categories } = validateV2Scores(input.scores, records)
+  const outstandingGatePassed = validateOutstandingGates(input.outstandingGates)
+  const caps = (input.caps ?? []).map(entry => {
+    if (!(entry.code in CAP_VALUES)) throw new TypeError('unknown cap code: ' + entry.code)
+    requireEvidenceRefs(entry.evidenceRefs, 'cap ' + entry.code, records)
+    return { ...entry, maximum: CAP_VALUES[entry.code] }
+  })
+  const strictestCap = caps.length ? Math.min(...caps.map(entry => entry.maximum)) : 100
+  const cappedScore = Math.min(rawScore, strictestCap)
+  const ceilings = (input.awardCeilings ?? []).map(entry => {
+    if (!(entry.code in CEILING_VALUES)) throw new TypeError('unknown award ceiling code: ' + entry.code)
+    requireEvidenceRefs(entry.evidenceRefs, 'award ceiling ' + entry.code, records)
+    return { ...entry, maximumBand: CEILING_VALUES[entry.code] }
+  })
+  let awardCeiling = ceilings.length ? ceilings.map(entry => entry.maximumBand).reduce((current, value) => lowerBand(current, value), 'Outstanding Candidate') : 'Outstanding Candidate'
+  if (!outstandingGatePassed) awardCeiling = lowerBand(awardCeiling, 'Finalist')
+  const rawBand = scoreBand(rawScore)
+  const cappedBand = scoreBand(cappedScore)
+  return { schemaVersion: 2, rubricId: input.rubricId, rubricVersion: input.rubricVersion, rubricHash: input.rubricHash, disqualification: false, disqualificationRisk: null, categoryScores: categories, rawScore, caps, strictestCap, cappedScore, rawBand, cappedBand, awardCeiling, outstandingGatePassed, finalBand: lowerBand(cappedBand, awardCeiling) }
+}
+
+export function scoreReview(input) {
+  if (input?.schemaVersion === 2 && input.rubricId !== undefined) return scoreReviewV2(input)
+
+  if (input?.schemaVersion !== 1) throw new TypeError('unsupported schemaVersion')
+  validateRubricTotal()
+
+  if (input.disqualificationRisk) {
+    requireEvidence(input.disqualificationRisk.evidence, 'disqualification risk')
+    return {
+      schemaVersion: 1,
+      disqualification: true,
+      disqualificationRisk: input.disqualificationRisk,
+      categoryScores: null,
+      rawScore: null,
+      caps: [],
+      strictestCap: null,
+      cappedScore: null,
+      awardCeiling: null,
+      outstandingGatePassed: null,
+      finalBand: 'Disqualification Risk',
+    }
+  }
+
+  const { total: rawScore, categories } = validateScores(input.scores)
+  const outstandingGatePassed = validateOutstandingGates(input.outstandingGates)
+
+  const caps = (input.caps ?? []).map((entry) => {
+    if (!(entry.code in CAP_VALUES)) throw new TypeError('unknown cap code: ' + entry.code)
+    requireEvidence(entry.evidence, 'cap ' + entry.code)
+    return { ...entry, maximum: CAP_VALUES[entry.code] }
+  })
+  const strictestCap = caps.length
+    ? Math.min(...caps.map((entry) => entry.maximum))
+    : 100
+  const cappedScore = Math.min(rawScore, strictestCap)
+
+  const ceilings = (input.awardCeilings ?? []).map((entry) => {
+    if (!(entry.code in CEILING_VALUES)) {
+      throw new TypeError('unknown award ceiling code: ' + entry.code)
+    }
+    requireEvidence(entry.evidence, 'award ceiling ' + entry.code)
+    return { ...entry, maximumBand: CEILING_VALUES[entry.code] }
+  })
+
+  let awardCeiling = ceilings.length
+    ? ceilings
+      .map((entry) => entry.maximumBand)
+      .reduce((current, value) => lowerBand(current, value), 'Outstanding Candidate')
+    : 'Outstanding Candidate'
+  if (!outstandingGatePassed) awardCeiling = lowerBand(awardCeiling, 'Finalist')
+
+  const rawBand = scoreBand(rawScore)
+  const cappedBand = scoreBand(cappedScore)
+  const finalBand = lowerBand(cappedBand, awardCeiling)
+
+  return {
+    schemaVersion: 1,
+    disqualification: false,
+    disqualificationRisk: null,
+    categoryScores: categories,
+    rawScore,
+    caps,
+    strictestCap,
+    cappedScore,
+    rawBand,
+    cappedBand,
+    awardCeiling,
+    outstandingGatePassed,
+    finalBand,
+  }
+}
+
+async function main() {
+  const path = process.argv[2]
+  if (!path) throw new Error('usage: mcm-score.mjs <review-score.json>')
+  const input = JSON.parse(await readFile(path, 'utf8'))
+  process.stdout.write(JSON.stringify(scoreReview(input), null, 2) + '\n')
+}
+
+const invokedPath = process.argv[1]
+if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) {
+  main().catch((error) => {
+    process.stderr.write(error.message + '\n')
+    process.exitCode = 1
+  })
+}

package/skills/math-modeling-audit/scripts/paper-final-review.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { evidenceRecords, rubricHash, scoreInput } from './project-initial-review.mjs'
+import { scoreReview } from './mcm-score.mjs'
+
+function hashText(text) { return createHash('sha256').update(text, 'utf8').digest('hex') }
+
+function finalSections(text) {
+  return [...text.matchAll(/^###\s+([一二三四五六七八九十百]+、[^\n]+)$/gm)].map(match => match[1])
+}
+
+export async function reviewPaper(paperPath, runRoot) {
+  const paperText = await readFile(paperPath, 'utf8')
+  const ledgerText = await readFile(join(runRoot, 'ledger.json'), 'utf8')
+  const ledger = JSON.parse(ledgerText)
+  const manuscriptSections = finalSections(paperText)
+  const hash = await rubricHash()
+  const score = scoreReview(scoreInput(ledger, hash))
+  const findings = manuscriptSections.length === 14 ? [] : [{ code: 'PAPER_SECTION_MISSING', severity: 'P1', message: 'the final manuscript must contain all fourteen panel sections' }]
+  const result = {
+    mode: 'PAPER_FINAL_REVIEW',
+    paperPath,
+    paperHash: hashText(paperText),
+    evidenceGraphHash: hashText(ledgerText),
+    rubricHash: hash,
+    sectionCount: manuscriptSections.length,
+    score,
+    categoryScores: score.categoryScores,
+    findings,
+    evidenceCount: evidenceRecords(ledger).length,
+  }
+  const outputRoot = join(runRoot, 'review')
+  await mkdir(outputRoot, { recursive: true })
+  await writeFile(join(outputRoot, 'final-panel.md'), '# Paper Final Review\n\n' + JSON.stringify(result, null, 2) + '\n', 'utf8')
+  await writeFile(join(outputRoot, 'final-score.json'), JSON.stringify(score, null, 2) + '\n', 'utf8')
+  return result
+}

package/skills/math-modeling-audit/scripts/project-initial-review.mjs

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+import { createHash } from 'node:crypto'
+import { mkdir, readFile, stat, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { RUBRIC, scoreReview } from './mcm-score.mjs'
+
+const OUTSTANDING_KEYS = ['taskComplete', 'noMajorError', 'coreValidated', 'meaningfulSensitivity', 'parametersSupported', 'summaryStrong', 'nonTemplateModeling', 'closedLoop', 'reproducible', 'memorableContribution']
+
+function hashText(text) { return createHash('sha256').update(text, 'utf8').digest('hex') }
+export async function rubricHash() { return hashText(await readFile(new URL('../references/mcm-icm-final-judge.md', import.meta.url), 'utf8')) }
+async function hasDirectory(path) { try { return (await stat(path)).isDirectory() } catch (error) { if (error.code === 'ENOENT') return false; throw error } }
+export function evidenceRecords(graph) {
+  return (graph.evidence ?? []).map(record => {
+    const rawHash = Object.values(record.outputHashes ?? {})[0] ?? ''
+    const artifactHash = rawHash.replace(/^sha256:/i, '')
+    return { id: record.id, artifactPath: record.artifactPath, artifactHash, claimVerdict: record.level === 'LEGACY_UNVERIFIED' ? 'INCONCLUSIVE' : 'SUPPORTED', stale: false }
+  }).filter(record => /^[a-f0-9]{64}$/i.test(record.artifactHash))
+}
+export function scoreInput(graph, hash) {
+  const evidence = evidenceRecords(graph)
+  const evidenceId = evidence[0]?.id
+  const scores = Object.fromEntries(Object.entries(RUBRIC).map(([id]) => [id, { score: 0, evidenceRefs: evidenceId ? [evidenceId] : [], verdict: evidenceId ? 'SUPPORTED' : 'INCONCLUSIVE', comment: evidenceId ? 'Project initial review baseline.' : 'No evidence artifact recorded.' }]))
+  return { schemaVersion: 2, rubricId: 'mcm-icm-final-judge', rubricVersion: '2026-09-02', rubricHash: hash, evidence, scores, caps: [], awardCeilings: [], outstandingGates: Object.fromEntries(OUTSTANDING_KEYS.map(key => [key, evidence.length > 0])) }
+}
+
+export async function reviewProject(runRoot) {
+  const ledger = JSON.parse(await readFile(join(runRoot, 'ledger.json'), 'utf8'))
+  const hash = await rubricHash()
+  const score = evidenceRecords(ledger).length ? scoreReview(scoreInput(ledger, hash)) : null
+  const paperComplete = await hasDirectory(join(runRoot, 'paper-evidence'))
+  const findings = []
+  if (!paperComplete) findings.push({ code: 'PAPER_EVIDENCE_INCOMPLETE', severity: 'P1', message: 'paper-evidence package is missing; model claims are not rewritten' })
+  if (!ledger.evidence?.length) findings.push({ code: 'EVIDENCE_MISSING', severity: 'P0', message: 'no evidence artifacts are linked in the graph' })
+  const outputRoot = join(runRoot, 'review')
+  await mkdir(outputRoot, { recursive: true })
+  const result = { mode: 'PROJECT_INITIAL_REVIEW', paperStatus: paperComplete ? 'READY' : 'INCOMPLETE', score, findings, evidenceGraphHash: hashText(JSON.stringify(ledger)), claimCount: (ledger.claims ?? []).length }
+  await writeFile(join(outputRoot, 'project-initial.md'), '# Project Initial Review\n\n' + JSON.stringify(result, null, 2) + '\n', 'utf8')
+  await writeFile(join(outputRoot, 'score.json'), JSON.stringify(score, null, 2) + '\n', 'utf8')
+  return result
+}