nubos-pilot 0.4.0 → 0.5.0

package/bin/install.js

@@ -222,19 +222,18 @@ async function _runInitQuestions(detectedRuntime, askUser, flags) {
   const scope = f.scope || (await askUser({ type: 'select', question: 'Installation scope?',
     options: VALID_SCOPES, default: 'local' })).value;
   const model_profile = (await askUser({ type: 'select', question: 'Model-Profile?',
-    options: ['inherit', 'quality', 'balanced', 'budget'], default: 'inherit' })).value;
-  const commit_docs = (await askUser({ type: 'confirm', question: 'Commit documentation artefacts?', default: true })).value;
-  const branching_strategy = (await askUser({ type: 'select', question: 'Branching strategy?',
-    options: ['single-branch', 'phase-branches', 'milestone-branches'], default: 'single-branch' })).value;
-  const phase_branch_template = (await askUser({ type: 'input', question: 'Phase branch template?', default: 'phase/{number}-{slug}' })).value;
-  const milestone_branch_template = (await askUser({ type: 'input', question: 'Milestone branch template?', default: 'milestone/{name}' })).value;
-  const parallelization = (await askUser({ type: 'confirm', question: 'Enable parallelization?', default: true })).value;
-  const research = (await askUser({ type: 'confirm', question: 'Enable research step?', default: false })).value;
-  const plan_checker = (await askUser({ type: 'confirm', question: 'Enable plan_checker?', default: true })).value;
-  const verifier = (await askUser({ type: 'confirm', question: 'Enable verifier?', default: true })).value;
+    options: ['frontier', 'quality', 'balanced', 'budget', 'inherit'], default: 'frontier' })).value;
   const response_language = (await askUser({ type: 'input', question: 'Response language (ISO-639 code)?', default: 'en' })).value;
