nubos-pilot 1.3.2 → 1.3.4

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

@@ -58,7 +58,7 @@ function assertCommittablePaths(paths, opts) {
   return committable;
 }
 
-function commitTask(taskId, files, message) {
+function commitTask(taskId, files, message, body) {
   const { committable, ignored } = classifyCommittablePaths(files);
   if (committable.length === 0) {
     if (ignored.length > 0) {
@@ -84,7 +84,11 @@ function commitTask(taskId, files, message) {
     });
   }
   execFileSync('git', ['add', '--', ...committable], { stdio: 'pipe', timeout: GIT_TIMEOUT_MS });
-  execFileSync('git', ['commit', '-m', message, '--', ...committable], { stdio: 'pipe', timeout: GIT_TIMEOUT_MS });
+  const commitArgs = ['commit', '-m', message];
+  if (typeof body === 'string' && body.trim().length > 0) {
+    commitArgs.push('-m', body);
+  }
+  execFileSync('git', [...commitArgs, '--', ...committable], { stdio: 'pipe', timeout: GIT_TIMEOUT_MS });
   return {
     committed: true,
     files_committed: committable.slice(),

package/lib/git.test.cjs

@@ -199,6 +199,34 @@ test('GIT-5: commitTask creates a single commit containing exactly the supplied
   });
 });
 
