nubos-pilot 1.3.0 → 1.3.2

package/lib/cache-align.test.cjs

@@ -0,0 +1,69 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const ca = require('./cache-align.cjs');
+
+test('CA-1: detectVolatile flags UUID/ISO-date/JWT/hex in the system prompt', () => {
+  const sys = 'Run id 550e8400-e29b-41d4-a716-446655440000 at 2026-06-23T10:00:00Z '
+    + 'token eyJhbGc.eyJzdWI.sig hash d41d8cd98f00b204e9800998ecf8427e';
+  const kinds = ca.detectVolatile(sys).map((f) => f.kind).sort();
+  assert.deepEqual(kinds, ['hex_hash', 'iso_datetime', 'jwt', 'uuid']);
+});
+
+test('CA-2: detectVolatile reads an array-form system prompt and is clean when stable', () => {
+  assert.deepEqual(ca.detectVolatile([{ type: 'text', text: 'You are a stable agent.' }]), []);
+  assert.deepEqual(ca.detectVolatile('plain stable instructions'), []);
+});
+
+test('CA-3: normalizeTools sorts tools by name and recursively sorts schema keys; arrays keep order', () => {
+  const tools = [
+    { name: 'zeta', description: 'z', input_schema: { type: 'object', required: ['b', 'a'], properties: { y: {}, x: {} } } },
+    { name: 'alpha', description: 'a', input_schema: { properties: { n: {} }, type: 'object' } },
+  ];
+  const out = ca.normalizeTools(tools);
+  assert.deepEqual(out.map((t) => t.name), ['alpha', 'zeta']);
+  assert.deepEqual(Object.keys(out[1]), ['description', 'input_schema', 'name']);
+  assert.deepEqual(Object.keys(out[1].input_schema.properties), ['x', 'y']);
+  assert.deepEqual(out[1].input_schema.required, ['b', 'a']);
+});
+
+test('CA-4: alignAnthropicBody adds exactly one ephemeral breakpoint on the last tool and is idempotent', () => {
+  const body = { system: 'sys', tools: [{ name: 'b' }, { name: 'a' }], messages: [] };
+  const r1 = ca.alignAnthropicBody(body);
+  assert.equal(r1.applied, true);
+  assert.deepEqual(r1.body.tools.map((t) => t.name), ['a', 'b']);
+  assert.equal(r1.body.tools[0].cache_control, undefined);
+  assert.deepEqual(r1.body.tools[1].cache_control, { type: 'ephemeral' });
+  const r2 = ca.alignAnthropicBody(r1.body);
+  assert.equal(r2.applied, false, 'second pass is a no-op — breakpoint already present');
+  assert.equal(JSON.stringify(r2.body), JSON.stringify(r1.body), 'byte-identical second pass');
+});
+
+test('CA-4b: normalizeTools is byte-deterministic regardless of input order (codepoint, not locale)', () => {
+  const a = [{ name: 'get_A' }, { name: 'get-a' }, { name: 'get_a' }, { name: 'tool10' }, { name: 'tool2' }];
+  const b = a.slice().reverse();
+  assert.equal(JSON.stringify(ca.normalizeTools(a)), JSON.stringify(ca.normalizeTools(b)), 'order-independent, stable bytes');
+  assert.deepEqual(ca.normalizeTools(a).map((t) => t.name), ['get-a', 'get_A', 'get_a', 'tool10', 'tool2']);
+});
+
+test('CA-4c: duplicate/degenerate names still order deterministically via body tiebreak', () => {
+  const x = [{ name: 'x', id: 2 }, { name: 'x', id: 1 }];
+  assert.equal(JSON.stringify(ca.normalizeTools(x)), JSON.stringify(ca.normalizeTools(x.slice().reverse())));
+});
+
+test('CA-5: customer-placement-wins — a caller-set cache_control is never disturbed', () => {
+  const body = { tools: [{ name: 'z', cache_control: { type: 'ephemeral' } }, { name: 'a' }], messages: [] };
+  const r = ca.alignAnthropicBody(body);
+  assert.equal(r.applied, false);
+  assert.deepEqual(r.body.tools.map((t) => t.name), ['z', 'a'], 'tool order untouched when caller manages caching');
+});
+
+test('CA-6: no tools → no normalization, detection still runs', () => {
+  const body = { system: 'id 550e8400-e29b-41d4-a716-446655440000', messages: [] };
+  const r = ca.alignAnthropicBody(body);
+  assert.equal(r.applied, false);
+  assert.equal(r.body, body);
+  assert.deepEqual(r.findings.map((f) => f.kind), ['uuid']);
+});

package/lib/checkpoint-reconcile.cjs

