@bongos/core 1.19.271 → 1.19.273

package/tests/context_pack.mjs

@@ -17,6 +17,7 @@ const require = createRequire(import.meta.url);
 const {
   apiContract,
   resolveWorktreeRoot,
+  worktreeGuidance,
   osFacts,
   normalizeClaims,
   buildContextPack,
@@ -177,6 +178,104 @@ t('buildContextPack: composes worktree + claims + api + os from injected runners
   assert.equal(pack.os.platform, 'linux');
 });
 
+// ---- task 1002573: which tree is this, and does the guidance tell the truth ----
+//
+// The pack used to print the root and then assert "this is the session's tree,
+// not the main checkout" UNCONDITIONALLY. Claiming from the main checkout
+// therefore produced a flatly false sentence, and the tooling told the builder to
+// do the one thing that makes the ship unmergeable (the receiving tree is the one
+// holding the branch — task 1002572). The signal was already computed elsewhere
+// (claim.js detectWorktreeName) and simply never surfaced.
+//
+// Stubs mirror real git: in the MAIN checkout `--git-dir` and `--git-common-dir`
+// both answer '.git'; in a LINKED worktree they diverge.
+const gitMain = (args) => {
+  const a = args.join(' ');
+  if (a.includes('--show-toplevel')) return '/repo\n';
+  if (a.includes('--git-common-dir')) return '.git\n';
+  if (a.includes('--git-dir')) return '.git\n';
+  throw new Error(`unexpected git call: ${a}`);
+};
+const gitLinked = (args) => {
+  const a = args.join(' ');
+  if (a.includes('--show-toplevel')) return '/repo/.claude/worktrees/task-1\n';
+  if (a.includes('--git-common-dir')) return '/repo/.git\n';
+  if (a.includes('--git-dir')) return '/repo/.git/worktrees/task-1\n';
+  throw new Error(`unexpected git call: ${a}`);
+};
+
+t('resolveWorktreeRoot: identical git-dir and common-dir ⇒ the MAIN checkout', () => {
+  const r = resolveWorktreeRoot({ runGit: gitMain, cwd: '/elsewhere' });
+  assert.equal(r.root, '/repo');
+  assert.equal(r.degraded, false);
+  assert.equal(r.isMainCheckout, true);
+});
+
+t('resolveWorktreeRoot: diverging git-dir ⇒ a LINKED worktree', () => {
+  const r = resolveWorktreeRoot({ runGit: gitLinked, cwd: '/elsewhere' });
+  assert.equal(r.root, '/repo/.claude/worktrees/task-1');
+  assert.equal(r.isMainCheckout, false);
+});
+
+t('resolveWorktreeRoot: unresolvable tree kind is UNKNOWN (null), never a guess', () => {
+  // toplevel works, but the dir probes fail — the kind must not default to either.
+  const partial = (args) => {
+    if (args.join(' ').includes('--show-toplevel')) return '/repo\n';
+    throw new Error('no');
+  };
+  assert.equal(resolveWorktreeRoot({ runGit: partial, cwd: '/c' }).isMainCheckout, null);
+  // And a total git failure still degrades to cwd without throwing.
+  const dead = resolveWorktreeRoot({ runGit: () => { throw new Error('no git'); }, cwd: '/here' });
+  assert.equal(dead.root, '/here');
+  assert.equal(dead.degraded, true);
+  assert.equal(dead.isMainCheckout, null);
+});
+
+t('worktreeGuidance: the main-checkout text DIFFERS from the worktree text', () => {
+  // The task's own verify criterion: the guidance must not read the same in both
+  // trees. Anything else means the builder is being told the same thing whether
+  // it is true or not.
+  const mainText = worktreeGuidance({ isMainCheckout: true }).join('\n');
+  const wtText = worktreeGuidance({ isMainCheckout: false }).join('\n');
+  assert.notEqual(mainText, wtText);
+  // The old, wrong sentence must NOT appear in the main checkout.
+  assert.doesNotMatch(mainText, /not the main checkout/i,
+    'the main checkout must never be told it is not the main checkout');
+  assert.match(wtText, /not the main checkout/i, 'a real worktree keeps the original line');
+});
+
+t('worktreeGuidance: the main-checkout warning names the CONSEQUENCE, not just the fact', () => {
+  const text = worktreeGuidance({ isMainCheckout: true }).join('\n');
+  assert.match(text, /MAIN CHECKOUT/);
+  assert.match(text, /auto-merge/i, 'says what breaks');
+  assert.match(text, /confirmed/, 'and where the ship strands');
+  assert.match(text, /git worktree add/, 'and gives the command that avoids it');
+});
+
+t('worktreeGuidance: unknown tree kind hedges instead of asserting either', () => {
+  for (const w of [{ isMainCheckout: null }, {}, null, undefined]) {
+    const text = worktreeGuidance(w).join('\n');
+    assert.match(text, /Could not tell/i, `hedged for ${JSON.stringify(w)}`);
+    assert.doesNotMatch(text, /THIS IS THE MAIN CHECKOUT/, 'never assert main');
+    assert.doesNotMatch(text, /This is the session's tree/, 'never assert worktree');
+  }
+});
+
+t('formatContextPack: renders the main-checkout WARNING when that is the truth', () => {
+  const pack = buildContextPack({
+    activeClaims: [{ task_id: 942, title: 'x' }],
+    currentTaskId: 942,
+    cwd: '/fallback',
+    platform: 'linux',
+    runGit: gitMain,
+    runWhich: fakeWhich({ timeout: '/usr/bin/timeout', psql: '/usr/bin/psql' }),
+  });
+  const out = formatContextPack(pack);
+  assert.match(out, /THIS IS THE MAIN CHECKOUT/);
+  assert.doesNotMatch(out, /not the main checkout/i);
+  assert.ok(!/undefined/.test(out), 'no undefined leaked into the rendered pack');
+});
+
 // ---- formatting ------------------------------------------------------------
 t('formatClaims: empty vs held, with the (this one) marker', () => {
   assert.equal(formatClaims([]), '(none held)');
@@ -194,16 +293,20 @@ t('formatOs: names the macOS no-timeout case in prose', () => {
 });
 
 t('formatContextPack: includes worktree root, prefix, a real kind, and warns the wrong-tree footgun', () => {
+  // task 1002573: uses a LINKED-worktree stub. It previously passed an
+  // args-ignoring stub, which returned the same path for every probe — i.e. the
+  // main checkout — while asserting the "not the main checkout" line. The test
+  // was encoding the bug.
   const pack = buildContextPack({
     activeClaims: [{ task_id: 942, title: 'x' }],
     currentTaskId: 942,
     cwd: '/fallback',
     platform: 'linux',
-    runGit: () => '/work/tree\n',
+    runGit: gitLinked,
     runWhich: fakeWhich({ timeout: '/usr/bin/timeout', psql: '/usr/bin/psql' }),
   });
   const out = formatContextPack(pack);
-  assert.match(out, /\/work\/tree/);
+  assert.match(out, /task-1/);
   assert.match(out, /\/api\/bongos/);
   assert.match(out, /feature/);          // a real kind from VALID_KINDS
   assert.match(out, /not the main checkout/i);

package/tests/hall_error_envelope.mjs

@@ -0,0 +1,264 @@
+// tests/hall_error_envelope.mjs — task 1002462.
+//
+// THE DEFECT. The server returns the ADR 0116 envelope via res.fail():
+// `{ error: { code, message, details } }`. The code is NESTED, so a bare
+// `data.error === 'CODE'` test compares a string to an OBJECT and silently never
+// matches — every switch falls through to its generic default. The builder gets
+// "Could not complete that (409). Try again." for a refusal the server described
+// precisely.
+//
+// It survived because it degrades into a wrong-but-PLAUSIBLE toast rather than a
+// visible break, so nothing failed and no smoke test could catch it. The same
+// defect appeared independently on four hall surfaces.
+//
+// The fix puts the readers in dom-utils.js — the shared toolkit every hall page
+// already loads first — so a fifth copy is never the easiest option.
+//
+// What we prove, executing the REAL files in a vm (the tests/hall_signout.mjs and
+// goal_criterion_confirm_ui.mjs precedent — there is no jsdom here):
+//   1. dom-utils' errCode / errMessage / errDetails read BOTH wire shapes and
+//      survive hostile input. This is now the single point of failure for four
+//      surfaces, so it is tested directly rather than through a page.
+//   2. END TO END on the real task.js: a 409 carrying the envelope renders the
+//      SERVER'S OWN sentence in the toast, not the generic fallback. This is the
+//      user-visible regression, driven through a real button click.
+//   3. Neither consumer still reads the flat shape anywhere.
+//
+// Run:  node tests/hall_error_envelope.mjs
+
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import vm from 'node:vm';
+import { fileURLToPath } from 'node:url';
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const HALL = path.join(ROOT, 'modules/hall-ui/public');
+
+let passed = 0;
+let failed = 0;
+function t(name, fn) {
+  try {
+    const r = fn();
+    if (r && typeof r.then === 'function') {
+      return r.then(
+        () => { passed++; console.log(`  ok  ${name}`); },
+        (e) => { failed++; console.log(`  FAIL ${name}`); console.log(`     ${e.message}`); }
+      );
+    }
+    passed++; console.log(`  ok  ${name}`);
+  } catch (e) {
+    failed++; console.log(`  FAIL ${name}`); console.log(`     ${e.message}`);
+  }
+  return Promise.resolve();
+}
+
+// ---- 1. the shared readers, from the real dom-utils.js ----------------------
+
+function loadOTB() {
+  const sandbox = {
+    window: {},
+    document: {
+      createElement: () => ({ style: {}, classList: { add() {}, remove() {} }, appendChild() {}, remove() {} }),
+      body: { appendChild() {} },
+      querySelector: () => null,
+      querySelectorAll: () => [],
+      getElementById: () => null,
+    },
+    setTimeout, clearTimeout, console,
+  };
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  vm.runInContext(fs.readFileSync(path.join(HALL, 'dom-utils.js'), 'utf8'), sandbox, { filename: 'dom-utils.js' });
+  return sandbox.window.OTB;
+}
+
+await t('dom-utils exports the envelope readers on window.OTB', () => {
+  const OTB = loadOTB();
+  for (const fn of ['errCode', 'errMessage', 'errDetails']) {
+    assert.equal(typeof OTB[fn], 'function', `${fn} must be on the shared toolkit`);
+  }
+});
+
+await t('errCode reads the ADR 0116 envelope AND the legacy flat shape', () => {
+  const { errCode } = loadOTB();
+  assert.equal(errCode({ error: { code: 'ALREADY_CLAIMED', message: 'x' } }), 'ALREADY_CLAIMED');
+  assert.equal(errCode({ error: 'ALREADY_CLAIMED' }), 'ALREADY_CLAIMED', 'an older server must still map');
+  assert.equal(errCode({ code: 'ALREADY_CLAIMED' }), 'ALREADY_CLAIMED');
+});
+
+await t('errCode never returns an object — the whole bug in one assertion', () => {
+  const { errCode } = loadOTB();
+  const code = errCode({ error: { code: 'TOUCHES_CONFLICT', details: { conflicts: [] } } });
+  assert.equal(typeof code, 'string');
+  assert.notEqual(typeof code, 'object', 'returning the object is what made every switch case miss');
+});
+
+await t('errMessage prefers the envelope message over a top-level one', () => {
+  const { errMessage } = loadOTB();
+  assert.equal(errMessage({ error: { code: 'c', message: 'the real sentence' } }), 'the real sentence');
+  assert.equal(errMessage({ message: 'legacy sentence' }), 'legacy sentence');
+  assert.equal(errMessage({ error: 'c' }), '');
+});
+
+await t('errDetails takes error.details, else falls back to the BODY (flat shape)', () => {
+  const { errDetails } = loadOTB();
+  assert.deepEqual(errDetails({ error: { code: 'c', details: { conflicts: [{ title: 'A' }] } } }).conflicts, [{ title: 'A' }]);
+  // On the flat shape the extra fields sat at the top level.
+  assert.deepEqual(errDetails({ error: 'c', conflicts: [{ title: 'B' }] }).conflicts, [{ title: 'B' }]);
+});
+
+await t('the readers survive hostile / empty input without throwing', () => {
+  const { errCode, errMessage, errDetails } = loadOTB();
+  for (const bad of [undefined, null, {}, { error: null }, { error: 0 }, { error: [] }, 'str', 42]) {
+    assert.equal(typeof errCode(bad), 'string', `errCode(${JSON.stringify(bad)})`);
+    assert.equal(typeof errMessage(bad), 'string');
+    assert.equal(typeof errDetails(bad), 'object');
+  }
+});
+
+// ---- 2. end to end through the REAL task.js --------------------------------
+
+// Minimal DOM: only what task.js touches (getElementById/querySelector by id,
+// addEventListener, innerHTML, textContent). Elements are plain objects with a
+// click() that invokes the registered handler.
+// The DOM handlers call runLifecycle without returning its promise, so the toast
+// lands several microtasks after the click. Flush rather than guess a timeout.
+async function flush(n = 12) {
+  for (let i = 0; i < n; i += 1) await new Promise((r) => setImmediate(r));
+}
+
+function makeEl(id) {
+  return {
+    id, innerHTML: '', textContent: '', disabled: false, dataset: {}, style: {},
+    _handlers: {},
+    addEventListener(ev, fn) { this._handlers[ev] = fn; },
+    click() { return this._handlers.click && this._handlers.click(); },
+    querySelector: () => null,
+    querySelectorAll: () => [],
+    classList: { add() {}, remove() {}, toggle() {} },
+    setAttribute() {}, removeAttribute() {}, appendChild() {}, remove() {},
+  };
+}
+
+async function bootTaskPage({ task, failWith }) {
+  const els = new Map();
+  const el = (id) => {
+    const key = String(id).replace(/^#/, '');
+    if (!els.has(key)) els.set(key, makeEl(key));
+    return els.get(key);
+  };
+  const toasts = [];
+  const document = {
+    _ready: null,
+    // renderTask does document.title.split(' — ') — it must be a real string.
+    title: '#0 — task — Cloud Bongos',
+    addEventListener(ev, fn) { if (ev === 'DOMContentLoaded') this._ready = fn; },
+    getElementById: (id) => el(id),
+    querySelector: (sel) => el(sel),
+    querySelectorAll: () => [],
+    createElement: () => makeEl('tmp'),
+    body: makeEl('body'),
+  };
+  const sandbox = {
+    document,
+    console,
+    setTimeout,
+    clearTimeout,
+    location: { hostname: 'builders.example.com', pathname: `/task/${task.id}`, href: '', assign() {} },
+    window: {
+      OTBBranding: { taskCreditValue: () => null, taskCreditLabel: () => 'credits' },
+      confirm: () => true,
+      location: { hostname: 'builders.example.com', pathname: `/task/${task.id}`, assign() {} },
+      // The generated typed client's result mode: { status, ok, data }.
+      BongosClient: {
+        createClient: () => ({
+          request: async (method, urlPath) => {
+            if (method === 'GET' && urlPath.includes('/me')) {
+              return { ok: true, status: 200, data: { builder: { id: 1, rank: 'archon' } } };
+            }
+            if (method === 'GET') return { ok: true, status: 200, data: { task, last_claim: null } };
+            // The lifecycle POST — refuse it with the shape under test.
+            return { ok: false, status: failWith.status, data: failWith.body };
+          },
+        }),
+      },
+    },
+  };
+  sandbox.window.document = document;
+  sandbox.globalThis = sandbox;
+  vm.createContext(sandbox);
+  // dom-utils FIRST, in this same context — exactly the real page's script order,
+  // and required because dom-utils' `$` closes over the document it sees at
+  // definition time.
+  vm.runInContext(fs.readFileSync(path.join(HALL, 'dom-utils.js'), 'utf8'), sandbox, { filename: 'dom-utils.js' });
+  const realToast = sandbox.window.OTB.toast;
+  sandbox.window.OTB = { ...sandbox.window.OTB, toast: (m) => { toasts.push(String(m)); } };
+  void realToast;
+  vm.runInContext(fs.readFileSync(path.join(HALL, 'task.js'), 'utf8'), sandbox, { filename: 'task.js' });
+  assert.ok(document._ready, 'task.js registered a DOMContentLoaded handler');
+  await document._ready();
+  return { els, el, toasts };
+}
+
+const VERIFY_TASK = { id: 4242, kind: 'verify', title: 'a verify task', status: 'completed', description: 'x' };
+
+await t('END TO END: a 409 envelope renders the SERVER\'S sentence, not the generic fallback', async () => {
+  const serverSentence = "Task #4242 is a verification task (kind='verify') — confirm it only AFTER the verification ran.";
+  const { el, toasts } = await bootTaskPage({
+    task: VERIFY_TASK,
+    failWith: {
+      status: 409,
+      body: { error: { code: 'verify_attestation_required', message: serverSentence, details: {} } },
+    },
+  });
+  const btn = el('confirm-btn');
+  assert.ok(btn._handlers.click, 'the confirm control rendered and is wired');
+  await btn.click();
+  await flush();
+  const shown = toasts.join(' | ');
+  assert.ok(
+    shown.includes(serverSentence),
+    `the toast must carry the server's own sentence. got: ${shown}`
+  );
+  assert.ok(
+    !/Could not complete that/.test(shown),
+    `the generic fallback is exactly the bug — got: ${shown}`
+  );
+});
+
+await t('END TO END: the legacy FLAT shape still maps (older server)', async () => {
+  const { el, toasts } = await bootTaskPage({
+    // status 'confirmed' + a supervisor is what renders the SHIP control.
+    task: { ...VERIFY_TASK, kind: 'feature', status: 'confirmed' },
+    failWith: { status: 409, body: { error: 'task_not_confirmed' } },
+  });
+  const btn = el('ship-btn');
+  assert.ok(btn._handlers.click, 'the ship control rendered');
+  await btn.click();
+  await flush();
+  const shown = toasts.join(' | ');
+  assert.match(shown, /only be shipped once it is confirmed/, `got: ${shown}`);
+  assert.ok(!/Could not complete that/.test(shown), `got: ${shown}`);
+});
+
+// ---- 3. no flat reads left in either consumer -------------------------------
+
+await t('neither work.js nor task.js reads the flat error shape any more', () => {
+  for (const rel of ['work.js', 'task.js']) {
+    const src = fs.readFileSync(path.join(HALL, rel), 'utf8');
+    const code = src.split('\n').filter((l) => !l.trim().startsWith('//')).join('\n');
+    assert.doesNotMatch(code, /data\s*&&\s*data\.error\b/, `${rel}: still reads data.error directly`);
+    assert.doesNotMatch(code, /err\.data\.error\s*===/, `${rel}: still compares err.data.error to a string`);
+    assert.doesNotMatch(code, /\bdata\.conflicts\b/, `${rel}: still reads conflicts off the body`);
+    assert.doesNotMatch(code, /\bdata\.what_to_do\b/, `${rel}: still reads what_to_do off the body`);
+    // And it must pull the shared readers rather than redefine a fifth copy.
+    assert.match(src, /window\.OTB/, `${rel}: uses the shared toolkit`);
+    assert.match(src, /errCode/, `${rel}: goes through errCode`);
+    assert.doesNotMatch(code, /function errCode\s*\(/, `${rel}: must NOT define its own copy`);
+  }
+});
+
+console.log('');
+console.log(`hall_error_envelope: ${passed} passed, ${failed} failed`);
+process.exit(failed === 0 ? 0 : 1);