nubos-pilot 0.1.0

package/lib/template.cjs

@@ -0,0 +1,66 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const { projectStateDir, NubosPilotError } = require('./core.cjs');
+
+const PLACEHOLDER_RE = /\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*)\s*\}\}/g;
+
+function templatesDir(cwd) {
+  return path.join(projectStateDir(cwd), 'templates');
+}
+
+function loadTemplate(name, vars, cwd = process.cwd()) {
+  const dir = templatesDir(cwd);
+  const filePath = path.resolve(dir, name + '.md');
+
+  
+  const dirWithSep = dir.endsWith(path.sep) ? dir : dir + path.sep;
+  if (!filePath.startsWith(dirWithSep)) {
+    throw new NubosPilotError(
+      'template-not-found',
+      `Template name "${name}" escapes templates directory`,
+      { template: name, path: filePath },
+    );
+  }
+
+  let raw;
+  try {
+    raw = fs.readFileSync(filePath, 'utf-8');
+  } catch (err) {
+    if (err && err.code === 'ENOENT') {
+      throw new NubosPilotError(
+        'template-not-found',
+        `Template "${name}" not found at ${filePath}`,
+        { template: name, path: filePath },
+      );
+    }
+    throw err;
+  }
+
+  return raw.replace(PLACEHOLDER_RE, (_match, key) => {
+    if (!(key in vars)) {
+      throw new NubosPilotError(
+        'template-unresolved-var',
+        `Undefined placeholder {{${key}}} in template "${name}"`,
+        { template: name, variable: key, available: Object.keys(vars) },
+      );
+    }
+    return String(vars[key]);
+  });
+}
+
+function listTemplates(cwd = process.cwd()) {
+  const dir = templatesDir(cwd);
+  let entries;
+  try {
+    entries = fs.readdirSync(dir);
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return [];
+    throw err;
+  }
+  return entries
+    .filter((f) => f.endsWith('.md'))
+    .map((f) => f.slice(0, -3))
+    .sort();
+}
+
+module.exports = { loadTemplate, listTemplates };

package/lib/template.test.cjs