@@ -0,0 +1,42 @@
+const path = require('node:path');
+const { listCheckpoints, deleteCheckpoint } = require('./checkpoint.cjs');
+const { findCommitByTaskId } = require('./git.cjs');
+const { TASK_ID_RE } = require('./ids.cjs');
+
+function committedSha(taskId, cwd) {
+  try {
+    return findCommitByTaskId(taskId, cwd);
+  } catch {
+    return null;
+  }
+}
+
+function reconcileCommittedCheckpoints(cwd = process.cwd(), opts = {}) {
+  const exclude = opts.exclude || null;
+  const pruned = [];
+  const remaining = [];
+  for (const file of listCheckpoints(cwd)) {
+    const taskId = path.basename(file, '.json');
+    if (!TASK_ID_RE.test(taskId)) {
+      remaining.push(taskId);
+      continue;
+    }
+    if (exclude && taskId === exclude) {
+      remaining.push(taskId);
+      continue;
+    }
+    const sha = committedSha(taskId, cwd);
+    if (sha) {
+      deleteCheckpoint(taskId, cwd);
+      pruned.push({ task_id: taskId, sha });
+    } else {
+      remaining.push(taskId);
+    }
+  }
+  return { pruned, remaining };
+}
+
+module.exports = {
+  committedSha,
+  reconcileCommittedCheckpoints,
+};

package/lib/checkpoint-reconcile.test.cjs

@@ -0,0 +1,106 @@
+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 { startTask, listCheckpoints } = require('./checkpoint.cjs');
+const { reconcileCommittedCheckpoints, committedSha } = require('./checkpoint-reconcile.cjs');
+
+const _repos = [];
+
+function makeRepo() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-cr-'));
+  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: null
+current_plan: null
+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 commitFor(root, taskId) {
+  execFileSync('git', ['-C', root, 'commit', '--allow-empty', '-q', '-m', `task(${taskId}): demo`], { stdio: 'pipe' });
+}
+
+after(() => {
+  while (_repos.length) {
+    const r = _repos.pop();
+    try { fs.rmSync(r, { recursive: true, force: true }); } catch {}
+  }
+});
+
+test('CR-1: prunes a checkpoint whose task already has a commit', () => {
+  const root = makeRepo();
+  startTask({ id: 'M013-S005-T0002', phase: 6, plan: '06-01', wave: 1 }, root);
+  commitFor(root, 'M013-S005-T0002');
+
+  const { pruned, remaining } = reconcileCommittedCheckpoints(root);
+  assert.equal(pruned.length, 1);
+  assert.equal(pruned[0].task_id, 'M013-S005-T0002');
+  assert.match(pruned[0].sha, /^[0-9a-f]{40}$/);
+  assert.deepEqual(remaining, []);
+  assert.deepEqual(listCheckpoints(root), []);
+});
+
+test('CR-2: keeps a checkpoint with no matching commit (genuine orphan)', () => {
+  const root = makeRepo();
+  startTask({ id: 'M013-S005-T0003', phase: 6, plan: '06-01', wave: 1 }, root);
+
+  const { pruned, remaining } = reconcileCommittedCheckpoints(root);
+  assert.deepEqual(pruned, []);
+  assert.deepEqual(remaining, ['M013-S005-T0003']);
+  assert.equal(listCheckpoints(root).length, 1);
+});
+
+test('CR-3: excludes the active current_task even when committed', () => {
+  const root = makeRepo();
+  startTask({ id: 'M013-S005-T0004', phase: 6, plan: '06-01', wave: 1 }, root);
+  commitFor(root, 'M013-S005-T0004');
+
+  const { pruned, remaining } = reconcileCommittedCheckpoints(root, { exclude: 'M013-S005-T0004' });
+  assert.deepEqual(pruned, []);
+  assert.deepEqual(remaining, ['M013-S005-T0004']);
+  assert.equal(listCheckpoints(root).length, 1);
+});
+
+test('CR-4: prunes committed tombstone but keeps uncommitted sibling', () => {
+  const root = makeRepo();
+  startTask({ id: 'M013-S005-T0002', phase: 6, plan: '06-01', wave: 1 }, root);
+  startTask({ id: 'M013-S005-T0003', phase: 6, plan: '06-01', wave: 1 }, root);
+  commitFor(root, 'M013-S005-T0002');
+
+  const { pruned, remaining } = reconcileCommittedCheckpoints(root);
+  assert.deepEqual(pruned.map((p) => p.task_id), ['M013-S005-T0002']);
+  assert.deepEqual(remaining, ['M013-S005-T0003']);
+});
+
+test('CR-5: committedSha returns null outside a git repo (no throw)', () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-cr-nogit-'));
+  _repos.push(root);
+  assert.equal(committedSha('M013-S005-T0002', root), null);
+});