nubos-pilot 0.5.4 → 0.5.6

package/agents/np-plan-checker.md

@@ -89,6 +89,7 @@ Run each dimension below; for every failure, emit one finding using the matching
 - Every `<task>` MUST have `id="M<NNN>-S<NNN>-T<NNNN>"` matching the enclosing slice (milestone and slice numbers must agree with the file path). Mismatch → `broken-dependency`.
 - Missing `depends_on`, `wave`, or `tier` attribute on the opening `<task>` tag → the scaffolder will drop it. Emit `fake-promotion-trigger` with a message telling the planner which task is missing which attribute.
 - `wave="<N>"` should equal the slice's S-number (e.g. S002 → wave="2"). Mismatch is a soft finding (`fake-promotion-trigger`).
+- **Task numbering restarts per slice.** Inside each `S<NNN>-PLAN.md`, the task IDs MUST start at `T0001` and increment contiguously (`T0001, T0002, …`). Counter that continues across slices (e.g. `S002` starting at `T0002` because `S001` used `T0001`) → `broken-dependency` with `target: S<NNN>-PLAN.md task <n>` and a message naming the expected vs. observed T-number. Gaps (`T0001, T0003`) are the same finding.
 
 ### Dimension 7: Nyquist Coverage Annotation
 

package/agents/np-planner.md

@@ -216,20 +216,22 @@ If any check fails, fix before returning. Plan-checker will catch what you miss,
 
 Inside each `S<NNN>-PLAN.md`, every `<task>` tag MUST have these four attributes on the opening tag:
 
-- `id="M<NNN>-S<NNN>-T<NNNN>"` — full-id, e.g. `id="M001-S001-T0001"`. Milestone 3 digits, slice 3 digits, task **4 digits**.
+- `id="M<NNN>-S<NNN>-T<NNNN>"` — full-id, e.g. `id="M001-S001-T0001"`. Milestone 3 digits, slice 3 digits, task **4 digits**. **Task numbering restarts at `T0001` inside every slice.** The first task of `S002` is `M<NNN>-S002-T0001`, the first task of `S003` is `M<NNN>-S003-T0001`. Tasks within a slice run `T0001, T0002, T0003, …` without gaps. Never continue the counter across slices (`S001-T0001, S002-T0002` is wrong — it must be `S001-T0001, S002-T0001`).
 - `depends_on="<id>[,<id>...]"` — comma-separated predecessor task full-ids, or empty string `""`. Must only reference tasks in **earlier slices** (cross-slice forward deps) or be empty (intra-slice tasks are implicitly parallel, never serial).
 - `wave="<N>"` — integer equal to the slice number. For S001 use `wave="1"`, for S002 use `wave="2"`, etc.
 - `tier="<haiku|sonnet|opus>"` — executor tier, picks the model via resolve-model.
 
 The scaffolder (`_extractTasksFromSlicePlan` in `bin/np-tools/plan-milestone.cjs`) reads ONLY these opening-tag attributes. Without them, zero task files are scaffolded and execute-phase has nothing to dispatch.
 
+Inside the body, every `<task>` MUST also contain a `<files_modified>` block listing the files the executor will touch (one per line or comma-separated). An empty or missing `<files_modified>` block produces `files_modified: []` in task frontmatter, which causes `commit-task` to fail (`commit-task-no-files`) unless the executor reported touched files via `checkpoint touch` as a runtime fallback. Plans MUST declare intent up-front; relying on the checkpoint fallback is a last-resort safety net.
+
 Correct example for `slices/S001/S001-PLAN.md`:
 
 ```
 <tasks>
 <task id="M001-S001-T0001" depends_on="" wave="1" tier="sonnet">
   <name>Seed login form</name>
-  <files>src/auth/LoginForm.tsx</files>
+  <files_modified>src/auth/LoginForm.tsx</files_modified>
   <read_first>
     - src/auth/AuthProvider.tsx
   </read_first>
@@ -257,7 +259,16 @@ Create `LoginForm.tsx` with email + password inputs. Wire it to the
 </tasks>
 ```
 
-Note both tasks have `depends_on=""` — they're in the same slice and run in parallel. If `T0002` truly needs `T0001` first, move `T0002` into a new slice `S002` and write `depends_on="M001-S001-T0001" wave="2"`.
+Note both tasks have `depends_on=""` — they're in the same slice and run in parallel. If `T0002` truly needs `T0001` first, move `T0002` into a new slice `S002` and renumber it to `T0001` — each slice owns its own task counter:
+
+```
+<task id="M001-S002-T0001" depends_on="M001-S001-T0001" wave="2" tier="sonnet">
+  <name>Use login handler in session flow</name>
+  ...
+</task>
+```
+
+The cross-slice dep `M001-S001-T0001` flows forward (S001 → S002); the new task is `T0001` of S002, not `T0003`.
 </task_format>
 
 <tooling_conventions>

