nubos-pilot 0.1.0

package/bin/np-tools/metrics.test.cjs

@@ -0,0 +1,188 @@
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+const subcmd = require('./metrics.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-metrics-cli-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  _sandboxes.push(root);
+  return root;
+}
+
+function captureStdio(fn) {
+  const outChunks = [];
+  const errChunks = [];
+  const origOut = process.stdout.write.bind(process.stdout);
+  const origErr = process.stderr.write.bind(process.stderr);
+  process.stdout.write = (c) => { outChunks.push(String(c)); return true; };
+  process.stderr.write = (c) => { errChunks.push(String(c)); return true; };
+  let rc;
+  try { rc = fn(); } finally {
+    process.stdout.write = origOut;
+    process.stderr.write = origErr;
+  }
+  return { stdout: outChunks.join(''), stderr: errChunks.join(''), rc };
+}
+
+function withCwd(cwd, fn) {
+  const orig = process.cwd();
+  process.chdir(cwd);
+  try { return fn(); } finally { process.chdir(orig); }
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    try { fs.rmSync(_sandboxes.pop(), { recursive: true, force: true }); } catch {  }
+  }
+});
+
+const ISO_MS_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/;
+
+test('MCLI-1: run(["now"]) / start-timestamp / end-timestamp all print ISO-ms timestamp and exit 0', () => {
+  for (const sub of ['now', 'start-timestamp', 'end-timestamp']) {
+    const cap = captureStdio(() => subcmd.run([sub]));
+    assert.equal(cap.rc, 0, sub + ' must return 0');
+    const line = cap.stdout.trim();
+    assert.match(line, ISO_MS_RE, sub + ' must print ISO-8601 with ms: got ' + JSON.stringify(line));
+  }
+});
+
+test('MCLI-2: run(record ...claude-full-argv) writes phase-09.jsonl and exits 0', () => {
+  const cwd = makeSandbox();
+  withCwd(cwd, () => {
+    const cap = captureStdio(() => subcmd.run([
+      'record',
+      '--agent', 'np-executor',
+      '--tier', 'sonnet',
+      '--resolved-model', 'claude-sonnet-4-6',
+      '--phase', '09',
+      '--plan', '09-01',
+      '--task', '09-01-T02',
+      '--started', '2026-04-16T14:30:12.123Z',
+      '--ended', '2026-04-16T14:31:08.987Z',
+      '--tokens-in', '3421',
+      '--tokens-out', '812',
+      '--status', 'ok',
+      '--runtime', 'claude',
+    ]));
+    assert.equal(cap.rc, 0, 'stderr was: ' + cap.stderr);
+    const filePath = path.join(cwd, '.nubos-pilot', 'metrics', 'phase-09.jsonl');
+    assert.ok(fs.existsSync(filePath));
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8').split(os.EOL).filter(Boolean)[0]);
+    assert.equal(parsed.phase, '09');
+    assert.equal(parsed.tokens_in, 3421);
+    assert.equal(parsed.runtime, 'claude');
+  });
+});
+
+test('MCLI-3: run(record ...phase="" runtime=codex) routes to meta.jsonl with null tokens (D-09)', () => {
+  const cwd = makeSandbox();
+  withCwd(cwd, () => {
+    const cap = captureStdio(() => subcmd.run([
+      'record',
+      '--agent', 'np-executor',
+      '--tier', 'sonnet',
+      '--resolved-model', 'claude-sonnet-4-6',
+      '--phase', '',
+      '--plan', '',
+      '--task', '',
+      '--started', '2026-04-16T14:30:12.123Z',
+      '--ended', '2026-04-16T14:31:08.987Z',
+      '--tokens-in', '9999',
+      '--tokens-out', '9999',
+      '--status', 'ok',
+      '--runtime', 'codex',
+    ]));
+    assert.equal(cap.rc, 0, 'stderr: ' + cap.stderr);
+    const metaPath = path.join(cwd, '.nubos-pilot', 'metrics', 'meta.jsonl');
+    assert.ok(fs.existsSync(metaPath));
+    const parsed = JSON.parse(fs.readFileSync(metaPath, 'utf-8').split(os.EOL).filter(Boolean)[0]);
+    assert.equal(parsed.phase, '');
+    assert.equal(parsed.runtime, 'codex');
+    assert.equal(parsed.tokens_in, null);
+    assert.equal(parsed.tokens_out, null);
+  });
+});
+
+test('MCLI-4: run(record --json @file:<path>) reads JSON blob and emits schema-identical record', () => {
+  const cwd = makeSandbox();
+  const jsonPayload = {
+    agent: 'np-eval-planner',
+    tier: 'opus',
+    resolved_model: 'claude-opus-4-7',
+    phase: '09',
+    plan: '09-02',
+    task: '09-02-T03',
+    started_at: '2026-04-16T14:30:12.123Z',
+    ended_at: '2026-04-16T14:31:08.987Z',
+    tokens_in: 100,
+    tokens_out: 50,
+    retry_count: 0,
+    status: 'error',
+    runtime: 'claude',
+    error: { code: 'eval-timeout', message: 'the agent timed out waiting for a long response' },
+  };
+  const jsonPath = path.join(cwd, 'payload.json');
+  fs.writeFileSync(jsonPath, JSON.stringify(jsonPayload));
+  withCwd(cwd, () => {
+    const cap = captureStdio(() => subcmd.run(['record', '--json', '@file:' + jsonPath]));
+    assert.equal(cap.rc, 0, 'stderr: ' + cap.stderr);
+    const filePath = path.join(cwd, '.nubos-pilot', 'metrics', 'phase-09.jsonl');
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8').split(os.EOL).filter(Boolean)[0]);
+    assert.equal(parsed.agent, 'np-eval-planner');
+    assert.equal(parsed.task, '09-02-T03');
+    assert.deepEqual(parsed.error, { code: 'eval-timeout', message: jsonPayload.error.message });
+  });
+});
+
+test('MCLI-5: run(record ...missing fields) exits 1 and writes JSON error envelope to stderr', () => {
+  const cwd = makeSandbox();
+  withCwd(cwd, () => {
+    const cap = captureStdio(() => subcmd.run([
+      'record',
+      '--agent', 'np-executor',
+      '--tier', 'sonnet',
+    ]));
+    assert.equal(cap.rc, 1);
+    const parsed = JSON.parse(cap.stderr.trim());
+    assert.equal(parsed.code, 'metrics-invalid-record');
+    assert.ok(Array.isArray(parsed.details.missing));
+  });
+});
+
+test('MCLI-6: run(record --error-code E1 --error-message boom --status error) writes error={code,message}', () => {
+  const cwd = makeSandbox();
+  withCwd(cwd, () => {
+    const cap = captureStdio(() => subcmd.run([
+      'record',
+      '--agent', 'np-executor',
+      '--tier', 'opus',
+      '--resolved-model', 'claude-opus-4-7',
+      '--phase', '09',
+      '--plan', '09-02',
+      '--task', '09-02-T01',
+      '--started', '2026-04-16T14:30:12.123Z',
+      '--ended', '2026-04-16T14:31:08.987Z',
+      '--status', 'error',
+      '--runtime', 'claude',
+      '--error-code', 'E1',
+      '--error-message', 'boom',
+    ]));
+    assert.equal(cap.rc, 0, 'stderr: ' + cap.stderr);
+    const filePath = path.join(cwd, '.nubos-pilot', 'metrics', 'phase-09.jsonl');
+    const parsed = JSON.parse(fs.readFileSync(filePath, 'utf-8').split(os.EOL).filter(Boolean)[0]);
+    assert.deepEqual(parsed.error, { code: 'E1', message: 'boom' });
+  });
+});
+
+test('MCLI-7: run(["unknown-subcommand"]) exits 1 with usage on stderr', () => {
+  const cap = captureStdio(() => subcmd.run(['unknown-subcommand']));
+  assert.equal(cap.rc, 1);
+  assert.match(cap.stderr, /Usage/i);
+});

