@bongos/core 1.19.818 → 1.19.820

package/tests/bug_attachment_audit.mjs

@@ -0,0 +1,122 @@
+// tests/bug_attachment_audit.mjs — the described-but-missing probe (task 1003918).
+//
+// WHY THIS FILE EXISTS. Five re-hosted #bugs screenshots — every one this instance
+// ever stored — disappeared in the 2026-07-05 droplet move, and nobody noticed for
+// two months. They cannot be re-fetched: the Discord CDN URL they were copied from
+// is signed and expires in about a day, so our copy IS the image. The probe is what
+// should have said so in July.
+//
+// A probe like this fails by finding nothing, and a clean bill of health looks
+// identical to working — which is exactly what happened while building it: the
+// first cut queried GET /tasks without naming a status, the route omits abandoned
+// rows by default, and every task describing these files is now abandoned or
+// shipped. It printed "0 linked, 0 missing". So the cases below lean on the ways
+// the extraction can go quietly empty.
+//
+// Run:  node tests/bug_attachment_audit.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { createRequire } from 'node:module';
+
+const require = createRequire(import.meta.url);
+const { describedAttachments, auditRows } = require('../scripts/gds/bug-attachment-audit.js');
+const { attachmentsDir } = require('../modules/discord/bug-attachments.js');
+const path = require('node:path');
+
+// The real link shape, taken verbatim from task 1003718's description.
+const REAL = '/api/gds/bug-attachments/bug-1523688670492627115-8bb16de1f5b4c20e.png';
+
+test('extracts the attachment name from a real embedded link', () => {
+  const got = describedAttachments(`![screenshot](https://cloudbongos.com${REAL})`);
+  assert.deepEqual(got, ['bug-1523688670492627115-8bb16de1f5b4c20e.png']);
+});
+
+test('the 19-digit Discord message id is not too long for the name pattern', () => {
+  // The id in every real filename here is 19 characters. A pattern sized for
+  // something shorter would match nothing and report a clean board.
+  assert.equal(describedAttachments(REAL).length, 1);
+});
+
+test('both /gds/ and /bongos/ spellings of the route are recognised', () => {
+  const a = describedAttachments('/api/gds/bug-attachments/bug-1-0123456789abcdef.png');
+  const b = describedAttachments('/api/bongos/bug-attachments/bug-1-0123456789abcdef.png');
+  assert.deepEqual(a, b, 'the route was renamed; a description can carry either');
+  assert.equal(a.length, 1);
+});
+
+test('the same file linked twice in one description is counted once', () => {
+  const text = `![a](${REAL}) and again ![a](${REAL})`;
+  assert.equal(describedAttachments(text).length, 1);
+});
+
+test('a description with no attachment yields nothing — and that is not an error', () => {
+  assert.deepEqual(describedAttachments('a bug about the hall sidebar'), []);
+  assert.deepEqual(describedAttachments(null), []);
+  assert.deepEqual(describedAttachments(undefined), []);
+});
+
+test('a malformed name is NOT extracted — the pattern is the traversal defence too', () => {
+  assert.deepEqual(describedAttachments('/api/gds/bug-attachments/../../etc/passwd'), []);
+  assert.deepEqual(describedAttachments('/api/gds/bug-attachments/bug-1-short.png'), []);
+  assert.deepEqual(describedAttachments('/api/gds/bug-attachments/bug-1-0123456789abcdef.exe'), []);
+});
+
+test('auditRows names the TASK for each missing file, not just the file', () => {
+  const rows = [
+    { id: '1003718', title: 'a re-filed bug', description: `![x](${REAL})` },
+    { id: '1003719', title: 'no images here', description: 'plain prose' },
+  ];
+  const r = auditRows(rows, () => false);
+  assert.equal(r.described.length, 1);
+  assert.equal(r.missing.length, 1);
+  assert.equal(r.missing[0].taskId, '1003718', '"a file is gone" is not actionable; "the image in task N is gone" is');
+  assert.equal(r.present, 0);
+});
+
+test('a present file is not reported missing', () => {
+  const rows = [{ id: '1', title: 't', description: `![x](${REAL})` }];
+  const r = auditRows(rows, () => true);
+  assert.deepEqual(r.missing, []);
+  assert.equal(r.present, 1);
+});
+
+test('the same file described by two tasks is reported for BOTH', () => {
+  // task 1002076 was re-filed as 1003718 and both descriptions carry the links;
+  // each renders a broken image, so each is worth naming.
+  const rows = [
+    { id: '1002076', title: 'original', description: `![x](${REAL})` },
+    { id: '1003718', title: 're-file', description: `![x](${REAL})` },
+  ];
+  const r = auditRows(rows, () => false);
+  assert.equal(r.missing.length, 2);
+});
+
+test('the store resolves against the INSTANCE root, not the core package (task 1003918)', () => {
+  // The old default was __dirname/../../var, which on a vendored core is
+  // node_modules/@bongos/core/var — wiped by every reinstall, and these files
+  // cannot be regenerated.
+  const prev = process.env.BUG_ATTACHMENTS_DIR;
+  delete process.env.BUG_ATTACHMENTS_DIR;
+  try {
+    const dir = attachmentsDir();
+    assert.ok(!dir.includes('node_modules'), `the store must not live inside an installed package: ${dir}`);
+    assert.equal(path.basename(dir), 'bug-attachments');
+    assert.equal(path.basename(path.dirname(dir)), 'var');
+  } finally {
+    if (prev === undefined) delete process.env.BUG_ATTACHMENTS_DIR;
+    else process.env.BUG_ATTACHMENTS_DIR = prev;
+  }
+});
+
+test('BUG_ATTACHMENTS_DIR still wins outright', () => {
+  const prev = process.env.BUG_ATTACHMENTS_DIR;
+  process.env.BUG_ATTACHMENTS_DIR = '/srv/persistent/bug-attachments';
+  try {
+    assert.equal(attachmentsDir(), '/srv/persistent/bug-attachments',
+      'on a box whose instance root is impermanent, the override is the answer');
+  } finally {
+    if (prev === undefined) delete process.env.BUG_ATTACHMENTS_DIR;
+    else process.env.BUG_ATTACHMENTS_DIR = prev;
+  }
+});

