nubos-pilot 0.6.1 → 0.6.2

package/agents/np-sc-extractor.md

@@ -0,0 +1,85 @@
+---
+name: np-sc-extractor
+description: Derives observable Success Criteria (SC-N) for a milestone from its goal, requirements, and captured decisions; persists them to roadmap.yaml via update-phase-meta. Spawned by /np:discuss-phase after the interview, before plan-phase.
+tier: haiku
+tools: Read, Bash, Grep, Glob
+color: "#10B981"
+---
+
+<role>
+You are the nubos-pilot Success-Criteria extractor. Your sole job: turn a milestone's vision (goal + requirements + interview decisions) into a short, observable, testable list of Success Criteria — and persist that list to `roadmap.yaml` via the `update-phase-meta` CLI helper.
+
+You do NOT interview the user. You do NOT edit code. You do NOT re-open scope debates. You read the context that `/np:discuss-phase` has just produced and translate it into SCs.
+</role>
+
+<input>
+- `milestone`, `milestone_id`, `milestone_name`, `milestone_dir`
+- `goal`: the milestone's goal string (from `roadmap.yaml`)
+- `requirements`: array of REQ-IDs in scope (from `roadmap.yaml`)
+- `context_path`: path to `<milestone_dir>/<milestone_id>-CONTEXT.md` (just written by the workflow)
+- `requirements_path`: path to `.nubos-pilot/REQUIREMENTS.md` (or `.planning/REQUIREMENTS.md`)
+- `existing_success_criteria`: current `success_criteria[]` from roadmap.yaml (may be empty)
+</input>
+
+<required_reading>
+1. `context_path` — the freshly captured decisions (WHAT the milestone locks in).
+2. `requirements_path` — filtered to the REQ-IDs in input; extract the observable behavior hints.
+3. Existing `M<NNN>-ROADMAP.md` and `M<NNN>-META.json` under `milestone_dir` IF they exist — they may already carry SCs a human drafted; prefer those verbatim over re-inventing.
+</required_reading>
+
+<extraction_rules>
+1. **Derive, don't invent.** Every SC must trace back to a concrete line in CONTEXT.md, REQUIREMENTS.md, or existing ROADMAP.md. If there is no basis, emit fewer SCs — do not invent requirements.
+2. **Observable.** Each SC must be checkable by a test or demo: "X happens when Y" / "metric Z stays under T". Avoid opinions ("code is clean", "UX feels fast").
+3. **Numbered.** IDs are strictly `SC-1`, `SC-2`, … (no gaps). Start at `SC-1` even if a different ID scheme appears in prose.
+4. **Reuse existing.** If `existing_success_criteria` is non-empty AND the content still matches the goal+requirements, return it unchanged (1:1). Only add/remove when the context materially disagrees.
+5. **Prefer sidecar source of truth.** If `M<NNN>-ROADMAP.md` or `M<NNN>-META.json` list SCs and `roadmap.yaml` does not, migrate them verbatim (fix only ID numbering).
+6. **Between 3 and 15 SCs.** Fewer than 3 = probably missing something; more than 15 = too granular (split the milestone in that case — but do not split here; instead emit a warning in your final message).
+</extraction_rules>
+
+<execution_flow>
+
+<step name="load">
+Read all `required_reading` files. Missing files: log and continue (e.g. META.json may not exist yet).
+</step>
+
+<step name="draft">
+Produce the SC list as a JSON array of `{id, text}` objects. `id` MUST match `/^SC-\d+$/`. `text` is one sentence, observable, testable.
+</step>
+
+<step name="persist">
+Call the helper:
+
+```bash
+echo '<JSON PATCH>' | node .nubos-pilot/bin/np-tools.cjs update-phase-meta <MILESTONE_NUMBER> --stdin
+```
+
+Where `<JSON PATCH>` is `{"success_criteria": [...your array...]}`. On success the helper returns `{"ok": true, ...}` — any other output is a failure and must be reported.
+</step>
+
+<step name="report">
+Emit a short summary to stdout:
+
+```
+np-sc-extractor: <N> success criteria persisted to roadmap.yaml (M<NNN>)
+  SC-1: <short text>
+  SC-2: <short text>
+  ...
+```
+
+If you had to WARN (>15 SCs, conflicting sources, no basis found), prepend `WARN:` lines before the summary. Never fail silently.
+</step>
+
+</execution_flow>
+
+<scope_guardrail>
+**Do:**
+- Read CONTEXT.md, REQUIREMENTS.md, existing sidecars.
+- Persist via `update-phase-meta --stdin`.
+- Reuse existing SCs verbatim when they still fit.
+
+**Don't:**
+- Ask the user questions (you are non-interactive).
+- Edit CONTEXT.md, ROADMAP.md, META.json, or any implementation file.
+- Invent SCs that have no basis in inputs.
+- Emit more than 15 SCs.
+</scope_guardrail>

