dsh-math-modeling-agent 0.1.1 → 0.1.2

package/docs/superpowers/plans/2026-08-22-math-modeling-dsh-plugin.md

@@ -1,3303 +0,0 @@
-# MathModelingAgent DSH Plugin Implementation Plan
-
-> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
-
-**Goal:** Build and verify a minimal, installable DSH bundle that provides evidence-driven mathematical modeling, independent auditing, and MCM/ICM final-panel scoring without requiring Python, Lean, or Wolfram at install time.
-
-**Architecture:** Ship exactly two public Skills through the official `@deepseek-ai/dsh-skill-filesystem` bundle seam. Keep deterministic state, capability, Python-environment, and score arithmetic behind four small Node modules; keep mathematical judgment in selective Markdown references and require artifact-backed verification before any strong status.
-
-**Tech Stack:** DSH bundle manifest and Cordis patch, Node.js ESM and built-in `node:test`, Markdown/YAML/JSON/JSONL, optional uv/Python, optional Lean/Lake, optional WolframScript.
-
----
-
-## Scope decision
-
-This remains one implementation plan because every task contributes to one installable package and one release gate. The MCM/ICM scorer is an internal mode of `math-modeling-audit`, not an independently deployed subsystem.
-
-## Locked file map
-
-- Create: `package.json` — npm metadata and `dsh.bundle.patch` declaration only.
-- Create: `cordis.patch.yml` — mount the packaged Skill root through the official filesystem provider.
-- Create: `.gitignore` — ignore only generated dependencies, packages, coverage, and run artifacts.
-- Create: `LICENSE` — MIT license.
-- Create: `README.md` — single concise bilingual user and contributor guide.
-- Create: `skills/math-modeling-agent/SKILL.md` — sole solve/resume interface.
-- Create: `skills/math-modeling-agent/references/*.md` — one authoritative file per internal policy.
-- Create: `skills/math-modeling-agent/scripts/capability-probe.mjs` — read-only PATH capability discovery.
-- Create: `skills/math-modeling-agent/scripts/python-environment.mjs` — run-local Python environment creation.
-- Create: `skills/math-modeling-agent/scripts/run-state.mjs` — atomic state, transition journal, validation, and recovery.
-- Create: `skills/math-modeling-agent/schemas/*.json` — versioned run, ledger, and attempt contracts.
-- Create: `skills/math-modeling-agent/examples/*` — minimal and resumed golden runs only.
-- Create: `skills/math-modeling-audit/SKILL.md` — independent audit and MCM/ICM judging interface.
-- Create: `skills/math-modeling-audit/references/*.md` — verification, evidence, data/citation, and final-judge protocols.
-- Create: `skills/math-modeling-audit/scripts/mcm-score.mjs` — deterministic 100-point arithmetic and cap enforcement.
-- Create: `skills/math-modeling-audit/examples/*.md` — one generic audit and one MCM final-review example.
-- Create: `tests/*.test.mjs` — one focused test file per deterministic module plus package integrity.
-- Preserve: `docs/superpowers/specs/2026-08-22-math-modeling-dsh-plugin-design.md` — approved design source of truth.
-
-### Task 1: Establish the installable DSH bundle shell
-
-**Files:**
-- Create: `tests/plugin-integrity.test.mjs`
-- Create: `package.json`
-- Create: `cordis.patch.yml`
-- Create: `.gitignore`
-- Create: `LICENSE`
-
-- [ ] **Step 1: Write the failing bundle-integrity test**
-
-Create `tests/plugin-integrity.test.mjs`:
-
-~~~javascript
-import assert from 'node:assert/strict'
-import { readFile } from 'node:fs/promises'
-import { dirname, resolve } from 'node:path'
-import test from 'node:test'
-import { fileURLToPath } from 'node:url'
-
-const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
-
-async function read(relativePath) {
-  return readFile(resolve(ROOT, relativePath), 'utf8')
-}
-
-test('package declares a dependency-free DSH bundle', async () => {
-  const manifest = JSON.parse(await read('package.json'))
-
-  assert.equal(manifest.name, 'dsh-math-modeling-agent')
-  assert.equal(manifest.version, '0.1.0')
-  assert.deepEqual(manifest.dsh, {
-    bundle: { patch: './cordis.patch.yml' },
-  })
-  assert.deepEqual(manifest.files, [
-    'cordis.patch.yml',
-    'skills',
-    'README.md',
-    'LICENSE',
-  ])
-  assert.equal(manifest.dependencies, undefined)
-  assert.equal(manifest.scripts.prepare, undefined)
-})
-
-test('Cordis patch mounts only the packaged Skill root', async () => {
-  const patch = await read('cordis.patch.yml')
-
-  assert.match(patch, /name: '@deepseek-ai\/dsh-skill-filesystem'/)
-  assert.match(patch, /providerName: dsh-math-modeling-agent/)
-  assert.match(patch, /includeDefaultRoots: false/)
-  assert.match(patch, /bundledSkillDir:/)
-  assert.match(patch, /new URL\('skills\/', baseUrl\)/)
-  assert.match(patch, /watch: false/)
-  assert.doesNotMatch(patch, /\.claude[\\/]plugins/i)
-  assert.doesNotMatch(patch, /C:[\/]Users[\/]/i)
-})
-~~~
-
-- [ ] **Step 2: Run the test and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: FAIL with `ENOENT` for `package.json` or `cordis.patch.yml`.
-
-- [ ] **Step 3: Create the minimal package manifest**
-
-Create `package.json`:
-
-~~~json
-{
-  "name": "dsh-math-modeling-agent",
-  "version": "0.1.0",
-  "description": "Evidence-driven mathematical modeling and verification skills for DeepSeek Harness",
-  "type": "module",
-  "files": [
-    "cordis.patch.yml",
-    "skills",
-    "README.md",
-    "LICENSE"
-  ],
-  "scripts": {
-    "test": "node --test",
-    "pack:check": "npm pack --dry-run --json"
-  },
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/yohanchen1/MathModelingAgent.git"
-  },
-  "keywords": [
-    "dsh",
-    "mathematical-modeling",
-    "verification",
-    "lean",
-    "wolfram",
-    "python"
-  ],
-  "dsh": {
-    "bundle": {
-      "patch": "./cordis.patch.yml"
-    }
-  }
-}
-~~~
-
-- [ ] **Step 4: Create the package-relative Cordis patch**
-
-Create `cordis.patch.yml`:
-
-~~~yaml
-- insert:
-    - id: dsh-math-modeling-agent-skills
-      name: '@deepseek-ai/dsh-skill-filesystem'
-      config:
-        providerName: dsh-math-modeling-agent
-        includeDefaultRoots: false
-        bundledSkillDir: !!js "process.getBuiltinModule('node:url').fileURLToPath(new URL('skills/', baseUrl))"
-        watch: false
-~~~
-
-- [ ] **Step 5: Add the minimal ignore file and license**
-
-Create `.gitignore`:
-
-~~~gitignore
-node_modules/
-coverage/
-*.tgz
-math-modeling-runs/
-.DS_Store
-Thumbs.db
-~~~
-
-Create `LICENSE`:
-
-~~~text
-MIT License
-
-Copyright (c) 2026 Yohan Chen
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-~~~
-
-- [ ] **Step 6: Run the bundle test and verify GREEN**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: 2 tests PASS, 0 failures.
-
-- [ ] **Step 7: Commit the bundle shell**
-
-~~~bash
-git add package.json cordis.patch.yml .gitignore LICENSE tests/plugin-integrity.test.mjs
-git commit -m "feat: add minimal dsh bundle shell"
-~~~
-
-### Task 2: Add read-only capability discovery
-
-**Files:**
-- Create: `tests/capability-probe.test.mjs`
-- Create: `skills/math-modeling-agent/scripts/capability-probe.mjs`
-
-- [ ] **Step 1: Write failing capability-probe tests**
-
-Create `tests/capability-probe.test.mjs`:
-
-~~~javascript
-import assert from 'node:assert/strict'
-import { chmod, mkdtemp, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { delimiter, join } from 'node:path'
-import test from 'node:test'
-
-import {
-  findExecutable,
-  probeCapabilities,
-} from '../skills/math-modeling-agent/scripts/capability-probe.mjs'
-
-async function fakeExecutable(directory, baseName, platform) {
-  const name = platform === 'win32' ? `${baseName}.cmd` : baseName
-  const path = join(directory, name)
-  await writeFile(
-    path,
-    platform === 'win32' ? '@exit /b 0\r\n' : '#!/bin/sh\nexit 0\n',
-  )
-  if (platform !== 'win32') await chmod(path, 0o755)
-  return path
-}
-
-test('findExecutable returns the first PATH candidate', async () => {
-  const platform = process.platform
-  const directory = await mkdtemp(join(tmpdir(), 'mma-capability-'))
-  const expected = await fakeExecutable(directory, 'uv', platform)
-  const env = {
-    PATH: [directory, process.env.PATH ?? ''].join(delimiter),
-    PATHEXT: '.COM;.EXE;.BAT;.CMD',
-  }
-
-  assert.equal(findExecutable(['uv'], { env, platform }), expected)
-})
-
-test('probeCapabilities reports candidates without executing them', async () => {
-  const platform = process.platform
-  const directory = await mkdtemp(join(tmpdir(), 'mma-capability-'))
-  const uv = await fakeExecutable(directory, 'uv', platform)
-  const lean = await fakeExecutable(directory, 'lean', platform)
-  const env = {
-    PATH: directory,
-    PATHEXT: '.COM;.EXE;.BAT;.CMD',
-  }
-
-  const report = probeCapabilities({ env, platform })
-
-  assert.equal(report.schemaVersion, 1)
-  assert.equal(report.node.status, 'available')
-  assert.deepEqual(report.tools.uv, {
-    status: 'candidate',
-    executable: uv,
-    kind: 'uv',
-    reason: 'Found on PATH; execute through the DSH shell to verify version and usability.',
-  })
-  assert.equal(report.tools.lean.executable, lean)
-  assert.equal(report.tools.wolfram.status, 'unavailable')
-})
-~~~
-
-- [ ] **Step 2: Run the test and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/capability-probe.test.mjs
-~~~
-
-Expected: FAIL with `ERR_MODULE_NOT_FOUND` for `capability-probe.mjs`.
-
-- [ ] **Step 3: Implement PATH-only capability probing**
-
-Create `skills/math-modeling-agent/scripts/capability-probe.mjs`:
-
-~~~javascript
-import { accessSync, constants, existsSync } from 'node:fs'
-import { delimiter, extname, join } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-const REASON = 'Found on PATH; execute through the DSH shell to verify version and usability.'
-
-const TOOL_CANDIDATES = {
-  uv: ['uv'],
-  python: ['python3', 'python', 'py'],
-  lean: ['lean'],
-  lake: ['lake'],
-  wolfram: ['wolframscript', 'WolframScript'],
-}
-
-function executableExtensions(env, platform) {
-  if (platform !== 'win32') return ['']
-  const raw = env.PATHEXT || '.COM;.EXE;.BAT;.CMD'
-  return ['', ...raw.split(';').filter(Boolean).map((value) => value.toLowerCase())]
-}
-
-function candidateNames(name, extensions, platform) {
-  if (platform !== 'win32' || extname(name)) return [name]
-  return extensions.map((extension) => `${name}${extension}`)
-}
-
-function isExecutable(path, platform) {
-  if (!existsSync(path)) return false
-  try {
-    accessSync(path, platform === 'win32' ? constants.F_OK : constants.X_OK)
-    return true
-  } catch {
-    return false
-  }
-}
-
-export function findExecutable(names, options = {}) {
-  const env = options.env ?? process.env
-  const platform = options.platform ?? process.platform
-  const directories = (env.PATH ?? '').split(delimiter).filter(Boolean)
-  const extensions = executableExtensions(env, platform)
-
-  for (const directory of directories) {
-    for (const name of names) {
-      for (const candidate of candidateNames(name, extensions, platform)) {
-        const path = join(directory, candidate)
-        if (isExecutable(path, platform)) return path
-      }
-    }
-  }
-  return undefined
-}
-
-function toolRecord(key, names, options) {
-  const executable = findExecutable(names, options)
-  if (!executable) {
-    return {
-      status: 'unavailable',
-      executable: null,
-      kind: key,
-      reason: 'No candidate executable was found on PATH.',
-    }
-  }
-  return {
-    status: 'candidate',
-    executable,
-    kind: key,
-    reason: REASON,
-  }
-}
-
-export function probeCapabilities(options = {}) {
-  const env = options.env ?? process.env
-  const platform = options.platform ?? process.platform
-  return {
-    schemaVersion: 1,
-    platform,
-    node: {
-      status: 'available',
-      executable: process.execPath,
-      version: process.version,
-    },
-    tools: Object.fromEntries(
-      Object.entries(TOOL_CANDIDATES).map(([key, names]) => [
-        key,
-        toolRecord(key, names, { env, platform }),
-      ]),
-    ),
-  }
-}
-
-function main() {
-  const pretty = process.argv.includes('--pretty')
-  process.stdout.write(
-    `${JSON.stringify(probeCapabilities(), null, pretty ? 2 : 0)}
-`,
-  )
-}
-
-const invokedPath = process.argv[1]
-if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) main()
-~~~
-
-- [ ] **Step 4: Run tests and inspect CLI JSON**
-
-Run:
-
-~~~bash
-node --test tests/capability-probe.test.mjs
-node skills/math-modeling-agent/scripts/capability-probe.mjs --pretty
-~~~
-
-Expected: 2 tests PASS; CLI emits valid JSON with Node available and external tools marked `candidate` or `unavailable`.
-
-- [ ] **Step 5: Commit capability discovery**
-
-~~~bash
-git add tests/capability-probe.test.mjs skills/math-modeling-agent/scripts/capability-probe.mjs
-git commit -m "feat: add deterministic capability discovery"
-~~~
-
-### Task 3: Add versioned run state, transitions, validation, and recovery
-
-**Files:**
-- Create: `skills/math-modeling-agent/schemas/run.schema.json`
-- Create: `skills/math-modeling-agent/schemas/ledger.schema.json`
-- Create: `skills/math-modeling-agent/schemas/attempt.schema.json`
-- Create: `tests/run-state.test.mjs`
-- Create: `tests/recovery.test.mjs`
-- Create: `skills/math-modeling-agent/scripts/run-state.mjs`
-
-- [ ] **Step 1: Write failing state and recovery tests**
-
-Create `tests/run-state.test.mjs`:
-
-~~~javascript
-import assert from 'node:assert/strict'
-import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-
-import {
-  initRun,
-  transitionRun,
-  validateRun,
-} from '../skills/math-modeling-agent/scripts/run-state.mjs'
-
-async function newRoot() {
-  return mkdtemp(join(tmpdir(), 'mma-run-'))
-}
-
-test('initRun creates a valid TRIAGE checkpoint and ledger', async () => {
-  const root = await newRoot()
-  const run = await initRun(root, {
-    taskId: 'sample-task',
-    mode: 'standard',
-  })
-
-  assert.equal(run.status, 'TRIAGE')
-  assert.equal(run.eventSequence, 0)
-  assert.equal(run.currentAttempt, 0)
-
-  const ledger = JSON.parse(await readFile(join(root, 'ledger.json'), 'utf8'))
-  assert.deepEqual(ledger.claims, [])
-  assert.deepEqual(ledger.assumptions, [])
-  assert.deepEqual(ledger.candidates, [])
-  assert.equal((await validateRun(root)).valid, true)
-})
-
-test('transitionRun rejects ATTEMPT-to-SOLVED shortcuts', async () => {
-  const root = await newRoot()
-  await initRun(root, { taskId: 'shortcut-test', mode: 'standard' })
-
-  await assert.rejects(
-    transitionRun(root, {
-      to: 'SOLVED',
-      reason: 'Model says it is correct.',
-      evidenceIds: ['E-001'],
-    }),
-    /illegal transition TRIAGE -> SOLVED/,
-  )
-})
-
-test('legal transitions are evidence-linked and increment attempts', async () => {
-  const root = await newRoot()
-  await initRun(root, { taskId: 'legal-test', mode: 'standard' })
-
-  const sequence = [
-    ['SCOPE_FROZEN', 'I-SCOPE'],
-    ['INPUT_PROFILED', 'E-INPUT'],
-    ['CLAIMS_REGISTERED', 'I-CLAIMS'],
-    ['CANDIDATES_READY', 'I-CANDIDATES'],
-    ['ATTEMPT', 'I-ATTEMPT'],
-  ]
-  for (const [to, reference] of sequence) {
-    await transitionRun(root, {
-      to,
-      reason: `advance to ${to}`,
-      issueIds: [reference],
-    })
-  }
-
-  const status = JSON.parse(await readFile(join(root, 'run.json'), 'utf8'))
-  assert.equal(status.status, 'ATTEMPT')
-  assert.equal(status.currentAttempt, 1)
-  assert.equal(status.eventSequence, 5)
-  assert.equal((await validateRun(root)).valid, true)
-})
-
-test('SOLVED requires claims, passed obligations, and no open critical issues', async () => {
-  const root = await newRoot()
-  await initRun(root, { taskId: 'solved-gate', mode: 'standard' })
-  for (const [to, reference] of [
-    ['SCOPE_FROZEN', 'I-SCOPE'],
-    ['INPUT_PROFILED', 'E-INPUT'],
-    ['CLAIMS_REGISTERED', 'I-CLAIMS'],
-    ['CANDIDATES_READY', 'I-CANDIDATES'],
-    ['ATTEMPT', 'I-ATTEMPT'],
-    ['EXECUTE', 'E-EXECUTE'],
-    ['VERIFY', 'E-VERIFY'],
-  ]) {
-    await transitionRun(root, { to, reason: 'advance', issueIds: [reference] })
-  }
-
-  const ledgerPath = join(root, 'ledger.json')
-  const ledger = JSON.parse(await readFile(ledgerPath, 'utf8'))
-  ledger.claims = [{ id: 'C-001', text: 'x = 4' }]
-  ledger.obligations = [{ id: 'O-001', required: true, status: 'OPEN' }]
-  ledger.issues = []
-  await writeFile(ledgerPath, JSON.stringify(ledger, null, 2))
-
-  await assert.rejects(
-    transitionRun(root, { to: 'SOLVED', reason: 'done', evidenceIds: ['E-VERIFY'] }),
-    /required obligations remain open/,
-  )
-
-  ledger.obligations[0].status = 'PASS'
-  ledger.issues = [{ id: 'I-CRITICAL', severity: 'critical', status: 'OPEN' }]
-  await writeFile(ledgerPath, JSON.stringify(ledger, null, 2))
-  await assert.rejects(
-    transitionRun(root, { to: 'SOLVED', reason: 'done', evidenceIds: ['E-VERIFY'] }),
-    /critical issues remain open/,
-  )
-
-  ledger.issues[0].status = 'CLOSED'
-  await writeFile(ledgerPath, JSON.stringify(ledger, null, 2))
-  const solved = await transitionRun(root, {
-    to: 'SOLVED',
-    reason: 'all obligations passed',
-    evidenceIds: ['E-VERIFY'],
-  })
-  assert.equal(solved.status, 'SOLVED')
-})
-
-test('High-Assurance SOLVED requires an independent audit flag', async () => {
-  const root = await newRoot()
-  await initRun(root, { taskId: 'audit-gate', mode: 'high-assurance' })
-  for (const [to, reference] of [
-    ['SCOPE_FROZEN', 'I-SCOPE'],
-    ['INPUT_PROFILED', 'E-INPUT'],
-    ['CLAIMS_REGISTERED', 'I-CLAIMS'],
-    ['CANDIDATES_READY', 'I-CANDIDATES'],
-    ['ATTEMPT', 'I-ATTEMPT'],
-    ['EXECUTE', 'E-EXECUTE'],
-    ['VERIFY', 'E-VERIFY'],
-  ]) {
-    await transitionRun(root, { to, reason: 'advance', issueIds: [reference] })
-  }
-
-  const ledgerPath = join(root, 'ledger.json')
-  const ledger = JSON.parse(await readFile(ledgerPath, 'utf8'))
-  ledger.claims = [{ id: 'C-001', text: 'verified claim' }]
-  ledger.obligations = [{ id: 'O-001', required: true, status: 'PASS' }]
-  ledger.issues = []
-  ledger.scope.independentAuditPassed = false
-  await writeFile(ledgerPath, JSON.stringify(ledger, null, 2))
-
-  await assert.rejects(
-    transitionRun(root, { to: 'SOLVED', reason: 'done', evidenceIds: ['E-VERIFY'] }),
-    /independent audit/,
-  )
-
-  ledger.scope.independentAuditPassed = true
-  await writeFile(ledgerPath, JSON.stringify(ledger, null, 2))
-  const solved = await transitionRun(root, {
-    to: 'SOLVED',
-    reason: 'audit passed',
-    evidenceIds: ['E-AUDIT'],
-  })
-  assert.equal(solved.status, 'SOLVED')
-})
-~~~
-
-Create `tests/recovery.test.mjs`:
-
-~~~javascript
-import assert from 'node:assert/strict'
-import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-
-import {
-  initRun,
-  recoverRun,
-  transitionRun,
-  validateRun,
-} from '../skills/math-modeling-agent/scripts/run-state.mjs'
-
-test('recoverRun restores the last journal snapshot without losing best candidate', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'mma-recovery-'))
-  await initRun(root, { taskId: 'recovery-test', mode: 'high-assurance' })
-  await transitionRun(root, {
-    to: 'SCOPE_FROZEN',
-    reason: 'Scope accepted.',
-    issueIds: ['I-SCOPE'],
-    patch: { bestCandidateId: 'C-007' },
-  })
-
-  const corrupted = JSON.parse(await readFile(join(root, 'run.json'), 'utf8'))
-  corrupted.status = 'SOLVED'
-  corrupted.eventSequence = 999
-  corrupted.bestCandidateId = null
-  await writeFile(join(root, 'run.json'), JSON.stringify(corrupted, null, 2))
-
-  assert.equal((await validateRun(root)).valid, false)
-  const recovered = await recoverRun(root)
-
-  assert.equal(recovered.status, 'SCOPE_FROZEN')
-  assert.equal(recovered.eventSequence, 1)
-  assert.equal(recovered.bestCandidateId, 'C-007')
-  assert.equal((await validateRun(root)).valid, true)
-})
-~~~
-
-- [ ] **Step 2: Run the tests and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/run-state.test.mjs tests/recovery.test.mjs
-~~~
-
-Expected: FAIL with `ERR_MODULE_NOT_FOUND` for `run-state.mjs`.
-
-- [ ] **Step 3: Create the run schema**
-
-Create `skills/math-modeling-agent/schemas/run.schema.json`:
-
-~~~json
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/yohanchen1/MathModelingAgent/schemas/run.schema.json",
-  "title": "Math Modeling Run",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "schemaVersion",
-    "taskId",
-    "mode",
-    "status",
-    "eventSequence",
-    "currentAttempt",
-    "bestCandidateId",
-    "budget",
-    "createdAt",
-    "updatedAt"
-  ],
-  "properties": {
-    "schemaVersion": { "const": 1 },
-    "taskId": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
-    "mode": { "enum": ["fast", "standard", "high-assurance"] },
-    "status": {
-      "enum": [
-        "TRIAGE", "SCOPE_FROZEN", "INPUT_PROFILED", "CLAIMS_REGISTERED",
-        "CANDIDATES_READY", "ATTEMPT", "EXECUTE", "VERIFY", "REVISE",
-        "RESEARCH", "FORK", "SOLVED", "PARTIAL", "CONDITIONAL",
-        "INCONCLUSIVE", "REFUTED", "INFEASIBLE", "UNIDENTIFIABLE",
-        "BLOCKED", "CANCELLED"
-      ]
-    },
-    "eventSequence": { "type": "integer", "minimum": 0 },
-    "currentAttempt": { "type": "integer", "minimum": 0 },
-    "bestCandidateId": { "type": ["string", "null"] },
-    "budget": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["attempts", "researchQueries", "computeSeconds"],
-      "properties": {
-        "attempts": { "type": "integer", "minimum": 1 },
-        "researchQueries": { "type": "integer", "minimum": 0 },
-        "computeSeconds": { "type": "integer", "minimum": 0 }
-      }
-    },
-    "createdAt": { "type": "string" },
-    "updatedAt": { "type": "string" }
-  }
-}
-~~~
-
-- [ ] **Step 4: Create the ledger and attempt schemas**
-
-Create `skills/math-modeling-agent/schemas/ledger.schema.json`:
-
-~~~json
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/yohanchen1/MathModelingAgent/schemas/ledger.schema.json",
-  "title": "Math Modeling Ledger",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "schemaVersion", "taskId", "scope", "assumptions", "claims",
-    "obligations", "subproblems", "candidates", "issues"
-  ],
-  "properties": {
-    "schemaVersion": { "const": 1 },
-    "taskId": { "type": "string" },
-    "scope": { "type": "object" },
-    "assumptions": { "type": "array" },
-    "claims": { "type": "array" },
-    "obligations": { "type": "array" },
-    "subproblems": { "type": "array" },
-    "candidates": { "type": "array" },
-    "issues": { "type": "array" }
-  }
-}
-~~~
-
-Create `skills/math-modeling-agent/schemas/attempt.schema.json`:
-
-~~~json
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://github.com/yohanchen1/MathModelingAgent/schemas/attempt.schema.json",
-  "title": "Math Modeling Attempt",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "schemaVersion", "attempt", "candidateId", "objective", "evidenceIds",
-    "closedObligationIds", "issuesOpened", "issuesClosed", "progress",
-    "nextAction", "status"
-  ],
-  "properties": {
-    "schemaVersion": { "const": 1 },
-    "attempt": { "type": "integer", "minimum": 1 },
-    "candidateId": { "type": "string" },
-    "objective": { "type": "string", "minLength": 1 },
-    "evidenceIds": { "type": "array", "items": { "type": "string" } },
-    "closedObligationIds": { "type": "array", "items": { "type": "string" } },
-    "issuesOpened": { "type": "array", "items": { "type": "string" } },
-    "issuesClosed": { "type": "array", "items": { "type": "string" } },
-    "progress": { "type": "boolean" },
-    "nextAction": { "type": "string", "minLength": 1 },
-    "status": { "type": "string" }
-  }
-}
-~~~
-
-- [ ] **Step 5: Implement the state Module**
-
-Create `skills/math-modeling-agent/scripts/run-state.mjs`:
-
-~~~javascript
-import { appendFile, mkdir, readFile, rename, writeFile } from 'node:fs/promises'
-import { randomUUID } from 'node:crypto'
-import { dirname, resolve } from 'node:path'
-import { pathToFileURL } from 'node:url'
-
-const MODES = new Set(['fast', 'standard', 'high-assurance'])
-const FINAL = new Set([
-  'SOLVED',
-  'PARTIAL',
-  'CONDITIONAL',
-  'INCONCLUSIVE',
-  'REFUTED',
-  'INFEASIBLE',
-  'UNIDENTIFIABLE',
-  'BLOCKED',
-  'CANCELLED',
-])
-
-const TRANSITIONS = {
-  TRIAGE: new Set(['SCOPE_FROZEN', 'BLOCKED', 'CANCELLED']),
-  SCOPE_FROZEN: new Set(['INPUT_PROFILED', 'BLOCKED', 'CANCELLED']),
-  INPUT_PROFILED: new Set(['CLAIMS_REGISTERED', 'BLOCKED', 'CANCELLED']),
-  CLAIMS_REGISTERED: new Set(['CANDIDATES_READY', 'BLOCKED', 'CANCELLED']),
-  CANDIDATES_READY: new Set(['ATTEMPT', 'BLOCKED', 'CANCELLED']),
-  ATTEMPT: new Set(['EXECUTE', 'BLOCKED', 'CANCELLED']),
-  EXECUTE: new Set(['VERIFY', 'BLOCKED', 'CANCELLED']),
-  VERIFY: new Set([
-    'REVISE',
-    'RESEARCH',
-    'FORK',
-    ...FINAL,
-  ]),
-  REVISE: new Set(['ATTEMPT', 'BLOCKED', 'CANCELLED']),
-  RESEARCH: new Set(['CANDIDATES_READY', 'BLOCKED', 'CANCELLED']),
-  FORK: new Set(['ATTEMPT', 'BLOCKED', 'CANCELLED']),
-}
-
-const DEFAULT_BUDGETS = {
-  fast: { attempts: 2, researchQueries: 0, computeSeconds: 60 },
-  standard: { attempts: 12, researchQueries: 12, computeSeconds: 1800 },
-  'high-assurance': { attempts: 24, researchQueries: 30, computeSeconds: 7200 },
-}
-
-function runPath(root) {
-  return resolve(root, 'run.json')
-}
-
-function ledgerPath(root) {
-  return resolve(root, 'ledger.json')
-}
-
-function eventsPath(root) {
-  return resolve(root, 'events.jsonl')
-}
-
-async function readJson(path) {
-  return JSON.parse(await readFile(path, 'utf8'))
-}
-
-async function atomicWriteJson(path, value) {
-  await mkdir(dirname(path), { recursive: true })
-  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`
-  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`)
-  await rename(temporary, path)
-}
-
-async function appendEvent(root, event) {
-  await appendFile(eventsPath(root), `${JSON.stringify(event)}\n`)
-}
-
-function assertTaskId(taskId) {
-  if (!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(taskId)) {
-    throw new TypeError('taskId must be kebab-case')
-  }
-}
-
-function assertReferences(evidenceIds, issueIds) {
-  if (![...(evidenceIds ?? []), ...(issueIds ?? [])].length) {
-    throw new TypeError('every transition requires at least one evidence or issue reference')
-  }
-}
-
-function assertSolvedGate(to, run, ledger) {
-  if (to !== 'SOLVED') return
-  if (!Array.isArray(ledger.claims) || ledger.claims.length === 0) {
-    throw new Error('SOLVED requires at least one registered claim')
-  }
-  const openObligations = ledger.obligations.filter(
-    (item) => item.required !== false && item.status !== 'PASS',
-  )
-  if (openObligations.length) throw new Error('required obligations remain open')
-
-  const openCriticalIssues = ledger.issues.filter(
-    (item) => item.severity === 'critical' && item.status !== 'CLOSED',
-  )
-  if (openCriticalIssues.length) throw new Error('critical issues remain open')
-
-  if (run.mode === 'high-assurance' && ledger.scope?.independentAuditPassed !== true) {
-    throw new Error('High-Assurance SOLVED requires an independent audit')
-  }
-}
-
-function assertRun(run) {
-  if (run.schemaVersion !== 1) throw new TypeError('unsupported run schemaVersion')
-  assertTaskId(run.taskId)
-  if (!MODES.has(run.mode)) throw new TypeError('invalid run mode')
-  if (!Number.isInteger(run.eventSequence) || run.eventSequence < 0) {
-    throw new TypeError('invalid eventSequence')
-  }
-  if (!Number.isInteger(run.currentAttempt) || run.currentAttempt < 0) {
-    throw new TypeError('invalid currentAttempt')
-  }
-}
-
-export async function initRun(root, input) {
-  assertTaskId(input.taskId)
-  if (!MODES.has(input.mode)) throw new TypeError('invalid run mode')
-
-  const now = new Date().toISOString()
-  const run = {
-    schemaVersion: 1,
-    taskId: input.taskId,
-    mode: input.mode,
-    status: 'TRIAGE',
-    eventSequence: 0,
-    currentAttempt: 0,
-    bestCandidateId: null,
-    budget: input.budget ?? DEFAULT_BUDGETS[input.mode],
-    createdAt: now,
-    updatedAt: now,
-  }
-  const ledger = {
-    schemaVersion: 1,
-    taskId: input.taskId,
-    scope: {},
-    assumptions: [],
-    claims: [],
-    obligations: [],
-    subproblems: [],
-    candidates: [],
-    issues: [],
-  }
-
-  await mkdir(resolve(root), { recursive: true })
-  await atomicWriteJson(ledgerPath(root), ledger)
-  await appendEvent(root, {
-    schemaVersion: 1,
-    sequence: 0,
-    type: 'RUN_INITIALIZED',
-    snapshot: run,
-  })
-  await atomicWriteJson(runPath(root), run)
-  return run
-}
-
-export async function transitionRun(root, input) {
-  const run = await readJson(runPath(root))
-  const ledger = await readJson(ledgerPath(root))
-  assertRun(run)
-  if (FINAL.has(run.status)) throw new Error(`run is terminal: ${run.status}`)
-  if (!TRANSITIONS[run.status]?.has(input.to)) {
-    throw new Error(`illegal transition ${run.status} -> ${input.to}`)
-  }
-  assertReferences(input.evidenceIds, input.issueIds)
-  assertSolvedGate(input.to, run, ledger)
-
-  const next = {
-    ...run,
-    ...(input.patch ?? {}),
-    status: input.to,
-    eventSequence: run.eventSequence + 1,
-    currentAttempt: run.currentAttempt + (input.to === 'ATTEMPT' ? 1 : 0),
-    updatedAt: new Date().toISOString(),
-  }
-  assertRun(next)
-
-  const event = {
-    schemaVersion: 1,
-    sequence: next.eventSequence,
-    type: 'STATUS_TRANSITION',
-    from: run.status,
-    to: next.status,
-    reason: input.reason,
-    evidenceIds: input.evidenceIds ?? [],
-    issueIds: input.issueIds ?? [],
-    snapshot: next,
-  }
-  await appendEvent(root, event)
-  await atomicWriteJson(runPath(root), next)
-  return next
-}
-
-export async function loadEvents(root) {
-  const raw = await readFile(eventsPath(root), 'utf8')
-  return raw.split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line))
-}
-
-export async function validateRun(root) {
-  const diagnostics = []
-  let run
-  let ledger
-  let events
-  try {
-    run = await readJson(runPath(root))
-    assertRun(run)
-  } catch (error) {
-    diagnostics.push(`run.json: ${error.message}`)
-  }
-  try {
-    ledger = await readJson(ledgerPath(root))
-    if (ledger.schemaVersion !== 1) throw new TypeError('unsupported schemaVersion')
-  } catch (error) {
-    diagnostics.push(`ledger.json: ${error.message}`)
-  }
-  try {
-    events = await loadEvents(root)
-    events.forEach((event, index) => {
-      if (event.sequence !== index) throw new TypeError(`non-monotonic sequence at ${index}`)
-    })
-  } catch (error) {
-    diagnostics.push(`events.jsonl: ${error.message}`)
-  }
-
-  const last = events?.at(-1)
-  if (run && ledger && run.taskId !== ledger.taskId) {
-    diagnostics.push('run and ledger taskId differ')
-  }
-  if (run && last && run.eventSequence !== last.sequence) {
-    diagnostics.push('run snapshot is not aligned with the event journal')
-  }
-  if (run && last && JSON.stringify(run) !== JSON.stringify(last.snapshot)) {
-    diagnostics.push('run snapshot differs from the last journal snapshot')
-  }
-
-  return { valid: diagnostics.length === 0, diagnostics }
-}
-
-export async function recoverRun(root) {
-  const events = await loadEvents(root)
-  const last = events.at(-1)
-  if (!last?.snapshot) throw new Error('event journal has no recoverable snapshot')
-  assertRun(last.snapshot)
-  await atomicWriteJson(runPath(root), last.snapshot)
-  return last.snapshot
-}
-
-export async function readRun(root) {
-  const run = await readJson(runPath(root))
-  assertRun(run)
-  return run
-}
-
-function usage() {
-  return 'usage: run-state.mjs <init|transition|validate|recover|status> <run-root> [arguments]'
-}
-
-async function main() {
-  const [command, root, ...args] = process.argv.slice(2)
-  if (!command || !root) throw new Error(usage())
-
-  let result
-  if (command === 'init') {
-    const [taskId, mode = 'standard'] = args
-    result = await initRun(root, { taskId, mode })
-  } else if (command === 'transition') {
-    const [to, reason, references = ''] = args
-    result = await transitionRun(root, {
-      to,
-      reason,
-      issueIds: references.split(',').filter(Boolean),
-    })
-  } else if (command === 'validate') {
-    result = await validateRun(root)
-    if (!result.valid) process.exitCode = 1
-  } else if (command === 'recover') {
-    result = await recoverRun(root)
-  } else if (command === 'status') {
-    result = await readRun(root)
-  } else {
-    throw new Error(usage())
-  }
-  process.stdout.write(`${JSON.stringify(result, null, 2)}
-`)
-}
-
-const invokedPath = process.argv[1]
-if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) {
-  main().catch((error) => {
-    process.stderr.write(`${error.message}
-`)
-    process.exitCode = 1
-  })
-}
-~~~
-
-- [ ] **Step 6: Run state and recovery tests**
-
-Run:
-
-~~~bash
-node --test tests/run-state.test.mjs tests/recovery.test.mjs
-~~~
-
-Expected: 6 tests PASS, 0 failures.
-
-- [ ] **Step 7: Commit the state Module**
-
-~~~bash
-git add skills/math-modeling-agent/schemas skills/math-modeling-agent/scripts/run-state.mjs tests/run-state.test.mjs tests/recovery.test.mjs
-git commit -m "feat: add resumable modeling run state"
-~~~
-
-### Task 4: Add isolated Python environment creation
-
-**Files:**
-- Create: `tests/python-environment.test.mjs`
-- Create: `skills/math-modeling-agent/scripts/python-environment.mjs`
-
-- [ ] **Step 1: Write failing Python-environment tests**
-
-Create `tests/python-environment.test.mjs`:
-
-~~~javascript
-import assert from 'node:assert/strict'
-import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import test from 'node:test'
-
-import {
-  createPythonEnvironment,
-  validatePackageSpec,
-} from '../skills/math-modeling-agent/scripts/python-environment.mjs'
-
-test('validatePackageSpec rejects URLs and VCS dependencies', () => {
-  assert.throws(() => validatePackageSpec('git+https://example.com/pkg.git'), /unsafe package spec/)
-  assert.throws(() => validatePackageSpec('../local.whl'), /unsafe package spec/)
-  assert.equal(validatePackageSpec('numpy==2.2.0'), 'numpy==2.2.0')
-  assert.equal(validatePackageSpec('scipy'), 'scipy')
-})
-
-test('uv path creates only a run-local environment and lock', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'mma-python-'))
-  const commands = []
-  const fakeRun = async (command, args, options = {}) => {
-    commands.push({ command, args, options })
-    if (options.stdoutFile) await writeFile(options.stdoutFile, 'numpy==2.2.0\n')
-    return 0
-  }
-  const capabilities = {
-    tools: {
-      uv: { status: 'candidate', executable: '/tools/uv', kind: 'uv' },
-      python: { status: 'unavailable', executable: null, kind: 'python' },
-    },
-  }
-
-  const manifest = await createPythonEnvironment({
-    runDir: root,
-    packages: ['numpy==2.2.0'],
-    capabilities,
-    runCommand: fakeRun,
-  })
-
-  assert.equal(manifest.status, 'ready')
-  assert.equal(manifest.adapter, 'uv')
-  assert.match(manifest.environmentDir, /\.python-env$/)
-  assert.equal(commands[0].command, '/tools/uv')
-  assert.deepEqual(commands[0].args.slice(0, 2), ['venv', '--seed'])
-  assert.equal(await readFile(join(root, 'requirements.lock'), 'utf8'), 'numpy==2.2.0\n')
-})
-
-test('missing runtime returns a blocker instead of modifying the system', async () => {
-  const root = await mkdtemp(join(tmpdir(), 'mma-python-'))
-  const manifest = await createPythonEnvironment({
-    runDir: root,
-    packages: [],
-    capabilities: {
-      tools: {
-        uv: { status: 'unavailable', executable: null },
-        python: { status: 'unavailable', executable: null },
-      },
-    },
-    runCommand: async () => {
-      throw new Error('must not run')
-    },
-  })
-
-  assert.equal(manifest.status, 'blocked')
-  assert.equal(manifest.reason, 'No uv or Python runtime candidate is available.')
-})
-~~~
-
-- [ ] **Step 2: Run the test and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/python-environment.test.mjs
-~~~
-
-Expected: FAIL with `ERR_MODULE_NOT_FOUND` for `python-environment.mjs`.
-
-- [ ] **Step 3: Implement the isolated environment Module**
-
-Create `skills/math-modeling-agent/scripts/python-environment.mjs`:
-
-~~~javascript
-import { closeSync, openSync } from 'node:fs'
-import { mkdir, rename, writeFile } from 'node:fs/promises'
-import { randomUUID } from 'node:crypto'
-import { basename, dirname, resolve } from 'node:path'
-import { spawnSync } from 'node:child_process'
-import { pathToFileURL } from 'node:url'
-
-const PACKAGE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]*(?:==[A-Za-z0-9][A-Za-z0-9._+-]*)?$/
-
-export function validatePackageSpec(value) {
-  if (!PACKAGE_PATTERN.test(value)) throw new TypeError(`unsafe package spec: ${value}`)
-  return value
-}
-
-function environmentPython(environmentDir) {
-  return process.platform === 'win32'
-    ? resolve(environmentDir, 'Scripts', 'python.exe')
-    : resolve(environmentDir, 'bin', 'python')
-}
-
-async function atomicWriteJson(path, value) {
-  await mkdir(dirname(path), { recursive: true })
-  const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`
-  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`)
-  await rename(temporary, path)
-}
-
-async function defaultRun(command, args, options = {}) {
-  let descriptor
-  try {
-    descriptor = options.stdoutFile ? openSync(options.stdoutFile, 'w') : undefined
-    const result = spawnSync(command, args, {
-      cwd: options.cwd,
-      shell: false,
-      stdio: descriptor === undefined
-        ? 'inherit'
-        : ['ignore', descriptor, 'inherit'],
-    })
-    return result.status ?? 1
-  } finally {
-    if (descriptor !== undefined) closeSync(descriptor)
-  }
-}
-
-function assertSuccess(status, label) {
-  if (status !== 0) throw new Error(`${label} failed with exit code ${status}`)
-}
-
-function pythonVenvArgs(record, environmentDir) {
-  const name = basename(record.executable).toLowerCase()
-  if (name === 'py' || name === 'py.exe') return ['-3', '-m', 'venv', environmentDir]
-  return ['-m', 'venv', environmentDir]
-}
-
-export async function createPythonEnvironment(input) {
-  const runDir = resolve(input.runDir)
-  const environmentDir = resolve(runDir, '.python-env')
-  const lockPath = resolve(runDir, 'requirements.lock')
-  const manifestPath = resolve(runDir, 'python-environment.json')
-  const packages = input.packages.map(validatePackageSpec)
-  const runCommand = input.runCommand ?? defaultRun
-  const uv = input.capabilities.tools?.uv
-  const python = input.capabilities.tools?.python
-  const commands = []
-
-  await mkdir(runDir, { recursive: true })
-
-  if (uv?.status === 'candidate' && uv.executable) {
-    const createArgs = ['venv', '--seed', environmentDir]
-    commands.push({ command: uv.executable, args: createArgs })
-    assertSuccess(await runCommand(uv.executable, createArgs, { cwd: runDir }), 'uv venv')
-
-    const pythonPath = environmentPython(environmentDir)
-    if (packages.length) {
-      const installArgs = ['pip', 'install', '--python', pythonPath, ...packages]
-      commands.push({ command: uv.executable, args: installArgs })
-      assertSuccess(await runCommand(uv.executable, installArgs, { cwd: runDir }), 'uv pip install')
-    }
-    const freezeArgs = ['-m', 'pip', 'freeze']
-    commands.push({ command: pythonPath, args: freezeArgs, stdoutFile: lockPath })
-    assertSuccess(
-      await runCommand(pythonPath, freezeArgs, { cwd: runDir, stdoutFile: lockPath }),
-      'pip freeze',
-    )
-
-    const manifest = {
-      schemaVersion: 1,
-      status: 'ready',
-      adapter: 'uv',
-      environmentDir,
-      python: pythonPath,
-      requestedPackages: packages,
-      lockPath,
-      commands,
-    }
-    await atomicWriteJson(manifestPath, manifest)
-    return manifest
-  }
-
-  if (python?.status === 'candidate' && python.executable) {
-    const createArgs = pythonVenvArgs(python, environmentDir)
-    commands.push({ command: python.executable, args: createArgs })
-    assertSuccess(
-      await runCommand(python.executable, createArgs, { cwd: runDir }),
-      'python venv',
-    )
-
-    const pythonPath = environmentPython(environmentDir)
-    if (packages.length) {
-      const installArgs = ['-m', 'pip', 'install', ...packages]
-      commands.push({ command: pythonPath, args: installArgs })
-      assertSuccess(
-        await runCommand(pythonPath, installArgs, { cwd: runDir }),
-        'pip install',
-      )
-    }
-    const freezeArgs = ['-m', 'pip', 'freeze']
-    commands.push({ command: pythonPath, args: freezeArgs, stdoutFile: lockPath })
-    assertSuccess(
-      await runCommand(pythonPath, freezeArgs, { cwd: runDir, stdoutFile: lockPath }),
-      'pip freeze',
-    )
-
-    const manifest = {
-      schemaVersion: 1,
-      status: 'ready',
-      adapter: 'venv',
-      environmentDir,
-      python: pythonPath,
-      requestedPackages: packages,
-      lockPath,
-      commands,
-    }
-    await atomicWriteJson(manifestPath, manifest)
-    return manifest
-  }
-
-  const manifest = {
-    schemaVersion: 1,
-    status: 'blocked',
-    adapter: null,
-    environmentDir,
-    python: null,
-    requestedPackages: packages,
-    lockPath: null,
-    commands,
-    reason: 'No uv or Python runtime candidate is available.',
-  }
-  await atomicWriteJson(manifestPath, manifest)
-  return manifest
-}
-
-function parseArguments(argv) {
-  const result = { packages: [] }
-  for (let index = 0; index < argv.length; index += 1) {
-    const value = argv[index]
-    if (value === '--run-dir') result.runDir = argv[++index]
-    else if (value === '--capabilities') result.capabilitiesPath = argv[++index]
-    else if (value === '--package') result.packages.push(argv[++index])
-    else throw new Error(`unknown argument: ${value}`)
-  }
-  if (!result.runDir || !result.capabilitiesPath) {
-    throw new Error('usage: python-environment.mjs --run-dir <path> --capabilities <json> [--package <spec>]')
-  }
-  return result
-}
-
-async function main() {
-  const args = parseArguments(process.argv.slice(2))
-  const { readFile } = await import('node:fs/promises')
-  const capabilities = JSON.parse(await readFile(args.capabilitiesPath, 'utf8'))
-  const manifest = await createPythonEnvironment({
-    runDir: args.runDir,
-    packages: args.packages,
-    capabilities,
-  })
-  process.stdout.write(`${JSON.stringify(manifest, null, 2)}
-`)
-  if (manifest.status === 'blocked') process.exitCode = 2
-}
-
-const invokedPath = process.argv[1]
-if (invokedPath && import.meta.url === pathToFileURL(invokedPath).href) {
-  main().catch((error) => {
-    process.stderr.write(`${error.message}
-`)
-    process.exitCode = 1
-  })
-}
-~~~
-
-- [ ] **Step 4: Run Python-environment tests**
-
-Run:
-
-~~~bash
-node --test tests/python-environment.test.mjs
-~~~
-
-Expected: 3 tests PASS, 0 failures.
-
-- [ ] **Step 5: Commit isolated Python setup**
-
-~~~bash
-git add tests/python-environment.test.mjs skills/math-modeling-agent/scripts/python-environment.mjs
-git commit -m "feat: add isolated python environment setup"
-~~~
-
-
-### Task 5: Create the deep math-modeling Skill and intake protocol
-
-**Files:**
-- Modify: `tests/plugin-integrity.test.mjs`
-- Create: `skills/math-modeling-agent/SKILL.md`
-- Create: `skills/math-modeling-agent/references/workflow.md`
-- Create: `skills/math-modeling-agent/references/math-grill.md`
-- Create: `skills/math-modeling-agent/references/problem-types.md`
-
-- [ ] **Step 1: Extend the integrity test to require exactly two valid Skills and real resources**
-
-In `tests/plugin-integrity.test.mjs`, replace:
-
-~~~javascript
-import { readFile } from 'node:fs/promises'
-~~~
-
-with:
-
-~~~javascript
-import { access, readFile, readdir } from 'node:fs/promises'
-~~~
-
-Append this block:
-
-~~~javascript
-function parseFrontmatter(source) {
-  const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(source)
-  assert.ok(match, 'SKILL.md must contain YAML frontmatter')
-  const metadata = Object.fromEntries(
-    match[1]
-      .split(/\r?\n/)
-      .filter(Boolean)
-      .map((line) => {
-        const separator = line.indexOf(':')
-        assert.ok(separator > 0, 'invalid frontmatter line: ' + line)
-        return [line.slice(0, separator).trim(), line.slice(separator + 1).trim()]
-      }),
-  )
-  return { metadata, body: match[2] }
-}
-
-test('package exposes exactly two kebab-case Skills', async () => {
-  const skillRoot = resolve(ROOT, 'skills')
-  const entries = (await readdir(skillRoot, { withFileTypes: true }))
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    .sort()
-
-  assert.deepEqual(entries, ['math-modeling-agent', 'math-modeling-audit'])
-
-  for (const name of entries) {
-    const source = await read('skills/' + name + '/SKILL.md')
-    const { metadata } = parseFrontmatter(source)
-    assert.equal(metadata.name, name)
-    assert.match(metadata.description, /This skill should be used when/i)
-  }
-})
-
-test('every resource named by a Skill exists within that Skill bundle', async () => {
-  for (const name of ['math-modeling-agent', 'math-modeling-audit']) {
-    const source = await read('skills/' + name + '/SKILL.md')
-    const { body } = parseFrontmatter(source)
-    const resources = [
-      ...body.matchAll(/`((?:references|scripts|schemas)\/[a-z0-9._/-]+)`/g),
-    ].map((match) => match[1])
-
-    assert.ok(resources.length > 0, name + ' must name its selective resources')
-    for (const resource of resources) {
-      await access(resolve(ROOT, 'skills', name, resource))
-    }
-  }
-})
-
-test('packaged files contain no developer-specific paths', async () => {
-  const files = [
-    'cordis.patch.yml',
-    'skills/math-modeling-agent/SKILL.md',
-    'skills/math-modeling-audit/SKILL.md',
-  ]
-  for (const file of files) {
-    const source = await read(file)
-    assert.doesNotMatch(source, /C:\\Users\\16605|\.claude[\\/]plugins/i)
-  }
-})
-~~~
-
-- [ ] **Step 2: Run the integrity test and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: FAIL because the two Skill bundles and their resources do not exist.
-
-- [ ] **Step 3: Create the main Skill interface**
-
-Create `skills/math-modeling-agent/SKILL.md`:
-
-~~~markdown
----
-name: math-modeling-agent
-description: This skill should be used when the user asks to "建立数学模型", "解决数学建模题", "继续上次建模", "寻找新的建模方向", "solve this modeling problem", or needs an evidence-backed mathematical model with computation, research, verification, per-attempt reports, and resumable state.
-whenToUse: Use for open-ended mathematical modeling, prediction, optimization, estimation, simulation, mechanism, decision, or multi-part contest problems; do not use for auditing an already completed artifact without changing it.
-user-invocable: true
----
-
-# Math Modeling Agent
-
-## Goal
-
-Move one mathematical problem from scoped intake to an evidence-backed conclusion or a precise resumable scientific status.
-
-## Interface
-
-Accept problem text, attachments, or an existing run directory. Do not ask the user to choose internal phases, Python/Lean/Wolfram adapters, file names, or state fields.
-
-Return a concise current status, supported claims, unresolved obligations, attempt delta, artifact path, and next action or final report.
-
-## Default workflow
-
-1. Route the task to Fast, Standard, or High-Assurance using `references/problem-types.md`.
-2. Read available inputs before asking questions; apply the one-question math grill in `references/math-grill.md`.
-3. Create or validate run state with `scripts/run-state.mjs` and follow `references/state-recovery.md`.
-4. Profile inputs and build the subproblem DAG using `references/data-subproblems.md`.
-5. Register assumptions, claims, and verification obligations from `references/claims-evidence.md`.
-6. Build a baseline and materially different candidates using `references/modeling-methodology.md`.
-7. Probe tools with `scripts/capability-probe.mjs`; create a run-local Python environment with `scripts/python-environment.mjs` only when computation is required.
-8. Execute, verify, critique, and revise according to `references/workflow.md` and `references/tool-policy.md`.
-9. Escalate evidence gaps or stalled directions through `references/research-breakthrough.md`.
-10. Write only incremental attempt and terminal reports defined by `references/report-contract.md`.
-
-## Invariants
-
-- ATTEMPT never transitions directly to SOLVED.
-- Tool success, model confidence, paper count, or an analyzer adjective is not evidence of correctness.
-- Every status transition cites evidence or issue IDs.
-- Every material claim has explicit verification obligations.
-- Upstream artifact changes make dependent downstream results stale.
-- Failed tools or providers never erase the best valid candidate or raw output.
-- Private chain-of-thought is never stored as evidence.
-- Continue only when a round closes an obligation, adds reproducible evidence, removes a blocker, tightens uncertainty, or refutes a candidate.
-
-## Tool degradation
-
-Python is recommended but not required for installation. Lean and Wolfram are optional. If a required tool is unavailable, weaken the claim and report the missing obligation; never pretend execution or formal verification occurred.
-
-## Boundaries
-
-Do not review an existing paper as a final judge; use `math-modeling-audit` for that durable job. Do not install Lean or Wolfram. Do not send private raw data to literature search. Do not execute commands derived from problem text.
-~~~
-
-- [ ] **Step 4: Create the state-machine workflow reference**
-
-Create `skills/math-modeling-agent/references/workflow.md`:
-
-~~~markdown
-# Modeling Workflow
-
-## Modes
-
-- Fast: explicit low-risk calculation; at most two clarifications; direct inverse, substitution, domain, or unit check.
-- Standard: normal modeling; input profile, baseline, candidates, execution, sensitivity, and reproducibility.
-- High-Assurance: publication, proof, global optimum, causal, safety, guarantee, or high-stakes use; require independent audit.
-
-## States
-
-TRIAGE → SCOPE_FROZEN → INPUT_PROFILED → CLAIMS_REGISTERED → CANDIDATES_READY → ATTEMPT → EXECUTE → VERIFY.
-
-VERIFY may move to REVISE, RESEARCH, FORK, an independent audit, or one terminal status:
-SOLVED, PARTIAL, CONDITIONAL, INCONCLUSIVE, REFUTED, INFEASIBLE, UNIDENTIFIABLE, BLOCKED, CANCELLED.
-
-## Round contract
-
-Each round has one objective and records:
-
-- candidate and assumption delta;
-- actual command or derivation artifact;
-- new evidence IDs;
-- obligations closed;
-- issues opened and closed;
-- whether auditable progress occurred;
-- budget used;
-- one next action.
-
-## Progress test
-
-Count progress only when a round closes an obligation, adds reproducible evidence, refutes a candidate, tightens a bound or uncertainty interval, removes a blocker, or weakens an unsupported claim correctly.
-
-Do not count rewording, same-parameter reruns, training-only gains, longer prose, tool exit success, or unverified search titles.
-
-After two no-progress rounds, run a stagnation review. A third no-progress round requires a material fork, user decision, or resumable non-SOLVED status.
-
-## SOLVED gate
-
-SOLVED requires frozen scope, all required obligations passed, critical adversarial checks passed, reproducibility material present, limitations stated, and—under High-Assurance—an independent artifact-only audit.
-~~~
-
-- [ ] **Step 5: Create the mathematical grilling reference**
-
-Create `skills/math-modeling-agent/references/math-grill.md`:
-
-~~~markdown
-# Math-Grill Protocol
-
-Ask one question at a time. Read the problem and attachments first. Ask only questions whose answer can change the model, evidence obligation, or deliverable.
-
-## Minimum routing questions
-
-1. What output is required: number, proof, model, prediction, optimum, or decision?
-2. Does data exist, and what is its source?
-3. Is the requested claim proof, global optimality, causality, safety, or a useful approximation?
-4. What error, confidence, or decision risk is acceptable?
-5. Is the result for practice, competition, publication, production, or high-stakes use?
-
-## Selective modeling fields
-
-Collect only applicable fields:
-
-- background and practical objective;
-- explicit and hidden subproblems;
-- data, label source, units, quality, time, and group structure;
-- decision/state variables and parameters;
-- objective or evaluation metric;
-- equality, inequality, integer, nonnegative, logical, initial, and boundary constraints;
-- assumptions and their source category;
-- acceptance criteria and final deliverable.
-
-## Rules
-
-- Infer before asking.
-- Ask the highest-impact unknown first.
-- Mark irrelevant fields “not applicable” with a reason.
-- Turn “自行判断” into an explicit modeling assumption with risk and sensitivity plan.
-- Do not freeze scope while a missing answer can change the problem type or claim strength.
-- Do not force a proof problem to invent data or an exploratory analysis to invent an objective function.
-~~~
-
-- [ ] **Step 6: Create the problem-type routing reference**
-
-Create `skills/math-modeling-agent/references/problem-types.md`:
-
-~~~markdown
-# Problem Types and Obligations
-
-| Type | Primary output | Mandatory checks |
-|---|---|---|
-| Symbolic calculation | exact expression or roots | domain, equivalence, substitution, singular cases |
-| Theorem/proposition | proof or counterexample | quantifiers, assumptions, boundary cases, proof completeness |
-| Deterministic numerical | approximation | residual, convergence, stability, discretization error |
-| Feasibility | satisfying assignment | every constraint, tolerance, certificate |
-| Optimization | local/global solution | objective fidelity, constraints, bounds, optimality gap/certificate |
-| Statistical estimation | estimate and uncertainty | sampling assumptions, interval, residual diagnostics |
-| Prediction/classification | out-of-sample performance | leakage-safe split, baseline, calibration, uncertainty |
-| Causal inference | identified effect | estimand, temporal order, confounding, sensitivity |
-| Stochastic/risk | distribution or risk measure | distribution assumptions, Monte Carlo error, tail behavior |
-| Inverse problem | recovered parameter/structure | identifiability, conditioning, regularization |
-| Mechanism/system | dynamic behavior | structural validity, units, calibration, initial/boundary conditions |
-| Decision analysis | recommendation | preference/weight source, constraints, sensitivity, regret |
-| Exploratory analysis | hypotheses/patterns | no causal upgrade, multiplicity, robustness |
-| Literature synthesis | supported method/fact | source verification, applicability, conflicting evidence |
-
-Use multiple labels when necessary, but choose one primary output and one explicit assurance mode.
-~~~
-
-- [ ] **Step 7: Run integrity test and verify expected partial RED**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: Skill-count test still FAILS because `math-modeling-audit` is not created; all `math-modeling-agent` resource checks PASS.
-
-- [ ] **Step 8: Commit the main Skill interface and intake protocol**
-
-~~~bash
-git add tests/plugin-integrity.test.mjs skills/math-modeling-agent/SKILL.md skills/math-modeling-agent/references/workflow.md skills/math-modeling-agent/references/math-grill.md skills/math-modeling-agent/references/problem-types.md
-git commit -m "feat: add mathematical modeling skill interface"
-~~~
-
-
-
-### Task 6: Add modeling, evidence, research, tool, report, and recovery references
-
-**Files:**
-- Create: `skills/math-modeling-agent/references/claims-evidence.md`
-- Create: `skills/math-modeling-agent/references/modeling-methodology.md`
-- Create: `skills/math-modeling-agent/references/data-subproblems.md`
-- Create: `skills/math-modeling-agent/references/research-breakthrough.md`
-- Create: `skills/math-modeling-agent/references/tool-policy.md`
-- Create: `skills/math-modeling-agent/references/state-recovery.md`
-- Create: `skills/math-modeling-agent/references/report-contract.md`
-- Create: `skills/math-modeling-agent/examples/minimal-run/README.md`
-- Create: `skills/math-modeling-agent/examples/resumed-run/README.md`
-
-- [ ] **Step 1: Create the claim/evidence contract**
-
-Create `skills/math-modeling-agent/references/claims-evidence.md`:
-
-~~~markdown
-# Claims and Evidence
-
-## Claim record
-
-Store claim ID, exact wording, type, scope/quantifiers, assumptions, risk, verification obligations, evidence IDs, countercheck, status, and limitations.
-
-## Assumption record
-
-Store statement, scope, source category, risk, sensitivity plan, validation status, and affected claims. Allowed source categories are problem, data, theory, verified literature, domain instruction, and modeling simplification.
-
-## Evidence record
-
-Store evidence ID, method, tool, timestamp, covered claim IDs, input/output hashes, command/workdir/environment, exit code, output artifacts, tolerance, limitations, and level:
-DERIVED, EXECUTED, VERIFIED, INDEPENDENTLY_VERIFIED, EXTERNALLY_VALIDATED, or NOT_CHECKED.
-
-## Obligation patterns
-
-- Numeric value: independent recomputation, residual/error bound, domain, and boundary check.
-- Feasibility: all constraints and justified tolerance on original scale.
-- Global optimum: convexity/KKT/duality, exact search, or certified bound; otherwise say local or best found.
-- Uniqueness: proof or explicit non-uniqueness disclaimer.
-- Prediction: untouched test/external validation, leakage-safe split, baseline, uncertainty, and calibration.
-- Causal effect: estimand, identification, temporal order, confounding, and sensitivity.
-- Robustness: parameter, data, seed, specification, and scenario perturbation.
-- Theorem: readable or kernel-checked proof plus formalization-fidelity audit.
-- Literature support: resolvable source, exact location, excerpt, retrieval date, and mapped claim.
-- Reproducibility: data/code/config versions, lock, seed, tolerance, commands, and clean rerun.
-
-Evidence strength may not be weaker than claim strength. Weaken unsupported claims; never weaken the verification rule.
-~~~
-
-- [ ] **Step 2: Create the modeling-methodology reference**
-
-Create `skills/math-modeling-agent/references/modeling-methodology.md`:
-
-~~~markdown
-# Modeling Methodology
-
-## Mechanism first
-
-Map real objects to variables, mechanism to equations, reality constraints to mathematical constraints, and requested decisions to objective/evaluation criteria. Never choose a named method first and force the problem into it.
-
-## Candidate portfolio
-
-Always begin with a defensible baseline. Add a more complex candidate only when it targets a documented baseline failure. Candidates must differ in mechanism, information, assumptions, or verification route—not wording.
-
-For each candidate record:
-
-- stable ID and parent/fork;
-- target subproblem and claims;
-- mechanism and equations;
-- assumptions and parameter sources;
-- input requirements;
-- expected information gain;
-- verification obligations;
-- stop/abandon conditions;
-- complexity, interpretability, and compute cost.
-
-## Selection
-
-Prefer the simplest candidate that meets evidence and accuracy requirements. Compare verification coverage, critical issues, empirical performance, robustness, complexity, interpretability, cost, and reproducibility. Do not reward model count, deep learning, metaheuristics, AHP, TOPSIS, entropy weights, or Monte Carlo by name.
-
-## Core checks
-
-- units and dimensions;
-- limiting and boundary cases;
-- known special cases;
-- constraint completeness;
-- identifiability and conditioning;
-- convergence and numerical stability;
-- data leakage and post-hoc parameters;
-- baseline and ablation;
-- sensitivity of conclusion-changing parameters;
-- model-result-conclusion traceability.
-~~~
-
-- [ ] **Step 3: Create input profiling and subproblem dependency guidance**
-
-Create `skills/math-modeling-agent/references/data-subproblems.md`:
-
-~~~markdown
-# Inputs, Data, and Subproblems
-
-## Input manifest
-
-For each accessible artifact record stable ID, cryptographic hash, source, path, type, size, encoding, readability, and extraction provenance. For tables record sheets, rows, columns, inferred types, units, missingness, duplicates, ranges, anomalies, label source, time structure, group structure, and leakage risk.
-
-Do not silently ignore unsupported files. Mark them unreadable and state the minimum representation needed.
-
-## Leakage audit
-
-Before model selection, identify target labels, future information, repeated entities, grouped observations, temporal ordering, and preprocessing fit scope. Fit imputation, scaling, feature selection, dimensionality reduction, and thresholds only inside training folds. Use time or group splits when ordinary random splits leak information.
-
-## Subproblem DAG
-
-Each subproblem records ID, exact task, required inputs, produced claims/artifacts, dependencies, acceptance criteria, and status. Downstream work references upstream IDs rather than copied prose.
-
-When an upstream artifact changes, mark every dependent output stale. If an upstream node is blocked, downstream work must choose exactly one state: blocked, provisional with explicit condition, or alternative independent path.
-~~~
-
-- [ ] **Step 4: Create research and breakthrough escalation guidance**
-
-Create `skills/math-modeling-agent/references/research-breakthrough.md`:
-
-~~~markdown
-# Research and Breakthrough
-
-Research only when it closes a named evidence gap, validates a parameter/assumption, supplies an applicable method, or explains a failure.
-
-## Source record
-
-Record author, title, year, venue, DOI/stable URL, version, retrieval date, exact page/section/theorem/table, excerpt, mapped claim, source quality, applicability, and support strength. Distinguish full text, abstract only, metadata only, secondary source, conflicting evidence, and citation needed.
-
-## Method matrix
-
-For each candidate method record applicability, assumptions, data needs, implementation cost, verification route, reason to try, and reason to reject.
-
-## Isolated campaign
-
-For genuinely hard multi-direction problems, give isolated subagents independent briefs and prevent cross-talk. Require a counterexample family, the first unproved step, honest evidence level, and direction-exhaustion discipline. The coordinator reads final reports and adjudicates.
-
-## Wall memo
-
-A direction may be abandoned only when refuted, blocked by a precise missing tool/theory/information, or after natural variants are exhausted. Write:
-
-- target and direction;
-- paths tried and evidence;
-- exact wall and wall type;
-- breakthrough condition;
-- restart checklist.
-
-On a new tool, model, source, or resumed request, scan wall memos before restarting from zero.
-~~~
-
-- [ ] **Step 5: Create tool adapter policy**
-
-Create `skills/math-modeling-agent/references/tool-policy.md`:
-
-~~~markdown
-# Tool Policy
-
-## Capability discovery
-
-Run `scripts/capability-probe.mjs`; treat PATH hits as candidates, then verify version and usability through the available DSH shell. Record unavailable, candidate, available, or unknown with reason.
-
-## Python
-
-Use `scripts/python-environment.mjs`. Prefer uv, then an existing Python runtime plus venv. Keep the environment under the run directory. Install only required normalized PyPI package names; VCS URLs, local wheels, or arbitrary indexes require explicit user approval. Record lock, seed, command, workdir, timeout, stdout/stderr, exit code, and generated files.
-
-## Lean
-
-Never auto-install. Use only for formalizable obligations. Record Lean/Lake/library versions, axioms/imports, proof artifact, absence of sorry/admit, and a separate natural-language-to-formal-statement fidelity check.
-
-## Wolfram
-
-Never auto-install. Verify executable and license usability. Use for applicable symbolic, exact, or high-precision claims and state the exact coverage boundary.
-
-## Search, PDF, and images
-
-Use available web, PDF, vision/OCR, or local Python readers. Do not send private raw data in search queries. Missing capabilities lower evidence level rather than causing fabricated execution.
-~~~
-
-- [ ] **Step 6: Create state and recovery guidance**
-
-Create `skills/math-modeling-agent/references/state-recovery.md`:
-
-~~~markdown
-# State and Recovery
-
-Default run root: `math-modeling-runs/<task-id>/`.
-
-Required durable files:
-
-- run.json: atomic current snapshot;
-- ledger.json: scope, assumptions, claims, obligations, subproblems, candidates, and issues;
-- events.jsonl: append-only transition journal;
-- problem-brief.md and inputs.json;
-- attempts/<number>/report.md plus code/artifacts only when they exist;
-- research/sources.jsonl and methods.md only when research occurs;
-- walls/ only when a direction is abandoned;
-- reproducibility.json and final-report.md for terminal output.
-
-Use `scripts/run-state.mjs` for initialization, transition, validation, and recovery. A transition without evidence/issue references is invalid. Provider, parser, or verifier failure preserves raw output and the best candidate. Resume by validating state, recovering from the last journal snapshot when needed, then skipping hash-stable completed work.
-
-Failure classes include data missing/schema/leakage, tool unavailable/dependency/license, runtime/timeout/numerical instability, model/assumption/parameter, verification/formalization, citation/research, parser/provider, no progress, and budget exhausted.
-~~~
-
-- [ ] **Step 7: Create report contracts**
-
-Create `skills/math-modeling-agent/references/report-contract.md`:
-
-~~~markdown
-# Report Contract
-
-## Attempt report
-
-Every attempt report contains exactly:
-
-1. one round objective;
-2. candidate/direction;
-3. assumption delta;
-4. claims changed;
-5. actual execution or derivation artifacts;
-6. new evidence IDs;
-7. obligations closed;
-8. issues opened and closed;
-9. delta from prior attempt;
-10. valid-progress decision;
-11. budget usage;
-12. current status;
-13. one next action.
-
-Do not copy full prior solutions or private reasoning.
-
-## Terminal report
-
-State the frozen question, final scientific status, answer/recommendation, verified claims and evidence links, conditional/unresolved claims, assumptions and sensitivity, candidate comparison, data and parameter sources, validation, failure cases, limitations, reproducibility commands, and resume conditions when non-SOLVED.
-
-## Chat summary
-
-After each round show only attempt number, direction, tool execution status, obligations passed/failed, most important failure, artifact path, and next action.
-~~~
-
-- [ ] **Step 8: Create two minimal examples**
-
-Create `skills/math-modeling-agent/examples/minimal-run/README.md`:
-
-~~~markdown
-# Minimal Run Example
-
-Problem: solve 2x + 3 = 11.
-
-Mode: Fast.
-
-Claim C-001: x = 4.
-
-Evidence E-001: algebraic derivation.
-Evidence E-002: substitution 2(4) + 3 = 11.
-
-Status: SOLVED.
-
-No Python, Lean, Wolfram, research directory, or empty artifact directory is required.
-~~~
-
-Create `skills/math-modeling-agent/examples/resumed-run/README.md`:
-
-~~~markdown
-# Resumed Run Example
-
-A Standard optimization run reached VERIFY with candidate C-003 and evidence E-008 before interruption. `run.json` was corrupted after the journal append.
-
-Resume sequence:
-
-1. run `node scripts/run-state.mjs validate <run-root>`;
-2. run `node scripts/run-state.mjs recover <run-root>`;
-3. confirm C-003 remains the best candidate;
-4. rerun only the incomplete verifier;
-5. append a new evidence-linked transition.
-
-Previously hash-stable Python outputs are not recomputed.
-~~~
-
-- [ ] **Step 9: Verify every main-Skill resource exists**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: only the missing `math-modeling-audit` bundle keeps the Skill-count test red; no missing main-Skill resource errors.
-
-- [ ] **Step 10: Commit modeling references and examples**
-
-~~~bash
-git add skills/math-modeling-agent/references skills/math-modeling-agent/examples
-git commit -m "docs: add modeling evidence and recovery protocols"
-~~~
-
-
-
-### Task 7: Add the independent audit Skill
-
-**Files:**
-- Create: `skills/math-modeling-audit/SKILL.md`
-- Create: `skills/math-modeling-audit/references/verification-protocol.md`
-- Create: `skills/math-modeling-audit/references/evidence-levels.md`
-- Create: `skills/math-modeling-audit/references/data-citation-audit.md`
-- Create: `skills/math-modeling-audit/examples/audit-report.md`
-
-- [ ] **Step 1: Create the audit Skill interface**
-
-Create `skills/math-modeling-audit/SKILL.md`:
-
-~~~markdown
----
-name: math-modeling-audit
-description: This skill should be used when the user asks to "独立核验数学模型", "检查推导", "寻找反例", "审计建模报告", "verify this model", or needs an artifact-only adversarial audit of mathematical claims, data, code, results, or citations.
-whenToUse: Use for existing artifacts and papers; do not take over open-ended model construction or silently rewrite the audited work.
-user-invocable: true
----
-
-# Math Modeling Audit
-
-## Goal
-
-Independently decide which claims in an existing artifact pass, fail, or remain inconclusive, and why.
-
-## Interface
-
-Accept a model, derivation, code/result artifact, paper, or MathModelingAgent run. Optionally accept the original problem, target claims, and assurance level.
-
-Return per-claim verdicts, evidence levels, counterexamples, reproducibility findings, and residual risk.
-
-## Workflow
-
-1. Freeze the artifact set and record review coverage.
-2. Reconstruct claims, assumptions, obligations, and evidence without trusting the author’s summary.
-3. Apply `references/verification-protocol.md` and `references/evidence-levels.md`.
-4. Audit data, parameters, leakage, citations, and reproducibility with `references/data-citation-audit.md`.
-5. Recompute applicable formulas and results through independent tools.
-6. Seek boundary cases, counterexamples, alternative explanations, and simpler models.
-7. Output PASS, FAIL, or INCONCLUSIVE per claim; do not silently repair the source.
-
-## Invariants
-
-- Paper prose and solver success are not verification artifacts.
-- Missing evidence is reported, never supplied on the author’s behalf.
-- Lean verifies the formal statement, not its natural-language fidelity or data pipeline.
-
-## Boundaries
-
-Do not edit the audited artifact. Do not reward complexity or presentation without evidence.
-~~~
-
-- [ ] **Step 2: Create the generic verification protocol**
-
-Create `skills/math-modeling-audit/references/verification-protocol.md`:
-
-~~~markdown
-# Independent Verification Protocol
-
-## Freeze inputs
-
-Hash the exact artifact set, problem statement, data, code, configuration, and environment evidence. Record anything unavailable.
-
-## Rebuild the claim map
-
-For each material claim record exact text, source location, assumptions, required evidence, supplied evidence, and independent countercheck.
-
-## Attack order
-
-1. task coverage and proxy substitution;
-2. units, dimensions, domain, bounds, and constraints;
-3. derivation and implementation consistency;
-4. data leakage, labels, splits, preprocessing, and post-hoc parameters;
-5. baseline, uncertainty, sensitivity, and external validity;
-6. reproducibility and citation truth;
-7. counterexamples, failure cases, and simpler alternatives.
-
-## Verdicts
-
-- PASS: required obligation is supported by reproducible evidence.
-- FAIL: a contradiction, counterexample, invalid method, or failed reproduction defeats the claim.
-- INCONCLUSIVE: evidence is insufficient or unavailable.
-
-Never convert INCONCLUSIVE to PASS because the approach looks reasonable.
-~~~
-
-- [ ] **Step 3: Create evidence-level guidance**
-
-Create `skills/math-modeling-audit/references/evidence-levels.md`:
-
-~~~markdown
-# Evidence Levels
-
-- NOT_CHECKED: no independent check.
-- DERIVED: transparent reasoning exists but was not executed.
-- EXECUTED: a tool ran and produced an artifact; correctness is not implied.
-- VERIFIED: the artifact passed its stated obligation and counterchecks.
-- INDEPENDENTLY_VERIFIED: a separate method/context reproduced or proved the claim.
-- EXTERNALLY_VALIDATED: independent real data, known theorem, or primary source supports applicability.
-
-Evidence strength must match claim strength. A training score cannot support generalization; one returned optimizer point cannot support global optimality; a formal proof cannot support unformalized real-world assumptions.
-~~~
-
-- [ ] **Step 4: Create data and citation audit guidance**
-
-Create `skills/math-modeling-audit/references/data-citation-audit.md`:
-
-~~~markdown
-# Data and Citation Audit
-
-## Data
-
-Map each key dataset to source, time, geography, sample size, unit, labels, preprocessing, split, and consuming model. Check duplicates, selection/survivor bias, time/future leakage, group leakage, normalization/feature selection outside training folds, and repeated test-set tuning.
-
-## Parameters
-
-Map each key parameter to value, unit, source, setting time, estimation/calibration route, allowed range, sensitivity, and whether it was changed after seeing results. Unsupported conclusion-sensitive values are Achilles’ heels.
-
-## Citations
-
-Verify author, title, year, venue, DOI/stable URL, version, retrieval date, exact page/section/theorem/table, excerpt, mapped claim, and whether evidence is full text, abstract only, metadata only, secondary, conflicting, or citation needed.
-
-Never invent a DOI, page, quotation, source, data set, or annual contest rule.
-~~~
-
-- [ ] **Step 5: Create the generic audit example**
-
-Create `skills/math-modeling-audit/examples/audit-report.md`:
-
-~~~markdown
-# Audit Example
-
-## Claim C-004
-
-Claim: “The returned point is the global optimum.”
-
-Evidence supplied: one successful SLSQP run.
-
-Verdict: INCONCLUSIVE.
-
-Reason: solver success supports a stationary/best-found point only. The artifact contains no convexity proof, certified bound, multi-start/global search, or optimality gap.
-
-Required upgrade: weaken the claim to “best found local solution” or add an appropriate global-optimality certificate.
-~~~
-
-- [ ] **Step 6: Run the complete package integrity test**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: all package and Skill integrity tests PASS; catalog contains exactly `math-modeling-agent` and `math-modeling-audit`.
-
-- [ ] **Step 7: Commit the independent audit Skill**
-
-~~~bash
-git add skills/math-modeling-audit tests/plugin-integrity.test.mjs
-git commit -m "feat: add independent mathematical audit skill"
-~~~
-
-
-
-### Task 8: Add deterministic MCM/ICM score arithmetic and cap enforcement
-
-**Files:**
-- Create: `tests/mcm-score.test.mjs`
-- Create: `skills/math-modeling-audit/scripts/mcm-score.mjs`
-
-- [ ] **Step 1: Write failing scorer tests**
-
-Create `tests/mcm-score.test.mjs`:
-
-~~~javascript
-import assert from 'node:assert/strict'
-import test from 'node:test'
-
-import {
-  RUBRIC,
-  scoreReview,
-} from '../skills/math-modeling-audit/scripts/mcm-score.mjs'
-
-function perfectScores() {
-  return Object.fromEntries(
-    Object.entries(RUBRIC).map(([id, maximum]) => [
-      id,
-      { score: maximum, evidence: ['paper p.1'] },
-    ]),
-  )
-}
-
-function allOutstandingGates(value = true) {
-  return {
-    taskComplete: value,
-    noMajorError: value,
-    coreValidated: value,
-    meaningfulSensitivity: value,
-    parametersSupported: value,
-    summaryStrong: value,
-    nonTemplateModeling: value,
-    closedLoop: value,
-    reproducible: value,
-    memorableContribution: value,
-  }
-}
-
-function input(overrides = {}) {
-  return {
-    schemaVersion: 1,
-    scores: perfectScores(),
-    caps: [],
-    awardCeilings: [],
-    outstandingGates: allOutstandingGates(),
-    disqualificationRisk: null,
-    ...overrides,
-  }
-}
-
-test('perfect supported review scores 100 and remains Outstanding', () => {
-  const result = scoreReview(input())
-  assert.equal(result.rawScore, 100)
-  assert.equal(result.cappedScore, 100)
-  assert.equal(result.finalBand, 'Outstanding Candidate')
-  assert.equal(result.outstandingGatePassed, true)
-})
-
-test('unvalidated core model applies the 84 cap', () => {
-  const result = scoreReview(input({
-    caps: [{ code: 'CORE_UNVALIDATED', evidence: 'No holdout or external validation.' }],
-  }))
-  assert.equal(result.strictestCap, 84)
-  assert.equal(result.cappedScore, 84)
-  assert.equal(result.finalBand, 'Meritorious')
-})
-
-test('multiple numeric caps apply the strictest one', () => {
-  const result = scoreReview(input({
-    caps: [
-      { code: 'NOT_REPRODUCIBLE', evidence: 'Algorithm settings absent.' },
-      { code: 'DATA_LEAKAGE', evidence: 'Target used during feature construction.' },
-    ],
-  }))
-  assert.equal(result.strictestCap, 69)
-  assert.equal(result.cappedScore, 69)
-  assert.equal(result.finalBand, 'Honorable Mention')
-})
-
-test('missing core task removes Outstanding and Finalist eligibility', () => {
-  const result = scoreReview(input({
-    awardCeilings: [{ code: 'MISSING_CORE_TASK', evidence: 'Problem 3 has no answer.' }],
-  }))
-  assert.equal(result.cappedScore, 100)
-  assert.equal(result.awardCeiling, 'Meritorious')
-  assert.equal(result.finalBand, 'Meritorious')
-})
-
-test('disqualification risk suppresses ordinary score requirements and output', () => {
-  const result = scoreReview({
-    schemaVersion: 1,
-    scores: {},
-    caps: [],
-    awardCeilings: [],
-    outstandingGates: {},
-    disqualificationRisk: {
-      code: 'FABRICATED_REFERENCE',
-      evidence: 'The cited DOI does not resolve and the title cannot be found.',
-    },
-  })
-  assert.equal(result.disqualification, true)
-  assert.equal(result.rawScore, null)
-  assert.equal(result.categoryScores, null)
-  assert.equal(result.outstandingGatePassed, null)
-  assert.equal(result.finalBand, 'Disqualification Risk')
-})
-
-test('every subscore and cap requires evidence', () => {
-  const scores = perfectScores()
-  scores['1.summary'] = { score: 4, evidence: [] }
-  assert.throws(() => scoreReview(input({ scores })), /evidence/)
-  assert.throws(
-    () => scoreReview(input({ caps: [{ code: 'MATH_ERROR', evidence: '' }] })),
-    /evidence/,
-  )
-})
-~~~
-
-- [ ] **Step 2: Run the scorer test and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/mcm-score.test.mjs
-~~~
-
-Expected: FAIL with `ERR_MODULE_NOT_FOUND` for `mcm-score.mjs`.
-
-- [ ] **Step 3: Implement fixed rubric, cap, ceiling, and disqualification logic**
-
-Create `skills/math-modeling-audit/scripts/mcm-score.mjs`:
-
-~~~javascript
-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
-  })
-}
-~~~
-
-- [ ] **Step 4: Run scorer tests**
-
-Run:
-
-~~~bash
-node --test tests/mcm-score.test.mjs
-~~~
-
-Expected: 6 tests PASS, 0 failures.
-
-- [ ] **Step 5: Commit deterministic scoring**
-
-~~~bash
-git add tests/mcm-score.test.mjs skills/math-modeling-audit/scripts/mcm-score.mjs
-git commit -m "feat: add deterministic mcm icm scoring"
-~~~
-
-
-
-### Task 9: Add the MCM/ICM final-panel rubric and golden output
-
-**Files:**
-- Modify: `skills/math-modeling-audit/SKILL.md`
-- Create: `skills/math-modeling-audit/references/mcm-icm-final-judge.md`
-- Create: `skills/math-modeling-audit/examples/mcm-final-review.md`
-
-- [ ] **Step 1: Extend the audit Skill only after the scorer exists**
-
-In `skills/math-modeling-audit/SKILL.md`, replace the frontmatter description with:
-
-~~~yaml
-description: This skill should be used when the user asks to "独立核验数学模型", "检查推导", "寻找反例", "审计建模报告", "按 MCM/ICM 终审框架打分", "verify this model", or needs an artifact-only adversarial audit of mathematical claims, data, code, results, citations, or a competition paper.
-~~~
-
-Replace the Interface paragraphs with:
-
-~~~markdown
-Accept a paper, model, derivation, code/result artifact, or MathModelingAgent run. Optionally accept the original problem, competition year/code, target claims, and assurance level.
-
-Return per-claim verdicts, evidence levels, counterexamples, reproducibility findings, residual risk, and—only for MCM/ICM judging intent—the fixed final-panel report.
-~~~
-
-Replace workflow Step 7 with:
-
-~~~markdown
-7. Output PASS, FAIL, or INCONCLUSIVE per claim; do not silently repair the source.
-8. For MCM/ICM scoring intent only, load `references/mcm-icm-final-judge.md`, validate arithmetic with `scripts/mcm-score.mjs`, and preserve its fourteen-section output.
-~~~
-
-After the Lean invariant, add:
-
-~~~markdown
-- A score never feeds back into the solver’s SOLVED gate.
-- Disqualification risk stops ordinary award scoring.
-~~~
-
-Replace the Boundaries paragraph with:
-
-~~~markdown
-Do not edit the audited artifact. Do not reward complexity or presentation without evidence. Do not load the large MCM/ICM rubric for generic audits.
-~~~
-
-- [ ] **Step 2: Run integrity test and verify RED for newly named resources**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: FAIL because `references/mcm-icm-final-judge.md` does not exist yet; the already implemented scorer path exists.
-
-- [ ] **Step 3: Create the complete final-judge reference**
-
-Create `skills/math-modeling-audit/references/mcm-icm-final-judge.md`:
-
-~~~markdown
-# MCM/ICM Final Judging Panel
-
-This is a simulated 100-point final-panel framework, not a COMAP official quantitative scorecard. Review as if the paper is competing for Outstanding Winner or Finalist. Do not coach, reward effort, or supply missing evidence.
-
-## Non-negotiable principles
-
-- Do not assume the model is correct.
-- Complexity, machine learning, optimization, neural networks, Monte Carlo, AHP, TOPSIS, entropy weights, or named algorithms earn no automatic innovation credit.
-- Reject formulas without mechanism, results without traceable computation, figures without conclusions, and formalistic sensitivity analysis that misses critical parameters.
-- Distinguish plausible from validated and a number from a credible modeling result.
-- Cite page, section, equation, table, figure, or exact value whenever possible.
-- If evidence is absent, write “论文未提供证据”.
-
-## Stage 1: veto and award caps
-
-Classify each item as 通过, 警告, 严重问题, or 一票否决风险:
-
-1. every subproblem is answered;
-2. no omission, off-target answer, or proxy substituted for the requested metric;
-3. no critical mathematical formula error;
-4. no dimensional, unit, or order-of-magnitude error;
-5. no key result violates constraints;
-6. summary, body, tables, and figures agree numerically;
-7. conclusions follow from model and computation;
-8. critical parameters have a source or defensible estimate;
-9. critical model and algorithm are reproducible;
-10. no data/future leakage or train-test mixing;
-11. sources, data, and references are traceable and non-fabricated;
-12. external methods, algorithms, images, and data are cited;
-13. applicable annual COMAP page, anonymity, submission, citation, and AI/disclosure rules are satisfied;
-14. core prediction/optimization/decision results are validated;
-15. model structure fits the real mechanism or the mismatch is discussed.
-
-Apply evidence-linked caps:
-
-- missing core subtask: Outstanding and Finalist normally unavailable;
-- conclusion-changing main-model math error: cap 69;
-- completely unvalidated core prediction/optimization/decision model: cap 84;
-- unsupported highly sensitive core parameter: cap 79;
-- irreproducible critical result: cap 79;
-- clear leakage or answer-information training: cap 69;
-- main conclusion conflicts with calculation/figure: cap 74;
-- almost no quantitative result: cap 59;
-- suspected fabricated data/reference, plagiarism, or serious rule violation: stop ordinary scoring and report Disqualification Risk.
-
-## Stage 2: 100-point scoring
-
-### 1. Problem understanding, decomposition, and summary — 10
-
-#### 1.1 Summary Sheet — 4
-
-Check whether a 60-second reader learns the problem, models, method per subproblem, core quantitative results, recommendation, validation, and numbers consistent with the body. “Good performance” without numbers is weak evidence.
-
-#### 1.2 Understanding and decomposition — 3
-
-Check every explicit task, hidden constraint, practical objective, stakeholder, subproblem relation, and whether the paper solved an easier substitute problem.
-
-#### 1.3 Assumptions, definitions, boundaries — 3
-
-Check completeness, necessity, realism, simplification rationale, applicability, distinction among fact/assumption/setting, and support from data, literature, or sensitivity.
-
-### 2. Data, evidence, and parameters — 12
-
-#### 2.1 Source credibility — 3
-
-For every key dataset record name, source, time, sample size, unit, and consuming model. Check temporal/spatial match, conflicts, update frequency, and traceability.
-
-#### 2.2 Cleaning and preprocessing — 2
-
-Check missing values, outliers, scaling, interpolation, smoothing, trend creation, method explanation, and before-after comparison.
-
-#### 2.3 Representativeness, bias, leakage — 2
-
-Check selection, survivor, temporal, spatial, and entity bias; train/validation/test separation; future and target leakage.
-
-#### 2.4 Parameter determination and calibration — 3
-
-Every key parameter must come from data estimation, literature, theory, calibration, inverse optimization, justified expert input, or an explicitly tested scenario. Unsupported values such as “let alpha=0.5” are penalized.
-
-#### 2.5 Data-parameter-model consistency — 2
-
-Check unit, temporal, and spatial consistency; physical meaning; whether data supports variables; and whether variables were invented only to fit a method.
-
-### 3. Model formulation — 22
-
-#### 3.1 Mechanism-to-mathematics mapping — 5
-
-Check whether variables, equations, probability structure, objective, and constraints correspond to the real mechanism rather than mathematical assembly.
-
-#### 3.2 Valuable innovation — 4
-
-Credit mechanism design, justified coupling, structural adaptation, meaningful new indicators, evidence-based correction, or a genuinely useful solver. Do not credit stacking, deep learning by name, jargon, or unnecessary parameters. Ask whether a simpler model gives essentially the same answer.
-
-#### 3.3 Variables, objective, constraints, equations — 4
-
-Check every symbol, objective fidelity, complete real constraints, mathematical correctness, units, initial conditions, and boundary conditions.
-
-#### 3.4 Assumption and internal consistency — 3
-
-Check contradictions among assumptions/equations, changing parameter meanings, reused symbols, and circular logic.
-
-#### 3.5 Complexity and explainability — 3
-
-Check necessary complexity, overfitting, removable modules, interpretability, and fit to a four-day contest.
-
-#### 3.6 Multi-subproblem unity — 3
-
-Check whether earlier results genuinely support later tasks and whether the paper forms problem → core model → extension → verification → decision rather than a model collage.
-
-### 4. Mathematical solution, algorithm, reproducibility — 16
-
-#### 4.1 Derivation correctness — 4
-
-Audit probability, calculus, differential/difference equations, matrices, statistics, normalization, weights, and recurrences. State whether an error changes the conclusion.
-
-#### 4.2 Algorithms and numerical methods — 4
-
-Check method suitability, initial values, stop/convergence conditions, numerical stability, hyperparameters, seeds, and local-versus-global claims.
-
-#### 4.3 Reproducibility — 3
-
-Check inputs, parameters, steps, outputs, code/pseudocode, and figure-to-computation traceability.
-
-#### 4.4 Complexity, convergence, optimality — 3
-
-Check time/space complexity, convergence, grid convergence, optimality proof/gap, baselines for heuristics, and multi-start tests.
-
-#### 4.5 Sanity checks — 2
-
-Check extremes, magnitude, bounds, units, sums/probabilities, resource capacities, nonnegative time, and common-sense violations.
-
-### 5. Results, validation, robustness, credibility — 24
-
-#### 5.1 Task completion — 4
-
-Build requirement → model → output → conclusion mapping. A method without the requested number, ranking, strategy, prediction, or decision is incomplete.
-
-#### 5.2 Numerical correctness and internal consistency — 4
-
-Audit the three to ten most important results: value, unit, page, model, input, computation path, reproducibility, plausibility, validation, and PASS/WARNING/FAIL. Compare summary, body, tables, figures, and repeated values.
-
-#### 5.3 Baseline and controls — 3
-
-Check naive, traditional, historical, official, current, random, or literature baselines. A standalone 91% result has no comparative meaning.
-
-#### 5.4 Sensitivity — 4
-
-Identify truly critical parameters first. Check realistic perturbation, quantitative output change, thresholds, rank reversal, and failure. Ask how far a parameter moves before the conclusion changes.
-
-#### 5.5 Robustness and uncertainty — 4
-
-Check parameter, data, measurement, random, structural, and scenario uncertainty; Monte Carlo, bootstrap, confidence/prediction intervals, worst case, or robust optimization. Distinguish exact-looking numbers from credible intervals.
-
-#### 5.6 Independent/external validation — 3
-
-Prefer holdout, time extrapolation, backtest, real case, independent source, literature result, known theorem, or simulation-to-reality comparison. Training-data self-validation is weak.
-
-#### 5.7 Failure scenarios and counterexamples — 2
-
-Check extreme parameters, missing data, network failure, demand shock, environmental/policy change, and black swans. Outstanding papers know when they fail.
-
-### 6. Conclusions, practical meaning, generalization — 8
-
-#### 6.1 Model-grounded conclusions — 3
-
-Trace data → model → result → conclusion. Penalize correlation written as causation, unlimited extrapolation, or precise policy advice without computation.
-
-#### 6.2 Actionable recommendations — 2
-
-Identify actor, action, timing, cost, risk, resources, and implementation constraints.
-
-#### 6.3 Concrete limitations — 2
-
-Name the most dangerous assumption, missing data, sensitive parameter, failure condition, and bias direction—not “more work is needed”.
-
-#### 6.4 Transferability — 1
-
-Assess extension across region, time, scale, network, and policy scenario.
-
-### 7. Writing, figures, professional presentation — 8
-
-#### 7.1 Structure — 2
-
-Check logical service of sections, repetition, result-before-model reasoning, jumps, and clear section purpose.
-
-#### 7.2 Figures — 2
-
-Check necessity, axes, units, legend, self-contained caption, resolution, font, color, independent readability, and whether the figure supports a conclusion.
-
-#### 7.3 Language — 1
-
-Check concise, professional, accurate language without empty AI-style prose.
-
-#### 7.4 Notation and formulas — 1
-
-Check prior definition, consistency, numbering, units, and absence of decorative equations.
-
-#### 7.5 Citations — 1
-
-Check data, image, algorithm, and literature references and correspondence between text and bibliography.
-
-#### 7.6 Page efficiency — 1
-
-Check wasted space, unnecessary contents pages, code in body, hidden key reasoning, and information density under the page limit.
-
-## Stage 3: model-by-model autopsy
-
-For every M1, M2, ... report:
-
-- problem solved, inputs, outputs, core equations, parameters, assumptions;
-- why chosen and mechanism fit;
-- mathematical correctness and parameter interpretability;
-- solver and result;
-- validation, sensitivity, robustness;
-- strengths, most serious defect, simpler alternative, marginal value;
-- score /10 and retain/simplify/restructure/untrustworthy.
-
-Conclude unified system or model collage.
-
-## Stage 4: key-result audit
-
-Use:
-
-| ID | Result | Source | Unit | Model | Reproducible | Magnitude | Validated | Importance | Verdict |
-|---|---|---|---|---|---|---|---|---|---|
-
-Then answer:
-
-1. most credible result;
-2. most fragile result;
-3. result most dependent on manual parameters;
-4. result most exposed to data failure;
-5. result whose failure collapses the paper;
-6. precision illusion;
-7. all constraints satisfied;
-8. better solution possibly missed;
-9. stability under ±5%, ±10%, ±20% input perturbations;
-10. reason to trust for real decisions.
-
-## Stage 5: type-specific module
-
-- MCM A: ODE/PDE/difference equations, initial/boundary conditions, dimensions, discretization, grid convergence, stability, parameter estimation, physical meaning.
-- MCM B: graph/combinatorial structure, dynamic/integer programming, correctness, complexity, optimality, scalability.
-- MCM C: quality, leakage, splits, feature engineering, variable selection, multicollinearity, overfitting, baselines, metrics, calibration, uncertainty, interpretation.
-- ICM D: network construction, node/edge meaning, weights, metrics, objective, constraints, optimization, scale, perturbation stability.
-- ICM E: boundary, time scale, lifecycle, environmental-economic-social tradeoff, weights, scenarios, uncertainty, long-run and unintended consequences.
-- ICM F: correlation/causality, behavior, stakeholders, fairness, cost, incentives, execution, scenarios, unintended and heterogeneous effects.
-
-## Stage 6: award judgment
-
-Reference bands:
-
-- 93–100 Outstanding Candidate;
-- 87–92 Finalist;
-- 78–86 Meritorious;
-- 68–77 Honorable Mention;
-- 55–67 Successful Participant;
-- below 55 Unsuccessful Risk.
-
-Outstanding additionally requires complete tasks, no major math/logic error, credible core validation, meaningful sensitivity/robustness, sourced key parameters, strong Summary Sheet, non-template modeling, closed model-result-conclusion loop, reproducibility, and one memorable contribution. High score without gates is Finalist or below.
-
-## Required final output
-
-Use exactly these top-level sections and fields.
-
-### 一、60 秒终审印象
-
-Paper objective; core methods; core results; strongest point; most serious first-impression problem; continue reading: 是/勉强/否.
-
-### 二、一票否决与奖项封顶检查
-
-For each risk: risk; evidence; severity; cap triggered; cap level.
-
-### 三、总体评价与最终得分
-
-Composite score /100; raw score; capped score; predicted award; Outstanding probability; Finalist-or-higher probability; core advantages; fatal weaknesses.
-
-### 四、100 分分项评分
-
-| 一级指标 | 二级指标 | 得分 | 满分 | 评委意见 |
-|---|---|---:|---:|---|
-
-Every row needs evidence.
-
-### 五、题目要求覆盖矩阵
-
-| 题目要求 | 是否完成 | 使用模型 | 最终结果 | 验证情况 | 判定 |
-|---|---|---|---|---|---|
-
-Find omissions and proxy answers.
-
-### 六、模型逐个尸检
-
-Review M1, M2, M3 separately using the autopsy template.
-
-### 七、建模结果专项审计
-
-Provide R1, R2, ... table and judge correctness, credibility, robustness, reproducibility, and practical meaning.
-
-### 八、数据与参数审计
-
-| 参数 | 数值 | 来源 | 是否有依据 | 敏感性 | 风险 |
-|---|---:|---|---|---|---|
-
-Name Achilles’ heel parameters.
-
-### 九、灵敏度、稳健性与验证专项评价
-
-State what authors did, omitted, whether existing analysis is effective or formalistic, and validation needed for Finalist/Outstanding.
-
-### 十、数学与计算正确性抽查
-
-Check at least three formulas, three numbers, one algorithm, one figure, and one final conclusion when available; recompute when possible.
-
-### 十一、图表与写作评审
-
-Name best/worst/delete/add figures, hardest and most wasteful sections, and whether Summary Sheet is final-round quality.
-
-### 十二、Outstanding Winner 差距分析
-
-Explain why another paper wins; missing decisive evidence; current award level; three blockers to Finalist; three blockers to Outstanding; genuine innovation; removable model.
-
-### 十三、修改优先级
-
-P0 no high award without fix; P1 Meritorious vs Finalist; P2 Finalist vs Outstanding; P3 polish. Every item states problem, severity, fix, expected gain, and low/medium/high cost.
-
-### 十四、评委最终裁决
-
-One-sentence summary; most likely award; recommend Final Round yes/no; Head Judge defense yes/no; reason; final verdict.
-
-Do not inflate for encouragement. Use “技术复杂度高于证据强度” or “presentation quality exceeds modeling quality” when supported. The final question is how credible the conclusions are and why they belong among the best papers.
-~~~
-
-- [ ] **Step 4: Create a complete fourteen-section golden example**
-
-Create `skills/math-modeling-audit/examples/mcm-final-review.md`:
-
-~~~markdown
-# MCM/ICM Final Review Example
-
-## 一、60 秒终审印象
-
-- 这篇论文试图解决什么：多阶段资源配置。
-- 核心方法：线性规划与情景分析。
-- 核心结果：方案 A 的报告成本最低，但未提供可复现求解日志。
-- 最大亮点：约束映射清楚。
-- 第一眼最严重的问题：核心优化没有独立验证。
-- 评委是否愿意继续认真阅读：勉强。
-
-## 二、一票否决与奖项封顶检查
-
-- 风险：核心优化模型完全没有验证。
-- 证据：论文第 12 页仅报告求解器 success，无基线、gap 或复算。
-- 严重程度：严重问题。
-- 是否触发封顶：是。
-- 封顶等级：84。
-
-## 三、总体评价与最终得分
-
-- 综合得分：84/100。
-- 原始得分：90/100。
-- 封顶后得分：84/100。
-- 获奖等级预测：Meritorious。
-- Outstanding 概率：2%。
-- Finalist 及以上概率：18%。
-- 核心优势：机制与约束清楚。
-- 致命弱点：结果证据不足。
-
-## 四、100 分分项评分
-
-| 一级指标 | 二级指标 | 得分 | 满分 | 评委意见 |
-|---|---|---:|---:|---|
-| 结果与验证 | 独立验证 | 0 | 3 | 第 12 页未提供独立证据。 |
-
-## 五、题目要求覆盖矩阵
-
-| 题目要求 | 是否完成 | 使用模型 | 最终结果 | 验证情况 | 判定 |
-|---|---|---|---|---|---|
-| 最优配置 | 表面完成 | 线性规划 | 方案 A | 未验证 | WARNING |
-
-## 六、模型逐个尸检
-
-M1 线性规划：可简化；模型评分 7/10；缺少最优性与复现证据。
-
-## 七、建模结果专项审计
-
-| ID | Result | Source | Unit | Model | Reproducible | Magnitude | Validated | Importance | Verdict |
-|---|---|---|---|---|---|---|---|---|---|
-| R1 | 方案 A 成本最低 | p.12 | USD | M1 | 否 | 合理 | 否 | 核心 | WARNING |
-
-## 八、数据与参数审计
-
-| 参数 | 数值 | 来源 | 是否有依据 | 敏感性 | 风险 |
-|---|---:|---|---|---|---|
-| 惩罚系数 | 0.5 | 无 | 否 | 未分析 | 高 |
-
-## 九、灵敏度、稳健性与验证专项评价
-
-作者只扰动非关键需求参数；未分析惩罚系数和可行域变化，因此现有分析形式主义。
-
-## 十、数学与计算正确性抽查
-
-材料不足以完成三项数值复算；该缺口保留为未验证，不补造结果。
-
-## 十一、图表与写作评审
-
-最好图为图 3；最差且应删除图为无单位的图 7；应增加约束 slack 与基线对比图。
-
-## 十二、Outstanding Winner 差距分析
-
-真正的 Outstanding 会提供最优性、基线、敏感性和复现证据；本稿技术复杂度高于证据强度。
-
-## 十三、修改优先级
-
-P0：补充可复现求解、约束检查和独立复算；预计提升高；成本中。
-
-## 十四、评委最终裁决
-
-- 一句话总结：模型合理但核心结果未被证明可信。
-- 最可能奖项：Meritorious。
-- 是否推荐进入 Final Round：否。
-- 如果我是 Head Judge，我是否会为这篇论文辩护：否。
-- 理由：缺少决定性结果证据。
-- 最终 verdict：Meritorious，不能因表达漂亮上调。
-~~~
-
-- [ ] **Step 5: Re-run package integrity and scorer tests**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs tests/mcm-score.test.mjs
-~~~
-
-Expected: all tests PASS and every MCM/ICM resource named by the audit Skill exists.
-
-- [ ] **Step 6: Commit the final-judge rubric and example**
-
-~~~bash
-git add skills/math-modeling-audit/SKILL.md skills/math-modeling-audit/references/mcm-icm-final-judge.md skills/math-modeling-audit/examples/mcm-final-review.md
-git commit -m "feat: add mcm icm final judging mode"
-~~~
-
-
-
-### Task 10: Write the single bilingual README and lock user-facing behavior
-
-**Files:**
-- Modify: `tests/plugin-integrity.test.mjs`
-- Create: `README.md`
-
-- [ ] **Step 1: Add failing README contract checks**
-
-Append to `tests/plugin-integrity.test.mjs`:
-
-~~~javascript
-test('README documents verified installation, degradation, scoring, and uninstall', async () => {
-  const readme = await read('README.md')
-  assert.match(readme, /dsh plugin --profile web add github:yohanchen1\/MathModelingAgent#v0\.1\.0/)
-  assert.match(readme, /dsh --profile web --dump-config/)
-  assert.match(readme, /restart|重启/i)
-  assert.match(readme, /Python.*optional|Python.*可选/is)
-  assert.match(readme, /Lean.*optional|Lean.*可选/is)
-  assert.match(readme, /Wolfram.*optional|Wolfram.*可选/is)
-  assert.match(readme, /MCM\/ICM/)
-  assert.match(readme, /math-modeling-runs/)
-  assert.match(readme, /dsh plugin --profile web remove dsh-math-modeling-agent/)
-})
-~~~
-
-- [ ] **Step 2: Run integrity test and verify RED**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: FAIL with `ENOENT` for `README.md`.
-
-- [ ] **Step 3: Create the concise bilingual README**
-
-Create `README.md`:
-
-~~~markdown
-# MathModelingAgent for DSH / 数学建模智能体
-
-An installable DeepSeek Harness bundle for evidence-driven mathematical modeling, computation, research, independent verification, and MCM/ICM final-panel review.
-
-一个可一键安装的 DSH 数学建模 Bundle：渐进式澄清问题、按需调用 Python/Lean/Wolfram、搜索文献与替代方法、记录每轮试错，并以证据而不是模型自信决定结论状态。
-
-## Install / 安装
-
-Pinned GitHub release / 固定 GitHub 版本：
-
-~~~bash
-dsh plugin --profile web add github:yohanchen1/MathModelingAgent#v0.1.0
-~~~
-
-After the npm release / npm 发布后：
-
-~~~bash
-dsh plugin --profile web add dsh-math-modeling-agent
-~~~
-
-Verify the composed profile / 验证配置：
-
-~~~bash
-dsh --profile web --dump-config
-~~~
-
-Restart the running DSH host after installation, then start the Web profile:
-安装后需重启当前 DSH host，再启动 Web profile：
-
-~~~bash
-dsh web
-~~~
-
-## Use / 使用
-
-Describe the task naturally. Internal phases and tools are selected automatically.
-直接描述任务，不需要记住 Skill 名称或选择内部流程。
-
-Examples / 示例：
-
-- “建立并验证这个优化问题的数学模型，附件中有 Excel 数据。”
-- “Continue the modeling run in math-modeling-runs/supply-plan.”
-- “按 MCM/ICM 终审 100 分框架审查这篇论文，先做封顶检查。”
-
-## What happens / 工作流程
-
-1. Classify the problem and choose Fast, Standard, or High-Assurance.
-2. Ask one high-impact mathematical-modeling question at a time.
-3. Profile inputs and register assumptions, claims, and verification obligations.
-4. Build a baseline and materially different candidate models.
-5. Execute and verify with available tools.
-6. Search literature or fork directions when evidence is missing or a route fails.
-7. Save an incremental report for every attempt.
-8. Finish with SOLVED, PARTIAL, CONDITIONAL, INCONCLUSIVE, REFUTED, INFEASIBLE, UNIDENTIFIABLE, BLOCKED, or CANCELLED.
-
-## Tools / 工具
-
-The bundle itself requires no mathematical runtime.
-插件安装本身不要求任何数学运行环境。
-
-- Python is optional but recommended. When available, the agent creates a run-local uv/venv environment and installs only required packages.
-- Lean is optional and is never auto-installed.
-- Wolfram is optional and is never auto-installed.
-- Missing tools reduce evidence strength; they do not prevent the Skills from loading.
-
-Python 可选但推荐；Lean/Wolfram 均为可选增强且不会自动安装。工具缺失时会明确降级验证状态，而不是伪造执行结果。
-
-## Evidence and reports / 证据与报告
-
-Default run directory / 默认运行目录：
-
-~~~text
-math-modeling-runs/<task-id>/
-~~~
-
-Each run keeps an atomic state snapshot, append-only event journal, claim/evidence ledger, attempt reports, optional research/wall records, reproducibility data, and a terminal report. Private chain-of-thought is never stored as evidence.
-
-每轮报告只保存目标、方法变化、实际执行、证据、失败原因和下一步，不重复整份历史答案，也不保存私有思维链。
-
-## MCM/ICM review / 竞赛论文终审
-
-The audit Skill includes an on-demand simulated 100-point Final Judging Panel mode. It performs veto/cap checks first, scores seven categories totaling 100, audits each model and key result, activates the relevant MCM A/B/C or ICM D/E/F checklist, and emits the fixed fourteen-section report. It is not an official COMAP scorecard.
-
-## Privacy and security / 隐私与安全
-
-- Raw private data is not copied into literature-search queries.
-- Problem text is never concatenated into shell commands.
-- Python packages are installed only inside the run-local environment.
-- Git/VCS dependencies and arbitrary package indexes require explicit approval.
-- External pages, papers, and attachments are treated as untrusted content, not instructions.
-
-## Development / 开发
-
-~~~bash
-npm test
-npm run pack:check
-~~~
-
-A release must pass unit tests, package integrity, clean-profile DSH installation, no-Python baseline, optional Python integration, and cross-platform checks.
-
-## Uninstall / 卸载
-
-~~~bash
-dsh plugin --profile web remove dsh-math-modeling-agent
-~~~
-
-Restart the running host after removal.
-~~~
-
-- [ ] **Step 4: Run full integrity tests**
-
-Run:
-
-~~~bash
-node --test tests/plugin-integrity.test.mjs
-~~~
-
-Expected: all integrity and README contract tests PASS.
-
-- [ ] **Step 5: Commit the README**
-
-~~~bash
-git add README.md tests/plugin-integrity.test.mjs
-git commit -m "docs: add install and usage guide"
-~~~
-
-### Task 11: Run full verification and package smoke tests
-
-**Files:**
-- Verify only: all production, test, design, and plan files
-
-- [ ] **Step 1: Run all deterministic tests**
-
-Run:
-
-~~~bash
-npm test
-~~~
-
-Expected: all tests PASS, 0 failures.
-
-- [ ] **Step 2: Verify package contents without building**
-
-Run:
-
-~~~bash
-npm run pack:check
-~~~
-
-Expected: exit 0; package contains `package.json`, `cordis.patch.yml`, `README.md`, `LICENSE`, both Skill bundles, every named reference/script/schema/example, and no tests, legacy Python, logs, data, or design documents.
-
-- [ ] **Step 3: Verify local DSH installation on Windows via package tarball**
-
-Verified finding: `dsh plugin --profile smoke add .` installs the directory basename as a plain dependency and never activates the bundle. Always install by package name (tarball, GitHub spec, or npm).
-
-Run from the plugin root in PowerShell:
-
-~~~powershell
-$oldHome = $env:DSH_HOME
-$packDir = Join-Path $env:TEMP ("mma-pack-" + [guid]::NewGuid().ToString("N"))
-New-Item -ItemType Directory -Path $packDir | Out-Null
-try {
-  npm pack --pack-destination $packDir | Out-Null
-  $tgz = Get-ChildItem -LiteralPath $packDir -Filter '*.tgz' | Select-Object -First 1
-  $tempHome = Join-Path $env:TEMP ("dsh-mma-smoke-" + [guid]::NewGuid().ToString("N"))
-  $env:DSH_HOME = $tempHome
-  dsh plugin --profile smoke add (Join-Path $packDir $tgz.Name)
-  if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-
-  $dump = dsh --profile smoke --dump-config
-  if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-  $dump | Select-String 'dsh-math-modeling-agent-skills'
-  $dump | Select-String 'bundledSkillDir'
-
-  dsh plugin --profile smoke remove dsh-math-modeling-agent
-  if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
-} finally {
-  $env:DSH_HOME = $oldHome
-}
-~~~
-
-Expected: the profile records `dsh-math-modeling-agent` in `dsh.profile.bundles`, dump contains the Skill provider row and `bundledSkillDir`, removal succeeds, and the user’s normal `DSH_HOME` is untouched.
-
-- [ ] **Step 4: Verify local DSH installation on Linux/macOS CI**
-
-Run:
-
-~~~bash
-old_home="${DSH_HOME-}"
-pack_dir="$(mktemp -d)"
-temp_home="$(mktemp -d)"
-npm pack --pack-destination "$pack_dir" >/dev/null
-export DSH_HOME="$temp_home"
-dsh plugin --profile smoke add "$pack_dir"/dsh-math-modeling-agent-0.1.0.tgz
-dsh --profile smoke --dump-config | grep 'dsh-math-modeling-agent-skills'
-dsh --profile smoke --dump-config | grep 'bundledSkillDir'
-dsh plugin --profile smoke remove dsh-math-modeling-agent
-export DSH_HOME="$old_home"
-~~~
-
-Expected: the same install/dump/remove behavior as Windows.
-
-- [ ] **Step 5: Run static repository checks**
-
-Run:
-
-~~~bash
-git diff --check
-git status --short
-git grep -n -E 'C:\\Users\\16605|\.claude[/\\]plugins|GEMINI_API_KEY|google-generativeai|run_logs|thinking_log' -- ':!docs/superpowers/**'
-~~~
-
-Expected:
-
-- `git diff --check` emits nothing;
-- `git status --short` contains only the implementation-plan file if it was not committed before execution;
-- the grep command returns no production matches.
-
-- [ ] **Step 6: Review the final file inventory for minimality**
-
-Run:
-
-~~~bash
-git ls-files
-~~~
-
-Expected: only the files declared by the approved spec plus design/plan documentation. No empty directories, duplicated protocols, lockfile without dependencies, generated package tarball, coverage output, legacy code, or temporary artifacts.
-
-- [ ] **Step 7: Commit any final verified documentation-only corrections**
-
-If verification required a factual README or reference correction, make only that correction, rerun Steps 1–6, then commit:
-
-~~~bash
-git add README.md skills
-git commit -m "docs: correct verified plugin guidance"
-~~~
-
-If no correction was required, do not create an empty commit.
-
-## Plan self-review checklist
-
-- [ ] Every approved spec section maps to at least one task above.
-- [ ] Exactly two public Skills are created.
-- [ ] The four deterministic Modules have stable interfaces and tests.
-- [ ] Python, Lean, and Wolfram remain optional at install time.
-- [ ] Every strong status is evidence-gated.
-- [ ] MCM/ICM subtotals equal 100 and caps are deterministic.
-- [ ] No task uses placeholders, “similar to”, or unspecified error handling.
-- [ ] Every code-changing step shows exact content or an exact replacement block.
-- [ ] Every task ends with a focused Conventional Commit.