@quadiusai/dsh-greenharness 0.0.0-stage → 0.1.1

package/bench/presets/mock-chat-template.json

@@ -0,0 +1,40 @@
+{
+  "description": "The mock preset with the NeMo-style thinking switch on both routes: chat_template_kwargs.enable_thinking follows the tier's reasoning effort. It checks the request body that a chat-template server such as vLLM would receive. Still a mock, not a model.",
+  "mock": true,
+  "routes": {
+    "mock-small": {
+      "baseURL": "http://127.0.0.1:8124/v1",
+      "api": "openai-completions",
+      "displayName": "Mock small",
+      "compat": {
+        "thinkingFormat": "chat-template",
+        "chatTemplateKwargs": { "enable_thinking": { "$var": "thinking.enabled" } }
+      },
+      "models": [{
+        "id": "mock-bolt-e4b",
+        "name": "Mock Bolt E4B",
+        "contextWindow": 65536,
+        "reasoningEfforts": { "off": null, "high": "high" }
+      }]
+    },
+    "mock-large": {
+      "baseURL": "http://127.0.0.1:8124/v1",
+      "api": "openai-completions",
+      "displayName": "Mock large",
+      "compat": {
+        "thinkingFormat": "chat-template",
+        "chatTemplateKwargs": { "enable_thinking": { "$var": "thinking.enabled" } }
+      },
+      "models": [{
+        "id": "mock-lightning-30b",
+        "name": "Mock Lightning",
+        "contextWindow": 262144,
+        "reasoningEfforts": { "off": null, "high": "high" }
+      }]
+    }
+  },
+  "tiers": {
+    "small": { "provider": "mock-small", "model": "mock-bolt-e4b", "reasoningEffort": "off" },
+    "large": { "provider": "mock-large", "model": "mock-lightning-30b", "reasoningEffort": "high" }
+  }
+}

package/bench/presets/mock.json

@@ -0,0 +1,32 @@
+{
+  "description": "Scripted mock server on 127.0.0.1. It checks routing and context edits only; it is not a model and measures no quality.",
+  "mock": true,
+  "routes": {
+    "mock-small": {
+      "baseURL": "http://127.0.0.1:8124/v1",
+      "api": "openai-completions",
+      "displayName": "Mock small",
+      "models": [{
+        "id": "mock-bolt-e4b",
+        "name": "Mock Bolt E4B",
+        "contextWindow": 65536,
+        "reasoningEfforts": { "off": null, "high": "high" }
+      }]
+    },
+    "mock-large": {
+      "baseURL": "http://127.0.0.1:8124/v1",
+      "api": "openai-completions",
+      "displayName": "Mock large",
+      "models": [{
+        "id": "mock-lightning-30b",
+        "name": "Mock Lightning",
+        "contextWindow": 262144,
+        "reasoningEfforts": { "off": null, "high": "high" }
+      }]
+    }
+  },
+  "tiers": {
+    "small": { "provider": "mock-small", "model": "mock-bolt-e4b", "reasoningEffort": "off" },
+    "large": { "provider": "mock-large", "model": "mock-lightning-30b", "reasoningEffort": "high" }
+  }
+}

package/bench/presets/nemo-brev.json

