@bongos/core 1.24.64 → 1.24.66

package/tests/session_start_freshness.mjs

@@ -19,11 +19,13 @@ import { createRequire } from 'node:module';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
+import { execFileSync } from 'node:child_process';
 import { requireHostModule } from './helpers.mjs';
 
 const require = createRequire(import.meta.url);
 const {
   decideFreshness, planFetch, viewNote, staleViewLine, lastMainFetchMs, FETCH_FRESH_MS, FETCH_OLD_NOTE_MS,
+  freshenOrWarn, sessionCheckout, hookCwd, syncEnvLocal,
 } = requireHostModule(require, '../.claude/hooks/session-start.js');
 
 let passed = 0;
@@ -185,5 +187,100 @@ test('lastMainFetchMs: no FETCH_HEAD anywhere → null (never fetched)', () => {
   assert.equal(lastMainFetchMs(null), null);
 });
 
+// ---------- the session's OWN checkout, not the main one (task 1005014) ----------
+// A worktree session can still run session-start with CLAUDE_PROJECT_DIR = the MAIN
+// checkout (run-node.sh keeps the main copy whenever its reroute declines). Then every
+// git read came from main, and the session was told main's branch and staleness as its
+// own. These build a real repo: origin + a main checkout that is current on 'main' + a
+// linked worktree on 'feat' that is 1 behind origin/main with an edit, so it warns.
+function sh(cwd, ...args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+}
+function fixture() {
+  const dir = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'ss-wt-')));
+  const origin = path.join(dir, 'origin.git');
+  const main = path.join(dir, 'main');
+  const wt = path.join(dir, 'wt');
+  sh(dir, 'init', '-q', '--bare', '-b', 'main', origin);
+  sh(dir, 'init', '-q', '-b', 'main', main);
+  const commit = (cwd, f) => {
+    fs.writeFileSync(path.join(cwd, f), f);
+    sh(cwd, 'add', f);
+    sh(cwd, '-c', 'user.name=t', '-c', 'user.email=t@t', 'commit', '-q', '-m', f);
+  };
+  commit(main, 'a.txt');
+  sh(main, 'remote', 'add', 'origin', origin);
+  sh(main, 'push', '-q', 'origin', 'main');
+  sh(main, 'worktree', 'add', '-q', '-b', 'feat', wt);
+  commit(main, 'b.txt');
+  sh(main, 'push', '-q', 'origin', 'main');
+  sh(main, 'fetch', '-q', 'origin');
+  fs.writeFileSync(path.join(wt, 'a.txt'), 'edited'); // dirty → warn, never ff
+  // A fresh FETCH_HEAD recording main, so no background fetch is started.
+  fs.writeFileSync(path.join(main, '.git', 'FETCH_HEAD'), "x\t\tbranch 'main' of origin\n");
+  return { dir, main, wt };
+}
+function captured(fn) {
+  const lines = [];
+  const orig = console.log;
+  console.log = (...a) => lines.push(a.join(' '));
+  try { fn(); } finally { console.log = orig; }
+  return lines.join('\n');
+}
+const norm = (p) => fs.realpathSync.native(p).toLowerCase();
+
+test('sessionCheckout: a linked worktree of the project is the session checkout, not the main one', () => {
+  const f = fixture();
+  try {
+    assert.equal(norm(sessionCheckout({ payloadCwd: f.wt, projectDir: f.main })), norm(f.wt));
+    assert.equal(norm(sessionCheckout({ payloadCwd: f.main, projectDir: f.main })), norm(f.main));
+    assert.equal(sessionCheckout({ payloadCwd: null, projectDir: f.main }), f.main);
+    // A folder outside this project (another repo, or no repo) never qualifies.
+    assert.equal(sessionCheckout({ payloadCwd: f.dir, projectDir: f.main }), f.main);
+  } finally { fs.rmSync(f.dir, { recursive: true, force: true }); }
+});
+
+test("freshenOrWarn: a worktree session is told ITS branch and staleness, not the main checkout's", () => {
+  const f = fixture();
+  const saved = { a: process.env.OTB_SUBAGENT, b: process.env.OTB_FRESHNESS_CHECK_OFF };
+  delete process.env.OTB_SUBAGENT; delete process.env.OTB_FRESHNESS_CHECK_OFF;
+  try {
+    const mainHead = sh(f.main, 'rev-parse', 'HEAD');
+    const out = captured(() => freshenOrWarn({ cwd: f.wt }));
+    assert.match(out, /1 commit\(s\) behind origin\/main/, `expected the worktree's own count, got:\n${out}`);
+    assert.match(out, /You're on 'feat'/, `expected the worktree's own branch, got:\n${out}`);
+    assert.equal(sh(f.main, 'rev-parse', 'HEAD'), mainHead, 'the main checkout is never touched');
+  } finally {
+    if (saved.a !== undefined) process.env.OTB_SUBAGENT = saved.a;
+    if (saved.b !== undefined) process.env.OTB_FRESHNESS_CHECK_OFF = saved.b;
+    fs.rmSync(f.dir, { recursive: true, force: true });
+  }
+});
+
+test('hookCwd: the payload cwd wins; a TTY, no payload or a bad payload falls back to the process cwd', () => {
+  assert.equal(hookCwd({ isTTY: false, read: () => JSON.stringify({ cwd: '/wt', hook_event_name: 'SessionStart' }), fallback: '/p' }), '/wt');
+  assert.equal(hookCwd({ isTTY: true, read: () => { throw new Error('a TTY is never read'); }, fallback: '/p' }), '/p');
+  assert.equal(hookCwd({ isTTY: false, read: () => '', fallback: '/p' }), '/p');
+  assert.equal(hookCwd({ isTTY: false, read: () => 'not json', fallback: '/p' }), '/p');
+  assert.equal(hookCwd({ isTTY: false, read: () => JSON.stringify({ cwd: 7 }), fallback: '/p' }), '/p');
+});
+
+test('sessionCheckout: a subfolder of the worktree resolves to the worktree top level', () => {
+  const f = fixture();
+  try {
+    fs.mkdirSync(path.join(f.wt, 'sub'));
+    assert.equal(norm(sessionCheckout({ payloadCwd: path.join(f.wt, 'sub'), projectDir: f.main })), norm(f.wt));
+  } finally { fs.rmSync(f.dir, { recursive: true, force: true }); }
+});
+
+test("syncEnvLocal: a worktree session gets main's .env.local (main was mistaken for \"this checkout\", so it never did)", () => {
+  const f = fixture();
+  try {
+    fs.writeFileSync(path.join(f.main, '.env.local'), 'K=v\n');
+    captured(() => syncEnvLocal({ cwd: f.wt }));
+    assert.equal(fs.readFileSync(path.join(f.wt, '.env.local'), 'utf8'), 'K=v\n');
+  } finally { fs.rmSync(f.dir, { recursive: true, force: true }); }
+});
+
 console.log(`\n${passed} passed, ${failed} failed`);
 process.exit(failed === 0 ? 0 : 1);

package/tests/ui_design_kit.mjs

@@ -27,7 +27,7 @@ const readJson = (rel) => JSON.parse(fs.readFileSync(path.join(ROOT, rel), 'utf8
 
 // ── the contract ──────────────────────────────────────────────────────────────
 test('the platform floors are a pinned list — a floor cannot vanish quietly', () => {
-  assert.deepEqual([...lib.FLOORS], ['console-errors', 'failed-requests', 'horizontal-overflow', 'text-fit', 'sibling-overlap', 'one-header-main-h1', 'controls-24px', 'top-bar-80px', 'reduced-motion']);
+  assert.deepEqual([...lib.FLOORS], ['console-errors', 'failed-requests', 'horizontal-overflow', 'text-fit', 'sibling-overlap', 'empty-graphic', 'one-header-main-h1', 'controls-24px', 'top-bar-80px', 'reduced-motion']);
   assert.deepEqual(lib.EXIT, { CLEAN: 0, PROBLEMS: 1, USAGE: 2, NO_BROWSER: 3 });
   assert.deepEqual(Object.keys(lib.SIZES), ['320', '390', '1024', '1280', '1440']);
   assert.deepEqual([...lib.DEFAULT_SIZES], [1440, 390, 320], 'render.js renders these unless --sizes names 1280');
@@ -100,6 +100,9 @@ test('auditFloors names each floor a render breaks, and says nothing about a cle
   const fit = lib.auditFloors({ ...clean(), textFit: ['#t1 "Governance" 15px past its card', 'b', 'c', 'd', 'e', 'f', 'g'], overlaps: ['#mSec > div ∩ #mSec > div 640x48'] }, { width: 1280 });
   assert.ok(fit.includes('text-fit: #t1 "Governance" 15px past its card | b | c | d | e (+2 more)'), fit.join(' / '));
   assert.ok(fit.includes('sibling-overlap: #mSec > div ∩ #mSec > div 640x48'));
+  // task 1005104: a logo whose referenced SVG failed to parse is a floor problem, not ALL CLEAN
+  assert.deepEqual(lib.auditFloors({ ...clean(), emptyGraphics: [] }, { width: 1440, mode: 'dark' }), []);
+  assert.deepEqual(lib.auditFloors({ ...clean(), emptyGraphics: ['a.brand > svg > use → "/logo.svg#mark" paints nothing'] }, { width: 1440, mode: 'dark' }), ['empty-graphic: a.brand > svg > use → "/logo.svg#mark" paints nothing']);
 });
 
 test('expectProblems compares every expectation the vocabulary allows', () => {

package/tests/ui_design_kit_fit.mjs

@@ -73,3 +73,33 @@ test('an overlap among <body>\'s own children is caught too — the one-cell gri
   await ctx.close();
   assert.deepEqual(facts.overlaps.map((o) => o.replace(/ \d+x\d+$/, '')), ['#first ∩ #second']);
 });
+
+// task 1005104: a referenced SVG that fails to parse leaves an empty <use> (or an <img> with no natural size) and
+// the logo simply vanishes — no console error, no failed request, so the render said ALL CLEAN. The empty-graphic
+// floor reports each shown <use>/<img> that paints nothing; a sprite sheet's own symbols, a hidden icon, a lazy
+// image not yet in view and a graphic that draws stay silent.
+test('the empty-graphic floor reports a <use> or <img> that paints nothing, and not one that draws or is hidden', { skip: !browser && 'no system Edge or Chrome' }, async () => {
+  const dot = 'data:image/svg+xml,' + encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20"><circle cx="10" cy="10" r="8"/></svg>');
+  const broken = 'data:image/svg+xml,' + encodeURIComponent('<svg xmlns="http://www.w3.org/2000/svg" width="20" height="20"><circle cx="10"');
+  const ctx = await browser.newContext({ viewport: { width: 1280, height: 800 } });
+  const page = await ctx.newPage();
+  await page.setContent(`<!doctype html><html><body><header></header><main><h1>logos</h1>
+    <svg width="0" height="0" style="position: absolute"><defs><symbol id="mark" viewBox="0 0 20 20"><circle cx="10" cy="10" r="8"/></symbol></defs><symbol id="empty"><use href="#nothing"/></symbol></svg>
+    <svg id="logo-ok" width="40" height="40"><use href="#mark"/></svg>
+    <svg id="logo-gone" width="40" height="40"><use href="#missing"/></svg>
+    <svg id="logo-unparsed" width="40" height="40"><use href="${broken}#mark"/></svg>
+    <span style="display: none"><svg width="40" height="40"><use href="#missing"/></svg></span>
+    <img id="img-ok" src="${dot}" alt="dot">
+    <img id="img-unparsed" src="${broken}" alt="">
+    <img id="img-flat" src="${dot}" alt="" style="width: 0; height: 0">
+    <img hidden src="${broken}" alt="">
+  </main></body></html>`, { waitUntil: 'load' });
+  const facts = await page.evaluate(lib.factsInPage, {});
+  await ctx.close();
+  const got = facts.emptyGraphics.map((g) => g.split(' → ')[0]).sort();
+  assert.deepEqual(got, ['#img-flat', '#img-unparsed', '#logo-gone > use', '#logo-unparsed > use'], facts.emptyGraphics.join('\n'));
+  assert.ok(facts.emptyGraphics.includes('#logo-gone > use → "#missing" paints nothing'), facts.emptyGraphics.join('\n'));
+  assert.ok(facts.emptyGraphics.includes('#logo-unparsed > use → "data:image/svg+xml…#mark" paints nothing'), facts.emptyGraphics.join('\n'));
+  const problems = lib.auditFloors(facts, { width: 1280 });
+  assert.ok(problems.some((p) => p.startsWith('empty-graphic: ') && p.includes('#logo-gone')), problems.join('\n'));
+});