package/bin/np-tools/new-milestone.cjs

@@ -0,0 +1,288 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const {
+  NubosPilotError,
+  atomicWriteFileSync,
+  projectStateDir,
+} = require('../../lib/core.cjs');
+const { addMilestone, addPhase, parseRoadmap } = require('../../lib/roadmap.cjs');
+const { createPhaseDir, phaseSlug } = require('../../lib/phase.cjs');
+const { mutateState } = require('../../lib/state.cjs');
+
+const TEMPLATES_DIR = path.join(__dirname, '..', '..', 'templates');
+const PLACEHOLDER_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+
+function _render(raw, vars, templateName) {
+  return raw.replace(PLACEHOLDER_RE, (_match, key) => {
+    if (!(key in vars)) {
+      throw new NubosPilotError(
+        'template-unresolved-var',
+        `Undefined placeholder {{${key}}} in template "${templateName}"`,
+        { template: templateName, variable: key, available: Object.keys(vars) },
+      );
+    }
+    return String(vars[key]);
+  });
+}
+
+function _loadTemplate(name) {
+  return fs.readFileSync(path.join(TEMPLATES_DIR, name + '.md'), 'utf-8');
+}
+
+function _slugify(raw) {
+  return String(raw || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+function _writeFile(target, content) {
+
+  
+
+  if (path.basename(target) === 'PROJECT.md') {
+    throw new NubosPilotError(
+      'new-milestone-forbidden-write',
+      'new-milestone.cjs is never allowed to write PROJECT.md (D-29)',
+      { path: target },
+    );
+  }
+  atomicWriteFileSync(target, content);
+}
+
+function _emit(stdout, payload) {
+  stdout.write(JSON.stringify(payload, null, 2));
+}
+
+function _interviewPayload() {
+  return {
+    mode: 'interview',
+    questions: [
+      { key: 'milestone_name', type: 'input',
+        question: 'Milestone name (e.g. "v2.0")?' },
+      { key: 'milestone_goal', type: 'input',
+        question: 'Milestone goal — one sentence describing what ships in this milestone?' },
+      { key: 'first_phase_name', type: 'input',
+        question: 'First phase name for this milestone?' },
+      { key: 'create_req_prefix', type: 'confirm',
+        question: 'Create a new "## <milestone> Requirements" section in REQUIREMENTS.md?' },
+    ],
+  };
+}
+
+function _validateAnswers(a) {
+  for (const key of ['milestone_name', 'milestone_goal', 'first_phase_name']) {
+    if (typeof a[key] !== 'string' || a[key].trim() === '') {
+      throw new NubosPilotError(
+        'answers-missing-field',
+        'answers JSON missing field: ' + key,
+        { field: key },
+      );
+    }
+  }
+  if ('create_req_prefix' in a && typeof a.create_req_prefix !== 'boolean') {
+    throw new NubosPilotError(
+      'answers-invalid-field',
+      'create_req_prefix must be a boolean',
+      { field: 'create_req_prefix', value: a.create_req_prefix },
+    );
+  }
+}
+
+function _guardInitialized(root) {
+  const projectMd = path.join(root, '.nubos-pilot', 'PROJECT.md');
+  if (!fs.existsSync(projectMd)) {
+    throw new NubosPilotError(
+      'project-not-initialized',
+      'PROJECT.md not found — run np:new-project first',
+      { hint: 'Run np:new-project first', path: projectMd },
+    );
+  }
+}
+
+function _appendReqPrefix(root, milestoneName) {
+  const reqPath = path.join(root, '.nubos-pilot', 'REQUIREMENTS.md');
+  const current = fs.readFileSync(reqPath, 'utf-8');
+
+  const header = `\n## ${milestoneName} Requirements\n\n<!-- TBD: first requirement -->\n- [ ] **REQ-TBD**: TBD\n`;
+  let next;
+  const marker = '\n## Out of Scope';
+  const idx = current.indexOf(marker);
+  if (idx >= 0) {
+    next = current.slice(0, idx) + header + current.slice(idx);
+  } else {
+    next = current.endsWith('\n') ? current + header : current + '\n' + header;
+  }
+  _writeFile(reqPath, next);
+}
+
+function _apply(answersPath, cwd, stdout) {
+  let raw;
+  try {
+    raw = fs.readFileSync(answersPath, 'utf-8');
+  } catch (err) {
+    throw new NubosPilotError(
+      'answers-not-readable',
+      'answers file not readable: ' + answersPath,
+      { path: answersPath, cause: err && err.code },
+    );
+  }
+  let answers;
+  try {
+    answers = JSON.parse(raw);
+  } catch (err) {
+    throw new NubosPilotError(
+      'answers-parse-error',
+      'answers file is not valid JSON',
+      { path: answersPath, cause: err && err.message },
+    );
+  }
+  _validateAnswers(answers);
+
+  const root = path.resolve(cwd);
+  _guardInitialized(root);
+
+  const milestoneId = _slugify(answers.milestone_name);
+  if (milestoneId === '') {
+    throw new NubosPilotError(
+      'invalid-slug',
+      'milestone_name slugifies to empty string',
+      { value: answers.milestone_name, field: 'milestone_name' },
+    );
+  }
+  const firstPhaseSlug = phaseSlug(answers.first_phase_name);
+  if (firstPhaseSlug === '') {
+    throw new NubosPilotError(
+      'invalid-slug',
+      'first_phase_name slugifies to empty string',
+      { value: answers.first_phase_name, field: 'first_phase_name' },
+    );
+  }
+
+  
+
+  
+
+  
+
+  const { phases: existingPhases } = parseRoadmap(root);
+  let globalMax = 0;
+  for (const p of existingPhases) {
+    const n = Number(p.number);
+    if (Number.isInteger(n) && n > globalMax) globalMax = n;
+  }
+  const nextPhaseNumber = globalMax + 1;
+
+  
+
+  
+
+  
+
+  addMilestone(
+    {
+      id: milestoneId,
+      name: answers.milestone_name,
+      phases: [
+        {
+          number: nextPhaseNumber,
+          slug: firstPhaseSlug,
+          name: answers.first_phase_name,
+          goal: answers.milestone_goal,
+          depends_on: [],
+          requirements: [],
+          success_criteria: [],
+          status: 'pending',
+          plans: [],
+        },
+      ],
+    },
+    root,
+  );
+  const phaseResult = {
+    milestoneId,
+    number: nextPhaseNumber,
+    slug: firstPhaseSlug,
+  };
+
+  
+
+  void addPhase;
+
+  
+
+  const phaseDir = createPhaseDir(phaseResult.number, firstPhaseSlug, root);
+  const padded = String(phaseResult.number).padStart(2, '0');
+  const ctxVars = {
+    phase_number: String(phaseResult.number),
+    phase_name: answers.first_phase_name,
+    phase_padded: padded,
+    phase_slug: firstPhaseSlug,
+    created_date: new Date().toISOString().slice(0, 10),
+    domain_text: '<!-- TBD: phase boundary -->',
+    decisions_text: '<!-- TBD: decisions -->',
+    canonical_refs_text: '<!-- TBD: canonical references -->',
+    code_context_text: '<!-- TBD: existing code insights -->',
+    specifics_text: '<!-- TBD: specific ideas / references -->',
+    deferred_text: '<!-- TBD: deferred ideas -->',
+  };
+  const contextMdPath = path.join(phaseDir, padded + '-CONTEXT.md');
+  _writeFile(contextMdPath, _render(_loadTemplate('CONTEXT'), ctxVars, 'CONTEXT'));
+
+  
+
+  if (answers.create_req_prefix === true) {
+    _appendReqPrefix(root, answers.milestone_name);
+  }
+
+  
+
+  mutateState((state) => {
+    const fm = Object.assign({}, state.frontmatter, {
+      milestone: milestoneId,
+      milestone_name: answers.milestone_name,
+      current_phase: Number(phaseResult.number),
+      current_plan: null,
+      current_task: null,
+      last_updated: new Date().toISOString(),
+    });
+    return { frontmatter: fm, body: state.body };
+  }, root);
+
+  
+  projectStateDir(root);
+
+  _emit(stdout, {
+    mode: 'apply',
+    milestoneId,
+    phaseNumber: phaseResult.number,
+    phaseSlug: firstPhaseSlug,
+    created_req_prefix: answers.create_req_prefix === true,
+  });
+}
+
+function run(args, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const argv = args || [];
+
+  const applyIdx = argv.indexOf('--apply');
+  if (applyIdx >= 0) {
+    const answersPath = argv[applyIdx + 1];
+    if (!answersPath) {
+      throw new NubosPilotError(
+        'missing-apply-path',
+        '--apply requires a path to the answers JSON file',
+        { args: argv.slice() },
+      );
+    }
+    _apply(answersPath, cwd, stdout);
+    return;
+  }
+
+  _emit(stdout, _interviewPayload());
+}
+
+module.exports = { run, _interviewPayload };

package/bin/np-tools/new-milestone.test.cjs

@@ -0,0 +1,166 @@
+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 crypto = require('node:crypto');
+
+const newProject = require('./new-project.cjs');
+const subcmd = require('./new-milestone.cjs');
+
+const _sandboxes = [];
+
+function makeEmptySandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-newms-'));
+  _sandboxes.push(root);
+  return root;
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    const p = _sandboxes.pop();
+    try { fs.rmSync(p, { recursive: true, force: true }); } catch {  }
+  }
+});
+
+function _captureStdout() {
+  let buf = '';
+  const stub = { write: (s) => { buf += s; return true; } };
+  return { stub, get: () => buf };
+}
+
+function _seedInitializedProject(root) {
+  const answers = {
+    project_name: 'Demo',
+    core_value: 'ship',
+    primary_constraints: 'nodejs',
+    first_milestone_name: 'v1.0',
+    first_phase_name: 'First Phase',
+  };
+  const p = path.join(root, 'init-answers.json');
+  fs.writeFileSync(p, JSON.stringify(answers), 'utf-8');
+  newProject.run(['--apply', p], { cwd: root, stdout: _captureStdout().stub });
+  fs.unlinkSync(p);
+}
+
+function _writeAnswers(root, answers, name) {
+  const p = path.join(root, (name || 'ms-answers') + '.json');
+  fs.writeFileSync(p, JSON.stringify(answers), 'utf-8');
+  return p;
+}
+
+function _baseMsAnswers() {
+  return {
+    milestone_name: 'v2.0',
+    milestone_goal: 'second milestone',
+    first_phase_name: 'Second Phase',
+    create_req_prefix: false,
+  };
+}
+
+test('NM-1: run([]) emits interview JSON with 4 questions', () => {
+  const sandbox = makeEmptySandbox();
+  const cap = _captureStdout();
+  subcmd.run([], { cwd: sandbox, stdout: cap.stub });
+  const payload = JSON.parse(cap.get().trim());
+  assert.equal(payload.mode, 'interview');
+  const keys = payload.questions.map((q) => q.key);
+  for (const expected of [
+    'milestone_name',
+    'milestone_goal',
+    'first_phase_name',
+    'create_req_prefix',
+  ]) {
+    assert.ok(keys.includes(expected), 'interview missing ' + expected);
+  }
+});
+
+test('NM-2: --apply without PROJECT.md throws project-not-initialized', () => {
+  const sandbox = makeEmptySandbox();
+  const answersPath = _writeAnswers(sandbox, _baseMsAnswers());
+  assert.throws(
+    () => subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub }),
+    (err) => err.name === 'NubosPilotError' && err.code === 'project-not-initialized',
+  );
+});
+
+test('NM-3: --apply on initialized project appends milestone + phase', () => {
+  const sandbox = makeEmptySandbox();
+  _seedInitializedProject(sandbox);
+  const answersPath = _writeAnswers(sandbox, _baseMsAnswers());
+  subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub });
+  const YAML = require('yaml');
+  const rm = YAML.parse(fs.readFileSync(path.join(sandbox, '.nubos-pilot', 'roadmap.yaml'), 'utf-8'));
+  assert.equal(rm.milestones.length, 2, 'roadmap.yaml should have 2 milestones');
+  assert.equal(rm.milestones[1].id, 'v2-0'); 
+  assert.equal(rm.milestones[1].phases.length, 1);
+});
+
+test('NM-4: --apply does NOT touch PROJECT.md (byte-equal before/after) — D-29', () => {
+  const sandbox = makeEmptySandbox();
+  _seedInitializedProject(sandbox);
+  const projectMdPath = path.join(sandbox, '.nubos-pilot', 'PROJECT.md');
+  const beforeBytes = fs.readFileSync(projectMdPath);
+  const beforeHash = crypto.createHash('sha256').update(beforeBytes).digest('hex');
+
+  const answersPath = _writeAnswers(sandbox, _baseMsAnswers());
+  subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub });
+
+  const afterBytes = fs.readFileSync(projectMdPath);
+  const afterHash = crypto.createHash('sha256').update(afterBytes).digest('hex');
+  assert.equal(afterHash, beforeHash, 'PROJECT.md bytes changed — D-29 violation');
+});
+
+test('NM-5: duplicate milestone_name throws roadmap-duplicate-milestone', () => {
+  const sandbox = makeEmptySandbox();
+  _seedInitializedProject(sandbox);
+
+  
+  const answers = Object.assign({}, _baseMsAnswers(), { milestone_name: 'v1.0' });
+  const answersPath = _writeAnswers(sandbox, answers);
+  assert.throws(
+    () => subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub }),
+    (err) => err.name === 'NubosPilotError' && err.code === 'roadmap-duplicate-milestone',
+  );
+});
+
+test('NM-6: create_req_prefix=true appends H2 section to REQUIREMENTS.md', () => {
+  const sandbox = makeEmptySandbox();
+  _seedInitializedProject(sandbox);
+  const reqPath = path.join(sandbox, '.nubos-pilot', 'REQUIREMENTS.md');
+  const before = fs.readFileSync(reqPath, 'utf-8');
+  assert.doesNotMatch(before, /## v2\.0 Requirements/);
+
+  const answers = Object.assign({}, _baseMsAnswers(), { create_req_prefix: true });
+  const answersPath = _writeAnswers(sandbox, answers);
+  subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub });
+
+  const after = fs.readFileSync(reqPath, 'utf-8');
+  assert.match(after, /## v2\.0 Requirements/);
+});
+
+test('NM-7: create_req_prefix=false leaves REQUIREMENTS.md byte-equal', () => {
+  const sandbox = makeEmptySandbox();
+  _seedInitializedProject(sandbox);
+  const reqPath = path.join(sandbox, '.nubos-pilot', 'REQUIREMENTS.md');
+  const beforeHash = crypto.createHash('sha256').update(fs.readFileSync(reqPath)).digest('hex');
+
+  const answersPath = _writeAnswers(sandbox, _baseMsAnswers());
+  subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub });
+
+  const afterHash = crypto.createHash('sha256').update(fs.readFileSync(reqPath)).digest('hex');
+  assert.equal(afterHash, beforeHash);
+});
+
+test('NM-8: STATE.md milestone pointer advances to new milestone id', () => {
+  const sandbox = makeEmptySandbox();
+  _seedInitializedProject(sandbox);
+  const answersPath = _writeAnswers(sandbox, _baseMsAnswers());
+  subcmd.run(['--apply', answersPath], { cwd: sandbox, stdout: _captureStdout().stub });
+  const { readState } = require('../../lib/state.cjs');
+  const st = readState(sandbox);
+  assert.equal(st.frontmatter.milestone, 'v2-0');
+
+  assert.equal(typeof st.frontmatter.current_phase, 'number');
+  assert.ok(st.frontmatter.current_phase >= 1);
+});