nubos-pilot 1.3.2 → 1.3.4

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

@@ -0,0 +1,91 @@
+'use strict';
+
+const { NubosPilotError } = require('../../lib/core.cjs');
+const debt = require('../../lib/economy-debt.cjs');
+
+function _parseFlags(list) {
+  const out = { _: [], file: null, line: null, category: null, note: null, status: null, json: false };
+  for (let i = 0; i < list.length; i++) {
+    const a = list[i];
+    if (a === '--json') out.json = true;
+    else if (a === '--file') out.file = list[++i];
+    else if (a.startsWith('--file=')) out.file = a.slice('--file='.length);
+    else if (a === '--line') out.line = list[++i];
+    else if (a.startsWith('--line=')) out.line = a.slice('--line='.length);
+    else if (a === '--category') out.category = list[++i];
+    else if (a.startsWith('--category=')) out.category = a.slice('--category='.length);
+    else if (a === '--note') out.note = list[++i];
+    else if (a.startsWith('--note=')) out.note = a.slice('--note='.length);
+    else if (a === '--status') out.status = list[++i];
+    else if (a.startsWith('--status=')) out.status = a.slice('--status='.length);
+    else out._.push(a);
+  }
+  return out;
+}
+
+function _renderList(entries, status) {
+  if (entries.length === 0) {
+    return status === 'resolved'
+      ? 'No resolved economy-debt entries.'
+      : 'Economy-debt ledger is empty. Lean already.';
+  }
+  const lines = entries.map((e) => {
+    const where = e.line > 0 ? e.file + ':' + e.line : (e.file || '(no file)');
+    const mark = e.status === 'resolved' ? '[x]' : '[ ]';
+    return mark + ' ' + e.id + '  ' + e.category.padEnd(18) + ' ' + where + '\n      ' + e.note;
+  });
+  const open = entries.filter((e) => e.status === 'open').length;
+  const resolved = entries.length - open;
+  lines.push('');
+  lines.push('total: ' + entries.length + ' (' + open + ' open, ' + resolved + ' resolved)');
+  return lines.join('\n');
+}
+
+function run(args, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const list = Array.isArray(args) ? args : [];
+  const verb = (list[0] || 'list').trim();
+  const flags = _parseFlags(list.slice(1));
+
+  if (verb === 'add') {
+    const note = flags.note != null ? flags.note : flags._.join(' ');
+    const entry = debt.addEntry(
+      { file: flags.file, line: flags.line, category: flags.category, note },
+      cwd,
+    );
+    stdout.write(JSON.stringify({ ok: true, action: 'add', was_new: entry.was_new, entry }) + '\n');
+    return 0;
+  }
+
+  if (verb === 'resolve') {
+    const id = flags._[0];
+    const entry = debt.resolveEntry(id, cwd);
+    stdout.write(JSON.stringify({ ok: true, action: 'resolve', entry }) + '\n');
+    return 0;
+  }
+
+  if (verb === 'list') {
+    const status = flags.status || 'open';
+    const entries = debt.listEntries(status, cwd);
+    if (flags.json) {
+      stdout.write(JSON.stringify({ ok: true, action: 'list', status, count: entries.length, entries }, null, 2) + '\n');
+    } else {
+      stdout.write(_renderList(entries, status) + '\n');
+    }
+    return 0;
+  }
+
+  throw new NubosPilotError(
+    'simplify-debt-unknown-verb',
+    "simplify-debt verb must be 'add', 'list', or 'resolve' (got: " + verb + ')',
+    { verb },
+  );
+}
+
+module.exports = { run, _parseFlags, _renderList };
+
+if (require.main === module) {
+  process.exit(run(process.argv.slice(2)));
+}

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,14 +6,23 @@ 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';
 
 const RESEARCHER_AGENT = 'np-researcher';
 
+// Round-1 preparation agents that run between the researcher swarm and the
+// executor. Config-gated (agents.architect / agents.test_writer). They get
+// Layer-C spawn-evidence stamps but are NOT Rule-9 audited (not in
+// AUDITED_AGENTS) — the architect is advisory/read-only and the test-writer's
+// quality is enforced downstream by the np-critic-tests axis.
+const TASK_ARCHITECT_AGENT = 'np-task-architect';
+const TEST_WRITER_AGENT = 'np-test-writer';
+
 const AUDITED_AGENTS = Object.freeze([
   EXECUTOR_AGENT,
   BUILD_FIXER_AGENT,
@@ -28,5 +37,7 @@ module.exports = {
   EXECUTOR_AGENT,
   BUILD_FIXER_AGENT,
   RESEARCHER_AGENT,
+  TASK_ARCHITECT_AGENT,
+  TEST_WRITER_AGENT,
   AUDITED_AGENTS,
 };

package/lib/agents.test.cjs

@@ -242,12 +242,15 @@ const NP_AGENTS = [
   { file: 'np-researcher-reconciler', expected_tier: 'sonnet' },
   { file: 'np-codebase-documenter', expected_tier: 'sonnet' },
   { file: 'np-architect', expected_tier: 'sonnet' },
+  { file: 'np-task-architect', expected_tier: 'sonnet' },
+  { file: 'np-test-writer', expected_tier: 'sonnet' },
   { file: 'np-build-fixer', expected_tier: 'sonnet' },
   { file: 'np-security-reviewer', expected_tier: 'sonnet' },
   { file: 'np-nyquist-auditor', expected_tier: 'haiku' },
   { 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 +260,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/config-defaults.cjs

@@ -18,6 +18,18 @@ const DEFAULT_AGENTS = Object.freeze({
   research: true,
   plan_checker: true,
   verifier: true,
+  // Per-task architecture step in the Nubosloop (np-task-architect). Runs in
+  // round 1 after the researcher swarm, before the test-writer and executor.
+  // Backfilled to true on install/update when absent (see bin/install.js).
+  architect: true,
+  // Per-task TDD step (np-test-writer). Runs in round 1 after the architect,
+  // before the executor — writes the tests the executor must make green.
+  // Backfilled to true on install/update when absent (see bin/install.js).
+  test_writer: 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 +47,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 +131,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 +167,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 +211,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,10 @@ const SCHEMA = Object.freeze({
       research:        { type: 'boolean', optional: true },
       plan_checker:    { type: 'boolean', optional: true },
       verifier:        { type: 'boolean', optional: true },
+      architect:       { type: 'boolean', optional: true },
+      test_writer:     { type: 'boolean', optional: true },
+      economy:         { type: 'enum', values: VALID_ECONOMY_MODES, optional: true },
+      economy_critic:  { type: 'boolean', optional: true },
     },
   },
   loop: {
@@ -54,6 +59,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,
+};