nubos-pilot 0.1.0

package/lib/plan.cjs

@@ -0,0 +1,85 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { extractFrontmatter } = require('./frontmatter.cjs');
+const { NubosPilotError } = require('./core.cjs');
+
+const PLAN_FILENAME_RE = /^\d{2}(\.\d+)?-\d{2}-PLAN\.md$/;
+
+function parsePlan(planPath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(planPath, 'utf-8');
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      throw new NubosPilotError(
+        'plan-not-found',
+        `PLAN.md not found at ${planPath}`,
+        { path: planPath, cause: err.code },
+      );
+    }
+    throw err;
+  }
+  const { frontmatter, body } = extractFrontmatter(raw);
+  return { frontmatter, body, path: planPath };
+}
+
+function listPlans(phaseDir) {
+  let entries;
+  try {
+    entries = fs.readdirSync(phaseDir);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return [];
+    throw err;
+  }
+  const matches = entries.filter((name) => name === 'PLAN.md' || PLAN_FILENAME_RE.test(name));
+  matches.sort();
+  return matches.map((name) => path.join(phaseDir, name));
+}
+
+function enumerateTasks(planPath) {
+  const tasksDir = path.join(path.dirname(planPath), 'tasks');
+  let entries;
+  try {
+    entries = fs.readdirSync(tasksDir);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return [];
+    throw err;
+  }
+  const md = entries.filter((name) => name.endsWith('.md'));
+  md.sort();
+  return md.map((name) => path.join(tasksDir, name));
+}
+
+const { computeWaves } = require('./tasks.cjs');
+
+function shouldPromoteToTasks(plan) {
+  const tasks = (plan && plan.tasks) || [];
+  const triggers = [];
+  if (tasks.length === 0) return { promote: false, triggers };
+
+  const computeInput = tasks.map((t) => ({
+    id: t.id,
+    depends_on: (t.frontmatter && t.frontmatter.depends_on) || [],
+    wave: t.frontmatter && t.frontmatter.wave,
+  }));
+  const { waves } = computeWaves(computeInput);
+  if (waves.length > 1) {
+    const maxWaveSize = Math.max(...waves.map((w) => w.length));
+    if (maxWaveSize >= 2) triggers.push('parallelism');
+  }
+
+  const tierSet = new Set(tasks.map((t) => t.frontmatter && t.frontmatter.tier));
+  if (tierSet.size >= 2) triggers.push('mixed-tiers');
+
+  if (
+    tasks.some(
+      (t) => ((t.frontmatter && t.frontmatter.depends_on) || []).length >= 2,
+    )
+  ) {
+    triggers.push('non-linear-deps');
+  }
+
+  return { promote: triggers.length > 0, triggers };
+}
+
+module.exports = { parsePlan, listPlans, enumerateTasks, shouldPromoteToTasks };

package/lib/plan.test.cjs