package/bin/install.js

@@ -536,6 +536,21 @@ async function _runInstallLocked(ctx) {
     console.error(yellow + '  [codex] repair skipped: ' + (err && err.message) + reset);
   }
   manifestMod.writeManifest(payloadDir, newManifest);
+  if (selectedRuntimesEarly.includes('claude')) {
+    try {
+      const claudeHooks = require('../lib/install/claude-hooks.cjs');
+      const res = claudeHooks.installClaudeHooks({
+        projectRoot, scope: resolvedScope, which: 'both', force: false,
+      });
+      console.error(dim + '  [claude-hooks] statusline: ' + res.results.statusline.action
+        + ', ctx-monitor: ' + res.results.ctxMonitor.action + reset);
+      if (res.results.statusline.action === 'skipped-existing') {
+        console.error(yellow + '  [claude-hooks] foreign statusLine preserved — re-run `install-hooks --force` to overwrite' + reset);
+      }
+    } catch (err) {
+      console.error(yellow + '  [claude-hooks] skipped: ' + (err && err.message) + reset);
+    }
+  }
   console.error(green + '✓ Installation abgeschlossen' + reset);
   return { mode, dryRun: false, written: Object.keys(newManifest.files).length,
     backedUp: backupLog.length, deleted: diff.stale.length };

package/bin/np-tools/_commands.cjs

@@ -50,6 +50,7 @@ const COMMANDS = [
   { name: 'stats',           category: 'Utility', description: 'Aggregated project stats (roadmap + STATE + git + metrics JSON shape)' },
   { name: 'detect-runtime',  category: 'Utility', description: 'Print detected runtime id (claude, codex, gemini, …) — reads config.json ∨ env ∨ default' },
   { name: 'template-path',   category: 'Utility', description: 'Print absolute path to a package-shipped template by name (e.g. VALIDATION, milestone/CONTEXT)' },
+  { name: 'update-phase-meta', category: 'Planning', description: 'Update roadmap.yaml phase fields (name/goal/requirements/success_criteria) via JSON patch' },
 
   { 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' },

package/bin/np-tools/update-phase-meta.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+const { NubosPilotError } = require('../../lib/core.cjs');
+const roadmap = require('../../lib/roadmap.cjs');
+
+function _parseArgs(args) {
+  const out = { milestone: null, json: null, stdin: false };
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (!a.startsWith('-')) {
+      if (out.milestone == null) { out.milestone = a; continue; }
+      continue;
+    }
+    if (a === '--json' || a === '-j') { out.json = args[++i] || null; continue; }
+    if (a === '--stdin') { out.stdin = true; continue; }
+  }
+  return out;
+}
+
+function _readStdinSync() {
+  const fs = require('node:fs');
+  try {
+    return fs.readFileSync(0, 'utf-8');
+  } catch {
+    return '';
+  }
+}
+
+function _validateMilestone(raw) {
+  if (raw == null) {
+    throw new NubosPilotError('update-phase-meta-missing-milestone',
+      'milestone number required (e.g. M002 or 2)', {});
+  }
+  const s = String(raw).trim();
+  const m = s.match(/^M?(\d+(?:\.\d+)?)$/i);
+  if (!m) {
+    throw new NubosPilotError('update-phase-meta-invalid-milestone',
+      'milestone must be M<NNN> or <number>', { milestone: raw });
+  }
+  return m[1];
+}
+
+function run(args, opts) {
+  const o = opts || {};
+  const cwd = o.cwd || process.cwd();
+  const stdout = o.stdout || process.stdout;
+  const readStdin = typeof o.readStdin === 'function' ? o.readStdin : _readStdinSync;
+  const stdinIsTty = o.stdinIsTty != null ? !!o.stdinIsTty : !!process.stdin.isTTY;
+  const parsed = _parseArgs(args || []);
+  const mNum = _validateMilestone(parsed.milestone);
+
+  let rawJson = parsed.json;
+  if (!rawJson && parsed.stdin) rawJson = readStdin();
+  if (!rawJson && !stdinIsTty) rawJson = readStdin();
+  if (!rawJson) {
+    throw new NubosPilotError('update-phase-meta-missing-json',
+      'JSON patch required (via --json, --stdin, or piped stdin)', {});
+  }
+
+  let patch;
+  try {
+    patch = JSON.parse(rawJson);
+  } catch (err) {
+    throw new NubosPilotError('update-phase-meta-invalid-json',
+      'invalid JSON patch: ' + err.message, { cause: err.message });
+  }
+  if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+    throw new NubosPilotError('update-phase-meta-invalid-json',
+      'JSON patch must be an object', {});
+  }
+
+  const result = roadmap.updatePhase(mNum, patch, cwd);
+  stdout.write(JSON.stringify({ ok: true, milestone: mNum, result }, null, 2) + '\n');
+  return 0;
+}
+
+module.exports = { run, _parseArgs, _validateMilestone };