@@ -0,0 +1,159 @@
+const tpl = require('./template.cjs');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+
+const _sandboxes = [];
+
+function makeSandbox(templates) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'nubos-pilot-tpl-'));
+  if (templates) {
+    const dir = path.join(root, '.nubos-pilot', 'templates');
+    fs.mkdirSync(dir, { recursive: true });
+    for (const [name, content] of Object.entries(templates)) {
+      fs.writeFileSync(path.join(dir, `${name}.md`), content, 'utf-8');
+    }
+  } else {
+    fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  }
+  _sandboxes.push(root);
+  return root;
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    const root = _sandboxes.pop();
+    try { fs.rmSync(root, { recursive: true, force: true }); } catch {}
+  }
+});
+
+const PHASE_CONTEXT = fs.readFileSync(path.join(__dirname, 'fixtures/templates/phase-context.md'), 'utf-8');
+const PLAN_SKELETON = fs.readFileSync(path.join(__dirname, 'fixtures/templates/plan-skeleton.md'), 'utf-8');
+
+test('TPL-1: phase-context with full vars substitutes all placeholders', () => {
+  const cwd = makeSandbox({ 'phase-context': PHASE_CONTEXT });
+  const out = tpl.loadTemplate('phase-context', {
+    phase_number: '03',
+    phase_name: 'Core Lib',
+    goal: 'Build parsers',
+    requirements: 'LIB-03',
+  }, cwd);
+  assert.match(out, /Phase 03: Core Lib/);
+  assert.match(out, /Requirements: LIB-03/);
+  assert.ok(!out.includes('{{'), 'no unresolved placeholders');
+});
+
+test('TPL-2: repeated {{phase_number}} substitutes in BOTH positions', () => {
+  const cwd = makeSandbox({ 'phase-context': PHASE_CONTEXT });
+  const out = tpl.loadTemplate('phase-context', {
+    phase_number: '03',
+    phase_name: 'X',
+    goal: 'Y',
+    requirements: 'Z',
+  }, cwd);
+
+  const occurrences = (out.match(/03/g) || []).length;
+  assert.ok(occurrences >= 2, `expected ≥2 occurrences of "03", got ${occurrences}`);
+});
+
+test('TPL-3: numeric value (3) stringifies to "3"', () => {
+  const cwd = makeSandbox({ tiny: 'value={{n}}' });
+  const out = tpl.loadTemplate('tiny', { n: 3 }, cwd);
+  assert.equal(out, 'value=3');
+});
+
+test('TPL-4: boolean true stringifies to "true"', () => {
+  const cwd = makeSandbox({ tiny: 'flag={{b}}' });
+  const out = tpl.loadTemplate('tiny', { b: true }, cwd);
+  assert.equal(out, 'flag=true');
+});
+
+test('TPL-5: empty-string value substitutes empty, does NOT throw', () => {
+  const cwd = makeSandbox({ tiny: 'x={{e}}|y' });
+  const out = tpl.loadTemplate('tiny', { e: '' }, cwd);
+  assert.equal(out, 'x=|y');
+});
+
+test('TPL-6: template with no placeholders returns content unchanged', () => {
+  const content = '# Static\n\nNo placeholders here.\n';
+  const cwd = makeSandbox({ static: content });
+  const out = tpl.loadTemplate('static', {}, cwd);
+  assert.equal(out, content);
+});
+
+test('TPL-7: missing var → throws template-unresolved-var with available keys', () => {
+  const cwd = makeSandbox({ 'phase-context': PHASE_CONTEXT });
+  let thrown = null;
+  try {
+    tpl.loadTemplate('phase-context', { phase_number: '03' }, cwd);
+  } catch (err) {
+    thrown = err;
+  }
+  assert.ok(thrown, 'expected throw');
+  assert.equal(thrown.name, 'NubosPilotError');
+  assert.equal(thrown.code, 'template-unresolved-var');
+  assert.ok(thrown.details, 'details object present');
+  assert.equal(thrown.details.template, 'phase-context');
+  assert.ok(['phase_name', 'goal', 'requirements'].includes(thrown.details.variable),
+    `variable should be one of the missing keys, got ${thrown.details.variable}`);
+  assert.deepEqual(thrown.details.available, ['phase_number']);
+});
+
+test('TPL-8: missing template file → throws template-not-found', () => {
+  const cwd = makeSandbox({});
+  let thrown = null;
+  try {
+    tpl.loadTemplate('missing-name', {}, cwd);
+  } catch (err) {
+    thrown = err;
+  }
+  assert.ok(thrown, 'expected throw');
+  assert.equal(thrown.name, 'NubosPilotError');
+  assert.equal(thrown.code, 'template-not-found');
+  assert.equal(thrown.details.template, 'missing-name');
+  assert.ok(thrown.details.path.endsWith(path.join('templates', 'missing-name.md')),
+    `path should end with templates/missing-name.md, got ${thrown.details.path}`);
+});
+
+test('TPL-9: {{123}} (digit-leading, non-identifier) returns verbatim', () => {
+  const cwd = makeSandbox({ edge: 'before {{123}} after' });
+  const out = tpl.loadTemplate('edge', {}, cwd);
+  assert.equal(out, 'before {{123}} after');
+});
+
+test('TPL-10: {{  spaced  }} (whitespace around identifier) IS a placeholder', () => {
+  const cwd = makeSandbox({ edge: 'x={{  name  }}' });
+  const out = tpl.loadTemplate('edge', { name: 'ok' }, cwd);
+  assert.equal(out, 'x=ok');
+});
+
+test('TPL-11: listTemplates returns sorted basenames without .md', () => {
+  const cwd = makeSandbox({
+    'phase-context': PHASE_CONTEXT,
+    'plan-skeleton': PLAN_SKELETON,
+  });
+  const list = tpl.listTemplates(cwd);
+  assert.deepEqual(list, ['phase-context', 'plan-skeleton']);
+});
+
+test('TPL-12: listTemplates on sandbox without templates dir returns []', () => {
+  const cwd = makeSandbox({});
+  const list = tpl.listTemplates(cwd);
+  assert.deepEqual(list, []);
+});
+
+test('TPL-13: cwd with no .nubos-pilot ancestor → projectStateDir throws not-in-project', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'nubos-pilot-tpl-noroot-'));
+  _sandboxes.push(root);
+  let thrown = null;
+  try {
+    tpl.listTemplates(root);
+  } catch (err) {
+    thrown = err;
+  }
+  assert.ok(thrown, 'expected throw');
+  assert.equal(thrown.name, 'NubosPilotError');
+  assert.equal(thrown.code, 'not-in-project');
+});

