nubos-pilot 1.3.1 → 1.3.3

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/git.cjs

@@ -92,7 +92,7 @@ function commitTask(taskId, files, message) {
   };
 }
 
-function findCommitByTaskId(id) {
+function findCommitByTaskId(id, cwd) {
   if (typeof id !== 'string' || !TASK_ID_RE.test(id)) {
     throw new NubosPilotError(
       'task-commit-not-found',
@@ -101,6 +101,8 @@ function findCommitByTaskId(id) {
     );
   }
 
+  const spawnOpts = { encoding: 'utf-8', timeout: GIT_TIMEOUT_MS };
+  if (cwd) spawnOpts.cwd = cwd;
   const out = execFileSync(
     'git',
     [
@@ -112,7 +114,7 @@ function findCommitByTaskId(id) {
       '1',
       '--format=%H',
     ],
-    { encoding: 'utf-8', timeout: GIT_TIMEOUT_MS },
+    spawnOpts,
   ).trim();
   if (!out) {
     throw new NubosPilotError(

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.1",
+  "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": {

package/workflows/execute-phase.md

@@ -35,8 +35,14 @@ RUNTIME=$(node .nubos-pilot/bin/np-tools.cjs detect-runtime)
 WORKTREE_ISOLATION=$(node .nubos-pilot/bin/np-tools.cjs config-get workflow.worktree_isolation 2>/dev/null || echo "false")
 TIER_ROUTING=$(node .nubos-pilot/bin/np-tools.cjs config-get workflow.tier_routing 2>/dev/null || echo "false")
 VERIFY_RUNS=$(node .nubos-pilot/bin/np-tools.cjs config-get loop.verify_runs 2>/dev/null || echo "1")
+ECONOMY=$(node .nubos-pilot/bin/np-tools.cjs economy-mode --json 2>/dev/null || echo '{"mode":"lite","prevention":true,"critic":false,"ultra":false}')
+ECONOMY_MODE=$(echo "$ECONOMY" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).mode)}catch{console.log("lite")}})')
+ECONOMY_PREVENTION=$(echo "$ECONOMY" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).prevention)}catch{console.log("true")}})')
+ECONOMY_CRITIC=$(echo "$ECONOMY" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).critic)}catch{console.log("false")}})')
 ```
 
+**Economy axis (Ponytail-style graduated modes, SSOT = `economy-mode`).** `$ECONOMY_MODE` is one of `off|lite|full|ultra` (default `lite` = prevention-first). It dials two mechanisms: `$ECONOMY_PREVENTION` (`true` for `lite`/`full`/`ultra`) gates the climb-the-ladder directive injected into the Executor (Step 3); `$ECONOMY_CRITIC` (`true` for `full`/`ultra`) gates the `np-critic-economy.md` audit module injected into np-critic (Step 5). `ultra` additionally tells the critic to lower its `shrinkable` bar. Resolve this ONCE here — never re-read the raw config toggle downstream.
+
 When `--verify-work` is passed, the init payload's `auto_verify: true` flag tells this workflow to chain into `/np:verify-work $PHASE` after every slice committed and `finalize-milestone` ran. Without the flag the workflow stops after finalize as before — verify-work then remains a separate manual step.
 
 **Language (SSOT = `.nubos-pilot/config.json` → `response_language`).**
@@ -118,16 +124,17 @@ If zero skills match, omit the block — do **not** invent skills. Adding new sk
 
 ## Pre-Flight — orphan-checkpoint guard
 
-Detect stale checkpoints from a prior run before starting new work:
+Detect stale checkpoints from a prior run before starting new work. `init resume-work` first **reconciles every checkpoint against git** (`lib/checkpoint-reconcile.cjs`): any checkpoint whose task already has a `task(<id>):` commit is a tombstone (finishTask never unlinked it — crash between commit and unlink, or a commit made outside `commit-task`) and is pruned silently. They surface in `RESUME.pruned_checkpoints` for the log, never as a prompt. Only genuinely **uncommitted** checkpoints reach `status: orphan` and the dialog below — so a finished milestone can never block the next one.
 
 ```bash
 RESUME=$(node .nubos-pilot/bin/np-tools.cjs init resume-work)
 RESUME_STATUS=$(echo "$RESUME" | node -e "process.stdin.on('data', d => console.log(JSON.parse(d).status))")
 if [ "$RESUME_STATUS" = "orphan" ]; then