package/bin/np-tools/update-phase-meta.test.cjs

@@ -0,0 +1,132 @@
+'use strict';
+
+const { test } = 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 mod = require('./update-phase-meta.cjs');
+const roadmap = require('../../lib/roadmap.cjs');
+
+const SEED = [
+  'schema_version: 1',
+  'milestones:',
+  '  - id: M001',
+  '    number: 1',
+  '    name: First',
+  '    goal: hello',
+  '    status: pending',
+  '    requirements: []',
+  '    success_criteria: []',
+  '    slices: []',
+  '',
+].join('\n');
+
+function mkSandbox() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'np-upm-'));
+  fs.mkdirSync(path.join(dir, '.nubos-pilot'));
+  fs.writeFileSync(path.join(dir, '.nubos-pilot', 'roadmap.yaml'), SEED);
+  return dir;
+}
+
+function captureStdout() {
+  const chunks = [];
+  return {
+    stream: { write: (c) => { chunks.push(c); } },
+    read: () => chunks.join(''),
+  };
+}
+
+test('UPM-1: _validateMilestone accepts M002, 2, and 2.1', () => {
+  assert.equal(mod._validateMilestone('M002'), '002');
+  assert.equal(mod._validateMilestone('2'), '2');
+  assert.equal(mod._validateMilestone('2.1'), '2.1');
+});
+
+test('UPM-2: _validateMilestone rejects garbage', () => {
+  assert.throws(
+    () => mod._validateMilestone('bogus'),
+    (err) => err.code === 'update-phase-meta-invalid-milestone',
+  );
+});
+
+test('UPM-3: run() writes SCs via --json flag', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    const rc = mod.run(['1', '--json', JSON.stringify({
+      success_criteria: [{ id: 'SC-1', text: 'log in works' }],
+    })], { cwd: dir, stdout: cap.stream, stdinIsTty: true });
+    assert.equal(rc, 0);
+    const p = roadmap.getPhase(1, dir);
+    assert.equal(p.success_criteria.length, 1);
+    const out = JSON.parse(cap.read());
+    assert.equal(out.ok, true);
+    assert.deepEqual(out.result.fields_updated, ['success_criteria']);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('UPM-4: invalid JSON via --json throws update-phase-meta-invalid-json', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    assert.throws(
+      () => mod.run(['1', '--json', '{broken'], { cwd: dir, stdout: cap.stream, stdinIsTty: true }),
+      (err) => err.code === 'update-phase-meta-invalid-json',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('UPM-5: JSON-array (not object) patch rejected', () => {
+  const dir = mkSandbox();
+  try {
+    assert.throws(
+      () => mod.run(['1', '--json', '[]'], { cwd: dir, stdout: captureStdout().stream, stdinIsTty: true }),
+      (err) => err.code === 'update-phase-meta-invalid-json',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('UPM-6: missing JSON throws update-phase-meta-missing-json', () => {
+  const dir = mkSandbox();
+  try {
+    assert.throws(
+      () => mod.run(['1'], { cwd: dir, stdout: captureStdout().stream, stdinIsTty: true }),
+      (err) => err.code === 'update-phase-meta-missing-json',
+    );
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+test('UPM-7: missing milestone arg throws update-phase-meta-missing-milestone', () => {
+  assert.throws(
+    () => mod.run(['--json', '{"goal":"x"}'], { cwd: process.cwd(), stdout: captureStdout().stream }),
+    (err) => err.code === 'update-phase-meta-missing-milestone',
+  );
+});
+
+test('UPM-8: run() reads from piped stdin when stdinIsTty false', () => {
+  const dir = mkSandbox();
+  try {
+    const cap = captureStdout();
+    const rc = mod.run(['1'], {
+      cwd: dir,
+      stdout: cap.stream,
+      stdinIsTty: false,
+      readStdin: () => JSON.stringify({ requirements: ['REQ-42'] }),
+    });
+    assert.equal(rc, 0);
+    const p = roadmap.getPhase(1, dir);
+    assert.deepEqual(p.requirements, ['REQ-42']);
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});

package/lib/agents.test.cjs

@@ -225,6 +225,7 @@ const NP_AGENTS = [
   { file: 'np-researcher', expected_tier: 'sonnet' },
   { file: 'np-codebase-documenter', expected_tier: 'sonnet' },
   { file: 'np-nyquist-auditor', expected_tier: 'haiku' },
+  { file: 'np-sc-extractor', expected_tier: 'haiku' },
 ];
 
 for (let i = 0; i < NP_AGENTS.length; i += 1) {

package/lib/roadmap.cjs

@@ -413,6 +413,112 @@ function addBacklogEntry(description, opts) {
   });
 }
 
+function _normalizeScList(scs) {
+  if (!Array.isArray(scs)) {
+    throw new NubosPilotError(
+      'roadmap-invalid-success-criteria',
+      'success_criteria must be an array',
+      { received: typeof scs },
+    );
+  }
+  const out = [];
+  for (let i = 0; i < scs.length; i++) {
+    const sc = scs[i];
+    if (typeof sc === 'string') {
+      const s = sc.trim();
+      if (!s) {
+        throw new NubosPilotError('roadmap-invalid-success-criteria',
+          'success_criteria[' + i + '] must be non-empty', { index: i });
+      }
+      out.push(s);
+      continue;
+    }
+    if (sc && typeof sc === 'object') {
+      const id = typeof sc.id === 'string' ? sc.id.trim() : '';
+      const text = typeof sc.text === 'string' ? sc.text.trim() : '';
+      if (!id || !/^SC-\d+$/.test(id)) {
+        throw new NubosPilotError('roadmap-invalid-success-criteria',
+          'success_criteria[' + i + '].id must match /^SC-\\d+$/', { index: i, id: sc.id });
+      }
+      if (!text) {
+        throw new NubosPilotError('roadmap-invalid-success-criteria',
+          'success_criteria[' + i + '].text must be non-empty', { index: i });
+      }
+      out.push({ id, text });
+      continue;
+    }
+    throw new NubosPilotError('roadmap-invalid-success-criteria',
+      'success_criteria[' + i + '] must be string or {id,text}', { index: i });
+  }
+  return out;
+}
+
+function _normalizeReqList(reqs) {
+  if (!Array.isArray(reqs)) {
+    throw new NubosPilotError('roadmap-invalid-requirements',
+      'requirements must be an array', { received: typeof reqs });
+  }
+  return reqs.map((r, i) => {
+    if (typeof r !== 'string' || !r.trim()) {
+      throw new NubosPilotError('roadmap-invalid-requirements',
+        'requirements[' + i + '] must be non-empty string', { index: i });
+    }
+    return r.trim();
+  });
+}
+
+function updatePhase(n, patch, cwd = process.cwd()) {
+  const want = String(n);
+  const p = patch || {};
+  const allowed = ['name', 'goal', 'requirements', 'success_criteria'];
+  const unknown = Object.keys(p).filter((k) => !allowed.includes(k));
+  if (unknown.length) {
+    throw new NubosPilotError('roadmap-invalid-patch',
+      'updatePhase: unknown keys: ' + unknown.join(', '),
+      { unknown, allowed });
+  }
+  const prepared = {};
+  if ('name' in p) {
+    if (typeof p.name !== 'string' || !p.name.trim()) {
+      throw new NubosPilotError('roadmap-invalid-patch',
+        'name must be non-empty string', {});
+    }
+    prepared.name = p.name.trim();
+  }
+  if ('goal' in p) {
+    if (typeof p.goal !== 'string') {
+      throw new NubosPilotError('roadmap-invalid-patch',
+        'goal must be string', {});
+    }
+    prepared.goal = p.goal;
+  }
+  if ('requirements' in p) prepared.requirements = _normalizeReqList(p.requirements);
+  if ('success_criteria' in p) prepared.success_criteria = _normalizeScList(p.success_criteria);
+
+  return _mutate(cwd, (doc) => {
+    let target = null;
+    for (const ms of doc.milestones) {
+      if (!ms) continue;
+      if (Array.isArray(ms.slices) && String(ms.number) === want) { target = ms; break; }
+      if (Array.isArray(ms.phases)) {
+        const hit = ms.phases.find((ph) => ph && String(ph.number) === want);
+        if (hit) { target = hit; break; }
+      }
+    }
+    if (!target) {
+      throw new NubosPilotError('phase-not-found',
+        'Phase ' + want + ' not found in roadmap.yaml',
+        { requested: want });
+    }
+    const updated = [];
+    for (const k of Object.keys(prepared)) {
+      target[k] = prepared[k];
+      updated.push(k);
+    }
+    return { number: want, name: target.name || '', fields_updated: updated };
+  });
+}
+
 function collapseMilestone(milestoneId, opts) {
   const cwd = (opts && opts.cwd) || process.cwd();
   if (typeof milestoneId !== 'string' || !/^[vV0-9._-]+$/.test(milestoneId)) {
@@ -446,6 +552,7 @@ module.exports = {
   addMilestone,
   addPhase,
   insertPhaseAfter,
+  updatePhase,
   addBacklogEntry,
   collapseMilestone,
 };

package/lib/roadmap.test.cjs

@@ -369,3 +369,87 @@ test('ROAD-COLLAPSE-3: unknown milestoneId throws roadmap-milestone-not-found',
     (err) => err.name === 'NubosPilotError' && err.code === 'roadmap-milestone-not-found',
   );
 });
+
+const WRITE_SEED_TOP_LEVEL = [
+  'schema_version: 1',
+  'milestones:',
+  '  - id: M001',
+  '    number: 1',
+  '    name: Auth',
+  '    goal: log users in',
+  '    status: pending',
+  '    requirements: []',
+  '    success_criteria: []',
+  '    slices: []',
+  '  - id: M002',
+  '    number: 2',
+  '    name: Voice',
+  '    goal: voice pipeline',
+  '    status: pending',
+  '    requirements: []',
+  '    success_criteria: []',
+  '    slices: []',
+  '',
+].join('\n');
+
+test('RM-UPDATE-1: updatePhase writes success_criteria to nested milestone.phases[]', () => {
+  const sandbox = makeSandbox(WRITE_SEED);
+  const res = roadmap.updatePhase(1, {
+    success_criteria: [{ id: 'SC-1', text: 'scaffold exists' }, { id: 'SC-2', text: 'ADRs committed' }],
+  }, sandbox);
+  assert.deepEqual(res.fields_updated, ['success_criteria']);
+  const p = roadmap.getPhase(1, sandbox);
+  assert.equal(p.success_criteria.length, 2);
+  assert.equal(p.success_criteria[0].id, 'SC-1');
+});
+
+test('RM-UPDATE-2: updatePhase writes to top-level milestone (new-style roadmap)', () => {
+  const sandbox = makeSandbox(WRITE_SEED_TOP_LEVEL);
+  roadmap.updatePhase(2, {
+    success_criteria: ['Speaker ID works', 'Latency < 2s'],
+    requirements: ['REQ-01'],
+  }, sandbox);
+  const p = roadmap.getPhase(2, sandbox);
+  assert.deepEqual(p.success_criteria, ['Speaker ID works', 'Latency < 2s']);
+  assert.deepEqual(p.requirements, ['REQ-01']);
+});
+
+test('RM-UPDATE-3: unknown phase number throws phase-not-found', () => {
+  const sandbox = makeSandbox(WRITE_SEED);
+  assert.throws(
+    () => roadmap.updatePhase(99, { success_criteria: ['x'] }, sandbox),
+    (err) => err.name === 'NubosPilotError' && err.code === 'phase-not-found',
+  );
+});
+
+test('RM-UPDATE-4: invalid SC id format throws roadmap-invalid-success-criteria', () => {
+  const sandbox = makeSandbox(WRITE_SEED);
+  assert.throws(
+    () => roadmap.updatePhase(1, { success_criteria: [{ id: 'BAD', text: 'x' }] }, sandbox),
+    (err) => err.name === 'NubosPilotError' && err.code === 'roadmap-invalid-success-criteria',
+  );
+});
+
+test('RM-UPDATE-5: unknown patch key throws roadmap-invalid-patch', () => {
+  const sandbox = makeSandbox(WRITE_SEED);
+  assert.throws(
+    () => roadmap.updatePhase(1, { status: 'done' }, sandbox),
+    (err) => err.name === 'NubosPilotError' && err.code === 'roadmap-invalid-patch',
+  );
+});
+
+test('RM-UPDATE-6: partial patch — only updates given fields', () => {
+  const sandbox = makeSandbox(WRITE_SEED);
+  roadmap.updatePhase(1, { goal: 'new goal text' }, sandbox);
+  const p = roadmap.getPhase(1, sandbox);
+  assert.equal(p.goal, 'new goal text');
+  assert.equal(p.success_criteria.length, 0, 'SCs untouched');
+  assert.equal(p.name, 'Foundation', 'name untouched');
+});
+
+test('RM-UPDATE-7: re-renders ROADMAP.md alongside roadmap.yaml', () => {
+  const sandbox = makeSandbox(WRITE_SEED);
+  roadmap.updatePhase(1, { success_criteria: ['check 1'] }, sandbox);
+  const md = fs.readFileSync(path.join(sandbox, '.nubos-pilot', 'ROADMAP.md'), 'utf-8');
+  assert.ok(md.includes('check 1'), 'ROADMAP.md re-rendered with new SC');
+});

package/np-tools.cjs

@@ -50,6 +50,7 @@ const topLevelCommands = {
   'text-mode':      require('./bin/np-tools/text-mode.cjs'),
   'detect-runtime': require('./bin/np-tools/detect-runtime.cjs'),
   'template-path':  require('./bin/np-tools/template-path.cjs'),
+  'update-phase-meta': require('./bin/np-tools/update-phase-meta.cjs'),
 };
 
 const THRESHOLD = 16 * 1024;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nubos-pilot",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "AI-driven planning and execution tool for code projects",
   "homepage": "https://github.com/Nubos-AI/nubos-pilot",
   "repository": {

package/templates/claude/payload/hooks/np-statusline.js

@@ -76,6 +76,36 @@ function renderBar(used, limit) {
   return color + bar + '\x1b[0m ' + pct + '%' + suffix;
 }
 
+function terminalWidth() {
+  const envCols = Number(process.env.COLUMNS);
+  if (Number.isFinite(envCols) && envCols > 0) return envCols;
+  if (process.stdout && process.stdout.columns) return process.stdout.columns;
+  try {
+    const { execSync } = require('node:child_process');
+    const out = execSync('tput cols', { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+    const n = Number(out);
+    if (Number.isFinite(n) && n > 0) return n;
+  } catch {}
+  return 120;
+}
+
+function visibleLen(s) {
+  const stripped = s.replace(/\x1b\[[0-9;]*m/g, '');
+  let w = 0;
+  for (const ch of stripped) {
+    const cp = ch.codePointAt(0);
+    if (cp > 0xFFFF) w += 2;
+    else w += 1;
+  }
+  return w;
+}
+
+function centerLine(line) {
+  const width = terminalWidth();
+  const pad = Math.max(0, Math.floor((width - visibleLen(line)) / 2));
+  return ' '.repeat(pad) + line;
+}
+
 function writeBridge(payload, usage, limit) {
   const sid = payload && payload.session_id;
   if (!sid) return;
@@ -97,14 +127,14 @@ function writeBridge(payload, usage, limit) {
   const usage = lastUsage(payload && payload.transcript_path);
   const prefix = '\x1b[38;5;33mnubos-pilot\x1b[0m';
   if (!usage) {
-    process.stdout.write(prefix);
+    process.stdout.write(centerLine(prefix));
     return;
   }
   writeBridge(payload, usage, limit);
   const bar = renderBar(usage.total, limit);
   const modelName = (payload && payload.model && payload.model.display_name) || '';
   const tail = modelName ? '  \x1b[2m' + modelName + '\x1b[0m' : '';
-  process.stdout.write(prefix + '  ctx ' + bar + tail);
+  process.stdout.write(centerLine(prefix + '  ctx ' + bar + tail));
 })().catch(() => {
   process.stdout.write('\x1b[38;5;33mnubos-pilot\x1b[0m');
 });

package/workflows/discuss-phase.md

@@ -370,18 +370,66 @@ If the template lacks a key, `render()` throws
 `NubosPilotError('template-missing-key', …)` — the workflow must not swallow
 that error. Fix the template or the accumulator, don't mask the failure.
 
+### Step 6b: Extract + persist Success Criteria (np-sc-extractor)
+
+CONTEXT.md now captures the decisions. Success Criteria in `roadmap.yaml` are still empty for this milestone — downstream `/np:verify-work` reads them from there, so we must persist them now. Spawn the SC-extractor (haiku) to derive observable SCs from goal + requirements + CONTEXT.md + any pre-existing `M<NNN>-ROADMAP.md` / `M<NNN>-META.json` sidecars, and call `update-phase-meta` to write them.
+
+```bash
+SC_START=$(node .nubos-pilot/bin/np-tools.cjs metrics start-timestamp)
+SC_MODEL=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-sc-extractor --profile balanced)
+
+REQS_PATH=".nubos-pilot/REQUIREMENTS.md"
+[[ -f "$REQS_PATH" ]] || REQS_PATH=".planning/REQUIREMENTS.md"
+
+EXISTING_SC_JSON=$(node -e '
+  const r = require("./lib/roadmap.cjs");
+  const p = r.getPhase(process.argv[1]);
+  process.stdout.write(JSON.stringify(p.success_criteria || []));
+' "$PHASE")
+
+# Spawn agent=np-sc-extractor tier=haiku model=$SC_MODEL milestone=$PHASE
+#   input: milestone=$PHASE, milestone_id=$MILESTONE_ID, milestone_dir=$MILESTONE_DIR,
+#          context_path=$CONTEXT_PATH, requirements_path=$REQS_PATH,
+#          existing_success_criteria=$EXISTING_SC_JSON
+#   output: calls `np-tools.cjs update-phase-meta $PHASE --stdin` with
+#           {"success_criteria": [{id:"SC-N", text:"..."}, ...]} and prints summary.
+
+SC_END=$(node .nubos-pilot/bin/np-tools.cjs metrics end-timestamp)
+node .nubos-pilot/bin/np-tools.cjs metrics record \
+  --agent np-sc-extractor --tier haiku --resolved-model "$SC_MODEL" \
+  --phase "$PHASE" --plan "${MILESTONE_ID}-sc" --task "${MILESTONE_ID}-sc-extract" \
+  --started "$SC_START" --ended "$SC_END" \
+  --tokens-in "${TOKENS_IN:-0}" --tokens-out "${TOKENS_OUT:-0}" \
+  --retry-count 0 --status ok --runtime "$RUNTIME"
+```
+
+After the spawn, sanity-check that `success_criteria` is non-empty:
+
+```bash
+SC_COUNT=$(node -e '
+  const r = require("./lib/roadmap.cjs");
+  const p = r.getPhase(process.argv[1]);
+  process.stdout.write(String((p.success_criteria || []).length));
+' "$PHASE")
+if [[ "$SC_COUNT" -lt 1 ]]; then
+  echo "ERROR: np-sc-extractor produced no success_criteria for $MILESTONE_ID — refusing to continue." >&2
+  exit 1
+fi
+```
+
+A failure here is loud by design: `/np:verify-work` and `/np:validate-phase` depend on a populated `success_criteria[]`. If the extractor cannot derive any, fix the goal/requirements/CONTEXT.md inputs before retrying.
+
 ### Step 7: Commit respecting config.commit_docs
 
 ```bash
 COMMIT_DOCS=$(node .nubos-pilot/bin/np-tools.cjs config-get workflow.commit_docs 2>/dev/null || echo "true")
 if [[ "$COMMIT_DOCS" == "true" ]]; then
-  git add "$CONTEXT_PATH"
-  git commit -m "docs($MILESTONE_ID): capture milestone context"
+  git add "$CONTEXT_PATH" .nubos-pilot/roadmap.yaml .nubos-pilot/ROADMAP.md
+  git commit -m "docs($MILESTONE_ID): capture milestone context + success criteria"
 fi
 ```
 
-If `workflow.commit_docs` is false, leave the file uncommitted — the user is
-opting into manual commit gating.
+If `workflow.commit_docs` is false, leave both CONTEXT.md and the roadmap edits uncommitted — the user is opting into manual commit gating.
 
 ### Step 8: Confirm and next steps
 

package/workflows/plan-phase.md

@@ -118,6 +118,29 @@ case "$CHOICE" in
 esac
 ```
 
+### Gate 1b — Empty success_criteria
+
+If `success_criteria.length == 0`:
+
+```bash
+CHOICE=$(node .nubos-pilot/bin/np-tools.cjs askuser --json '{
+  "type": "select",
+  "header": "No SCs in roadmap.yaml",
+  "question": "Milestone has no success_criteria in roadmap.yaml. Downstream /np:verify-work will produce an empty VERIFICATION.md. How to proceed?",
+  "options": [
+    {"label": "Run /np:discuss-phase first", "description": "Recommended — np-sc-extractor derives SCs from CONTEXT.md + goal + requirements and writes them to roadmap.yaml."},
+    {"label": "Continue anyway",             "description": "Plan the milestone without SCs; you must back-fill them before /np:verify-work."},
+    {"label": "Abort",                       "description": "Exit without changes."}
+  ]
+}')
+case "$CHOICE" in
+  "Run /np:discuss-phase"*) echo "Run: /np:discuss-phase $PHASE"; exit 0 ;;
+  "Abort")                  exit 0 ;;
+esac
+```
+
+The planner will still emit a plan without SCs, but you are consciously opting into a known-broken verify-work path. The safer default is always to re-run `/np:discuss-phase` — Step 6b there spawns `np-sc-extractor` which populates `roadmap.yaml` directly.
+
 ### Gate 2 — Missing slice RESEARCH.md
 
 Research is per-slice  (`slices/S<NNN>/S<NNN>-RESEARCH.md`). The planner can plan without research, but if the roadmap config requires it, ask. The `--research` flag auto-dispatches `/np:research-phase` before re-entering.