package/tests/cli_package.mjs

@@ -21,6 +21,22 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 
 const REPO_ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// HOME ALONE IS NOT ISOLATION ON WINDOWS (task 1003763).
+//
+// os.homedir() reads USERPROFILE on win32 and never consults HOME, so
+// `env: { ...process.env, HOME: home }` isolated nothing there: the installed CLI
+// saw the DEVELOPER'S REAL session file. That is precisely the false green the
+// comment below guards against — an unauthenticated-path assertion passing because
+// the machine happens to be signed in.
+//
+// HOMEDRIVE/HOMEPATH are os.homedir()'s second win32 source, so all four go. Named
+// rather than inlined twice: this is the third site in the repo to need it (after
+// tests/cli_sessions.mjs in task 1003760 and tests/cli_surface.mjs in task 1003941),
+// and every one of them got it half-right first.
+function homelessEnv(home, extra = {}) {
+  return { ...process.env, HOME: home, USERPROFILE: home, HOMEDRIVE: '', HOMEPATH: home, ...extra };
+}
 const BUILDER = path.join(REPO_ROOT, 'scripts', 'gds', 'build-cli-package.js');
 // Running npm from a test (task 1003529). On Windows `npm` is a .cmd shim: bare
 // 'npm' is ENOENT and 'npm.cmd' is EINVAL under Node 24's CVE-2024-27980 mitigation,