+  ORPHAN_ID=$(echo "$RESUME" | node -e "process.stdin.on('data', d => { const p = JSON.parse(d); console.log((p.checkpoint_ids || [])[0] || '') })")
   CHOICE=$(node .nubos-pilot/bin/np-tools.cjs askuser --json '{
     "type": "select",
     "header": "Verwaiste Checkpoints gefunden",
-    "question": "Vor dem Milestone-Start wurden Checkpoint-Dateien ohne passenden STATE.current_task gefunden. Was tun?",
+    "question": "Vor dem Milestone-Start wurde ein uncommitteter Checkpoint ohne passenden STATE.current_task gefunden (kein zugehöriger Commit). Was tun?",
     "options": [
       {"label": "Clean working tree (reset-slice)", "description": "Verwirft die in-flight Task und löscht ihren Checkpoint."},
       {"label": "Resume the orphan task",            "description": "Setzt STATE.current_task auf den Checkpoint-Eintrag und spawnt den Executor."},
@@ -135,6 +142,13 @@ if [ "$RESUME_STATUS" = "orphan" ]; then
     ]
   }')
   case "$CHOICE" in
+    "Clean working tree (reset-slice)")
+      node .nubos-pilot/bin/np-tools.cjs reset-slice "$ORPHAN_ID"
+      ;;
+    "Resume the orphan task")
+      echo "execute-phase: resuming orphan task $ORPHAN_ID — run /np:resume-work" >&2
+      exit 0
+      ;;
     "Abort") exit 0 ;;
   esac
 fi
@@ -419,6 +433,10 @@ for WAVE_INDEX in 0 1 2 ...; do
       #       <verify_excerpt>: tail of $VERIFY_LOG    (R≥2 only)
       #       <lang_directive>: $LANG_DIRECTIVE
       #       <skills>: $AGENT_SKILLS_EXECUTOR
+      #       <economy_mode>: $ECONOMY_MODE — when $ECONOMY_PREVENTION = true (lite/full/
+      #         ultra) instruct the agent to APPLY the np-executor "Climb the ladder"
+      #         discipline before writing (prevention-first). When $ECONOMY_MODE = off,
+      #         instruct it to SKIP the ladder (no economy pressure this run).
       #     RULES — Agent MUST: edit ONLY paths in files_modified (D-04 scope guard) —
       #     success_criteria are the acceptance target, NEVER a licence to touch other files,
       #     run `node np-tools.cjs knowledge-search "<q>" --task $TASK_ID` via Bash
@@ -558,6 +576,12 @@ for WAVE_INDEX in 0 1 2 ...; do
       #         - agents/np-critic-style.md
       #         - agents/np-critic-tests.md
       #         - agents/np-critic-acceptance.md
+      #         - agents/np-critic-economy.md   ← ONLY when $ECONOMY_CRITIC = true (mode full/ultra)
+      #           (resolved once in the init block via `economy-mode --json`; omit this line
+      #            entirely when $ECONOMY_CRITIC = false — default mode lite has prevention
+      #            on but the critic off). When $ECONOMY_MODE = ultra, ALSO append to the
+      #            prompt: "Economy mode: ultra — lower the shrinkable bar per the Ultra
+      #            section of np-critic-economy.md." Never inject the module at off/lite.
       #       <report_path>$CRITIC_REPORT_PATH</report_path>
       #     Agent MUST: Write the full findings JSON to $CRITIC_REPORT_PATH,
       #     emit ONLY the verdict-envelope as final message (~150 bytes):

package/workflows/simplify-debt.md