+test('GIT-5b: commitTask attaches a multi-line body via a second -m when body is supplied', () => {
+  const root = makeRepo();
+  inRepo(root, () => {
+    writeFile(root, 'lib/git.cjs', '// stub');
+    git.commitTask(
+      'M006-S001-T0001',
+      ['lib/git.cjs'],
+      'task(M006-S001-T0001): add git helper',
+      'Implements the git helper.\n\nTask: M006-S001-T0001',
+    );
+    const subject = execFileSync('git', ['log', '-n', '1', '--format=%s'], { encoding: 'utf-8' }).trim();
+    const fullBody = execFileSync('git', ['log', '-n', '1', '--format=%b'], { encoding: 'utf-8' });
+    assert.equal(subject, 'task(M006-S001-T0001): add git helper');
+    assert.match(fullBody, /Implements the git helper\./);
+    assert.match(fullBody, /Task: M006-S001-T0001/);
+  });
+});
+
+test('GIT-5c: commitTask omits the body -m when body is empty/whitespace (backward-compatible)', () => {
+  const root = makeRepo();
+  inRepo(root, () => {
+    writeFile(root, 'lib/git.cjs', '// stub');
+    git.commitTask('M006-S001-T0001', ['lib/git.cjs'], 'task(M006-S001-T0001): add git helper', '   ');
+    const fullBody = execFileSync('git', ['log', '-n', '1', '--format=%b'], { encoding: 'utf-8' }).trim();
+    assert.equal(fullBody, '');
+  });
+});
+
 test('GIT-6: findCommitByTaskId returns 40-char SHA for known task commit', () => {
   const root = makeRepo();
   inRepo(root, () => {

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.4",
   "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/templates/RULES.md

@@ -79,7 +79,33 @@ Examples:
 -->
 - _TBD — fill with logging policy._
 
-## Code Style
+## Conventions
+
+> **How your code must be built.** These rules bind the architect (`np-task-architect`),
+> the test-writer (`np-test-writer`), the executor, and the style critic
+> (`np-critic-style`). They are read on every task. Each subsection is **MUST FILL** —
+> use `- _none — <reason>_` only when a subsection genuinely does not apply.
+
+### Class / Module Structure
+
+<!-- How classes, modules, and units are shaped. Examples:
+- One public class per file; file name matches the class name.
+- Constructor injection only — no service-locator / static singletons.
+- Business logic lives in Services/Actions; controllers stay thin (no DB access).
+- Public surface ≤ 5 methods; split when it grows past that.
+-->
+- _TBD — fill with class/module construction rules._
+
+### Naming
+
+<!-- Identifier conventions. Examples:
+- Classes PascalCase, methods camelCase, constants UPPER_SNAKE.
+- Booleans read as predicates (`isActive`, `hasAccess`), never `flag`/`status`.
+- Table names follow the framework's pluralization — never override.
+-->
+- _TBD — fill with naming conventions._
+
+### Code Style
 
 <!-- Format/lint/comment policy. Examples:
 - No comments inside source — names + tests carry intent.
@@ -88,6 +114,15 @@ Examples:
 -->
 - _TBD — fill with style policy._
 
+### Patterns & Paradigms
+
+<!-- Architectural patterns that are required or banned. Examples:
+- Required: Repository pattern for all persistence; Result objects over exceptions for control flow.
+- Banned: anemic domain models; inheritance for code reuse (prefer composition).
+- Errors are typed and surfaced — never swallowed or stringly-typed.
+-->
+- _TBD — fill with required/banned patterns._
+
 ## Out-of-Scope (Forever)
 
 <!-- Things this project explicitly will never do. Distinct from deferred ideas.

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`).**
@@ -213,6 +219,10 @@ SPAWN_HEADLESS_ENABLED=$(node .nubos-pilot/bin/np-tools.cjs config-get spawn.hea
 SPAWN_HEADLESS_AGENTS=$(node .nubos-pilot/bin/np-tools.cjs config-get spawn.headless.agents 2>/dev/null || echo '["np-critic","np-researcher"]')
 SPAWN_HEADLESS_FALLBACK=$(node .nubos-pilot/bin/np-tools.cjs config-get spawn.headless.fallback_on_error 2>/dev/null || echo true)
 CONF_INJECT_CRITERIA=$(node .nubos-pilot/bin/np-tools.cjs config-get conformance.inject_criteria 2>/dev/null || echo true)
+# Round-1 prep agents (default on; backfilled on install/update). When a toggle
+# is false the matching ACTION CONTRACT (Step 2b / Step 2c) is skipped wholesale.
+ARCHITECT_ENABLED=$(node .nubos-pilot/bin/np-tools.cjs config-get agents.architect 2>/dev/null || echo true)
+TEST_WRITER_ENABLED=$(node .nubos-pilot/bin/np-tools.cjs config-get agents.test_writer 2>/dev/null || echo true)
 # Milestone success_criteria as the executor's acceptance target (rendered once from the INIT payload).
 # Intent-level only (ADR-0019): these describe what "done right" means, NOT how to build it.
 SUCCESS_CRITERIA_BLOCK=$(echo "$INIT" | node -e 'process.stdin.on("data",d=>{try{const c=JSON.parse(d).success_criteria||[];console.log(c.map(x=>"- "+(x.id?x.id+": ":"")+(x.text||x)).join("\n"))}catch(e){console.log("")}})')
@@ -408,6 +418,131 @@ for WAVE_INDEX in 0 1 2 ...; do
         CONSENSUS_PATTERN=""
       fi
 
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # ACTION CONTRACT — Step 2b: Per-Task Architect (Round 1, config-gated)
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # WHEN: $ROUND -eq 1 AND $ARCHITECT_ENABLED = true. Skip wholesale otherwise
+      #   (agents.architect=false → no architect this run; R≥2 build-fixer rounds
+      #   never run it).
+      # SKIP-GUARD: loop-post-architect-missing-spawn-audit (needs 1 architect audit).
+      #
+      # Execute EXACTLY these three groups, in order:
+      #
+      # (1) ONE Agent tool-call (real, not bash):
+      #       Agent(subagent_type="np-task-architect", prompt=<…>)
+      #     Prompt fields:
+      #       <files_to_read>: task plan, slice plan, CONTEXT.md, RULES.md,
+      #         M<NNN>-ARCHITECTURE.md (if present), .nubos-pilot/codebase/INDEX.md
+      #       <consensus_pattern>: $CONSENSUS_PATTERN (researcher output; may be empty)
+      #       <lang_directive>: $LANG_DIRECTIVE
+      #     Curated skills (quality bar) — instruct the agent to Read each that
+      #     applies from .claude/skills/<skill>/SKILL.md: np-system-design,
+      #     np-service-boundary, np-api-design, np-composition-patterns,
+      #     np-error-handling, np-adr (only for a costly-to-reverse choice).
+      #     The agent is READ-ONLY: it emits its Task-Architecture spec as its FINAL
+      #     MESSAGE (markdown per its Output Contract). Write that message verbatim
+      #     to "$ARCH_CONSTRAINTS_PATH".
+      #
+      # (2) ONE Bash audit-stamp (same round) — architect is NOT Rule-9 audited,
+      #     so an empty tool-use log is correct:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" \
+      #         --agent np-task-architect --tool-use-log '[]'
+      #
+      # (3) ONE Bash advance:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" \
+      #         --phase post-architect
+      #
+      # $ARCH_CONSTRAINTS is injected as <architecture_constraints> into the
+      # test-writer (Step 2c) AND executor (Step 3) prompts.
+      #
+      # Rationale: ADR-0023 — a per-task structural pass before tests/code so the
+      # test-writer and executor build against a decided shape, honouring RULES.md
+      # Conventions. Ephemeral ($TMPDIR, never committed) → plan-lint untouched.
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      ARCH_CONSTRAINTS=""
+      ARCH_CONSTRAINTS_PATH="${TMPDIR:-/tmp}/np-arch-${TASK_ID}.md"
+      if [ "$ROUND" -eq 1 ] && [ "$ARCHITECT_ENABLED" = "true" ]; then
+        # Off-host (ADR-0021): np-task-architect is read-only (Read/Grep/Glob), not
+        # Rule-9 audited, writes no files — run via spawn-offhost with default cwd
+        # when it routes to an openai-compat provider; its spec returns as the
+        # spawn's final message (content).
+        ARCHITECT_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-task-architect --json 2>/dev/null \
+          | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).kind||"native")}catch{console.log("native")}})')
+        if [ "$ARCHITECT_KIND" = "openai-compat" ]; then
+          A_PROMPT="${TMPDIR:-/tmp}/np-offhost-task-architect-${TASK_ID}.md"
+          # … render the files_to_read block + consensus + skills + $LANG_DIRECTIVE into "$A_PROMPT" …
+          A_OUT=$(node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+            --agent np-task-architect --task-file "$A_PROMPT" --task-id "$TASK_ID" \
+            --read-only --no-audit ${SLICE_CWD:+--cwd "$SLICE_CWD"})
+          echo "$A_OUT" | ARCH_PATH="$ARCH_CONSTRAINTS_PATH" node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{let c="";try{c=JSON.parse(s).content||""}catch{}require("fs").writeFileSync(process.env.ARCH_PATH,c)})'
+        else
+          true  # → execute group (1): native Agent spawn; write its final message to "$ARCH_CONSTRAINTS_PATH".
+        fi
+        node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" --agent np-task-architect --tool-use-log '[]'
+        node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" --phase post-architect
+        [ -f "$ARCH_CONSTRAINTS_PATH" ] && ARCH_CONSTRAINTS=$(cat "$ARCH_CONSTRAINTS_PATH")
+      fi
+
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # ACTION CONTRACT — Step 2c: Test-Writer / TDD (Round 1, config-gated)
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      # WHEN: $ROUND -eq 1 AND $TEST_WRITER_ENABLED = true. Runs AFTER the architect,
+      #   BEFORE the executor. Skip wholesale otherwise.
+      # SKIP-GUARD: loop-post-test-writer-missing-spawn-audit (needs 1 test-writer audit).
+      #
+      # Execute EXACTLY these three groups, in order:
+      #
+      # (1) ONE Agent tool-call (real, not bash):
+      #       Agent(subagent_type="np-test-writer", prompt=<…>)
+      #     Prompt fields:
+      #       <files_to_read>: task plan, slice plan, RULES.md, neighbouring tests
+      #       <architecture_constraints>: $ARCH_CONSTRAINTS (the architect's required
+      #         test surfaces; empty when the architect is disabled)
+      #       <success_criteria>: $SUCCESS_CRITERIA_BLOCK + slice UAT path (intent-level)
+      #       <lang_directive>: $LANG_DIRECTIVE
+      #     Curated skill (quality bar) — instruct the agent to Read
+      #     .claude/skills/np-test-strategy/SKILL.md and satisfy its Verification bar.
+      #     RULES — the agent writes REAL, VALID test files for every required surface;
+      #     it MUST NOT skip/stub/weaken assertions (Rule 10). Tests MAY be red now;
+      #     the executor makes them green. The agent emits a JSON envelope whose
+      #     tests_written paths you collect into $TDD_TESTS.
+      #
+      # (2) ONE Bash audit-stamp (same round) — test-writer is NOT Rule-9 audited:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" \
+      #         --agent np-test-writer --tool-use-log '[]'
+      #
+      # (3) ONE Bash advance — pass the written test paths so they are recorded in
+      #     the checkpoint (nubosloop.tdd_tests) and commit-task folds them into the
+      #     commit even when files_modified did not enumerate them:
+      #       node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" \
+      #         --phase post-test-writer --tests "$TDD_TESTS"
+      #
+      # Rationale: ADR-0023 — TDD inside the loop. The mechanical verify gate
+      # (Step 4) runs only AFTER the executor, so red-until-executor is expected
+      # and not a failure. The np-critic-tests axis (Step 5) re-audits for any
+      # skipped/vacuous assertions that slipped through.
+      # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+      TDD_TESTS=""
+      if [ "$ROUND" -eq 1 ] && [ "$TEST_WRITER_ENABLED" = "true" ]; then
+        # Off-host (ADR-0021): np-test-writer writes test files, so off-host needs
+        # worktree isolation exactly like the executor (model-driven Write confined
+        # + ff-merged back). When worktree isolation is off, it runs native.
+        TEST_WRITER_KIND=$(node .nubos-pilot/bin/np-tools.cjs resolve-model np-test-writer --json 2>/dev/null \
+          | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{console.log(JSON.parse(s).kind||"native")}catch{console.log("native")}})')
+        if [ "$TEST_WRITER_KIND" = "openai-compat" ] && [ "$WORKTREE_ISOLATION" = "true" ] && [ -n "$SLICE_CWD" ] && [ "$SLICE_CWD" != "." ]; then
+          TW_PROMPT="${TMPDIR:-/tmp}/np-offhost-test-writer-${TASK_ID}.md"
+          # … render files_to_read + architecture_constraints + success_criteria + skill + $LANG_DIRECTIVE into "$TW_PROMPT" …
+          TW_OUT=$(node .nubos-pilot/bin/np-tools.cjs spawn-offhost \
+            --agent np-test-writer --task-file "$TW_PROMPT" --task-id "$TASK_ID" \
+            --cwd "$SLICE_CWD" --allow-bash --no-audit)
+          TDD_TESTS=$(echo "$TW_OUT" | node -e 'let s="";process.stdin.on("data",d=>s+=d).on("end",()=>{try{const j=JSON.parse(JSON.parse(s).content||"{}");console.log((j.tests_written||[]).join(", "))}catch{console.log("")}})')
+        else
+          true  # → execute group (1): native Agent spawn; collect tests_written from the envelope into $TDD_TESTS.
+        fi
+        node .nubos-pilot/bin/np-tools.cjs loop-audit-tool-use "$TASK_ID" --agent np-test-writer --tool-use-log '[]'
+        node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" --phase post-test-writer --tests "$TDD_TESTS"
+      fi
+
       # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
       # ACTION CONTRACT — Step 3: Executor (R1) / Build-Fixer (R≥2)
       # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -418,6 +553,13 @@ for WAVE_INDEX in 0 1 2 ...; do
       #     Prompt fields:
       #       <files_to_read>: task plan, slice plan, prior slice SUMMARYs, CONTEXT.md
       #       <consensus_pattern>: $CONSENSUS_PATTERN (with [VERIFIED]/[PROVISIONAL]/[CACHED])
+      #       <architecture_constraints>: $ARCH_CONSTRAINTS — the per-task architect's
+      #         decided structure + constraints (empty when agents.architect is off).
+      #         The executor builds against this shape; it is intent-level, not a code spec.
+      #       <tdd_tests>: $TDD_TESTS — test files np-test-writer wrote (R1, empty when off).
+      #         The executor MUST make them green WITHOUT deleting, skipping, or weakening
+      #         any assertion. They are in scope alongside files_modified (recorded in the
+      #         checkpoint at post-test-writer) and commit-task commits them with the diff.
       #       <success_criteria>: when $CONF_INJECT_CRITERIA = true, include the milestone
       #         acceptance target — $SUCCESS_CRITERIA_BLOCK plus the slice UAT path
       #         (.nubos-pilot/milestones/M<NNN>/slices/S<NNN>/S<NNN>-UAT.md). Frame it as
@@ -427,7 +569,12 @@ 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
-      #     RULES — Agent MUST: edit ONLY paths in files_modified (D-04 scope guard) —
+      #       <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 plus the <tdd_tests>
+      #     paths (D-04 scope guard; the TDD tests are the sole sanctioned addition) —
       #     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
       #     ≥1× (Rule 9 — the --task flag writes the audit evidence ledger),
@@ -566,6 +713,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):