topo-workbench 0.0.1 → 1.0.1

package/README.md

@@ -1,5 +1,31 @@
 # topo-workbench
 
-The command-line runner for Workbench, the benchmark behind [Model Topography](https://modeltopography.com).
+Run [Workbench](https://modeltopography.com), the Model Topography benchmark, on any model you can reach, then submit
+the run for grading. Workbench is a [Harbor](https://harborframework.com) dataset, `model-topography/workbench@1.0`: 12
+tasks across Entry, Middle Management and Senior Executive work.
 
-Not released yet. `npx topo-workbench run` will start a benchmark run once Workbench launches.
+Install it, check your setup, run, and submit:
+
+```sh
+npm install --global topo-workbench
+topo-workbench doctor
+OPENROUTER_API_KEY=... topo-workbench run --agent opencode --model openrouter/moonshotai/kimi-k3
+topo-workbench submit workbench-jobs/2026-10-23__12-00-00
+```
+
+- **Any agent Harbor runs:** `claude-code`, `codex`, `gemini-cli`, `kimi-cli`, `grok-build`, `opencode`, `mini-swe-agent`,
+  `openhands`, `aider`, `goose` and more.
+- **Any model:** name its provider first: `openrouter/...`, `deepseek/...`, `gemini/...`, `xai/...`, `anthropic/...`. The run
+  may reach that provider's API and nothing else. Name another endpoint with `--allow-host`.
+- **Your key stays yours.** It is read from your environment, used by your run, and never uploaded. `submit` refuses to
+  upload a job that holds a key or a residual personal identifier. Before submitting, create an owner-only
+  `~/.config/mtb-export/identifiers` file with one personal identifier per line. `submit` scrubs that list, Codex
+  creator IDs, and your home directory from a staged copy. It rejects residual text, binary identifiers, and unsafe
+  symbolic links. Use `--identifiers FILE` to use another owner-only file.
+- **Community full sample.** The default is 10 attempts at each task. Use `--task` or `--tier` to try a few first.
+- **Published point eligibility.** A point needs at least five scored attempts at every size. It reports its actual
+  attempt counts. Partial and top-up campaigns can pool when they use the same task conditions.
+- **Grading is sealed.** Your run does not grade itself. The maintainers grade the uploaded trials with the private
+  grader, and the result joins the map once its campaign is published.
+
+Requirements: Docker, Node 22 or newer, and Harbor 0.23.0 (`uv tool install harbor==0.23.0`).

package/bin/topo-workbench.js

@@ -1,2 +1,5 @@
 #!/usr/bin/env node
-console.log('Workbench is not released yet. Follow https://modeltopography.com for launch.');
+import { main } from '../lib/cli.js';
+// Every error ends here as one line and a failing exit code, never a stack trace.
+try { process.exitCode = await main(); }
+catch (error) { console.error(`topo-workbench: ${error.message}`); process.exitCode = 1; }

package/lib/cli.js

@@ -0,0 +1,163 @@
+// topo-workbench: run Workbench on any model with Harbor, then submit the run for grading. The grader is sealed
+// (Dan, 2026-10-11, 2A), so a run here never grades itself: Harbor runs with verification off, and the maintainers
+// regrade the uploaded trials with the private grader before a point reaches the map.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { parseArgs } from 'node:util';
+import { hostsFor, providerOf, PROVIDERS } from './providers.js';
+import { findPersonalData, findSecrets, readIdentifiers, scrubPersonalData } from './scrub.js';
+
+export const HARBOR_VERSION = '0.23.0';
+export const DATASET = 'model-topography/workbench@1.0';
+export const ORG = 'model-topography';
+export const REPOSITORY = 'ddmirolli/workbench';
+// Community runs default to the 10-attempt full sample. A published point needs five scored attempts at every size.
+export const FULL_SAMPLE = 10;
+
+const USAGE = `topo-workbench: run Workbench on any model, then submit the run for grading.
+
+  topo-workbench doctor
+  topo-workbench run --agent AGENT --model PROVIDER/MODEL [--reasoning LEVEL] [--attempts 10] [--concurrent 4]
+                     [--tier entry|management|executive ...] [--task workbench-management-4 ...] [--allow-host HOST ...] [--out DIR] [-- HARBOR_ARGS]
+  topo-workbench submit JOB_DIRECTORY [--dry-run] [--identifiers FILE]
+
+AGENT is any Harbor agent: claude-code, codex, gemini-cli, kimi-cli, opencode, mini-swe-agent, openhands, aider, goose...
+Your own provider key is read from your environment (for example OPENROUTER_API_KEY) and never uploaded.
+Docs: https://modeltopography.com/participate`;
+
+const run = (command, args, options = {}) => spawnSync(command, args, { encoding: 'utf8', ...options });
+
+export function harborVersion(harbor = 'harbor') {
+  const out = run(harbor, ['--version']);
+  return out.status === 0 ? out.stdout.trim().split(/\s+/).pop() : null;
+}
+export function doctor({ harbor = 'harbor', log = console.log } = {}) {
+  const problems = [];
+  const docker = run('docker', ['info', '--format', '{{.ServerVersion}}']);
+  if (docker.status !== 0) problems.push('Docker is not running. Start Docker Desktop or the Docker daemon.');
+  const version = harborVersion(harbor);
+  if (!version) problems.push(`Harbor is not installed. Install it: uv tool install harbor==${HARBOR_VERSION}`);
+  else if (version !== HARBOR_VERSION) problems.push(`Harbor ${version} is installed; Workbench is measured with ${HARBOR_VERSION}: uv tool install --force harbor==${HARBOR_VERSION}`);
+  const major = Number(process.versions.node.split('.')[0]);
+  if (major < 22) problems.push(`Node ${process.versions.node}; Workbench needs Node 22 or newer.`);
+  for (const problem of problems) log(`- ${problem}`);
+  if (!problems.length) log(`Ready: Docker, Harbor ${HARBOR_VERSION}, Node ${process.versions.node}.`);
+  return problems;
+}
+
+// How each agent takes a reasoning level. Agents not listed take theirs through `-- --ak key=value`.
+export function reasoningArgs(agent, level) {
+  if (!level) return [];
+  if (agent === 'codex') return ['--ak', `config=${JSON.stringify({ model_reasoning_effort: level })}`];
+  if (agent === 'claude-code') return ['--ak', `reasoning_effort=${level}`];
+  throw new Error(`Pass ${agent}'s reasoning setting to Harbor directly: -- --ak KEY=VALUE`);
+}
+
+// The Harbor command for a run. Verification is off: the grader is sealed.
+export function runArgs(options) {
+  const { agent, model, reasoning, attempts = FULL_SAMPLE, concurrent = 4, tiers = [], tasks = [], allowHosts = [], out, dataset = DATASET, path: local, extra = [] } = options;
+  if (!agent) throw new Error('Name the agent: --agent claude-code, codex, opencode, ...');
+  if (!model) throw new Error('Name the model: --model PROVIDER/MODEL, such as openrouter/moonshotai/kimi-k2');
+  const args = ['run', ...(local ? ['-p', local] : ['-d', dataset]), '-a', agent, '-m', model, '-k', String(attempts), '-n', String(concurrent),
+    '--disable-verification', '-o', out,
+    // The runtime image's npm cache belongs to root; agents that install with npm need a cache they can write.
+    '--ae', 'NPM_CONFIG_CACHE=/tmp/npm-cache'];
+  for (const host of hostsFor(agent, model, allowHosts)) args.push('--allow-agent-host', host);
+  for (const tier of tiers) args.push('-i', `*workbench-${tier}-*`);
+  for (const task of tasks) args.push('-i', `*${task}`);
+  args.push(...reasoningArgs(agent, reasoning), ...extra);
+  return args;
+}
+
+// What a submission says about its run, read from Harbor's own job record.
+export function describeJob(job) {
+  const config = JSON.parse(fs.readFileSync(path.join(job, 'config.json'), 'utf8'));
+  const trials = fs.readdirSync(job, { withFileTypes: true }).filter(e => e.isDirectory() && fs.existsSync(path.join(job, e.name, 'result.json'))).map(e => e.name);
+  const agent = config.agents?.[0] ?? config.agent ?? {};
+  return { agent: agent.name ?? null, model: agent.model_name ?? null, kwargs: agent.kwargs ?? {}, trials: trials.length,
+    tasks: [...new Set(trials.map(t => t.split('__')[0]))].sort() };
+}
+
+// A scrubbed copy of the job. It removes creator IDs, listed personal identifiers, and the home directory. The
+// original stays untouched. The staged copy must also pass the key, residual-data, and symbolic-link checks.
+export function stageJob(job, staging, { home = os.homedir(), secrets = [], identifiers = [] } = {}) {
+  fs.rmSync(staging, { recursive: true, force: true });
+  fs.cpSync(job, staging, { recursive: true, verbatimSymlinks: true });
+  const walk = directory => { for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+    const file = path.join(directory, entry.name);
+    if (entry.isDirectory()) walk(file);
+    else if (entry.isFile()) {
+      const bytes = fs.readFileSync(file);
+      if (bytes.includes(0)) continue;
+      const text = bytes.toString('utf8'), clean = scrubPersonalData(text, { identifiers, home });
+      if (clean !== text) fs.writeFileSync(file, clean);
+    }
+  } };
+  walk(staging);
+  // Harbor names an uploaded job by its config's job_name, or by the upload time when there is none, and a download
+  // expects that name as the archive's folder: the copy names itself after its folder.
+  const config = path.join(staging, 'config.json');
+  if (fs.existsSync(config)) { const value = JSON.parse(fs.readFileSync(config, 'utf8')); if (!value.job_name) fs.writeFileSync(config, JSON.stringify({ ...value, job_name: path.basename(staging) }, null, 2)); }
+  const stagingName = path.basename(staging);
+  return [...findSecrets(staging, { secrets, stagingName }), ...findPersonalData(staging, { identifiers, home, stagingName })];
+}
+
+export async function main(argv = process.argv.slice(2), { harbor = 'harbor', log = console.log, env = process.env } = {}) {
+  const [command, ...rest] = argv;
+  const split = rest.indexOf('--'), own = split < 0 ? rest : rest.slice(0, split), extra = split < 0 ? [] : rest.slice(split + 1);
+  if (command === 'doctor') return doctor({ harbor, log }).length ? 1 : 0;
+  if (command === 'run') {
+    const { values } = parseArgs({ args: own, options: { agent: { type: 'string' }, model: { type: 'string' }, reasoning: { type: 'string' },
+      attempts: { type: 'string' }, concurrent: { type: 'string' }, tier: { type: 'string', multiple: true }, task: { type: 'string', multiple: true }, 'allow-host': { type: 'string', multiple: true },
+      out: { type: 'string' }, dataset: { type: 'string' }, path: { type: 'string' } } });
+    if (doctor({ harbor, log: () => {} }).length) { doctor({ harbor, log }); return 1; }
+    const provider = providerOf(values.agent, values.model);
+    if (provider && PROVIDERS[provider].key && !env[PROVIDERS[provider].key] && !['claude-code', 'codex'].includes(values.agent))
+      log(`Note: ${PROVIDERS[provider].key} is not set; the agent may not reach ${provider}.`);
+    const out = path.resolve(values.out ?? 'workbench-jobs');
+    const args = runArgs({ agent: values.agent, model: values.model, reasoning: values.reasoning, attempts: Number(values.attempts ?? FULL_SAMPLE),
+      concurrent: Number(values.concurrent ?? 4), tiers: values.tier ?? [], tasks: values.task ?? [], allowHosts: values['allow-host'] ?? [], out, dataset: values.dataset, path: values.path, extra });
+    log(`harbor ${args.join(' ')}`);
+    const result = spawnSync(harbor, args, { stdio: 'inherit', env });
+    if (result.status === 0) {
+      const job = fs.existsSync(out) ? fs.readdirSync(out).filter(n => fs.existsSync(path.join(out, n, 'config.json'))).sort().at(-1) : null;
+      log(`\nDone. The default community sample is ${FULL_SAMPLE} attempts at each task. A published point needs at least five scored attempts at every size; compatible partial and top-up campaigns can pool. Submit it for grading: topo-workbench submit ${job ? path.join(out, job) : out + '/<job>'}`);
+    }
+    return result.status ?? 1;
+  }
+  if (command === 'submit') {
+    const { values, positionals } = parseArgs({ args: own, allowPositionals: true, strict: true,
+      options: { 'dry-run': { type: 'boolean' }, identifiers: { type: 'string' } } });
+    const dryRun = values['dry-run'] ?? false, job = positionals.length === 1 && path.resolve(positionals[0]);
+    if (!job || !fs.existsSync(path.join(job, 'config.json'))) { log('Name a Harbor job directory: topo-workbench submit workbench-jobs/2026-10-23__12-00-00'); return 1; }
+    let identifiers;
+    try { identifiers = readIdentifiers(values.identifiers); }
+    catch (error) { log(`Not uploaded: ${error.message}`); return 1; }
+    const secrets = Object.values(PROVIDERS).map(p => env[p.key]).filter(Boolean);
+    // The copy keeps the job's own folder name: Harbor names the uploaded job by it, and a download expects it.
+    const staging = path.join(fs.mkdtempSync(path.join(os.tmpdir(), 'topo-workbench-')), path.basename(job));
+    const findings = stageJob(job, staging, { secrets, identifiers });
+    if (findings.length) {
+      log('Not uploaded: the job holds what must stay on this machine.');
+      for (const f of findings) log(`- ${f.file}: ${f.kind}`);
+      return 1;
+    }
+    const described = describeJob(staging);
+    if (dryRun) { log(`Checked ${described.trials} trials (${described.agent}, ${described.model}): nothing that must stay on this machine. Staged at ${staging}.\nWithout --dry-run: harbor upload ${staging} --private --share-org ${ORG} -y, then a prefilled GitHub issue.`); return 0; }
+    log(`Uploading ${described.trials} trials (${described.agent}, ${described.model}) to Harbor Hub, shared with ${ORG}...`);
+    const upload = spawnSync(harbor, ['upload', staging, '--private', '--share-org', ORG, '-y'], { encoding: 'utf8', env });
+    process.stdout.write(upload.stdout ?? ''); process.stderr.write(upload.stderr ?? '');
+    if (upload.status !== 0) return upload.status ?? 1;
+    const hub = /(https:\/\/\S*hub\.harborframework\.com\S*)/.exec(upload.stdout ?? '')?.[1] ?? '(see the upload output above)';
+    const title = `Submission: ${described.model} with ${described.agent}`;
+    const body = [`Harbor job: ${hub}`, `Agent: ${described.agent}`, `Model: ${described.model}`, `Agent options: ${JSON.stringify(described.kwargs)}`,
+      `Trials: ${described.trials} across ${described.tasks.join(', ')}`, `topo-workbench: ${JSON.parse(fs.readFileSync(new URL('../package.json', import.meta.url), 'utf8')).version}`].join('\n');
+    const url = `https://github.com/${REPOSITORY}/issues/new?labels=submission&title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`;
+    log(`\nUploaded. File the submission (opens a prefilled GitHub issue):\n${url}`);
+    return 0;
+  }
+  log(USAGE);
+  return command === undefined || command === 'help' || command === '--help' ? 0 : 1;
+}

package/lib/providers.js

@@ -0,0 +1,37 @@
+// The model provider's API hosts for a run. A run's agent may reach its own provider and nothing else beyond the
+// task's allowlist (Dan, 2026-10-11: outsiders run Workbench on any model they can access). Harbor opens each host
+// for the agent's run only (`--allow-agent-host`), so the task itself never changes.
+//
+// A model id names its provider first, as Harbor's agents take it: `openrouter/moonshotai/kimi-k2`,
+// `gemini/gemini-3-pro`, `anthropic/claude-sonnet-5-5`. Add a provider by adding a line.
+export const PROVIDERS = {
+  anthropic: { hosts: ['api.anthropic.com'], key: 'ANTHROPIC_API_KEY' },
+  openai: { hosts: ['api.openai.com'], key: 'OPENAI_API_KEY' },
+  openrouter: { hosts: ['openrouter.ai'], key: 'OPENROUTER_API_KEY' },
+  google: { hosts: ['generativelanguage.googleapis.com'], key: 'GEMINI_API_KEY' },
+  gemini: { hosts: ['generativelanguage.googleapis.com'], key: 'GEMINI_API_KEY' },
+  moonshot: { hosts: ['api.moonshot.ai'], key: 'MOONSHOT_API_KEY' },
+  kimi: { hosts: ['api.moonshot.ai'], key: 'MOONSHOT_API_KEY' },
+  deepseek: { hosts: ['api.deepseek.com'], key: 'DEEPSEEK_API_KEY' },
+  xai: { hosts: ['api.x.ai'], key: 'XAI_API_KEY' },
+  meta: { hosts: ['api.llama.com'], key: 'LLAMA_API_KEY' },
+  llama: { hosts: ['api.llama.com'], key: 'LLAMA_API_KEY' },
+  together: { hosts: ['api.together.xyz'], key: 'TOGETHER_API_KEY' },
+  groq: { hosts: ['api.groq.com'], key: 'GROQ_API_KEY' },
+  mistral: { hosts: ['api.mistral.ai'], key: 'MISTRAL_API_KEY' },
+  fireworks: { hosts: ['api.fireworks.ai'], key: 'FIREWORKS_API_KEY' },
+};
+// Agents that sign in to their own service rather than take a provider prefix.
+const AGENT_PROVIDER = { 'claude-code': 'anthropic', codex: 'openai', 'gemini-cli': 'google', 'kimi-cli': 'moonshot', 'grok-build': 'xai' };
+
+export function providerOf(agent, model) {
+  const prefix = String(model ?? '').split('/')[0].toLowerCase();
+  if (PROVIDERS[prefix]) return prefix;
+  return AGENT_PROVIDER[agent] ?? null;
+}
+// The hosts a run opens: its provider's, then any the runner names with --allow-host, each once.
+export function hostsFor(agent, model, extra = []) {
+  const provider = providerOf(agent, model);
+  if (!provider && !extra.length) throw new Error(`No provider is known for model "${model}" with agent "${agent}". Name its API host: --allow-host api.example.com`);
+  return [...new Set([...(provider ? PROVIDERS[provider].hosts : []), ...extra])];
+}

package/lib/scrub.js

@@ -0,0 +1,118 @@
+// What must never leave a runner's machine in an upload: keys, creator IDs, listed personal identifiers, and the
+// runner's home directory. The check reads every file of a job, text or binary, and names files and kinds, never
+// values. The caller uploads only a staged copy that passes these checks.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+export const KEY_PATTERNS = [
+  ['Anthropic key', /sk-ant-[A-Za-z0-9_-]{20,}/],
+  ['OpenRouter key', /sk-or-[A-Za-z0-9_-]{20,}/],
+  ['OpenAI key', /sk-(?!or-|ant-)(?:proj-|svcacct-|admin-)?[A-Za-z0-9_-]{32,}/],
+  ['Google key', /AIza[0-9A-Za-z_-]{35}/],
+  ['xAI key', /xai-[A-Za-z0-9]{40,}/],
+  ['Groq key', /gsk_[A-Za-z0-9]{40,}/],
+  ['Hugging Face token', /hf_[A-Za-z0-9]{30,}/],
+  ['GitHub token', /gh[pousr]_[A-Za-z0-9]{36,}/],
+  ['AWS access key', /AKIA[0-9A-Z]{16}/],
+  ['private key', /-----BEGIN [A-Z ]*PRIVATE KEY-----/],
+];
+
+export const REDACTED = '[redacted]';
+export const DEFAULT_IDENTIFIERS = path.join(os.homedir(), '.config/mtb-export/identifiers');
+const CREATOR = /"(creator_user_id|creator_account_id)"\s*:\s*("(?:[^"\\]|\\.)*"|null|true|false|-?[0-9][0-9.eE+-]*)/g;
+const CREATOR_ESCAPED_START = /(\\+)"(creator_user_id|creator_account_id)\1"\s*:\s*(?:(\1")|(null|true|false|-?[0-9][0-9.eE+-]*))/g;
+const keptCreatorValue = value => value === `"${REDACTED}"` || value === 'null' || /^(\\+)"\[redacted\]\1"$/.test(value);
+
+function escapedCreators(text) {
+  const matches = [], start = new RegExp(CREATOR_ESCAPED_START);
+  for (let match; (match = start.exec(text));) {
+    const [source, escapes, key, stringStart, bare] = match;
+    if (bare) { matches.push({ start: match.index, end: match.index + source.length, key, value: bare, escapes }); continue; }
+    const depth = escapes.length, closeStride = 2 * (depth + 1), contentStart = start.lastIndex;
+    let end = -1;
+    for (let quote = text.indexOf('"', contentStart); quote >= 0; quote = text.indexOf('"', quote + 1)) {
+      let slashCount = 0;
+      while (text[quote - slashCount - 1] === '\\') slashCount += 1;
+      if (slashCount >= depth && (slashCount - depth) % closeStride === 0) { end = quote + 1; break; }
+    }
+    if (end >= 0) matches.push({ start: match.index, end, key, value: text.slice(contentStart - depth - 1, end), escapes });
+  }
+  return matches;
+}
+
+export function readIdentifiers(file = DEFAULT_IDENTIFIERS) {
+  if (!fs.existsSync(file)) throw new Error(`No identifiers file at ${file}. List personal identifiers there, one per line, before submitting a run.`);
+  if ((fs.statSync(file).mode & 0o077) !== 0) throw new Error(`${file} must be readable by its owner only (chmod 600).`);
+  const values = fs.readFileSync(file, 'utf8').split('\n').map(line => line.trim()).filter(line => line && !line.startsWith('#'));
+  if (!values.length) throw new Error(`${file} lists no identifiers.`);
+  if (values.some(value => value.length < 6)) throw new Error(`${file}: every identifier must be at least 6 characters.`);
+  return values;
+}
+
+function walk(directory, links = [], paths = []) {
+  const files = fs.readdirSync(directory, { withFileTypes: true }).flatMap(entry => {
+    const file = path.join(directory, entry.name);
+    paths.push(file);
+    if (entry.isSymbolicLink()) { links.push(file); return []; }
+    if (entry.isDirectory()) return walk(file, links, paths).files;
+    return entry.isFile() ? [file] : [];
+  });
+  return { files, links, paths };
+}
+
+const isText = bytes => !bytes.includes(0);
+const replaceAll = (text, value, by) => text.split(value).join(by);
+
+export function scrubPersonalData(text, { identifiers = [], home = os.homedir() } = {}) {
+  let clean = text.replace(CREATOR, (_, key) => `"${key}":"${REDACTED}"`);
+  for (const match of escapedCreators(clean).reverse()) clean = `${clean.slice(0, match.start)}${match.escapes}"${match.key}${match.escapes}":${match.escapes}"${REDACTED}${match.escapes}"${clean.slice(match.end)}`;
+  for (const identifier of identifiers) clean = replaceAll(clean, identifier, REDACTED);
+  return home && home.length > 1 ? replaceAll(clean, home, '~') : clean;
+}
+
+// Every finding names a file and a kind. `secrets` are provider-key values held by the runner.
+export function findSecrets(directory, { secrets = [], stagingName = '' } = {}) {
+  const findings = [], values = secrets.filter(value => typeof value === 'string' && value.length >= 12), walked = walk(directory);
+  const scanName = (name, file) => {
+    for (const [kind, pattern] of KEY_PATTERNS) if (pattern.test(name)) findings.push({ file, kind: `${kind} in path` });
+    if (values.some(value => name.includes(value))) findings.push({ file, kind: 'a key from this environment in path' });
+  };
+  for (const item of walked.paths) scanName(path.relative(directory, item), path.relative(directory, item));
+  if (stagingName) scanName(stagingName, 'staged job name');
+  for (const file of walked.files) {
+    const text = fs.readFileSync(file).toString('latin1'), relative = path.relative(directory, file);
+    for (const [kind, pattern] of KEY_PATTERNS) if (pattern.test(text)) findings.push({ file: relative, kind });
+    if (values.some(value => text.includes(value))) findings.push({ file: relative, kind: 'a key from this environment' });
+  }
+  return findings;
+}
+
+export function findPersonalData(directory, { identifiers = [], home = os.homedir(), stagingName = '' } = {}) {
+  const findings = [], values = identifiers.filter(value => typeof value === 'string' && value.length >= 6), { files, links, paths } = walk(directory);
+  const scan = (bytes, file) => {
+    values.forEach((value, index) => { if (bytes.includes(Buffer.from(value))) findings.push({ file, kind: `identifier ${index + 1}` }); });
+    if (home && home.length > 1 && bytes.includes(Buffer.from(home))) findings.push({ file, kind: 'the home directory' });
+  };
+  for (const item of paths) {
+    const relative = path.relative(directory, item);
+    scan(Buffer.from(relative), relative);
+  }
+  if (stagingName) scan(Buffer.from(stagingName), 'staged job name');
+  for (const file of files) {
+    const bytes = fs.readFileSync(file), relative = path.relative(directory, file);
+    scan(bytes, relative);
+    if (!isText(bytes)) continue;
+    const text = bytes.toString('utf8');
+    for (const match of text.matchAll(CREATOR)) if (!keptCreatorValue(match[2])) findings.push({ file: relative, kind: `unredacted ${match[1]}` });
+    for (const match of escapedCreators(text)) if (!keptCreatorValue(match.value)) findings.push({ file: relative, kind: `unredacted ${match.key}` });
+  }
+  for (const link of links) {
+    const target = fs.readlinkSync(link), relative = `${path.relative(directory, link)} (link)`;
+    scan(Buffer.from(target), relative);
+    if (path.isAbsolute(target) || path.relative(directory, path.resolve(path.dirname(link), target)).split(path.sep)[0] === '..') {
+      findings.push({ file: relative, kind: 'unsafe symbolic link' });
+    }
+  }
+  return findings;
+}

package/package.json

@@ -1,11 +1,13 @@
 {
   "name": "topo-workbench",
-  "version": "0.0.1",
-  "description": "Workbench: the Model Topography benchmark runner. Coming soon.",
+  "version": "1.0.1",
+  "description": "Workbench: run the Model Topography benchmark on any model with Harbor, then submit the run for grading.",
   "homepage": "https://modeltopography.com",
   "license": "MIT",
   "author": "Dan Mirolli",
+  "type": "module",
   "bin": { "topo-workbench": "bin/topo-workbench.js" },
-  "files": ["bin"],
-  "engines": { "node": ">=22" }
+  "files": ["bin", "lib"],
+  "engines": { "node": ">=22" },
+  "scripts": { "test": "node --test test/*.test.js" }
 }