nubos-pilot 1.3.1 → 1.3.3

package/bin/np-tools/simplify-debt.test.cjs

@@ -0,0 +1,99 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { test, afterEach } = require('node:test');
+const assert = require('node:assert/strict');
+
+const subcmd = require('./simplify-debt.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-simplify-debt-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  _sandboxes.push(root);
+  return root;
+}
+
+function capture(fn) {
+  const out = [];
+  const orig = process.stdout.write.bind(process.stdout);
+  process.stdout.write = (c) => { out.push(String(c)); return true; };
+  let rc;
+  try { rc = fn(); } finally { process.stdout.write = orig; }
+  return { stdout: out.join(''), rc };
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    try { fs.rmSync(_sandboxes.pop(), { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+});
+
+test('SD-1: add records an entry and reports was_new', () => {
+  const cwd = makeSandbox();
+  const { stdout, rc } = capture(() =>
+    subcmd.run(['add', '--file', 'src/foo.ts', '--line', '42', '--category', 'over-engineering', '--note', 'inline the factory'], { cwd }),
+  );
+  assert.equal(rc, 0);
+  const res = JSON.parse(stdout);
+  assert.equal(res.ok, true);
+  assert.equal(res.action, 'add');
+  assert.equal(res.was_new, true);
+  assert.equal(res.entry.category, 'over-engineering');
+});
+
+test('SD-2: add accepts the note as positional args', () => {
+  const cwd = makeSandbox();
+  const { stdout, rc } = capture(() =>
+    subcmd.run(['add', '--category', 'shrinkable', 'collapse', 'this', 'loop'], { cwd }),
+  );
+  assert.equal(rc, 0);
+  assert.equal(JSON.parse(stdout).entry.note, 'collapse this loop');
+});
+
+test('SD-3: list (default open) renders the ledger', () => {
+  const cwd = makeSandbox();
+  capture(() => subcmd.run(['add', '--file', 'a.ts', '--category', 'shrinkable', '--note', 'use reduce'], { cwd }));
+  const { stdout, rc } = capture(() => subcmd.run(['list'], { cwd }));
+  assert.equal(rc, 0);
+  assert.match(stdout, /shrinkable/);
+  assert.match(stdout, /1 open/);
+});
+
+test('SD-4: list --json emits structured entries', () => {
+  const cwd = makeSandbox();
+  capture(() => subcmd.run(['add', '--file', 'a.ts', '--category', 'shrinkable', '--note', 'x'], { cwd }));
+  const { stdout } = capture(() => subcmd.run(['list', '--json'], { cwd }));
+  const res = JSON.parse(stdout);
+  assert.equal(res.count, 1);
+  assert.equal(res.entries[0].category, 'shrinkable');
+});
+
+test('SD-5: no-arg defaults to list', () => {
+  const cwd = makeSandbox();
+  const { stdout, rc } = capture(() => subcmd.run([], { cwd }));
+  assert.equal(rc, 0);
+  assert.match(stdout, /empty|Lean already/i);
+});
+
+test('SD-6: resolve moves an entry to resolved', () => {
+  const cwd = makeSandbox();
+  const added = capture(() => subcmd.run(['add', '--file', 'a.ts', '--category', 'native-duplication', '--note', 'reuse helper'], { cwd }));
+  const id = JSON.parse(added.stdout).entry.id;
+  const { stdout, rc } = capture(() => subcmd.run(['resolve', id], { cwd }));
+  assert.equal(rc, 0);
+  assert.equal(JSON.parse(stdout).entry.status, 'resolved');
+  const open = capture(() => subcmd.run(['list', '--json'], { cwd }));
+  assert.equal(JSON.parse(open.stdout).count, 0);
+});
+
+test('SD-7: unknown verb throws', () => {
+  const cwd = makeSandbox();
+  assert.throws(
+    () => subcmd.run(['frobnicate'], { cwd }),
+    (err) => err && err.name === 'NubosPilotError' && err.code === 'simplify-debt-unknown-verb',
+  );
+});

package/lib/agents-registry.cjs

@@ -6,8 +6,9 @@ const LEGACY_CRITIC_AXIS_AGENTS = Object.freeze([
   'np-critic-style',
   'np-critic-tests',
   'np-critic-acceptance',
+  'np-critic-economy',
 ]);
-const SUPPORTED_CRITIC_AXES = Object.freeze(['critic', 'style', 'tests', 'acceptance']);
+const SUPPORTED_CRITIC_AXES = Object.freeze(['critic', 'style', 'tests', 'acceptance', 'economy']);
 
 const EXECUTOR_AGENT = 'np-executor';
 const BUILD_FIXER_AGENT = 'np-build-fixer';

package/lib/agents.test.cjs

@@ -248,6 +248,7 @@ const NP_AGENTS = [
   { file: 'np-sc-extractor', expected_tier: 'haiku' },
   { file: 'np-critic', expected_tier: 'sonnet' },
   { file: 'np-learnings-extractor', expected_tier: 'haiku' },
+  { file: 'np-simplifier', expected_tier: 'sonnet' },
 ];
 
 // Audit-surface modules — files in agents/ that carry agent-shaped frontmatter
@@ -257,6 +258,7 @@ const NP_AGENT_MODULES = [
   { file: 'np-critic-style', parent: 'np-critic' },
   { file: 'np-critic-tests', parent: 'np-critic' },
   { file: 'np-critic-acceptance', parent: 'np-critic' },
+  { file: 'np-critic-economy', parent: 'np-critic' },
 ];
 
 for (let i = 0; i < NP_AGENTS.length; i += 1) {

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);
+});