package/lib/undo.cjs

@@ -0,0 +1,179 @@
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { NubosPilotError, withFileLocks, atomicWriteFileSync, projectStateDir } = require('./core.cjs');
+const { parseState, serializeState } = require('./state.cjs');
+const {
+  findCommitByTaskId,
+  revertCommit,
+  restoreFiles,
+  listTaskCommits,
+} = require('./git.cjs');
+const {
+  readCheckpoint,
+  deleteCheckpoint,
+  checkpointPath,
+} = require('./checkpoint.cjs');
+const { setTaskStatus, TASK_ID_RE } = require('./tasks.cjs');
+const { paddedPhase } = require('./phase.cjs');
+
+function _statePath(cwd) {
+  return path.join(projectStateDir(cwd), 'STATE.md');
+}
+
+function _findPlanDirForTask(taskId, cwd) {
+
+  
+  const phasesRoot = path.join(projectStateDir(cwd), 'phases');
+  let entries;
+  try {
+    entries = fs.readdirSync(phasesRoot, { withFileTypes: true });
+  } catch (err) {
+    if (err && err.code === 'ENOENT') return null;
+    throw err;
+  }
+  const padded = taskId.slice(0, 2);
+  for (const e of entries) {
+    if (!e.isDirectory()) continue;
+    if (!(e.name === padded || e.name.startsWith(padded + '-'))) continue;
+    const candidate = path.join(phasesRoot, e.name, 'tasks', taskId + '.md');
+    if (fs.existsSync(candidate)) return path.join(phasesRoot, e.name);
+  }
+  return null;
+}
+
+function _extractTaskIdFromSubject(subject) {
+
+  
+  const m = String(subject).match(/^task\(([^)]+)\):/);
+  if (!m) return null;
+  if (!TASK_ID_RE.test(m[1])) return null;
+  return m[1];
+}
+
+function undoTask(id, cwd = process.cwd()) {
+
+  
+
+  const sha = findCommitByTaskId(id);
+
+  
+  try {
+    revertCommit(sha);
+  } catch (err) {
+    throw new NubosPilotError(
+      'undo-revert-conflict',
+      'git revert failed for task ' + id + ' (sha ' + sha + ')',
+      { taskId: id, sha, cause: err && err.message },
+    );
+  }
+  const planDir = _findPlanDirForTask(id, cwd);
+  if (planDir) {
+    try { setTaskStatus(id, 'pending', planDir); }
+    catch (err) {
+
+      
+      process.stderr.write('[nubos-pilot warn] setTaskStatus pending failed for ' + id + ': ' + (err && err.message) + '\n');
+    }
+  }
+  return { task_id: id, reverted_sha: sha };
+}
+
+function resetSlice(cwd = process.cwd()) {
+
+  
+
+  const statePath = _statePath(cwd);
+  const stateBody = fs.readFileSync(statePath, 'utf-8');
+  const state = parseState(stateBody);
+  const currentTask = state.frontmatter && state.frontmatter.current_task;
+  if (currentTask == null) {
+    throw new NubosPilotError(
+      'undo-dirty-tree',
+      'No current_task in STATE.md — nothing to reset',
+      {},
+    );
+  }
+  const cp = readCheckpoint(currentTask, cwd);
+  if (!cp) {
+    throw new NubosPilotError(
+      'checkpoint-orphan',
+      'STATE.current_task=' + currentTask + ' but no checkpoint file',
+      { current_task: currentTask },
+    );
+  }
+  const files = Array.isArray(cp.files_touched) ? cp.files_touched : [];
+  if (files.length > 0) restoreFiles(files);
+
+  const cpPath = checkpointPath(currentTask, cwd);
+  withFileLocks([statePath, cpPath], () => {
+
+    const fresh = parseState(fs.readFileSync(statePath, 'utf-8'));
+    fresh.frontmatter.current_task = null;
+    atomicWriteFileSync(statePath, serializeState(fresh));
+    try { fs.unlinkSync(cpPath); } catch (err) {
+      if (!err || err.code !== 'ENOENT') throw err;
+    }
+  });
+
+  const planDir = _findPlanDirForTask(currentTask, cwd);
+  if (planDir) {
+    try { setTaskStatus(currentTask, 'pending', planDir); }
+    catch (err) {
+      process.stderr.write('[nubos-pilot warn] setTaskStatus pending failed for ' + currentTask + ': ' + (err && err.message) + '\n');
+    }
+  }
+  return { task_id: currentTask, restored_paths: files };
+}
+
+function _undoCommitsBatch(prefix, cwd) {
+
+  
+
+  const commits = listTaskCommits(prefix);
+  if (commits.length === 0) {
+    return { reverted: [], pending_count: 0, message: 'nothing to revert' };
+  }
+  const reverted = [];
+  const taskIds = new Set();
+  for (const c of commits) {
+    revertCommit(c.sha);
+    reverted.push({ sha: c.sha, subject: c.subject });
+    const tid = _extractTaskIdFromSubject(c.subject);
+    if (tid) taskIds.add(tid);
+  }
+
+  for (const tid of taskIds) {
+    const planDir = _findPlanDirForTask(tid, cwd);
+    if (!planDir) continue;
+    try { setTaskStatus(tid, 'pending', planDir); }
+    catch (err) {
+      process.stderr.write('[nubos-pilot warn] setTaskStatus pending failed for ' + tid + ': ' + (err && err.message) + '\n');
+    }
+  }
+  return { reverted, pending_count: taskIds.size };
+}
+
+function undoPlan(planId, cwd = process.cwd()) {
+  if (typeof planId !== 'string' || !/^\d{2}-\d{2}$/.test(planId)) {
+    throw new NubosPilotError(
+      'undo-invalid-plan-id',
+      'undoPlan requires a plan id in NN-NN form, got: ' + planId,
+      { planId },
+    );
+  }
+  return _undoCommitsBatch(planId, cwd);
+}
+
+function undoPhase(n, cwd = process.cwd()) {
+
+  const padded = paddedPhase(n);
+  return _undoCommitsBatch(padded, cwd);
+}
+
+module.exports = {
+  undoTask,
+  undoPlan,
+  undoPhase,
+  resetSlice,
+};

