@bongos/core 1.21.38 → 1.21.40

package/tests/hall_matter_card.mjs

@@ -31,6 +31,7 @@ const require = createRequire(import.meta.url);
 require(path.join(PUB, 'city-draw.js'));
 require(path.join(PUB, 'street-draw.js'));
 const C = require(path.join(PUB, 'street-card.js'));
+const D = require(path.join(PUB, 'street-desk.js'));
 const read = (f) => fs.readFileSync(path.join(PUB, f), 'utf8');
 const NOW = Date.parse('2026-10-02T12:00:00.000Z');
 const VIEWER = '95';
@@ -77,8 +78,12 @@ test('an open unanimous sitting that waits on you: the proposer\'s words, the ch
   assert.equal(cv.counsel.revise, false);
   assert.deepEqual(cv.actions.map((a) => [a.key, a.label, a.tone]), [['for', 'vote for', 'primary'], ['object', 'object', 'quiet']]);
   assert.deepEqual(cv.textActions.map((a) => a.key), ['abstain']);
-  assert.ok(cv.objectForm.sections.length >= 3);
   assert.equal(cv.readOnly, false);
+  // more (task 1004566): the whole rationale, who and when, and every vote in order
+  assert.equal(cv.more.text[0].words, 'Three pieces of finished work are waiting because no one is allowed to test them.\n\nMore below.');
+  assert.equal(cv.more.who, 'Put up by Ana Ruiz.');
+  assert.equal(cv.more.when, 'opened 2026-10-01 · closes 2026-10-03');
+  assert.deepEqual(cv.more.history, ['2026-10-01 · Ana Ruiz voted for', '2026-10-01 · Theo voted for', '2026-10-01 · Mira voted for']);
 });
 
 test('a majority sitting with an objection, after your yes: voices for and against, what it still needs', () => {
@@ -104,7 +109,7 @@ test('a sitting that came back to you: counsel answers the objection, revise and
   assert.equal(cv.readOnly, false);
 });
 
-test('passed, not yours, a Full Idea, and a ballot not read yet are read-only', () => {
+test('passed, not yours, and a ballot not read yet are read-only; a Full Idea is voted on here with its sections under more', () => {
   const passed = card([matter({ state: 'settled' })], 'board:41', room([], [item({ closed_at: '2026-10-02T09:00:00.000Z', outcome: 'passed', votes: [vote(4, 'Ana', 'yes'), vote(5, 'Theo', 'yes')] })]));
   assert.equal(passed.result, 'Passed 2–0. In force from 2026-10-02.');
   assert.deepEqual([passed.readOnly, passed.actions.length, passed.textActions.length], [true, 0, 0]);
@@ -113,9 +118,11 @@ test('passed, not yours, a Full Idea, and a ballot not read yet are read-only',
   assert.equal(notMine.actions.length, 0);
   assert.ok(!notMine.seats.some((s) => s.pos === 'you'), 'no seat drawn for you when you have none');
   const idea = card([matter({ building: 'planning', state: 'needs' })], 'board:41', room([item({ subject_type: 'full_idea', subject: { title: 'An idea', author_id: '4', field_values: { purpose: 'It does a thing.' } } })]));
-  assert.equal(idea.actions.length, 0, 'a Full Idea is voted on with its sections in front of you');
-  assert.match(idea.result, /Board Room/);
-  assert.equal(idea.href, '/board-room?item=41');
+  assert.deepEqual(idea.actions.map((a) => a.key), ['for', 'object'], 'a Full Idea is voted on from the card (task 1004566)');
+  assert.equal(idea.result, 'Read its sections under more, then vote.');
+  assert.deepEqual(idea.more.text, [{ label: 'what it is for', words: 'It does a thing.' }], 'its sections are in front of the voter');
+  const ownIdea = card([matter({ building: 'planning', state: 'moving' })], 'board:41', room([item({ subject_type: 'full_idea', subject: { title: 'An idea', author_id: VIEWER, field_values: { purpose: 'Mine.' } }, votes: [] })]));
+  assert.deepEqual([ownIdea.readOnly, ownIdea.actions.length, ownIdea.result], [true, 0, 'Yours. It is with the sitting now.'], 'its author never votes on it');
   const loading = card([matter()], 'board:41', null);
   assert.deepEqual([loading.loading, loading.readOnly, loading.result], [true, true, 'Reading the sitting…']);
   const gone = card([matter()], 'board:41', room([]));
@@ -134,8 +141,10 @@ test('a constitution amendment shows each changed setting struck and inserted ag
 
 test('admissions: fine by me or object when it is yours, read-only when it is not', () => {
   const m = { id: 'access_requests:7', source: 'access_requests', building: 'people', rule: 'decide', state: 'needs', title: 'Admit Kai as a builder', short: 'admit kai', where: 'people · waiting to join · vouched', proposer: { login: 'kai', name: 'Kai' }, tally: null, href: '/watch', ref: { type: 'access_request', id: '7' } };
-  const cv = card([m], 'access_requests:7');
-  assert.equal(cv.quote.words, 'Kai asked to join as a builder, and someone vouched for them.');
+  const cv = card([{ ...m, detail: 'I build the docs site.' }], 'access_requests:7');
+  assert.equal(cv.quote, null, 'the compact card is the title, one fact and its acts');
+  assert.deepEqual(cv.more.text.map((t) => t.words), ['Kai asked to join as a builder, and someone vouched for them.', 'I build the docs site.']);
+  assert.equal(cv.more.who, 'Raised by Kai.');
   assert.deepEqual(cv.actions.map((a) => [a.key, a.label]), [['fine', 'fine by me'], ['refuse', 'object']]);
   const other = card([{ ...m, state: 'moving' }], 'access_requests:7');
   assert.deepEqual([other.readOnly, other.actions.length], [true, 0]);
@@ -312,21 +321,20 @@ test('vote for: one POST to the vote route, a toast, the docket re-read, and the
   assert.match(p.byId.get('streetPins').children[0].className, /street-pin--moving street-pin--answer/, 'the pin moved from needs to moving');
 });
 
-test('object: the form asks for the reason and the part, then puts both on the record', async () => {
+test('object: "no" opens the desk row\'s one-tap reasons, and a tap puts the reason and the part on the record', async () => {
   const p = await bootPage({ feeds: BASE(docket([matter()])), posts: { 'POST /api/bongos/government/board/items/41/votes': { ok: true, vote: {}, item_closed: true, outcome: 'returned' } } });
   p.byId.get('streetPins').children[0].fire('click');
   await settle(); await settle();
-  byAct(p.byId.get('streetCardBody'), 'object').fire('click');
-  assert.equal(p.focused.el, p.byId.get('mcardReason'), 'focus goes to the reason');
-  byAct(p.byId.get('streetCardBody'), 'object-send').fire('click');
-  await settle();
-  assert.equal(p.calls.filter((c) => c.method !== 'GET').length, 0, 'an empty objection is refused before it is sent');
-  assert.match(walk(p.byId.get('streetCardBody'), (n) => n.className === 'mcard-error')[0].textContent, /^Say why/);
-  p.byId.get('mcardReason').value = 'Volunteers go quiet.';
-  p.byId.get('mcardSection').value = 'scope';
-  byAct(p.byId.get('streetCardBody'), 'object-send').fire('click');
+  const body = () => p.byId.get('streetCardBody');
+  assert.equal(byAct(body(), 'object').textContent, D.ACT_WORDS.object, 'the desk row\'s word');
+  assert.equal(byAct(body(), 'object').attrs['aria-expanded'], 'false');
+  byAct(body(), 'object').fire('click');
+  assert.equal(p.calls.filter((c) => c.method !== 'GET').length, 0, 'asking sends nothing');
+  assert.equal(byAct(body(), 'object').attrs['aria-expanded'], 'true');
+  assert.deepEqual(walk(body(), (n) => n.className === 'mcard-chip').map((n) => n.textContent), Object.values(D.CHIPS), 'the same chips as the desk row');
+  byAct(body(), 'chip-scope').fire('click');
   await settle(); await settle(); await settle();
-  assert.deepEqual(p.calls.filter((c) => c.method !== 'GET').map((c) => c.body), [{ direction: 'no', reason_md: 'Volunteers go quiet.', section_key: 'scope' }]);
+  assert.deepEqual(p.calls.filter((c) => c.method !== 'GET').map((c) => c.body), [{ direction: 'no', reason_md: 'Objects to what it changes (one tap on the floor desk).', section_key: 'scope' }]);
   assert.equal(p.byId.get('streetToast').textContent, 'Your objection is on the record. It goes back to its author to revise.');
 });
 
@@ -382,6 +390,123 @@ test('the card\'s motion is CSS only and dies under reduced motion; tokens only;
   assert.match(html, /id="streetToast" role="status" aria-live="polite"/);
 });
 
+// ── one action model, and more in place (task 1004566) ──────────────────────
+// Every docket source in the shape its route hands it, with the acts its owning
+// module gives a viewer who may act. The card for each must offer the desk
+// row's acts for the same item and link nowhere.
+const SOURCE_FIXTURES = () => {
+  const ms = [
+    matter(),
+    matter({ id: 'board:43', building: 'planning', short: 'idea to ratify', title: 'Ask before a big change', ref: { type: 'board_item', id: '43' } }),
+    { id: 'blockers:11', source: 'blockers', building: 'planning', rule: 'decide', state: 'needs', title: 'Hosting for the demo', short: 'blocker', where: 'planning · holds 2 tasks', opened_at: '2026-09-30T09:00:00.000Z', proposer: null, tally: null, href: '/blockers#blocker-11', ref: { type: 'blocker', id: '11' }, acts: [{ key: 'decide', options: [{ key: 'go ahead', label: 'go ahead' }, { key: 'not now', label: 'not now' }] }], detail: 'Option A: Render\nOption B: Fly' },
+    { id: 'access_requests:7', source: 'access_requests', building: 'people', rule: 'decide', state: 'needs', title: 'Admit Kai as a builder', where: 'people · waiting to join', proposer: { login: 'kai', name: 'Kai' }, href: '/watch', ref: { type: 'access_request', id: '7' } },
+    { id: 'goal_join_requests:5', source: 'goal_join_requests', building: 'people', rule: 'decide', state: 'needs', title: 'Bo asks to join Sign-up', proposer: { login: 'bo' }, href: '/goals#/goal/1000125', ref: { type: 'goal_membership_request', id: '5' } },
+    { id: 'override_requests:9', source: 'override_requests', building: 'release', rule: 'decide', state: 'needs', title: 'Override: the new sign-up', proposer: { login: 'lu' }, href: '/task/12', ref: { type: 'override_request', id: '9' }, detail: 'The grader timed out twice.' },
+    { id: 'removal_proposals:61', source: 'removal_proposals', building: 'disputes', rule: 'decide', state: 'needs', title: 'Old search page', href: '/task/61', ref: { type: 'task', id: '61' }, acts: [{ key: 'remove' }, { key: 'keep' }] },
+    { id: 'redteam_reports:4', source: 'redteam_reports', building: 'disputes', rule: 'decide', state: 'needs', title: 'Security report: sign-in limit skipped', href: '/watch', ref: { type: 'vulnerability_report', id: '4' }, acts: [{ key: 'confirm' }, { key: 'dispute' }] },
+    { id: 'criteria_uat:3', source: 'criteria_uat', building: 'review', rule: 'signoff', state: 'needs', title: 'The export runs nightly', href: '/goals#/goal/7', ref: { type: 'criterion', id: '3' }, acts: [{ key: 'signoff', options: [{ key: 'live', label: 'tested it live' }] }, { key: 'force', options: [{ key: 'tested_by_hand', label: 'tested by hand' }] }] },
+    { id: 'core_update:1.21.20', source: 'core_update', building: 'release', rule: 'decide', state: 'needs', title: 'Take core 1.21.20 (running 1.21.19)', href: '/settings#software-update', ref: { type: 'core_version', id: '1.21.20' } },
+    { id: 'gate_approvals:88', source: 'gate_approvals', building: 'release', rule: 'decide', state: 'needs', title: 'PR 88 waits at the gate', href: '/gate', ref: { type: 'pull_request', id: '88' } },
+    { id: 'autobongos_fence:project', source: 'autobongos_fence', building: 'automation', rule: 'decide', state: 'needs', title: 'Unattended building is off', href: '/autobongos', ref: { type: 'autonomy_fence', id: 'project' }, acts: [{ key: 'switch_on' }] },
+    { id: 'module_rechecks:7', source: 'module_rechecks', building: 'release', rule: 'rule', state: 'needs', title: 'image-tools 1.2.0 failed its security check', href: '/modules', ref: { type: 'module_version', id: 'image-tools@1.2.0' }, acts: [{ key: 'recheck', options: [{ key: 'fixed', label: 'fixed since' }] }] },
+  ];
+  const d = docket(ms);
+  d.desks = [{ key: 'release.core', building: 'release', status: 'live', rows: [{ id: 'release.core:41', desk: 'release.core', building: 'release', name: 'Core 1.21.20', fact: 'not checked yet', facts: [], over: 'core_update', ref: { type: 'core_pin', id: '41' }, acts: [{ key: 'check', options: [{ key: '1.21.20', label: '1.21.20' }] }] }] }];
+  const idea = item({ id: '43', subject_type: 'full_idea', subject: { title: 'Ask before a big change', author_id: '4', field_values: { purpose: 'Ask first.', success: 'No surprises.' } }, votes: [] });
+  return { d, r: room([item(), idea]) };
+};
+
+test('every docket source kind opens a card with the desk row\'s acts when the viewer may act, and links nowhere', () => {
+  const expected = [...read('../../government/docket.js').split('const EXPECTED_SOURCES')[1].split(']);')[0].matchAll(/source: '([a-z_]+)'/g)].map((x) => x[1]);
+  const { d, r } = SOURCE_FIXTURES();
+  assert.deepEqual([...new Set(d.matters.map((m) => m.source))].sort(), expected.slice().sort(), 'a fixture for every source the docket names');
+  const { document } = fakeDom();
+  const matched = [];
+  for (const m of d.matters) {
+    const cv = D.cardFor(m.id, d, { room: r, now: NOW });
+    assert.ok(cv && cv.row && cv.row.actions.length, `${m.id}: the card acts`);
+    assert.equal(cv.readOnly, false, m.id);
+    // one action model: the card's acts ARE the desk row's for the same item
+    const row = [0, 1, 2, 3, 4, 5, 6, 7].reduce((all, f) => all.concat(D.rowsFor(m.building, f, d, { room: r, now: NOW })), [])
+      .find((x) => x.matter === m.id || (x.desk && m.source === 'core_update' && x.over === 'core_update'));
+    if (row) { matched.push(m.id); assert.deepEqual(cv.row.actions.map((a) => [a.key, a.label]), row.actions.map((a) => [a.key, a.label]), `${m.id}: the same acts as its desk row`); }
+    const host = document.createElement('div');
+    C.render(document, host, cv, { act() {}, openForm() {}, ask() {}, more() {}, pick() {} }, { more: true });
+    const links = walk(host, (n) => n.tagName === 'a' || (n.attrs && 'href' in n.attrs));
+    assert.deepEqual(links.map((n) => n.attrs.href), [], `${m.id}: no link out`);
+    assert.ok(walk(host, (n) => n.attrs && n.attrs['data-act'] === 'more').length === 1, `${m.id}: a more toggle`);
+  }
+  assert.deepEqual(matched.sort(), d.matters.map((m) => m.id).sort(), 'the comparison ran for every kind');
+  // the core keeps check-then-take: its card is the Release desk's core row
+  const core = D.cardFor('core_update:1.21.20', d, { now: NOW });
+  assert.deepEqual(core.row.actions.map((a) => a.key), ['check']);
+  assert.deepEqual(C.request(core.row.card, 'check', { option: '1.21.20' }), { method: 'POST', url: '/api/bongos/provisioning/instances/41/core-upgrade', body: { to: '1.21.20', dry_run: true } });
+  // a module version is checked again through the reassess route, with a one-tap reason
+  const rc = D.cardFor('module_rechecks:7', d, { now: NOW });
+  assert.deepEqual(C.request(rc.row.card, 'recheck', { option: 'fixed', label: 'fixed since' }), { method: 'POST', url: '/api/bongos/store/modules/image-tools/versions/1.2.0/reassess', body: { reason: 'Asked on the street: fixed since.' } });
+  // the review queue's pin opens its first piece of work, with that work's acts
+  const q = D.cardFor('queue', d, { room: r, now: NOW });
+  assert.equal(q.key, 'criteria_uat:3');
+  assert.deepEqual(q.row.actions.map((a) => a.key), ['signoff', 'force']);
+  // the page carries no "open it where it lives" link
+  assert.doesNotMatch(read('street.html'), /streetCardOpen|where it lives/);
+  assert.doesNotMatch(read('street.js'), /streetCardOpen/);
+});
+
+test('a viewer who may not act gets the card without acts and still no link out', () => {
+  const { d, r } = SOURCE_FIXTURES();
+  d.matters = d.matters.map((m) => { const x = { ...m, state: 'moving' }; delete x.acts; return x; });
+  d.desks = []; // a desk row is only handed to a viewer who may act on it
+  const { document } = fakeDom();
+  for (const m of d.matters.filter((x) => x.source !== 'board')) {
+    const cv = D.cardFor(m.id, d, { room: r, now: NOW });
+    assert.equal(cv.row, null, `${m.id}: nothing to act on`);
+    const host = document.createElement('div');
+    C.render(document, host, cv, { act() {}, openForm() {}, ask() {}, more() {}, pick() {} }, { more: true });
+    assert.deepEqual(walk(host, (n) => n.attrs && 'href' in n.attrs).map((n) => n.attrs.href), [], m.id);
+  }
+});
+
+test('more expands the same card in place: the full text, who and when, and the record; less folds it', async () => {
+  const { d } = SOURCE_FIXTURES();
+  d.matters = d.matters.filter((m) => m.source === 'blockers');
+  const p = await bootPage({ feeds: { ...BASE(d) } });
+  p.byId.get('streetPins').children[0].fire('click');
+  await settle(); await settle();
+  const body = () => p.byId.get('streetCardBody');
+  const toggle = () => byAct(body(), 'more');
+  assert.equal(toggle().attrs['aria-expanded'], 'false');
+  assert.equal(walk(body(), (n) => n.className === 'mcard-more').length, 0, 'compact first');
+  // compact: one fact and at most two buttons (the line rule)
+  assert.equal(walk(body(), (n) => n.className === 'street-card__result').length, 1);
+  assert.ok(walk(body(), (n) => /^mcard-btn /.test(n.className)).length <= 2);
+  toggle().fire('click');
+  assert.equal(toggle().attrs['aria-expanded'], 'true');
+  assert.equal(toggle().attrs['aria-controls'], 'mcardMore');
+  assert.equal(p.byId.get('streetCard').attrs['data-more'], 'open');
+  const more = walk(body(), (n) => n.className === 'mcard-more')[0];
+  assert.equal(more.attrs.id, 'mcardMore');
+  assert.deepEqual(walk(more, (n) => n.className === 'mcard-more__text').map((n) => n.textContent), ['Option A: Render\nOption B: Fly']);
+  assert.equal(walk(more, (n) => n.className === 'mcard-more__meta')[0].textContent, 'opened 2026-09-30');
+  assert.deepEqual(walk(more, (n) => n.tagName === 'li').map((n) => n.textContent), ['how it is decided: decides alone'], 'the where line is the card head already');
+  assert.equal(p.calls.filter((c) => c.method !== 'GET').length, 0, 'opening more sends nothing');
+  assert.equal(p.window.location.hash, '', 'and goes nowhere');
+  // the blocker's options stand open, as on the desk: deciding it is picking one
+  byAct(body(), 'chip-go ahead');
+  assert.ok(byAct(body(), 'chip-go ahead'), 'its options stand open');
+  toggle().fire('click');
+  assert.equal(walk(body(), (n) => n.className === 'mcard-more').length, 0, 'less folds it');
+});
+
+test('the docket hands a matter its detail only as text, bounded, and only when there is some', () => {
+  const src = read('../../government/docket.js');
+  assert.match(src, /\.\.\.detailField\(raw\.detail\)/);
+  assert.match(src, /const MAX_DETAIL = 4000;/);
+  for (const [f, re] of [['../../ideas/governor-docket.js', /detail: b\.body_md/], ['../../lifecycle/governor-docket.js', /detail: r\.rationale/], ['../../lifecycle/governor-docket.js', /detail: r\.description/], ['../../security/routes/reports.js', /detail: \[r\.target/], ['../../onboarding/routes/access-requests.js', /detail: r\.note/]]) {
+    assert.match(read(f), re, f);
+  }
+});
+
 // ── the Board Room names the new subjects ───────────────────────────────────
 
 test('the Board Room labels a building\'s matter as that building\'s matter, and a who-decides change as its own amendment', () => {

package/tests/hall_street.mjs

@@ -505,7 +505,7 @@ test('a pin opens its short card, Escape closes it and focus goes back to the pi
   const card = p.byId.get('streetCard');
   assert.equal(card.hidden, false);
   assert.equal(p.byId.get('streetCardTitle').textContent, '<img src=x onerror=alert(1)>', 'docket text lands as text');
-  assert.equal(p.byId.get('streetCardOpen').attrs.href, '/builders/board-room');
+  assert.equal(p.byId.get('streetCardOpen').attrs.href, undefined, 'the card links nowhere: it acts in place (task 1004566)');
   assert.equal(p.focused.el, p.byId.get('streetCardClose'));
   assert.equal(p.byId.get('streetPins').children[0].attrs['aria-expanded'], 'true');
   const e = { key: 'Escape', prevented: false, preventDefault() { this.prevented = true; } };

package/tests/hall_street_inside.mjs

@@ -218,7 +218,7 @@ test('a source that is off, coming, not yours or unreadable never shows a number
   const none = I.civicInfo('release', { docket: null, now: NOW });
   assert.ok(none.floors.every((f) => f.count === '' && f.status !== 'ok' && f.status !== 'pending'), 'no docket: no numbers anywhere');
   assert.equal(none.onFile, 'the docket could not be read just now');
-  assert.deepEqual(none.table, []);
+  assert.deepEqual(none.record, [], 'no docket: nothing filed');
 });
 
 test('a floor bound to a reading shows its figure and line when live; Planning counts the open goals', () => {
@@ -237,12 +237,12 @@ test('a floor bound to a reading shows its figure and line when live; Planning c
   assert.ok(m.texts.some((t) => t.v === '5' && t.s === 20), 'only open goals are counted on the wall');
 });
 
-test('on the table: the building\'s matters, needs first; each row names the matter it opens', () => {
-  const ms = [matter({ id: 'board:1', source: 'board', building: 'charter', state: 'moving', title: 'B', deadline: '2026-10-04T09:00:00.000Z' }), matter({ id: 'board:2', source: 'board', building: 'charter', state: 'needs', title: 'A', deadline: '2026-10-02T20:00:00.000Z' }), matter({ id: 'blockers:3' })];
+test('no separate list of matters: the floor desks carry every matter, so the model keeps no table (task 1004565)', () => {
+  const ms = [matter({ id: 'board:1', source: 'board', building: 'charter', state: 'moving', title: 'B' }), matter({ id: 'board:2', source: 'board', building: 'charter', state: 'needs', title: 'A' })];
   const m = I.buildingModel({ key: 'charter', docket: docket(ms), mode: 'light', now: NOW });
-  assert.deepEqual(m.table.map((r) => [r.matter, r.label, r.status, r.state]), [['board:2', 'A', 'needs you · today', 'needs'], ['board:1', 'B', 'moving · sun', 'moving']]);
-  assert.equal(m.table[0].color, S.theme('light').accentText);
-  assert.ok(m.hasTable);
+  assert.ok(!('table' in m) && !('hasTable' in m), 'no table fields on the model');
+  assert.doesNotMatch(m.label, /on the table/, 'the building\'s label no longer counts a table');
+  assert.match(m.label, /floors in use\.$/);
 });
 
 test('the record files the building\'s matters by the month each was opened, newest drawer first', () => {
@@ -524,7 +524,8 @@ const FEEDS = (ms, extra = {}) => ({
 
 test('the markup carries the interior: one persistent lift, two flip blocks, the panel and the back link', () => {
   const html = read('street.html').replace(/<!--[\s\S]*?-->/g, '');
-  for (const id of ['streetInside', 'insideBack', 'insideSvg', 'insideFloors', 'insideLift', 'insideAnnex', 'insidePanel', 'insideName', 'insideAmend', 'insideAmendNote', 'insideFill', 'insideTable', 'insideOpenA', 'insideOpenB', 'insideDrawers', 'insideDrawerItems', 'insideDName', 'insideLegend', 'insideItems']) assert.match(html, new RegExp(`id="${id}"`), id);
+  for (const id of ['streetInside', 'insideBack', 'insideSvg', 'insideFloors', 'insideLift', 'insideAnnex', 'insidePanel', 'insideName', 'insideAmend', 'insideAmendNote', 'insideFill', 'insideOpenA', 'insideOpenB', 'insideDrawers', 'insideDrawerItems', 'insideDName', 'insideLegend', 'insideItems']) assert.match(html, new RegExp(`id="${id}"`), id);
+  assert.doesNotMatch(html, /insideTable|on the table here/i, 'the "on the table here" list is gone (task 1004565)');
   assert.equal((html.match(/<h1\b/g) || []).length, 1, 'the street keeps its one h1; the interior names are h2');
   assert.match(html, /<section class="inside" id="streetInside"[^>]*hidden>/, 'hidden until an address names a building or a district');
   assert.match(html, /<button type="button" class="inside-textbtn" id="insideAmend"/);
@@ -539,8 +540,7 @@ test('a building address draws the interior in place of the street, from the doc
   assert.equal(p.byId.get('insideFloors').children.length, 7, 'a button per floor in use');
   assert.equal(p.byId.get('insideFloors').children[4].attrs['aria-pressed'], 'true', 'the floor being decided is chosen');
   assert.equal(p.byId.get('insideLift').style.transform, 'translateY(-208px)');
-  assert.equal(p.byId.get('insideTable').children.length, 1);
-  assert.equal(p.byId.get('insideTable').children[0].className, 'inside-row inside-row--needs');
+  assert.equal(p.byId.get('insideTable'), undefined, 'no separate list of matters');
   assert.equal(p.byId.get('insideSeats').children[0].className, 'inside-seat inside-seat--open');
   assert.equal(p.focused.el, null, 'a page opened at the address keeps the browser\'s own start');
   p.location.hash = '#building=rules';
@@ -575,15 +575,17 @@ test('picking a floor moves the SAME lift node and re-enters the chosen block; d
   assert.match(p.byId.get('insideAmendNote').textContent, /could not be read/);
 });
 
-test('a table row opens the short card; Escape gives focus back to the row; back to the street returns to the door', async () => {
+test('a matter is a desk row: its name opens it in place; back to the street returns to the door', async () => {
   const ms = [matter({ id: 'board:1', source: 'board', building: 'charter', state: 'needs', title: '<b>x</b>' })];
   const p = await bootPage({ hash: '#building=charter', feeds: FEEDS(ms) });
-  p.byId.get('insideTable').children[0].fire('click');
-  assert.equal(p.byId.get('streetCard').hidden, false);
-  assert.equal(p.byId.get('streetCardTitle').textContent, '<b>x</b>', 'docket text lands as text');
-  p.fireWin('keydown', { key: 'Escape', preventDefault() {} });
-  assert.equal(p.byId.get('streetCard').hidden, true);
-  assert.equal(p.focused.el.attrs['data-matter'], 'board:1', 'focus goes back to the row');
+  const desk = () => (p.byId.get('insideOpenA').hidden ? p.byId.get('insideOpenB') : p.byId.get('insideOpenA'));
+  const find = (el, pred) => { if (pred(el)) return el; for (const c of el.children) { const hit = find(c, pred); if (hit) return hit; } return null; };
+  const nameOf = () => find(desk(), (el) => el.attrs && el.attrs['data-matter'] === 'board:1');
+  assert.ok(nameOf(), 'the desk carries the matter as a row');
+  assert.equal(nameOf().attrs['aria-expanded'], 'false');
+  nameOf().fire('click');
+  assert.equal(nameOf().attrs['aria-expanded'], 'true', 'the row opens in place');
+  assert.equal(p.byId.get('streetCard').hidden, true, 'no card is needed inside: the desk acts');
   p.byId.get('insideBack').fire('click');
   assert.deepEqual(p.history, ['/builders/street']);
   assert.equal(p.byId.get('streetInside').hidden, true);