nubos-pilot 0.5.6 → 0.5.8

package/bin/np-tools/commit.cjs

@@ -2,6 +2,7 @@ const { execFileSync } = require('node:child_process');
 const path = require('node:path');
 const { NubosPilotError } = require('../../lib/core.cjs');
 const { assertCommittablePaths } = require('../../lib/git.cjs');
+const { resolveCommitArtifacts } = require('../../lib/commit-policy.cjs');
 
 const MAX_MSG = 2000;
 
@@ -65,6 +66,7 @@ function _validateFiles(files) {
 
 function run(argv, ctx) {
   const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
   const stdout = context.stdout || process.stdout;
   const stderr = context.stderr || process.stderr;
   try {
@@ -81,6 +83,10 @@ function run(argv, ctx) {
       return 1;
     }
     _validateFiles(files);
+    if (resolveCommitArtifacts(cwd) === false) {
+      stdout.write(JSON.stringify({ committed: false, reason: 'commit_artifacts=false', files }) + '\n');
+      return 0;
+    }
     const committable = assertCommittablePaths(files);
     if (committable.length === 0) {
       throw new NubosPilotError('commit-no-paths', 'commit invoked with no committable paths', { files });

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

@@ -91,3 +91,47 @@ test('COMMIT-4: overlong message exceeds limit → commit-message-too-long', ()
   assert.equal(code, 1);
   assert.match(stderr.toString(), /"code":\s*"commit-message-too-long"/);
 });
+
+test('COMMIT-5: workflow.commit_artifacts=false skips commit silently with exit 0', () => {
+  const sb = makeSandbox();
+  initGit(sb);
+  fs.writeFileSync(path.join(sb, 'note.md'), 'x');
+  fs.writeFileSync(
+    path.join(sb, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ workflow: { commit_artifacts: false } }),
+  );
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const code = commitCli.run(['docs: note', '--files', 'note.md'], { cwd: sb, stdout, stderr });
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const out = stdout.toString();
+  assert.match(out, /"committed":\s*false/);
+  assert.match(out, /"reason":\s*"commit_artifacts=false"/);
+  let logOut = '';
+  try {
+    logOut = execFileSync('git', ['log', '--oneline'], { cwd: sb, encoding: 'utf-8' }).trim();
+  } catch { logOut = ''; }
+  assert.equal(logOut, '', 'expected no commits to be created');
+});
+
+test('COMMIT-6: workflow.commit_artifacts=true still commits normally', () => {
+  const sb = makeSandbox();
+  initGit(sb);
+  fs.writeFileSync(path.join(sb, 'note.md'), 'x');
+  fs.writeFileSync(
+    path.join(sb, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ workflow: { commit_artifacts: true } }),
+  );
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const origCwd = process.cwd();
+  process.chdir(sb);
+  let code;
+  try {
+    code = commitCli.run(['docs: note', '--files', 'note.md'], { stdout, stderr });
+  } finally {
+    process.chdir(origCwd);
+  }
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  assert.match(stdout.toString(), /"committed":\s*true/);
+});

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

@@ -8,6 +8,7 @@ const crypto = require('node:crypto');
 const {
   NubosPilotError,
   projectStateDir,
+  atomicWriteFileSync,
 } = require('../../lib/core.cjs');
 const layout = require('../../lib/layout.cjs');
 const { getPhase } = require('../../lib/roadmap.cjs');
@@ -141,6 +142,84 @@ function _initPayload(mNum, cwd) {
   };
 }
 
