nubos-pilot 0.9.9 → 1.0.0

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

@@ -7,7 +7,7 @@ const { TASK_ID_RE, setTaskStatus } = require('../../lib/tasks.cjs');
 const layout = require('../../lib/layout.cjs');
 const git = require('../../lib/git.cjs');
 const { commitTask, findCommitByTaskId } = git;
-const { deleteCheckpoint, readCheckpoint } = require('../../lib/checkpoint.cjs');
+const { deleteCheckpoint, readCheckpoint, mergeCheckpoint } = require('../../lib/checkpoint.cjs');
 
 const BYPASS_FLAG = '--bypass-nubosloop';
 
@@ -162,7 +162,45 @@ function run(args, ctx) {
 
 
 
-  commitTask(taskId, safeFiles, message);
+  const result = commitTask(taskId, safeFiles, message);
+
+  if (result.committed === false && result.reason === 'artifacts-gitignored') {
+    // Soft-skip: every files_modified entry is gitignored. The task ran the
+    // full Nubosloop (preflight → executor → critic), edits landed locally,
+    // and the workflow already stamped `committed_at` via loop-run-round.
+    // We mark the task done WITHOUT a git commit, record the skip reason on
+    // the checkpoint for audit, and let the wave continue. Symmetric to
+    // commit_artifacts=false (commit.cjs:102) and to feedback_no_container_blocker:
+    // gitignore is a routing signal, never a hard stop.
+    try {
+      mergeCheckpoint(taskId, (cur) => ({
+        nubosloop: Object.assign({}, (cur && cur.nubosloop) || {}, {
+          commit_skipped: 'artifacts-gitignored',
+          files_ignored: result.files_ignored.slice(),
+        }),
+      }), cwd);
+    } catch (err) {
+      process.stderr.write('[nubos-pilot warn] checkpoint stamp failed for ' + taskId + ': ' + (err && err.message) + '\n');
+    }
+    try { deleteCheckpoint(taskId, cwd); } catch {}
+    try { setTaskStatus(taskId, 'done', cwd); } catch (err) {
+      process.stderr.write('[nubos-pilot warn] setTaskStatus failed for ' + taskId + ': ' + (err && err.message) + '\n');
+    }
+    const skipPayload = {
+      ok: true,
+      task_id: taskId,
+      committed: false,
+      skip_reason: 'artifacts-gitignored',
+      files: safeFiles,
+      files_ignored: result.files_ignored,
+      files_source: filesSource,
+      nubosloop_bypassed: gate.bypassed,
+      nubosloop_forced_commit_phase: !!gate.forced_commit_phase,
+    };
+    stdout.write(JSON.stringify(skipPayload));
+    return skipPayload;
+  }
+
   const sha = findCommitByTaskId(taskId);
 
   try { deleteCheckpoint(taskId, cwd); } catch {  }
@@ -173,8 +211,11 @@ function run(args, ctx) {
   const payload = {
     ok: true,
     task_id: taskId,
+    committed: true,
     sha,
     files: safeFiles,
+    files_committed: result.files_committed,
+    files_ignored: result.files_ignored,
     files_source: filesSource,
     nubosloop_bypassed: gate.bypassed,
     nubosloop_forced_commit_phase: !!gate.forced_commit_phase,

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

@@ -164,24 +164,59 @@ test('CT-3: commit-task emits JSON with sha + files on success', () => {
   assert.ok(subject.startsWith('task(M006-S001-T0001):'), 'subject: ' + subject);
 });
 
-test('CT-4: commit-task LOUD-FAILS when every files_modified entry is gitignored (D-25)', () => {
+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']);
   seedLoopReadyCheckpoint(root, 'M006-S001-T0002');
   fs.writeFileSync(path.join(root, '.gitignore'), 'build/\n', 'utf-8');
   fs.mkdirSync(path.join(root, 'build'), { recursive: true });
   fs.writeFileSync(path.join(root, 'build', 'out.js'), 'noise', 'utf-8');
+  const before = execFileSync('git', ['-C', root, 'log', '--format=%H'], { encoding: 'utf-8' }).trim().split('\n').filter(Boolean).length;
   const prev = process.cwd();
   process.chdir(root);
   const cap = _capture();
+  let payload;
   try {
-    assert.throws(
-      () => subcmd.run(['M006-S001-T0002'], { cwd: root, stdout: cap.stub }),
-      (err) => err && err.code === 'commit-all-paths-gitignored',
-    );
+    payload = subcmd.run(['M006-S001-T0002'], { cwd: root, stdout: cap.stub });
   } finally {
     process.chdir(prev);
   }
+  assert.equal(payload.ok, true);
+  assert.equal(payload.committed, false);
+  assert.equal(payload.skip_reason, 'artifacts-gitignored');
+  assert.deepEqual(payload.files_ignored, ['build/out.js']);
+  const after = execFileSync('git', ['-C', root, 'log', '--format=%H'], { encoding: 'utf-8' }).trim().split('\n').filter(Boolean).length;
+  assert.equal(after, before, 'soft-skip must not produce a commit');
+  const cpPath = path.join(root, '.nubos-pilot', 'checkpoints', 'M006-S001-T0002.json');
+  assert.equal(fs.existsSync(cpPath), false, 'checkpoint must be deleted on terminal skip (symmetric to commit success)');
+});
+
+test('CT-4b: commit-task commits the tracked subset on mixed paths (artifacts + real source)', () => {
+  const root = makeRepo();
+  seedPlanAndTask(root, '06-01', 'M006-S001-T0003', ['src/a.ts', '.nubos-pilot/codebase/modules/x.md']);
+  seedLoopReadyCheckpoint(root, 'M006-S001-T0003');
+  fs.writeFileSync(path.join(root, '.gitignore'), '.nubos-pilot/codebase/\n', 'utf-8');
+  fs.mkdirSync(path.join(root, 'src'), { recursive: true });
+  fs.writeFileSync(path.join(root, 'src', 'a.ts'), 'export const x = 1;', 'utf-8');
+  fs.mkdirSync(path.join(root, '.nubos-pilot', 'codebase', 'modules'), { recursive: true });
+  fs.writeFileSync(path.join(root, '.nubos-pilot', 'codebase', 'modules', 'x.md'), '# X', 'utf-8');
+  const prev = process.cwd();
+  process.chdir(root);
+  const cap = _capture();
+  let payload;
+  try {
+    payload = subcmd.run(['M006-S001-T0003'], { cwd: root, stdout: cap.stub });
+  } finally {
+    process.chdir(prev);
+  }
+  assert.equal(payload.ok, true);
+  assert.equal(payload.committed, true);
+  assert.deepEqual(payload.files_committed, ['src/a.ts']);
+  assert.deepEqual(payload.files_ignored, ['.nubos-pilot/codebase/modules/x.md']);
+  assert.ok(/^[0-9a-f]{40}$/.test(payload.sha));
+  const stat = execFileSync('git', ['-C', root, 'show', '--stat', '--format=', 'HEAD'], { encoding: 'utf-8' });
+  assert.match(stat, /src\/a\.ts/);
+  assert.doesNotMatch(stat, /codebase\/modules\/x\.md/);
 });
 
 test('CT-5: commit-task unknown task id → task-not-found', () => {

package/bin/np-tools/commit.cjs

@@ -107,7 +107,15 @@ function run(argv, ctx) {
     const normalized = _normalizeFiles(files, cwd, root);
     const committable = assertCommittablePaths(normalized, { cwd: root });
     if (committable.length === 0) {
-      throw new NubosPilotError('commit-no-paths', 'commit invoked with no committable paths', { files });
+      // All paths gitignored → soft-skip with structured payload (symmetric to
+      // commit_artifacts=false above). The earlier `commit-no-paths` throw
+      // turned a routing signal into a hard error.
+      stdout.write(JSON.stringify({
+        committed: false,
+        reason: 'artifacts-gitignored',
+        files_ignored: normalized,
+      }) + '\n');
+      return 0;
     }
     execFileSync('git', ['add', '--', ...committable], { cwd: root, stdio: 'pipe' });
     execFileSync('git', ['commit', '-m', msg, '--', ...committable], { cwd: root, stdio: 'pipe' });

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

@@ -141,6 +141,34 @@ test('COMMIT-5: workflow.commit_artifacts=false skips commit silently with exit
   assert.equal(logOut, '', 'expected no commits to be created');
 });
 
+test('COMMIT-7: all-paths-gitignored soft-skips with structured payload (exit 0, no commit)', () => {
+  const sb = makeSandbox();
+  initGit(sb);
+  fs.writeFileSync(path.join(sb, '.gitignore'), 'build/\n');
+  fs.mkdirSync(path.join(sb, 'build'), { recursive: true });
+  fs.writeFileSync(path.join(sb, 'build', 'out.js'), 'noise');
+  const stdout = makeSink();
+  const stderr = makeSink();
+  const origCwd = process.cwd();
+  process.chdir(sb);
+  let code;
+  try {
+    code = commitCli.run(['chore: artifact', '--files', 'build/out.js'], { stdout, stderr });
+  } finally {
+    process.chdir(origCwd);
+  }
+  assert.equal(code, 0, 'stderr=' + stderr.toString());
+  const payload = JSON.parse(stdout.toString().trim());
+  assert.equal(payload.committed, false);
+  assert.equal(payload.reason, 'artifacts-gitignored');
+  assert.deepEqual(payload.files_ignored, ['build/out.js']);
+  let logOut;
+  try {
+    logOut = execFileSync('git', ['log', '--format=%H'], { cwd: sb, encoding: 'utf-8' });
+  } catch { logOut = ''; }
+  assert.equal(logOut.trim(), '', 'expected no commits to be created');
+});
+
 test('COMMIT-6: workflow.commit_artifacts=true still commits normally', () => {
   const sb = makeSandbox();
   initGit(sb);

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

@@ -71,7 +71,7 @@ function _runPreflight(taskId, list, cwd) {
       );
     }
   }
-  const opts = {};
+  const opts = { taskId };
   const t = args.getFlag(list, '--threshold');
   if (t !== undefined) opts.threshold = Number(t);
   const m = args.getFlag(list, '--min-occurrence');
@@ -103,6 +103,7 @@ function _runPreflight(taskId, list, cwd) {
     cache_hit: result.hit,
     bypass_swarm: result.bypass_swarm,
     cache_miss_reason: result.cache_miss_reason,
+    swarm: result.swarm,
     forced: force,
   };
 }

package/bin/researcher-merge.cjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const swarm = require('../lib/researcher-swarm.cjs');
+
+const USAGE = [
+  'Usage:',
+  '  researcher-merge.cjs <spawn-output-1.json> [spawn-output-2.json] [...] [options]',
+  '  researcher-merge.cjs --stdin [options]',
+  '',
+  'Options:',
+  '  --stdin            Read a JSON array of spawn outputs from stdin instead of file args',
+  '  --out <path>       Write rendered consensus markdown to <path> (default: stdout)',
+  '  --json             Emit the merged consensus as JSON instead of markdown',
+  '  --heading <text>   Markdown heading (default: "Researcher-Schwarm Consensus")',
+  '  -h, --help         Show this help',
+  '',
+  'Each spawn output must be a JSON object with shape:',
+  '  { decisions[], risks[], patterns[], open_questions[], sources[] }',
+  '',
+  'Exit codes:',
+  '  0 success, 2 invalid usage, 3 unreadable input, 4 invalid spawn output',
+].join('\n');
+
+function _hasFlag(argv, name) { return argv.includes(name); }
+function _flag(argv, name) {
+  const i = argv.indexOf(name);
+  return i >= 0 && i + 1 < argv.length ? argv[i + 1] : null;
+}
+
+function _die(code, msg) {
+  process.stderr.write(msg + '\n');
+  process.exit(code);
+}
+
+function _readJson(file) {
+  let raw;
+  try { raw = fs.readFileSync(file, 'utf-8'); }
+  catch (err) { _die(3, 'researcher-merge: cannot read ' + file + ': ' + err.message); }
+  try { return JSON.parse(raw); }
+  catch (err) { _die(4, 'researcher-merge: invalid JSON in ' + file + ': ' + err.message); }
+}
+
+function _readStdin() {
+  return new Promise((resolve, reject) => {
+    let buf = '';
+    process.stdin.setEncoding('utf-8');
+    process.stdin.on('data', (chunk) => { buf += chunk; });
+    process.stdin.on('end', () => resolve(buf));
+    process.stdin.on('error', reject);
+  });
+}
+
+async function _collectInputs(argv) {
+  if (_hasFlag(argv, '--stdin')) {
+    const raw = await _readStdin();
+    let parsed;
+    try { parsed = JSON.parse(raw); }
+    catch (err) { _die(4, 'researcher-merge: invalid JSON on stdin: ' + err.message); }
+    if (!Array.isArray(parsed)) {
+      _die(4, 'researcher-merge: --stdin payload must be a JSON array of spawn outputs');
+    }
+    return parsed;
+  }
+  const files = argv.filter((a) => !a.startsWith('-') && a !== _flag(argv, '--out') && a !== _flag(argv, '--heading'));
+  if (!files.length) _die(2, USAGE);
+  return files.map(_readJson);
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (_hasFlag(argv, '-h') || _hasFlag(argv, '--help')) {
+    process.stdout.write(USAGE + '\n');
+    process.exit(0);
+  }
+  if (!argv.length) _die(2, USAGE);
+  const outPath = _flag(argv, '--out');
+  const heading = _flag(argv, '--heading');
+  const asJson = _hasFlag(argv, '--json');
+  const inputs = await _collectInputs(argv);
+  for (let i = 0; i < inputs.length; i += 1) {
+    const o = inputs[i];
+    if (!o || typeof o !== 'object' || Array.isArray(o)) {
+      _die(4, 'researcher-merge: spawn output #' + i + ' must be a JSON object');
+    }
+  }
+  const consensus = swarm.mergeConsensus(inputs);
+  const payload = asJson
+    ? JSON.stringify(consensus, null, 2) + '\n'
+    : swarm.renderConsensusToMarkdown(consensus, heading ? { heading } : undefined);
+  if (outPath) {
+    fs.mkdirSync(path.dirname(path.resolve(outPath)), { recursive: true });
+    fs.writeFileSync(outPath, payload, 'utf-8');
+    process.stdout.write(outPath + '\n');
+  } else {
+    process.stdout.write(payload);
+  }
+}
+
+main().catch((err) => _die(1, 'researcher-merge: ' + (err && err.stack ? err.stack : String(err))));

package/bin/researcher-merge.test.cjs

@@ -0,0 +1,142 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { spawnSync } = require('node:child_process');
+
+const CLI = path.resolve(__dirname, 'researcher-merge.cjs');
+
+function _mkTmp() {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'np-merge-'));
+}
+
+function _spawn(args, opts) {
+  return spawnSync('node', [CLI, ...args], Object.assign({ encoding: 'utf-8' }, opts || {}));
+}
+
+function _writeJson(dir, name, obj) {
+  const p = path.join(dir, name);
+  fs.writeFileSync(p, JSON.stringify(obj), 'utf-8');
+  return p;
+}
+
+const SAME_INPUT_OUTPUT = (extra) => Object.assign({
+  decisions: [{ claim: 'use jose for JWT', confidence: 'HIGH', provenance: '[VERIFIED]' }],
+  risks: [],
+  patterns: [{ name: 'verifyJwt', description: 'verifyJwt(token, jwks)' }],
+  open_questions: [],
+  sources: [],
+}, extra || {});
+
+test('RM-1: file-args produce consensus markdown with high agreement_score', () => {
+  const r = _mkTmp();
+  try {
+    const a = _writeJson(r, 'a.json', SAME_INPUT_OUTPUT());
+    const b = _writeJson(r, 'b.json', SAME_INPUT_OUTPUT());
+    const c = _writeJson(r, 'c.json', SAME_INPUT_OUTPUT({ risks: [{ description: 'key rotation', severity: 'MEDIUM' }] }));
+    const res = _spawn([a, b, c]);
+    assert.equal(res.status, 0, res.stderr);
+    assert.match(res.stdout, /<consensus_meta>/);
+    assert.match(res.stdout, /agreement_score: 1\.000/);
+    assert.match(res.stdout, /use jose for JWT.*agreement=3/);
+    assert.match(res.stdout, /verifyJwt.*agreement=3/);
+    assert.match(res.stdout, /\[MEDIUM\] key rotation/);
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('RM-2: --stdin reads JSON array', () => {
+  const inputs = [SAME_INPUT_OUTPUT(), SAME_INPUT_OUTPUT(), SAME_INPUT_OUTPUT()];
+  const res = _spawn(['--stdin'], { input: JSON.stringify(inputs) });
+  assert.equal(res.status, 0, res.stderr);
+  assert.match(res.stdout, /agreement_score: 1\.000/);
+});
+
+test('RM-3: --json emits structured consensus', () => {
+  const r = _mkTmp();
+  try {
+    const a = _writeJson(r, 'a.json', SAME_INPUT_OUTPUT());
+    const res = _spawn([a, '--json']);
+    assert.equal(res.status, 0, res.stderr);
+    const parsed = JSON.parse(res.stdout);
+    assert.equal(parsed.meta.k, 1);
+    assert.ok(Array.isArray(parsed.decisions));
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('RM-4: topic-split spawns produce ZERO majority decisions and EMPTY pattern intersection (the canonical bug we guard against)', () => {
+  const r = _mkTmp();
+  try {
+    const a = _writeJson(r, 'a.json', {
+      decisions: [{ claim: 'install Cashier 16 via composer require laravel/cashier', confidence: 'HIGH', provenance: '[CITED: cashier docs]' }],
+      risks: [], patterns: [{ name: 'composerInstall' }], open_questions: [], sources: [],
+    });
+    const b = _writeJson(r, 'b.json', {
+      decisions: [{ claim: 'use Pest for feature tests', confidence: 'HIGH', provenance: '[CITED: pest docs]' }],
+      risks: [], patterns: [{ name: 'pestFeatureTest' }], open_questions: [], sources: [],
+    });
+    const c = _writeJson(r, 'c.json', {
+      decisions: [{ claim: 'set CASHIER_CURRENCY in .env', confidence: 'HIGH', provenance: '[CITED: env docs]' }],
+      risks: [], patterns: [{ name: 'envConfig' }], open_questions: [], sources: [],
+    });
+    const res = _spawn([a, b, c, '--json']);
+    assert.equal(res.status, 0, res.stderr);
+    const parsed = JSON.parse(res.stdout);
+    assert.equal(parsed.decisions.length, 0, 'no claim reaches majority — every decision is seen by exactly one spawn');
+    assert.equal(parsed.flagged_decisions.length, 3, 'every decision lands in flagged because none crossed the majority threshold');
+    assert.equal(parsed.patterns.length, 0, 'no pattern reaches the k≥2 intersection threshold');
+    assert.equal(parsed.meta.flagged_count, 3);
+    assert.ok(
+      parsed.meta.agreement_score < 0.5,
+      'topic-split surfaces as low agreement_score (each decision seen by 1/3 spawns ≈ 0.333), unambiguously distinguishable from full consensus (1.0)',
+    );
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('RM-5: --out writes consensus to file and prints the path', () => {
+  const r = _mkTmp();
+  try {
+    const a = _writeJson(r, 'a.json', SAME_INPUT_OUTPUT());
+    const out = path.join(r, 'consensus.md');
+    const res = _spawn([a, '--out', out]);
+    assert.equal(res.status, 0, res.stderr);
+    assert.equal(res.stdout.trim(), out);
+    const written = fs.readFileSync(out, 'utf-8');
+    assert.match(written, /Researcher-Schwarm Consensus/);
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('RM-6: invalid JSON in spawn output exits 4', () => {
+  const r = _mkTmp();
+  try {
+    const bad = path.join(r, 'bad.json');
+    fs.writeFileSync(bad, 'NOT JSON', 'utf-8');
+    const res = _spawn([bad]);
+    assert.equal(res.status, 4);
+    assert.match(res.stderr, /invalid JSON/);
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('RM-7: no args exits 2 with usage', () => {
+  const res = _spawn([]);
+  assert.equal(res.status, 2);
+  assert.match(res.stderr, /Usage:/);
+});
+
+test('RM-8: --stdin with non-array exits 4', () => {
+  const res = _spawn(['--stdin'], { input: '{"not":"an array"}' });
+  assert.equal(res.status, 4);
+  assert.match(res.stderr, /must be a JSON array/);
+});
+
+test('RM-9: --heading overrides default consensus heading', () => {
+  const r = _mkTmp();
+  try {
+    const a = _writeJson(r, 'a.json', SAME_INPUT_OUTPUT());
+    const res = _spawn([a, '--heading', 'Cashier 16 Consensus']);
+    assert.equal(res.status, 0, res.stderr);
+    assert.match(res.stdout, /^# Cashier 16 Consensus/m);
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});

package/lib/git.cjs

@@ -24,11 +24,11 @@ function isPathIgnored(p, opts) {
   }
 }
 
-function assertCommittablePaths(paths, opts) {
+function classifyCommittablePaths(paths, opts) {
   if (!Array.isArray(paths)) {
     throw new NubosPilotError(
       'commit-paths-invalid',
-      'assertCommittablePaths expects an array of paths',
+      'classifyCommittablePaths expects an array of paths',
       { got: typeof paths },
     );
   }
@@ -42,41 +42,58 @@ function assertCommittablePaths(paths, opts) {
     } catch (err) {
       if (_isFatalCheckIgnore(err)) {
         if (err.status === 128) throw err;
-
       }
     }
   }
-  if (ignored.length > 0 && ignored.length === paths.length) {
-
-    throw new NubosPilotError(
-      'commit-all-paths-gitignored',
-      `All target paths are gitignored: ${paths.join(', ')}`,
-      { paths },
-    );
-  }
-  if (ignored.length > 0) {
+  const committable = paths.filter((p) => !ignored.includes(p));
+  return { committable, ignored };
+}
 
+function assertCommittablePaths(paths, opts) {
+  const { committable, ignored } = classifyCommittablePaths(paths, opts);
+  // Soft-skip on all-ignored: return [] and let the caller decide. The earlier
+  // throw turned a workflow-level routing decision (artifact-only tasks whose
+  // outputs land in gitignored paths — e.g. `.nubos-pilot/codebase/modules/*.md`
+  // when the operator opted out of versioning planning artifacts) into a hard
+  // crash. Symmetric to `feedback_no_container_blocker`: gitignore state is a
+  // routing signal, not a blocker.
+  if (ignored.length > 0 && committable.length > 0) {
     process.stderr.write(
       `[nubos-pilot warn] gitignored (skipping): ${ignored.join(', ')}\n`,
     );
   }
-  return paths.filter((p) => !ignored.includes(p));
+  return committable;
 }
 
 function commitTask(taskId, files, message) {
-  const committable = assertCommittablePaths(files);
+  const { committable, ignored } = classifyCommittablePaths(files);
   if (committable.length === 0) {
-
-    
-
+    if (ignored.length > 0) {
+      return {
+        committed: false,
+        reason: 'artifacts-gitignored',
+        files_committed: [],
+        files_ignored: ignored.slice(),
+      };
+    }
     throw new NubosPilotError(
       'commit-no-paths',
       'commitTask invoked with empty file list',
       { taskId },
     );
   }
+  if (ignored.length > 0) {
+    process.stderr.write(
+      `[nubos-pilot warn] gitignored (skipping): ${ignored.join(', ')}\n`,
+    );
+  }
   execFileSync('git', ['add', '--', ...committable], { stdio: 'pipe' });
   execFileSync('git', ['commit', '-m', message, '--', ...committable], { stdio: 'pipe' });
+  return {
+    committed: true,
+    files_committed: committable.slice(),
+    files_ignored: ignored.slice(),
+  };
 }
 
 function findCommitByTaskId(id) {
@@ -257,6 +274,7 @@ function runGit(args, opts) {
 module.exports = {
   commitTask,
   assertCommittablePaths,
+  classifyCommittablePaths,
   revertCommit,
   restoreFiles,
   checkoutFromHead,

package/lib/git.test.cjs

@@ -82,21 +82,89 @@ test('GIT-2: assertCommittablePaths writes stderr warning for partial-ignored an
   });
 });
 
-test('GIT-3: assertCommittablePaths throws commit-all-paths-gitignored when every path ignored (D-25)', () => {
+test('GIT-3: assertCommittablePaths SOFT-SKIPS when every path ignored (returns [], no throw, no stderr noise)', () => {
   const root = makeRepo();
   inRepo(root, () => {
     writeFile(root, '.gitignore', '.env\nsecret.txt\n');
     writeFile(root, '.env', 'X=1');
     writeFile(root, 'secret.txt', 'shh');
-    assert.throws(
-      () => git.assertCommittablePaths(['.env', 'secret.txt']),
-      (err) => {
-        return err.name === 'NubosPilotError'
-          && err.code === 'commit-all-paths-gitignored'
-          && Array.isArray(err.details.paths)
-          && err.details.paths.includes('.env');
-      },
-    );
+    const original = process.stderr.write;
+    let captured = '';
+    process.stderr.write = (chunk) => { captured += chunk; return true; };
+    let result;
+    try {
+      result = git.assertCommittablePaths(['.env', 'secret.txt']);
+    } finally {
+      process.stderr.write = original;
+    }
+    assert.deepEqual(result, []);
+    assert.equal(captured, '', 'all-ignored is a routing signal, not a warning — caller surfaces the skip reason');
+  });
+});
+
+test('GIT-3b: classifyCommittablePaths returns clean { committable, ignored } split without side effects', () => {
+  const root = makeRepo();
+  inRepo(root, () => {
+    writeFile(root, '.gitignore', 'build/\n.env\n');
+    writeFile(root, 'src/a.ts', 'x');
+    writeFile(root, 'src/b.ts', 'y');
+    writeFile(root, 'build/out.js', 'noise');
+    writeFile(root, '.env', 'X=1');
+    const original = process.stderr.write;
+    let captured = '';
+    process.stderr.write = (chunk) => { captured += chunk; return true; };
+    let res;
+    try {
+      res = git.classifyCommittablePaths(['src/a.ts', 'build/out.js', 'src/b.ts', '.env']);
+    } finally {
+      process.stderr.write = original;
+    }
+    assert.deepEqual(res.committable, ['src/a.ts', 'src/b.ts']);
+    assert.deepEqual(res.ignored.sort(), ['.env', 'build/out.js']);
+    assert.equal(captured, '', 'classify is pure introspection — no stderr writes');
+  });
+});
+
+test('GIT-3c: commitTask returns soft-skip payload when every path is gitignored (no commit created)', () => {
+  const root = makeRepo();
+  inRepo(root, () => {
+    writeFile(root, '.gitignore', 'build/\n');
+    writeFile(root, 'build/out.js', 'noise');
+    const before = execFileSync('git', ['log', '--format=%H'], { encoding: 'utf-8' }).trim().split('\n').filter(Boolean).length;
+    const result = git.commitTask('M006-S001-T0099', ['build/out.js'], 'task(M006-S001-T0099): doc update');
+    assert.equal(result.committed, false);
+    assert.equal(result.reason, 'artifacts-gitignored');
+    assert.deepEqual(result.files_committed, []);
+    assert.deepEqual(result.files_ignored, ['build/out.js']);
+    const after = execFileSync('git', ['log', '--format=%H'], { encoding: 'utf-8' }).trim().split('\n').filter(Boolean).length;
+    assert.equal(after, before, 'no new commit for soft-skip');
+  });
+});
+
+test('GIT-3d: commitTask commits the tracked subset on mixed paths (warns about ignored entries)', () => {
+  const root = makeRepo();
+  inRepo(root, () => {
+    writeFile(root, '.gitignore', 'build/\n');
+    writeFile(root, 'src/a.ts', 'x');
+    writeFile(root, 'build/out.js', 'noise');
+    const original = process.stderr.write;
+    let captured = '';
+    process.stderr.write = (chunk) => { captured += chunk; return true; };
+    let result;
+    try {
+      result = git.commitTask('M006-S001-T0100', ['src/a.ts', 'build/out.js'], 'task(M006-S001-T0100): mixed');
+    } finally {
+      process.stderr.write = original;
+    }
+    assert.equal(result.committed, true);
+    assert.deepEqual(result.files_committed, ['src/a.ts']);
+    assert.deepEqual(result.files_ignored, ['build/out.js']);
+    assert.match(captured, /gitignored \(skipping\)/);
+    const subject = execFileSync('git', ['log', '-n', '1', '--format=%s'], { encoding: 'utf-8' }).trim();
+    assert.equal(subject, 'task(M006-S001-T0100): mixed');
+    const stat = execFileSync('git', ['show', '--stat', '--format=', 'HEAD'], { encoding: 'utf-8' });
+    assert.match(stat, /src\/a\.ts/);
+    assert.doesNotMatch(stat, /build\/out\.js/);
   });
 });
 

package/lib/nubosloop.cjs

@@ -636,31 +636,71 @@ function preflightCacheLookup(query, opts, cwd) {
     );
   }
   const o = safeAssign({}, swarm.resolveSwarmOpts(cwd), opts || {});
+  const taskId = (opts && typeof opts.taskId === 'string') ? opts.taskId : null;
+  const spawnInput = taskId
+    ? { task_id: taskId, task_query: query }
+    : { task_query: query };
+  // Symmetry with research-phase init: spawn_specs are built unconditionally
+  // and the consumer decides via bypass_swarm whether to ignore them. This
+  // closes the execute-phase gap where the orchestrator had no per-spawn
+  // contract and fell back to topic-splitting (FAIL-S from the 2026-05-05
+  // researcher-swarm review).
+  const spawnSpecs = swarm.buildSpawnSpecs(spawnInput, o.k);
+  const swarmBlock = {
+    k: o.k,
+    threshold: o.threshold,
+    min_occurrence: o.minOccurrence,
+    spawn_specs: spawnSpecs,
+  };
   const SOFT_CACHE_FAILURES = new Set(['mcp-adapter-not-implemented', 'knowledge-adapter-unknown']);
   let adapter;
   try { adapter = getAdapter(cwd); }
   catch (err) {
     if (err && err.name === 'NubosPilotError' && SOFT_CACHE_FAILURES.has(err.code)) {
-      return { hit: null, bypass_swarm: false, cache_miss_reason: { code: err.code, message: err.message } };
+      return {
+        hit: null,
+        bypass_swarm: false,
+        cache_miss_reason: { code: err.code, message: err.message },
+        swarm: safeAssign({}, swarmBlock, {
+          cache_hit: null,
+          cache_miss_reason: { code: err.code, message: err.message },
+          bypass_swarm: false,
+        }),
+      };
     }
     throw err;
   }
   const m = adapter.match(query, { threshold: o.threshold, minOccurrence: o.minOccurrence });
   if (m && m.best) {
+    const hit = {
+      adapter: adapter.name,
+      fingerprint: m.best.fingerprint,
+      pattern: m.best.pattern,
+      outcome: m.best.outcome,
+      occurrence: m.best.occurrence,
+      similarity: m.best.similarity,
+    };
     return {
-      hit: {
-        adapter: adapter.name,
-        fingerprint: m.best.fingerprint,
-        pattern: m.best.pattern,
-        outcome: m.best.outcome,
-        occurrence: m.best.occurrence,
-        similarity: m.best.similarity,
-      },
+      hit,
       bypass_swarm: true,
       cache_miss_reason: null,
+      swarm: safeAssign({}, swarmBlock, {
+        cache_hit: hit,
+        cache_miss_reason: null,
+        bypass_swarm: true,
+      }),
     };
   }
-  return { hit: null, bypass_swarm: false, cache_miss_reason: null };
+  return {
+    hit: null,
+    bypass_swarm: false,
+    cache_miss_reason: null,
+    swarm: safeAssign({}, swarmBlock, {
+      cache_hit: null,
+      cache_miss_reason: null,
+      bypass_swarm: false,
+    }),
+  };
 }
 
 function _emptyHistogram(maxRounds) {

package/lib/nubosloop.test.cjs

@@ -753,6 +753,62 @@ test('NL-PF-5: preflightCacheLookup rejects empty query', () => {
   } finally { fs.rmSync(r, { recursive: true, force: true }); }
 });
 
+test('NL-PF-6: preflightCacheLookup populates swarm.spawn_specs on cache miss (k entries, identical input, distinct seed_delta)', () => {
+  const r = _mkRoot();
+  try {
+    const out = loop.preflightCacheLookup('install Cashier 16 with Sanctum auth', { taskId: 'M001-S001-T0001' }, r);
+    assert.equal(out.bypass_swarm, false);
+    assert.ok(out.swarm, 'swarm block must be present on miss');
+    assert.equal(out.swarm.bypass_swarm, false);
+    assert.equal(out.swarm.k, 3);
+    assert.ok(Array.isArray(out.swarm.spawn_specs));
+    assert.equal(out.swarm.spawn_specs.length, 3);
+    const inputs = out.swarm.spawn_specs.map((s) => JSON.stringify(s.input));
+    assert.equal(new Set(inputs).size, 1, 'every spawn_spec must carry the IDENTICAL input — topic-split is the bug this guards');
+    assert.equal(out.swarm.spawn_specs[0].input.task_query, 'install Cashier 16 with Sanctum auth');
+    assert.equal(out.swarm.spawn_specs[0].input.task_id, 'M001-S001-T0001');
+    const deltas = out.swarm.spawn_specs.map((s) => s.seed_delta);
+    assert.equal(new Set(deltas).size, 3, 'each spawn_spec must carry a DISTINCT seed_delta');
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('NL-PF-7: preflightCacheLookup still emits swarm block on cache hit (orchestrator may bypass; payload stays symmetric)', () => {
+  const r = _mkRoot();
+  try {
+    learnings.logLearning({ pattern: 'use jose for jwt verification', outcome: 'verified' }, r);
+    learnings.logLearning({ pattern: 'use jose for jwt verification', outcome: 'verified' }, r);
+    learnings.logLearning({ pattern: 'use jose for jwt verification', outcome: 'verified' }, r);
+    const out = loop.preflightCacheLookup('use jose for jwt verification', { threshold: 0.5, minOccurrence: 3 }, r);
+    assert.equal(out.bypass_swarm, true);
+    assert.ok(out.swarm);
+    assert.equal(out.swarm.bypass_swarm, true);
+    assert.ok(out.swarm.cache_hit);
+    assert.equal(out.swarm.spawn_specs.length, 3);
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('NL-PF-8: preflightCacheLookup honors swarm.research.k from config', () => {
+  const r = _mkRoot({ swarm: { research: { k: 5 } } });
+  try {
+    const out = loop.preflightCacheLookup('whatever query', {}, r);
+    assert.equal(out.swarm.k, 5);
+    assert.equal(out.swarm.spawn_specs.length, 5);
+    const deltas = out.swarm.spawn_specs.map((s) => s.seed_delta);
+    assert.equal(new Set(deltas).size, 5);
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
+test('NL-PF-9: preflightCacheLookup soft-fail still includes swarm block (orchestrator can spawn while cache adapter is down)', () => {
+  const r = _mkRoot({ swarm: { knowledge_adapter: 'mcp' } });
+  try {
+    const out = loop.preflightCacheLookup('any query', {}, r);
+    assert.equal(out.cache_miss_reason.code, 'mcp-adapter-not-implemented');
+    assert.ok(out.swarm);
+    assert.equal(out.swarm.spawn_specs.length, 3);
+    assert.equal(out.swarm.cache_miss_reason.code, 'mcp-adapter-not-implemented');
+  } finally { fs.rmSync(r, { recursive: true, force: true }); }
+});
+
 test('NL-28: persisted tokens field is reused on match (no re-tokenize)', () => {
   const r = _mkRoot();
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nubos-pilot",
-  "version": "0.9.9",
+  "version": "1.0.0",
   "description": "AI-driven planning and execution tool for code projects",
   "homepage": "https://github.com/Nubos-AI/nubos-pilot",
   "repository": {

package/workflows/execute-phase.md

@@ -135,6 +135,15 @@ Every task runs through the **Nubosloop** ([ADR-0010](../docs/adr/0010-nubosloop
 
 7. **Commit** — `loop-run-round --phase commit --learning-pattern "$CONSENSUS_PATTERN" --learning-outcome verified` stamps the checkpoint to `pre-commit` and auto-logs the learning (when `auto_log_learning=true`, default — feeds future Round-1 cache hits). Then `node .nubos-pilot/bin/np-tools.cjs commit-task "$TASK_ID"` performs the atomic commit per ADR-0004.
 
+   **Two terminal outcomes**, both exit 0 and complete the task:
+
+   | `committed` | `skip_reason`           | When it fires                                                              | Wave handling |
+   |-------------|-------------------------|----------------------------------------------------------------------------|---------------|
+   | `true`      | _(absent)_              | At least one `files_modified` entry is tracked → atomic commit lands       | Continue      |
+   | `false`     | `artifacts-gitignored`  | Every `files_modified` entry is gitignored (e.g. `.nubos-pilot/codebase/modules/*.md` when artifacts aren't versioned) | Continue — task is done, no commit produced |
+
+   The orchestrator checks `git check-ignore --quiet --` per file: exit 0 = ignored, exit 1 = tracked, exit ≥ 2 = real failure (propagate). Soft-skip is not a failure mode — `commit-task` deletes the checkpoint and sets task status to `done` symmetric to a real commit. **Mixed paths** (some tracked, some ignored) commit only the tracked subset and emit a `[nubos-pilot warn] gitignored (skipping): …` line; the task is `committed: true` with `files_ignored` populated for audit. Gitignore state is a routing signal, never a hard stop — symmetric to the container-state doctrine.
+
 **Per-task loop control values (read once at wave start):**
 
 ```bash
@@ -211,9 +220,21 @@ for WAVE_INDEX in 0 1 2 ...; do
 
       # === Step 2: Researcher-Schwarm (cache miss on R1, or re-route on R≥2) ===
       # PARALLEL spawn of $SWARM_K agents/np-researcher.md (single message,
-      # $SWARM_K Agent blocks). Merge via lib/researcher-swarm.cjs::mergeConsensus.
-      # Result is injected into the next executor prompt as $CONSENSUS_PATTERN
-      # with provenance ([VERIFIED] on majority + spawn-citation, else [PROVISIONAL]).
+      # $SWARM_K Agent blocks). Merge via lib/researcher-swarm.cjs::mergeConsensus
+      # (exposed as `bin/researcher-merge.cjs`). Result is injected into the next
+      # executor prompt as $CONSENSUS_PATTERN with provenance ([VERIFIED] on
+      # majority + spawn-citation, else [PROVISIONAL]).
+      #
+      # SPAWN CONTRACT — symmetric to research-phase Step 4. Every spawn receives
+      # the SAME `<task_query>` (the loop's `$TASK_QUERY`, identical for all k
+      # researchers — this is what makes the merge a CONSENSUS over the same
+      # question, not a divide-and-conquer over k different questions). The only
+      # per-spawn variation is a single `<seed_delta>` line read from
+      # `swarm.spawn_specs[i].seed_delta` (preflight payload). NO researcher
+      # knows the others exist. Topic-splitting the task into k subtopics is the
+      # canonical bypass — `bin/researcher-merge.cjs` will report agreement_score
+      # ≈ 0 and an empty pattern intersection if the orchestrator violates this.
+      #
       # The orchestrator MUST stamp `loop-audit-tool-use --agent np-researcher`
       # ONCE PER RESEARCHER SPAWN — Layer-C now requires `swarm.research.k`
       # audit entries for the round (Gap #6 fix, 2026-05-05). The earlier
@@ -222,10 +243,24 @@ for WAVE_INDEX in 0 1 2 ...; do
       # (Mehrheit/Union/Schnittmenge) into a fiction. With the k-gate the
       # synthetic-consensus bypass is mechanically blocked.
       if { [ "$ROUND" -eq 1 ] && [ "$CACHE_HIT" != "true" ]; } || [ "$NEXT_ACTION" = "researcher" ]; then
-        # Spawn $SWARM_K np-researcher agents (parallel). After EACH spawn:
+        # Read swarm.spawn_specs[] from the preflight payload — one entry per
+        # spawn, each carrying { index, seed_delta, input } where input.task_query
+        # is identical across the k entries. The orchestrator MUST iterate
+        # `swarm.spawn_specs` and pass `<seed_delta>` per spawn. It MUST NOT
+        # rewrite or partition `input.task_query`.
+        SPAWN_SPECS=$(echo "$PREFLIGHT" | node -e \
+          'process.stdin.on("data",d=>{const j=JSON.parse(d);process.stdout.write(JSON.stringify((j.swarm&&j.swarm.spawn_specs)||[]))})')
+        # Spawn $SWARM_K np-researcher agents (parallel, single message). Each
+        # spawn prompt:
+        #   <files_to_read>: task plan, slice plan, prior slice SUMMARYs, CONTEXT.md, codebase docs
+        #   <task_query>:   $TASK_QUERY (verbatim, identical for every spawn)
+        #   <seed_delta>:   swarm.spawn_specs[i].seed_delta (one line, per-spawn)
+        # After EACH spawn — exactly $SWARM_K audit calls per researcher round:
         #   loop-audit-tool-use "$TASK_ID" --agent np-researcher --tool-use-log <json>
-        # i.e. exactly $SWARM_K audit calls per researcher round. Then merge:
-        CONSENSUS_PATTERN=$(node .nubos-pilot/bin/researcher-merge.cjs ...)  # real merged output
+        # Collect the $SWARM_K structured outputs as files
+        # ($TMPDIR/np-spawn-${TASK_ID}-r${ROUND}-${i}.json) and merge:
+        CONSENSUS_PATTERN=$(node .nubos-pilot/bin/researcher-merge.cjs \
+          "${SPAWN_OUT_PATHS[@]}")
         node .nubos-pilot/bin/np-tools.cjs loop-run-round "$TASK_ID" --phase post-researcher
       elif [ "$CACHE_HIT" = "true" ] && [ -z "$CONSENSUS_PATTERN" ]; then
         # Cache-hit branch: the cached pattern is ALREADY in the learning store —
@@ -495,8 +530,8 @@ After every slice completes, point the operator at `/np:validate-phase $PHASE` t
 - Run `loop-run-round --phase post-executor` AFTER mechanical checks; honor `next_action: spawn-build-fixer` (verify-red short-circuit, skip critics this round).
 - Run `loop-run-round --phase post-critics` AFTER critics return, to obtain the routing `next_action`.
 - Run `loop-audit-tool-use` per round per spawn — for executor/build-fixer this drives Rule 9 enforcement, AND for `np-critic` this is the spawn-evidence required by the Layer-C audit-trail gate (`loop-post-executor-missing-spawn-audit` / `loop-post-critics-missing-critic-audit`). After the Single-Critic Revision (ADR-0010, 2026-05-05) the per-round audit count is **two** in rounds ≥ 2 (`np-build-fixer` + `np-critic`) and **`swarm.research.k` + 2** in round 1 (k × `np-researcher` + `np-executor` + `np-critic`). All audits in the active round are mandatory before the corresponding `loop-run-round --phase post-{researcher|executor|critics}` invocation.
-- Route every commit through `node .nubos-pilot/bin/np-tools.cjs commit-task` so `assertCommittablePaths` (D-25) runs.
-- Hard-stop the wave when `commit-task` returns non-zero, OR a task hits `stuck`/`plan-checker`.
+- Route every commit through `node .nubos-pilot/bin/np-tools.cjs commit-task` so `classifyCommittablePaths` runs (gitignored entries are split into a `files_ignored` audit list; mixed paths commit only the tracked subset; all-ignored soft-skips with `skip_reason: artifacts-gitignored` and exit 0).
+- Hard-stop the wave when `commit-task` returns non-zero, OR a task hits `stuck`/`plan-checker`. **Soft-skip is exit 0 — wave continues.**
 
 **Don't:**
 - Run tasks across slices in parallel — slices are serial.