@@ -0,0 +1,40 @@
+{
+  "description": "Live NeMo models on a Brev instance, reached through port-forwards on localhost. The large tier is Nemotron 3.5 Lightning 30B-A3B (BF16). The small tier is Nemotron 3.5 Bolt E4B, whose model id, serve command and thinking switch are NOT verified; see bench/BREV.md before trusting its numbers.",
+  "mock": false,
+  "routes": {
+    "nemo-bolt-e4b": {
+      "baseURL": "http://127.0.0.1:8001/v1",
+      "api": "openai-completions",
+      "displayName": "Nemotron 3.5 Bolt E4B (Brev, unverified)",
+      "compat": {
+        "thinkingFormat": "chat-template",
+        "chatTemplateKwargs": { "enable_thinking": { "$var": "thinking.enabled" } }
+      },
+      "models": [{
+        "id": "nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB",
+        "name": "Nemotron 3.5 Bolt E4B",
+        "contextWindow": 65536,
+        "reasoningEfforts": { "off": null, "high": "high" }
+      }]
+    },
+    "nemo-lightning-30b": {
+      "baseURL": "http://127.0.0.1:8000/v1",
+      "api": "openai-completions",
+      "displayName": "Nemotron 3.5 Lightning 30B-A3B (Brev)",
+      "compat": {
+        "thinkingFormat": "chat-template",
+        "chatTemplateKwargs": { "enable_thinking": { "$var": "thinking.enabled" } }
+      },
+      "models": [{
+        "id": "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16",
+        "name": "Nemotron 3.5 Lightning 30B-A3B",
+        "contextWindow": 262144,
+        "reasoningEfforts": { "off": null, "high": "high" }
+      }]
+    }
+  },
+  "tiers": {
+    "small": { "provider": "nemo-bolt-e4b", "model": "nvidia/NVIDIA-Nemotron-3.5-Bolt-E4B-4GB", "reasoningEffort": "off" },
+    "large": { "provider": "nemo-lightning-30b", "model": "nvidia/NVIDIA-Nemotron-3.5-Lightning-30B-A3B-BF16", "reasoningEffort": "high" }
+  }
+}

package/bench/run-case.mjs

