nubos-pilot 0.1.0

package/lib/verify.cjs

@@ -0,0 +1,116 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { withFileLock, atomicWriteFileSync, NubosPilotError } = require('./core.cjs');
+const { getPhase } = require('./roadmap.cjs');
+const { paddedPhase, findPhaseDir } = require('./phase.cjs');
+
+const _SUBJECTIVE_RE = /\b(subjective|feels?|UX|usability|look|looks|aesthetic|intuitive)\b/i;
+
+function verifyPhase(n, { cwd = process.cwd() } = {}) {
+  const phase = getPhase(n, cwd);
+  const criteria = phase.success_criteria || [];
+  return criteria.map((sc, idx) => ({
+    id: 'SC-' + (idx + 1),
+    text: sc,
+    status: null,            
+    classified_by: null,     
+    evidence: [],
+    notes: '',
+    needs_user_confirm: _SUBJECTIVE_RE.test(sc),
+  }));
+}
+
+function _phaseStatusFromResults(results) {
+
+  if (results.some((r) => r.status === 'Fail')) return 'failed';
+
+  if (results.some((r) => r.status === 'Defer')) return 'deferred';
+  if (results.some((r) => r.needs_user_confirm && r.status == null)) return 'deferred';
+
+  if (results.every((r) => r.status === 'Pass')) return 'verified';
+
+  return 'deferred';
+}
+
+function renderVerificationMd(n, phaseName, results) {
+  const phaseStatus = _phaseStatusFromResults(results);
+  const ts = new Date().toISOString().slice(0, 10);
+  const lines = [];
+  lines.push('# Phase ' + n + ': ' + phaseName + ' - Verification');
+  lines.push('');
+  lines.push('**Verified:** ' + ts);
+  lines.push('**Phase Status:** ' + phaseStatus);
+  lines.push('');
+  lines.push('## Success Criteria');
+  lines.push('');
+  for (const r of results) {
+    lines.push('### ' + r.id + ': ' + r.text);
+    lines.push('- **Status:** ' + (r.status || 'Pending'));
+    lines.push('- **Classified by:** ' + (r.classified_by || 'n/a'));
+    const evidence = Array.isArray(r.evidence) && r.evidence.length > 0
+      ? r.evidence.join(', ')
+      : '—';
+    lines.push('- **Evidence:** ' + evidence);
+    if (r.notes) {
+      lines.push('- **Notes:** ' + r.notes);
+    }
+    if (r.needs_user_confirm && r.status == null) {
+      lines.push('- **Needs user confirm:** true');
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+const _SC_RE = /^### (SC-\d+): ([^\n]+)\n- \*\*Status:\*\* (\w+)/gm;
+
+function parseVerificationMd(filePath) {
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    throw new NubosPilotError(
+      'verify-file-unreadable',
+      'VERIFICATION.md not readable at ' + filePath,
+      { path: filePath, cause: err && err.code },
+    );
+  }
+
+  
+
+  const out = [];
+  for (const m of raw.matchAll(_SC_RE)) {
+    out.push({
+      id: m[1],
+      text: m[2].trim(),
+      status: m[3],
+    });
+  }
+  return out;
+}
+
+function writeVerificationMd(n, cwd = process.cwd()) {
+  const phase = getPhase(n, cwd);
+  const phaseDir = findPhaseDir(n, cwd);
+  if (!phaseDir) {
+    throw new NubosPilotError(
+      'verify-phase-dir-missing',
+      'Phase directory not found for phase ' + n,
+      { phase: n },
+    );
+  }
+  const padded = paddedPhase(n);
+  const target = path.join(phaseDir, padded + '-VERIFICATION.md');
+  const results = verifyPhase(n, { cwd });
+  const md = renderVerificationMd(n, phase.name, results);
+  return withFileLock(target, () => atomicWriteFileSync(target, md));
+}
+
+module.exports = {
+  verifyPhase,
+  renderVerificationMd,
+  parseVerificationMd,
+  writeVerificationMd,
+
+  _phaseStatusFromResults,
+};

package/lib/verify.test.cjs

@@ -0,0 +1,187 @@
+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 verify = require('./verify.cjs');
+const {
+  verifyPhase,
+  renderVerificationMd,
+  parseVerificationMd,
+  writeVerificationMd,
+} = verify;
+
+const _sandboxes = [];
+
+function makeRoadmapSandbox(phases) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-verify-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  fs.mkdirSync(path.join(root, '.nubos-pilot', 'phases'), { recursive: true });
+  const doc = {
+    milestones: [
+      {
+        id: 'v1.0',
+        name: 'verify-test-milestone',
+        phases: phases,
+      },
+    ],
+  };
+
+  const YAML = require('yaml');
+  fs.writeFileSync(
+    path.join(root, '.nubos-pilot', 'roadmap.yaml'),
+    YAML.stringify(doc, { indent: 2 }),
+    'utf-8',
+  );
+  _sandboxes.push(root);
+  return root;
+}
+
+function cleanupAll() {
+  while (_sandboxes.length) {
+    const r = _sandboxes.pop();
+    try { fs.rmSync(r, { recursive: true, force: true }); } catch {  }
+  }
+}
+
+test.afterEach(() => cleanupAll());
+
+test('VR-1: renderVerificationMd emits D-24-schema headers and per-SC blocks', () => {
+  const results = [
+    {
+      id: 'SC-1', text: 'first criterion', status: 'Pass',
+      classified_by: 'np-verifier', evidence: ['abc1234', 'lib/foo.cjs'],
+      notes: '', needs_user_confirm: false,
+    },
+    {
+      id: 'SC-2', text: 'second criterion', status: 'Fail',
+      classified_by: 'np-verifier', evidence: [], notes: 'missing export',
+      needs_user_confirm: false,
+    },
+  ];
+  const md = renderVerificationMd(6, 'test-phase', results);
+
+  assert.match(md, /^# Phase 6: test-phase - Verification$/m);
+  assert.match(md, /^\*\*Verified:\*\* \d{4}-\d{2}-\d{2}$/m);
+  assert.match(md, /^\*\*Phase Status:\*\* (verified|failed|deferred)$/m);
+  assert.match(md, /^## Success Criteria$/m);
+
+  assert.match(md, /^### SC-1: first criterion$/m);
+  assert.match(md, /^- \*\*Status:\*\* Pass$/m);
+  assert.match(md, /^- \*\*Classified by:\*\* np-verifier$/m);
+  assert.match(md, /^- \*\*Evidence:\*\* abc1234, lib\/foo\.cjs$/m);
+  assert.match(md, /^### SC-2: second criterion$/m);
+  assert.match(md, /^- \*\*Status:\*\* Fail$/m);
+  assert.match(md, /^- \*\*Notes:\*\* missing export$/m);
+});
+
+test('VR-2: parseVerificationMd round-trip extracts id/text/status', () => {
+  const results = [
+    { id: 'SC-1', text: 'alpha', status: 'Pass', classified_by: 'np-verifier', evidence: [], notes: '', needs_user_confirm: false },
+    { id: 'SC-2', text: 'beta',  status: 'Fail', classified_by: 'user',     evidence: [], notes: '', needs_user_confirm: false },
+    { id: 'SC-3', text: 'gamma', status: 'Defer', classified_by: 'user',    evidence: [], notes: '', needs_user_confirm: false },
+  ];
+  const md = renderVerificationMd(7, 'round-trip-phase', results);
+
+  const tmp = path.join(os.tmpdir(), 'np-verify-round-' + Date.now() + '.md');
+  fs.writeFileSync(tmp, md, 'utf-8');
+  try {
+    const parsed = parseVerificationMd(tmp);
+    assert.equal(parsed.length, 3);
+    assert.deepEqual(
+      parsed.map((r) => ({ id: r.id, text: r.text, status: r.status })),
+      [
+        { id: 'SC-1', text: 'alpha', status: 'Pass' },
+        { id: 'SC-2', text: 'beta',  status: 'Fail' },
+        { id: 'SC-3', text: 'gamma', status: 'Defer' },
+      ],
+    );
+  } finally {
+    try { fs.unlinkSync(tmp); } catch {}
+  }
+});
+
+test('VR-3: phase status — any Fail → failed', () => {
+  const results = [
+    { id: 'SC-1', text: 't', status: 'Pass', classified_by: 'np-verifier', evidence: [], notes: '', needs_user_confirm: false },
+    { id: 'SC-2', text: 't', status: 'Fail', classified_by: 'np-verifier', evidence: [], notes: '', needs_user_confirm: false },
+    { id: 'SC-3', text: 't', status: 'Defer', classified_by: 'user',    evidence: [], notes: '', needs_user_confirm: false },
+  ];
+  const md = renderVerificationMd(1, 'n', results);
+  assert.match(md, /^\*\*Phase Status:\*\* failed$/m);
+});
+
+test('VR-4: phase status — no Fail, any Defer → deferred', () => {
+  const results = [
+    { id: 'SC-1', text: 't', status: 'Pass', classified_by: 'np-verifier', evidence: [], notes: '', needs_user_confirm: false },
+    { id: 'SC-2', text: 't', status: 'Defer', classified_by: 'user',    evidence: [], notes: '', needs_user_confirm: false },
+  ];
+  const md = renderVerificationMd(1, 'n', results);
+  assert.match(md, /^\*\*Phase Status:\*\* deferred$/m);
+});
+
+test('VR-5: phase status — all Pass → verified', () => {
+  const results = [
+    { id: 'SC-1', text: 't', status: 'Pass', classified_by: 'np-verifier', evidence: [], notes: '', needs_user_confirm: false },
+    { id: 'SC-2', text: 't', status: 'Pass', classified_by: 'np-verifier', evidence: [], notes: '', needs_user_confirm: false },
+  ];
+  const md = renderVerificationMd(1, 'n', results);
+  assert.match(md, /^\*\*Phase Status:\*\* verified$/m);
+});
+
+test('VR-6: verifyPhase returns skeleton Result[] with null status per SC', () => {
+  const sb = makeRoadmapSandbox([
+    {
+      number: 6,
+      name: 'exec-phase',
+      slug: 'exec-phase',
+      goal: 'execute things',
+      success_criteria: [
+        'criterion one works',
+        'criterion two works',
+        'criterion three works',
+      ],
+      requirements: [],
+      status: 'pending',
+      plans: [],
+    },
+  ]);
+  const results = verifyPhase(6, { cwd: sb });
+  assert.equal(results.length, 3);
+  for (let i = 0; i < results.length; i++) {
+    const r = results[i];
+    assert.equal(r.id, 'SC-' + (i + 1));
+    assert.equal(r.status, null);
+    assert.equal(r.classified_by, null);
+    assert.ok(Array.isArray(r.evidence));
+    assert.equal(r.needs_user_confirm, false);
+  }
+  assert.equal(results[0].text, 'criterion one works');
+});
+
+test('VR-7: writeVerificationMd persists under <phase_dir>/<padded>-VERIFICATION.md', () => {
+  const sb = makeRoadmapSandbox([
+    {
+      number: 6,
+      name: 'exec-phase',
+      slug: 'exec-phase',
+      goal: 'execute things',
+      success_criteria: ['only one thing'],
+      requirements: [],
+      status: 'pending',
+      plans: [],
+    },
+  ]);
+
+  const phaseDir = path.join(sb, '.nubos-pilot', 'phases', '06-exec-phase');
+  fs.mkdirSync(phaseDir, { recursive: true });
+
+  writeVerificationMd(6, sb);
+
+  const target = path.join(phaseDir, '06-VERIFICATION.md');
+  assert.ok(fs.existsSync(target), 'VERIFICATION.md should exist at ' + target);
+  const content = fs.readFileSync(target, 'utf-8');
+  assert.match(content, /^# Phase 6: exec-phase - Verification$/m);
+  assert.match(content, /^### SC-1: only one thing$/m);
+});

package/np-tools.cjs

@@ -0,0 +1,303 @@
+#!/usr/bin/env node
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { projectStateDir, NubosPilotError } = require('./lib/core.cjs');
+const { getPhase } = require('./lib/roadmap.cjs');
+const { paddedPhase, phaseSlug, findPhaseDir } = require('./lib/phase.cjs');
+const { parsePlan, listPlans } = require('./lib/plan.cjs');
+const { loadTaskGraph } = require('./lib/tasks.cjs');
+const { COMMANDS } = require('./bin/np-tools/_commands.cjs');
+
+const initWorkflows = {
+  'plan-phase':          require('./bin/np-tools/plan-phase.cjs'),
+  'discuss-phase':       require('./bin/np-tools/discuss-phase.cjs'),
+  'discuss-phase-power': require('./bin/np-tools/discuss-phase-power.cjs'),
+  'research-phase':      require('./bin/np-tools/research-phase.cjs'),
+  'new-project':         require('./bin/np-tools/new-project.cjs'),
+  'new-milestone':       require('./bin/np-tools/new-milestone.cjs'),
+  'plan-milestone-gaps': require('./bin/np-tools/plan-milestone-gaps.cjs'),
+
+  'execute-phase':       require('./bin/np-tools/execute-phase.cjs'),
+  'execute-plan':        require('./bin/np-tools/execute-plan.cjs'),
+  'autonomous':          require('./bin/np-tools/autonomous.cjs'),
+  'verify-work':         require('./bin/np-tools/verify-work.cjs'),
+  'add-tests':           require('./bin/np-tools/add-tests.cjs'),
+  'pause-work':          require('./bin/np-tools/pause-work.cjs'),
+  'resume-work':         require('./bin/np-tools/resume-work.cjs'),
+
+  'ai-integration-phase': require('./bin/np-tools/ai-integration-phase.cjs'),
+  'ui-phase':             require('./bin/np-tools/ui-phase.cjs'),
+  'ui-review':            require('./bin/np-tools/ui-review.cjs'),
+  'eval-review':          require('./bin/np-tools/eval-review.cjs'),
+
+  'code-review':          require('./bin/np-tools/code-review.cjs'),
+
+  'add-todo':             require('./bin/np-tools/add-todo.cjs'),
+};
+
+const topLevelCommands = {
+  'agent-skills': require('./bin/np-tools/agent-skills.cjs'),
+
+  'commit-task':  require('./bin/np-tools/commit-task.cjs'),
+  'checkpoint':   require('./bin/np-tools/checkpoint.cjs'),
+
+  'undo':         require('./bin/np-tools/undo.cjs'),
+  'undo-task':    require('./bin/np-tools/undo-task.cjs'),
+  'reset-slice':  require('./bin/np-tools/reset-slice.cjs'),
+  'skip':         require('./bin/np-tools/skip.cjs'),
+  'park':         require('./bin/np-tools/park.cjs'),
+  'unpark':       require('./bin/np-tools/unpark.cjs'),
+  'askuser':        require('./bin/np-tools/askuser.cjs'),
+  'commit':         require('./bin/np-tools/commit.cjs'),
+  'config-get':     require('./bin/np-tools/config.cjs'),
+  'dispatch':       require('./bin/np-tools/dispatch.cjs'),
+  'doctor':         require('./bin/np-tools/doctor.cjs'),
+  'generate-slug':  require('./bin/np-tools/slug.cjs'),
+  'metrics':        require('./bin/np-tools/metrics.cjs'),
+  'phase':          require('./bin/np-tools/phase.cjs'),
+  'plan-diff':      require('./bin/np-tools/plan-diff.cjs'),
+  'queue':          require('./bin/np-tools/queue.cjs'),
+  'resolve-model':  require('./bin/np-tools/resolve-model.cjs'),
+  'stats':          require('./bin/np-tools/stats.cjs'),
+  'triage':         require('./bin/np-tools/triage.cjs'),
+};
+
+const THRESHOLD = 16 * 1024;
+
+function _resolveStateDir(cwd) {
+  try {
+    return projectStateDir(cwd);
+  } catch (err) {
+    if (err && err.code === 'not-in-project') {
+      const boot = path.join(path.resolve(cwd), '.planning');
+      if (fs.existsSync(boot)) return boot;
+    }
+    throw err;
+  }
+}
+
+function _resolvePhaseDir(n, cwd) {
+  try {
+    const hit = findPhaseDir(n, cwd);
+    if (hit) return hit;
+  } catch (err) {
+    if (!err || err.code !== 'not-in-project') throw err;
+  }
+  const padded = paddedPhase(n);
+  const stateDir = _resolveStateDir(cwd);
+  const phasesRoot = path.join(stateDir, 'phases');
+  let entries;
+  try {
+    entries = fs.readdirSync(phasesRoot, { withFileTypes: true });
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return null;
+    throw err;
+  }
+  const matches = entries
+    .filter((e) => e.isDirectory())
+    .filter((e) => e.name === padded || e.name.startsWith(padded + '-'))
+    .map((e) => e.name)
+    .sort((a, b) => b.length - a.length);
+  if (matches.length === 0) return null;
+  return path.join(phasesRoot, matches[0]);
+}
+
+function _sanitizeLabel(s) {
+  return String(s).replace(/[^a-zA-Z0-9-]/g, '_');
+}
+
+function emit(payload, _stdout, _cwd) {
+  const stdout = _stdout || process.stdout;
+  const cwd = _cwd || process.cwd();
+  const json = JSON.stringify(payload, null, 2);
+  if (Buffer.byteLength(json, 'utf-8') <= THRESHOLD) {
+    stdout.write(json);
+    return;
+  }
+  const stateDir = _resolveStateDir(cwd);
+  const tmpDir = path.join(stateDir, '.tmp');
+  fs.mkdirSync(tmpDir, { recursive: true });
+  const workflow = _sanitizeLabel(payload && payload._workflow ? payload._workflow : 'init');
+  const suffix = process.pid + '-' + crypto.randomBytes(4).toString('hex');
+  const tmpPath = path.join(tmpDir, 'init-' + workflow + '-' + suffix + '.json');
+  fs.writeFileSync(tmpPath, json, 'utf-8');
+  stdout.write('@file:' + tmpPath);
+}
+
+function _makePhasePayload(n, cwd, workflowLabel) {
+  const padded = paddedPhase(n);
+  const phase = getPhase(n, cwd);
+  const phase_dir = _resolvePhaseDir(n, cwd);
+  const stateDir = _resolveStateDir(cwd);
+  let has_context = false;
+  let has_research = false;
+  let has_plans = false;
+  if (phase_dir) {
+    has_context = fs.existsSync(path.join(phase_dir, padded + '-CONTEXT.md'));
+    has_research = fs.existsSync(path.join(phase_dir, padded + '-RESEARCH.md'));
+    has_plans = listPlans(phase_dir).length > 0;
+  }
+  return {
+    _workflow: workflowLabel,
+    phase_number: String(n),
+    padded_phase: padded,
+    phase_slug: phase_dir ? path.basename(phase_dir).slice(padded.length + 1) : phaseSlug(phase.name),
+    phase_name: phase.name,
+    phase_dir,
+    phase_found: !!phase_dir,
+    roadmap_path: path.join(stateDir, 'ROADMAP.md'),
+    state_path: path.join(stateDir, 'STATE.md'),
+    has_context,
+    has_research,
+    has_plans,
+    goal: phase.goal,
+    requirements: phase.requirements,
+    success_criteria: phase.success_criteria,
+  };
+}
+
+function composeInit(workflow, args, cwd) {
+  const useCwd = cwd || process.cwd();
+  switch (workflow) {
+    case 'phase-op':
+      return _makePhasePayload(args[0], useCwd, 'phase-op');
+    case 'plan-phase': {
+      const base = _makePhasePayload(args[0], useCwd, 'plan-phase');
+      if (base.phase_dir) {
+        base.planned_plans = listPlans(base.phase_dir);
+        base.context_path = base.has_context
+          ? path.join(base.phase_dir, base.padded_phase + '-CONTEXT.md')
+          : null;
+        base.research_path = base.has_research
+          ? path.join(base.phase_dir, base.padded_phase + '-RESEARCH.md')
+          : null;
+      } else {
+        base.planned_plans = [];
+        base.context_path = null;
+        base.research_path = null;
+      }
+      return base;
+    }
+    case 'execute-phase': {
+      const base = _makePhasePayload(args[0], useCwd, 'execute-phase');
+      base.plans = [];
+      if (base.phase_dir) {
+        for (const planPath of listPlans(base.phase_dir)) {
+          const parsed = parsePlan(planPath);
+          const planDir = path.dirname(planPath);
+          const tg = loadTaskGraph(planDir);
+          base.plans.push({
+            plan_path: planPath,
+            plan_frontmatter: parsed.frontmatter,
+            tasks_dir: path.join(planDir, 'tasks'),
+            task_count: tg.tasks.length,
+            waves: tg.waves,
+            warnings: tg.warnings,
+          });
+        }
+      }
+      return base;
+    }
+    default: {
+      if (args[0]) {
+        try {
+          return _makePhasePayload(args[0], useCwd, workflow);
+        } catch (err) {
+          if (err && err.code === 'phase-not-found') {
+            return { _workflow: workflow, phase_found: false, phase_number: String(args[0]) };
+          }
+          throw err;
+        }
+      }
+      return { _workflow: workflow, phase_found: false };
+    }
+  }
+}
+
+function main() {
+  const args = process.argv.slice(2);
+  try {
+    const cmd = args[0];
+    let payload;
+    switch (cmd) {
+      case 'init': {
+        const wf = args[1];
+
+        
+
+        
+        if (wf && Object.prototype.hasOwnProperty.call(initWorkflows, wf)) {
+          const rc = initWorkflows[wf].run(args.slice(2));
+          if (rc && typeof rc.then === 'function') {
+            rc.then((code) => {
+              if (typeof code === 'number' && code !== 0) process.exit(code);
+            }).catch((err) => {
+              process.stderr.write(String((err && err.stack) || err) + '\n');
+              process.exit(1);
+            });
+          } else if (typeof rc === 'number' && rc !== 0) {
+            process.exit(rc);
+          }
+          return;
+        }
+        payload = composeInit(wf, args.slice(2));
+        break;
+      }
+      case 'next':
+        payload = require('./bin/np-tools/next.cjs').run(args.slice(1));
+        break;
+      case 'progress':
+        payload = require('./bin/np-tools/progress.cjs').run(args.slice(1));
+        break;
+      case 'state':
+        payload = require('./bin/np-tools/state.cjs').run(args.slice(1));
+        break;
+      case 'help':
+        payload = require('./bin/np-tools/help.cjs').run(args.slice(1));
+        break;
+      default: {
+
+        
+        if (cmd && Object.prototype.hasOwnProperty.call(topLevelCommands, cmd)) {
+          const rc = topLevelCommands[cmd].run(args.slice(1));
+          if (rc && typeof rc.then === 'function') {
+            rc.then((code) => {
+              if (typeof code === 'number' && code !== 0) process.exit(code);
+            }).catch((err) => {
+              process.stderr.write(String((err && err.stack) || err) + '\n');
+              process.exit(1);
+            });
+          } else if (typeof rc === 'number' && rc !== 0) {
+            process.exit(rc);
+          }
+          return;
+        }
+        throw new NubosPilotError(
+          'unknown-command',
+          'Unknown command: ' + cmd,
+          { cmd },
+        );
+      }
+    }
+    emit(payload);
+  } catch (err) {
+    const code = (err && err.code) || 'init-internal-error';
+    const message = (err && err.message) || String(err);
+    const details = (err && err.details) || null;
+    fs.writeSync(2, JSON.stringify({ error: { code, message, details } }) + '\n');
+    process.exit(1);
+  }
+}
+
+if (require.main === module) main();
+
+module.exports = {
+  composeInit,
+  emit,
+  _makePhasePayload,
+  main,
+  COMMANDS,
+  initWorkflows,
+  topLevelCommands,
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "nubos-pilot",
+  "version": "0.1.0",
+  "description": "AI-driven planning and execution tool for code projects",
+  "homepage": "https://github.com/Nubos-AI/nubos-pilot",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Nubos-AI/nubos-pilot.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Nubos-AI/nubos-pilot/issues"
+  },
+  "license": "MIT",
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "yaml": "^2.8.0"
+  },
+  "bin": {
+    "nubos-pilot": "bin/install.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "templates/",
+    "workflows/",
+    "agents/",
+    "docs/",
+    "np-tools.cjs",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test 'lib/**/*.test.cjs' 'tests/**/*.test.cjs' 'bin/**/*.test.cjs'",
+    "test:coverage": "node --test --experimental-test-coverage --test-coverage-include='lib/**' 'lib/**/*.test.cjs' 'tests/**/*.test.cjs' 'bin/**/*.test.cjs'",
+    "check-coverage": "node bin/check-coverage.cjs",
+    "ci": "npm run test && npm run check-coverage"
+  }
+}