package/bin/install.js

@@ -663,6 +663,12 @@ function _runUninstallLocked(projectRoot) {
 
 async function main() {
   const rawArgs = process.argv.slice(2);
+  if (rawArgs.includes('--version') || rawArgs.includes('-v')) {
+    let version = '0.0.0';
+    try { version = String(require('../package.json').version || '0.0.0'); } catch {}
+    process.stdout.write(version + '\n');
+    return;
+  }
   const { flags, rest } = parseInstallFlags(rawArgs);
   const sub = rest[0];
   const cwd = process.cwd();

package/bin/np-tools/_commands.cjs

@@ -47,6 +47,7 @@ const COMMANDS = [
   { name: 'text-mode',       category: 'Utility', description: 'Print whether text mode is active (config.workflow.text_mode ∨ CLAUDECODE)' },
   { 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: 'detect-runtime',  category: 'Utility', description: 'Print detected runtime id (claude, codex, gemini, …) — reads config.json ∨ env ∨ default' },
 
   { 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/commit-task.cjs

@@ -7,7 +7,7 @@ const { TASK_ID_RE, setTaskStatus } = require('../../lib/tasks.cjs');
 const layout = require('../../lib/layout.cjs');
 const git = require('../../lib/git.cjs');
 const { commitTask, findCommitByTaskId } = git;
-const { deleteCheckpoint } = require('../../lib/checkpoint.cjs');
+const { deleteCheckpoint, readCheckpoint } = require('../../lib/checkpoint.cjs');
 
 function _resolveTaskFile(taskId, cwd) {
   const parsed = layout.parseTaskFullId(taskId);
@@ -70,11 +70,21 @@ function run(args, ctx) {
   const { filePath } = _resolveTaskFile(taskId, cwd);
   const raw = fs.readFileSync(filePath, 'utf-8');
   const { frontmatter, body } = extractFrontmatter(raw);
-  const files = Array.isArray(frontmatter.files_modified) ? frontmatter.files_modified : [];
+  const declared = Array.isArray(frontmatter.files_modified) ? frontmatter.files_modified : [];
+  let files = declared.slice();
+  let filesSource = 'frontmatter';
+  if (files.length === 0) {
+    const cp = readCheckpoint(taskId, cwd);
+    const touched = cp && Array.isArray(cp.files_touched) ? cp.files_touched : [];
+    if (touched.length > 0) {
+      files = touched.slice();
+      filesSource = 'checkpoint';
+    }
+  }
   if (files.length === 0) {
     throw new NubosPilotError(
       'commit-task-no-files',
-      'Task ' + taskId + ' has empty files_modified',
+      'Task ' + taskId + ' has empty files_modified and no files_touched in checkpoint',
       { taskId },
     );
   }
@@ -93,7 +103,7 @@ function run(args, ctx) {
     process.stderr.write('[nubos-pilot warn] setTaskStatus failed for ' + taskId + ': ' + (err && err.message) + '\n');
   }
 
-  const payload = { ok: true, task_id: taskId, sha, files: safeFiles };
+  const payload = { ok: true, task_id: taskId, sha, files: safeFiles, files_source: filesSource };
   stdout.write(JSON.stringify(payload));
   return payload;
 }

package/bin/np-tools/commit-task.test.cjs

@@ -158,3 +158,40 @@ test('CT-5: commit-task unknown task id → task-not-found', () => {
     (err) => err && err.code === 'commit-task-not-found',
   );
 });
+
+test('CT-6: empty files_modified falls back to checkpoint.files_touched', () => {
+  const root = makeRepo();
+  seedPlanAndTask(root, '06-01', 'M006-S001-T0010', []);
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'b.ts'), 'export const b = 2;\n', 'utf-8');
+  const cpPath = path.join(root, '.nubos-pilot', 'checkpoints', 'M006-S001-T0010.json');
+  fs.mkdirSync(path.dirname(cpPath), { recursive: true });
+  fs.writeFileSync(cpPath, JSON.stringify({
+    schema_version: 1,
+    task_id: 'M006-S001-T0010',
+    status: 'pre-commit',
+    files_touched: ['src/b.ts'],
+  }), 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  const cap = _capture();
+  try {
+    subcmd.run(['M006-S001-T0010'], { cwd: root, stdout: cap.stub });
+  } finally {
+    process.chdir(prev);
+  }
+  const payload = JSON.parse(cap.get());
+  assert.equal(payload.ok, true);
+  assert.equal(payload.files_source, 'checkpoint');
+  assert.deepEqual(payload.files, ['src/b.ts']);
+});
+
+test('CT-7: empty files_modified AND no checkpoint → commit-task-no-files', () => {
+  const root = makeRepo();
+  seedPlanAndTask(root, '06-01', 'M006-S001-T0011', []);
+  const cap = _capture();
+  assert.throws(
+    () => subcmd.run(['M006-S001-T0011'], { cwd: root, stdout: cap.stub }),
+    (err) => err && err.code === 'commit-task-no-files',
+  );
+});

package/bin/np-tools/detect-runtime.cjs

@@ -0,0 +1,24 @@
+'use strict';
+
+const { detect } = require('../../lib/runtime/index.cjs');
+
+function run(argv, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const args = Array.isArray(argv) ? argv.slice() : [];
+  const result = detect({ cwd });
+  if (args.includes('--json')) {
+    stdout.write(JSON.stringify(result) + '\n');
+  } else {
+    stdout.write(result.runtime + '\n');
+  }
+  return 0;
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  const code = run(process.argv.slice(2));
+  if (typeof code === 'number' && code !== 0) process.exit(code);
+}

package/bin/np-tools/detect-runtime.test.cjs

@@ -0,0 +1,47 @@
+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 { Writable } = require('node:stream');
+
+const cli = require('./detect-runtime.cjs');
+
+function makeSink() {
+  const chunks = [];
+  const w = new Writable({
+    write(chunk, _enc, cb) { chunks.push(chunk); cb(); },
+  });
+  w.toString = () => Buffer.concat(chunks.map((c) => Buffer.isBuffer(c) ? c : Buffer.from(String(c)))).toString('utf-8');
+  return w;
+}
+
+function makeSandbox(runtime) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-detect-rt-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  if (runtime) {
+    fs.writeFileSync(
+      path.join(root, '.nubos-pilot', 'config.json'),
+      JSON.stringify({ runtime, runtime_source: 'config' }),
+    );
+  }
+  return root;
+}
+
+test('detect-runtime: reads runtime from .nubos-pilot/config.json', () => {
+  const sb = makeSandbox('gemini');
+  const stdout = makeSink();
+  const code = cli.run([], { cwd: sb, stdout });
+  assert.equal(code, 0);
+  assert.equal(stdout.toString().trim(), 'gemini');
+});
+
+test('detect-runtime --json emits {runtime, source}', () => {
+  const sb = makeSandbox('codex');
+  const stdout = makeSink();
+  const code = cli.run(['--json'], { cwd: sb, stdout });
+  assert.equal(code, 0);
+  const parsed = JSON.parse(stdout.toString());
+  assert.equal(parsed.runtime, 'codex');
+  assert.ok(parsed.source);
+});

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

@@ -163,12 +163,65 @@ function _extractTasksFromSlicePlan(planPath) {
   return out;
 }
 
+function _escapeRegex(s) {
+  return String(s).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function _buildMilestoneRemap(mNum, cwd) {
+  const slices = layout.listSlices(mNum, cwd);
+  const remap = new Map();
+  for (const s of slices) {
+    const planPath = layout.slicePlanPath(mNum, s.number, cwd);
+    if (!fs.existsSync(planPath)) continue;
+    const tasks = _extractTasksFromSlicePlan(planPath);
+    tasks.forEach((t, idx) => {
+      const oldId = t.id;
+      if (!oldId) return;
+      const newId = layout.taskFullId(mNum, s.number, idx + 1);
+      if (oldId !== newId) remap.set(oldId, newId);
+    });
+  }
+  return remap;
+}
+
+function _rewriteSlicePlanIds(planPath, remap) {
+  if (remap.size === 0) return false;
+  const raw = fs.readFileSync(planPath, 'utf-8');
+  const keys = [...remap.keys()].sort((a, b) => b.length - a.length);
+  const re = new RegExp('\\b(' + keys.map(_escapeRegex).join('|') + ')\\b', 'g');
+  const next = raw.replace(re, (m) => remap.get(m) || m);
+  if (next === raw) return false;
+  atomicWriteFileSync(planPath, next);
+  return true;
+}
+
+function _normalizeMilestoneTaskIds(mNum, cwd) {
+  const remap = _buildMilestoneRemap(mNum, cwd);
+  if (remap.size === 0) return { changed: false, remap: {} };
+  const slices = layout.listSlices(mNum, cwd);
+  for (const s of slices) {
+    const planPath = layout.slicePlanPath(mNum, s.number, cwd);
+    if (!fs.existsSync(planPath)) continue;
+    _rewriteSlicePlanIds(planPath, remap);
+  }
+  return { changed: true, remap: Object.fromEntries(remap) };
+}
+
 function _extractInnerTag(body, tag) {
   const re = new RegExp('<' + tag + '(?:\\s[^>]*)?>([\\s\\S]*?)</' + tag + '>', 'i');
   const m = body.match(re);
   return m ? m[1].trim() : '';
 }
 
+function _parseFilesList(body) {
+  const raw = _extractInnerTag(body, 'files_modified') || _extractInnerTag(body, 'files');
+  if (!raw) return [];
+  return raw
+    .split(/[,\n]/)
+    .map((s) => s.trim().replace(/^[-*]\s+/, '').trim())
+    .filter(Boolean);
+}
+
 function _filesYaml(files) {
   if (!files.length) return '[]';
   return '\n' + files.map((f) => '  - ' + JSON.stringify(f)).join('\n');
@@ -184,8 +237,7 @@ function _renderTaskPlanMd(task, mNum, sNum) {
   const parsed = fullId.match(/T(\d{4,})$/);
   const taskNum = parsed ? Number(parsed[1]) : 0;
   const name = _extractInnerTag(task.body, 'name') || fullId;
-  const files = _extractInnerTag(task.body, 'files');
-  const filesList = files ? files.split(/[,\n]/).map((s) => s.trim()).filter(Boolean) : [];
+  const filesList = _parseFilesList(task.body);
   const readFirst = _extractInnerTag(task.body, 'read_first');
   const action = _extractInnerTag(task.body, 'action');
   const verify = _extractInnerTag(task.body, 'verify');
@@ -258,6 +310,13 @@ function _scaffoldSliceTasks(mNum, sNum, cwd) {
   if (!fs.existsSync(planPath)) {
     return { scaffolded: [], reason: 'no-slice-plan', slice: layout.sliceFullId(mNum, sNum) };
   }
+  const sliceRemap = new Map();
+  const preTasks = _extractTasksFromSlicePlan(planPath);
+  preTasks.forEach((t, idx) => {
+    const newId = layout.taskFullId(mNum, sNum, idx + 1);
+    if (t.id && t.id !== newId) sliceRemap.set(t.id, newId);
+  });
+  _rewriteSlicePlanIds(planPath, sliceRemap);
   const tasks = _extractTasksFromSlicePlan(planPath);
   if (tasks.length === 0) {
     return { scaffolded: [], reason: 'no-tasks-in-slice-plan', slice: layout.sliceFullId(mNum, sNum) };
@@ -293,12 +352,19 @@ function _scaffoldAllTasks(mNum, cwd) {
   if (slices.length === 0) {
     return { scaffolded: [], reason: 'no-slices', milestone: layout.mId(mNum) };
   }
+  const normalized = _normalizeMilestoneTaskIds(mNum, cwd);
   const per = [];
   for (const s of slices) {
     per.push(_scaffoldSliceTasks(mNum, s.number, cwd));
   }
   const total = per.reduce((acc, p) => acc + (p.task_count || 0), 0);
-  return { scaffolded: per, reason: 'ok', milestone: layout.mId(mNum), total_tasks: total };
+  return {
+    scaffolded: per,
+    reason: 'ok',
+    milestone: layout.mId(mNum),
+    total_tasks: total,
+    normalized_ids: normalized.changed ? normalized.remap : {},
+  };
 }
 
 function _createMilestoneDir(mNum, cwd) {

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

@@ -207,3 +207,149 @@ test('PM-9: unknown verb throws', () => {
     (err) => err && err.code === 'plan-milestone-unknown-verb',
   );
 });
+
+test('PM-10: scaffold-all-tasks renumbers task ids per slice when planner numbered globally', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  const plan1 = [
+    '---', 'slice: "M001-S001"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S001-T0001" wave="1" tier="sonnet" depends_on=""><name>A</name><action>A</action><done>D</done></task>',
+    '<task id="M001-S001-T0002" wave="1" tier="sonnet" depends_on=""><name>B</name><action>A</action><done>D</done></task>',
+    '<task id="M001-S001-T0003" wave="1" tier="sonnet" depends_on=""><name>C</name><action>A</action><done>D</done></task>',
+  ].join('\n');
+  const plan2 = [
+    '---', 'slice: "M001-S002"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S002-T0004" wave="2" tier="sonnet" depends_on="M001-S001-T0003"><name>D</name><action>A</action><done>D</done></task>',
+    '<task id="M001-S002-T0005" wave="2" tier="sonnet" depends_on=""><name>E</name><action>A</action><done>D</done></task>',
+  ].join('\n');
+  const plan3 = [
+    '---', 'slice: "M001-S003"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S003-T0006" wave="3" tier="sonnet" depends_on="M001-S002-T0004"><name>F</name><action>A</action><done>D</done></task>',
+    '<task id="M001-S003-T0007" wave="3" tier="sonnet" depends_on="M001-S002-T0005,M001-S001-T0001"><name>G</name><action>A</action><done>D</done></task>',
+  ].join('\n');
+  seedSliceDir(sandbox, 1, 1, { 'S001-PLAN.md': plan1 });
+  seedSliceDir(sandbox, 1, 2, { 'S002-PLAN.md': plan2 });
+  seedSliceDir(sandbox, 1, 3, { 'S003-PLAN.md': plan3 });
+
+  const cap = _capture();
+  subcmd.run(['scaffold-all-tasks', '1'], { cwd: sandbox, stdout: cap.stub });
+  const out = JSON.parse(cap.get().trim());
+  assert.equal(out.reason, 'ok');
+  assert.equal(out.total_tasks, 7);
+
+  const tasksBase = path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices');
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S001', 'tasks', 'T0001')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S001', 'tasks', 'T0002')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S001', 'tasks', 'T0003')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S002', 'tasks', 'T0001')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S002', 'tasks', 'T0002')));
+  assert.ok(!fs.existsSync(path.join(tasksBase, 'S002', 'tasks', 'T0004')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S003', 'tasks', 'T0001')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'S003', 'tasks', 'T0002')));
+  assert.ok(!fs.existsSync(path.join(tasksBase, 'S003', 'tasks', 'T0006')));
+
+  const s2t1 = fs.readFileSync(path.join(tasksBase, 'S002', 'tasks', 'T0001', 'T0001-PLAN.md'), 'utf-8');
+  assert.match(s2t1, /id: "M001-S002-T0001"/);
+  assert.match(s2t1, /- "M001-S001-T0003"/);
+
+  const s3t1 = fs.readFileSync(path.join(tasksBase, 'S003', 'tasks', 'T0001', 'T0001-PLAN.md'), 'utf-8');
+  assert.match(s3t1, /id: "M001-S003-T0001"/);
+  assert.match(s3t1, /- "M001-S002-T0001"/);
+
+  const s3t2 = fs.readFileSync(path.join(tasksBase, 'S003', 'tasks', 'T0002', 'T0002-PLAN.md'), 'utf-8');
+  assert.match(s3t2, /id: "M001-S003-T0002"/);
+  assert.match(s3t2, /- "M001-S002-T0002"/);
+  assert.match(s3t2, /- "M001-S001-T0001"/);
+
+  const s2PlanRaw = fs.readFileSync(path.join(tasksBase, 'S002', 'S002-PLAN.md'), 'utf-8');
+  assert.match(s2PlanRaw, /id="M001-S002-T0001"/);
+  assert.match(s2PlanRaw, /id="M001-S002-T0002"/);
+  assert.doesNotMatch(s2PlanRaw, /T0004/);
+  assert.doesNotMatch(s2PlanRaw, /T0005/);
+
+  assert.deepEqual(out.normalized_ids['M001-S002-T0004'], 'M001-S002-T0001');
+  assert.deepEqual(out.normalized_ids['M001-S002-T0005'], 'M001-S002-T0002');
+  assert.deepEqual(out.normalized_ids['M001-S003-T0006'], 'M001-S003-T0001');
+  assert.deepEqual(out.normalized_ids['M001-S003-T0007'], 'M001-S003-T0002');
+});
+
+test('PM-11: scaffold-all-tasks is idempotent — already-normalized ids stay unchanged', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  const plan1 = [
+    '---', 'slice: "M001-S001"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S001-T0001" wave="1" tier="sonnet" depends_on=""><name>A</name><action>A</action><done>D</done></task>',
+  ].join('\n');
+  const plan2 = [
+    '---', 'slice: "M001-S002"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S002-T0001" wave="2" tier="sonnet" depends_on="M001-S001-T0001"><name>B</name><action>A</action><done>D</done></task>',
+  ].join('\n');
+  seedSliceDir(sandbox, 1, 1, { 'S001-PLAN.md': plan1 });
+  seedSliceDir(sandbox, 1, 2, { 'S002-PLAN.md': plan2 });
+
+  subcmd.run(['scaffold-all-tasks', '1'], { cwd: sandbox, stdout: _capture().stub });
+  const cap = _capture();
+  subcmd.run(['scaffold-all-tasks', '1'], { cwd: sandbox, stdout: cap.stub });
+  const out = JSON.parse(cap.get().trim());
+  assert.deepEqual(out.normalized_ids, {});
+});
+
+test('PM-13: scaffold accepts <files_modified> tag and strips bullet prefixes', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  const slicePlan = [
+    '---', 'slice: "M001-S001"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S001-T0001" wave="1" tier="sonnet" depends_on="">',
+    '  <name>Multi-file task</name>',
+    '  <files_modified>',
+    '    - src/a.ts',
+    '    - src/b.ts',
+    '    - src/c.ts',
+    '  </files_modified>',
+    '  <action>Touch three files.</action>',
+    '  <done>Done.</done>',
+    '</task>',
+  ].join('\n');
+  seedSliceDir(sandbox, 1, 1, { 'S001-PLAN.md': slicePlan });
+  subcmd.run(['scaffold-slice-tasks', '1', '1'], { cwd: sandbox, stdout: _capture().stub });
+  const body = fs.readFileSync(
+    path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S001', 'tasks', 'T0001', 'T0001-PLAN.md'),
+    'utf-8',
+  );
+  assert.match(body, /- "src\/a.ts"/);
+  assert.match(body, /- "src\/b.ts"/);
+  assert.match(body, /- "src\/c.ts"/);
+  assert.doesNotMatch(body, /- "- /);
+});
+
+test('PM-12: scaffold-slice-tasks renumbers its own slice when ids do not start at T0001', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  const plan2 = [
+    '---', 'slice: "M001-S002"', 'milestone: "M001"', '---', '',
+    '<task id="M001-S002-T0004" wave="2" tier="sonnet" depends_on=""><name>A</name><action>A</action><done>D</done></task>',
+    '<task id="M001-S002-T0005" wave="2" tier="sonnet" depends_on=""><name>B</name><action>A</action><done>D</done></task>',
+  ].join('\n');
+  seedSliceDir(sandbox, 1, 2, { 'S002-PLAN.md': plan2 });
+
+  const cap = _capture();
+  subcmd.run(['scaffold-slice-tasks', '1', '2'], { cwd: sandbox, stdout: cap.stub });
+  const out = JSON.parse(cap.get().trim());
+  assert.equal(out.task_count, 2);
+
+  const tasksBase = path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S002', 'tasks');
+  assert.ok(fs.existsSync(path.join(tasksBase, 'T0001')));
+  assert.ok(fs.existsSync(path.join(tasksBase, 'T0002')));
+  assert.ok(!fs.existsSync(path.join(tasksBase, 'T0004')));
+
+  const planRaw = fs.readFileSync(
+    path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S002', 'S002-PLAN.md'),
+    'utf-8',
+  );
+  assert.match(planRaw, /id="M001-S002-T0001"/);
+  assert.doesNotMatch(planRaw, /T0004/);
+});

package/bin/np-tools/stats.cjs

@@ -1,14 +1,78 @@
+const fs = require('node:fs');
 const path = require('node:path');
 const { execFileSync } = require('node:child_process');
 const { NubosPilotError, findProjectRoot } = require('../../lib/core.cjs');
 const { parseRoadmap } = require('../../lib/roadmap.cjs');
 const { readState } = require('../../lib/state.cjs');
 const { aggregatePhase } = require('../../lib/metrics-aggregate.cjs');
+const { extractFrontmatter } = require('../../lib/frontmatter.cjs');
+const layout = require('../../lib/layout.cjs');
 
-const SCHEMA_VERSION = 1;
+const SCHEMA_VERSION = 2;
 
 function _usage() {
-  return 'Usage:\n  np-tools.cjs stats json';
+  return 'Usage:\n  np-tools.cjs stats json\n  np-tools.cjs stats bar';
+}
+
+function _percent(num, den) {
+  if (!den || den <= 0) return 0;
+  return Math.min(100, Math.round((num / den) * 100));
+}
+
+function _taskStatus(planPath) {
+  try {
+    const raw = fs.readFileSync(planPath, 'utf-8');
+    const { frontmatter } = extractFrontmatter(raw);
+    return frontmatter && typeof frontmatter.status === 'string'
+      ? frontmatter.status : null;
+  } catch {
+    return null;
+  }
+}
+
+function _collectTaskAndSliceStats(cwd) {
+  let tasksTotal = 0;
+  let tasksComplete = 0;
+  let slicesTotal = 0;
+  let slicesComplete = 0;
+  const milestones = layout.listMilestones(cwd);
+  for (const m of milestones) {
+    const slices = layout.listSlices(m.number, cwd);
+    for (const s of slices) {
+      slicesTotal += 1;
+      const tasks = layout.listTasks(m.number, s.number, cwd);
+      if (tasks.length === 0) continue;
+      let doneInSlice = 0;
+      for (const t of tasks) {
+        if (!fs.existsSync(t.plan_path)) continue;
+        tasksTotal += 1;
+        if (_taskStatus(t.plan_path) === 'done') {
+          tasksComplete += 1;
+          doneInSlice += 1;
+        }
+      }
+      if (doneInSlice === tasks.length && tasks.length > 0) slicesComplete += 1;
+    }
+  }
+  return {
+    tasks: {
+      total: tasksTotal,
+      complete: tasksComplete,
+      percent: _percent(tasksComplete, tasksTotal),
+    },
+    slices: {
+      total: slicesTotal,
+      complete: slicesComplete,
+      percent: _percent(slicesComplete, slicesTotal),
+    },
+  };
+}
+
+function _renderBar(label, percent, width) {
+  const w = Math.max(4, Math.min(60, width || 24));
+  const filled = Math.round((percent / 100) * w);
+  const bar = '█'.repeat(filled) + '░'.repeat(w - filled);
+  return label + ' [' + bar + '] ' + String(percent).padStart(3, ' ') + '%';
 }
 
 function _emitError(err, stderr) {
@@ -81,7 +145,8 @@ async function _buildStats(cwd) {
     plansTotal += ph.plans_total;
     plansComplete += ph.plans_complete;
   }
-  const percent = plansTotal > 0 ? Math.round((plansComplete / plansTotal) * 100) : 0;
+  const percent = _percent(plansComplete, plansTotal);
+  const fs_progress = _collectTaskAndSliceStats(useCwd);
   let lastActivity = null;
   try {
     const st = readState(useCwd);
@@ -108,6 +173,8 @@ async function _buildStats(cwd) {
     plans_total: plansTotal,
     plans_complete: plansComplete,
     percent,
+    tasks: fs_progress.tasks,
+    slices: fs_progress.slices,
     git,
     last_activity: lastActivity,
     metrics_by_phase,
@@ -121,7 +188,7 @@ async function run(argv, ctx) {
   const stderr = context.stderr || process.stderr;
   const args = Array.isArray(argv) ? argv.slice() : [];
   const sub = args.shift();
-  if (sub !== 'json') {
+  if (sub !== 'json' && sub !== 'bar') {
     stderr.write(_usage() + '\n');
     return 1;
   }
@@ -133,6 +200,11 @@ async function run(argv, ctx) {
   }
   try {
     const out = await _buildStats(cwd);
+    if (sub === 'bar') {
+      stdout.write(_renderBar('Tasks ', out.tasks.percent) + '  (' + out.tasks.complete + '/' + out.tasks.total + ')\n');
+      stdout.write(_renderBar('Slices', out.slices.percent) + '  (' + out.slices.complete + '/' + out.slices.total + ')\n');
+      return 0;
+    }
     stdout.write(JSON.stringify(out, null, 2) + '\n');
     return 0;
   } catch (err) {
@@ -141,7 +213,7 @@ async function run(argv, ctx) {
   }
 }
 
-module.exports = { run, _buildStats, _collectPhases, _milestoneEntry };
+module.exports = { run, _buildStats, _collectPhases, _milestoneEntry, _collectTaskAndSliceStats, _renderBar };
 
 if (require.main === module) {
   run(process.argv.slice(2)).then((code) => process.exit(code)).catch((err) => {

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

@@ -87,17 +87,99 @@ test('STATS-1: stats json emits schema_version + phases + git + metrics_by_phase
   const code = await statsCli.run(['json'], { cwd: sb, stdout, stderr });
   assert.equal(code, 0, 'stderr=' + stderr.toString());
   const parsed = JSON.parse(stdout.toString());
-  assert.equal(parsed.schema_version, 1);
+  assert.equal(parsed.schema_version, 2);
   assert.ok(parsed.milestone);
   assert.equal(parsed.phases.length, 2);
   assert.equal(parsed.plans_total, 2);
   assert.equal(parsed.plans_complete, 1);
   assert.equal(parsed.percent, 50);
+  assert.ok(parsed.tasks);
+  assert.equal(typeof parsed.tasks.total, 'number');
+  assert.equal(typeof parsed.tasks.complete, 'number');
+  assert.equal(typeof parsed.tasks.percent, 'number');
+  assert.ok(parsed.slices);
+  assert.equal(typeof parsed.slices.total, 'number');
+  assert.equal(typeof parsed.slices.complete, 'number');
+  assert.equal(typeof parsed.slices.percent, 'number');
   assert.ok(parsed.git);
   assert.ok(typeof parsed.git.commits === 'number');
   assert.ok(parsed.metrics_by_phase);
 });
 
+function writeTaskPlan(root, mNum, sNum, tNum, status) {
+  const mid = 'M' + String(mNum).padStart(3, '0');
+  const sid = 'S' + String(sNum).padStart(3, '0');
+  const tid = 'T' + String(tNum).padStart(4, '0');
+  const dir = path.join(root, '.nubos-pilot', 'milestones', mid, 'slices', sid, 'tasks', tid);
+  fs.mkdirSync(dir, { recursive: true });
+  const fm = [
+    '---',
+    `id: ${mid}-${sid}-${tid}`,
+    `slice: ${mid}-${sid}`,
+    `milestone: ${mid}`,
+    'type: execute',
+    `status: ${status}`,
+    'tier: sonnet',
+    'owner: executor',
+    `wave: ${sNum}`,
+    'depends_on: []',
+    'files_modified: []',
+    'autonomous: true',
+    'must_haves: {}',
+    '---',
+    '',
+    `# ${mid}-${sid}-${tid}`,
+    '',
+  ].join('\n');
+  fs.writeFileSync(path.join(dir, tid + '-PLAN.md'), fm);
+}
+
+test('STATS-4: tasks + slices percent reflect filesystem task status', async () => {
+  const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
+  writeTaskPlan(sb, 1, 1, 1, 'done');
+  writeTaskPlan(sb, 1, 1, 2, 'done');
+  writeTaskPlan(sb, 1, 2, 1, 'done');
+  writeTaskPlan(sb, 1, 2, 2, 'pending');
+  writeTaskPlan(sb, 1, 3, 1, 'pending');
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = await statsCli.run(['json'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const parsed = JSON.parse(stdout.toString());
+  assert.equal(parsed.tasks.total, 5);
+  assert.equal(parsed.tasks.complete, 3);
+  assert.equal(parsed.tasks.percent, 60);
+  assert.equal(parsed.slices.total, 3);
+  assert.equal(parsed.slices.complete, 1, 'only S001 has all tasks done');
+  assert.equal(parsed.slices.percent, 33);
+});
+
+test('STATS-5: tasks + slices are 0 when nothing scaffolded', async () => {
+  const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
+  const stdout = makeSink();
+  const stderr = makeSink();
+  await statsCli.run(['json'], { cwd: sb, stdout, stderr });
+  const parsed = JSON.parse(stdout.toString());
+  assert.equal(parsed.tasks.total, 0);
+  assert.equal(parsed.tasks.percent, 0);
+  assert.equal(parsed.slices.total, 0);
+  assert.equal(parsed.slices.percent, 0);
+});
+
+test('STATS-6: stats bar renders two progress rows on stdout', async () => {
+  const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
+  writeTaskPlan(sb, 1, 1, 1, 'done');
+  writeTaskPlan(sb, 1, 1, 2, 'pending');
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = await statsCli.run(['bar'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const out = stdout.toString();
+  assert.match(out, /Tasks .*\d+%/);
+  assert.match(out, /Slices.*\d+%/);
+  assert.match(out, /1\/2/);
+});
+
 test('STATS-2: unknown subcommand prints usage', async () => {
   const sb = makeSandbox(DEMO_YAML, DEMO_STATE);
   const stdout = makeSink();

package/np-tools.cjs

@@ -47,6 +47,7 @@ const topLevelCommands = {
   'stats':          require('./bin/np-tools/stats.cjs'),
   'lang-directive': require('./bin/np-tools/lang-directive.cjs'),
   'text-mode':      require('./bin/np-tools/text-mode.cjs'),
+  'detect-runtime': require('./bin/np-tools/detect-runtime.cjs'),
 };
 
 const THRESHOLD = 16 * 1024;

package/package.json

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

package/workflows/execute-phase.md

@@ -20,7 +20,7 @@ LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init execute-milestone init "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_EXECUTOR=$(node .nubos-pilot/bin/np-tools.cjs agent-skills executor 2>/dev/null)
-RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
+RUNTIME=$(node .nubos-pilot/bin/np-tools.cjs detect-runtime)
 ```
 
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**

package/workflows/plan-phase.md

@@ -77,7 +77,7 @@ INIT=$(node .nubos-pilot/bin/np-tools.cjs init plan-milestone init "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_PLANNER=$(node .nubos-pilot/bin/np-tools.cjs agent-skills planner 2>/dev/null)
 AGENT_SKILLS_CHECKER=$(node .nubos-pilot/bin/np-tools.cjs agent-skills plan-checker 2>/dev/null)
-RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
+RUNTIME=$(node .nubos-pilot/bin/np-tools.cjs detect-runtime)
 ```
 
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**

package/workflows/research-phase.md

@@ -95,7 +95,7 @@ payload; larger payloads are written to a tmp file and referenced via
 LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init research-phase "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
+RUNTIME=$(node .nubos-pilot/bin/np-tools.cjs detect-runtime)
 ```
 
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**

package/workflows/validate-phase.md

@@ -22,7 +22,7 @@ fi
 LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
 INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
-RUNTIME=$(node -e "console.log(require('./lib/runtime/index.cjs').detect().runtime)")
+RUNTIME=$(node .nubos-pilot/bin/np-tools.cjs detect-runtime)
 ```
 
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**