@@ -0,0 +1,242 @@
+#!/usr/bin/env node
+/**
+ * Run one benchmark case through the real DSH headless runner and report what happened.
+ *
+ *   node bench/run-case.mjs --task subtract-bug --arm greenharness --scenario subtract-fix --out <dir>
+ *   node bench/run-case.mjs --task subtract-bug --arm always-large --preset nemo-brev --out <dir>
+ *
+ * Arms:
+ *   greenharness  DSH with the GreenHarness plugin: the small tier by default, escalating on verifier failures.
+ *   always-large  DSH without the plugin; every model call uses the large tier (the single-model baseline).
+ *   always-small  DSH without the plugin; every model call uses the small tier.
+ *
+ * Presets (bench/presets/<name>.json) name the routes and the two tiers. A preset with "mock": true
+ * (such as `mock`) points its routes at a scripted OpenAI-compatible server (plumbing only, not a
+ * model) and needs --scenario. Live presets serve real models and run the task from its TASK.md;
+ * they take no --scenario.
+ *
+ * Environment: DSH_BIN (the dsh binary, default `dsh`), NEMO_API_KEY (default: a placeholder for
+ * local servers that do not check keys).
+ *
+ * Writes under --out: workspace/ (the task after the run), patch.yml, ledger.jsonl, requests.jsonl
+ * (mock only), stdout.txt, stderr.txt and summary.json. The verdict is an independent re-run of
+ * `node --test` in the workspace, not the agent's own claim.
+ */
+import { execFile } from 'node:child_process'
+import { existsSync, readFileSync } from 'node:fs'
+import { cp, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { startMockServer } from './mock-openai-server.mjs'
+import { renderPatch } from './lib/patch.mjs'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const pluginRoot = resolve(here, '..')
+const ARMS = ['greenharness', 'always-large', 'always-small']
+const DEFAULT_PROMPT = 'Fix the failing tests in this project. Run node --test to check your work.'
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2))
+  const { task, arm, scenario, out, preset = 'mock', port = '8124' } = options
+  if (!task || !out || !ARMS.includes(arm)) {
+    console.error(`usage: node bench/run-case.mjs --task <dir under bench/tasks> --arm <${ARMS.join('|')}> --out <dir> [--preset mock|nemo-brev] [--scenario <name>] [--port 8124]`)
+    process.exitCode = 2
+    return
+  }
+
+  const outDir = resolve(out)
+  await rm(outDir, { recursive: true, force: true })
+  await mkdir(outDir, { recursive: true })
+  const workspace = join(outDir, 'workspace')
+  await cp(join(here, 'tasks', task), workspace, { recursive: true })
+  const prompt = existsSync(join(workspace, 'TASK.md')) ? await readFile(join(workspace, 'TASK.md'), 'utf8') : DEFAULT_PROMPT
+
+  const spec = JSON.parse(await readFile(join(here, 'presets', `${preset}.json`), 'utf8'))
+  const routes = structuredClone(spec.routes)
+  let mock
+  if (spec.mock === true) {
+    if (!scenario) throw new Error('a mock preset needs --scenario <name>')
+    const script = JSON.parse(await readFile(join(here, 'scenarios', `${scenario}.json`), 'utf8'))
+    mock = await startMockServer({ port: Number(port), steps: script.steps, logPath: join(outDir, 'requests.jsonl') })
+    for (const route of Object.values(routes)) route.baseURL = mock.url
+  }
+
+  const tiers = arm === 'always-large' ? { small: spec.tiers.large, large: spec.tiers.large }
+    : arm === 'always-small' ? { small: spec.tiers.small, large: spec.tiers.small }
+      : spec.tiers
+  const patchPath = join(outDir, 'patch.yml')
+  await writeFile(patchPath, renderPatch({
+    routes,
+    tiers,
+    greenharness: arm === 'greenharness',
+    pluginEntry: join(pluginRoot, 'src', 'index.mjs'),
+    ledgerPath: join(outDir, 'ledger.jsonl'),
+  }))
+
+  const started = Date.now()
+  let session
+  try {
+    session = await run(process.env.DSH_BIN ?? 'dsh', ['headless', '--patch', patchPath, prompt], {
+      cwd: workspace,
+      env: { ...process.env, DSH_HOME: join(outDir, 'dsh-home'), NEMO_API_KEY: process.env.NEMO_API_KEY ?? 'local-dev-no-auth' },
+      timeout: 15 * 60 * 1000,
+    })
+  } finally {
+    if (mock) await mock.close()
+  }
+  const wallSeconds = (Date.now() - started) / 1000
+  await writeFile(join(outDir, 'stdout.txt'), session.stdout)
+  await writeFile(join(outDir, 'stderr.txt'), session.stderr)
+
+  // TAP output has the `# pass N` lines that matchCount reads; the default reporter does not.
+  const suite = await run(process.execPath, ['--test', '--test-reporter=tap'], { cwd: workspace, timeout: 5 * 60 * 1000 })
+  const ledger = readJsonl(join(outDir, 'ledger.jsonl'))
+  const requests = mock ? readJsonl(join(outDir, 'requests.jsonl')) : []
+  // A problem makes the run fail loudly. Without these checks, a wrong DSH_BIN or a plugin that
+  // did not load would look like a finished run, and the greenharness arm would quietly be a baseline.
+  const problems = []
+  if (session.code !== 0) problems.push(`DSH exited with code ${session.code}; read stderr.txt`)
+  if (arm === 'greenharness' && !ledger.some(record => record.type === 'request')) {
+    problems.push('GreenHarness recorded no model calls, so the plugin probably did not load; read stderr.txt for "failed to import" or "did not activate"')
+  }
+  const summary = {
+    arm,
+    task,
+    preset,
+    scenario: scenario ?? null,
+    wallSeconds,
+    dshExitCode: session.code,
+    dshTimedOut: session.timedOut,
+    problems,
+    suite: { exitCode: suite.code, pass: matchCount(suite.stdout, 'pass'), fail: matchCount(suite.stdout, 'fail') },
+    finalText: session.stdout.trim(),
+    ledger: summarizeLedger(ledger),
+    ...(mock ? { mock: summarizeMock(requests) } : {}),
+  }
+  await writeFile(join(outDir, 'summary.json'), `${JSON.stringify(summary, null, 2)}\n`)
+  console.log(JSON.stringify(summary, null, 2))
+  for (const problem of problems) console.error(`problem: ${problem}`)
+  if (problems.length > 0) process.exitCode = 1
+}
+
+/**
+ * Run a command and resolve with its exit code and output. Never rejects.
+ * @param {string} command
+ * @param {string[]} args
+ * @param {import('node:child_process').ExecFileOptions} [options]
+ */
+function run(command, args, options = {}) {
+  return new Promise((done) => {
+    execFile(command, args, { maxBuffer: 256 * 1024 * 1024, ...options }, (error, stdout, stderr) => {
+      // A program that never started (for example, a wrong DSH_BIN) has no numeric exit code.
+      // Keep its message, or stderr.txt stays empty and the failure is invisible.
+      const startFailure = error && typeof error.code !== 'number' ? `${error.message}\n` : ''
+      done({
+        code: error ? (typeof error.code === 'number' ? error.code : 1) : 0,
+        stdout: String(stdout ?? ''),
+        stderr: String(stderr ?? '') + startFailure,
+        timedOut: error?.killed === true,
+      })
+    })
+  })
+}
+
+/**
+ * @param {string} text - TAP output.
+ * @param {'pass' | 'fail'} kind
+ */
+function matchCount(text, kind) {
+  const match = new RegExp(`^# ${kind} (\\d+)$`, 'm').exec(text)
+  return match ? Number(match[1]) : null
+}
+
+/** @param {string} path */
+function readJsonl(path) {
+  if (!existsSync(path)) return []
+  return readFileSync(path, 'utf8').split('\n').filter(line => line.trim() !== '').map(line => JSON.parse(line))
+}
+
+/**
+ * What the ledger says the run cost and did.
+ * @param {Array<Record<string, any>>} records
+ */
+function summarizeLedger(records) {
+  const requests = records.filter(r => r.type === 'request')
+  const tools = records.filter(r => r.type === 'tool')
+  const usage = { inputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, outputTokens: 0 }
+  for (const request of requests) {
+    for (const key of Object.keys(usage)) usage[key] += request.usage?.[key] ?? 0
+  }
+  return {
+    model_calls: requests.length,
+    tiers: countBy(requests, r => r.tier),
+    models: countBy(requests, r => `${r.provider}/${r.model}`),
+    usage,
+    costUsd: sum(requests, r => (Number.isFinite(r.costUsd) ? r.costUsd : 0)),
+    route_changes: records.filter(r => r.type === 'route').map(r => `${r.from}->${r.to} (${r.reason})`),
+    loop_breaks: records.filter(r => r.type === 'loop-break').length,
+    tool_actions: countBy(tools, r => `${r.tool}:${r.action}`),
+    errors: records.filter(r => r.type === 'error').map(r => `${r.stage}: ${r.message}`),
+  }
+}
+
+/**
+ * What the mock server saw: which model served each agent call, and what the model was shown.
+ * @param {Array<Record<string, any>>} records
+ */
+function summarizeMock(records) {
+  const agent = records.filter(r => r.agentCall)
+  const toolResults = records.flatMap(r => r.toolMessages ?? [])
+  return {
+    agent_calls: agent.length,
+    side_calls: records.length - agent.length,
+    served_models: countBy(agent, r => r.model),
+    prompt_tokens_est: sum(agent, r => r.promptTokens),
+    cached_tokens_est: sum(agent, r => r.cachedTokens),
+    model_notices_sent: sum(records, r => r.noticeCount ?? 0),
+    saw_distill_footer: toolResults.some(t => t.includes('[greenharness: distilled')),
+    saw_dedupe_stub: toolResults.some(t => t.includes('[greenharness: this read returns the same lines')),
+    saw_loop_guard_denial: toolResults.some(t => t.includes('GreenHarness loop guard')),
+  }
+}
+
+/**
+ * @template T
+ * @param {T[]} items
+ * @param {(item: T) => unknown} key
+ */
+function countBy(items, key) {
+  const counts = {}
+  for (const item of items) {
+    const name = String(key(item))
+    counts[name] = (counts[name] ?? 0) + 1
+  }
+  return counts
+}
+
+/**
+ * @template T
+ * @param {T[]} items
+ * @param {(item: T) => unknown} pick
+ */
+function sum(items, pick) {
+  return items.reduce((total, item) => total + (Number(pick(item)) || 0), 0)
+}
+
+/** @param {string[]} argv */
+function parseArgs(argv) {
+  const options = {}
+  for (let i = 0; i < argv.length; i += 2) {
+    const key = argv[i]
+    if (!key?.startsWith('--') || argv[i + 1] === undefined) {
+      throw new Error(`expected --name value pairs, got: ${argv.slice(i).join(' ')}`)
+    }
+    options[key.slice(2)] = argv[i + 1]
+  }
+  return options
+}
+
+main().catch((error) => {
+  console.error(error)
+  process.exitCode = 1
+})