@@ -0,0 +1,93 @@
+---
+command: np:simplify-debt
+description: Economy-debt ledger — record, list, and resolve simplifications you deferred rather than fixed now, so "later" doesn't become "never". CRUD-only (no agent spawn unless you harvest from a review). Manual twin of the in-loop Economy critic (agents.economy full/ultra).
+argument-hint: "[list [--status open|resolved|all]] | [add --file <f> --line <n> --category <c> --note <text>] | [resolve <id>] | [harvest [<git-range>]]"
+---
+
+# /np:simplify-debt
+
+<objective>
+Keep a durable ledger of over-engineering you chose NOT to fix this round. `/np:simplify-review` finds what could be deleted, reused, or condensed; whatever you defer goes here as a tracked entry, so the shortcut is harvested rather than lost. Each entry carries a `file`, optional `line`, one of the four Economy categories (`over-engineering` / `stdlib-reinvention` / `native-duplication` / `shrinkable`), and a one-line note. This command is CRUD over `.nubos-pilot/economy-debt/` — it does not edit source and does not commit code. It is the deferred-work counterpart of the in-loop Economy critic (`/np:execute-phase` with `agents.economy` set to `full` or `ultra`).
+</objective>
+
+## Initialize
+
+```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
+VERB="${1:-list}"
+```
+
+`$LANG_DIRECTIVE` governs the prose you wrap around the CLI output; the ledger lines (id, category, `file:line`, note) stay canonical. Supersedes CLAUDE.md.
+
+## Route by verb
+
+This is a pure-CRUD workflow — the ledger lives behind `node .nubos-pilot/bin/np-tools.cjs simplify-debt`; never read or write `.nubos-pilot/economy-debt/` directly.
+
+### `list` (default)
+
+```bash
+node .nubos-pilot/bin/np-tools.cjs simplify-debt list --status "${2:-open}"
+```
+
+Prints the open ledger (oldest debt first — longest-deferred is most urgent). `--status resolved` or `--status all` widen the view; append `--json` for the machine shape. Print the output verbatim.
+
+### `add`
+
+```bash
+node .nubos-pilot/bin/np-tools.cjs simplify-debt add \
+  --file "$FILE" --line "$LINE" --category "$CATEGORY" --note "$NOTE"
+```
+
+`--category` MUST be one of `over-engineering`, `stdlib-reinvention`, `native-duplication`, `shrinkable` (the CLI rejects anything else). `--line` is optional (omit for a file-level note). Adds are idempotent: re-adding an identical finding is a no-op (`was_new=false`), so re-harvesting the same review never duplicates.
+
+### `resolve`
+
+```bash
+node .nubos-pilot/bin/np-tools.cjs simplify-debt resolve "$ID"
+```
+
+Moves the entry from `open/` to `resolved/` and stamps the resolution time. Use it once the simplification has actually landed (by hand or via a later `/np:execute-phase` round).
+
+### `harvest [<git-range>]`
+
+Spawn ONE read-only reviewer — `Agent(subagent_type="np-simplifier", prompt=<…>)` — over the diff (default: working tree + staged vs `HEAD`; or the passed git range). Its prompt MUST carry `agents/np-critic-economy.md` as the rubric (the canonical ladder + safety boundaries) and the captured `git diff --no-color`. For each finding the reviewer returns that you are NOT fixing now, record it with one `simplify-debt add` call (mapping the report tag to the matching `--category`). Findings you fix immediately are not harvested. Print the resulting open ledger when done.
+
+## No Source Mutation
+
+CRUD over the ledger only. This workflow NEVER edits source, NEVER stages, NEVER commits code. The ledger files under `.nubos-pilot/economy-debt/` are the only writes; commit them with your normal docs/artifact flow if `workflow.commit_docs` is set.
+
+## Scope Guardrail
+
+<scope_guardrail>
+**Do:**
+- Route every ledger read/write through `node .nubos-pilot/bin/np-tools.cjs simplify-debt <verb>` — never touch `.nubos-pilot/economy-debt/` directly.
+- Use one of the four Economy categories on `add`; the CLI is the source of truth and rejects others.
+- On `harvest`, pass `agents/np-critic-economy.md` to the reviewer so the ledger and the in-loop critic apply the identical bar.
+
+**Don't:**
+- Edit, stage, or commit source — this command only records deferred work. No `Write`/`Edit` of source, no `git add` of code.
+- Log a test, input-validation, error-handling, security, or required-edge-case removal as debt — those are completeness, never economy (the rubric's safety boundaries; completeness wins).
+- Record low-confidence "could be cleaner" noise — every entry needs a concrete file + replacement, same bar as `/np:simplify-review`.
+</scope_guardrail>
+
+## Output
+
+- The ledger view (open / resolved / all) or the result of an `add` / `resolve`, printed verbatim.
+- On `harvest`: one ledger entry per deferred finding, then the refreshed open ledger.
+- No source changes, no code commits.
+
+## Definition of Done
+
+Ledger CRUD. Definition of Done, per [`templates/COMPLETENESS.md`](../templates/COMPLETENESS.md):
+
+- Rule 3 (Do it with tests) — the ledger NEVER records deleting or weakening test code; coverage is completeness, not debt.
+- Rule 8 (Never present a workaround when the real fix exists) — entries point at the root-cause-simple form, not an obscure golfed one-liner.
+- Rule 11 (Ship the complete thing) — deferred simplifications are tracked, not silently dropped; "later" stays visible until `resolve`.
+
+Any violation = the operation is incomplete; surface it and exit non-zero. The orchestrator does not relax these.
+
+## Related Workflows
+
+- **`/np:simplify-review <git-range>`** — read-only economy audit of a diff (the finder; this command is the ledger that outlives a single review).
+- **`/np:execute-phase`** — runs the Economy critic in-loop when `agents.economy` is `full` or `ultra`, enforcing the same rubric during execution.
+- **`/np:add-todo`** — general pending-todo capture (this command is the economy-specific deferred-work ledger).

package/workflows/simplify-review.md

@@ -0,0 +1,103 @@
+---
+command: np:simplify-review
+description: Read-only economy audit of a git diff, the working tree, or the whole repo (--repo) — flags over-engineering, stdlib-reinvention, native-duplication, and shrinkable logic via the np-simplifier agent. Never edits or commits; emits a deletion-oriented report. Manual twin of the Economy critic axis (agents.economy full/ultra).
+argument-hint: "[<git-range> | --repo]  (default: working tree + staged vs HEAD)"
+---
+
+# /np:simplify-review
+
+<objective>
+Catalogue what could be deleted, reused, or condensed in a change set — the "wrote-too-much" review. A read-only `np-simplifier` agent scans the diff against the Economy rubric (`agents/np-critic-economy.md`) and emits one finding per removable construct plus a `net: -<N> lines possible.` summary. This command NEVER edits source and NEVER commits; it hands a report to the user. It is the manual counterpart of the in-loop Economy critic (`/np:execute-phase` with `agents.economy` set to `full` or `ultra`), and both apply the identical rubric and safety boundaries.
+</objective>
+
+## Initialize
+
+```bash
+LANG_DIRECTIVE=$(node .nubos-pilot/bin/np-tools.cjs lang-directive)
+RANGE="$*"
+if [[ "$RANGE" == "--repo" || "$RANGE" == "--all" ]]; then
+  SCOPE_MODE="repo"
+  FILES=$(git ls-files)
+  SCOPE_DESC="whole repository (tracked files)"
+  if [[ -z "$FILES" ]]; then
+    echo "No tracked files in scope ($SCOPE_DESC). Nothing to review."
+    exit 0
+  fi
+elif [[ -n "$RANGE" ]]; then
+  SCOPE_MODE="diff"
+  DIFF=$(git diff --no-color "$RANGE")
+  SCOPE_DESC="$RANGE"
+else
+  SCOPE_MODE="diff"
+  DIFF=$(git diff --no-color HEAD)
+  SCOPE_DESC="working tree + staged vs HEAD"
+fi
+if [[ "$SCOPE_MODE" == "diff" && -z "$DIFF" ]]; then
+  echo "No changes in scope ($SCOPE_DESC). Nothing to review."
+  exit 0
+fi
+```
+
+Capture is read-only — neither `git diff` nor `git ls-files` stages, edits, or commits anything. There are two scope modes:
+
+- **diff** (default) — a range (`HEAD~5..HEAD`, a branch name, `--staged`, …) is passed through verbatim; with no argument the scope is uncommitted + staged work against `HEAD`. This is the "review what just changed" mode.
+- **repo** (`--repo` / `--all`) — audits the whole tracked tree, not just a diff. `git ls-files` hands the agent the file roster; the agent walks the existing source for standing over-engineering (single-use abstractions, hand-rolled stdlib, duplicated native features, condensable logic) that predates any one change. Slower and noisier than diff mode — use it for a periodic cleanup pass, not every review.
+
+**Language (SSOT = `.nubos-pilot/config.json` → `response_language`).** `$LANG_DIRECTIVE` is authoritative for the report's prose and the final summary line. Finding lines (`<file>:L<line>: <tag> …`), file paths, and code snippets stay canonical. Supersedes CLAUDE.md.
+
+## Review
+
+Spawn ONE read-only reviewer — `Agent(subagent_type="np-simplifier", prompt=<…>)`, sonnet by default. The prompt MUST carry:
+
+- `<files_to_read>` listing `agents/np-critic-economy.md` (the canonical rubric — ladder, categories, severity bar, safety boundaries), plus `.nubos-pilot/codebase/INDEX.md` and `.nubos-pilot/RULES.md` when present (stdlib / native-feature / existing-helper context).
+- The review scope, by mode:
+  - **diff mode** — pass the captured `$DIFF` as the scope; the agent reviews only the changed hunks.
+  - **repo mode** — pass `$SCOPE_DESC` plus the `$FILES` roster from `git ls-files`, and instruct the agent to walk the tracked source itself (`Read`/`Grep`/`Glob`) under the same rubric. The agent should skip vendored, generated, and lock files and prioritise the largest hand-written modules. Because there is no diff, findings cite the source line as `<file>:L<line>` from the file it read.
+- `$SCOPE_MODE` and `$SCOPE_DESC` so the agent knows whether it is auditing a change set or the standing codebase.
+- `$LANG_DIRECTIVE` so the prose follows the project language.
+
+The agent is READ-ONLY (`tools: Read, Bash, Grep, Glob` — no Write/Edit). It returns a plain-text report: one line per finding in the shape `<file>:L<line>: <tag> <what>. <replacement>.` (tags `delete:` / `stdlib:` / `native:` / `shrink:`), ending with `net: -<N> lines possible.` or `Lean already. Ship.`
+
+## Report
+
+Print the agent's report verbatim to the user. Do not edit files, do not stage, do not commit — this command only catalogues. Close with the next-step hint:
+
+```
+Reductions are suggestions, not applied. To act on them: edit by hand, or run
+/np:execute-phase with agents.economy set to full (or ultra) so the Economy critic
+enforces the same bar inside the adversarial loop.
+```
+
+## Scope Guardrail
+
+<scope_guardrail>
+**Do:**
+- Capture the scope read-only — `git diff` in diff mode, `git ls-files` in `--repo` mode (no staging, no `-w` rewrites, no commit).
+- Spawn exactly one `np-simplifier` agent; pass it `agents/np-critic-economy.md` as the rubric so the manual command and the in-loop critic never diverge.
+- Print the report verbatim; respect `$LANG_DIRECTIVE` for prose only.
+
+**Don't:**
+- Edit, stage, or commit anything — this is a read-only audit. No `git add`, no `commit`, no `Write`/`Edit` of source.
+- Flag tests, input validation, error handling, security/access-control, or required edge cases as removable (the rubric's safety boundaries; completeness wins over economy).
+- Emit low-confidence "could be cleaner" noise — high-confidence, concrete replacements only.
+</scope_guardrail>
+
+## Output
+
+- A plain-text economy report to the user (findings + `net: -<N> lines possible.` or `Lean already. Ship.`).
+- No filesystem changes, no commits, no state mutation — read-only by contract.
+
+## Definition of Done
+
+This workflow audits a diff for economy and reports. The Definition of Done, per [`templates/COMPLETENESS.md`](../templates/COMPLETENESS.md):
+
+- Rule 3 (Do it with tests) — the report NEVER proposes deleting or weakening test code; coverage is completeness, not bloat.
+- Rule 5 (Aim to genuinely impress) — every finding cites file, line, the exact construct, and a concrete replacement; no vague "could be simpler" entries.
+- Rule 8 (Never present a workaround when the real fix exists) — reductions favour the root-cause-simple form over obscure golfed one-liners.
+
+Any violation = the review is incomplete; surface it and exit non-zero. The orchestrator does not relax these.
+
+## Related Workflows
+
+- **`/np:verify-work <N>`** — correctness/acceptance verification (the orthogonal axis; economy never judges correctness).
+- **`/np:execute-phase`** — runs the Economy critic in-loop when `agents.economy` is `full` or `ultra`, enforcing this exact rubric during execution.