nubos-pilot 1.3.2 → 1.3.4

package/bin/np-tools/commit-task.cjs

@@ -91,19 +91,90 @@ function _resolveSafe(root, p) {
 }
 
 const _COMMIT_NAME_MAX = 200;
+const _COMMIT_BODY_MAX = 2000;
+const _TASK_ID_PREFIX_RE = /^\s*M\d{3,}-S\d{3,}-T\d{4,}\s*[—:-]\s*/;
+const _PLACEHOLDER_RE = /^\s*(?:\{\{.*\}\}|_?TBD\b.*|_none\b.*)\s*$/i;
+
 function _sanitizeCommitName(s) {
   return String(s == null ? '' : s).replace(/[\r\n\t]+/g, ' ').replace(/\s+/g, ' ').trim().slice(0, _COMMIT_NAME_MAX);
 }
 
+// The scaffolded H1 is "# <task-id> — <name>"; without a `name:` frontmatter
+// field the body regex captures the whole heading, producing the duplicated
+// "task(ID): ID — desc" subject. Strip a leading task-id prefix so the subject
+// reads "task(ID): desc".
 function _extractName(frontmatter, body) {
+  // Strip a leading task-id prefix, but fall through to the next source when the
+  // strip empties the candidate — a `name:` of just "M001-S001-T0001 —" or an H1
+  // with no description must not produce a bare "task(ID): " subject.
   if (typeof frontmatter.name === 'string' && frontmatter.name.length > 0) {
-    return _sanitizeCommitName(frontmatter.name);
+    const stripped = _sanitizeCommitName(String(frontmatter.name).replace(_TASK_ID_PREFIX_RE, ''));
+    if (stripped) return stripped;
   }
   const m = String(body || '').match(/^#\s+(?:Task:\s*)?(.+?)\s*$/m);
-  if (m) return _sanitizeCommitName(m[1]);
+  if (m) {
+    const stripped = _sanitizeCommitName(m[1].replace(_TASK_ID_PREFIX_RE, ''));
+    if (stripped) return stripped;
+  }
   return _sanitizeCommitName(frontmatter.id || 'task');
 }
 
+function _innerTag(body, tag) {
+  const m = String(body || '').match(new RegExp('<' + tag + '>([\\s\\S]*?)</' + tag + '>'));
+  if (!m) return '';
+  const inner = m[1].trim();
+  // A still-unfilled placeholder may carry a Markdown bullet prefix
+  // (`- _TBD — …`); test the de-bulleted form so it is recognised and omitted.
+  const candidate = inner.replace(/^[-*+]\s+/, '');
+  return _PLACEHOLDER_RE.test(candidate) ? '' : inner;
+}
+
+function _sanitizeCommitBody(s) {
+  return String(s == null ? '' : s)
+    .replace(/\r\n?/g, '\n')
+    .replace(/[ \t]+\n/g, '\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+    .slice(0, _COMMIT_BODY_MAX);
+}
+
+// Compose a descriptive commit body from the task's intent so the history is
+// self-explanatory months later: what the task does (<action>), what it must
+// satisfy (<acceptance_criteria>), the task id, and the files it touched.
+function _dedupe(arr) {
+  const seen = new Set();
+  const out = [];
+  for (const x of arr) {
+    if (!seen.has(x)) { seen.add(x); out.push(x); }
+  }
+  return out;
+}
+
+// Test files np-test-writer wrote this task (ADR-0023). The test-writer chooses
+// their paths at runtime — the planner-authored files_modified does not list
+// them — so the post-test-writer phase records them in the checkpoint. Fold them
+// into the commit set so the executor-greened tests land with their production
+// code instead of being silently dropped.
+function _tddTestFiles(taskId, cwd, root) {
+  const cp = readCheckpoint(taskId, cwd);
+  const np = cp && cp.nubosloop;
+  const tests = np && Array.isArray(np.tdd_tests) ? np.tdd_tests : [];
+  return tests.map((p) => _resolveSafe(root, p));
+}
+
+function _composeCommitBody(body, taskId, files) {
+  const action = _innerTag(body, 'action');
+  const accept = _innerTag(body, 'acceptance_criteria');
+  const parts = [];
+  if (action) parts.push(action);
+  if (accept) parts.push('Acceptance:\n' + accept);
+  parts.push('Task: ' + taskId);
+  if (Array.isArray(files) && files.length > 0) {
+    parts.push('Files: ' + files.join(', '));
+  }
+  return _sanitizeCommitBody(parts.join('\n\n'));
+}
+
 function run(args, ctx) {
   const context = ctx || {};
   const cwd = context.cwd || process.cwd();
@@ -153,13 +224,16 @@ function run(args, ctx) {
     );
   }
   const root = findProjectRoot(cwd);
-  const safeFiles = files.map((p) => _resolveSafe(root, p));
+  const declaredSafe = files.map((p) => _resolveSafe(root, p));
+  const safeFiles = _dedupe([...declaredSafe, ..._tddTestFiles(taskId, cwd, root)]);
   const name = _extractName(frontmatter, body);
   const message = 'task(' + taskId + '): ' + name;
+  // Compose the body from the paths that will actually be committed (commitTask
+  // drops gitignored entries), so `git log` never advertises a file the diff omits.
+  const { committable } = git.classifyCommittablePaths(safeFiles);
+  const commitBody = _composeCommitBody(body, taskId, committable);
 
-
-
-  const result = commitTask(taskId, safeFiles, message);
+  const result = commitTask(taskId, safeFiles, message, commitBody);
 
   if (result.committed === false && result.reason === 'artifacts-gitignored') {
     try {

package/bin/np-tools/commit-task.test.cjs

@@ -164,6 +164,139 @@ test('CT-3: commit-task emits JSON with sha + files on success', () => {
   assert.ok(subject.startsWith('task(M006-S001-T0001):'), 'subject: ' + subject);
 });
 
+test('CT-3b: subject strips the duplicated task-id prefix from the H1 heading', () => {
+  const root = makeRepo();
+  const taskId = 'M006-S001-T0050';
+  const m = taskId.match(/^(M\d{3,})-(S\d{3,})-(T\d{4,})$/);
+  const [, mId, sId, tId] = m;
+  const taskDir = path.join(root, '.nubos-pilot', 'milestones', mId, 'slices', sId, 'tasks', tId);
+  fs.mkdirSync(taskDir, { recursive: true });
+  fs.writeFileSync(path.join(taskDir, tId + '-PLAN.md'), [
+    '---',
+    `id: ${taskId}`,
+    `milestone: ${mId}`,
+    `slice: ${mId}-${sId}`,
+    'type: execute',
+    'status: in-progress',
+    'tier: sonnet',
+    'owner: np-executor',
+    'wave: 1',
+    'depends_on: []',
+    'files_modified:',
+    '  - src/a.ts',
+    'autonomous: true',
+    'must_haves: {}',
+    '---',
+    '',
+    `# ${taskId} — wire the outcome feedback loop`,
+    '',
+    '<action>',
+    'Add the OutcomeRecorder service and persist verdicts.',
+    '</action>',
+    '',
+    '<acceptance_criteria>',
+    '- Verdicts persist across restarts',
+    '- API returns 201 on record',
+    '</acceptance_criteria>',
+  ].join('\n'), 'utf-8');
+  seedLoopReadyCheckpoint(root, taskId);
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  const cap = _capture();
+  try {
+    subcmd.run([taskId], { cwd: root, stdout: cap.stub });
+  } finally {
+    process.chdir(prev);
+  }
+  const subject = execFileSync('git', ['-C', root, 'log', '-n', '1', '--format=%s'], { encoding: 'utf-8' }).trim();
+  assert.equal(subject, `task(${taskId}): wire the outcome feedback loop`,
+    'subject must not repeat the task id after the colon');
+  const fullBody = execFileSync('git', ['-C', root, 'log', '-n', '1', '--format=%b'], { encoding: 'utf-8' });
+  assert.match(fullBody, /Add the OutcomeRecorder service/, 'body should carry the <action> intent');
+  assert.match(fullBody, /Acceptance:/);
+  assert.match(fullBody, /Verdicts persist across restarts/);
+  assert.match(fullBody, new RegExp('Task: ' + taskId));
+  assert.match(fullBody, /Files: src\/a\.ts/);
+});
+
+test('CT-3c: test-writer files recorded in nubosloop.tdd_tests are folded into the commit', () => {
+  const root = makeRepo();
+  const taskId = 'M006-S001-T0060';
+  seedPlanAndTask(root, '06-01', taskId, ['src/a.ts']);
+  seedLoopReadyCheckpoint(root, taskId, { nubosloop: { tdd_tests: ['tests/a.test.ts'] } });
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'tests'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n', 'utf-8');
+  fs.writeFileSync(path.join(root, 'tests', 'a.test.ts'), 'test("a", () => {});\n', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    subcmd.run([taskId], { cwd: root, stdout: _capture().stub });
+  } finally {
+    process.chdir(prev);
+  }
+  const committed = execFileSync('git', ['-C', root, 'show', '--name-only', '--format=', 'HEAD'], { encoding: 'utf-8' });
+  assert.match(committed, /src\/a\.ts/, 'production file must be committed');
+  assert.match(committed, /tests\/a\.test\.ts/, 'tdd test file must be committed even though it is not in files_modified');
+});
+
+test('CT-3d: degenerate task name falls back to the id instead of an empty subject', () => {
+  const root = makeRepo();
+  const taskId = 'M006-S001-T0061';
+  const m = taskId.match(/^(M\d{3,})-(S\d{3,})-(T\d{4,})$/);
+  const [, mId, sId, tId] = m;
+  const taskDir = path.join(root, '.nubos-pilot', 'milestones', mId, 'slices', sId, 'tasks', tId);
+  fs.mkdirSync(taskDir, { recursive: true });
+  fs.writeFileSync(path.join(taskDir, tId + '-PLAN.md'), [
+    '---',
+    `id: ${taskId}`,
+    `milestone: ${mId}`,
+    `slice: ${mId}-${sId}`,
+    'type: execute', 'status: in-progress', 'tier: sonnet', 'owner: np-executor',
+    'wave: 1', 'depends_on: []',
+    'files_modified:', '  - src/a.ts',
+    'autonomous: true', 'must_haves: {}',
+    '---', '',
+    `# ${taskId} — `,
+  ].join('\n'), 'utf-8');
+  seedLoopReadyCheckpoint(root, taskId);
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    subcmd.run([taskId], { cwd: root, stdout: _capture().stub });
+  } finally {
+    process.chdir(prev);
+  }
+  const subject = execFileSync('git', ['-C', root, 'log', '-n', '1', '--format=%s'], { encoding: 'utf-8' }).trim();
+  assert.equal(subject, `task(${taskId}): ${taskId}`, 'empty name must fall back to the id, never a bare colon');
+});
+
+test('CT-3e: commit body Files: lists only committed paths, not gitignored ones', () => {
+  const root = makeRepo();
+  const taskId = 'M006-S001-T0062';
+  seedPlanAndTask(root, '06-01', taskId, ['src/a.ts', 'build/out.js']);
+  seedLoopReadyCheckpoint(root, taskId);
+  fs.writeFileSync(path.join(root, '.gitignore'), 'build/\n', 'utf-8');
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(root, 'build'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const a = 1;\n', 'utf-8');
+  fs.writeFileSync(path.join(root, 'build', 'out.js'), 'noise', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  try {
+    subcmd.run([taskId], { cwd: root, stdout: _capture().stub });
+  } finally {
+    process.chdir(prev);
+  }
+  const fullBody = execFileSync('git', ['-C', root, 'log', '-n', '1', '--format=%b'], { encoding: 'utf-8' });
+  assert.match(fullBody, /Files: src\/a\.ts/);
+  assert.doesNotMatch(fullBody, /build\/out\.js/, 'gitignored path must not be advertised in the body');
+});
+
 test('CT-4: commit-task SOFT-SKIPS when every files_modified entry is gitignored (artifacts-gitignored terminator)', () => {
   const root = makeRepo();
   seedPlanAndTask(root, '06-01', 'M006-S001-T0002', ['build/out.js']);

package/bin/np-tools/doctor.cjs

@@ -343,6 +343,7 @@ const NUBOSLOOP_CRITICS = [
   'np-critic-style',       // axis module (Style)
   'np-critic-tests',       // axis module (Tests)
   'np-critic-acceptance',  // axis module (Acceptance)
+  'np-critic-economy',     // axis module (Economy)
 ];
 
 function _checkNubosloopCritics(projectRoot) {

package/bin/np-tools/economy-mode.cjs

@@ -0,0 +1,47 @@
+'use strict';
+
+const { economyFlags } = require('../../lib/economy-mode.cjs');
+const { emitErrorEnvelope } = require('./_args.cjs');
+
+function _usage() {
+  return 'Usage:\n  np-tools.cjs economy-mode [--json]';
+}
+
+function _readConfig(cwd) {
+  const { readConfig } = require('../../lib/config.cjs');
+  try {
+    const cfg = readConfig(cwd);
+    return cfg && Object.keys(cfg).length === 0 ? null : cfg;
+  } catch (err) {
+    if (err && err.code === 'not-in-project') return null;
+    throw err;
+  }
+}
+
+function run(argv, ctx) {
+  const context = ctx || {};
+  const cwd = context.cwd || process.cwd();
+  const stdout = context.stdout || process.stdout;
+  const stderr = context.stderr || process.stderr;
+  const args = Array.isArray(argv) ? argv.slice() : [];
+  if (args.includes('--help') || args.includes('-h')) {
+    stdout.write(_usage() + '\n');
+    return 0;
+  }
+  const asJson = args.includes('--json');
+  try {
+    const config = _readConfig(cwd);
+    const flags = economyFlags(config || {});
+    stdout.write((asJson ? JSON.stringify(flags) : flags.mode) + '\n');
+    return 0;
+  } catch (err) {
+    emitErrorEnvelope(err, stderr, 'economy-mode-internal-error');
+    return 1;
+  }
+}
+
+module.exports = { run };
+
+if (require.main === module) {
+  process.exit(run(process.argv.slice(2)));
+}

package/bin/np-tools/loop-commands.test.cjs

@@ -426,6 +426,125 @@ function _seedSpawnEvidence(taskId, round, agents, cwd) {
   }
 }
 
+test('LCLI-RR-2a: phase=post-architect refuses without np-task-architect spawn audit', async () => {
+  const r = _mkRoot();
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  require('../../lib/nubosloop.cjs').recordLoopState('M001-S001-T0001', { round: 1 }, r);
+  const loopRunRound = require('./loop-run-round.cjs');
+  await assert.rejects(
+    () => loopRunRound.run(
+      ['M001-S001-T0001', '--phase', 'post-architect'],
+      { cwd: r, stdout: _cap().stub },
+    ),
+    (err) => err && err.code === 'loop-post-architect-missing-spawn-audit',
+  );
+});
+
+test('LCLI-RR-2b: phase=post-architect with stamp → spawn-test-writer, no round bump', async () => {
+  const r = _mkRoot();
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  _seedSpawnEvidence('M001-S001-T0001', 1, ['np-task-architect'], r);
+  const cap = _cap();
+  const loopRunRound = require('./loop-run-round.cjs');
+  await loopRunRound.run(['M001-S001-T0001', '--phase', 'post-architect'], { cwd: r, stdout: cap.stub });
+  const out = JSON.parse(cap.get());
+  assert.equal(out.phase, 'post-architect');
+  assert.equal(out.next_action, 'spawn-test-writer');
+  const cp = checkpoint.readCheckpoint('M001-S001-T0001', r);
+  assert.equal(cp.nubosloop.last_phase, 'post-architect');
+  assert.equal(cp.nubosloop.round, 1, 'prep step must not bump the round counter');
+});
+
+test('LCLI-RR-2c: phase=post-architect --force-post-architect bypasses the audit gate', async () => {
+  const r = _mkRoot();
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  require('../../lib/nubosloop.cjs').recordLoopState('M001-S001-T0001', { round: 1 }, r);
+  const cap = _cap();
+  const loopRunRound = require('./loop-run-round.cjs');
+  await loopRunRound.run(
+    ['M001-S001-T0001', '--phase', 'post-architect', '--force-post-architect'],
+    { cwd: r, stdout: cap.stub },
+  );
+  const out = JSON.parse(cap.get());
+  assert.equal(out.forced, true);
+  assert.equal(out.next_action, 'spawn-test-writer');
+});
+
+test('LCLI-RR-2d: phase=post-test-writer refuses without np-test-writer spawn audit', async () => {
+  const r = _mkRoot();
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  require('../../lib/nubosloop.cjs').recordLoopState('M001-S001-T0001', { round: 1 }, r);
+  const loopRunRound = require('./loop-run-round.cjs');
+  await assert.rejects(
+    () => loopRunRound.run(
+      ['M001-S001-T0001', '--phase', 'post-test-writer'],
+      { cwd: r, stdout: _cap().stub },
+    ),
+    (err) => err && err.code === 'loop-post-test-writer-missing-spawn-audit',
+  );
+});
+
+test('LCLI-RR-2e: phase=post-test-writer with stamp → spawn-executor, no round bump', async () => {
+  const r = _mkRoot();
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  _seedSpawnEvidence('M001-S001-T0001', 1, ['np-test-writer'], r);
+  const cap = _cap();
+  const loopRunRound = require('./loop-run-round.cjs');
+  await loopRunRound.run(['M001-S001-T0001', '--phase', 'post-test-writer'], { cwd: r, stdout: cap.stub });
+  const out = JSON.parse(cap.get());
+  assert.equal(out.phase, 'post-test-writer');
+  assert.equal(out.next_action, 'spawn-executor');
+  const cp = checkpoint.readCheckpoint('M001-S001-T0001', r);
+  assert.equal(cp.nubosloop.last_phase, 'post-test-writer');
+  assert.equal(cp.nubosloop.round, 1);
+});
+
+test('LCLI-RR-2f: phase=post-test-writer --tests records the written paths in nubosloop.tdd_tests', async () => {
+  const r = _mkRoot();
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  _seedSpawnEvidence('M001-S001-T0001', 1, ['np-test-writer'], r);
+  const cap = _cap();
+  const loopRunRound = require('./loop-run-round.cjs');
+  await loopRunRound.run(
+    ['M001-S001-T0001', '--phase', 'post-test-writer', '--tests', 'tests/a.test.ts, tests/b.test.ts'],
+    { cwd: r, stdout: cap.stub },
+  );
+  const out = JSON.parse(cap.get());
+  assert.deepEqual(out.tdd_tests, ['tests/a.test.ts', 'tests/b.test.ts']);
+  const cp = checkpoint.readCheckpoint('M001-S001-T0001', r);
+  assert.deepEqual(cp.nubosloop.tdd_tests, ['tests/a.test.ts', 'tests/b.test.ts']);
+});
+
+test('LCLI-RR-2g: post-researcher next_action skips disabled prep steps (architect off → test-writer)', async () => {
+  const r = _mkRoot();
+  fs.writeFileSync(
+    path.join(r, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ agents: { architect: false } }),
+    'utf-8',
+  );
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  _seedSpawnEvidence('M001-S001-T0001', 1, ['np-researcher', 'np-researcher', 'np-researcher'], r);
+  const cap = _cap();
+  const loopRunRound = require('./loop-run-round.cjs');
+  await loopRunRound.run(['M001-S001-T0001', '--phase', 'post-researcher'], { cwd: r, stdout: cap.stub });
+  assert.equal(JSON.parse(cap.get()).next_action, 'spawn-test-writer');
+});
+
+test('LCLI-RR-2h: post-researcher next_action → executor when both prep steps are off', async () => {
+  const r = _mkRoot();
+  fs.writeFileSync(
+    path.join(r, '.nubos-pilot', 'config.json'),
+    JSON.stringify({ agents: { architect: false, test_writer: false } }),
+    'utf-8',
+  );
+  checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
+  _seedSpawnEvidence('M001-S001-T0001', 1, ['np-researcher', 'np-researcher', 'np-researcher'], r);
+  const cap = _cap();
+  const loopRunRound = require('./loop-run-round.cjs');
+  await loopRunRound.run(['M001-S001-T0001', '--phase', 'post-researcher'], { cwd: r, stdout: cap.stub });
+  assert.equal(JSON.parse(cap.get()).next_action, 'spawn-executor');
+});
+
 test('LCLI-RR-3: loop-run-round phase=post-executor with verify-green → spawn-critic-schwarm', async () => {
   const r = _mkRoot();
   checkpoint.startTask({ id: 'M001-S001-T0001' }, r);
@@ -1184,7 +1303,7 @@ test('LCLI-RR-35: post-researcher accepts when k=3 np-researcher audits exist (T
     { cwd: r, stdout: cap.stub },
   );
   const out = JSON.parse(cap.get());
-  assert.equal(out.next_action, 'spawn-executor');
+  assert.equal(out.next_action, 'spawn-architect');
   assert.equal(out.forced, false);
   assert.equal(out.expected_researcher_count, 3);
 });
@@ -1207,7 +1326,7 @@ test('LCLI-RR-35b: post-researcher k-gate honors swarm.research.k config (Gap #6
   );
   const out = JSON.parse(cap.get());
   assert.equal(out.expected_researcher_count, 1);
-  assert.equal(out.next_action, 'spawn-executor');
+  assert.equal(out.next_action, 'spawn-architect');
 });
 
 test('LCLI-RR-36: --force-post-researcher bypasses Layer-C gate + stamps flag (T2)', async () => {

package/bin/np-tools/loop-run-round.cjs

@@ -7,6 +7,7 @@ const { NubosPilotError, safeAssign } = require('../../lib/core.cjs');
 const safePath = require('../../lib/safe-path.cjs');
 
 const checkpoint = require('../../lib/checkpoint.cjs');
+const config = require('../../lib/config.cjs');
 const nubosloop = require('../../lib/nubosloop.cjs');
 const messaging = require('../../lib/messaging.cjs');
 const compress = require('../../lib/compress.cjs');
@@ -40,6 +41,8 @@ function _verifyExcerpt(verifyOutput, cwd) {
 const VALID_PHASES = new Set([
   'preflight',
   'post-researcher',
+  'post-architect',
+  'post-test-writer',
   'post-executor',
   'post-critics',
   'commit',
@@ -153,13 +156,124 @@ function _runPostResearcher(taskId, list, cwd) {
   );
   return {
     phase: 'post-researcher',
-    next_action: 'spawn-executor',
+    next_action: _nextAfterResearcher(cwd),
     forced: force,
     expected_researcher_count: expectedK,
     round: merged.nubosloop ? merged.nubosloop.round : null,
   };
 }
 
+// Round-1 preparation steps (architect, test-writer) that run between the
+// researcher swarm and the executor. Each verifies its spawn was stamped via
+// `loop-audit-tool-use` (Layer-C SKIP-GUARD) and records last_phase. They never
+// bump the round counter — TDD writes tests once; build-fixer rounds iterate.
+// Config-gated in the orchestrator: when agents.architect / agents.test_writer
+// is off the step (and this phase) is simply never invoked.
+function _checkPrepSpawnAudited(taskId, list, cwd, agent, forceFlag) {
+  const force = list.includes(forceFlag);
+  const cur = checkpoint.readCheckpoint(taskId, cwd) || {};
+  const round = Number((cur.nubosloop && cur.nubosloop.round)) || 1;
+  const satisfied = force
+    ? true
+    : nubosloop.assertSpawnsAuditedForRound(taskId, [agent], round, cwd).satisfied;
+  return { force, round, satisfied };
+}
+
+function _stampPrepPhase(taskId, cwd, phase, lastAction, forcedKey, force, extraFn) {
+  return checkpoint.mergeCheckpoint(
+    taskId,
+    (curCp) => {
+      const prev = (curCp && curCp.nubosloop) || {};
+      const partial = { last_phase: phase, last_action: lastAction };
+      if (force) partial[forcedKey] = true;
+      if (typeof extraFn === 'function') safeAssign(partial, extraFn(prev));
+      return { nubosloop: safeAssign({}, prev, partial) };
+    },
+    cwd,
+  );
+}
+
+// The round-1 prep steps are config-gated, so the emitted next_action hint must
+// reflect which downstream steps are actually enabled — a consumer driving off
+// the JSON hint (rather than the ACTION CONTRACT prose) must not skip an enabled
+// architect/test-writer or stall on a disabled one.
+function _nextEnabled(cwd, steps) {
+  for (const [path, action] of steps) {
+    if (config.tryReadConfigPath(cwd, path, true, { onWarn() {} })) return action;
+  }
+  return 'spawn-executor';
+}
+
+function _nextAfterResearcher(cwd) {
+  return _nextEnabled(cwd, [['agents.architect', 'spawn-architect'], ['agents.test_writer', 'spawn-test-writer']]);
+}
+
+function _nextAfterArchitect(cwd) {
+  return _nextEnabled(cwd, [['agents.test_writer', 'spawn-test-writer']]);
+}
+
+// `--tests "a, b, c"` → ['a','b','c']; the post-test-writer phase records these
+// (the paths np-test-writer wrote) so commit-task can fold them into the commit.
+function _parseTestPaths(raw) {
+  if (typeof raw !== 'string' || raw.trim() === '') return [];
+  return raw.split(',').map((s) => s.trim()).filter((s) => s.length > 0);
+}
+
+function _runPostArchitect(taskId, list, cwd) {
+  const g = _checkPrepSpawnAudited(taskId, list, cwd, 'np-task-architect', '--force-post-architect');
+  if (!g.satisfied) {
+    throw new NubosPilotError(
+      'loop-post-architect-missing-spawn-audit',
+      'phase=post-architect refused: no `loop-audit-tool-use` record for round=' + g.round +
+      ', agent=np-task-architect on ' + taskId + '. ' +
+      'Spawn np-task-architect and call `loop-audit-tool-use ' + taskId +
+      ' --agent np-task-architect --tool-use-log <json>` after the spawn, ' +
+      'or pass --force-post-architect for an explicit override.',
+      { taskId, round: g.round, missing: ['np-task-architect'], required: ['np-task-architect'] },
+    );
+  }
+  const merged = _stampPrepPhase(taskId, cwd, 'post-architect', 'architect-spawned', 'forced_post_architect', g.force);
+  return {
+    phase: 'post-architect',
+    next_action: _nextAfterArchitect(cwd),
+    forced: g.force,
+    round: merged.nubosloop ? merged.nubosloop.round : g.round,
+  };
+}
+
+function _runPostTestWriter(taskId, list, cwd) {
+  const g = _checkPrepSpawnAudited(taskId, list, cwd, 'np-test-writer', '--force-post-test-writer');
+  if (!g.satisfied) {
+    throw new NubosPilotError(
+      'loop-post-test-writer-missing-spawn-audit',
+      'phase=post-test-writer refused: no `loop-audit-tool-use` record for round=' + g.round +
+      ', agent=np-test-writer on ' + taskId + '. ' +
+      'Spawn np-test-writer and call `loop-audit-tool-use ' + taskId +
+      ' --agent np-test-writer --tool-use-log <json>` after the spawn, ' +
+      'or pass --force-post-test-writer for an explicit override.',
+      { taskId, round: g.round, missing: ['np-test-writer'], required: ['np-test-writer'] },
+    );
+  }
+  const testPaths = _parseTestPaths(args.getFlag(list, '--tests'));
+  const merged = _stampPrepPhase(
+    taskId, cwd, 'post-test-writer', 'test-writer-spawned', 'forced_post_test_writer', g.force,
+    (prev) => {
+      const prior = Array.isArray(prev.tdd_tests) ? prev.tdd_tests : [];
+      const seen = new Set(prior);
+      const tdd_tests = prior.slice();
+      for (const p of testPaths) { if (!seen.has(p)) { seen.add(p); tdd_tests.push(p); } }
+      return { tdd_tests };
+    },
+  );
+  return {
+    phase: 'post-test-writer',
+    next_action: 'spawn-executor',
+    forced: g.force,
+    tdd_tests: merged.nubosloop && Array.isArray(merged.nubosloop.tdd_tests) ? merged.nubosloop.tdd_tests : [],
+    round: merged.nubosloop ? merged.nubosloop.round : g.round,
+  };
+}
+
 function _runPostExecutor(taskId, list, cwd) {
   const verifyExitCode = args.getFlag(list, '--verify-exit-code');
   if (verifyExitCode === undefined) {
@@ -311,7 +425,7 @@ function _runPostCritics(taskId, list, cwd) {
         'phase=post-critics refused: critic-schwarm spawn-evidence missing for round=' + gateRound +
         ' on ' + taskId + ' (missing audits: ' + verdict.missing.join(', ') + '). ' +
         'For each critic agent, call `loop-audit-tool-use ' + taskId +
-        ' --agent <np-critic-style|np-critic-tests|np-critic-acceptance> --tool-use-log <json>` ' +
+        ' --agent <np-critic-style|np-critic-tests|np-critic-acceptance|np-critic-economy> --tool-use-log <json>` ' +
         'after the spawn, then re-run --phase post-critics. Pass --force-post-critics for an explicit override.',
         { taskId, round: gateRound, missing: verdict.missing.slice(), required: nubosloop.POST_CRITICS_EVIDENCE.slice() },
       );
@@ -557,7 +671,7 @@ async function run(argv, ctx) {
   if (!phase) {
     throw new NubosPilotError(
       'loop-run-round-missing-phase',
-      'loop-run-round requires --phase <preflight|post-researcher|post-executor|post-critics|commit|stuck>',
+      'loop-run-round requires --phase <preflight|post-researcher|post-architect|post-test-writer|post-executor|post-critics|commit|stuck>',
       { hint: 'each phase corresponds to a non-LLM transition between LLM spawns' },
     );
   }
@@ -572,9 +686,11 @@ async function run(argv, ctx) {
   const tail = list.slice(1);
   let result;
   switch (phase) {
-    case 'preflight':       result = await _runPreflight(taskId, tail, cwd); break;
-    case 'post-researcher': result = _runPostResearcher(taskId, tail, cwd); break;
-    case 'post-executor':   result = _runPostExecutor(taskId, tail, cwd); break;
+    case 'preflight':        result = await _runPreflight(taskId, tail, cwd); break;
+    case 'post-researcher':  result = _runPostResearcher(taskId, tail, cwd); break;
+    case 'post-architect':   result = _runPostArchitect(taskId, tail, cwd); break;
+    case 'post-test-writer': result = _runPostTestWriter(taskId, tail, cwd); break;
+    case 'post-executor':    result = _runPostExecutor(taskId, tail, cwd); break;
     case 'post-critics':    result = _runPostCritics(taskId, tail, cwd); break;
     case 'commit':          result = _runCommit(taskId, tail, cwd); break;
     case 'stuck':           result = _runStuck(taskId, tail, cwd); break;

package/bin/np-tools/resolve-model.cjs

@@ -32,6 +32,7 @@ const CRITIC_TIER_OVERRIDES = {
   'np-critic-style':       'style_tier',
   'np-critic-tests':       'tests_tier',
   'np-critic-acceptance':  'acceptance_tier',
+  'np-critic-economy':     'economy_tier',
 };
 
 function _criticTierOverride(config, agentName) {