package/bench/run-mock-suite.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+/**
+ * Runs every scripted scenario under every arm and prints one table. It is a plumbing check: the
+ * mock is scripted, so the numbers show routing and context edits, not model quality or real cost.
+ *
+ *   npm run bench:mock            (needs Node 24 and DSH: set DSH_BIN, or put `dsh` on PATH)
+ *
+ * Results land under BENCH_OUT (default: runs/mock). Each case also writes its own summary.json.
+ */
+import { execFile } from 'node:child_process'
+import { readFile, readdir, writeFile, mkdir } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const here = dirname(fileURLToPath(import.meta.url))
+const outRoot = resolve(process.env.BENCH_OUT ?? join(here, '..', 'runs', 'mock'))
+const ARMS = ['greenharness', 'always-large', 'always-small']
+
+const scenarios = (await readdir(join(here, 'scenarios')))
+  .filter(name => name.endsWith('.json'))
+  .map(name => name.replace(/\.json$/, ''))
+  .sort()
+
+const rows = []
+for (const scenario of scenarios) {
+  for (const arm of ARMS) {
+    const out = join(outRoot, `${scenario}-${arm}`)
+    await runCase(['--task', 'subtract-bug', '--arm', arm, '--scenario', scenario, '--out', out, '--preset', 'mock'])
+    rows.push(await readRow(scenario, arm, join(out, 'summary.json')))
+  }
+}
+
+const table = renderTable(rows)
+await mkdir(outRoot, { recursive: true })
+await writeFile(join(outRoot, 'SUMMARY.md'), `${table}\n\nMock token counts are characters divided by four. They are not a tokenizer and not a bill.\n`)
+console.log(table)
+
+/** @param {string[]} args */
+function runCase(args) {
+  return new Promise((done) => {
+    execFile(process.execPath, [join(here, 'run-case.mjs'), ...args], { env: process.env, maxBuffer: 64 * 1024 * 1024 }, (error, _stdout, stderr) => {
+      if (error) console.error(`case failed: ${args.join(' ')}\n${stderr}`)
+      done()
+    })
+  })
+}
+
+/**
+ * @param {string} scenario
+ * @param {string} arm
+ * @param {string} path
+ */
+async function readRow(scenario, arm, path) {
+  try {
+    const summary = JSON.parse(await readFile(path, 'utf8'))
+    const served = summary.mock?.served_models ?? {}
+    return {
+      scenario,
+      arm,
+      calls: summary.mock?.agent_calls ?? 0,
+      served: `${served['mock-bolt-e4b'] ?? 0} small / ${served['mock-lightning-30b'] ?? 0} large`,
+      promptEst: summary.mock?.prompt_tokens_est ?? 0,
+      cachedEst: summary.mock?.cached_tokens_est ?? 0,
+      suite: summary.suite?.fail === null ? 'not run' : `${summary.suite.pass} pass / ${summary.suite.fail} fail`,
+      distilled: summary.ledger?.tool_actions?.['bash:distill'] ?? 0,
+      deduped: summary.ledger?.tool_actions?.['read:dedupe'] ?? 0,
+      routes: summary.ledger?.route_changes?.length ?? 0,
+      loopDenied: summary.mock?.saw_loop_guard_denial === true,
+      errors: summary.ledger?.errors?.length ?? 0,
+    }
+  } catch (error) {
+    return { scenario, arm, error: String(error?.message ?? error) }
+  }
+}
+
+/** @param {Array<Record<string, any>>} rows */
+function renderTable(rows) {
+  const header = '| scenario | arm | agent calls | served by | prompt tokens (est.) | cached (est.) | suite | distilled | deduped | route changes | loop denied | errors |'
+  const rule = '|---|---|---:|---|---:|---:|---|---:|---:|---:|---|---:|'
+  const body = rows.map((row) => {
+    if (row.error) return `| ${row.scenario} | ${row.arm} | error: ${row.error} |`
+    return `| ${row.scenario} | ${row.arm} | ${row.calls} | ${row.served} | ${row.promptEst} | ${row.cachedEst} | ${row.suite} | ${row.distilled} | ${row.deduped} | ${row.routes} | ${row.loopDenied ? 'yes' : 'no'} | ${row.errors} |`
+  })
+  return [header, rule, ...body].join('\n')
+}

