@bongos/core 1.19.305 → 1.19.307

package/tests/ship_cannot_lie.mjs

@@ -0,0 +1,168 @@
+// tests/ship_cannot_lie.mjs — G04, task 1003168, goal 1000077, criterion
+// guards-ship-cannot-lie.
+//
+// TWO fixes, one incident, so one test file.
+//
+// (1) Prose reaches ship.js through a FILE, never only through the shell.
+//     Backticks in handoff notes are command-substituted by bash BEFORE node
+//     runs: the span executes, its output replaces it, and the remaining
+//     arguments are truncated. That shipped a task with empty notes and no
+//     summary — the ledger recorded nothing about a session that happened
+//     (learning 1000197).
+//
+// (2) A ship that dies mid-pipeline must say where it stopped. resolveClaim
+//     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.
+import { strict as assert } from 'node:assert';
+import { test } from 'node:test';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { argText } = require('../scripts/gds/cli-lib.js');
+const { fatalRecoveryLines, markShipProgress, _peekForTest } = require('../scripts/gds/ship-honesty.js');
+
+// Injected IO so no case touches the filesystem.
+const io = {
+  readFile: (f) => {
+    if (f === 'notes.md') return 'real notes with `backticks` in them';
+    if (f === 'bom.md') return 'after a BOM';
+    throw new Error('ENOENT: no such file');
+  },
+  readStdin: () => 'from stdin',
+};
+
+// ---- (1) prose from a file -------------------------------------------------
+test('THE INCIDENT: a file argument carries backticks through untouched', () => {
+  // The shell never sees this content, so the backticks survive verbatim —
+  // that is the entire point of the flag.
+  const r = argText('--notes', ['--notes-file', 'notes.md'], io);
+  assert.equal(r.source, 'file');
+  assert.match(r.value, /`backticks`/);
+  assert.equal(r.error, null);
+});
+
+test('inline still works, for a short summary with no awkward characters', () => {
+  const r = argText('--summary', ['--summary', 'one line'], io);
+  assert.deepEqual([r.value, r.source, r.error], ['one line', 'inline', null]);
+});
+
+test('BOTH given is REFUSED, never silently resolved', () => {
+  // Precedence would mean one of the caller's two inputs vanished with no word
+  // said — the same quiet loss the flag exists to end.
+  const r = argText('--notes', ['--notes', 'a', '--notes-file', 'notes.md'], io);
+  assert.ok(r.error, 'both-given must be an error');
+  assert.match(r.error, /both/i);
+  assert.equal(r.value, '', 'a refusal must not hand back a half-resolved value');
+});
+
+test('a dash reads stdin', () => {
+  const r = argText('--notes', ['--notes-file', '-'], io);
+  assert.deepEqual([r.value, r.source], ['from stdin', 'stdin']);
+});
+
+test('an unreadable file is an error, not silently empty', () => {
+  // Silently-empty is precisely how the original incident hid itself.
+  const r = argText('--notes', ['--notes-file', 'gone.md'], io);
+  assert.ok(r.error);
+  assert.match(r.error, /could not read/);
+});
+
+test('a missing value for the file flag is caught, including a following flag', () => {
+  for (const args of [['--notes-file'], ['--notes-file', '--summary', 'x']]) {
+    const r = argText('--notes', args, io);
+    assert.ok(r.error, `${JSON.stringify(args)} must error`);
+    assert.match(r.error, /needs a path/);
+  }
+});
+
+test('a PowerShell BOM is stripped', () => {
+  // PS 5.1's `>` redirection writes a UTF-8 BOM; without stripping it the first
+  // character of every note would be U+FEFF.
+  const r = argText('--notes', ['--notes-file', 'bom.md'], io);
+  assert.equal(r.value, 'after a BOM');
+});
+
+test('neither flag yields empty string, not null — callers concatenate it', () => {
+  const r = argText('--notes', [], io);
+  assert.deepEqual([r.value, r.source, r.error], ['', 'none', null]);
+});
+
+// ---- (2) the ship cannot lie about how far it got --------------------------
+test('every stage names the task, its real status, and a recovery command', () => {
+  for (const stage of ['preflight', 'resolved', 'graded', 'landed']) {
+    const lines = fatalRecoveryLines({ stage, taskId: 4242 });
+    assert.ok(Array.isArray(lines) && lines.length >= 3, `${stage} must say something`);
+    for (const l of lines) assert.equal(typeof l, 'string', `${stage} lines are printable as-is`);
+    assert.ok(lines.some((l) => l.includes('4242')), `${stage} must name the task`);
+    assert.ok(
+      lines.some((l) => l.includes('node scripts/gds/ship.js 4242')),
+      `${stage} must name the command that recovers it`,
+    );
+  }
+});
+
+test('pre-resolve says the claim is INTACT — the opposite of the post-resolve case', () => {
+  const text = fatalRecoveryLines({ stage: 'preflight', taskId: 7 }).join('\n');
+  assert.match(text, /NOT resolved/);
+  assert.match(text, /still active/);
+});
+
+test("post-resolve names 'completed' AND that the grade did not record", () => {
+  // The distinction the status itself cannot make.
+  const text = fatalRecoveryLines({ stage: 'resolved', taskId: 7 }).join('\n');
+  assert.match(text, /'completed'/);
+  assert.match(text, /grade did NOT record/);
+  assert.match(text, /No credits/i);
+});
+
+test("post-grade names 'confirmed' and that the grade PASSED", () => {
+  const text = fatalRecoveryLines({ stage: 'graded', taskId: 7 }).join('\n');
+  assert.match(text, /'confirmed'/);
+  assert.match(text, /PASSED/);
+});
+
+test('the landed stage does NOT claim the ship failed', () => {
+  // It reached 'shipped'; only the after-work broke. Saying "the ship did not
+  // finish" there would be the same lying-status problem in reverse.
+  const lines = fatalRecoveryLines({ stage: 'landed', taskId: 7 });
+  assert.match(lines[0], /LANDED/);
+  assert.ok(!/did NOT finish/.test(lines.join('\n')));
+});
+
+test('NO stage recommends --regrade as the recovery', () => {
+  // A plain re-run routes by the task's CURRENT status, so it resumes whichever
+  // leg stalled. --regrade accepts only 'completed' and refuses a task that got
+  // to 'confirmed' — and the builder reading a crash cannot know which it is.
+  for (const stage of ['preflight', 'resolved', 'graded', 'landed']) {
+    const text = fatalRecoveryLines({ stage, taskId: 7 });
+    for (const l of text) {
+      assert.ok(
+        !/^\s*Resume:?\s+node .*--regrade/.test(l) && !/re-run:\s+node .*--regrade/.test(l),
+        `${stage} must not prescribe --regrade: ${l}`,
+      );
+    }
+  }
+});
+
+test('an unknown stage degrades to the safe pre-resolve message', () => {
+  // A future leg added without a case here must not produce a confident wrong
+  // claim about credits or status.
+  const text = fatalRecoveryLines({ stage: 'something-new', taskId: 7 }).join('\n');
+  assert.match(text, /NOT resolved/);
+});
+
+test('a missing taskId still yields a usable command', () => {
+  const text = fatalRecoveryLines({ stage: 'resolved', taskId: null }).join('\n');
+  assert.match(text, /ship\.js <task-id>/);
+});
+
+test('markShipProgress is the single writer, and ship.js re-exports the reader', () => {
+  // Wiring proof: the extraction must not have left ship.js reading a stale copy.
+  markShipProgress('graded', 99);
+  assert.deepEqual(_peekForTest(), { stage: 'graded', taskId: 99 });
+  assert.match(fatalRecoveryLines().join('\n'), /#99/, 'the default arg reads live progress');
+  const shipCli = require('../scripts/gds/ship.js');
+  assert.equal(typeof shipCli.fatalRecoveryLines, 'function', 'ship.js still exposes it');
+  assert.equal(shipCli.fatalRecoveryLines, fatalRecoveryLines, 'same function, not a copy');
+});

package/tests/ship_smoke_gate.mjs

@@ -14,7 +14,7 @@ import { strict as assert } from 'node:assert';
 import { createRequire } from 'node:module';
 
 const require = createRequire(import.meta.url);
-const { smokeGateMessages } = require('../scripts/gds/ship.js');
+const { smokeGateMessages } = require('../scripts/gds/ship-honesty.js');
 
 let passed = 0;
 let failed = 0;
@@ -61,8 +61,14 @@ t('parked: names the deliberate stop, the exact status, and that nothing was pai
   assert.match(parkedText, /no credits/i);
 });
 
-t('parked: names the resume path (--regrade)', () => {
-  assert.match(parkedText, /ship\.js 1234 --regrade/);
+t('parked: names the resume path (a plain re-run, not --regrade)', () => {
+  // task 1003168 (G04): this used to say --regrade. A plain re-run routes by the
+  // task's CURRENT status, so it resumes whichever leg stalled; --regrade accepts
+  // only 'completed' and refuses a task that got as far as 'confirmed'. Since the
+  // builder reading this cannot know which leg died, the advice must be the
+  // command that works from either.
+  assert.match(parkedText, /ship\.js 1234$|ship\.js 1234\s/m);
+  assert.ok(!/ship\.js 1234 --regrade/.test(parkedText), 'must not recommend --regrade');
 });
 
 t('both message sets are non-empty arrays of strings (printable as-is)', () => {