nubos-pilot 0.7.0 → 0.7.2

package/lib/worktree.test.cjs

@@ -0,0 +1,228 @@
+'use strict';
+
+const { test, after } = 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 { execFileSync } = require('node:child_process');
+
+const worktree = require('./worktree.cjs');
+
+const _repos = [];
+
+after(() => {
+  for (const r of _repos) {
+    try { fs.rmSync(r, { recursive: true, force: true }); } catch {}
+  }
+});
+
+function makeRepo(opts) {
+  const o = opts || {};
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-worktree-'));
+  execFileSync('git', ['init', '-q', '-b', 'main', root], { stdio: 'pipe' });
+  execFileSync('git', ['-C', root, 'config', 'user.email', 'test@nubos-pilot.local']);
+  execFileSync('git', ['-C', root, 'config', 'user.name', 'nubos-test']);
+  execFileSync('git', ['-C', root, 'config', 'commit.gpgsign', 'false']);
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  if (o.gitignored !== false) {
+    fs.writeFileSync(path.join(root, '.gitignore'), '.nubos-pilot/worktrees/\n', 'utf-8');
+    execFileSync('git', ['-C', root, 'add', '.gitignore'], { stdio: 'pipe' });
+  }
+  execFileSync('git', ['-C', root, 'commit', '--allow-empty', '-q', '-m', 'chore: init'], { stdio: 'pipe' });
+  _repos.push(root);
+  return root;
+}
+
+function writeConfig(root, cfg) {
+  fs.writeFileSync(
+    path.join(root, '.nubos-pilot', 'config.json'),
+    JSON.stringify(cfg, null, 2),
+    'utf-8',
+  );
+}
+
+function commitFile(root, rel, body, message) {
+  const abs = path.join(root, rel);
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, body, 'utf-8');
+  execFileSync('git', ['-C', root, 'add', rel], { stdio: 'pipe' });
+  execFileSync('git', ['-C', root, 'commit', '-q', '-m', message], { stdio: 'pipe' });
+}
+
+test('WT-1: sliceBranchName builds np/<mid>-<sid> for a valid slice id', () => {
+  assert.equal(worktree.sliceBranchName('M001-S001'), 'np/M001-S001');
+  assert.equal(worktree.sliceBranchName('M042-S099'), 'np/M042-S099');
+});
+
+test('WT-2: sliceBranchName rejects malformed ids', () => {
+  assert.throws(
+    () => worktree.sliceBranchName('not-a-slice-id'),
+    (err) => err.name === 'NubosPilotError' && err.code === 'layout-invalid-id',
+  );
+});
+
+test('WT-3: parseSliceBranchName round-trips sliceBranchName', () => {
+  const parsed = worktree.parseSliceBranchName('np/M003-S007');
+  assert.deepEqual(parsed, { sliceFullId: 'M003-S007', milestone: 3, slice: 7 });
+});
+
+test('WT-4: parseSliceBranchName returns null for non-np branches', () => {
+  assert.equal(worktree.parseSliceBranchName('main'), null);
+  assert.equal(worktree.parseSliceBranchName('feature/foo'), null);
+  assert.equal(worktree.parseSliceBranchName('np/not-valid'), null);
+});
+
+test('WT-5: sliceWorktreePath lives under .nubos-pilot/worktrees/<mid>/<sid>', () => {
+  const root = makeRepo();
+  const p = worktree.sliceWorktreePath('M001-S002', root);
+  assert.equal(p, path.join(root, '.nubos-pilot', 'worktrees', 'M001', 'S002'));
+});
+
+test('WT-6: worktreeIsolationEnabled reads workflow.worktree_isolation flag', () => {
+  const root = makeRepo();
+  assert.equal(worktree.worktreeIsolationEnabled(root), false);
+  writeConfig(root, { workflow: { worktree_isolation: true } });
+  assert.equal(worktree.worktreeIsolationEnabled(root), true);
+  writeConfig(root, { workflow: { worktree_isolation: false } });
+  assert.equal(worktree.worktreeIsolationEnabled(root), false);
+});
+
+test('WT-7: createSliceWorktree creates a worktree and branch on current HEAD', () => {
+  const root = makeRepo();
+  const res = worktree.createSliceWorktree('M001-S001', root);
+
+  assert.equal(res.slice_full_id, 'M001-S001');
+  assert.equal(res.branch, 'np/M001-S001');
+  assert.equal(res.path, path.join(root, '.nubos-pilot', 'worktrees', 'M001', 'S001'));
+  assert.match(res.base_sha, /^[a-f0-9]{40}$/);
+
+  assert.ok(fs.existsSync(res.path), 'worktree path must exist');
+  const branchCheck = execFileSync('git', ['-C', root, 'rev-parse', '--verify', '--quiet', 'refs/heads/np/M001-S001']);
+  assert.ok(branchCheck.toString().trim().length === 40);
+});
+
+test('WT-8: createSliceWorktree refuses to recreate an existing worktree', () => {
+  const root = makeRepo();
+  worktree.createSliceWorktree('M001-S001', root);
+  assert.throws(
+    () => worktree.createSliceWorktree('M001-S001', root),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-already-exists',
+  );
+});
+
+test('WT-9: createSliceWorktree refuses to reuse an existing branch', () => {
+  const root = makeRepo();
+  execFileSync('git', ['-C', root, 'branch', 'np/M002-S001'], { stdio: 'pipe' });
+  assert.throws(
+    () => worktree.createSliceWorktree('M002-S001', root),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-branch-conflict',
+  );
+});
+
+test('WT-10: listSliceWorktrees returns only np/ worktrees, not main', () => {
+  const root = makeRepo();
+  worktree.createSliceWorktree('M001-S001', root);
+  worktree.createSliceWorktree('M001-S002', root);
+  const list = worktree.listSliceWorktrees(root);
+  assert.equal(list.length, 2);
+  const ids = list.map((w) => w.slice_full_id).sort();
+  assert.deepEqual(ids, ['M001-S001', 'M001-S002']);
+  assert.ok(list[0].branch.startsWith('np/'));
+});
+
+test('WT-11: hasSliceWorktree reports correctly before and after creation', () => {
+  const root = makeRepo();
+  assert.equal(worktree.hasSliceWorktree('M001-S001', root), false);
+  worktree.createSliceWorktree('M001-S001', root);
+  assert.equal(worktree.hasSliceWorktree('M001-S001', root), true);
+  assert.equal(worktree.hasSliceWorktree('M001-S002', root), false);
+});
+
+test('WT-12: removeSliceWorktree deletes the worktree and its branch', () => {
+  const root = makeRepo();
+  const res = worktree.createSliceWorktree('M001-S001', root);
+  worktree.removeSliceWorktree('M001-S001', root);
+  assert.equal(fs.existsSync(res.path), false);
+  const branchCheck = execFileSync('git', ['-C', root, 'branch', '--list', 'np/M001-S001']).toString().trim();
+  assert.equal(branchCheck, '');
+});
+
+test('WT-13: removeSliceWorktree with deleteBranch=false keeps the branch', () => {
+  const root = makeRepo();
+  worktree.createSliceWorktree('M001-S001', root);
+  worktree.removeSliceWorktree('M001-S001', root, { deleteBranch: false });
+  const branchCheck = execFileSync('git', ['-C', root, 'branch', '--list', 'np/M001-S001']).toString().trim();
+  assert.match(branchCheck, /np\/M001-S001/);
+});
+
+test('WT-14: ffMergeSliceWorktree ff-merges a slice branch back to main', () => {
+  const root = makeRepo();
+  const created = worktree.createSliceWorktree('M001-S001', root);
+  commitFile(created.path, 'src/foo.txt', 'hello', 'task: add foo');
+  const res = worktree.ffMergeSliceWorktree('M001-S001', 'main', root);
+  assert.match(res.merged_sha, /^[a-f0-9]{40}$/);
+
+  const head = execFileSync('git', ['-C', root, 'rev-parse', 'HEAD']).toString().trim();
+  assert.equal(head, res.merged_sha);
+  assert.ok(fs.existsSync(path.join(root, 'src/foo.txt')));
+});
+
+test('WT-15: ffMergeSliceWorktree rejects a non-ff merge (main moved ahead)', () => {
+  const root = makeRepo();
+  worktree.createSliceWorktree('M001-S001', root);
+  commitFile(path.join(root, '.nubos-pilot', 'worktrees', 'M001', 'S001'), 'in-slice.txt', 'x', 'task: slice work');
+  commitFile(root, 'on-main.txt', 'y', 'chore: advance main');
+
+  assert.throws(
+    () => worktree.ffMergeSliceWorktree('M001-S001', 'main', root),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-ff-not-possible',
+  );
+});
+
+test('WT-16: ffMergeSliceWorktree rejects when HEAD is on wrong branch', () => {
+  const root = makeRepo();
+  worktree.createSliceWorktree('M001-S001', root);
+  execFileSync('git', ['-C', root, 'checkout', '-q', '-b', 'other'], { stdio: 'pipe' });
+  assert.throws(
+    () => worktree.ffMergeSliceWorktree('M001-S001', 'main', root),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-ff-wrong-branch',
+  );
+});
+
+test('WT-17: ffMergeSliceWorktree fails if the slice branch does not exist', () => {
+  const root = makeRepo();
+  assert.throws(
+    () => worktree.ffMergeSliceWorktree('M001-S099', 'main', root),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-branch-missing',
+  );
+});
+
+test('WT-18: _assertGitRepo fails outside a git repo', () => {
+  const nonRepo = fs.mkdtempSync(path.join(os.tmpdir(), 'np-nonrepo-'));
+  _repos.push(nonRepo);
+  assert.throws(
+    () => worktree.listSliceWorktrees(nonRepo),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-not-git-repo',
+  );
+});
+
+test('WT-19: createSliceWorktree nests parent dirs under .nubos-pilot/worktrees/', () => {
+  const root = makeRepo();
+  const res = worktree.createSliceWorktree('M042-S013', root);
+  assert.ok(res.path.endsWith(path.join('.nubos-pilot', 'worktrees', 'M042', 'S013')));
+  assert.ok(fs.existsSync(path.join(root, '.nubos-pilot', 'worktrees', 'M042')));
+});
+
+test('WT-20: pruneSliceWorktrees does not throw on a clean repo', () => {
+  const root = makeRepo();
+  assert.doesNotThrow(() => worktree.pruneSliceWorktrees(root));
+});
+
+test('WT-21: createSliceWorktree refuses when .nubos-pilot/worktrees/ is NOT gitignored', () => {
+  const root = makeRepo({ gitignored: false });
+  assert.throws(
+    () => worktree.createSliceWorktree('M001-S001', root),
+    (err) => err.name === 'NubosPilotError' && err.code === 'worktree-not-gitignored',
+  );
+});

