@bongos/core 1.19.794 → 1.19.796

package/scripts/gds/ship-honesty.js

@@ -195,9 +195,63 @@ function regradeNotesRefusal(taskId) {
   ];
 }
 
+// THE FOURTH WAY TO LOSE THE BUILDER'S PROSE — and the only one where what
+// survives is worse than nothing, because it is a sentence that was true once.
+//
+// regradeMain falls back to the stored value_summary when --summary is omitted
+// (`summaryArg || task.value_summary`), and persistRegradeSummary deliberately
+// writes nothing on an omission. Both postures are right alone: a re-grade with
+// no summary must not blank the row, and an empty broadcast would be worse than
+// a stale one. Together they mean the DEFAULT re-grade re-publishes the first
+// attempt's sentence with nothing saying so.
+//
+// That is the task-1002343 incident exactly. Shipped 2026-09-04 asserting "No
+// project was created and nothing on the live system was left changed"; parked
+// at completed on a failing grade; redone 2026-09-07, when a project WAS created
+// (instance 40, r24-proof). The re-grade omitted --summary, so the ledger and the
+// #ship-news post both announced the opposite of what landed. Nobody ignored a
+// correction — there was no prompt to make one.
+//
+// So this is a NOTICE, not a refusal and not a behaviour change. The fallback is
+// correct and stays; task 1003817 already built the correction path (--summary on
+// a re-grade now reaches the row, the hall, /status and the broadcast). What was
+// missing is the moment that tells the builder that path exists, while the run
+// can still be corrected. Printed BEFORE the grade spend for the reason the
+// --notes refusal is: a warning that first costs a 4-worker panel run is barely
+// a warning at all.
+//
+// Returns [] when the row holds no stored summary — there is no stale text to
+// warn about then, and an empty summary is the merge leg's problem, not this
+// one. Pure, so the WORDING is testable: a notice that fails to name the fix is
+// noise with a warning sign on it.
+function staleSummaryNotice(taskId, storedSummary) {
+  // Control characters are stripped BEFORE the whitespace collapse, which only
+  // matches \s and would leave an ESC through. The stored summary is builder prose
+  // that has already been server-side stored and is already bound for Discord and
+  // the hall, so this crosses no new trust boundary — but this is the one place it
+  // reaches a TERMINAL, where an escape sequence could repaint the notice around it.
+  const stored = String(storedSummary || '')
+    .replace(/[\u0000-\u001f\u007f-\u009f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  if (!stored) return [];
+  const shown = stored.length > 140 ? `${stored.slice(0, 139)}…` : stored;
+  return [
+    '⚠ No --summary given — this re-grade reuses the summary stored at the FIRST ship:',
+    `      "${shown}"`,
+    '  That sentence describes the attempt that FAILED its grade. A re-grade usually means the',
+    '  work changed since, and this text is what the panel reads, what the merge commit and PR',
+    '  say, and what goes to Discord #ship-news as the durable record of this ship.',
+    '',
+    '  If it still describes what landed, ignore this. If not, correct it in this same run:',
+    `    node scripts/gds/ship.js ${taskId} --regrade --summary-file summary.txt`,
+    '  (the -file form is the safe one for prose — a shell eats backticks in an inline value)',
+  ];
+}
+
 module.exports = {
   resolveProse, markShipProgress, fatalRecoveryLines, smokeGateMessages,
-  proseFlagPresent, regradeNotesRefusal,
+  proseFlagPresent, regradeNotesRefusal, staleSummaryNotice,
   _resetForTest: () => { shipProgress = { stage: 'preflight', taskId: null }; },
   _peekForTest: () => shipProgress,
 };

package/src/module-api.js

@@ -71,7 +71,7 @@ const { responsibilityFor, ROLE_RESPONSIBILITIES } = require('./role-responsibil
 // there. scripts/gds/bump-version.js still rewrites the literal below; it appends
 // the entry to that file. Look for a version's history there, not here.
 // ---------------------------------------------------------------------------
-const CORE_VERSION = '1.19.794'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
+const CORE_VERSION = '1.19.796'; // CI auto-patch carrier (ADR 0161); changelog: docs/module-api-changelog.md
 
 // A namespaced logger so a module's log lines are attributable + consistent.
 // Usage: const log = api.logger('dev-box'); log.info('mounted');

package/tests/claude_materialize.mjs

@@ -26,6 +26,9 @@ const require = createRequire(import.meta.url);
 const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..');
 const m = require('../scripts/gds/claude-materialize.js');
 const claim = require('../scripts/gds/claim.js');
+// The live verb table, so a starter allow-rule naming a verb that does not exist
+// fails here rather than shipping as an inert permission (task 1003962).
+const { VERBS: cliVerbs } = require('../bin/bongos.js');
 
 let passed = 0;
 let failed = 0;
@@ -704,5 +707,73 @@ t('materializeModeSkills lands the real module-owned skills, self-ignored, and i
   rmSync(core, { recursive: true, force: true });
 });
 
+// ---------------------------------------------------------------------------
+// task 1003962 — the starter settings.json for a package-only install.
+//
+// THE GAP: `.claude/skills/` ships in the core package but `.claude/settings.json`
+// is excluded as topology, so an instance received the methodology and none of the
+// permissions that let it run — every blessed command met the auto-mode classifier.
+// ---------------------------------------------------------------------------
+
+t('the starter carries PERMISSIONS ONLY — no hooks, no env (those are topology)', () => {
+  const parsed = JSON.parse(m.renderStarterSettings());
+  assert.ok(Array.isArray(parsed.permissions.allow), 'must carry permissions.allow');
+  assert.ok(!('hooks' in parsed), 'hooks are gate machinery and must NOT ship to an instance');
+  assert.ok(!('env' in parsed), 'env is topology and must NOT ship to an instance');
+  assert.ok(parsed._doc.includes('grants no authority'),
+    'the file must say out loud that it grants no authority (ADR 0016)');
+});
+
+t('every allow-rule names a verb the CLI actually registers', () => {
+  // The drift this catches: a rule naming a verb that was renamed or never existed
+  // is silently inert — it looks like a permission and grants nothing, so the
+  // builder still meets the classifier and nobody can see why.
+  for (const rule of m.STARTER_ALLOW) {
+    const inner = rule.replace(/^Bash\(/, '').replace(/:\*\)$/, '');
+    const verb = inner.split(' ')[1];
+    assert.ok(cliVerbs[verb], `allow-rule "${rule}" names "${verb}", which is not a registered bongos verb`);
+  }
+});
+
+t('the escape hatch is NOT blanket-allowed', () => {
+  // `bongos exec` runs any script inside the core by path. Allow-listing it bare
+  // would be a blanket grant wearing a narrow rule's clothes.
+  assert.ok(!m.STARTER_ALLOW.includes('Bash(bongos exec:*)'),
+    'bongos exec must never be allowed bare');
+  const execRules = m.STARTER_ALLOW.filter((r) => r.includes('bongos exec'));
+  for (const r of execRules) {
+    assert.match(r, /bongos exec scripts\/gds\/[a-z-]+\.js/,
+      `an exec rule must name its script in full, got: ${r}`);
+  }
+});
+
+t('a package-only install (no settings.json at the core root) GETS the starter', () => {
+  const core = mkdtempSync(join(tmpdir(), 'w3-starter-core-'));
+  const inst = mkdtempSync(join(tmpdir(), 'w3-starter-inst-'));
+  mkdirSync(join(core, '.claude', 'skills'), { recursive: true });   // skills ship; settings.json does not
+  const res = m.materializeClaude({ coreRoot: core, instanceDir: inst, dryRun: false });
+  assert.equal(res.settings, true, 'materialize should report it wrote settings');
+  const written = join(inst, '.claude', 'settings.json');
+  assert.ok(existsSync(written), 'instance must receive a starter settings.json');
+  const parsed = JSON.parse(readFileSync(written, 'utf8'));
+  assert.deepEqual(parsed.permissions.allow, m.STARTER_ALLOW);
+  rmSync(core, { recursive: true, force: true });
+  rmSync(inst, { recursive: true, force: true });
+});
+
+t("an instance's OWN settings.json is never clobbered", () => {
+  const core = mkdtempSync(join(tmpdir(), 'w3-keep-core-'));
+  const inst = mkdtempSync(join(tmpdir(), 'w3-keep-inst-'));
+  mkdirSync(join(core, '.claude', 'skills'), { recursive: true });
+  mkdirSync(join(inst, '.claude'), { recursive: true });
+  const mine = JSON.stringify({ permissions: { allow: ['Bash(echo hello:*)'] } }, null, 2);
+  writeFileSync(join(inst, '.claude', 'settings.json'), mine);
+  m.materializeClaude({ coreRoot: core, instanceDir: inst, dryRun: false });
+  assert.equal(readFileSync(join(inst, '.claude', 'settings.json'), 'utf8'), mine,
+    'an upgrade must never overwrite permissions the instance has grown');
+  rmSync(core, { recursive: true, force: true });
+  rmSync(inst, { recursive: true, force: true });
+});
+
 console.log(`\nclaude_materialize: ${passed} passed, ${failed} failed`);
 process.exit(failed ? 1 : 0);

package/tests/hall_collab_world.mjs

@@ -123,10 +123,121 @@ test('the first line is decided: the ask\'s first sentence is the title, the res
   assert.equal(L.titleOf('docs/x.md is stale and y.js too').title, 'docs/x.md is stale and y.js too', 'a dot inside a path is not a sentence break');
   const t = L.titleOf('  padded.  and trailing   ');
   assert.equal(`${t.title} ${t.rest}`, 'padded. and trailing', 'nothing is clipped');
+  // titleOf is still the sentence splitter; what the page DOES with the tail
+  // changed in task 1003960 and is asserted in the next test.
+  assert.equal(typeof L.summaryOf, 'function', 'the page face is built on summaryOf now');
+});
+
+test('a card face carries two sentences at most, and the whole ask waits behind a door', () => {
+  const L = lib();
+
+  // The common case: two short sentences fit, so there is nothing behind a door
+  // and the page must not offer one. A door onto nothing is a lie about there
+  // being more to read.
+  const fits = L.summaryOf('The pin will not move past 782. Can you look before I ship?');
+  assert.deepEqual(fits, {
+    title: 'The pin will not move past 782.',
+    lead: 'Can you look before I ship?',
+    more: '',
+  });
+  assert.equal(L.summaryOf('Can you look at the pin?').more, '', 'one sentence needs no door');
+
+  // The case the owner reported: a real ask, written the way the ask-for-help
+  // skill asks for it, is five parts long. Two reach the face; the rest does not.
+  const long = [
+    'The deploy pin is stuck at 1.19.782.',
+    'I need a Metic because the release gate is above my rank.',
+    'Run the release pipeline, then check /version reports 789.',
+    'Verify by loading the hall and reading the footer.',
+    'I already ruled out a stale CDN cache and a bad merge.',
+  ].join(' ');
+  const s = L.summaryOf(long);
+  assert.equal(s.title, 'The deploy pin is stuck at 1.19.782.');
+  assert.equal(s.lead, 'I need a Metic because the release gate is above my rank.');
+  assert.ok(s.more, 'the rest goes behind the door');
+  assert.equal(s.more, long, 'and what is behind the door is the WHOLE ask, so a copy is not a fragment');
+  assert.ok(!s.title.includes('Verify by loading'), 'nothing past the second sentence is on the face');
+
+  // A sentence count alone is not enough: one 4000-character paragraph with no
+  // full stop is ONE sentence, and counting sentences would put all of it on the
+  // face. The line budget catches it, and the ask still goes behind the door whole.
+  const blob = 'x '.repeat(900).trim();
+  const b = L.summaryOf(blob);
+  assert.ok(b.title.length < 160, 'a blob is cut to a lead-in');
+  assert.ok(b.title.endsWith('\u2026'), 'and the cut is marked');
+  assert.equal(b.lead, '');
+  assert.equal(b.more, blob, 'the words are not lost, only moved');
+
+  // The cut never lands mid-word.
+  const words = 'antidisestablishmentarianism '.repeat(40).trim();
+  const w = L.summaryOf(words);
+  assert.ok(/(^|\s)antidisestablishmentarianism\u2026$/.test(w.title) || w.title.endsWith('antidisestablishmentarianism\u2026'),
+    'clipWords cuts at a space, never inside a word');
+
+  assert.deepEqual(L.summaryOf(''), { title: '', lead: '', more: '' }, 'an empty ask renders nothing, not a door');
+});
+
+test('the door tracks what is UNREAD, not the sentence count', () => {
+  const L = lib();
+
+  // Raised by the grader on task 1003960 as a violation of "one or two sentences
+  // shows no expander". It is neither a violation nor a bug, and the rule it
+  // appeals to was the imprecise one: an ask earns a door when part of it is not
+  // on the face, and sentence two can be longer than the face on its own.
+  const twoButLong = 'The pin will not move. ' + 'I have tried '.repeat(30).trim() + '.';
+  const r = L.summaryOf(twoButLong);
+  assert.equal(r.title, 'The pin will not move.');
+  assert.ok(r.lead.endsWith('\u2026'), 'the second sentence did not fit, so it was cut');
+  assert.ok(r.lead.length < twoButLong.length, 'and part of it is therefore unread');
+  assert.equal(r.more, twoButLong,
+    'so it gets a door — hiding one here would abbreviate an ask with no way to read the rest');
+
+  // The mirror case, so the pair states the rule between them: two sentences
+  // that BOTH fit are fully on the face, so there is nothing to open.
+  assert.equal(L.summaryOf('The pin will not move. Can you look?').more, '',
+    'nothing unread means no door');
+});
+
+test('the door and the copy control are on the row, and the copy control is reachable while it is shut', () => {
   const js = read('collab.js');
-  assert.match(js, /L\.titleOf\(req\.what_is_stuck\)/);
-  assert.match(js, /class="ov-row__title">\$\{escapeHtml\(t\.title\)\}/);
-  assert.match(js, /class="ov-row__sub">\$\{escapeHtml\(t\.rest\)\}/);
+  assert.match(js, /L\.summaryOf\(req\.what_is_stuck\)/, 'the face is built from summaryOf');
+  assert.match(js, /class="ov-row__title">\$\{escapeHtml\(s\.title\)\}/);
+  assert.match(js, /class="ov-row__sub">\$\{escapeHtml\(s\.lead\)\}/);
+  assert.match(js, /if \(!s\.more\) return html;/, 'no door when the ask already fits');
+
+  // The door announces its state and names what it controls, so it works from
+  // the keyboard and reads correctly to a screen reader.
+  assert.match(js, /data-ask-toggle aria-expanded="false" aria-controls="\$\{fid\}"/);
+  assert.match(js, /aria-expanded', open \? 'false' : 'true'/, 'and the state flips when it opens');
+  assert.match(js, /Read the full ask/);
+  assert.match(js, /Hide the full ask/);
+
+  // The copy control sits in the SAME block as the door, which is rendered
+  // whether or not the ask is open — the owner asked for it "in the closed
+  // version next to the link", and a control only reachable after expanding
+  // would make a reader open four thousand characters to take them away.
+  const bar = js.slice(js.indexOf('<div class="cb-ask">'), js.indexOf('</div>', js.indexOf('<div class="cb-ask">')));
+  assert.match(bar, /data-ask-toggle/, 'the door is in the bar');
+  assert.match(bar, /Copy for Session Start/, 'and so is the copy control, in the owner\'s words');
+  assert.ok(!/hidden/.test(bar), 'the bar itself is never hidden');
+  assert.match(js, /<p class="cb-ask__full" id="\$\{fid\}" hidden>/, 'only the ask is hidden');
+
+  // What lands on the clipboard is the ask verbatim, line breaks and all.
+  assert.match(js, /full\.textContent/, 'copied from textContent, so the line breaks survive');
+  assert.ok(!/full\.innerText/.test(js), 'innerText on a hidden element is not guaranteed to keep them');
+  assert.match(js, /document\.execCommand\('copy'\)/, 'with the hall\'s fallback for an insecure context');
+
+  // One request can appear in three blocks at once, so the id is block-scoped.
+  assert.match(js, /function askId\(key, id\)/);
+  assert.match(js, /cb-ask-\$\{key\}-/);
+  assert.match(js, /rowFn\(r, nowMs, false, key\)/, 'and paintBlock hands the key down');
+
+  const css = read('collab.css');
+  for (const cls of ['.cb-ask ', '.cb-ask__door', '.cb-ask__copy', '.cb-ask__full']) {
+    assert.ok(css.includes(cls), `collab.css dresses ${cls.trim()}`);
+  }
+  assert.match(css, /\.cb-ask__full[\s\S]*?white-space: pre-wrap/, 'the opened ask keeps its own paragraphs');
+  assert.ok(!/\.cb-ask__copy[^}]*text-transform/.test(css), 'the copy control keeps the capitals the owner wrote');
 });
 
 test('"asked of you" reads in runs — by name first, then each craft', () => {

package/tests/ship_cannot_lie.mjs

@@ -17,6 +17,10 @@
 //
 // (3) --regrade must not swallow --notes. Same shape as (1): prose handed to
 //     ship.js that reaches nothing, silently (task 1003702).
+//
+// (4) --regrade must not silently REUSE the failed attempt's summary. The same
+//     silence as (3) from the other side: prose the builder never handed over,
+//     published as though they had (task 1003693).
 import { strict as assert } from 'node:assert';
 import { test } from 'node:test';
 import { createRequire } from 'node:module';
@@ -26,7 +30,7 @@ const require = createRequire(import.meta.url);
 const { argText } = require('../scripts/gds/cli-lib.js');
 const {
   fatalRecoveryLines, markShipProgress, _peekForTest,
-  proseFlagPresent, regradeNotesRefusal,
+  proseFlagPresent, regradeNotesRefusal, staleSummaryNotice,
 } = require('../scripts/gds/ship-honesty.js');
 
 // Injected IO so no case touches the filesystem.
@@ -297,3 +301,73 @@ test('a re-grade that omits --summary leaves the stored value_summary alone', ()
   // And a failed write never aborts the re-grade — no process.exit, no throw.
   assert.ok(!/process\.exit/.test(code), 'a summary that will not persist must not kill the re-grade');
 });
+
+// ── (4) an omitted --summary on a re-grade says so (task 1003693) ────────────
+//
+// The sibling of the ACCEPTANCE 2 test above. That one pins that an omitted
+// --summary does not OVERWRITE the row; this one pins that it does not pass in
+// SILENCE. Both postures were already right and the gap was between them: the
+// default re-grade re-publishes the failed attempt's sentence to #ship-news
+// with nothing saying so (task 1002343, 2026-09-07).
+
+test('the stale-summary notice quotes the sentence and names the fix', () => {
+  const lines = staleSummaryNotice(1002343, 'No project was created and nothing on the live system was left changed.');
+  const text = lines.join('\n');
+  // The builder cannot judge a summary they are not shown — the whole point is
+  // that the stored sentence is plausible until you read it next to the work.
+  assert.match(text, /No project was created and nothing on the live system was left changed\./,
+    'quotes the stored sentence verbatim');
+  // A notice that names no fix is noise with a warning sign on it.
+  assert.match(text, /--regrade --summary-file/, 'names the correcting flag');
+  assert.match(text, /ship\.js 1002343 --regrade/, 'as a runnable command with the real task id');
+  // WHY it matters: this text becomes the durable public record, not just a log line.
+  assert.match(text, /#ship-news/, 'says where the sentence ends up');
+  assert.match(text, /FAILED its grade/, 'says which attempt the stored sentence describes');
+});
+
+test('the notice stays silent when there is no stored summary to go stale', () => {
+  // No stored text means nothing can be re-published wrongly; an empty summary
+  // is the merge leg's problem. Warning here would train the builder to skip it.
+  for (const empty of ['', '   ', null, undefined]) {
+    assert.deepEqual(staleSummaryNotice(1, empty), [], `silent for ${JSON.stringify(empty)}`);
+  }
+});
+
+test('the quoted sentence is always one readable line', () => {
+  // value_summary allows up to LIMITS.VALUE_SUMMARY characters and may hold
+  // newlines. Either would break the quoted line out of the notice block and
+  // bury the runnable command that follows it.
+  const long = staleSummaryNotice(7, 'x'.repeat(400));
+  assert.ok(long[1].length < 160, 'a long summary is truncated');
+  assert.match(long[1], /…/, 'and says it was truncated');
+  const multi = staleSummaryNotice(9, 'line one\n\nline two\ttabbed');
+  assert.equal(multi[1].split('\n').length, 1, 'newlines collapse');
+  assert.match(multi[1], /"line one line two tabbed"/, 'into single spaces');
+
+  // This is the one place a stored summary reaches a TERMINAL. \s does not match
+  // ESC, so the collapse above would pass an escape sequence straight through and
+  // let it repaint the notice around itself.
+  const esc = staleSummaryNotice(11, 'safe\u001b[31mred\u0007 text');
+  assert.ok(!/[\u0000-\u001f\u007f-\u009f]/.test(esc.join(' ')),
+    'terminal control characters are stripped before display');
+  assert.match(esc[1], /"safe \[31mred text"/, 'and the readable text survives');
+});
+
+test('the notice is wired into the regrade path, before any grade spend', () => {
+  // The (1) lesson again: a helper nothing calls is not a fix. And the ORDER is
+  // load-bearing for the same reason the --notes refusal's is — a warning the
+  // builder reads only after a 4-worker panel has run cannot change that run.
+  const src = readFileSync(new URL('../scripts/gds/ship-flow.js', import.meta.url), 'utf8');
+  const regrade = src.slice(src.indexOf('async function regradeMain'));
+  const code = regrade.replace(/\/\/[^\n]*/g, ''); // comments describe, they do not print
+
+  const call = code.indexOf('staleSummaryNotice(taskId, task.value_summary)');
+  assert.ok(call !== -1, 'regradeMain emits the notice');
+  // Keyed on the RAW flag, like persistRegradeSummary — `summary` has already
+  // absorbed the fallback by this point, so testing it would never be falsy.
+  // Brace-form or one-liner, but it must branch on summaryArg and nothing else.
+  assert.match(code, /if \(!summaryArg\)\s*\{?\s*(\n\s*)?for \(const line of staleSummaryNotice/,
+    'it fires on the raw omitted flag, not the resolved fallback');
+  const preflight = code.indexOf('preflight(claimLike');
+  assert.ok(preflight !== -1 && call < preflight, 'and prints before the preflight and the panel');
+});

package/tests/skill_friction_kind.mjs

@@ -0,0 +1,163 @@
+// tests/skill_friction_kind.mjs
+//
+// 'skill-friction' as a real idea kind, and the one predicate that hides those
+// rows from a Xenos (task 1003105, goal 1000095, from idea 1000759).
+//
+// Two things are pinned here, and they fail in different directions.
+//
+// THE DRIFT TRIPWIRE. `VALID_KINDS` in JS and the CHECK constraint in SQL are
+// two lists that must say the same thing, and nothing made them. Widening one
+// and not the other is silent in both directions: a kind added only to JS gets
+// past validation and dies on INSERT with a constraint violation instead of a
+// clean BAD_KIND, and a kind added only to SQL is unreachable. That is the exact
+// shape of the bug this task fixed, so the fix ships with the tripwire.
+//
+// THE FOUR GATES. Skill-friction rows are hidden from Xenos-rank builders in
+// four separate read paths. They used to be four hand-copied conditions testing
+// a title prefix; now that the marker can ALSO be a kind, four copies would be
+// four chances for one to learn about the kind and the others not to — and a
+// gate that silently stops hiding is invisible until the wrong reader sees the
+// row. So there is one predicate, and these tests hold it to both markers, to
+// correct bind-parameter numbering, and to costing nothing for a viewer who may
+// see everything.
+//
+// Pure: no DB, no network.
+//
+// Run:  node tests/skill_friction_kind.mjs
+
+import { strict as assert } from 'node:assert';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const inbox = require('../modules/ideas/inbox.js');
+
+const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// The migration that currently defines the constraint. If a later migration
+// widens it again, point this at that file — forcing that edit is the job.
+const CONSTRAINT_MIGRATION = path.join(
+  ROOT, 'migrations', 'core_244_skill_friction_kind.sql'
+);
+
+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}`);
+  }
+}
+
+// ---- the kind exists at all ------------------------------------------------
+
+test('skill-friction is a valid kind, so the two skills that file one stop failing BAD_KIND', () => {
+  assert.ok(
+    inbox.VALID_KINDS.includes('skill-friction'),
+    "/planning-session and /priority-session both instruct kind='skill-friction'"
+  );
+  assert.equal(inbox.SKILL_FRICTION_KIND, 'skill-friction');
+});
+
+test('widening the enum did not drop anything that was already in it', () => {
+  for (const k of [
+    'feature', 'bug', 'infra', 'refactor', 'spike', 'learning-capture',
+    'cleanup', 'decision', 'blocker-resolution', 'unclassified', 'criterion-proposal',
+  ]) {
+    assert.ok(inbox.VALID_KINDS.includes(k), `${k} missing from VALID_KINDS`);
+  }
+});
+
+// ---- JS and SQL say the same thing -----------------------------------------
+
+test('the SQL CHECK constraint and VALID_KINDS list exactly the same kinds', () => {
+  const sql = fs.readFileSync(CONSTRAINT_MIGRATION, 'utf8');
+  const m = /CHECK\s*\(\s*kind\s+IN\s*\(([\s\S]*?)\)\s*\)/i.exec(sql);
+  assert.ok(m, 'the migration declares a CHECK (kind IN (...)) constraint');
+
+  const fromSql = [...m[1].matchAll(/'([^']+)'/g)].map((x) => x[1]);
+  assert.ok(fromSql.length > 0, 'the constraint lists at least one kind');
+
+  const a = [...fromSql].sort();
+  const b = [...inbox.VALID_KINDS].sort();
+  assert.deepEqual(
+    a, b,
+    `SQL and JS disagree — only in SQL: [${a.filter((k) => !b.includes(k))}], ` +
+    `only in JS: [${b.filter((k) => !a.includes(k))}]`
+  );
+});
+
+// ---- the visibility gate ---------------------------------------------------
+
+test('a viewer who may see everything costs no clause and no bind parameters', () => {
+  for (const rank of [null, undefined, 'metic', 'archon', 'Archon', 'something-new']) {
+    const params = [];
+    assert.equal(inbox.skillFrictionHiddenClause(rank, params), null, `rank=${rank}`);
+    assert.equal(params.length, 0, `rank=${rank} pushed no params`);
+  }
+});
+
+test('a Xenos is hidden from BOTH markers — the kind and the legacy title prefix', () => {
+  const params = [];
+  const clause = inbox.skillFrictionHiddenClause('xenos', params);
+  assert.ok(clause, 'a Xenos gets a clause');
+  assert.match(clause, /kind <> \$1/, 'the kind marker is tested');
+  assert.match(clause, /title NOT LIKE \$2/, 'the legacy prefix marker is tested too');
+  assert.deepEqual(params, [inbox.SKILL_FRICTION_KIND, `${inbox.SKILL_FRICTION_TAG}%`]);
+});
+
+test('the rank test is case-insensitive, so a capitalised Xenos is still hidden', () => {
+  const params = [];
+  assert.ok(inbox.skillFrictionHiddenClause('XENOS', params), 'XENOS is still a Xenos');
+  assert.equal(inbox.rankCanSeeSkillFriction('Xenos'), false);
+  assert.equal(inbox.rankCanSeeSkillFriction('metic'), true);
+  assert.equal(inbox.rankCanSeeSkillFriction(null), true);
+});
+
+test('bind parameters are numbered from where the caller already was, not from 1', () => {
+  const params = ['open', 42];
+  const clause = inbox.skillFrictionHiddenClause('xenos', params, 'i');
+  assert.match(clause, /i\.kind <> \$3/, 'continues the caller\'s numbering');
+  assert.match(clause, /i\.title NOT LIKE \$4/);
+  assert.equal(params.length, 4, 'and appended exactly two');
+});
+
+test('the table alias is applied to both columns or to neither', () => {
+  const withAlias = inbox.skillFrictionHiddenClause('xenos', [], 'i');
+  assert.match(withAlias, /i\.kind/);
+  assert.match(withAlias, /i\.title/);
+  const bare = inbox.skillFrictionHiddenClause('xenos', []);
+  assert.doesNotMatch(bare, /\bi\./, 'no alias means no alias on either column');
+  assert.match(bare, /\bkind <>/);
+  assert.match(bare, /\btitle NOT LIKE/);
+});
+
+test('the clause is parenthesised, so ANDing it into a WHERE cannot change the other terms', () => {
+  const clause = inbox.skillFrictionHiddenClause('xenos', []);
+  assert.ok(clause.startsWith('(') && clause.endsWith(')'), `not parenthesised: ${clause}`);
+  assert.match(clause, / AND /, 'both markers must hold for the row to be shown');
+});
+
+// ---- the legacy marker is not quietly retired ------------------------------
+
+test('the legacy title prefix is still exported and still the nightly routine\'s marker', () => {
+  assert.equal(inbox.SKILL_FRICTION_TAG, '[skill-friction]');
+  const routine = fs.readFileSync(
+    path.join(ROOT, '.claude', 'scheduled-tasks', 'skill-usage-review', 'SKILL.md'), 'utf8'
+  );
+  assert.ok(
+    routine.includes('[skill-friction]'),
+    'skill-usage-review still tags the prefix — the gate must keep recognising it'
+  );
+});
+
+console.log('');
+console.log(`skill-friction kind + visibility gate (task 1003105): ${passed} passed, ${failed} failed`);
+if (failed > 0) process.exit(1);