@@ -0,0 +1,263 @@
+const { test, describe, it } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const plan = require('./plan.cjs');
+const { shouldPromoteToTasks } = require('./plan.cjs');
+
+const FIXTURES = path.join(__dirname, 'fixtures', 'plans');
+const sandboxes = [];
+
+function makeSandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-plan-'));
+  sandboxes.push(root);
+  return root;
+}
+
+process.on('exit', () => {
+  for (const s of sandboxes) {
+    try { fs.rmSync(s, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('PL-1: parsePlan returns frontmatter + body + path for valid PLAN.md', () => {
+  const p = path.join(FIXTURES, 'linear', 'PLAN.md');
+  const result = plan.parsePlan(p);
+  assert.equal(result.path, p);
+  assert.equal(result.frontmatter.phase, 99);
+  assert.equal(typeof result.body, 'string');
+  assert.ok(result.body.length > 0);
+});
+
+test('PL-2: parsePlan on missing path throws plan-not-found', () => {
+  const p = path.join(FIXTURES, 'does-not-exist', 'PLAN.md');
+  assert.throws(
+    () => plan.parsePlan(p),
+    (err) => err.name === 'NubosPilotError' && err.code === 'plan-not-found',
+  );
+});
+
+test('PL-3: parsePlan on malformed frontmatter propagates frontmatter-parse-error', () => {
+  const root = makeSandbox();
+  const p = path.join(root, 'BAD.md');
+  fs.writeFileSync(p, '---\n\tbad: tab\n---\n\nbody\n');
+  assert.throws(
+    () => plan.parsePlan(p),
+    (err) => err.name === 'NubosPilotError' && err.code === 'frontmatter-parse-error',
+  );
+});
+
+test('PL-4: listPlans returns sorted absolute paths of PLAN.md variants', () => {
+  const root = makeSandbox();
+  fs.writeFileSync(path.join(root, '01-02-PLAN.md'), '---\nphase: 1\n---\n');
+  fs.writeFileSync(path.join(root, '01-01-PLAN.md'), '---\nphase: 1\n---\n');
+  const result = plan.listPlans(root);
+  assert.equal(result.length, 2);
+  assert.equal(result[0], path.join(root, '01-01-PLAN.md'));
+  assert.equal(result[1], path.join(root, '01-02-PLAN.md'));
+  assert.ok(path.isAbsolute(result[0]));
+});
+
+test('PL-5: enumerateTasks returns sorted absolute paths of task files', () => {
+  const planPath = path.join(FIXTURES, 'linear', 'PLAN.md');
+  const result = plan.enumerateTasks(planPath);
+  assert.equal(result.length, 3);
+  assert.equal(path.basename(result[0]), 'T-01.md');
+  assert.equal(path.basename(result[1]), 'T-02.md');
+  assert.equal(path.basename(result[2]), 'T-03.md');
+  assert.ok(path.isAbsolute(result[0]));
+});
+
+test('PL-6: enumerateTasks on plan with no tasks/ dir returns empty array', () => {
+  const root = makeSandbox();
+  const planPath = path.join(root, 'PLAN.md');
+  fs.writeFileSync(planPath, '---\nphase: 1\n---\n');
+  const result = plan.enumerateTasks(planPath);
+  assert.deepEqual(result, []);
+});
+
+test('PL-7: parsePlan integration on real 02-01-PLAN.md preserves requirements array', () => {
+  const realPlan = path.resolve(
+    __dirname,
+    '..',
+    '.planning',
+    'phases',
+    '02-core-lib-atomic-state-primitives',
+    '02-01-PLAN.md',
+  );
+  if (!fs.existsSync(realPlan)) {
+
+    return;
+  }
+  const result = plan.parsePlan(realPlan);
+  assert.ok(Array.isArray(result.frontmatter.requirements), 'requirements must be an array');
+  assert.deepEqual(result.frontmatter.requirements, ['LIB-01']);
+});
+
+function mkTask(id, { tier = 'sonnet', deps = [] } = {}) {
+  return {
+    id,
+    frontmatter: { id, status: 'pending', tier, owner: 'claude', depends_on: deps },
+    body: '',
+  };
+}
+
+function mkPlan(tasks) {
+  return { frontmatter: {}, tasks };
+}
+
+function mulberry32(seed) {
+  return function () {
+    let t = (seed += 0x6d2b79f5);
+    t = Math.imul(t ^ (t >>> 15), t | 1);
+    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+  };
+}
+
+describe('shouldPromoteToTasks (D-18 heuristic)', () => {
+  it('returns {promote:false, triggers:[]} for empty tasks', () => {
+    assert.deepStrictEqual(shouldPromoteToTasks(mkPlan([])), {
+      promote: false,
+      triggers: [],
+    });
+  });
+
+  it('returns {promote:false, triggers:[]} for a single task with no deps', () => {
+    const p = mkPlan([mkTask('T-01')]);
+    assert.deepStrictEqual(shouldPromoteToTasks(p), { promote: false, triggers: [] });
+  });
+
+  it('three tasks in one wave (all same tier, no deps) does NOT promote', () => {
+
+    const p = mkPlan([mkTask('T-01'), mkTask('T-02'), mkTask('T-03')]);
+    const r = shouldPromoteToTasks(p);
+    assert.deepStrictEqual(r, { promote: false, triggers: [] });
+  });
+
+  it('parallelism trigger fires: 2 parallel roots + 2 dependents (waves.length=2, maxSize=2)', () => {
+    const p = mkPlan([
+      mkTask('T-01'),
+      mkTask('T-02'),
+      mkTask('T-03', { deps: ['T-01'] }),
+      mkTask('T-04', { deps: ['T-02'] }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.equal(r.promote, true);
+    assert.ok(r.triggers.includes('parallelism'));
+  });
+
+  it('parallelism NOT fired for strictly sequential chain (maxSize < 2)', () => {
+    const p = mkPlan([
+      mkTask('T-01'),
+      mkTask('T-02', { deps: ['T-01'] }),
+      mkTask('T-03', { deps: ['T-02'] }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.ok(!r.triggers.includes('parallelism'));
+  });
+
+  it('mixed-tiers trigger fires when tier cardinality >= 2', () => {
+    const p = mkPlan([
+      mkTask('T-01', { tier: 'haiku' }),
+      mkTask('T-02', { tier: 'opus' }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.equal(r.promote, true);
+    assert.ok(r.triggers.includes('mixed-tiers'));
+  });
+
+  it('mixed-tiers NOT fired when all tasks share a tier', () => {
+    const p = mkPlan([
+      mkTask('T-01', { tier: 'sonnet' }),
+      mkTask('T-02', { tier: 'sonnet' }),
+      mkTask('T-03', { tier: 'sonnet' }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.ok(!r.triggers.includes('mixed-tiers'));
+  });
+
+  it('non-linear-deps trigger fires when any task has depends_on.length >= 2', () => {
+    const p = mkPlan([
+      mkTask('T-01'),
+      mkTask('T-02'),
+      mkTask('T-03', { deps: ['T-01', 'T-02'] }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.equal(r.promote, true);
+    assert.ok(r.triggers.includes('non-linear-deps'));
+  });
+
+  it('non-linear-deps NOT fired when every task has depends_on.length <= 1', () => {
+    const p = mkPlan([
+      mkTask('T-01'),
+      mkTask('T-02', { deps: ['T-01'] }),
+      mkTask('T-03', { deps: ['T-02'] }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.ok(!r.triggers.includes('non-linear-deps'));
+  });
+
+  it('combined: all three triggers fire together', () => {
+
+    
+
+    const p = mkPlan([
+      mkTask('T-01', { tier: 'haiku' }),
+      mkTask('T-02', { tier: 'opus' }),
+      mkTask('T-03', { tier: 'haiku', deps: ['T-01'] }),
+      mkTask('T-04', { tier: 'opus', deps: ['T-01', 'T-02'] }),
+    ]);
+    const r = shouldPromoteToTasks(p);
+    assert.equal(r.promote, true);
+    assert.deepStrictEqual(
+      [...r.triggers].sort(),
+      ['mixed-tiers', 'non-linear-deps', 'parallelism'],
+    );
+  });
+
+  it('purity property: 100 random deterministic plans produce byte-identical output on repeat', () => {
+    const rand = mulberry32(12345);
+    const TIERS = ['haiku', 'sonnet', 'opus'];
+    for (let trial = 0; trial < 100; trial++) {
+      const n = Math.floor(rand() * 11); 
+      const tasks = [];
+      for (let i = 0; i < n; i++) {
+        const id = `T-${String(i + 1).padStart(2, '0')}`;
+        const tier = TIERS[Math.floor(rand() * TIERS.length)];
+        const deps = [];
+
+        const numDeps = Math.min(i, Math.floor(rand() * 3));
+        const priorIds = tasks.map((t) => t.id);
+
+        const shuffled = [...priorIds];
+        for (let k = shuffled.length - 1; k > 0; k--) {
+          const j = Math.floor(rand() * (k + 1));
+          [shuffled[k], shuffled[j]] = [shuffled[j], shuffled[k]];
+        }
+        for (let d = 0; d < numDeps && d < shuffled.length; d++) {
+          deps.push(shuffled[d]);
+        }
+        tasks.push(mkTask(id, { tier, deps }));
+      }
+      const p = mkPlan(tasks);
+      const a = shouldPromoteToTasks(p);
+      const b = shouldPromoteToTasks(p);
+      assert.equal(
+        JSON.stringify(a),
+        JSON.stringify(b),
+        `purity violated at trial ${trial} with ${n} tasks`,
+      );
+    }
+  });
+
+  it('edge case: tasks missing frontmatter.tier — all undefined means tierSet size=1, mixed-tiers NOT fired', () => {
+
+    const t1 = { id: 'T-01', frontmatter: { id: 'T-01', status: 'pending', owner: 'c', depends_on: [] }, body: '' };
+    const t2 = { id: 'T-02', frontmatter: { id: 'T-02', status: 'pending', owner: 'c', depends_on: [] }, body: '' };
+    const r = shouldPromoteToTasks(mkPlan([t1, t2]));
+    assert.ok(!r.triggers.includes('mixed-tiers'));
+  });
+});

package/lib/progress.cjs

@@ -0,0 +1,95 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { mutateState, readState } = require('./state.cjs');
+const { parseRoadmap } = require('./roadmap.cjs');
+const { findPhaseDir } = require('./phase.cjs');
+const { listPlans } = require('./plan.cjs');
+const { NubosPilotError } = require('./core.cjs');
+
+function _zeroProgress() {
+  return { total_phases: 0, completed_phases: 0, total_plans: 0, completed_plans: 0, percent: 0 };
+}
+
+function _phaseDirFor(n, cwd) {
+  try { return findPhaseDir(n, cwd); }
+  catch (err) {
+    if (err && err.code === 'not-in-project') return null;
+    return null;
+  }
+}
+
+function _computeFromRoadmap(cwd) {
+  let roadmap;
+  try { roadmap = parseRoadmap(cwd); }
+  catch (err) {
+    if (err && err.code === 'roadmap-parse-error') return _zeroProgress();
+    throw err;
+  }
+  const phases = roadmap.phases || [];
+  let totalPhases = phases.length;
+  let completedPhases = 0;
+  let totalPlans = 0;
+  let completedPlans = 0;
+  for (const ph of phases) {
+    if (ph.complete) completedPhases += 1;
+
+    const dir = _phaseDirFor(Number(ph.number), cwd);
+    let plansCount = 0;
+    if (dir) {
+
+      let onDisk = [];
+      try { onDisk = listPlans(dir); } catch { onDisk = []; }
+      plansCount = onDisk.length;
+    }
+    if (plansCount === 0) {
+      plansCount = Array.isArray(ph.plans) ? ph.plans.length : 0;
+    }
+    totalPlans += plansCount;
+
+    if (Array.isArray(ph.plans)) {
+      for (const p of ph.plans) if (p && p.complete) completedPlans += 1;
+    }
+  }
+  const percent = totalPhases === 0 ? 0 : Math.round((completedPhases / totalPhases) * 100);
+  return {
+    total_phases: totalPhases,
+    completed_phases: completedPhases,
+    total_plans: totalPlans,
+    completed_plans: completedPlans,
+    percent,
+  };
+}
+
+function recomputeProgress(cwd = process.cwd()) {
+  const computed = _computeFromRoadmap(cwd);
+  try {
+    mutateState((cur) => {
+      return { ...cur, frontmatter: { ...cur.frontmatter, progress: computed } };
+    }, cwd);
+  } catch (err) {
+
+    if (err && err.code && String(err.code).startsWith('ENOENT')) return computed;
+    if (err && err.message && /ENOENT/.test(err.message)) return computed;
+    throw err;
+  }
+  return computed;
+}
+
+function readProgress(cwd = process.cwd()) {
+  try {
+    const s = readState(cwd);
+    const p = s && s.frontmatter && s.frontmatter.progress;
+    if (p && typeof p === 'object') return p;
+    return _zeroProgress();
+  } catch (err) {
+    if (err && err.code && String(err.code).startsWith('ENOENT')) return _zeroProgress();
+    if (err && err.message && /ENOENT/.test(err.message)) return _zeroProgress();
+    throw new NubosPilotError(
+      'progress-read-error',
+      `readProgress failed: ${err && err.message}`,
+      { cause: err && err.code },
+    );
+  }
+}
+
+module.exports = { recomputeProgress, readProgress };

package/lib/progress.test.cjs

@@ -0,0 +1,116 @@
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const progress = require('./progress.cjs');
+
+const sandboxes = [];
+
+function makeSandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-progress-test-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'));
+  sandboxes.push(root);
+  return root;
+}
+
+function seedState(root, progressBlock) {
+  const lines = ['---', 'schema_version: 2', 'milestone: v1.0', 'current_phase: 1',
+    'current_plan: null', 'current_task: null', 'last_updated: 2026-04-15'];
+  if (progressBlock) {
+    lines.push('progress:');
+    for (const k of Object.keys(progressBlock)) lines.push(`  ${k}: ${progressBlock[k]}`);
+  }
+  lines.push('---', '', '# State\n');
+  fs.writeFileSync(path.join(root, '.nubos-pilot', 'STATE.md'), lines.join('\n'));
+}
+
+function seedRoadmap(root, phases) {
+  const YAML = require('yaml');
+  fs.writeFileSync(
+    path.join(root, '.nubos-pilot', 'roadmap.yaml'),
+    YAML.stringify({ schema_version: 1, milestones: [{ id: 'v1.0', name: 'm', phases }] }, { indent: 2 }),
+  );
+}
+
+function seedPhaseDir(root, n, slug, planIds) {
+  const padded = String(n).padStart(2, '0');
+  const dir = path.join(root, '.nubos-pilot', 'phases', padded + '-' + slug);
+  fs.mkdirSync(dir, { recursive: true });
+  for (const id of planIds || []) {
+    fs.writeFileSync(path.join(dir, id + '-PLAN.md'), '---\nphase: ' + n + '\n---\nbody\n');
+  }
+}
+
+afterEach(() => {
+  while (sandboxes.length) {
+    const p = sandboxes.pop();
+    try { fs.rmSync(p, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('P1: recomputeProgress writes aggregated block to STATE.md', () => {
+  const root = makeSandbox();
+  seedState(root);
+  seedRoadmap(root, [
+    { number: 1, name: 'One', slug: 'one', status: 'done', plans: [{ id: '01-01', complete: true }] },
+    { number: 2, name: 'Two', slug: 'two', status: 'pending', plans: [{ id: '02-01', complete: false }, { id: '02-02', complete: false }] },
+  ]);
+  seedPhaseDir(root, 1, 'one', ['01-01']);
+  seedPhaseDir(root, 2, 'two', ['02-01', '02-02']);
+  const out = progress.recomputeProgress(root);
+  assert.equal(out.total_phases, 2);
+  assert.equal(out.completed_phases, 1);
+  assert.equal(out.total_plans, 3);
+  assert.equal(out.completed_plans, 1);
+
+  assert.ok(typeof out.percent === 'number');
+
+  const raw = fs.readFileSync(path.join(root, '.nubos-pilot', 'STATE.md'), 'utf-8');
+  assert.match(raw, /progress:/);
+  assert.match(raw, /total_phases: 2/);
+});
+
+test('P2: readProgress returns persisted block (O(1) read, no recomputation)', () => {
+  const root = makeSandbox();
+  seedState(root, {
+    total_phases: 7, completed_phases: 3, total_plans: 12, completed_plans: 5, percent: 42,
+  });
+  const out = progress.readProgress(root);
+  assert.equal(out.total_phases, 7);
+  assert.equal(out.completed_phases, 3);
+  assert.equal(out.total_plans, 12);
+  assert.equal(out.completed_plans, 5);
+  assert.equal(out.percent, 42);
+});
+
+test('P3: missing phase dir = zero-contribution (Pattern S-7)', () => {
+  const root = makeSandbox();
+  seedState(root);
+  seedRoadmap(root, [
+    { number: 1, name: 'One', slug: 'one', status: 'pending', plans: [{ id: '01-01', complete: false }] },
+
+    { number: 2, name: 'Two', slug: 'two', status: 'pending', plans: [] },
+  ]);
+  seedPhaseDir(root, 1, 'one', ['01-01']);
+  const out = progress.recomputeProgress(root);
+  assert.equal(out.total_phases, 2);
+  assert.equal(out.completed_phases, 0);
+
+  assert.equal(out.total_plans, 1);
+  assert.equal(out.completed_plans, 0);
+});
+
+test('P4: recomputeProgress uses mutateState (STATE.md updated atomically)', () => {
+  const root = makeSandbox();
+  seedState(root);
+  seedRoadmap(root, [
+    { number: 1, name: 'One', slug: 'one', status: 'done', plans: [{ id: '01-01', complete: true }] },
+  ]);
+  seedPhaseDir(root, 1, 'one', ['01-01']);
+  progress.recomputeProgress(root);
+  const after = progress.readProgress(root);
+  assert.equal(after.total_phases, 1);
+  assert.equal(after.completed_phases, 1);
+});

package/lib/researcher-contract.test.cjs

@@ -0,0 +1,61 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const { loadAgent, FORBIDDEN } = require('./agents.cjs');
+
+const AGENT_PATH = path.join(__dirname, '..', 'agents', 'np-researcher.md');
+const BODY = fs.readFileSync(AGENT_PATH, 'utf-8');
+
+function withSandbox(fn) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-rc-contract-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'agents'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'agents', 'np-researcher.md'), BODY, 'utf-8');
+  try { return fn(root); }
+  finally { fs.rmSync(root, { recursive: true, force: true }); }
+}
+
+test('RC-1: loadAgent("np-researcher") returns tier=sonnet', () => {
+  withSandbox((sb) => {
+    const fm = loadAgent('np-researcher', sb);
+    assert.equal(fm.tier, 'sonnet');
+    assert.equal(fm.name, 'np-researcher');
+  });
+});
+
+test('RC-2: tools list contains the required web+MCP surface', () => {
+  withSandbox((sb) => {
+    const fm = loadAgent('np-researcher', sb);
+    assert.equal(typeof fm.tools, 'string');
+    for (const needle of ['WebSearch', 'WebFetch', 'mcp__context7__*', 'mcp__firecrawl__*', 'mcp__exa__*']) {
+      assert.ok(
+        fm.tools.includes(needle),
+        'tools string missing "' + needle + '" — got: ' + fm.tools,
+      );
+    }
+  });
+});
+
+test('RC-3: body contains verbatim offline-confirm German prompt (D-21)', () => {
+  const verbatim = 'Kein Web-/Context7-Zugriff verfügbar — mit lokalen Quellen (Repo + Prior-Phase-CONTEXT.md) fortfahren?';
+  assert.ok(BODY.includes(verbatim), 'body missing verbatim D-21 prompt');
+});
+
+test('RC-4: body contains "## Research Coverage" literal heading (D-22)', () => {
+  assert.ok(
+    /^## Research Coverage$/m.test(BODY),
+    'body missing "## Research Coverage" heading on its own line',
+  );
+});
+
+test('RC-6: frontmatter contains no FORBIDDEN field', () => {
+  withSandbox((sb) => {
+    const fm = loadAgent('np-researcher', sb);
+    for (const f of FORBIDDEN) {
+      assert.equal(fm[f], undefined, 'FORBIDDEN field present: ' + f);
+    }
+  });
+});