@bongos/core 1.19.645 → 1.19.647

package/tests/box_access.mjs

@@ -414,5 +414,160 @@ t('1003227 config/ is a cone-mode DIRECTORY entry (a file path aborts the whole
   }
 });
 
+// ---------------------------------------------------------------------------
+// task 1003087 / idea 1000793 — builder widening that SURVIVES the */10 tick
+//
+// The bug: the cron re-applies the server-computed sparse set, so a builder's
+// own `git sparse-checkout add` is deleted — sometimes mid-command (a live suite
+// died with MODULE_NOT_FOUND that read exactly like a code bug). The widen set is
+// therefore recorded server-side and unioned in HERE, on the same path the cron
+// asks every tick. These pin the two halves that matter: it actually widens, and
+// it cannot be used to climb past the rank scope.
+// ---------------------------------------------------------------------------
+
+console.log('\nnormalizeWidenPath — a repo-relative directory, or nothing:');
+
+t('accepts a plain repo-relative dir and strips the noise around it', () => {
+  assert.equal(access.normalizeWidenPath('docs'), 'docs');
+  assert.equal(access.normalizeWidenPath('  docs  '), 'docs');
+  assert.equal(access.normalizeWidenPath('./docs/'), 'docs');
+  assert.equal(access.normalizeWidenPath('docs//adr'), 'docs/adr');
+});
+
+t('folds a Windows separator rather than judging the path on it', () => {
+  const BS = String.fromCharCode(92);
+  assert.equal(access.normalizeWidenPath(`modules${BS}game`), 'modules/game');
+});
+
+t('REFUSES traversal, absolute paths and drive letters outright', () => {
+  // Refused, never "cleaned up into something that still works" — this string
+  // reaches `git sparse-checkout set` on a real box.
+  for (const bad of ['../etc', 'a/../../b', '/etc/passwd', 'C:/Windows', '..', '.', '']) {
+    assert.equal(access.normalizeWidenPath(bad), null, `${JSON.stringify(bad)} must be refused`);
+  }
+});
+
+t('refuses a non-string, an over-long path, and odd characters', () => {
+  assert.equal(access.normalizeWidenPath(null), null);
+  assert.equal(access.normalizeWidenPath(42), null);
+  assert.equal(access.normalizeWidenPath({}), null);
+  assert.equal(access.normalizeWidenPath('a'.repeat(500)), null);
+  assert.equal(access.normalizeWidenPath('modules/ga me'), null);
+  assert.equal(access.normalizeWidenPath('modules/rm -rf'), null);
+});
+
+console.log('\nadmissibleWidenPaths — rank is the ceiling, and it is the whole point:');
+
+t('a Metic (full rank scope) may widen anywhere', () => {
+  assert.deepEqual(access.admissibleWidenPaths(['modules/game'], 'metic'), ['modules/game']);
+  assert.deepEqual(access.admissibleWidenPaths(['migrations'], 'archon'), ['migrations']);
+});
+
+t('a Xenos may NOT widen past the starter surface — that would be rank escalation', () => {
+  // The security property of this feature stated as a test: if an arbitrary widen
+  // were honored, a convenience flag would hand a starter-scoped builder the whole
+  // repo, which is the rank gate defeated rather than a checkout preference.
+  assert.deepEqual(access.admissibleWidenPaths(['modules/game'], 'xenos'), []);
+  assert.deepEqual(access.admissibleWidenPaths(['migrations'], 'xenos'), []);
+  assert.deepEqual(access.admissibleWidenPaths(['modules/lifecycle'], 'thetes'), []);
+});
+
+t('a Xenos MAY widen INSIDE starter — a task box is narrower than their rank allows', () => {
+  // Not a null grant: task scope is BASE union modules, which is narrower than
+  // starter, so this is the room to climb back to what rank already permitted.
+  assert.deepEqual(access.admissibleWidenPaths(['docs/adr'], 'xenos'), ['docs/adr']);
+  assert.deepEqual(access.admissibleWidenPaths(['src/world'], 'xenos'), ['src/world']);
+});
+
+t('normalizes, dedupes and sorts, and drops the invalid without failing the rest', () => {
+  const got = access.admissibleWidenPaths(['./docs/', 'docs', '../etc', 'art'], 'metic');
+  assert.deepEqual(got, ['art', 'docs'], 'one invalid entry must not discard the valid ones');
+});
+
+t('is capped, so a widen set can never become a second scope system', () => {
+  const many = Array.from({ length: access.MAX_WIDEN_PATHS + 20 }, (_, i) => `docs/d${i}`);
+  assert.equal(access.admissibleWidenPaths(many, 'metic').length, access.MAX_WIDEN_PATHS);
+});
+
+t('a missing / non-array widen set is simply no widening', () => {
+  for (const v of [undefined, null, 'docs', 42, {}]) {
+    assert.deepEqual(access.admissibleWidenPaths(v, 'metic'), []);
+  }
+});
+
+console.log('\nwithWidenPaths — union into the computed set, without redundancy:');
+
+t('adds a dir the set does not already cover', () => {
+  assert.deepEqual(access.withWidenPaths(['src/bongos'], ['docs']), ['src/bongos', 'docs']);
+});
+
+t('skips a dir an ANCESTOR already covers — cone mode pulls the whole subtree', () => {
+  assert.deepEqual(access.withWidenPaths(['scripts'], ['scripts/gds']), ['scripts'],
+    'adding scripts/gds under scripts is noise in the git command and in the scope readout');
+});
+
+t('passes a null sparse set (the full clone) straight through', () => {
+  assert.equal(access.withWidenPaths(null, ['docs']), null,
+    'a full clone already holds everything — there is nothing to widen INTO');
+});
+
+t('an empty widen set returns the computed set untouched', () => {
+  const base = ['src/bongos', 'scripts'];
+  assert.deepEqual(access.withWidenPaths(base, []), base);
+});
+
+console.log('\ndecideSourceAccess — the widen reaches the spec the box actually fetches:');
+
+t('a task-scoped box gets its widen unioned into the sparse set', () => {
+  const d = access.decideSourceAccess({
+    rank: 'metic', status: 'active', scopeKeys: [], hasActiveClaims: false,
+    moduleScopeMap: {}, widenPaths: ['modules/game'],
+  });
+  assert.equal(d.allowed, true);
+  assert.ok(d.spec.sparsePaths.includes('modules/game'),
+    'the widen must reach the SPEC — this is the value the cron writes into sparse-checkout');
+});
+
+t('an out-of-scope widen never reaches the spec for a starter-scoped builder', () => {
+  const d = access.decideSourceAccess({
+    rank: 'xenos', status: 'active', scopeKeys: [], hasActiveClaims: false,
+    moduleScopeMap: {}, widenPaths: ['modules/game'],
+  });
+  assert.ok(!d.spec.sparsePaths.includes('modules/game'));
+});
+
+t('no widenPaths leaves every scope byte-identical to before the feature', () => {
+  const withArg = access.decideSourceAccess({
+    rank: 'metic', status: 'active', scopeKeys: [], hasActiveClaims: false, moduleScopeMap: {}, widenPaths: [],
+  });
+  const without = access.decideSourceAccess({
+    rank: 'metic', status: 'active', scopeKeys: [], hasActiveClaims: false, moduleScopeMap: {},
+  });
+  assert.deepEqual(withArg.spec, without.spec, 'a box that asked for nothing must fetch exactly what it always did');
+});
+
+t('a full-clone builder is unaffected — sparsePaths stays null', () => {
+  const d = access.decideSourceAccess({ rank: 'metic', status: 'active', widenPaths: ['docs'] });
+  assert.equal(d.spec.sparsePaths, null);
+  assert.equal(d.spec.mode, 'full');
+});
+
+t('widening cannot resurrect access for an inactive or below-floor builder', () => {
+  // The widen set is read from the box row, so it must not become a way around
+  // the ALLOW/DENY gate that runs before any scope is computed.
+  const inactive = access.decideSourceAccess({ rank: 'metic', status: 'inactive', widenPaths: ['docs'] });
+  assert.equal(inactive.allowed, false);
+  assert.equal(inactive.reason, 'BUILDER_INACTIVE');
+  assert.equal(inactive.spec, undefined);
+});
+
+t('every admitted widen path is still a DIRECTORY — cone mode aborts on a file', () => {
+  for (const p of access.admissibleWidenPaths(['docs/adr', 'src/world'], 'metic')) {
+    assert.ok(!p.endsWith('/'), `${p} must not carry a trailing slash`);
+    const last = p.split('/').pop();
+    assert.ok(!/\.[a-z0-9]+$/i.test(last), `${p} looks like a FILE — cone mode would abort the set`);
+  }
+});
+
 console.log(`\nbox_access.mjs: ${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);

package/tests/box_sync_scope_report.mjs

@@ -18,6 +18,8 @@ import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
 const { formatScopeReport } = require('../scripts/gds/box-sync.js');
+// task 1003087 — the widen read-out lives in the same module.
+const sync = require('../scripts/gds/box-sync.js');
 
 let passed = 0;
 let failed = 0;
@@ -77,5 +79,48 @@ t('an unknown scope value is reported verbatim rather than swallowed', () => {
   assert.match(joined({ scope: 'something-new', sparse_paths: [] }), /something-new/);
 });
 
+// ---------------------------------------------------------------------------
+// task 1003087 — the --widen read-out
+//
+// The whole feature exists because a widen that silently stops applying is
+// indistinguishable from one that works. So the report must say when the server
+// stored a path it will NOT apply (outside the caller's rank scope) — otherwise
+// this fix reintroduces its own bug one layer up.
+// ---------------------------------------------------------------------------
+
+const widenLines = (body) => sync.formatWidenReport(body).join('\n');
+
+t('an empty widen set says so plainly rather than printing nothing', () => {
+  assert.match(widenLines({ widen_paths: [], ignored: [] }), /nothing kept/i);
+});
+
+t('a kept set names the paths and the count', () => {
+  const out = widenLines({ widen_paths: ['docs', 'modules/game'], ignored: [] });
+  assert.match(out, /2 path/);
+  assert.match(out, /docs/);
+  assert.match(out, /modules\/game/);
+});
+
+t('an IGNORED path is called out loudly, not folded into the kept list', () => {
+  const out = widenLines({ widen_paths: ['docs', 'modules/game'], ignored: ['modules/game'] });
+  assert.match(out, /IGNORED/);
+  assert.match(out, /rank scope/i,
+    'the reason must be named — "stored but not applied" with no why is the silent failure again');
+});
+
+t('a garbage / missing body degrades to one honest line rather than throwing', () => {
+  for (const bad of [null, undefined, 'nope', 42, []]) {
+    assert.match(widenLines(bad), /could not read/i);
+  }
+});
+
+t('valueAfter reads the argument after a flag, and refuses the next flag as a value', () => {
+  assert.equal(sync.valueAfter(['--widen', 'docs'], '--widen'), 'docs');
+  assert.equal(sync.valueAfter(['--widen', '--dry-run'], '--widen'), null,
+    'consuming the next FLAG as a path would silently widen to something nobody typed');
+  assert.equal(sync.valueAfter(['--widen'], '--widen'), null);
+  assert.equal(sync.valueAfter([], '--widen'), null);
+});
+
 console.log(`\nbox_sync_scope_report.mjs: ${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);

package/tests/claude_materialize.mjs

@@ -318,6 +318,36 @@ t('materializeClaude: a skill the module STOPPED declaring is withdrawn too', ()
   for (const d of [core, inst]) rmSync(d, { recursive: true, force: true });
 });
 