package/bench/scenarios/loop-stuck.json

@@ -0,0 +1,11 @@
+{
+  "description": "Keep re-running a failing command with no edits. The loop breaker should deny the repeat after three identical failures.",
+  "steps": [
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "content": "Stopping: the tests keep failing." }
+  ]
+}

package/bench/scenarios/subtract-fix.json

@@ -0,0 +1,12 @@
+{
+  "description": "Run the suite (fails), read the source twice (the second read should dedupe), fix subtract with an exact edit, rerun twice (passes), then finish.",
+  "steps": [
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "tool_calls": [{ "name": "read", "arguments": { "file_path": "src/math.mjs" } }] },
+    { "tool_calls": [{ "name": "read", "arguments": { "file_path": "src/math.mjs" } }] },
+    { "tool_calls": [{ "name": "edit", "arguments": { "file_path": "src/math.mjs", "old_string": "export function subtract(a, b) {\n  return a + b", "new_string": "export function subtract(a, b) {\n  return a - b" } }] },
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "tool_calls": [{ "name": "bash", "arguments": { "command": "node --test", "description": "Run the test suite" } }] },
+    { "content": "Fixed subtract to return a - b. All tests pass." }
+  ]
+}

package/bench/tasks/subtract-bug/TASK.md

@@ -0,0 +1,2 @@
+The `subtract` function in `src/math.mjs` returns the wrong result. Make `node --test` pass
+without changing the tests. Keep the change minimal.