+function _readTaskSummaryBody(summaryPath) {
+  if (!fs.existsSync(summaryPath)) return null;
+  const raw = fs.readFileSync(summaryPath, 'utf-8');
+  const { body } = extractFrontmatter(raw);
+  return String(body || '').trim();
+}
+
+function _finalizeSlice(mNum, sNum, cwd) {
+  const slicePath = layout.findSliceDir(mNum, sNum, cwd);
+  if (!slicePath) {
+    throw new NubosPilotError(
+      'finalize-slice-not-found',
+      'Slice ' + layout.sliceFullId(mNum, sNum) + ' does not exist',
+      { milestone: mNum, slice: sNum },
+    );
+  }
+  const summaryPath = layout.sliceSummaryPath(mNum, sNum, cwd);
+  const tasks = _sliceTasksSorted(mNum, sNum, cwd);
+  const doneTasks = tasks.filter((t) => t.status === 'done');
+  const pendingTasks = tasks.filter((t) => t.status !== 'done');
+
+  const lines = [
+    '---',
+    'slice: ' + JSON.stringify(layout.sliceFullId(mNum, sNum)),
+    'milestone: ' + JSON.stringify(layout.mId(mNum)),
+    'type: slice-summary',
+    'task_count: ' + tasks.length,
+    'tasks_done: ' + doneTasks.length,
+    'tasks_pending: ' + pendingTasks.length,
+    'generated_at: ' + JSON.stringify(new Date().toISOString()),
+    '---',
+    '',
+    '# ' + layout.sliceFullId(mNum, sNum) + ' — SUMMARY',
+    '',
+    '_Auto-aggregated from task summaries by `execute-milestone finalize-slice`._',
+    '',
+    '## Task Roll-Up',
+    '',
+    '| Task | Status | Name |',
+    '|------|--------|------|',
+  ];
+  for (const t of tasks) {
+    lines.push('| ' + t.id + ' | ' + t.status + ' | ' + (t.name || '').replace(/\|/g, '\\|') + ' |');
+  }
+  lines.push('', '## Task Summaries', '');
+  for (const t of tasks) {
+    lines.push('### ' + t.id + ' — ' + (t.name || ''));
+    lines.push('');
+    const body = _readTaskSummaryBody(t.summary_path);
+    if (body) {
+      lines.push(body);
+    } else {
+      lines.push('_No T<NNNN>-SUMMARY.md file present._');
+    }
+    lines.push('');
+  }
+  atomicWriteFileSync(summaryPath, lines.join('\n'));
+  return {
+    slice: layout.sliceFullId(mNum, sNum),
+    summary_path: summaryPath,
+    task_count: tasks.length,
+    tasks_done: doneTasks.length,
+    tasks_pending: pendingTasks.length,
+  };
+}
+
+function _finalizeMilestone(mNum, cwd) {
+  const slices = layout.listSlices(mNum, cwd);
+  if (slices.length === 0) {
+    return { milestone: layout.mId(mNum), finalized: [], reason: 'no-slices' };
+  }
+  const finalized = [];
+  for (const s of slices) {
+    finalized.push(_finalizeSlice(mNum, s.number, cwd));
+  }
+  return { milestone: layout.mId(mNum), finalized, reason: 'ok' };
+}
+
 function _findTaskByFullId(mNum, taskFullId, cwd) {
   let parsed;
   try {
@@ -218,6 +297,19 @@ function run(args, ctx) {
       _emit(payload, stdout, cwd);
       return payload;
     }
+    case 'finalize-slice': {
+      const mNum = _validateMilestoneArg(list[1]);
+      const sNum = _validateMilestoneArg(list[2]);
+      const payload = _finalizeSlice(mNum, sNum, cwd);
+      _emit(payload, stdout, cwd);
+      return payload;
+    }
+    case 'finalize-milestone': {
+      const mNum = _validateMilestoneArg(list[1]);
+      const payload = _finalizeMilestone(mNum, cwd);
+      _emit(payload, stdout, cwd);
+      return payload;
+    }
     default:
       throw new NubosPilotError(
         'execute-milestone-unknown-verb',

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

@@ -152,3 +152,98 @@ test('EM-6: unknown verb throws', () => {
     (err) => err && err.code === 'execute-milestone-unknown-verb',
   );
 });
+
+function _writeTaskSummary(sandbox, mNum, sNum, tNum, body) {
+  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 fullId = mId + '-' + sId + '-' + tId;
+  const dir = path.join(sandbox, '.nubos-pilot', 'milestones', mId, 'slices', sId, 'tasks', tId);
+  const content = [
+    '---',
+    'id: ' + JSON.stringify(fullId),
+    'status: done',
+    '---',
+    '',
+    body,
+    '',
+  ].join('\n');
+  fs.writeFileSync(path.join(dir, tId + '-SUMMARY.md'), content);
+}
+
+test('EM-7: finalize-slice writes S<NNN>-SUMMARY.md aggregating task summaries', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  seedSliceDir(sandbox, 1, 1, {});
+  _seedTask(sandbox, 1, 1, 1, ['src/a.ts']);
+  _seedTask(sandbox, 1, 1, 2, ['src/b.ts']);
+  _writeTaskSummary(sandbox, 1, 1, 1, '## Changes\n- Added src/a.ts');
+  _writeTaskSummary(sandbox, 1, 1, 2, '## Changes\n- Added src/b.ts');
+
+  const cap = _capture();
+  subcmd.run(['finalize-slice', '1', '1'], { cwd: sandbox, stdout: cap.stub });
+  const out = JSON.parse(cap.get());
+  assert.equal(out.slice, 'M001-S001');
+  assert.equal(out.task_count, 2);
+
+  const summaryPath = path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S001', 'S001-SUMMARY.md');
+  assert.ok(fs.existsSync(summaryPath));
+  const body = fs.readFileSync(summaryPath, 'utf-8');
+  assert.match(body, /slice: "M001-S001"/);
+  assert.match(body, /type: slice-summary/);
+  assert.match(body, /### M001-S001-T0001/);
+  assert.match(body, /### M001-S001-T0002/);
+  assert.match(body, /Added src\/a.ts/);
+  assert.match(body, /Added src\/b.ts/);
+});
+
+test('EM-8: finalize-slice fails when slice directory does not exist', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  const cap = _capture();
+  assert.throws(
+    () => subcmd.run(['finalize-slice', '1', '9'], { cwd: sandbox, stdout: cap.stub }),
+    (err) => err && err.code === 'finalize-slice-not-found',
+  );
+});
+
+test('EM-9: finalize-milestone iterates every slice and produces one summary per slice', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  seedSliceDir(sandbox, 1, 1, {});
+  seedSliceDir(sandbox, 1, 2, {});
+  _seedTask(sandbox, 1, 1, 1, ['src/a.ts']);
+  _seedTask(sandbox, 1, 2, 1, ['src/c.ts']);
+
+  const cap = _capture();
+  subcmd.run(['finalize-milestone', '1'], { cwd: sandbox, stdout: cap.stub });
+  const out = JSON.parse(cap.get());
+  assert.equal(out.milestone, 'M001');
+  assert.equal(out.finalized.length, 2);
+  assert.equal(out.reason, 'ok');
+
+  const s1 = path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S001', 'S001-SUMMARY.md');
+  const s2 = path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S002', 'S002-SUMMARY.md');
+  assert.ok(fs.existsSync(s1));
+  assert.ok(fs.existsSync(s2));
+});
+
+test('EM-10: finalize-slice marks tasks without SUMMARY.md but does not fail', () => {
+  const sandbox = makeSandbox();
+  seedRoadmapYaml(sandbox, _roadmap());
+  seedMilestoneDir(sandbox, 1, {});
+  seedSliceDir(sandbox, 1, 1, {});
+  _seedTask(sandbox, 1, 1, 1, ['src/a.ts']);
+  const dir = path.join(sandbox, '.nubos-pilot', 'milestones', 'M001', 'slices', 'S001', 'tasks', 'T0001');
+  fs.rmSync(path.join(dir, 'T0001-SUMMARY.md'));
+
+  const cap = _capture();
+  subcmd.run(['finalize-slice', '1', '1'], { cwd: sandbox, stdout: cap.stub });
+  const out = JSON.parse(cap.get());
+  assert.equal(out.task_count, 1);
+  const body = fs.readFileSync(out.summary_path, 'utf-8');
+  assert.match(body, /No T<NNNN>-SUMMARY.md file present/);
+});

package/lib/agents.cjs

@@ -50,16 +50,22 @@ function validateAgentFrontmatter(fm, agentName) {
 }
 
 function loadAgent(name, cwd) {
-  const root = findProjectRoot(cwd || process.cwd());
-  const p = path.join(root, 'agents', name + '.md');
-  if (!fs.existsSync(p)) {
+  const candidates = [];
+  try {
+    const root = findProjectRoot(cwd || process.cwd());
+    candidates.push(path.join(root, 'agents', name + '.md'));
+  } catch {}
+  candidates.push(path.resolve(__dirname, '..', 'agents', name + '.md'));
+
+  const found = candidates.find((p) => fs.existsSync(p));
+  if (!found) {
     throw new NubosPilotError(
       'agent-not-found',
-      'Agent "' + name + '" not found at ' + p,
-      { name, path: p },
+      'Agent "' + name + '" not found at ' + candidates[0],
+      { name, path: candidates[0], tried: candidates },
     );
   }
-  const { frontmatter } = extractFrontmatter(fs.readFileSync(p, 'utf-8'));
+  const { frontmatter } = extractFrontmatter(fs.readFileSync(found, 'utf-8'));
   return validateAgentFrontmatter(frontmatter, name);
 }
 

package/lib/commit-policy.cjs

@@ -0,0 +1,60 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { findProjectRoot, NubosPilotError } = require('./core.cjs');
+
+const DEFAULT_COMMIT_ARTIFACTS = true;
+
+function _coerceBool(raw) {
+  if (raw === true || raw === false) return raw;
+  if (raw == null) return null;
+  const s = String(raw).trim().toLowerCase();
+  if (s === 'true' || s === '1' || s === 'yes' || s === 'on') return true;
+  if (s === 'false' || s === '0' || s === 'no' || s === 'off') return false;
+  return null;
+}
+
+function readConfigCommitArtifacts(cwd) {
+  let root;
+  try {
+    root = findProjectRoot(cwd || process.cwd());
+  } catch (err) {
+    if (err && err.code === 'not-in-project') return null;
+    throw err;
+  }
+  const p = path.join(root, '.nubos-pilot', 'config.json');
+  if (!fs.existsSync(p)) return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
+  } catch (err) {
+    throw new NubosPilotError('commit-policy-config-parse-error', 'config.json invalid JSON', { cause: err && err.message });
+  }
+  if (!parsed || typeof parsed !== 'object') return null;
+  const workflow = parsed.workflow;
+  if (!workflow || typeof workflow !== 'object') return null;
+  if (!Object.prototype.hasOwnProperty.call(workflow, 'commit_artifacts')) return null;
+  return _coerceBool(workflow.commit_artifacts);
+}
+
+function resolveCommitArtifacts(cwd) {
+  const fromConfig = readConfigCommitArtifacts(cwd);
+  if (fromConfig !== null) return fromConfig;
+  return DEFAULT_COMMIT_ARTIFACTS;
+}
+
+function resolveCommitArtifactsDetail(cwd) {
+  const fromConfig = readConfigCommitArtifacts(cwd);
+  if (fromConfig !== null) {
+    return { enabled: fromConfig, source: 'config' };
+  }
+  return { enabled: DEFAULT_COMMIT_ARTIFACTS, source: 'default' };
+}
+
+module.exports = {
+  DEFAULT_COMMIT_ARTIFACTS,
+  readConfigCommitArtifacts,
+  resolveCommitArtifacts,
+  resolveCommitArtifactsDetail,
+};

package/lib/commit-policy.test.cjs

@@ -0,0 +1,74 @@
+'use strict';
+
+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 {
+  DEFAULT_COMMIT_ARTIFACTS,
+  readConfigCommitArtifacts,
+  resolveCommitArtifacts,
+  resolveCommitArtifactsDetail,
+} = require('./commit-policy.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox(config) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-commit-policy-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  if (config !== undefined) {
+    fs.writeFileSync(
+      path.join(root, '.nubos-pilot', 'config.json'),
+      typeof config === 'string' ? config : JSON.stringify(config),
+    );
+  }
+  _sandboxes.push(root);
+  return root;
+}
+
+test.afterEach(() => {
+  while (_sandboxes.length) {
+    try { fs.rmSync(_sandboxes.pop(), { recursive: true, force: true }); } catch {  }
+  }
+});
+
+test('CP-1: default is true when config absent', () => {
+  const sb = makeSandbox();
+  assert.equal(resolveCommitArtifacts(sb), true);
+  assert.equal(DEFAULT_COMMIT_ARTIFACTS, true);
+});
+
+test('CP-2: workflow.commit_artifacts=false is respected', () => {
+  const sb = makeSandbox({ workflow: { commit_artifacts: false } });
+  assert.equal(resolveCommitArtifacts(sb), false);
+  assert.deepEqual(resolveCommitArtifactsDetail(sb), { enabled: false, source: 'config' });
+});
+
+test('CP-3: workflow.commit_artifacts=true is respected', () => {
+  const sb = makeSandbox({ workflow: { commit_artifacts: true } });
+  assert.equal(resolveCommitArtifacts(sb), true);
+  assert.deepEqual(resolveCommitArtifactsDetail(sb), { enabled: true, source: 'config' });
+});
+
+test('CP-4: missing workflow.commit_artifacts key falls back to default', () => {
+  const sb = makeSandbox({ workflow: { text_mode: true } });
+  assert.equal(resolveCommitArtifacts(sb), true);
+  assert.deepEqual(resolveCommitArtifactsDetail(sb), { enabled: true, source: 'default' });
+});
+
+test('CP-5: invalid JSON surfaces as commit-policy-config-parse-error', () => {
+  const sb = makeSandbox('{ "workflow": { "commit_artifacts": false ');
+  assert.throws(
+    () => readConfigCommitArtifacts(sb),
+    (err) => err && err.code === 'commit-policy-config-parse-error',
+  );
+});
+
+test('CP-6: string "false" / "off" / "0" coerce to false', () => {
+  for (const val of ['false', 'off', '0', 'no']) {
+    const sb = makeSandbox({ workflow: { commit_artifacts: val } });
+    assert.equal(resolveCommitArtifacts(sb), false, 'expected ' + val + ' → false');
+  }
+});