+t('materializeClaude: a CORE skill that took over a module-owned name is NOT withdrawn — and a disabled module\'s core-shipped name still is (task 1003818)', () => {
+  // The regression this pins: step 1 copies the core's dir in, and 1c deleted it again in
+  // the SAME run, because no enabled module declared the name any more. The core-checkout
+  // twin has always guarded this via tracked() ("a core skill can take over a name a
+  // module once owned"); the instance side shipped without it in task 1003632.
+  const { core, inst, modDir } = withdrawFixture();
+  m.materializeClaude({ coreRoot: core, instanceDir: inst, dryRun: false });   // alpha lands, recorded
+
+  // the module stops declaring alpha; the core now ships its own
+  writeFileSync(join(modDir, 'module.json'), JSON.stringify({ key: 'foo', default: true, contributes: { skills: ['beta'] } }));
+  mkdirSync(join(core, '.claude', 'skills', 'alpha'), { recursive: true });
+  writeFileSync(join(core, '.claude', 'skills', 'alpha', 'SKILL.md'), '---\nname: alpha\n---\nCORE OWNS THIS NOW\n');
+  const kept = m.materializeClaude({ coreRoot: core, instanceDir: inst, dryRun: false });
+  assert.deepEqual(kept.withdrawnSkills, [], 'a name the core ships now is the core\'s, whatever the manifest said');
+  assert.match(readFileSync(join(inst, '.claude', 'skills', 'alpha', 'SKILL.md'), 'utf8'), /CORE OWNS THIS NOW/, 'and it is the core copy that survives');
+
+  // THE OTHER HALF, which the guard must not break: a DISABLED module declaring a
+  // core-shipped name means step 1 skips the copy, so the instance dir IS stale.
+  const inst2 = mkdtempSync(join(tmpdir(), 'wd-inst-'));
+  writeFileSync(join(modDir, 'module.json'), JSON.stringify({ key: 'foo', default: true, contributes: { skills: ['alpha', 'beta'] } }));
+  m.materializeClaude({ coreRoot: core, instanceDir: inst2, dryRun: false });
+  assert.ok(existsSync(join(inst2, '.claude', 'skills', 'alpha')), 'landed while enabled');
+  mkdirSync(join(inst2, 'config'), { recursive: true });
+  writeFileSync(join(inst2, 'config', 'modules.json'), JSON.stringify({ modules: { foo: false } }));
+  const gone = m.materializeClaude({ coreRoot: core, instanceDir: inst2, dryRun: false });
+  assert.ok(gone.withdrawnSkills.includes('alpha'), 'a disabled module\'s core-shipped name is still withdrawn — step 1 skipped it, so the dir is stale');
+  assert.ok(!existsSync(join(inst2, '.claude', 'skills', 'alpha')));
+  for (const d of [core, inst, inst2]) rmSync(d, { recursive: true, force: true });
+});
+
 t('materializeClaude: a HAND-WRITTEN skill is never withdrawn, even when a disabled module declares its name', () => {
   const { core, inst } = withdrawFixture();
   // The owner wrote .claude/skills/alpha themselves; no materialize ever landed it,

package/tests/ship_cannot_lie.mjs

@@ -14,13 +14,20 @@
 //     lands the task at 'completed' before the grade runs, and 'completed' is
 //     ALSO what a grade-failed task looks like — so a bare `fatal: <stack>`
 //     left nobody able to tell how far it got.
+//
+// (3) --regrade must not swallow --notes. Same shape as (1): prose handed to
+//     ship.js that reaches nothing, silently (task 1003702).
 import { strict as assert } from 'node:assert';
 import { test } from 'node:test';
 import { createRequire } from 'node:module';
+import { readFileSync } from 'node:fs';
 
 const require = createRequire(import.meta.url);
 const { argText } = require('../scripts/gds/cli-lib.js');
-const { fatalRecoveryLines, markShipProgress, _peekForTest } = require('../scripts/gds/ship-honesty.js');
+const {
+  fatalRecoveryLines, markShipProgress, _peekForTest,
+  proseFlagPresent, regradeNotesRefusal,
+} = require('../scripts/gds/ship-honesty.js');
 
 // Injected IO so no case touches the filesystem.
 const io = {
@@ -166,3 +173,98 @@ test('markShipProgress is the single writer, and ship.js re-exports the reader',
   assert.equal(typeof shipCli.fatalRecoveryLines, 'function', 'ship.js still exposes it');
   assert.equal(shipCli.fatalRecoveryLines, fatalRecoveryLines, 'same function, not a copy');
 });
+
+// ── (3) --regrade refuses --notes instead of swallowing it (task 1003702) ────
+//
+// The third way to lose the builder's prose, and the same incident shape as (1):
+// prose handed to ship.js that reaches nothing, with no error. --regrade
+// resolved only summary + response, so --notes parsed as an unknown flag and
+// vanished; a builder answering a "no evidence in the notes" blocker passed it
+// again there and got the identical finding back marked unanswered.
+
+test('every spelling of --notes is caught, and nothing else is', () => {
+  // All four forms argText accepts. Catching only the bare flag would leave
+  // --notes-file — the form the ship docs actively recommend for prose — silent,
+  // which is the exact defect wearing different clothes.
+  for (const argv of [
+    ['1', '--regrade', '--notes', 'x'],
+    ['1', '--regrade', '--notes=x'],
+    ['1', '--regrade', '--notes-file', 'n.md'],
+    ['1', '--regrade', '--notes-file=n.md'],
+  ]) {
+    assert.equal(proseFlagPresent(argv, 'notes'), true, `caught: ${argv.join(' ')}`);
+  }
+  // Not over-eager: the flags a re-grade legitimately takes must still pass, and
+  // a flag that merely CONTAINS the word is a different flag.
+  for (const argv of [
+    ['1', '--regrade'],
+    ['1', '--regrade', '--response-file', 'r.md'],
+    ['1', '--regrade', '--summary', 'x'],
+    ['1', '--regrade', '--no-notes-please'],
+    ['1', '--regrade', '--response', 'my --notes were wrong'],
+  ]) {
+    assert.equal(proseFlagPresent(argv, 'notes'), false, `not caught: ${argv.join(' ')}`);
+  }
+  // Generic over the flag name — it is not a --notes special case.
+  assert.equal(proseFlagPresent(['--response-file', 'r.md'], 'response'), true);
+});
+
+test('THE ACCEPTANCE: the refusal names where the evidence must go instead', () => {
+  // A non-zero exit that does not say what to do is the same dead end with an
+  // error code on it. The refusal has to carry the working channel, or a builder
+  // reads "not supported" and goes back to putting evidence nowhere.
+  const text = regradeNotesRefusal(1003698).join('\n');
+  assert.match(text, /--response/, 'names the channel that reaches the panel');
+  assert.match(text, /--response-file/, 'and its file form, the safe one for prose');
+  assert.match(text, /diff/i, 'and the diff, which is what the panel actually reads');
+  assert.match(text, /ship\.js 1003698 --regrade/, 'a runnable command with the real task id');
+  // It must not be reassuring about the thing that did not happen.
+  assert.match(text, /NOT been saved/, 'says plainly that the notes went nowhere');
+  // And it must not claim the notes were merely "not supported yet" — the
+  // substantive fact is that the grader never reads ship notes at all, so a
+  // builder does not go looking for a flag that would make them count.
+  assert.match(text, /never reads ship notes/, 'explains WHY, not just that it refused');
+});
+
+test('the refusal is wired into the regrade path, before any grade spend', () => {
+  // Wiring proof (the (1) lesson: a helper nothing calls is not a fix). Also
+  // pins the ORDER — a refusal that costs a 4-worker panel run first is barely
+  // better than the silence, so the guard must precede the preflight.
+  const src = readFileSync(new URL('../scripts/gds/ship-flow.js', import.meta.url), 'utf8');
+  const regrade = src.slice(src.indexOf('async function regradeMain'));
+  const guard = regrade.indexOf("proseFlagPresent(args, 'notes')");
+  assert.ok(guard !== -1, 'regradeMain consults the guard');
+  const preflight = regrade.indexOf('preflight(claimLike');
+  assert.ok(preflight !== -1 && guard < preflight, 'it refuses before the preflight and the panel');
+  // The usage line must not advertise a flag the path refuses.
+  const usage = regrade.slice(0, regrade.indexOf('resolveProse'));
+  assert.ok(!/--notes/.test(usage.replace(/proseFlagPresent[^\n]*/g, '')
+    .replace(/\/\/[^\n]*/g, '')), 'usage does not offer --notes');
+});
+
+test('ACCEPTANCE 3: --summary reaches the GRADER on a re-grade but never the task row', () => {
+  // Task 1003702's third acceptance asked whether --summary reaches the stored
+  // value_summary on a re-grade. It does NOT, and that is a separate defect
+  // filed as task 1003817 (it needs a server route change; this task's fix is
+  // CLI-only). Pinned here rather than left in prose for the reason this whole
+  // file exists: the panel reads the DIFF, so an answer that lives only in ship
+  // notes is an answer nobody can check — which is the very bug task 1003702 is.
+  const src = readFileSync(new URL('../scripts/gds/ship-flow.js', import.meta.url), 'utf8');
+  const regrade = src.slice(src.indexOf('async function regradeMain'));
+  const code = regrade.replace(/\/\/[^\n]*/g, ''); // comments describe, they do not write
+
+  // Half one — the threading is intact, so nothing regressed: --summary still
+  // falls back to the stored value and still reaches the grader and the card.
+  assert.match(code, /const summary = summaryArg \|\| task\.value_summary/,
+    'the stored summary is still the fallback when --summary is omitted');
+  assert.match(code, /gradeAndRecord\(\{[\s\S]{0,200}?summary,/,
+    'the summary still reaches the grader prompt');
+  assert.match(code, /valueSummary: summary/, 'and the completion card');
+
+  // Half two — and there is no writer. A `value_summary:` KEY would be a request
+  // payload; the legitimate read is `task.value_summary`, dot-access. If someone
+  // later adds the write (task 1003817), this assertion is what tells them to
+  // update the comment above `const summary` rather than leave it lying.
+  assert.ok(!/[^.]\bvalue_summary\s*:/.test(code),
+    'regradeMain writes value_summary nowhere — see task 1003817');
+});