package/lib/undo.test.cjs

@@ -0,0 +1,261 @@
+const { test, after } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { execFileSync } = require('node:child_process');
+
+const undo = require('./undo.cjs');
+const git = require('./git.cjs');
+const cp = require('./checkpoint.cjs');
+
+const _repos = [];
+
+function makeRepo() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-undo-'));
+  execFileSync('git', ['init', '-q', '-b', 'main', root], { stdio: 'pipe' });
+  execFileSync('git', ['-C', root, 'config', 'user.email', 'test@nubos.local']);
+  execFileSync('git', ['-C', root, 'config', 'user.name', 'nubos-test']);
+  execFileSync('git', ['-C', root, 'commit', '--allow-empty', '-q', '-m', 'chore: init'], { stdio: 'pipe' });
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.nubos-pilot', 'STATE.md'), `---
+schema_version: 2
+milestone: m1
+milestone_name: m1
+current_phase: 6
+current_plan: "06-01"
+current_task: null
+last_updated: "2026-04-15T00:00:00Z"
+progress:
+  total_phases: 0
+  completed_phases: 0
+  total_plans: 0
+  completed_plans: 0
+  percent: 0
+session:
+  stopped_at: null
+  resume_file: null
+  last_activity: null
+---
+
+# State
+`, 'utf-8');
+  _repos.push(root);
+  return root;
+}
+
+function seedTask(root, planId, taskId, filesModified) {
+  const phase = planId.slice(0, 2);
+  const phaseDir = path.join(root, '.nubos-pilot', 'phases', phase + '-demo');
+  const tasksDir = path.join(phaseDir, 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+  const fm = [
+    '---',
+    `id: ${taskId}`,
+    `phase: ${Number(phase)}`,
+    `plan: "${planId}"`,
+    'type: auto',
+    'status: done',
+    'tier: sonnet',
+    'owner: np-executor',
+    'wave: 1',
+    'depends_on: []',
+    'files_modified:',
+    ...filesModified.map((f) => `  - ${f}`),
+    'autonomous: true',
+    'must_haves:',
+    '  truths: []',
+    '---',
+    '',
+    '# Task: demo',
+  ].join('\n');
+  fs.writeFileSync(path.join(tasksDir, taskId + '.md'), fm, 'utf-8');
+  return { phaseDir, planDir: phaseDir };
+}
+
+function commitFor(root, taskId, files) {
+  for (const f of files) {
+    const abs = path.join(root, f);
+    fs.mkdirSync(path.dirname(abs), { recursive: true });
+    fs.writeFileSync(abs, 'content for ' + taskId + ' in ' + f, 'utf-8');
+  }
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    git.commitTask(taskId, files, 'task(' + taskId + '): demo');
+  } finally {
+    process.chdir(prev);
+  }
+}
+
+after(() => {
+  while (_repos.length) {
+    const r = _repos.pop();
+    try { fs.rmSync(r, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('UN-1: undoTask reverts the commit and resets task status to pending', () => {
+  const root = makeRepo();
+  seedTask(root, '06-01', '06-01-T01', ['src/a.ts']);
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    commitFor(root, '06-01-T01', ['src/a.ts']);
+    const before = execFileSync('git', ['log', '--format=%H'], { encoding: 'utf-8' }).trim().split('\n').length;
+    const result = undo.undoTask('06-01-T01', root);
+    assert.equal(result.task_id, '06-01-T01');
+    assert.ok(/^[0-9a-f]{40}$/.test(result.reverted_sha));
+    const after = execFileSync('git', ['log', '--format=%H'], { encoding: 'utf-8' }).trim().split('\n').length;
+    assert.equal(after, before + 1, 'a new revert commit should exist');
+
+    const taskFile = path.join(root, '.nubos-pilot', 'phases', '06-demo', 'tasks', '06-01-T01.md');
+    assert.match(fs.readFileSync(taskFile, 'utf-8'), /^status: pending$/m);
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-2: undoTask with malicious task-id format → task-commit-not-found (T-06-17)', () => {
+  const root = makeRepo();
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    assert.throws(
+      () => undo.undoTask('06-99; rm -rf /', root),
+      (err) => err && err.code === 'task-commit-not-found',
+    );
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-3: resetSlice restores files_touched, deletes checkpoint, resets task status', () => {
+  const root = makeRepo();
+  seedTask(root, '06-01', '06-01-T03', ['src/c.ts']);
+
+  const abs = path.join(root, 'src', 'c.ts');
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, 'baseline\n', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    execFileSync('git', ['add', 'src/c.ts'], { stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', 'baseline', '-q'], { stdio: 'pipe' });
+
+    cp.startTask({ id: '06-01-T03', phase: 6, plan: '06-01', wave: 1 }, root);
+    cp.writeCheckpoint('06-01-T03', { files_touched: ['src/c.ts'] }, root);
+
+    fs.writeFileSync(abs, 'dirty work\n', 'utf-8');
+    const result = undo.resetSlice(root);
+    assert.equal(result.task_id, '06-01-T03');
+    assert.deepEqual(result.restored_paths, ['src/c.ts']);
+
+    assert.equal(fs.readFileSync(abs, 'utf-8'), 'baseline\n');
+
+    assert.equal(cp.readCheckpoint('06-01-T03', root), null);
+
+    const stateBody = fs.readFileSync(path.join(root, '.nubos-pilot', 'STATE.md'), 'utf-8');
+    assert.match(stateBody, /current_task: null/);
+
+    const taskFile = path.join(root, '.nubos-pilot', 'phases', '06-demo', 'tasks', '06-01-T03.md');
+    assert.match(fs.readFileSync(taskFile, 'utf-8'), /^status: pending$/m);
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-4: resetSlice with no current_task → undo-dirty-tree', () => {
+  const root = makeRepo();
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    assert.throws(
+      () => undo.resetSlice(root),
+      (err) => err && err.code === 'undo-dirty-tree',
+    );
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-5: resetSlice with current_task but no checkpoint → checkpoint-orphan', () => {
+  const root = makeRepo();
+
+  const sp = path.join(root, '.nubos-pilot', 'STATE.md');
+  const body = fs.readFileSync(sp, 'utf-8').replace(/current_task: null/, 'current_task: "06-01-T07"');
+  fs.writeFileSync(sp, body, 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    assert.throws(
+      () => undo.resetSlice(root),
+      (err) => err && err.code === 'checkpoint-orphan',
+    );
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-6: undoPlan reverts all task commits in reverse chronological order', () => {
+  const root = makeRepo();
+  seedTask(root, '06-01', '06-01-T01', ['src/p1.ts']);
+  seedTask(root, '06-01', '06-01-T02', ['src/p2.ts']);
+  seedTask(root, '06-01', '06-01-T03', ['src/p3.ts']);
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    commitFor(root, '06-01-T01', ['src/p1.ts']);
+    commitFor(root, '06-01-T02', ['src/p2.ts']);
+    commitFor(root, '06-01-T03', ['src/p3.ts']);
+    const result = undo.undoPlan('06-01', root);
+    assert.equal(result.reverted.length, 3);
+
+    const revertCount = execFileSync('git', ['log', '--grep=^Revert', '--format=%H'], { encoding: 'utf-8' })
+      .trim().split('\n').filter(Boolean).length;
+    assert.equal(revertCount, 3);
+
+    for (const id of ['06-01-T01', '06-01-T02', '06-01-T03']) {
+      const tf = path.join(root, '.nubos-pilot', 'phases', '06-demo', 'tasks', id + '.md');
+      assert.match(fs.readFileSync(tf, 'utf-8'), /^status: pending$/m, id);
+    }
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-7: undoPlan with nothing committed → emit nothing-to-revert', () => {
+  const root = makeRepo();
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    const result = undo.undoPlan('06-99', root);
+    assert.deepEqual(result.reverted, []);
+    assert.equal(result.message, 'nothing to revert');
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-8: undoPhase reverts all plans of the phase', () => {
+  const root = makeRepo();
+  seedTask(root, '06-01', '06-01-T01', ['src/q1.ts']);
+  seedTask(root, '06-02', '06-02-T01', ['src/q2.ts']);
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    commitFor(root, '06-01-T01', ['src/q1.ts']);
+    commitFor(root, '06-02-T01', ['src/q2.ts']);
+    const result = undo.undoPhase(6, root);
+    assert.equal(result.reverted.length, 2);
+  } finally {
+    process.chdir(prev);
+  }
+});
+
+test('UN-9: exports', () => {
+  assert.equal(typeof undo.undoTask, 'function');
+  assert.equal(typeof undo.undoPlan, 'function');
+  assert.equal(typeof undo.undoPhase, 'function');
+  assert.equal(typeof undo.resetSlice, 'function');
+});