package/package.json

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

package/workflows/add-tests.md

@@ -17,7 +17,7 @@ sentinels survive regeneration.
 
 ```bash
 PHASE="$1"
-INIT=$(node .nubos-pilot/bin/np-tools.cjs init add-tests "$PHASE")
+INIT=$(node .nubos-pilot/bin/np-tools.cjs init add-tests init "$PHASE")
 ```
 
 Parse: `phase`, `target_path`, `verification_path`, `pass_cases[]`,

package/workflows/execute-phase.md

@@ -136,7 +136,16 @@ for WAVE_INDEX in 0 1 2 ...; do
     fi
   done
   # wait for all parallel executors in this wave to finish before next wave
+
+  # After every task in the slice committed: aggregate per-task summaries into
+  # the slice-level S<NNN>-SUMMARY.md so /np:validate-phase can audit it.
+  SLICE_NUM=$(echo "$WAVE" | node -e "process.stdin.on('data', d => console.log(JSON.parse(d).wave))")
+  node .nubos-pilot/bin/np-tools.cjs init execute-milestone finalize-slice "$PHASE" "$SLICE_NUM" >/dev/null
 done
+
+# Milestone done — regenerate every slice summary so retroactive / resumed
+# runs also end with a complete audit surface.
+node .nubos-pilot/bin/np-tools.cjs init execute-milestone finalize-milestone "$PHASE" >/dev/null
 ```
 
 After every slice completes, point the operator at `/np:validate-phase $PHASE` to run the UAT per slice.

package/workflows/plan-phase.md

@@ -277,8 +277,11 @@ The scaffolder:
 ## Commit
 
 ```bash