package/np-tools.cjs

@@ -54,6 +54,16 @@ const topLevelCommands = {
   'phase-meta':     require('./bin/np-tools/phase-meta.cjs'),
   'state-dir':      require('./bin/np-tools/state-dir.cjs'),
   'render-template': require('./bin/np-tools/render-template.cjs'),
+  'render-todo':     require('./bin/np-tools/render-todo.cjs'),
+  'handoff-write':   require('./bin/np-tools/handoff-write.cjs'),
+  'handoff-read':    require('./bin/np-tools/handoff-read.cjs'),
+  'handoff-list':    require('./bin/np-tools/handoff-list.cjs'),
+  'handoff-status':  require('./bin/np-tools/handoff-status.cjs'),
+  'worktree-create':   require('./bin/np-tools/worktree-create.cjs'),
+  'worktree-remove':   require('./bin/np-tools/worktree-remove.cjs'),
+  'worktree-list':     require('./bin/np-tools/worktree-list.cjs'),
+  'worktree-ff-merge': require('./bin/np-tools/worktree-ff-merge.cjs'),
+  'dashboard':         require('./bin/np-tools/dashboard.cjs'),
   'thread-resume':  require('./bin/np-tools/thread-resume.cjs'),
   'state-incr':     require('./bin/np-tools/state-incr.cjs'),
   'session-aggregate':     require('./bin/np-tools/session-aggregate.cjs'),

package/package.json

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

package/workflows/dashboard.md

@@ -0,0 +1,49 @@
+---
+command: np:dashboard
+description: One-shot console dashboard of milestones, slices, and tasks. Read-only — no files written, no state mutated, no git commit.
+---
+
+# np:dashboard
+
+Read-only snapshot of milestones, slices, and task statuses for the project.
+
+```bash
+node .nubos-pilot/bin/np-tools.cjs dashboard
+```
+
+That is the entire workflow. The CLI prints the snapshot to stdout — milestone-by-milestone, with one row per slice showing per-status counts plus a checkbox row of all tasks in the slice (`[ ]` pending, `[~]` in-progress, `[x]` done, `[-]` skipped, `[!]` parked).
+
+## No Commit
+
+Read-only. No files are written, no state is mutated, no git commit is made.
+
+## Scope Guardrail
+
+<scope_guardrail>
+**Do:**
+- Run the CLI with no arguments for the formatted view, `--json` for the raw snapshot, or `--no-color` for plain text.
+- Treat the output as a render — re-run the workflow when you want a fresh view.
+
+**Don't:**
+- Add a long-running watch loop here — single-shot only, by design (ADR-0001).
+- Mutate any state from this workflow — strictly read-only.
+- Add additional sections beyond milestones / slices / tasks. Drill-down into handoffs / checkpoints / worktrees uses their dedicated commands.
+</scope_guardrail>
+
+## Output
+
+Stdout only — formatted milestone overview with checkbox rows per slice. No files created. No state mutated. No git commit.
+
+## Success Criteria
+
+- [ ] Empty project renders the "No milestones yet" placeholder line.
+- [ ] Every milestone in `roadmap.yaml` appears with its name and status.
+- [ ] Every slice's checkbox row reflects current task frontmatter `status` values.
+- [ ] `--json` emits the snapshot shape `{ milestones: [{ id, number, name, status, slices: [{ id, full_id, counts, task_statuses }] }] }`.
+- [ ] `--no-color` emits no ANSI escape sequences.
+- [ ] Zero file writes, zero state mutations, zero commits.
+
+## Related Workflows
+
+- **`/np:stats`** — phases-table + metrics aggregation (commit-history view).
+- **`/np:state`** — current STATE.md frontmatter snapshot.

package/workflows/execute-phase.md

@@ -21,6 +21,7 @@ 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 .nubos-pilot/bin/np-tools.cjs detect-runtime)
+WORKTREE_ISOLATION=$(node .nubos-pilot/bin/np-tools.cjs config-get workflow.worktree_isolation 2>/dev/null || echo "false")
 ```
 
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
@@ -95,6 +96,18 @@ for WAVE_INDEX in 0 1 2 ...; do
 
   echo "=== Wave $((WAVE_INDEX+1)): $SLICE_FULL_ID — tasks: $TASK_IDS ===" >&2
 
+  # Worktree-Isolation (ADR-0008): when workflow.worktree_isolation=true,
+  # create an isolated git worktree for this slice before spawning executors.
+  # Executors run inside the worktree (cwd = worktree path), commits land on
+  # the slice branch np/<slice-full-id>, and the slice is fast-forward merged
+  # back on success. On failure: worktree stays in place for inspection.
+  SLICE_CWD="$PWD"
+  if [ "$WORKTREE_ISOLATION" = "true" ]; then
+    WT_CREATE=$(node .nubos-pilot/bin/np-tools.cjs worktree-create "$SLICE_FULL_ID")
+    SLICE_CWD=$(echo "$WT_CREATE" | node -e "process.stdin.on('data', d => console.log(JSON.parse(d).path))")
+    echo "[np:execute-phase] worktree created at $SLICE_CWD (branch np/$SLICE_FULL_ID)" >&2
+  fi
+
   # For each task id in TASK_IDS, spawn an executor IN PARALLEL.
   # The orchestrator's parallel primitive dispatches all of them in a single
   # message (multiple Agent tool use blocks in one send).
@@ -131,6 +144,9 @@ for WAVE_INDEX in 0 1 2 ...; do
 
     if [ "$COMMIT_STATUS" -ne 0 ]; then
       echo "[np:execute-phase] commit-task failed for $TASK_ID — aborting wave $SLICE_FULL_ID." >&2
+      if [ "$WORKTREE_ISOLATION" = "true" ]; then
+        echo "  Worktree $SLICE_CWD left in place for inspection. Clean up with: /np:reset-slice $TASK_ID" >&2
+      fi
       exit "$COMMIT_STATUS"
     fi
   done
@@ -140,6 +156,23 @@ for WAVE_INDEX in 0 1 2 ...; do
   # 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
+
+  # Worktree merge-back (ADR-0008 D-8.7): fast-forward-only merge the slice
+  # branch back onto the invoking workspace's current branch. Non-FF (e.g.
+  # because the base branch advanced during execution) fails hard — that
+  # surfaces the drift to the user rather than silently rewriting task SHAs.
+  if [ "$WORKTREE_ISOLATION" = "true" ]; then
+    FF_RESULT=$(node .nubos-pilot/bin/np-tools.cjs worktree-ff-merge "$SLICE_FULL_ID" 2>&1)
+    FF_STATUS=$?
+    if [ "$FF_STATUS" -ne 0 ]; then
+      echo "[np:execute-phase] ff-merge for $SLICE_FULL_ID failed — worktree left in place for inspection:" >&2
+      echo "  $FF_RESULT" >&2
+      echo "  To resolve: cd into $SLICE_CWD, rebase onto current base, then re-run this workflow." >&2
+      exit "$FF_STATUS"
+    fi
+    node .nubos-pilot/bin/np-tools.cjs worktree-remove "$SLICE_FULL_ID" >/dev/null
+    echo "[np:execute-phase] worktree $SLICE_FULL_ID merged + removed." >&2
+  fi
 done
 
 # Milestone done — regenerate every slice summary so retroactive / resumed