@bongos/core 1.17.0

package/tests/sound_prefs.mjs

@@ -0,0 +1,198 @@
+// tests/sound_prefs.mjs
+//
+// Unit smoke for src/bongos/sound-prefs.js (V3.R91 / #786). Verifies the pure
+// helpers — DB plumbing is exercised by routes/me.js + the production smoke once
+// migration 075 is in place; here we cover defaults, validation, patch-apply,
+// and the effective-map shape the local player consumes, without touching pg.
+//
+// Run:  node tests/sound_prefs.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const sp = require('../modules/builder-settings/sound-prefs.js');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+console.log('sound-prefs constants:');
+
+t('the five sounds are the known set', () => {
+  assert.deepEqual(sp.KNOWN_SOUNDS, ['chime', 'alert', 'ship', 'triumph', 'fanfare']);
+});
+
+t('every KNOWN_SOUNDS has a default + meta', () => {
+  for (const s of sp.KNOWN_SOUNDS) {
+    assert.ok(s in sp.SOUND_DEFAULTS, `missing default for ${s}`);
+    assert.ok(s in sp.SOUND_META, `missing meta for ${s}`);
+    assert.equal(typeof sp.SOUND_META[s].label, 'string');
+    assert.equal(typeof sp.SOUND_META[s].desc, 'string');
+  }
+});
+
+t('all sounds default ON', () => {
+  for (const s of sp.KNOWN_SOUNDS) assert.equal(sp.SOUND_DEFAULTS[s], true, `${s} should default on`);
+});
+
+console.log('getForBuilder:');
+
+t('unset sound resolves to default ON', () => {
+  assert.equal(sp.getForBuilder({}, 'chime'), true);
+  assert.equal(sp.getForBuilder(null, 'fanfare'), true);
+});
+
+t('explicit false mutes; explicit true keeps on', () => {
+  assert.equal(sp.getForBuilder({ chime: false }, 'chime'), false);
+  assert.equal(sp.getForBuilder({ chime: true }, 'chime'), true);
+});
+
+t('unknown sound resolves to null', () => {
+  assert.equal(sp.getForBuilder({}, 'gong'), null);
+});
+
+console.log('listEffective:');
+
+t('lists every known sound with override + effective', () => {
+  const rows = sp.listEffective({ ship: false });
+  assert.equal(rows.length, sp.KNOWN_SOUNDS.length);
+  const ship = rows.find((r) => r.sound === 'ship');
+  assert.equal(ship.override_enabled, false);
+  assert.equal(ship.enabled, false);
+  const chime = rows.find((r) => r.sound === 'chime');
+  assert.equal(chime.override_enabled, null); // unset
+  assert.equal(chime.enabled, true);          // default
+});
+
+console.log('effectiveMap:');
+
+t('effectiveMap returns a bool for every known sound', () => {
+  const map = sp.effectiveMap({ alert: false });
+  assert.equal(Object.keys(map).length, sp.KNOWN_SOUNDS.length);
+  assert.equal(map.alert, false);
+  assert.equal(map.chime, true);
+  for (const s of sp.KNOWN_SOUNDS) assert.equal(typeof map[s], 'boolean');
+});
+
+console.log('validatePatch:');
+
+t('accepts booleans for known sounds', () => {
+  const v = sp.validatePatch({ chime: false, fanfare: true });
+  assert.ok(v.ok);
+  assert.deepEqual(v.patch, { chime: false, fanfare: true });
+});
+
+t('accepts null as the clear sentinel', () => {
+  const v = sp.validatePatch({ chime: null });
+  assert.ok(v.ok);
+  assert.equal(v.patch.chime, null);
+});
+
+t('rejects unknown sound', () => {
+  const v = sp.validatePatch({ gong: false });
+  assert.ok(!v.ok);
+  assert.equal(v.errors[0].error, 'unknown_sound');
+});
+
+t('rejects non-boolean value', () => {
+  const v = sp.validatePatch({ chime: 'off' });
+  assert.ok(!v.ok);
+  assert.equal(v.errors[0].error, 'not_a_boolean');
+});
+
+t('rejects a non-object body', () => {
+  assert.ok(!sp.validatePatch(null).ok);
+  assert.ok(!sp.validatePatch([]).ok);
+});
+
+t('empty body is a valid no-op', () => {
+  const v = sp.validatePatch({});
+  assert.ok(v.ok);
+  assert.deepEqual(v.patch, {});
+});
+
+console.log('applyPatch:');
+
+t('applyPatch sets booleans', () => {
+  assert.deepEqual(sp.applyPatch({}, { chime: false }), { chime: false });
+});
+
+t('applyPatch deletes keys when value is null', () => {
+  const next = sp.applyPatch({ chime: false }, { chime: null });
+  assert.ok(!('chime' in next));
+});
+
+t('applyPatch leaves unrelated keys alone', () => {
+  const next = sp.applyPatch({ chime: false, ship: false }, { fanfare: true });
+  assert.equal(next.chime, false);
+  assert.equal(next.ship, false);
+  assert.equal(next.fanfare, true);
+});
+
+t('applyPatch handles null/undefined existing', () => {
+  assert.deepEqual(sp.applyPatch(null, { chime: false }), { chime: false });
+  assert.deepEqual(sp.applyPatch(undefined, { ship: true }), { ship: true });
+});
+
+console.log('volume (#788):');
+
+t('getVolume defaults to 100 when unset', () => {
+  assert.equal(sp.getVolume({}), 100);
+  assert.equal(sp.getVolume(null), 100);
+  assert.equal(sp.getVolume({ chime: false }), 100);
+});
+
+t('getVolume returns the stored value, clamped + rounded', () => {
+  assert.equal(sp.getVolume({ volume: 60 }), 60);
+  assert.equal(sp.getVolume({ volume: 0 }), 0);
+  assert.equal(sp.getVolume({ volume: 150 }), 100);
+  assert.equal(sp.getVolume({ volume: -10 }), 0);
+  assert.equal(sp.getVolume({ volume: 60.7 }), 61);
+});
+
+t('volume key is not treated as a sound', () => {
+  assert.equal(sp.isKnownSound('volume'), false);
+  // effectiveMap + listEffective only cover real sounds, never volume
+  assert.ok(!('volume' in sp.effectiveMap({ volume: 50 })));
+  assert.ok(!sp.listEffective({ volume: 50 }).some((r) => r.sound === 'volume'));
+});
+
+t('validatePatch accepts a numeric volume 0-100', () => {
+  const v = sp.validatePatch({ volume: 40 });
+  assert.ok(v.ok);
+  assert.equal(v.patch.volume, 40);
+});
+
+t('validatePatch accepts null volume (clear)', () => {
+  const v = sp.validatePatch({ volume: null });
+  assert.ok(v.ok);
+  assert.equal(v.patch.volume, null);
+});
+
+t('validatePatch rejects out-of-range / non-numeric volume', () => {
+  assert.ok(!sp.validatePatch({ volume: 101 }).ok);
+  assert.ok(!sp.validatePatch({ volume: -1 }).ok);
+  assert.ok(!sp.validatePatch({ volume: 'loud' }).ok);
+});
+
+t('validatePatch handles a mixed sound + volume body', () => {
+  const v = sp.validatePatch({ chime: false, volume: 25 });
+  assert.ok(v.ok);
+  assert.deepEqual(v.patch, { chime: false, volume: 25 });
+});
+
+t('applyPatch sets + clears volume alongside sounds', () => {
+  let next = sp.applyPatch({ chime: false }, { volume: 30 });
+  assert.equal(next.volume, 30);
+  assert.equal(next.chime, false);
+  next = sp.applyPatch(next, { volume: null });
+  assert.ok(!('volume' in next));
+  assert.equal(next.chime, false); // unrelated key untouched
+});
+
+console.log(`\n${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);

package/tests/sprite_facing.mjs

@@ -0,0 +1,35 @@
+// tests/sprite_facing.mjs
+//
+// Behavior-preserving refactor check (task 1968, ADR 0113): resolveFacing
+// was extracted out of Player.js's _applyIdleTexture/_applyWalkTexture so
+// the sprite Studio can resolve the right-facing mirror identically to the
+// live game. Pure, Phaser-free — pins the exact mapping both callers rely on.
+//
+// Run:  node tests/sprite_facing.mjs
+
+import { strict as assert } from 'node:assert';
+import { resolveFacing } from '../modules/game/public/game/player/spriteFacing.js';
+
+let passed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    console.log(`  ok  ${name}`);
+    passed++;
+  } catch (e) {
+    console.error(`  FAIL ${name}: ${e.message}`);
+    process.exitCode = 1;
+  }
+}
+
+test('down/up/left pass through unmirrored', () => {
+  assert.deepEqual(resolveFacing('down'), { sourceDir: 'down', flipX: false });
+  assert.deepEqual(resolveFacing('up'), { sourceDir: 'up', flipX: false });
+  assert.deepEqual(resolveFacing('left'), { sourceDir: 'left', flipX: false });
+});
+
+test('right resolves to the left-facing art, flipped', () => {
+  assert.deepEqual(resolveFacing('right'), { sourceDir: 'left', flipX: true });
+});
+
+console.log(`${passed} passed`);

package/tests/status-probe.mjs

@@ -0,0 +1,89 @@
+// tests/status-probe.mjs
+//
+// Task #565 — external uptime prober. The HTTP probing + git push are exercised
+// live in CI (.github/workflows/status-probe.yml); this file covers the pure
+// logic that decides what the off-box history records and what The Watch will
+// read: argument parsing, the uptime-percentage computation (window filtering +
+// rounding + empty-window), and JSONL history parsing (blank/corrupt-line
+// tolerance + missing-file → []).
+//
+// Run:  node tests/status-probe.mjs
+
+import { strict as assert } from 'node:assert';
+import { writeFile, mkdtemp, rm } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import { uptimePct, readHistory, parseArgs } from '../scripts/status-probe.mjs';
+
+let passed = 0;
+const ok = (name) => { passed++; console.log('  ✓', name); };
+
+// --- parseArgs: defaults, overrides, numeric coercion ---
+{
+  const a = parseArgs([]);
+  assert.equal(a.target, 'https://amazonprimea.com/healthz');
+  assert.equal(a.attempts, 3);
+  assert.equal(a['timeout-ms'], 15000);
+  ok('parseArgs returns defaults');
+
+  const b = parseArgs(['--target', 'https://x/h', '--attempts', '5', '--timeout-ms', '2000']);
+  assert.equal(b.target, 'https://x/h');
+  assert.equal(b.attempts, 5);                 // coerced to Number
+  assert.equal(b['timeout-ms'], 2000);
+  assert.equal(typeof b.attempts, 'number');
+  ok('parseArgs applies overrides and coerces numerics');
+}
+
+// --- uptimePct: window filtering + rounding + empty window ---
+{
+  const now = 1_000_000_000_000;
+  const rows = [
+    { t: new Date(now - 1000).toISOString(), status: 'up' },
+    { t: new Date(now - 2000).toISOString(), status: 'down' },
+    { t: new Date(now - 3000).toISOString(), status: 'up' },
+    { t: new Date(now - 4000).toISOString(), status: 'up' },
+  ];
+  assert.equal(uptimePct(rows, now - 5000), 75);   // 3 up / 4 total
+  assert.equal(uptimePct(rows, now - 2500), 50);   // window = {up, down}
+  assert.equal(uptimePct(rows, now + 1000), null); // nothing in window
+  assert.equal(uptimePct([], now - 5000), null);   // no data
+  ok('uptimePct filters to window, rounds, and returns null when empty');
+
+  // rounding to 2 d.p.: 2 up / 3 total = 66.67
+  const three = [
+    { t: new Date(now - 1000).toISOString(), status: 'up' },
+    { t: new Date(now - 2000).toISOString(), status: 'up' },
+    { t: new Date(now - 3000).toISOString(), status: 'down' },
+  ];
+  assert.equal(uptimePct(three, now - 5000), 66.67);
+  ok('uptimePct rounds to two decimal places');
+}
+
+// --- readHistory: JSONL parse, blank/corrupt tolerance, missing file ---
+{
+  const dir = await mkdtemp(path.join(os.tmpdir(), 'status-probe-test-'));
+  try {
+    const f = path.join(dir, 'history.jsonl');
+    await writeFile(
+      f,
+      JSON.stringify({ t: '2026-01-01T00:00:00Z', status: 'up' }) + '\n' +
+      '\n' +                                   // blank line — skipped
+      'this is not json\n' +                   // corrupt line — skipped, not fatal
+      JSON.stringify({ t: '2026-01-02T00:00:00Z', status: 'down' }) + '\n'
+    );
+    const rows = await readHistory(f);
+    assert.equal(rows.length, 2);
+    assert.equal(rows[0].status, 'up');
+    assert.equal(rows[1].status, 'down');
+    ok('readHistory parses JSONL and skips blank/corrupt lines');
+
+    const none = await readHistory(path.join(dir, 'does-not-exist.jsonl'));
+    assert.deepEqual(none, []);
+    ok('readHistory returns [] for a missing file');
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+console.log(`\nstatus-probe: ${passed} checks passed`);

package/tests/status_backfill.mjs

@@ -0,0 +1,94 @@
+// tests/status_backfill.mjs
+//
+// The migration 055 backfill (#435) decodes the legacy "**Criterion:** Cn"
+// prose into structured task_criteria rows. The decode is the fragile part, so
+// this test mirrors the SQL regex logic in JS and asserts it against the real
+// prose shapes found in the live GDS task descriptions. If the prose format
+// ever drifts, this catches it before the migration mislinks anything.
+//
+// SQL being mirrored (migrations/055_task_criteria.sql):
+//   line  = (regexp_match(description, '\*\*Criterion:\*\*\s*([^\r\n]*)'))[1]
+//   cnums = regexp_matches(line, 'C([0-9]+)', 'g')
+//
+// Run:  node tests/status_backfill.mjs
+
+import { strict as assert } from 'node:assert';
+
+// Exact JS mirror of the two-step SQL extraction.
+function extractCnums(description) {
+  const m = /\*\*Criterion:\*\*\s*([^\r\n]*)/.exec(description || '');
+  if (!m || !m[1]) return [];
+  return [...m[1].matchAll(/C(\d+)/g)].map((x) => Number(x[1]));
+}
+
+// Positional decode: cnum n → the n-th criterion (1-based) in the version's
+// (sort_order, criterion_id) ordering. Mirrors ROW_NUMBER() in the backfill
+// and criterionProgress().
+function mapToCriterion(orderedCriteria, cnum) {
+  return orderedCriteria[cnum - 1] ?? null;
+}
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  try { fn(); passed++; console.log(`  ok  ${name}`); }
+  catch (err) { failed++; console.log(`  FAIL ${name}`); console.log(`     ${err.message}`); }
+}
+
+// ---------- extraction against real prose shapes ----------
+
+test('single criterion: "**Criterion:** C8."', () => {
+  assert.deepEqual(extractCnums('**Criterion:** C8.'), [8]);
+});
+
+test('multi-criterion: "C3 — …; C7 — …" → [3, 7]', () => {
+  assert.deepEqual(
+    extractCnums('**Criterion:** C3 — per-builder authorship; C7 — server-enforced (not file-baked).'),
+    [3, 7]
+  );
+});
+
+test('"C2 — karma signal sourcing." → [2]', () => {
+  assert.deepEqual(extractCnums('**Criterion:** C2 — karma signal sourcing.'), [2]);
+});
+
+test('"C1, C2 — …" comma-separated → [1, 2]', () => {
+  assert.deepEqual(extractCnums('**Criterion:** C1, C2 — onboarding visible to Archon; ranks managed.'), [1, 2]);
+});
+
+test('non-Cn criterion line → [] (left unlinked, not guessed)', () => {
+  assert.deepEqual(extractCnums('**Criterion:** cross-cutting (identity).'), []);
+  assert.deepEqual(extractCnums('**Criterion:** the proof Tier 1 is done.'), []);
+});
+
+test('no Criterion line at all → []', () => {
+  assert.deepEqual(extractCnums('Provide Stripe test keys and product catalog.'), []);
+});
+
+test('only the Criterion LINE counts — a "C9" later in the body is ignored', () => {
+  const desc = '**Criterion:** C1, C2 — onboarding.\n\n**Cross-refs:** see C9 in another section.';
+  assert.deepEqual(extractCnums(desc), [1, 2]);
+});
+
+test('leading whitespace / full real R54 description prefix', () => {
+  const desc = '**Criterion:** C8 — cloneable repo, local-first memory, server-canonical on ship.\n\n- foo\n- bar';
+  assert.deepEqual(extractCnums(desc), [8]);
+});
+
+// ---------- positional decode ----------
+
+test('positional map: C8 → 8th criterion (cloneable-local-memory-server-sync)', () => {
+  // The real GDS-V3 ordering (by sort_order, criterion_id).
+  const ordered = [
+    'onboarding-2h', 'three-ranks-gate-everything', 'per-builder-credentials',
+    'quality-bar-holds', 'propose-ratify', 'parallel-safe-under-load',
+    'server-enforced-perms', 'cloneable-local-memory-server-sync', 'security-baseline-plus-red-team',
+  ];
+  assert.equal(mapToCriterion(ordered, 8), 'cloneable-local-memory-server-sync');
+  assert.equal(mapToCriterion(ordered, 1), 'onboarding-2h');
+  assert.equal(mapToCriterion(ordered, 10), null); // out of range → unlinked, not a crash
+});
+
+console.log('');
+console.log(`Status backfill tests: ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);

