nubos-pilot 1.3.2 → 1.3.3

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/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,
+};

package/lib/economy-debt.test.cjs

@@ -0,0 +1,131 @@
+'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 debt = require('./economy-debt.cjs');
+
+const _sandboxes = [];
+
+function makeSandbox() {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'np-economy-debt-'));
+  fs.mkdirSync(path.join(root, '.nubos-pilot'), { recursive: true });
+  _sandboxes.push(root);
+  return root;
+}
+
+afterEach(() => {
+  while (_sandboxes.length) {
+    try { fs.rmSync(_sandboxes.pop(), { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+});
+
+test('ED-1: addEntry writes an open entry and returns was_new=true', () => {
+  const cwd = makeSandbox();
+  const e = debt.addEntry(
+    { file: 'src/foo.ts', line: 42, category: 'over-engineering', note: 'Single-use factory — inline it.' },
+    cwd,
+  );
+  assert.equal(e.was_new, true);
+  assert.equal(e.status, 'open');
+  assert.equal(e.category, 'over-engineering');
+  assert.equal(e.file, 'src/foo.ts');
+  assert.equal(e.line, 42);
+  assert.match(e.id, /^[0-9a-f]{7}$/);
+  assert.ok(fs.existsSync(e.path));
+});
+
+test('ED-2: addEntry is idempotent — identical input does not duplicate', () => {
+  const cwd = makeSandbox();
+  const first = debt.addEntry(
+    { file: 'a.ts', line: 1, category: 'shrinkable', note: 'manual reduce -> Array.reduce' },
+    cwd,
+  );
+  const second = debt.addEntry(
+    { file: 'a.ts', line: 1, category: 'shrinkable', note: 'manual reduce -> Array.reduce' },
+    cwd,
+  );
+  assert.equal(first.id, second.id);
+  assert.equal(second.was_new, false);
+  assert.equal(debt.listEntries('open', cwd).length, 1);
+});
+
+test('ED-3: addEntry rejects a category outside the four economy routes', () => {
+  const cwd = makeSandbox();
+  assert.throws(
+    () => debt.addEntry({ file: 'a.ts', category: 'security', note: 'x' }, cwd),
+    (err) => err && err.name === 'NubosPilotError' && err.code === 'economy-debt-invalid-category',
+  );
+});
+
+test('ED-4: addEntry rejects an empty note', () => {
+  const cwd = makeSandbox();
+  assert.throws(
+    () => debt.addEntry({ file: 'a.ts', category: 'shrinkable', note: '  ' }, cwd),
+    (err) => err && err.name === 'NubosPilotError' && err.code === 'economy-debt-missing-note',
+  );
+});
+
+test('ED-5: line defaults to 0 (file-level) when omitted', () => {
+  const cwd = makeSandbox();
+  const e = debt.addEntry({ file: 'a.ts', category: 'native-duplication', note: 'reimplements framework helper' }, cwd);
+  assert.equal(e.line, 0);
+  const parsed = debt.listEntries('open', cwd)[0];
+  assert.equal(parsed.line, 0);
+});
+
+test('ED-6: listEntries sorts oldest-first and round-trips note + fields', () => {
+  const cwd = makeSandbox();
+  debt.addEntry({ file: 'a.ts', line: 5, category: 'shrinkable', note: 'first' }, cwd);
+  debt.addEntry({ file: 'b.ts', line: 9, category: 'over-engineering', note: 'second' }, cwd);
+  const list = debt.listEntries('open', cwd);
+  assert.equal(list.length, 2);
+  assert.equal(list[0].note, 'first');
+  assert.equal(list[1].note, 'second');
+  assert.equal(list[1].category, 'over-engineering');
+  assert.equal(list[1].line, 9);
+});
+
+test('ED-7: resolveEntry moves open -> resolved and stamps resolved time', () => {
+  const cwd = makeSandbox();
+  const e = debt.addEntry({ file: 'a.ts', line: 1, category: 'stdlib-reinvention', note: 'hand-rolled clamp' }, cwd);
+  const r = debt.resolveEntry(e.id, cwd);
+  assert.equal(r.status, 'resolved');
+  assert.match(r.resolved, /^\d{4}-\d{2}-\d{2}T/);
+  assert.equal(debt.listEntries('open', cwd).length, 0);
+  assert.equal(debt.listEntries('resolved', cwd).length, 1);
+  assert.equal(debt.listEntries('all', cwd).length, 1);
+  assert.ok(!fs.existsSync(e.path));
+});
+
+test('ED-8: resolveEntry throws economy-debt-not-found for an unknown id', () => {
+  const cwd = makeSandbox();
+  assert.throws(
+    () => debt.resolveEntry('deadbee', cwd),
+    (err) => err && err.name === 'NubosPilotError' && err.code === 'economy-debt-not-found',
+  );
+});
+
+test('ED-9: listEntries rejects an invalid status', () => {
+  const cwd = makeSandbox();
+  assert.throws(
+    () => debt.listEntries('bogus', cwd),
+    (err) => err && err.name === 'NubosPilotError' && err.code === 'economy-debt-invalid-status',
+  );
+});
+
+test('ED-10: empty ledger lists as []', () => {
+  const cwd = makeSandbox();
+  assert.deepEqual(debt.listEntries('open', cwd), []);
+  assert.deepEqual(debt.listEntries('all', cwd), []);
+});
+
+test('ED-11: ECONOMY_CATEGORIES matches the four canonical economy routes', () => {
+  assert.deepEqual(
+    debt.ECONOMY_CATEGORIES.slice().sort(),
+    ['native-duplication', 'over-engineering', 'shrinkable', 'stdlib-reinvention'],
+  );
+});

package/lib/economy-mode.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+// Single source of truth for the Economy axis activation level (Ponytail-style
+// graduated modes). The Economy schicht has two mechanisms — the prevention
+// ladder in agents/np-executor.md (guidance BEFORE writing) and the in-loop
+// Economy critic (agents/np-critic-economy.md, audits the diff AFTER). One
+// enum dials both:
+//
+//   off    prevention OFF, critic OFF  — no economy pressure at all
+//   lite   prevention ON,  critic OFF  — prevention-first DEFAULT (advisory only)
+//   full   prevention ON,  critic ON   — standard critic rubric
+//   ultra  prevention ON,  critic ON   — aggressive critic (lowered shrinkable bar)
+//
+// Default is `lite`: the climb-the-ladder discipline is on, but nothing bounces
+// work back. This makes prevention-first the documented default philosophy
+// while keeping the costlier critic opt-in (full/ultra).
+//
+// Backward-compat: the legacy boolean `agents.economy_critic` is honoured when
+// `agents.economy` is absent — true→full, false→lite — so a pre-existing
+// gitignored config keeps its behaviour. The resolver is LOUD: an explicit but
+// invalid `agents.economy` string throws rather than silently defaulting.
+
+const { NubosPilotError } = require('./core.cjs');
+
+const VALID_ECONOMY_MODES = Object.freeze(['off', 'lite', 'full', 'ultra']);
+const DEFAULT_ECONOMY_MODE = 'lite';
+
+function resolveEconomyMode(config) {
+  const agents = config && typeof config === 'object' ? config.agents : null;
+  if (agents && typeof agents === 'object') {
+    if (agents.economy !== undefined) {
+      const explicit = agents.economy;
+      if (typeof explicit !== 'string' || !VALID_ECONOMY_MODES.includes(explicit)) {
+        throw new NubosPilotError(
+          'config-invalid-economy-mode',
+          'agents.economy must be one of ' + VALID_ECONOMY_MODES.join('|') + ' (got: ' + JSON.stringify(explicit) + ')',
+          { value: explicit, valid: VALID_ECONOMY_MODES },
+        );
+      }
+      return explicit;
+    }
+    if (typeof agents.economy_critic === 'boolean') {
+      return agents.economy_critic ? 'full' : 'lite';
+    }
+  }
+  return DEFAULT_ECONOMY_MODE;
+}
+
+function preventionOn(mode) { return mode !== 'off'; }
+function criticOn(mode) { return mode === 'full' || mode === 'ultra'; }
+function isUltra(mode) { return mode === 'ultra'; }
+
+function economyFlags(config) {
+  const mode = resolveEconomyMode(config);
+  return { mode, prevention: preventionOn(mode), critic: criticOn(mode), ultra: isUltra(mode) };
+}
+
+module.exports = {
+  VALID_ECONOMY_MODES,
+  DEFAULT_ECONOMY_MODE,
+  resolveEconomyMode,
+  preventionOn,
+  criticOn,
+  isUltra,
+  economyFlags,
+};

package/lib/economy-mode.test.cjs

@@ -0,0 +1,85 @@
+'use strict';
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+
+const {
+  VALID_ECONOMY_MODES,
+  DEFAULT_ECONOMY_MODE,
+  resolveEconomyMode,
+  preventionOn,
+  criticOn,
+  isUltra,
+  economyFlags,
+} = require('./economy-mode.cjs');
+
+test('default is lite (prevention-first) when nothing is set', () => {
+  assert.equal(DEFAULT_ECONOMY_MODE, 'lite');
+  assert.equal(resolveEconomyMode({}), 'lite');
+  assert.equal(resolveEconomyMode({ agents: {} }), 'lite');
+  assert.equal(resolveEconomyMode(null), 'lite');
+  assert.equal(resolveEconomyMode(undefined), 'lite');
+});
+
+test('explicit agents.economy wins for every valid mode', () => {
+  for (const mode of VALID_ECONOMY_MODES) {
+    assert.equal(resolveEconomyMode({ agents: { economy: mode } }), mode);
+  }
+});
+
+test('legacy agents.economy_critic maps true→full, false→lite', () => {
+  assert.equal(resolveEconomyMode({ agents: { economy_critic: true } }), 'full');
+  assert.equal(resolveEconomyMode({ agents: { economy_critic: false } }), 'lite');
+});
+
+test('non-boolean legacy economy_critic falls back to the lite default (schema warns separately)', () => {
+  assert.equal(resolveEconomyMode({ agents: { economy_critic: 'true' } }), 'lite');
+  assert.equal(resolveEconomyMode({ agents: { economy_critic: 1 } }), 'lite');
+  assert.equal(resolveEconomyMode({ agents: { economy_critic: null } }), 'lite');
+});
+
+test('explicit economy overrides the legacy bool', () => {
+  assert.equal(resolveEconomyMode({ agents: { economy: 'off', economy_critic: true } }), 'off');
+  assert.equal(resolveEconomyMode({ agents: { economy: 'ultra', economy_critic: false } }), 'ultra');
+});
+
+test('invalid explicit economy throws loud (no silent default)', () => {
+  assert.throws(
+    () => resolveEconomyMode({ agents: { economy: 'banana' } }),
+    (err) => err.code === 'config-invalid-economy-mode',
+  );
+  assert.throws(
+    () => resolveEconomyMode({ agents: { economy: 42 } }),
+    (err) => err.code === 'config-invalid-economy-mode',
+  );
+});
+
+test('flag helpers gate prevention/critic/ultra correctly', () => {
+  assert.equal(preventionOn('off'), false);
+  assert.equal(preventionOn('lite'), true);
+  assert.equal(preventionOn('full'), true);
+  assert.equal(preventionOn('ultra'), true);
+
+  assert.equal(criticOn('off'), false);
+  assert.equal(criticOn('lite'), false);
+  assert.equal(criticOn('full'), true);
+  assert.equal(criticOn('ultra'), true);
+
+  assert.equal(isUltra('ultra'), true);
+  assert.equal(isUltra('full'), false);
+});
+
+test('economyFlags bundles the resolved mode with its gates', () => {
+  assert.deepEqual(economyFlags({ agents: { economy: 'off' } }), {
+    mode: 'off', prevention: false, critic: false, ultra: false,
+  });
+  assert.deepEqual(economyFlags({}), {
+    mode: 'lite', prevention: true, critic: false, ultra: false,
+  });
+  assert.deepEqual(economyFlags({ agents: { economy: 'full' } }), {
+    mode: 'full', prevention: true, critic: true, ultra: false,
+  });
+  assert.deepEqual(economyFlags({ agents: { economy: 'ultra' } }), {
+    mode: 'ultra', prevention: true, critic: true, ultra: true,
+  });
+});

package/lib/nubosloop.cjs

@@ -34,6 +34,10 @@ const ROUTE_TABLE = {
   'verify-mismatch': 'executor',
   'unmet-criterion': 'executor',
   'scope-creep': 'executor',
+  'over-engineering': 'executor',
+  'stdlib-reinvention': 'executor',
+  'native-duplication': 'executor',
+  'shrinkable': 'executor',
   'information-missing': 'researcher',
   'question-to-user': 'askuser',
   'locked-decision-violation': 'plan-checker',

package/lib/nubosloop.test.cjs

@@ -191,6 +191,7 @@ test('NL-17: ROUTE_TABLE covers every documented finding category', () => {
     'missing-test', 'edge-case-gap',
     'weak-assertion', 'silenced-failure', 'test-naming', 'non-deterministic',
     'verify-mismatch', 'unmet-criterion', 'scope-creep', 'information-missing',
+    'over-engineering', 'stdlib-reinvention', 'native-duplication', 'shrinkable',
     'infrastructure-mismatch',
     'question-to-user', 'locked-decision-violation', 'stuck-detected',
   ];

package/np-tools.cjs

@@ -44,6 +44,7 @@ const topLevelCommands = {
   'askuser':        require('./bin/np-tools/askuser.cjs'),
   'commit':         require('./bin/np-tools/commit.cjs'),
   'config-get':     require('./bin/np-tools/config.cjs'),
+  'economy-mode':   require('./bin/np-tools/economy-mode.cjs'),
   'scan-codebase':  require('./bin/np-tools/scan-codebase.cjs'),
   'update-docs':    require('./bin/np-tools/update-docs.cjs'),
   'graph-impact':   require('./bin/np-tools/graph-impact.cjs'),
@@ -79,6 +80,7 @@ const topLevelCommands = {
   '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'),
+  'simplify-debt':     require('./bin/np-tools/simplify-debt.cjs'),
   'archive-project':   require('./bin/np-tools/archive-project.cjs'),
 
   ...initWorkflows,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nubos-pilot",
-  "version": "1.3.2",
+  "version": "1.3.3",
   "description": "Self-hosted AI pilot for any codebase. Researcher and critic agents plan, execute and verify each change.",
   "homepage": "https://pilot.nubos.cloud",
   "repository": {