@@ -152,7 +168,7 @@ test('the packed tarball installs and every verb runs with no repo present', (t)
   // file on this machine cannot make a verb look healthier than it is.
   fs.writeFileSync(path.join(site, 'package.json'), JSON.stringify({ name: 'probe', private: true }));
   const installed = npm(['install', '--no-audit', '--no-fund', '--silent', path.join(site, tarball)], {
-    cwd: site, encoding: 'utf8', env: { ...process.env, HOME: home },
+    cwd: site, encoding: 'utf8', env: homelessEnv(home),
   });
   assert.equal(installed.status, 0, `npm install failed:\n${installed.stderr}`);
 
@@ -166,7 +182,7 @@ test('the packed tarball installs and every verb runs with no repo present', (t)
 
   const runVerb = (args) => spawnSync(process.execPath, [bongos, ...args], {
     cwd: site, encoding: 'utf8', input: '',
-    env: { ...process.env, HOME: home, CLOUDBONGOS_API_BASE: 'http://127.0.0.1:45999', NO_COLOR: '1' },
+    env: homelessEnv(home, { CLOUDBONGOS_API_BASE: 'http://127.0.0.1:45999', NO_COLOR: '1' }),
   });
 
   // help and version must work with nothing configured at all.

package/tests/cli_surface.mjs

@@ -169,18 +169,47 @@ function runGuidance(fn, env) {
   const code =
     `const l=require(${JSON.stringify(path.join(REPO_ROOT, 'scripts', 'gds', 'cli-lib.js'))});` +
     `Promise.resolve(l[${JSON.stringify(fn)}]()).catch(()=>{});`;
+  // HOME ALONE IS NOT ISOLATION ON WINDOWS (task 1003941). cli-lib resolves the
+  // session through os.homedir(), which on win32 reads USERPROFILE and ignores
+  // HOME entirely — so the child found the DEVELOPER'S REAL session, requireSession
+  // succeeded, and the guidance these tests exist to read was never printed. That
+  // failed on any Windows box whose builder happened to be signed in, and went
+  // green again once their CLI session expired, which made it read as a flake.
+  //
+  // HOMEDRIVE/HOMEPATH are os.homedir()'s second win32 source, so all four go.
+  const HOMELESS = path.join(REPO_ROOT, 'no-such-home-for-tests');
   const r = spawnSync(process.execPath, ['-e', code], {
     encoding: 'utf8',
-    env: { ...process.env, ...env, HOME: path.join(REPO_ROOT, 'no-such-home-for-tests') },
+    env: {
+      ...process.env,
+      ...env,
+      HOME: HOMELESS,
+      USERPROFILE: HOMELESS,
+      HOMEDRIVE: '',
+      HOMEPATH: HOMELESS,
+    },
   });
   return `${r.stdout || ''}${r.stderr || ''}`;
 }
 
+// The isolation above either worked or it did not, and the difference is visible:
+// a child with no session PRINTS guidance, and a child that found one prints
+// nothing. Every assertion below that looks for something ABSENT is satisfied for
+// free by that silence, so the silence is checked for first (task 1003941).
+function guidanceOutput(fn, env) {
+  const out = runGuidance(fn, env);
+  assert.ok(out.trim().length > 0,
+    `${fn} printed NOTHING. That means the child found a real CLI session instead of `
+    + 'the blanked home, so this test is reading an unisolated environment and every '
+    + '"must not contain" assertion here is vacuous (task 1003941).');
+  return out;
+}
+
 const GUIDANCE = ['printUnauthGuidanceAndExit', 'printBoxScopeGuidanceAndExit', 'requireSession'];
 
 test('no guidance path speaks slash commands to a terminal reader', () => {
   for (const fn of GUIDANCE) {
-    const out = runGuidance(fn, { BONGOS_SURFACE: 'terminal' });
+    const out = guidanceOutput(fn, { BONGOS_SURFACE: 'terminal' });
     const leaks = [...out.matchAll(/\/builder-[a-z-]+/g)].map((m) => m[0]);
     assert.deepEqual(leaks, [], `${fn} leaked to a terminal reader: ${leaks.join(', ')}\n${out}`);
     assert.ok(!/node scripts\/gds\//.test(out), `${fn} told a terminal reader to run a repo script:\n${out}`);

package/tests/hall_roster_world.mjs

@@ -271,11 +271,16 @@ test('sessions: every id on a row is a door, the earned figure is shown, the tot
   assert.match(html, /<div class="stat-row" id="stats-body"><\/div>/);
   const ths = (html.match(/<th[ >]/g) || []).length;
   // task 1002516: a tenth column, "Plain speech" — the transcript accessibility
-  // dimension the criterion asks to surface on the dashboard (ADR 0291). The
-  // per-cell contract (a not-scored session is a dash, never a zero) lives in
-  // tests/hall_sessions_ledger.mjs; this pin is only the column count.
-  assert.equal(ths, 10, 'ten columns: session, builder, tasks, earned, turns, tokens, tool errors, duration, plain speech, recorded');
-  assert.match(src, /colspan="10"/, 'the empty row spans them all');
+  // dimension the criterion asks to surface on the dashboard (ADR 0291).
+  // task 1003975: an eleventh, "Kind" — the session's derived shape, so the 54%
+  // of rows with no task chip are readable at all. The per-cell contracts (a
+  // not-scored session is a dash, never a zero; an unclassified one is a dash,
+  // never 'Unclear') live in tests/hall_sessions_ledger.mjs and
+  // tests/session_type.mjs; this pin is the column count AND that the empty row
+  // still spans them — a header added without widening the colspan leaves the
+  // empty state short by a column, which no screenshot pass would catch.
+  assert.equal(ths, 11, 'eleven columns: session, builder, kind, tasks, earned, turns, tokens, tool errors, duration, plain speech, recorded');
+  assert.match(src, new RegExp(`colspan="${ths}"`), 'the empty row spans them all');
   const fam = html.indexOf('/builders/oversight.css');
   assert.ok(fam > 0 && html.indexOf('/builders/sessions.css') > fam, 'sessions.html links the family sheet before its own');
 });

package/tests/home_isolation_guard.mjs

@@ -0,0 +1,95 @@
+// tests/home_isolation_guard.mjs — setting HOME for a child isolates nothing on
+// Windows (task 1003763).
+//
+// os.homedir() reads USERPROFILE on win32 and never consults HOME, so
+// `env: { ...process.env, HOME: tmp }` leaves the child looking at the developer's
+// real home — and their real CLI session. Three tasks fixed this one site at a time:
+// 1003760 (cli_sessions, which DESTROYED a live session), 1003941 (cli_surface) and
+// this one (cli_package). The last two are the dangerous shape — a test that isolates
+// nothing does not announce itself, it quietly stops testing what its comment claims.
+//
+// Run:  node tests/home_isolation_guard.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync } 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 { checkHomeIsolation, offendingLines, stripComments, ALLOW } =
+  require('../scripts/gds/home-isolation-guard.js');
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+test('the live tree is clean, and the scan is not empty', () => {
+  const r = checkHomeIsolation();
+  assert.deepEqual(r.violations, [], r.violations.join('\n'));
+  // A guard that scans nothing passes for free. The note carries the counts so a
+  // silently-broken scan is visible rather than reassuring.
+  const scanned = Number(/^(\d+) test file/.exec(r.note)?.[1] ?? 0);
+  const sites = Number(/(\d+) of them build a child env/.exec(r.note)?.[1] ?? 0);
+  assert.ok(scanned > 100, `expected the whole tests/ tree, scanned ${scanned}`);
+  assert.ok(sites > 0, 'no file builds a child env with HOME — the pattern has drifted and this guard is inert');
+});
+
+test('the original broken shape IS caught', () => {
+  const src = 'const r = spawnSync(node, [x], { env: { ...process.env, HOME: home } });';
+  assert.equal(offendingLines(src).length, 1);
+});
+
+test('the fixed shape is not', () => {
+  const src = 'const r = spawnSync(node, [x], { env: { ...process.env, HOME: home, USERPROFILE: home } });';
+  assert.deepEqual(offendingLines(src), []);
+});
+
+test('a HELPER CALL SITE is not a child env', () => {
+  // tests/setup_smoke.mjs passes { HOME: fakeHome } to its own runSetup(), which adds
+  // USERPROFILE itself. Flagging the callers would point at the wrong line and, worse,
+  // train someone to "fix" three call sites instead of the one helper.
+  assert.deepEqual(offendingLines("runSetup(['--dry-run'], { HOME: fakeHome });"), []);
+});
+
+test('a COMMENT quoting the bug is not the bug', () => {
+  // Every file that fixed this now explains it by quoting the broken line. A raw text
+  // scan therefore reports exactly the files that already fixed it — which is how the
+  // first run of this guard produced three false positives.
+  assert.deepEqual(offendingLines('// env: { ...process.env, HOME: home } isolated nothing'), []);
+  assert.deepEqual(offendingLines('/* env: { ...process.env, HOME: home } */'), []);
+  assert.ok(!stripComments('// { ...process.env, HOME: x }').includes('HOME'));
+});
+
+test('a multi-line literal is still read', () => {
+  const src = [
+    'const r = spawnSync(node, [x], {',
+    '  env: {',
+    '    ...process.env,',
+    '    HOME: home,',
+    '  },',
+    '});',
+  ].join('\n');
+  assert.equal(offendingLines(src).length, 1, 'the literal wraps — a single-line matcher misses the real shape');
+});
+
+test('every allowlisted file exists and still means HOME differently', () => {
+  // An allowlist entry is a claim. If the file is gone, the claim is stale and the
+  // entry is a hole nobody is watching.
+  for (const [name, why] of ALLOW) {
+    const p = path.join(REPO_ROOT, 'tests', name);
+    let src;
+    try { src = readFileSync(p, 'utf8'); } catch {
+      assert.fail(`allowlisted tests/${name} no longer exists — remove the entry rather than leaving an unwatched hole`);
+    }
+    assert.ok(why && why.length > 20, `tests/${name} needs a reason, not just an exemption`);
+    assert.match(src, /HOME/, `tests/${name} no longer mentions HOME, so its exemption is dead`);
+  }
+});
+
+test('the two sites this task fixed are actually fixed', () => {
+  const src = readFileSync(path.join(REPO_ROOT, 'tests', 'cli_package.mjs'), 'utf8');
+  assert.deepEqual(offendingLines(src), []);
+  assert.match(src, /USERPROFILE/, 'cli_package must set USERPROFILE alongside HOME');
+  const surface = readFileSync(path.join(REPO_ROOT, 'tests', 'cli_surface.mjs'), 'utf8');
+  assert.deepEqual(offendingLines(surface), []);
+});

package/tests/module_api_lazy.mjs

@@ -35,8 +35,13 @@ function loadedAfter(spec, read = null) {
     const ROOT = ${JSON.stringify(ROOT)};
     const m = require(path.join(ROOT, ${JSON.stringify(spec)}));
     ${read ? `void m[${JSON.stringify(read)}];` : ''}
+    // POSIX-normalised before filtering (task 1003941). path.relative returns
+    // backslashes on win32, so 'src/bongos/' matched NOTHING and every list came
+    // back empty — which made the two laziness assertions below pass VACUOUSLY on
+    // Windows: they assert that a filtered-empty list is empty. An eager require
+    // reintroduced at the doorway would have shipped green.
     const files = Object.keys(require.cache)
-      .map((f) => path.relative(ROOT, f))
+      .map((f) => path.relative(ROOT, f).split(path.sep).join('/'))
       .filter((f) => f.startsWith('src/bongos/'));
     process.stdout.write(JSON.stringify(files));
   `;
@@ -50,6 +55,32 @@ function loadedAfter(spec, read = null) {
   return JSON.parse(out);
 }
 
+// CALIBRATION — can the instrument see anything at all? (task 1003941)
+//
+// Every other assertion in this file has the shape "nothing heavy is in this
+// list", which an EMPTY list satisfies for free. So an empty list is not evidence
+// of laziness; it is evidence of nothing, and the two tests that guard the ADR
+// 0083 doorway invariant cannot tell the difference.
+//
+// That is not hypothetical. loadedAfter filtered on a 'src/bongos/' prefix after
+// path.relative, which returns BACKSLASHES on win32 — so on Windows the filter
+// matched nothing, every list was empty, and both doorway tests passed vacuously.
+// An eager require reintroduced at the doorway would have shipped green.
+//
+// The fix normalises separators, but a normalisation can break again silently, and
+// asserting the doorway's own list is non-empty would be wrong — loading NOTHING
+// from src/bongos/ is precisely what the doorway is supposed to do. So the probe
+// is calibrated against a module that certainly does load one. If this test fails,
+// every emptiness assertion below is meaningless and should be read as untested.
+test('CALIBRATION: the probe can see a src/bongos/ require at all', () => {
+  const files = loadedAfter('src/bongos/pool.js');
+  assert.ok(files.includes('src/bongos/pool.js'),
+    'requiring src/bongos/pool.js must show up in the probe\'s own list. It does not, so '
+    + 'the list is empty for reasons unrelated to laziness — check the path normalisation '
+    + 'in loadedAfter (task 1003941). Until this passes, every "loads nothing" assertion '
+    + `in this file is vacuous. Saw: ${JSON.stringify(files.slice(0, 5))}`);
+});
+
 test('importing the doorway loads no server: no pool, no auth, no routes', () => {
   const files = loadedAfter('src/module-api.js');
   const heavy = files.filter((f) => HEAVY.test(f));

package/tests/routine_capture_kind.mjs

@@ -0,0 +1,147 @@
+// tests/routine_capture_kind.mjs — a routine that files its findings must name a
+// kind the server accepts (task 1003694).
+//
+// THE FAILURE THIS PINS. .claude/scheduled-tasks/dep-audit-nightly/SKILL.md filed
+// with `--kind security`. That is not one of the kinds — captureIdea throws BAD_KIND
+// and the route 400s — so the capture step of that nightly routine had NEVER filed
+// anything.
+//
+// It is quiet in the worst way. The routine still runs, still does the audit, and
+// only the step that turns a finding into a durable row fails. There is no
+// accumulating queue whose emptiness would look wrong, so nothing ever looked wrong.
+// A scheduled routine cannot notice its own silence, which is exactly why this is a
+// test and not a runtime check.
+//
+// Run:  node tests/routine_capture_kind.mjs
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readFileSync, readdirSync, existsSync } 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 { VALID_KINDS } = require('../modules/ideas/inbox.js');
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Every SKILL.md that could carry a capture command: the scheduled routines and the
+// skills. A routine is the dangerous case (nobody reads its output), but a skill with
+// a bad kind wastes a builder's time the same way.
+function skillFiles() {
+  const out = [];
+  const roots = [
+    path.join(REPO_ROOT, '.claude', 'scheduled-tasks'),
+    path.join(REPO_ROOT, '.claude', 'skills'),
+  ];
+  for (const root of roots) {
+    if (!existsSync(root)) continue;
+    for (const d of readdirSync(root, { withFileTypes: true })) {
+      if (!d.isDirectory()) continue;
+      const p = path.join(root, d.name, 'SKILL.md');
+      if (existsSync(p)) out.push(p);
+    }
+  }
+  return out;
+}
+
+// `--kind foo` — a LITERAL kind, on a CAPTURE command only.
+//
+// Both narrowings are load-bearing, and I got each wrong first:
+//
+//   - CAPTURE ONLY. `--kind` is not unique to capture.js. recall.js takes its own
+//     `--kind doc|db`, and a matcher that reads every `--kind` in the tree reports
+//     three recall invocations as broken. A guard whose first run is mostly noise
+//     is a guard people learn to suppress.
+//   - LITERAL ONLY. A placeholder (`--kind <bug|cleanup>`, `--kind cleanup|refactor`)
+//     documents a CHOICE rather than passing a value; overnight-code-review and
+//     repo-simplify-sweep both use that form deliberately.
+const CAPTURE_LINE_RE = /capture\.js/;
+const KIND_RE = /--kind\s+([a-z][a-z0-9-]*)(?=[\s`'"]|$)/g;
+
+// A capture command can wrap across lines with a trailing backslash, so the unit of
+// inspection is the command, not the line: a run of lines joined while the previous
+// one ends in `\`.
+function captureCommands(text) {
+  const lines = String(text || '').split('\n');
+  const out = [];
+  let buf = null;
+  for (const line of lines) {
+    const continues = /\\\s*$/.test(line);
+    if (buf !== null) {
+      buf += ' ' + line;
+      if (!continues) { out.push(buf); buf = null; }
+    } else if (CAPTURE_LINE_RE.test(line)) {
+      if (continues) buf = line;
+      else out.push(line);
+    }
+  }
+  if (buf !== null) out.push(buf);
+  return out;
+}
+
+function literalKinds(text) {
+  const out = [];
+  for (const cmd of captureCommands(text)) {
+    for (const m of cmd.matchAll(KIND_RE)) {
+      const after = cmd.slice(m.index + m[0].length, m.index + m[0].length + 1);
+      if (after === '|') continue; // `--kind cleanup|refactor` — a menu, not a value
+      out.push(m[1]);
+    }
+  }
+  return out;
+}
+
+test('every literal --kind in a routine or skill is a kind the server accepts', () => {
+  const files = skillFiles();
+  // The scan must not pass by finding nothing: these files exist, and at least one of
+  // them documents a capture command.
+  assert.ok(files.length > 0, 'found no SKILL.md files at all — the scan is broken, not clean');
+
+  const bad = [];
+  let seen = 0;
+  for (const f of files) {
+    for (const kind of literalKinds(readFileSync(f, 'utf8'))) {
+      seen += 1;
+      if (!VALID_KINDS.includes(kind)) bad.push(`${path.relative(REPO_ROOT, f)}: --kind ${kind}`);
+    }
+  }
+  assert.ok(seen > 0, 'no literal --kind found anywhere — the pattern has drifted, and this test would pass an empty repo');
+  assert.deepEqual(bad, [],
+    `these file a kind the server rejects with a 400 — for a SCHEDULED routine that means its findings are silently never filed:\n  ${bad.join('\n  ')}\n`
+    + `Valid kinds: ${VALID_KINDS.join(', ')}`);
+});
+
+test('the matcher reads a literal kind on a capture command', () => {
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind infra --body-file x'), ['infra']);
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js "t" --kind security'), ['security'],
+    'the real bug is still caught');
+});
+
+test('a DIFFERENT tool\'s --kind is not this guard\'s business', () => {
+  // recall.js takes --kind doc|db. Reading every --kind in the tree reported three
+  // recall invocations as broken on the first run of this guard.
+  assert.deepEqual(literalKinds('node scripts/gds/recall.js nightly backup --kind doc'), []);
+  assert.deepEqual(literalKinds('add `--kind doc` for ADRs/recipes'), []);
+});
+
+test('a documented menu is not a value', () => {
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind <bug|cleanup|refactor>'), []);
+  assert.deepEqual(literalKinds('node scripts/gds/capture.js --kind cleanup|refactor \\'), []);
+});
+
+test('a capture command wrapped over lines is still read', () => {
+  const text = ['node scripts/gds/capture.js "t" \\', '  --kind security \\', '  --body-file /tmp/x'].join('\n');
+  assert.deepEqual(literalKinds(text), ['security'],
+    'dep-audit-nightly writes exactly this shape — a line-at-a-time matcher misses it');
+});
+
+test('dep-audit-nightly specifically now files with an accepted kind (task 1003694)', () => {
+  const p = path.join(REPO_ROOT, '.claude', 'scheduled-tasks', 'dep-audit-nightly', 'SKILL.md');
+  const src = readFileSync(p, 'utf8');
+  assert.ok(!/--kind\s+security\b/.test(src), 'security is not a kind and never was');
+  const kinds = literalKinds(src);
+  assert.ok(kinds.length > 0, 'the routine must still file something');
+  for (const k of kinds) assert.ok(VALID_KINDS.includes(k), `${k} is not a valid kind`);
+});