-  return { runtime, runtimes, scope, mcp: !!f.mcp, model_profile, commit_docs, branching_strategy, phase_branch_template,
-    milestone_branch_template, parallelization, research, plan_checker, verifier, response_language };
+  return {
+    runtime, runtimes, scope, mcp: !!f.mcp,
+    model_profile,
+    response_language,
+    commit_docs: true,
+    parallelization: true,
+    research: true,
+    plan_checker: true,
+    verifier: true,
+  };
 }
 
 function _repairCodexConfig() {
@@ -251,56 +250,38 @@ function _repairCodexConfig() {
 
 const LEGACY_AGENTS = new Set(['claude', 'codex', 'gemini', 'opencode']);
 
+const DEFAULT_CLAUDE_MD = '# CLAUDE.md\n\n'
+  + 'Project guidance for Claude Code. Add project-specific instructions above the'
+  + ' managed block — `npx nubos-pilot` only rewrites the block between the markers.\n';
+
 function _rewriteManagedMarkdown(projectRoot, runtimes) {
   const claudePath = path.join(projectRoot, 'CLAUDE.md');
   const agentsPath = path.join(projectRoot, 'AGENTS.md');
   const geminiPath = path.join(projectRoot, 'GEMINI.md');
-  const claudeExists = fs.existsSync(claudePath);
-  if (claudeExists) {
-    const content = fs.readFileSync(claudePath, 'utf-8');
-    const next = managedBlockMod.rewriteBlock(content, MANAGED_BLOCK_INNER);
-    atomicWriteFileSync(claudePath, next);
-  }
-
-  let agentsBase;
-  if (fs.existsSync(agentsPath)) {
-    agentsBase = fs.readFileSync(agentsPath, 'utf-8');
-  } else if (claudeExists) {
-    agentsBase = agentsMdMod.generateAgentsMd(fs.readFileSync(claudePath, 'utf-8'), 'codex');
-  } else {
-    agentsBase = null;
-  }
-  if (agentsBase !== null) {
-    const agentsNext = managedBlockMod.rewriteBlock(agentsBase, MANAGED_BLOCK_INNER);
-    atomicWriteFileSync(agentsPath, agentsNext);
-  }
-
-  let geminiBase;
-  if (fs.existsSync(geminiPath)) {
-    geminiBase = fs.readFileSync(geminiPath, 'utf-8');
-  } else if (claudeExists) {
-    geminiBase = agentsMdMod.generateAgentsMd(fs.readFileSync(claudePath, 'utf-8'), 'gemini');
-  } else {
-    geminiBase = null;
-  }
-  if (geminiBase !== null) {
-    const geminiNext = managedBlockMod.rewriteBlock(geminiBase, MANAGED_BLOCK_INNER);
-    atomicWriteFileSync(geminiPath, geminiNext);
-  }
+  const claudeBase = fs.existsSync(claudePath)
+    ? fs.readFileSync(claudePath, 'utf-8')
+    : DEFAULT_CLAUDE_MD;
+  const claudeNext = managedBlockMod.rewriteBlock(claudeBase, MANAGED_BLOCK_INNER);
+  atomicWriteFileSync(claudePath, claudeNext);
+
+  const agentsBase = fs.existsSync(agentsPath)
+    ? fs.readFileSync(agentsPath, 'utf-8')
+    : agentsMdMod.generateAgentsMd(claudeNext, 'codex');
+  atomicWriteFileSync(agentsPath, managedBlockMod.rewriteBlock(agentsBase, MANAGED_BLOCK_INNER));
+
+  const geminiBase = fs.existsSync(geminiPath)
+    ? fs.readFileSync(geminiPath, 'utf-8')
+    : agentsMdMod.generateAgentsMd(claudeNext, 'gemini');
+  atomicWriteFileSync(geminiPath, managedBlockMod.rewriteBlock(geminiBase, MANAGED_BLOCK_INNER));
 
   const extras = (runtimes || []).filter((id) => !LEGACY_AGENTS.has(id));
   for (const id of extras) {
     const meta = registryMod.getRuntimeMeta(id);
     if (!meta) continue;
     const targetPath = registryMod.runtimeAgentsPath(meta, 'local', projectRoot);
-    let base;
-    if (fs.existsSync(targetPath)) {
-      base = fs.readFileSync(targetPath, 'utf-8');
-    } else if (claudeExists) {
-      base = agentsMdMod.generateAgentsMd(fs.readFileSync(claudePath, 'utf-8'), 'codex');
-    } else {
-      base = '';
-    }
+    const base = fs.existsSync(targetPath)
+      ? fs.readFileSync(targetPath, 'utf-8')
+      : agentsMdMod.generateAgentsMd(claudeNext, 'codex');
     const next = managedBlockMod.rewriteBlock(base, MANAGED_BLOCK_INNER);
     fs.mkdirSync(path.dirname(targetPath), { recursive: true });
     atomicWriteFileSync(targetPath, next);

package/bin/np-tools/_commands.cjs

@@ -1,70 +1,54 @@
 const COMMANDS = [
-  { name: 'next',     category: 'Utility', description: 'Print the next actionable step' },
-  { name: 'progress', category: 'Utility', description: 'Report % complete across phases and plans' },
   { name: 'state',    category: 'Utility', description: 'Print the current project state snapshot' },
   { name: 'help',     category: 'Utility', description: 'List available commands' },
   { name: 'init',     category: 'Utility', description: 'Dispatcher init payload for workflows' },
 
-  { name: 'discuss-phase',       category: 'Planning', description: 'Adaptive phase-context interview (writes CONTEXT.md)' },
-  { name: 'discuss-phase-power', category: 'Planning', description: 'Bulk gray-area question file-UI (power mode)' },
-  { name: 'research-phase',      category: 'Planning', description: 'Optional phase-level research (WebFetch + MCP; offline fallback)' },
-  { name: 'plan-phase',          category: 'Planning', description: 'Creates PLAN.md with plan-checker verification loop' },
-  { name: 'new-project',         category: 'Planning', description: 'Greenfield project init (PROJECT.md + REQUIREMENTS.md + roadmap)' },
-  { name: 'new-milestone',       category: 'Planning', description: 'Append milestone + first phase to an existing project' },
-  { name: 'plan-milestone-gaps', category: 'Planning', description: 'Create corrective phases from audit gaps' },
+  { name: 'discuss-project',     category: 'Planning', description: 'Adaptive project-context interview (writes PROJECT.md decisions)' },
+  { name: 'discuss-phase',       category: 'Planning', description: 'Adaptive milestone-context interview (writes M<NNN>-CONTEXT.md)' },
+  { name: 'research-phase',      category: 'Planning', description: 'Milestone-level research (WebFetch + MCP; offline fallback)' },
+  { name: 'plan-milestone',      category: 'Planning', description: 'Plan a milestone: scaffolds slices + tasks' },
+  { name: 'new-project',         category: 'Planning', description: 'Greenfield project init (PROJECT.md + REQUIREMENTS.md + M001 milestone)' },
+  { name: 'new-milestone',       category: 'Planning', description: 'Append a new milestone (M<NNN>) to an existing project' },
   { name: 'agent-skills',        category: 'Planning', description: 'Print agent_skills config for a given subagent' },
 
-  { name: 'execute-phase',       category: 'Execution', description: 'Wave-based phase execution (emits per-task executor-spawn payloads)' },
-  { name: 'execute-plan',        category: 'Execution', description: 'Single-plan execution (sub-case of execute-phase)' },
-  { name: 'commit-task',         category: 'Execution', description: 'Atomic per-task git commit via lib/git.cjs (D-03/D-25 enforced)' },
+  { name: 'execute-milestone',   category: 'Execution', description: 'Wave-based milestone execution — slice by slice, tasks parallel within a slice' },
+  { name: 'commit-task',         category: 'Execution', description: 'Atomic per-task git commit via lib/git.cjs' },
   { name: 'checkpoint',          category: 'Execution', description: 'Per-task crash-safety checkpoint CRUD (start/transition/touch/show)' },
-  { name: 'autonomous',          category: 'Execution', description: 'In-session gate snapshot for auto-advance loop (ADR-0001, no daemon)' },
-  { name: 'verify-work',         category: 'Execution', description: 'Two-pass goal-backward verification (D-21/D-22 VERIFICATION.md render/record)' },
+  { name: 'verify-work',         category: 'Execution', description: 'Two-pass goal-backward verification (milestone-level VERIFICATION.md)' },
   { name: 'add-tests',           category: 'Execution', description: 'Persist VERIFICATION Pass-cases as node:test UAT (Sentinel-preserving)' },
   { name: 'pause-work',          category: 'Execution', description: 'Stamp STATE.session.stopped_at + resume_file for explicit handoff' },
   { name: 'resume-work',         category: 'Execution', description: 'Classify session state (resume | orphan | clean) from STATE + checkpoints' },
 
-  { name: 'undo',                category: 'Execution', description: 'Revert all task commits of a phase or plan via git revert (no history rewrite)' },
-  { name: 'undo-task',           category: 'Execution', description: 'Revert a single task commit and reset task status to pending' },
-  { name: 'reset-slice',         category: 'Execution', description: 'Restore working-tree files of the in-flight task and clear current_task (no commit)' },
   { name: 'skip',                category: 'Execution', description: 'Mark task status skipped (lifecycle CRUD)' },
   { name: 'park',                category: 'Execution', description: 'Mark task status parked (lifecycle CRUD)' },
   { name: 'unpark',              category: 'Execution', description: 'Return a parked task to pending (lifecycle CRUD)' },
 
-  { name: 'doctor',              category: 'Install', description: '5-check install-integrity scan (--fix for auto-safe fixes)' },
-  { name: 'dispatch',            category: 'Install', description: 'State-router: computes next action and delegates via Skill()' },
-  { name: 'queue',               category: 'Install', description: 'Unified queue across todos/backlog/UAT/unplanned phases' },
-  { name: 'triage',              category: 'Install', description: 'Interactive per-item triage loop (promote/keep/drop)' },
+  { name: 'undo',                category: 'Execution', description: 'Revert every task commit of a milestone or slice via git revert (no history rewrite)' },
+  { name: 'undo-task',           category: 'Execution', description: 'Revert a single task commit and reset task status to pending' },
+  { name: 'reset-slice',         category: 'Execution', description: 'Discard in-flight task: restore working tree from HEAD, drop checkpoint, clear STATE.current_task' },
 
-  { name: 'resolve-model',       category: 'Utility', description: 'Resolve agent/tier to model alias or id (Tier×Profile matrix; consulted at Task-spawn sites by workflows)' },
+  { name: 'doctor',              category: 'Install', description: '5-check install-integrity scan (--fix for auto-safe fixes)' },
+  { name: 'scan-codebase',       category: 'Install', description: 'Initial deep codebase inventory → .nubos-pilot/codebase/ skill docs' },
+  { name: 'update-docs',         category: 'Install', description: 'Refresh stale module docs after code changes' },
 
+  { name: 'resolve-model',       category: 'Utility', description: 'Resolve agent/tier to model alias or id (Tier×Profile matrix)' },
   { name: 'metrics',             category: 'Utility', description: 'Record JSONL metrics entry (record | now | start-timestamp | end-timestamp)' },
 
-  { name: 'plan-diff',           category: 'Planning', description: 'Render two-part PLAN.md diff (semantic + git) or archive-rejected with reason' },
+  { name: 'validate-phase',      category: 'Review',  description: 'Nyquist validation gap-fill via np-nyquist-auditor' },
 
-  { name: 'ai-integration-phase', category: 'Planning', description: 'AI-SPEC generator with framework-selector + eval-planner (spawns 4 np-agents)' },
-  { name: 'ui-phase',              category: 'Planning', description: 'UI-SPEC generator with researcher + checker revision loop' },
-  { name: 'ui-review',             category: 'Review', description: '6-pillar retroactive UI audit on a completed phase' },
-  { name: 'eval-review',           category: 'Review', description: 'Retroactive eval-coverage audit on a completed phase' },
+  { name: 'add-todo',            category: 'Capture', description: 'Capture a pending todo to .nubos-pilot/todos/pending/ + increment STATE count' },
+  { name: 'note',                category: 'Capture', description: 'Capture a free-form note (project default, --global writes to ~/.nubos-pilot/notes/)' },
+  { name: 'add-backlog',         category: 'Capture', description: 'Append backlog item to ROADMAP.md' },
 
   { name: 'askuser',         category: 'Utility', description: 'Capability-layer prompt wrapper (reads spec JSON, returns chosen label)' },
-  { name: 'commit',          category: 'Utility', description: 'Atomic git commit wrapper with gitignore-guard (D-21)' },
+  { name: 'commit',          category: 'Utility', description: 'Atomic git commit wrapper with gitignore-guard' },
   { name: 'config-get',      category: 'Utility', description: 'Read value from .nubos-pilot/config.json by dotted key path' },
-  { name: 'generate-slug',   category: 'Utility', description: 'Slugify text via lib/phase.cjs.phaseSlug (used by add-todo, add-backlog, thread)' },
-  { name: 'phase',           category: 'Utility', description: 'Phase utilities (next-decimal <base> — used by add-backlog 999.x)' },
+  { name: 'generate-slug',   category: 'Utility', description: 'Slugify text via lib/layout.cjs.slugify' },
   { name: 'stats',           category: 'Utility', description: 'Aggregated project stats (roadmap + STATE + git + metrics JSON shape)' },
 
-  { name: 'code-review',      category: 'Review',  description: 'Source-file review via np-code-reviewer (depth quick/standard/deep) — writes REVIEW.md sidecar' },
-  { name: 'code-review-fix',  category: 'Review',  description: 'Auto-fix REVIEW.md findings via np-code-fixer (atomic commit per finding)' },
-  { name: 'review',           category: 'Review',  description: 'Cross-AI peer review via 7-CLI fan-out (gemini/claude/codex/coderabbit/opencode/qwen/cursor)' },
-  { name: 'secure-phase',     category: 'Review',  description: 'Threat-mitigation audit via np-security-auditor against PLAN.md threat_model' },
-  { name: 'validate-phase',   category: 'Review',  description: 'Nyquist validation gap-fill via np-nyquist-auditor' },
-  { name: 'add-todo',         category: 'Capture', description: 'Capture a pending todo to .nubos-pilot/todos/pending/ + increment STATE count' },
-  { name: 'note',             category: 'Capture', description: 'Capture a free-form note (project default, --global writes to ~/.nubos-pilot/notes/)' },
-  { name: 'add-backlog',      category: 'Capture', description: 'Append backlog item 999.x to ROADMAP.md + scaffold phase dir' },
   { name: 'thread',           category: 'Utility', description: 'Cross-session thread CRUD (create/resume under .nubos-pilot/threads/)' },
   { name: 'session-report',   category: 'Utility', description: 'Generate session report from metrics since .last-session pointer' },
-  { name: 'cleanup',          category: 'Utility', description: 'Archive completed milestones to .nubos-pilot/archive/v<X.Y>/ + collapse ROADMAP <details> block' },
+  { name: 'cleanup',          category: 'Utility', description: 'Archive completed milestones to .nubos-pilot/archive/v<X.Y>/' },
 ];
 
 module.exports = { COMMANDS };

package/bin/np-tools/add-tests.cjs

@@ -3,65 +3,61 @@ const path = require('node:path');
 
 const { NubosPilotError, atomicWriteFileSync, withFileLock } = require('../../lib/core.cjs');
 const { getPhase } = require('../../lib/roadmap.cjs');
-const { paddedPhase, phaseSlug, findPhaseDir } = require('../../lib/phase.cjs');
-const { parseVerificationMd } = require('../../lib/verify.cjs');
+const layout = require('../../lib/layout.cjs');
+const { parseVerificationMd, milestoneVerificationPath } = require('../../lib/verify.cjs');
 
 const BEGIN_MARKER = '// >>> np:add-tests begin';
 const END_MARKER = '// <<< np:add-tests end';
 
-function _validatePhaseArg(raw) {
-  if (raw == null || raw === '' || !/^\d+(\.\d+)?$/.test(String(raw))) {
+function _validateMilestoneArg(raw) {
+  if (raw == null || raw === '' || !/^\d+$/.test(String(raw))) {
     throw new NubosPilotError(
       'add-tests-invalid-phase',
-      'add-tests requires a numeric phase argument',
+      'add-tests requires a positive integer milestone argument',
       { value: raw == null ? '' : String(raw) },
     );
   }
-  return String(raw);
+  return Number(raw);
 }
 
-function _resolveTestTarget(phaseArg, cwd) {
-  const phaseN = Number(phaseArg);
-  const phase = getPhase(phaseN, cwd);
-  const slug = phase.slug || phaseSlug(phase.name);
-  const padded = paddedPhase(phaseN);
+function _resolveTestTarget(mNum, cwd) {
+  const def = getPhase(mNum, cwd);
+  const slug = layout.slugify(def.name || 'milestone');
+  const mIdStr = layout.mId(mNum);
   let dir = path.resolve(cwd);
   for (let i = 0; i < 10; i++) {
     if (fs.existsSync(path.join(dir, 'package.json'))) {
       return {
         pkg_root: dir,
-        target_path: path.join(dir, 'test', 'uat', 'phase-' + padded + '-' + slug + '.test.cjs'),
-        padded, slug,
+        target_path: path.join(dir, 'test', 'uat', mIdStr.toLowerCase() + '-' + slug + '.test.cjs'),
+        milestone_id: mIdStr, slug,
       };
     }
     const parent = path.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-
   return {
     pkg_root: path.resolve(cwd),
-    target_path: path.join(path.resolve(cwd), 'test', 'uat', 'phase-' + padded + '-' + slug + '.test.cjs'),
-    padded, slug,
+    target_path: path.join(path.resolve(cwd), 'test', 'uat', mIdStr.toLowerCase() + '-' + slug + '.test.cjs'),
+    milestone_id: mIdStr, slug,
   };
 }
 
-function _loadCases(phaseArg, cwd) {
-  const phaseN = Number(phaseArg);
-  const padded = paddedPhase(phaseN);
-  const phase_dir = findPhaseDir(phaseN, cwd);
-  if (!phase_dir) {
+function _loadCases(mNum, cwd) {
+  const mDir = layout.findMilestoneDir(mNum, cwd);
+  if (!mDir) {
     throw new NubosPilotError(
       'add-tests-phase-dir-missing',
-      'Phase directory not found for phase ' + phaseN,
-      { phase: phaseN },
+      'Milestone directory not found for milestone ' + mNum,
+      { milestone: mNum },
     );
   }
-  const vp = path.join(phase_dir, padded + '-VERIFICATION.md');
+  const vp = milestoneVerificationPath(mNum, cwd);
   if (!fs.existsSync(vp)) {
     throw new NubosPilotError(
       'add-tests-verification-missing',
-      'VERIFICATION.md not found — run `/np:verify-work ' + phaseArg + '` first',
+      'VERIFICATION.md not found — run `/np:verify-work ' + mNum + '` first',
       { path: vp },
     );
   }
@@ -75,10 +71,10 @@ function _jsString(s) {
   return "'" + String(s).replace(/\\/g, '\\\\').replace(/'/g, "\\'").replace(/\n/g, '\\n') + "'";
 }
 
-function _renderBlock(phasePadded, passes, skips) {
+function _renderBlock(milestoneId, passes, skips) {
   const date = new Date().toISOString().slice(0, 10);
   const lines = [];
-  lines.push(BEGIN_MARKER + ' (phase ' + phasePadded + ', generated ' + date + ')');
+  lines.push(BEGIN_MARKER + ' (' + milestoneId + ', generated ' + date + ')');
   lines.push("const { test } = require('node:test');");
   lines.push("const assert = require('node:assert');");
   lines.push('');
@@ -111,11 +107,11 @@ function _mergeBlock(existing, block) {
   return before + block + after;
 }
 
-function _emitTests(phaseArg, cwd) {
-  const { passes, skips } = _loadCases(phaseArg, cwd);
-  const target = _resolveTestTarget(phaseArg, cwd);
+function _emitTests(mNum, cwd) {
+  const { passes, skips } = _loadCases(mNum, cwd);
+  const target = _resolveTestTarget(mNum, cwd);
   fs.mkdirSync(path.dirname(target.target_path), { recursive: true });
-  const block = _renderBlock(target.padded, passes, skips);
+  const block = _renderBlock(target.milestone_id, passes, skips);
   return withFileLock(target.target_path, () => {
     let existing = null;
     try { existing = fs.readFileSync(target.target_path, 'utf-8'); } catch { existing = null; }
@@ -139,12 +135,13 @@ function run(args, ctx) {
 
   switch (verb) {
     case 'init': {
-      const phaseArg = _validatePhaseArg(list[1]);
-      const target = _resolveTestTarget(phaseArg, cwd);
-      const { passes, skips, verification_path } = _loadCases(phaseArg, cwd);
+      const mNum = _validateMilestoneArg(list[1]);
+      const target = _resolveTestTarget(mNum, cwd);
+      const { passes, skips, verification_path } = _loadCases(mNum, cwd);
       const payload = {
         _workflow: 'add-tests',
-        phase: phaseArg,
+        milestone: mNum,
+        milestone_id: target.milestone_id,
         target_path: target.target_path,
         verification_path,
         pass_cases: passes,
@@ -154,8 +151,8 @@ function run(args, ctx) {
       return payload;
     }
     case 'emit': {
-      const phaseArg = _validatePhaseArg(list[1]);
-      const result = _emitTests(phaseArg, cwd);
+      const mNum = _validateMilestoneArg(list[1]);
+      const result = _emitTests(mNum, cwd);
       stdout.write(JSON.stringify(result));
       return result;
     }

package/bin/np-tools/add-tests.test.cjs

@@ -3,30 +3,40 @@ const assert = require('node:assert/strict');
 const fs = require('node:fs');
 const path = require('node:path');
 
-const { makeSandbox, seedRoadmapYaml, seedPhaseDir, cleanupAll } =
+const { makeSandbox, seedRoadmapYaml, seedMilestoneDir, cleanupAll } =
   require('../../tests/helpers/fixture.cjs');
 const subcmd = require('./add-tests.cjs');
 
 function _roadmap() {
   return {
-    schema_version: 1,
-    milestones: [{ id: 'v1.0', name: 'm1', phases: [
-      { number: 6, name: 'Execution', slug: 'execution', goal: '', depends_on: [],
-        requirements: [], success_criteria: ['a', 'b', 'c'],
-        status: 'planned', plans: [] },
-    ]}],
+    schema_version: 2,
+    milestones: [
+      {
+        id: 'M006',
+        number: 6,
+        name: 'Execution',
+        goal: '',
+        requirements: [],
+        success_criteria: ['a', 'b', 'c'],
+        status: 'pending',
+        slices: [],
+      },
+    ],
   };
 }
 
-function _capture() { let b = ''; return { stub: { write: (s) => { b += s; return true; } }, get: () => b }; }
+function _capture() {
+  let b = '';
+  return { stub: { write: (s) => { b += s; return true; } }, get: () => b };
+}
 
 function _seedVerification(sandbox) {
-  const phaseDir = seedPhaseDir(sandbox, 6, 'execution', {});
+  const mDir = seedMilestoneDir(sandbox, 6, {});
   const v = [
-    '# Phase 6: Execution - Verification',
+    '# M006 — Execution — Verification',
     '',
     '**Verified:** 2026-04-15',
-    '**Phase Status:** deferred',
+    '**Milestone Status:** deferred',
     '',
     '## Success Criteria',
     '',
@@ -46,10 +56,9 @@ function _seedVerification(sandbox) {
     '- **Evidence:** —',
     '',
   ].join('\n');
-  fs.writeFileSync(path.join(phaseDir, '06-VERIFICATION.md'), v, 'utf-8');
-
+  fs.writeFileSync(path.join(mDir, 'M006-VERIFICATION.md'), v, 'utf-8');
   fs.writeFileSync(path.join(sandbox, 'package.json'), '{"name":"sandbox"}', 'utf-8');
-  return phaseDir;
+  return mDir;
 }
 
 afterEach(cleanupAll);
@@ -60,40 +69,39 @@ test('AT-1: init emits pass_cases (1) and skip_cases (2) categorized', () => {
   _seedVerification(sandbox);
   const cap = _capture();
   const p = subcmd.run(['init', '6'], { cwd: sandbox, stdout: cap.stub });
+  assert.equal(p.milestone, 6);
+  assert.equal(p.milestone_id, 'M006');
   assert.equal(p.pass_cases.length, 1);
   assert.equal(p.skip_cases.length, 2);
-  assert.ok(p.target_path.endsWith('test/uat/phase-06-execution.test.cjs'));
+  assert.ok(p.target_path.endsWith(path.join('test', 'uat', 'm006-execution.test.cjs')));
 });
 
 test('AT-2: emit writes node:test file with begin/end sentinels', () => {
   const sandbox = makeSandbox();
   seedRoadmapYaml(sandbox, _roadmap());
   _seedVerification(sandbox);
-  const cap = _capture();
-  const r = subcmd.run(['emit', '6'], { cwd: sandbox, stdout: cap.stub });
+  const r = subcmd.run(['emit', '6'], { cwd: sandbox, stdout: _capture().stub });
   const body = fs.readFileSync(r.target_path, 'utf-8');
   assert.ok(body.includes('// >>> np:add-tests begin'));
   assert.ok(body.includes('// <<< np:add-tests end'));
   assert.ok(body.includes("test('SC-1: First passes'"));
   assert.ok(body.includes("test.skip('SC-2: Second fails'"));
   assert.ok(body.includes("test.skip('SC-3: Deferred'"));
+  assert.ok(body.includes('M006'));
 });
 
 test('AT-3: sentinel preservation — user edits OUTSIDE block survive regeneration', () => {
   const sandbox = makeSandbox();
   seedRoadmapYaml(sandbox, _roadmap());
   _seedVerification(sandbox);
-  const cap1 = _capture();
-  subcmd.run(['emit', '6'], { cwd: sandbox, stdout: cap1.stub });
-  const target = path.join(sandbox, 'test', 'uat', 'phase-06-execution.test.cjs');
-
+  subcmd.run(['emit', '6'], { cwd: sandbox, stdout: _capture().stub });
+  const target = path.join(sandbox, 'test', 'uat', 'm006-execution.test.cjs');
   let body = fs.readFileSync(target, 'utf-8');
   const userTest = "// USER AUTHORED: do not delete\ntest('user: custom case', () => { assert.ok(1); });\n\n";
   body = userTest + body;
   fs.writeFileSync(target, body, 'utf-8');
 
-  const cap2 = _capture();
-  subcmd.run(['emit', '6'], { cwd: sandbox, stdout: cap2.stub });
+  subcmd.run(['emit', '6'], { cwd: sandbox, stdout: _capture().stub });
   const after = fs.readFileSync(target, 'utf-8');
   assert.ok(after.includes('// USER AUTHORED: do not delete'), 'user content lost');
   assert.ok(after.includes("test('user: custom case'"), 'user test lost');
@@ -103,20 +111,18 @@ test('AT-3: sentinel preservation — user edits OUTSIDE block survive regenerat
 test('AT-4: missing VERIFICATION.md → loud error', () => {
   const sandbox = makeSandbox();
   seedRoadmapYaml(sandbox, _roadmap());
-  seedPhaseDir(sandbox, 6, 'execution', {});
+  seedMilestoneDir(sandbox, 6, {});
   fs.writeFileSync(path.join(sandbox, 'package.json'), '{}', 'utf-8');
-  const cap = _capture();
   assert.throws(
-    () => subcmd.run(['init', '6'], { cwd: sandbox, stdout: cap.stub }),
+    () => subcmd.run(['init', '6'], { cwd: sandbox, stdout: _capture().stub }),
     (err) => err && err.code === 'add-tests-verification-missing',
   );
 });
 
 test('AT-5: unknown verb throws', () => {
   const sandbox = makeSandbox();
-  const cap = _capture();
   assert.throws(
-    () => subcmd.run(['bogus'], { cwd: sandbox, stdout: cap.stub }),
+    () => subcmd.run(['bogus'], { cwd: sandbox, stdout: _capture().stub }),
     (err) => err && err.code === 'add-tests-unknown-verb',
   );
 });

package/bin/np-tools/add-todo.cjs

@@ -2,7 +2,7 @@ const fs = require('node:fs');
 const path = require('node:path');
 
 const { projectStateDir, NubosPilotError } = require('../../lib/core.cjs');
-const { phaseSlug } = require('../../lib/phase.cjs');
+const { slugify } = require('../../lib/layout.cjs');
 
 const MAX_DESCRIPTION_LENGTH = 500;
 
@@ -34,7 +34,7 @@ function _buildPayload(description, cwd) {
   const now = new Date();
   const iso = now.toISOString();
   const date = iso.slice(0, 10);
-  const slug = phaseSlug(description);
+  const slug = slugify(description);
   if (!slug) {
     throw new NubosPilotError(
       'add-todo-empty-slug',

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

@@ -53,29 +53,29 @@ after(() => {
 test('CPT-1: checkpoint start writes file and updates STATE.current_task', () => {
   const root = makeRoot();
   const cap = _capture();
-  subcmd.run(['start', '06-01-T01', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
-  const cp = JSON.parse(fs.readFileSync(path.join(root, '.nubos-pilot', 'checkpoints', '06-01-T01.json'), 'utf-8'));
-  assert.equal(cp.task_id, '06-01-T01');
+  subcmd.run(['start', 'M006-S001-T0001', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
+  const cp = JSON.parse(fs.readFileSync(path.join(root, '.nubos-pilot', 'checkpoints', 'M006-S001-T0001.json'), 'utf-8'));
+  assert.equal(cp.task_id, 'M006-S001-T0001');
   assert.equal(cp.status, 'in-progress');
   const state = fs.readFileSync(path.join(root, '.nubos-pilot', 'STATE.md'), 'utf-8');
-  assert.ok(state.includes('current_task: 06-01-T01'), state);
+  assert.ok(state.includes('current_task: M006-S001-T0001'), state);
 });
 
 test('CPT-2: checkpoint transition updates status', () => {
   const root = makeRoot();
   const cap = _capture();
-  subcmd.run(['start', '06-01-T02', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
-  subcmd.run(['transition', '06-01-T02', 'verifying'], { cwd: root, stdout: cap.stub });
-  const cp = JSON.parse(fs.readFileSync(path.join(root, '.nubos-pilot', 'checkpoints', '06-01-T02.json'), 'utf-8'));
+  subcmd.run(['start', 'M006-S001-T0002', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
+  subcmd.run(['transition', 'M006-S001-T0002', 'verifying'], { cwd: root, stdout: cap.stub });
+  const cp = JSON.parse(fs.readFileSync(path.join(root, '.nubos-pilot', 'checkpoints', 'M006-S001-T0002.json'), 'utf-8'));
   assert.equal(cp.status, 'verifying');
 });
 
 test('CPT-3: checkpoint transition rejects unknown status', () => {
   const root = makeRoot();
   const cap = _capture();
-  subcmd.run(['start', '06-01-T03', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
+  subcmd.run(['start', 'M006-S001-T0003', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
   assert.throws(
-    () => subcmd.run(['transition', '06-01-T03', 'weird'], { cwd: root, stdout: cap.stub }),
+    () => subcmd.run(['transition', 'M006-S001-T0003', 'weird'], { cwd: root, stdout: cap.stub }),
     (err) => err && err.code === 'checkpoint-invalid-status',
   );
 });
@@ -83,28 +83,28 @@ test('CPT-3: checkpoint transition rejects unknown status', () => {
 test('CPT-4: checkpoint touch appends to files_touched', () => {
   const root = makeRoot();
   const cap = _capture();
-  subcmd.run(['start', '06-01-T04', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
-  subcmd.run(['touch', '06-01-T04', 'src/a.ts'], { cwd: root, stdout: cap.stub });
-  subcmd.run(['touch', '06-01-T04', 'src/b.ts'], { cwd: root, stdout: cap.stub });
-  const cp = JSON.parse(fs.readFileSync(path.join(root, '.nubos-pilot', 'checkpoints', '06-01-T04.json'), 'utf-8'));
+  subcmd.run(['start', 'M006-S001-T0004', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap.stub });
+  subcmd.run(['touch', 'M006-S001-T0004', 'src/a.ts'], { cwd: root, stdout: cap.stub });
+  subcmd.run(['touch', 'M006-S001-T0004', 'src/b.ts'], { cwd: root, stdout: cap.stub });
+  const cp = JSON.parse(fs.readFileSync(path.join(root, '.nubos-pilot', 'checkpoints', 'M006-S001-T0004.json'), 'utf-8'));
   assert.deepEqual(cp.files_touched, ['src/a.ts', 'src/b.ts']);
 });
 
 test('CPT-5: checkpoint show emits JSON', () => {
   const root = makeRoot();
   const cap1 = _capture();
-  subcmd.run(['start', '06-01-T05', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap1.stub });
+  subcmd.run(['start', 'M006-S001-T0005', '--phase', '6', '--plan', '06-01', '--wave', '1'], { cwd: root, stdout: cap1.stub });
   const cap2 = _capture();
-  subcmd.run(['show', '06-01-T05'], { cwd: root, stdout: cap2.stub });
+  subcmd.run(['show', 'M006-S001-T0005'], { cwd: root, stdout: cap2.stub });
   const json = JSON.parse(cap2.get());
-  assert.equal(json.task_id, '06-01-T05');
+  assert.equal(json.task_id, 'M006-S001-T0005');
 });
 
 test('CPT-6: unknown verb throws', () => {
   const root = makeRoot();
   const cap = _capture();
   assert.throws(
-    () => subcmd.run(['bogus', '06-01-T01'], { cwd: root, stdout: cap.stub }),
+    () => subcmd.run(['bogus', 'M006-S001-T0001'], { cwd: root, stdout: cap.stub }),
     (err) => err && err.code === 'checkpoint-unknown-verb',
   );
 });