package/lib/config-defaults.cjs

@@ -18,6 +18,10 @@ const DEFAULT_AGENTS = Object.freeze({
   research: true,
   plan_checker: true,
   verifier: true,
+  // Economy axis level (off|lite|full|ultra). Default `lite` = prevention-first:
+  // the climb-the-ladder discipline is on, the in-loop critic is opt-in (full/ultra).
+  // Resolved via lib/economy-mode.cjs; legacy `economy_critic` bool still honoured.
+  economy: 'lite',
 });
 
 const DEFAULT_LOOP = Object.freeze({
@@ -35,6 +39,7 @@ const DEFAULT_SWARM_CRITIC = Object.freeze({
   style_tier: 'haiku',
   tests_tier: 'sonnet',
   acceptance_tier: 'sonnet',
+  economy_tier: 'haiku',
 });
 
 const DEFAULT_SWARM = Object.freeze({
@@ -118,6 +123,13 @@ const DEFAULT_MODEL_PROFILE = 'frontier';
 const DEFAULT_SCOPE = 'local';
 const DEFAULT_RESPONSE_LANGUAGE = 'en';
 
+// Install/update ships the most aggressive Economy level by default. This is the
+// value written into a fresh config.json (and backfilled into keyless configs on
+// update — see bin/install.js). It deliberately differs from the *resolved*
+// fallback in DEFAULT_AGENTS.economy (`lite`): a config with the key absent
+// entirely stays conservative, but anything nubos-pilot writes opts into ultra.
+const INSTALL_ECONOMY_MODE = 'ultra';
+
 const DEFAULT_CONFIG_TREE = Object.freeze({
   scope: DEFAULT_SCOPE,
   model_profile: DEFAULT_MODEL_PROFILE,
@@ -147,7 +159,7 @@ function buildInstallConfig(answers) {
     model_profile: a.model_profile || DEFAULT_MODEL_PROFILE,
     response_language: a.response_language || DEFAULT_RESPONSE_LANGUAGE,
     workflow: workflowOverride,
-    agents: { ...DEFAULT_AGENTS },
+    agents: { ...DEFAULT_AGENTS, economy: INSTALL_ECONOMY_MODE },
     loop: { ...DEFAULT_LOOP },
     swarm: {
       research: { ...DEFAULT_SWARM_RESEARCH },
@@ -191,6 +203,7 @@ module.exports = {
   DEFAULT_MODEL_PROFILE,
   DEFAULT_SCOPE,
   DEFAULT_RESPONSE_LANGUAGE,
+  INSTALL_ECONOMY_MODE,
   DEFAULT_CONFIG_TREE,
   buildInstallConfig,
 };

package/lib/config-defaults.test.cjs

@@ -6,8 +6,17 @@ const {
   DEFAULT_WORKFLOW,
   DEFAULT_MODEL_PROFILE,
   DEFAULT_SCOPE,
+  DEFAULT_CONFIG_TREE,
+  INSTALL_ECONOMY_MODE,
 } = require('./config-defaults.cjs');
 
+test('CFD-economy: install writes economy=ultra, but the resolved fallback stays lite', () => {
+  assert.equal(INSTALL_ECONOMY_MODE, 'ultra');
+  assert.equal(buildInstallConfig({ runtime: 'claude' }).agents.economy, 'ultra');
+  // The keyless resolved fallback is intentionally conservative.
+  assert.equal(DEFAULT_CONFIG_TREE.agents.economy, 'lite');
+});
+
 test('CFD-1: buildInstallConfig defaults preserve commit_artifacts:true (back-compat)', () => {
   const cfg = buildInstallConfig({ runtime: 'claude' });
   assert.equal(cfg.workflow.commit_artifacts, true);

package/lib/config-schema.cjs

@@ -5,6 +5,7 @@ const VALID_SCOPES = Object.freeze(['local', 'global']);
 const VALID_MODEL_PROFILES = Object.freeze(['frontier', 'quality', 'balanced', 'budget', 'inherit']);
 const VALID_KNOWLEDGE_ADAPTERS = Object.freeze(['local']);
 const VALID_TIERS = Object.freeze(['haiku', 'sonnet', 'opus']);
+const { VALID_ECONOMY_MODES } = require('./economy-mode.cjs');
 
 const SCHEMA = Object.freeze({
   scope:            { type: 'enum', values: VALID_SCOPES, optional: true },
@@ -32,6 +33,8 @@ const SCHEMA = Object.freeze({
       research:        { type: 'boolean', optional: true },
       plan_checker:    { type: 'boolean', optional: true },
       verifier:        { type: 'boolean', optional: true },
+      economy:         { type: 'enum', values: VALID_ECONOMY_MODES, optional: true },
+      economy_critic:  { type: 'boolean', optional: true },
     },
   },
   loop: {
@@ -54,6 +57,7 @@ const SCHEMA = Object.freeze({
           style_tier:      { type: 'enum', values: VALID_TIERS, optional: true },
           tests_tier:      { type: 'enum', values: VALID_TIERS, optional: true },
           acceptance_tier: { type: 'enum', values: VALID_TIERS, optional: true },
+          economy_tier:    { type: 'enum', values: VALID_TIERS, optional: true },
         },
       },
       knowledge_adapter: { type: 'enum', values: VALID_KNOWLEDGE_ADAPTERS, optional: true },

package/lib/economy-debt.cjs

@@ -0,0 +1,235 @@
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const { projectStateDir, NubosPilotError } = require('./core.cjs');
+const { slugify } = require('./layout.cjs');
+const { extractFrontmatter } = require('./frontmatter.cjs');
+
+// The economy-debt ledger records simplifications a reviewer chose to DEFER
+// rather than fix now — the manual twin of the in-loop Economy critic
+// (agents.economy ∈ {full,ultra}). It exists so "later" does not become "never":
+// /np:simplify-review surfaces over-build, and what is not fixed this round is
+// harvested here. Categories mirror the canonical four economy routes in
+// lib/nubosloop.cjs::ROUTE_TABLE and agents/np-critic-economy.md — keep in sync.
+const ECONOMY_CATEGORIES = Object.freeze([
+  'over-engineering',
+  'stdlib-reinvention',
+  'native-duplication',
+  'shrinkable',
+]);
+
+const STATUSES = Object.freeze(['open', 'resolved']);
+const MAX_NOTE_LENGTH = 500;
+const ID_LENGTH = 7;
+
+function debtRoot(cwd) {
+  return path.join(projectStateDir(cwd || process.cwd()), 'economy-debt');
+}
+
+function statusDir(status, cwd) {
+  return path.join(debtRoot(cwd), status);
+}
+
+function _entryId(file, line, category, note) {
+  const key = String(file) + ':' + String(line) + ':' + String(category) + ':' + String(note);
+  return crypto.createHash('sha1').update(key, 'utf-8').digest('hex').slice(0, ID_LENGTH);
+}
+
+function _composeMd(entry) {
+  const fm = [
+    '---',
+    'id: ' + entry.id,
+    'category: ' + entry.category,
+    'file: ' + entry.file,
+    'line: ' + entry.line,
+    'created: ' + entry.created,
+    'status: ' + entry.status,
+  ];
+  if (entry.resolved) fm.push('resolved: ' + entry.resolved);
+  fm.push('---');
+  return fm.join('\n') + '\n' + entry.note + '\n';
+}
+
+function _parseEntry(filePath) {
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const { frontmatter, body } = extractFrontmatter(raw);
+  const lineRaw = frontmatter.line;
+  const lineNum = Number.parseInt(lineRaw, 10);
+  return {
+    id: frontmatter.id != null ? String(frontmatter.id) : '',
+    category: frontmatter.category != null ? String(frontmatter.category) : '',
+    file: frontmatter.file != null ? String(frontmatter.file) : '',
+    line: Number.isFinite(lineNum) ? lineNum : 0,
+    created: frontmatter.created != null ? String(frontmatter.created) : '',
+    resolved: frontmatter.resolved != null ? String(frontmatter.resolved) : '',
+    status: frontmatter.status != null ? String(frontmatter.status) : '',
+    note: String(body || '').trim(),
+    path: filePath,
+  };
+}
+
+function _validateInput(input) {
+  const file = input && input.file != null ? String(input.file).trim() : '';
+  const note = input && input.note != null ? String(input.note).trim() : '';
+  const category = input && input.category != null ? String(input.category).trim() : '';
+  if (!note) {
+    throw new NubosPilotError(
+      'economy-debt-missing-note',
+      'economy-debt entry requires a non-empty note',
+      {},
+    );
+  }
+  if (note.length > MAX_NOTE_LENGTH) {
+    throw new NubosPilotError(
+      'economy-debt-note-too-long',
+      'economy-debt note must be <= ' + MAX_NOTE_LENGTH + ' chars',
+      { length: note.length },
+    );
+  }
+  if (!ECONOMY_CATEGORIES.includes(category)) {
+    throw new NubosPilotError(
+      'economy-debt-invalid-category',
+      'economy-debt category must be one of: ' + ECONOMY_CATEGORIES.join(', '),
+      { category, valid: ECONOMY_CATEGORIES.slice() },
+    );
+  }
+  let line = 0;
+  if (input && input.line != null && String(input.line).trim() !== '') {
+    line = Number.parseInt(input.line, 10);
+    if (!Number.isFinite(line) || line < 0) {
+      throw new NubosPilotError(
+        'economy-debt-invalid-line',
+        'economy-debt line must be a non-negative integer',
+        { line: input.line },
+      );
+    }
+  }
+  return { file, note, category, line };
+}
+
+/**
+ * Append a deferred-simplification entry to the open ledger. Idempotent: an
+ * identical (file, line, category, note) maps to the same id and is not
+ * duplicated — a re-harvest of the same finding is a no-op, returning the
+ * existing entry with `created: false`.
+ * @returns {{id, category, file, line, created, status, path, was_new: boolean}}
+ */
+function addEntry(input, cwd) {
+  const { file, note, category, line } = _validateInput(input);
+  const id = _entryId(file, line, category, note);
+  const openDir = statusDir('open', cwd);
+  const resolvedDir = statusDir('resolved', cwd);
+  const slug = slugify(note).slice(0, 48) || 'entry';
+  const fileName = id + '-' + slug + '.md';
+
+  // already open, or already resolved — either way this finding is on record
+  const existingOpen = _findById(id, 'open', cwd);
+  if (existingOpen) return Object.assign({}, _parseEntry(existingOpen), { was_new: false });
+  const existingResolved = _findById(id, 'resolved', cwd);
+  if (existingResolved) return Object.assign({}, _parseEntry(existingResolved), { was_new: false });
+
+  fs.mkdirSync(openDir, { recursive: true });
+  const entry = {
+    id,
+    category,
+    file,
+    line,
+    created: new Date().toISOString(),
+    status: 'open',
+    note,
+  };
+  const target = path.join(openDir, fileName);
+  fs.writeFileSync(target, _composeMd(entry), 'utf-8');
+  void resolvedDir;
+  return Object.assign({}, entry, { path: target, was_new: true });
+}
+
+function _findById(id, status, cwd) {
+  const dir = statusDir(status, cwd);
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return null;
+  }
+  const hit = names.find((n) => n.endsWith('.md') && n.slice(0, ID_LENGTH) === id);
+  return hit ? path.join(dir, hit) : null;
+}
+
+/**
+ * List ledger entries. status: 'open' | 'resolved' | 'all'. Sorted by created
+ * ascending (oldest debt first — the longest-deferred is the most urgent).
+ */
+function listEntries(status, cwd) {
+  const want = status || 'open';
+  const dirs = want === 'all' ? STATUSES.slice() : [want];
+  if (want !== 'all' && !STATUSES.includes(want)) {
+    throw new NubosPilotError(
+      'economy-debt-invalid-status',
+      "economy-debt status must be 'open', 'resolved', or 'all'",
+      { status: want },
+    );
+  }
+  const out = [];
+  for (const d of dirs) {
+    const dir = statusDir(d, cwd);
+    let names;
+    try {
+      names = fs.readdirSync(dir);
+    } catch {
+      continue;
+    }
+    for (const n of names) {
+      if (!n.endsWith('.md')) continue;
+      out.push(_parseEntry(path.join(dir, n)));
+    }
+  }
+  out.sort((a, b) => (a.created < b.created ? -1 : a.created > b.created ? 1 : 0));
+  return out;
+}
+
+/**
+ * Mark an open entry resolved: stamp `resolved` + flip status, then move the
+ * file from open/ to resolved/. Throws economy-debt-not-found if no open entry
+ * carries the id.
+ */
+function resolveEntry(id, cwd) {
+  const wanted = String(id || '').trim();
+  if (!wanted) {
+    throw new NubosPilotError('economy-debt-missing-id', 'resolve requires an entry id', {});
+  }
+  const src = _findById(wanted, 'open', cwd);
+  if (!src) {
+    throw new NubosPilotError(
+      'economy-debt-not-found',
+      'no open economy-debt entry with id: ' + wanted,
+      { id: wanted },
+    );
+  }
+  const entry = _parseEntry(src);
+  entry.resolved = new Date().toISOString();
+  entry.status = 'resolved';
+  const resolvedDir = statusDir('resolved', cwd);
+  fs.mkdirSync(resolvedDir, { recursive: true });
+  const target = path.join(resolvedDir, path.basename(src));
+  fs.writeFileSync(target, _composeMd(entry), 'utf-8');
+  fs.rmSync(src);
+  return Object.assign({}, entry, { path: target });
+}
+
+module.exports = {
+  ECONOMY_CATEGORIES,
+  STATUSES,
+  MAX_NOTE_LENGTH,
+  debtRoot,
+  statusDir,
+  addEntry,
+  listEntries,
+  resolveEntry,
+  _entryId,
+  _parseEntry,
+  _composeMd,
+};