package/tests/stop_refcheck.mjs

@@ -0,0 +1,127 @@
+// tests/stop_refcheck.mjs
+//
+// task 1015 — the live-chat #NNN → GitHub-404 backstop (follow-on to task 929).
+// The Stop hook must be CONSERVATIVE in the same way the doc-linkifier is: it
+// blocks the turn ONLY on a bare "#NNN" that genuinely 404s in chat, and never
+// on a real "PR #8", an already-clickable hall link, a code-spanned ref, or a
+// heading anchor — a false block nags the builder for nothing. These pin that
+// boundary down. Pure: no API, no network (validIds is a fixed Set).
+//
+// Run:  node tests/stop_refcheck.mjs
+
+import { strict as assert } from 'node:assert';
+import { createRequire } from 'node:module';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const require = createRequire(import.meta.url);
+const { evaluate, buildReason, lastAssistantText, RESOLVER_BASE } = require('../.claude/hooks/stop-refcheck.js');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try { fn(); passed++; console.log(`  PASS  ${name}`); }
+  catch (e) { failed++; console.log(`  FAIL  ${name}\n        ${e.message}`); }
+}
+
+// 286/526/870 are "real task ids" for this test; 5/84 stand in for ids that may
+// also be a blocker/migration number (entity classification ignores id membership).
+const IDS = new Set([5, 84, 170, 286, 526, 870]);
+const ev = (s) => evaluate(s, IDS);
+
+// ---- blocks (a bare ref that would 404 in chat) ----------------------------
+
+t('a bare task ref blocks', () => {
+  const r = ev('So the only genuine C9 code remaining is landing #286.');
+  assert.equal(r.block, true);
+  assert.ok(r.refs.includes('#286'));
+});
+
+t('several bare task refs block and are all surfaced', () => {
+  const r = ev('shipped #170/#286/#526 today');
+  assert.equal(r.block, true);
+  assert.deepEqual(r.refs.sort(), ['#170', '#286', '#526'].sort());
+});
+
+t('an unknown id (not in the allow-list) is left bare — the stale-cache fail-safe', () => {
+  // 999 is not a known task id here; with no entity/PR context the hook must NOT
+  // block (better a missed link than a wrong one — same posture as linkify).
+  assert.equal(ev('see #999 maybe').block, false);
+});
+
+t('an entity ref (migration/blocker) blocks too — it also 404s in chat', () => {
+  assert.equal(ev('applied migration #84 last night').block, true);
+  assert.equal(ev('this is gated on blocker #5').block, true);
+});
+
+// ---- allows (must NOT nag) -------------------------------------------------
+
+t('a message with no #refs at all does not block (fast path)', () => {
+  assert.equal(ev('Shipped the security headers and verified the deploy.').block, false);
+});
+
+t('an already-clickable hall link does not block', () => {
+  // The exact shape linkify-refs.js emits — [#286] is link text, the #/task/286
+  // in the URL is not a bare "#<digits>".
+  const s = `landing [#286](${RESOLVER_BASE}286) today`;
+  assert.equal(ev(s).block, false);
+});
+
+t('the "task 286" prose form (no #) does not block', () => {
+  assert.equal(ev('the only C9 item is task 286').block, false);
+});
+
+t('a genuine GitHub PR ref is left alone', () => {
+  // "PR #286" — even though 286 is a known task id, the PR context means the
+  // bare autolink is CORRECT, so linkify (and therefore the hook) skips it.
+  assert.equal(ev('see PR #286 for the merge').block, false);
+  assert.equal(ev('merged in pull request #870').block, false);
+});
+
+t('a code-spanned ref the agent already neutralized does not block', () => {
+  assert.equal(ev('blocker `#5` is still open').block, false);
+});
+
+t('a heading-anchor-style slug does not block', () => {
+  assert.equal(ev('see [§12](#12-session-update-protocol) above').block, false);
+});
+
+t('no id allow-list → fail open (never block on a guess)', () => {
+  assert.equal(evaluate('landing #286 today', new Set()).block, false);
+});
+
+// ---- the nudge tells the model exactly what to emit ------------------------
+
+t('the block reason gives a real-task worked example + the no-# rule', () => {
+  const reason = buildReason(['#286', '#84'], IDS);
+  assert.ok(reason.includes(`[#286](${RESOLVER_BASE}286)`), 'shows the compact #-link form for a real task');
+  assert.ok(/no\s*"#"/i.test(reason), 'states the non-task no-# rule');
+  assert.ok(/PR/i.test(reason), 'tells it to leave genuine PR refs alone');
+});
+
+// ---- transcript parsing (offline, temp file) -------------------------------
+
+t('lastAssistantText returns the final assistant text, skipping tool_use blocks', () => {
+  const tp = path.join(os.tmpdir(), `otb-refcheck-test-${process.pid}.jsonl`);
+  const lines = [
+    { type: 'user', message: { role: 'user', content: [{ type: 'text', text: 'hi' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [
+      { type: 'text', text: 'working on it' },
+      { type: 'tool_use', name: 'Bash', input: {} },
+    ] } },
+    { type: 'user', message: { role: 'user', content: [{ type: 'tool_result', content: 'ok' }] } },
+    { type: 'assistant', message: { role: 'assistant', content: [{ type: 'text', text: 'done, see #286' }] } },
+  ];
+  fs.writeFileSync(tp, lines.map((l) => JSON.stringify(l)).join('\n') + '\n');
+  try {
+    const txt = lastAssistantText(tp);
+    assert.equal(txt, 'done, see #286');
+    assert.equal(evaluate(txt, IDS).block, true);
+  } finally {
+    fs.rmSync(tp, { force: true });
+  }
+});
+
+console.log(`\nstop_refcheck: ${passed} passed, ${failed} failed`);
+process.exit(failed ? 1 : 0);