package/bench/tasks/subtract-bug/package.json

@@ -0,0 +1,9 @@
+{
+  "name": "subtract-bug",
+  "version": "1.0.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "test": "node --test"
+  }
+}

package/bench/tasks/subtract-bug/src/math.mjs

@@ -0,0 +1,8 @@
+export function add(a, b) {
+  return a + b
+}
+
+// Bug: subtract should return a - b.
+export function subtract(a, b) {
+  return a + b
+}

package/bench/tasks/subtract-bug/test/math.test.mjs

@@ -0,0 +1,11 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { add, subtract } from '../src/math.mjs'
+
+test('adds two numbers', () => {
+  assert.equal(add(2, 3), 5)
+})
+
+test('subtracts b from a', () => {
+  assert.equal(subtract(5, 3), 2)
+})

package/bench/tasks/subtract-bug/test/noise.test.mjs

@@ -0,0 +1,9 @@
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+
+// Passing filler that makes the raw runner output long, so distillation has work to do.
+for (let i = 0; i < 300; i += 1) {
+  test(`filler case ${i}`, () => {
+    assert.ok(i >= 0)
+  })
+}

package/cordis.patch.yml

@@ -0,0 +1,4 @@
+# Mounted by `dsh plugin --profile <name> add @quadiusai/dsh-greenharness`. Every setting has a default.
+- insert:
+    - id: greenharness
+      name: '@quadiusai/dsh-greenharness'

package/package.json

@@ -1,6 +1,44 @@
 {
   "name": "@quadiusai/dsh-greenharness",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1",
+  "description": "GreenHarness: a DeepSeek Harness (dsh) plugin that cuts token, GPU and dollar cost in multi-step agent workflows. Install with one command; control it with /greenharness.",
+  "type": "module",
+  "main": "src/index.mjs",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "files": [
+    "src",
+    "bench",
+    "cordis.patch.yml",
+    "README.md",
+    "GETTING-STARTED.md"
+  ],
+  "scripts": {
+    "test": "node --test test/*.test.mjs",
+    "bench:mock": "node bench/run-mock-suite.mjs",
+    "mock-server": "node bench/mock-openai-server.mjs"
+  },
+  "engines": {
+    "node": ">=22.19.0"
+  },
+  "keywords": [
+    "dsh",
+    "deepseek-harness",
+    "cordis",
+    "agents",
+    "nvidia",
+    "nemotron",
+    "finops",
+    "green-ai"
+  ],
+  "license": "MIT",
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "~3.18.5"
+  }
+}