-git add "$milestone_dir"
-git commit -m "docs(${milestone_id}): milestone plan ready for execute"
+COMMIT_ARTIFACTS=$(node .nubos-pilot/bin/np-tools.cjs config-get workflow.commit_artifacts 2>/dev/null || echo "true")
+if [[ "$COMMIT_ARTIFACTS" != "false" ]]; then
+  git add "$milestone_dir"
+  git commit -m "docs(${milestone_id}): milestone plan ready for execute"
+fi
 ```
 
 Commits include: all milestone-level artefacts (CONTEXT/ROADMAP/META), every slice's ASSESSMENT/PLAN/UAT, and every scaffolded task file.

package/workflows/validate-phase.md

@@ -20,7 +20,7 @@ if [[ -z "$PHASE" ]]; then
 fi
 
 LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
-INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work "$PHASE")
+INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work init "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 RUNTIME=$(node .nubos-pilot/bin/np-tools.cjs detect-runtime)
 ```

package/workflows/verify-work.md

@@ -17,7 +17,7 @@ Slice-level acceptance (UAT) is validated separately by `/np:validate-phase <N>`
 ```bash
 PHASE="$1"
 LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
-INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work "$PHASE")
+INIT=$(node .nubos-pilot/bin/np-tools.cjs init verify-work init "$PHASE")
 if [[ "$INIT" == @file:* ]]; then INIT=$(cat "${INIT#@file:}"); fi
 AGENT_SKILLS_VERIFIER=$(node .nubos-pilot/bin/np-tools.cjs agent-skills verifier 2>/dev/null)
 ```