0xray 4.0.30 → 4.0.32

package/dist/integrations/hooks/goggles-pipeline.mjs

@@ -0,0 +1,632 @@
+/**
+ * Goggles. Kind 0 name-checks the six outer names.
+ * Digest and triage return one card. Empty stays empty.
+ * A held plane stays quiet. A leave is denied.
+ */
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const FIELD_ORDER = ['plate', 'entry', 'exit', 'files', 'skills', 'setup', 'teardown', 'worn'];
+const HERE = dirname(fileURLToPath(import.meta.url));
+const WORN_PLANES = ['dichotomy', 'syncopate', 'synthesis', 'digest', 'triage', 'loop'];
+const CARD_PLANES = ['ground', 'routing', 'house', 'boot', 'governance', 'memory-recall', 'orchestration', 'processor', 'reporting'];
+const CARD_FLAVORS = ['digest', 'triage'];
+const SCOPE_ZOOM = ['ecosystem', 'part', 'one flow', 'one artifact'];
+
+/** Empty GOGGLES_PLANES_PATH keeps the file beside the organ. */
+export function planesFile() {
+  const override = process.env.GOGGLES_PLANES_PATH;
+  if (typeof override === 'string' && override.trim()) return override.trim();
+  return join(HERE, 'goggles-planes.json');
+}
+
+function drawnPlanes() {
+  try {
+    const data = JSON.parse(readFileSync(planesFile(), 'utf8'));
+    return Array.isArray(data.planes) ? data.planes.map((name) => String(name)) : [];
+  } catch {
+    return [];
+  }
+}
+
+export function actualityOf(map, worn) {
+  const left = Array.isArray(map) ? map : [];
+  const right = Array.isArray(worn) ? worn : [];
+  const same = left.length === right.length && left.every((name, index) => name === right[index]);
+  return same ? '' : 'Actuality. Drift: worn is not the map.';
+}
+
+export function actualityLine() {
+  return actualityOf(drawnPlanes(), WORN_PLANES);
+}
+
+function acceptedPlanes() {
+  const map = new Set(drawnPlanes());
+  return WORN_PLANES.filter((name) => map.has(name));
+}
+
+function readingLine(name, scope) {
+  return scope ? `The reading is ${name}. Scope is ${scope}.` : `The reading is ${name}.`;
+}
+
+function organDeny(reason) {
+  return { gate: 'goggles', decision: 'deny', reason };
+}
+
+function planeWord(name, text) {
+  return new RegExp(`(?:^|[^A-Za-z0-9-])${String(name).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?:[^A-Za-z0-9-]|$)`, 'i').test(String(text || ''));
+}
+
+function withoutPaths(text) {
+  return String(text || '').replace(/(?:[\w.@~-]+\/)+[\w.-]+/g, ' ');
+}
+
+export function organStop(held, action) {
+  if (!held) return null;
+  if (held.drift) return organDeny(held.drift);
+  const plane = held.plane;
+  if (!plane) return null;
+  const text = String(action?.text || '');
+  const paths = (action?.paths || []).map(String).filter(Boolean);
+  const tool = String(action?.tool || '');
+  if (/docs-site\/docs\/plates\/[a-z0-9-]+\.md/i.test([text, ...paths].join('\n'))) {
+    return organDeny(`The reading is ${plane}. That drawing is not the plane.`);
+  }
+  const stripped = withoutPaths(text);
+  const others = acceptedPlanes().filter((name) => name !== plane && planeWord(name, stripped));
+  const namesThis = planeWord(plane, stripped);
+  if (others.length > 1 || (others.length === 1 && namesThis)) {
+    return organDeny(`The reading is ${plane}. The action names two planes.`);
+  }
+  if (others.length === 1) {
+    return organDeny(`The reading is ${plane}. The action is ${others[0]}.`);
+  }
+  return scopeStop(plane, held.scope, tool, paths);
+}
+
+function scopeStop(plane, scope, tool, paths) {
+  if (!scope || scope === 'ecosystem') return null;
+  if (scope === 'part') {
+    const dirs = new Set(paths.map((file) => dirname(file)));
+    if (dirs.size > 1) return organDeny(`The reading is ${plane}. Scope is part. This action crosses parts.`);
+    return null;
+  }
+  if (scope === 'one flow') {
+    if (/grep|search|glob|read|open/i.test(tool) && paths.length !== 1) {
+      return organDeny(`The reading is ${plane}. Scope is one flow. This action is not one flow.`);
+    }
+    return null;
+  }
+  if (scope === 'one artifact') {
+    if (/bash|shell/i.test(tool) || paths.length !== 1) {
+      return organDeny(`The reading is ${plane}. Scope is one artifact. This action is wider.`);
+    }
+  }
+  return null;
+}
+
+function readingPath(root) {
+  return join(root, '.xray', 'state', 'goggles-reading.json');
+}
+
+function loadReading(root) {
+  try {
+    const data = JSON.parse(readFileSync(readingPath(root), 'utf8'));
+    if (!data || typeof data !== 'object') return null;
+    if (typeof data.drift === 'string' && data.drift) return { drift: data.drift };
+    if (typeof data.plane !== 'string' || !data.plane) return null;
+    return { plane: data.plane, scope: typeof data.scope === 'string' ? data.scope : '' };
+  } catch {
+    return null;
+  }
+}
+
+function saveReading(root, rec) {
+  const file = readingPath(root);
+  mkdirSync(dirname(file), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(rec)}\n`);
+}
+
+function clearReading(root) {
+  const file = readingPath(root);
+  if (existsSync(file)) unlinkSync(file);
+}
+
+function findScopes(words) {
+  let rest = ` ${words.join(' ').toLowerCase()} `;
+  const hits = [];
+  const ordered = [...SCOPE_ZOOM].sort((a, b) => b.length - a.length);
+  for (const scope of ordered) {
+    const needle = ` ${scope} `;
+    if (!rest.includes(needle)) continue;
+    hits.push(scope);
+    rest = rest.split(needle).join(' ');
+  }
+  return hits;
+}
+
+function kindPastOne(words) {
+  const lower = words.map((word) => word.toLowerCase());
+  if (lower.length === 1 && /^\d+$/.test(lower[0]) && Number(lower[0]) > 1) return true;
+  for (let i = 0; i < lower.length; i += 1) {
+    if (!/^(kind|pull|pull-up|level)$/.test(lower[i])) continue;
+    const next = lower[i + 1];
+    if (next && /^\d+$/.test(next) && Number(next) > 1) return true;
+  }
+  return false;
+}
+
+function isKindZero(lower) {
+  if (lower.includes('actuality')) return true;
+  if (lower.length === 1 && lower[0] === '0') return true;
+  for (let i = 0; i < lower.length; i += 1) {
+    if ((lower[i] === 'kind' || lower[i] === 'level') && lower[i + 1] === '0') return true;
+  }
+  return false;
+}
+
+function namesTheSet(lower) {
+  const joined = lower.join(' ');
+  if (joined === 'kind 1' || joined === 'level 1') return true;
+  const mentionsSet = lower.includes('outer') || lower.includes('outer-loop');
+  if (!mentionsSet) return false;
+  const planes = acceptedPlanes().filter((name) => lower.includes(name));
+  if (planes.length === 0) return true;
+  return planes.length === 1 && planes[0] === 'loop' && findScopes(lower).length === 0;
+}
+
+function gogglesAnswer(argv) {
+  const words = [];
+  for (const raw of argv || []) {
+    const arg = String(raw || '').trim();
+    if (!arg || arg.toLowerCase() === 'pop') continue;
+    words.push(arg);
+  }
+  const lower = words.map((word) => word.toLowerCase());
+  const none = (text) => ({ text, cards: null });
+  if (lower.includes('calling')) return none('');
+  if (kindPastOne(words)) return none('');
+  if (words.length === 0) return none('');
+  if (namesTheSet(lower)) return none('Name one plane.');
+  if (isKindZero(lower)) {
+    if (findScopes(words).length) return none('');
+    if (acceptedPlanes().some((name) => lower.includes(name))) return none('');
+    return none(actualityLine());
+  }
+  const flavors = CARD_FLAVORS.filter((name) => lower.includes(name));
+  if (flavors.length > 1) return none('');
+  if (flavors.length === 1) {
+    const others = acceptedPlanes().filter((name) => name !== flavors[0] && lower.includes(name));
+    if (others.length) return none('');
+    const cards = collectCards(flavors[0], lower);
+    if (!cards) return none('');
+    return { text: cards.map((card) => formatCardText(card)).join('\n\n'), cards };
+  }
+  const planes = acceptedPlanes().filter((name) => lower.includes(name));
+  if (planes.length !== 1) return none('');
+  const scopes = findScopes(words.filter((word) => word.toLowerCase() !== planes[0]));
+  if (scopes.length > 1) return none('');
+  return none(readingLine(planes[0], scopes[0] || ''));
+}
+
+export function readGoggles(argv) {
+  return ok(gogglesAnswer(argv).text);
+}
+
+export function lookCards(argv) {
+  return gogglesAnswer(argv).cards;
+}
+
+function cardPlanesNamed(lower) {
+  return CARD_PLANES.filter((name) => lower.includes(name));
+}
+
+function listedFiles(plane, scope) {
+  const files = Array.isArray(plane.files) ? plane.files.map(String) : [];
+  if (scope === 'one artifact') return files.length === 1 ? [files[0]] : null;
+  const unpathed = Array.isArray(plane.unpathed) ? plane.unpathed : [];
+  const parts = files.slice();
+  for (const name of unpathed) parts.push(name === 'mill' ? 'mill has no path' : String(name));
+  return parts;
+}
+
+function cardView(plane, scope, flavor, root) {
+  const listed = listedFiles(plane, scope);
+  if (!listed) return null;
+  const view = {
+    plane: plane.id,
+    flavor,
+    scope: scope || '',
+    from: plane.id === 'ground' ? '' : 'ground',
+    digest: plane.digest || '',
+    plate: plane.plate || '',
+    entry: plane.entry || '',
+    exit: plane.exit || '',
+    files: listed,
+    skills: plane.skills || '',
+    setup: plane.setup || '',
+    teardown: plane.teardown || '',
+    worn: plane.worn || '',
+    narrow: scope === 'one flow' || scope === 'one artifact',
+  };
+  if (flavor === 'triage') {
+    const filled = new Set(filledOf(plane));
+    view.empty = FIELD_ORDER.filter((name) => !filled.has(name));
+    view.exam = examinePlane(plane, root).text;
+  }
+  return view;
+}
+
+function formatCardText(view) {
+  const rows = [
+    ['Plane', view.plane],
+    ['From', view.from],
+    ['Digest', view.digest],
+    ['Plate', view.plate],
+    ['Entry', view.entry],
+    ['Exit', view.exit],
+    ['Files', view.files.join(', ')],
+    ['Skills', view.skills],
+    ['Setup', view.setup],
+    ['Teardown', view.teardown],
+    ['Worn', view.worn],
+  ];
+  const shown = view.narrow
+    ? rows.filter(([key]) => key === 'Plane' || key === 'Digest' || key === 'Files')
+    : rows;
+  let text = shown.map(([key, value]) => `${key}: ${value}`.trimEnd()).join('\n');
+  if (view.flavor === 'triage') {
+    const lines = [];
+    if (view.empty.length) lines.push(`Empty: ${view.empty.join(', ')}`);
+    lines.push(view.exam);
+    text = `${text}\n${lines.join('\n')}`;
+  }
+  return text;
+}
+
+export function formatCardPane(view) {
+  const rows = [['Plane', view.plane]];
+  if (!view.narrow) rows.push(['From', view.from]);
+  rows.push(['Digest', view.digest]);
+  if (!view.narrow) {
+    rows.push(
+      ['Plate', view.plate],
+      ['Entry', view.entry],
+      ['Exit', view.exit],
+      ['Files', view.files.join(', ')],
+      ['Skills', view.skills],
+      ['Setup', view.setup],
+      ['Teardown', view.teardown],
+      ['Worn', view.worn],
+    );
+  } else {
+    rows.push(['Files', view.files.join(', ')]);
+  }
+  if (view.flavor === 'triage') {
+    if (Array.isArray(view.empty) && view.empty.length) rows.push(['Empty', view.empty.join(', ')]);
+    if (view.exam) rows.push(['', view.exam]);
+  }
+  const body = rows.map(([label, value]) => (label ? `${label.padEnd(8)} ${value}` : value).trimEnd());
+  const title = `${view.flavor} · ${view.plane}`;
+  const width = Math.max(title.length + 2, ...body.map((line) => line.length));
+  const top = `┌ ${title} ${'─'.repeat(Math.max(0, width - title.length - 1))}┐`;
+  const mid = body.map((line) => `│ ${line.padEnd(width)} │`);
+  const bot = `└${'─'.repeat(width + 2)}┘`;
+  return [top, ...mid, bot].join('\n');
+}
+
+function collectCards(flavor, lower) {
+  const named = cardPlanesNamed(lower);
+  const scopes = findScopes(lower.filter((word) => word !== flavor && !named.includes(word)));
+  if (named.length > 1 || scopes.length > 1) return null;
+  const scope = scopes[0] || '';
+  if (!named.length && (scope === 'part' || scope === 'one flow' || scope === 'one artifact')) return null;
+  const platesDir = findPlatesDir(HERE);
+  if (!platesDir) return null;
+  const ids = named.length ? named : CARD_PLANES;
+  const root = repoRootFrom(platesDir);
+  const cards = [];
+  for (const id of ids) {
+    const plane = assemblePlane(id, platesDir);
+    if (!plane) continue;
+    const view = cardView(plane, scope, flavor, root);
+    if (!view) return null;
+    cards.push(view);
+  }
+  return cards;
+}
+
+export function findPlatesDir(start) {
+  let dir = start;
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = join(dir, 'docs-site', 'docs', 'plates');
+    if (existsSync(join(candidate, 'index.md'))) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+
+function stripFrontmatter(raw) {
+  return String(raw).replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n/, '').trim();
+}
+
+
+function boxTitles(line) {
+  const titles = [];
+  for (const part of String(line).split('│')) {
+    const title = part.replace(/\s+/g, ' ').trim();
+    if (!/[A-Za-z]/.test(title)) continue;
+    if (title.startsWith('·') || title.includes('LAYER')) continue;
+    titles.push(title);
+  }
+  return titles;
+}
+
+function doorsOf(body) {
+  let layer = '';
+  let want = false;
+  const found = { input: [], output: [] };
+  for (const line of String(body).split(/\r?\n/)) {
+    if (line.includes('INPUT LAYER')) { layer = 'input'; want = false; continue; }
+    if (line.includes('OUTPUT LAYER')) { layer = 'output'; want = false; continue; }
+    if (line.includes('PROCESSING LAYER')) { layer = ''; want = false; continue; }
+    if (layer !== 'input' && layer !== 'output') continue;
+    if (line.includes('┌')) { want = true; continue; }
+    if (!want) continue;
+    const titles = boxTitles(line);
+    if (!titles.length) continue;
+    found[layer].push(...titles);
+    want = false;
+  }
+  const join = (list) => (list.length ? list.join(' · ') : null);
+  return { entry: join(found.input), exit: join(found.output) };
+}
+
+function takeOf(body) {
+  const lines = String(body).split(/\r?\n/);
+  const prose = [];
+  let pastHeading = false;
+  for (const line of lines) {
+    if (!pastHeading) {
+      if (/^#\s+/.test(line)) pastHeading = true;
+      continue;
+    }
+    if (line.startsWith('```')) break;
+    if (!line.trim()) {
+      if (prose.length) break;
+      continue;
+    }
+    prose.push(line.trim());
+  }
+  const paragraph = prose.join(' ');
+  const sentence = paragraph.match(/^.*?[.!?](?:\s|$)/);
+  return (sentence ? sentence[0] : paragraph).trim();
+}
+
+
+function overlayTable() {
+  const file = planesFile();
+  if (!existsSync(file)) return {};
+  return JSON.parse(readFileSync(file, 'utf8'));
+}
+
+function present(value) {
+  if (Array.isArray(value)) return value.length > 0;
+  return Boolean(value);
+}
+
+export function filledOf(plane) {
+  const flags = {
+    plate: present(plane.plate),
+    entry: present(plane.entry),
+    exit: present(plane.exit),
+    files: present(plane.files) || present(plane.unpathed),
+    skills: present(plane.skills),
+    setup: present(plane.setup),
+    teardown: present(plane.teardown),
+    worn: present(plane.worn),
+  };
+  return FIELD_ORDER.filter((name) => flags[name]);
+}
+
+export function assemblePlane(id, platesDir) {
+  const extra = overlayTable()[id] || {};
+  let plate = null;
+  let digest = extra.digest || '';
+  let doors = { entry: null, exit: null };
+  if (id !== 'ground') {
+    const abs = join(platesDir, `${id}.md`);
+    if (!existsSync(abs)) return null;
+    const raw = readFileSync(abs, 'utf8');
+    plate = join('docs-site', 'docs', 'plates', `${id}.md`);
+    if (!digest) digest = takeOf(stripFrontmatter(raw));
+    doors = doorsOf(raw);
+  }
+  if (!digest) return null;
+  return {
+    id,
+    digest,
+    plate,
+    entry: extra.entry || doors.entry || null,
+    exit: extra.exit || doors.exit || null,
+    entryIsMark: Boolean(extra.entry),
+    exitIsMark: Boolean(extra.exit),
+    files: extra.files || null,
+    unpathed: extra.unpathed || null,
+    skills: extra.skills || null,
+    setup: extra.setup || null,
+    teardown: extra.teardown || null,
+    worn: extra.worn || null,
+    mark: extra.mark || null,
+    wornMark: extra.wornMark || null,
+    pick: extra.pick || null,
+  };
+}
+
+function repoRootFrom(platesDir) {
+  return dirname(dirname(dirname(platesDir)));
+}
+
+function miss(text) {
+  return { ok: false, text };
+}
+
+function ok(text) {
+  return { ok: true, text };
+}
+
+function holds() {
+  return { kind: 'holds', text: 'Holds.' };
+}
+
+function drift(text) {
+  return { kind: 'drift', text: `Drift: ${text}` };
+}
+
+function drawing() {
+  return { kind: 'drawing', text: 'Drawing only.' };
+}
+
+function fileHas(root, rel, mark) {
+  if (!rel || !mark) return false;
+  const full = join(root, rel);
+  return existsSync(full) && readFileSync(full, 'utf8').includes(mark);
+}
+
+
+function examinePlane(plane, root) {
+  const files = Array.isArray(plane.files) ? plane.files : [];
+  const checkable = files.length > 0 || plane.skills || plane.worn;
+  if (!checkable) return drawing();
+  for (const rel of files) {
+    if (!existsSync(join(root, rel))) return drift(`${rel} is not there`);
+  }
+  if (plane.mark && !fileHas(root, files[0], plane.mark)) {
+    return drift(`${plane.mark} is not in ${files[0]}`);
+  }
+  if (plane.worn && !fileHas(root, plane.worn, plane.wornMark || plane.mark)) {
+    return drift(`the worn build is not ${files[0] || plane.worn}`);
+  }
+  if (plane.skills && !existsSync(join(root, plane.skills))) {
+    return drift(`${plane.skills} is not there`);
+  }
+  if (plane.entryIsMark && plane.entry && files[0] && !fileHas(root, files[0], plane.entry)) {
+    return drift(`${plane.entry} is not in ${files[0]}`);
+  }
+  if (plane.exitIsMark && plane.exit && files[0] && !fileHas(root, files[0], plane.exit)) {
+    return drift(`${plane.exit} is not in ${files[0]}`);
+  }
+  return holds();
+}
+
+
+export function look(argv) {
+  return readGoggles(argv);
+}
+
+
+function isGogglesWork(text) {
+  return /(?<![A-Za-z0-9-])goggles(?![A-Za-z0-9-])/i.test(String(text || ''));
+}
+
+
+export function cardStop(root, toolName, text, paths = []) {
+  const raw = [String(text || ''), ...(paths || [])].join('\n');
+  if (isGogglesWork(raw)) {
+    clearReading(root);
+    clearCardLine(root);
+    return null;
+  }
+  const held = loadReading(root);
+  if (!held) return null;
+  const drift = actualityLine();
+  if (drift) return organDeny(drift);
+  return organStop(held, { tool: toolName, text, paths });
+}
+
+function stationFile(root) {
+  return join(root, '.xray', 'state', 'STATION.md');
+}
+
+function withoutCardLines(text) {
+  return String(text || '')
+    .split(/\r?\n/)
+    .filter((row) => !/^Card:\s/.test(row.trim()))
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n');
+}
+
+function clearCardLine(root) {
+  const dest = stationFile(root);
+  if (!existsSync(dest)) return;
+  const prev = readFileSync(dest, 'utf8');
+  const next = withoutCardLines(prev).replace(/\s*$/, '');
+  const body = next ? `${next}\n` : '';
+  if (body !== prev) writeFileSync(dest, body);
+}
+
+
+function intentWords(text) {
+  return String(text || '').toLowerCase().split(/[^a-z0-9-]+/).filter(Boolean);
+}
+
+export function handCard(root, intent) {
+  try {
+    clearCardLine(root);
+    const text = String(intent || '');
+    if (isGogglesWork(text)) {
+      clearReading(root);
+      return null;
+    }
+    const words = intentWords(text);
+    const looked = readGoggles(words);
+    if (looked.text.startsWith('Actuality. Drift')) {
+      saveReading(root, { drift: looked.text });
+      return null;
+    }
+    const planes = acceptedPlanes().filter((name) => words.includes(name));
+    if (planes.length !== 1) {
+      clearReading(root);
+      return null;
+    }
+    const scopes = findScopes(words.filter((word) => word !== planes[0]));
+    if (scopes.length > 1) {
+      clearReading(root);
+      return null;
+    }
+    const next = { plane: planes[0], scope: scopes[0] || '' };
+    const prev = loadReading(root);
+    if (prev && prev.plane === next.plane && (prev.scope || '') === next.scope && !prev.drift) return null;
+    saveReading(root, next);
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+
+export function lensPath(root) {
+  return join(root, '.xray', 'state', 'LENS.md');
+}
+
+
+export function maintainLens(root) {
+  const text = actualityLine();
+  mkdirSync(dirname(lensPath(root)), { recursive: true });
+  writeFileSync(lensPath(root), `${text}\n`);
+  return ok(text);
+}
+
+
+const isMain = Boolean(process.argv[1]) && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  const answered = gogglesAnswer(process.argv.slice(2));
+  const pane = process.stdout.isTTY && Array.isArray(answered.cards) && answered.cards.length > 0;
+  const text = pane ? answered.cards.map((card) => formatCardPane(card)).join('\n\n') : answered.text;
+  process.stdout.write(`${text}\n`);
+  process.exit(0);
+}

package/dist/integrations/hooks/goggles-planes.json

@@ -0,0 +1,28 @@
+{
+  "actuality": "map vs worn",
+  "planes": ["dichotomy", "syncopate", "synthesis", "digest", "triage", "loop"],
+  "scope": ["ecosystem", "part", "one flow", "one artifact"],
+  "ground": {
+    "digest": "Home. The dev plane.",
+    "files": [
+      "src",
+      "grok-bot/OP-PROC.md",
+      "src/opencode/agents",
+      "Agents.md",
+      "src/integrations",
+      "package.json",
+      "scripts/foundry"
+    ],
+    "skills": "SKILLS.md"
+  },
+  "routing": {
+    "files": ["src/nucleus/thin-dispatch.ts"],
+    "worn": "dist/nucleus/thin-dispatch.js",
+    "mark": "export function scoreAndRoute",
+    "wornMark": "function scoreAndRoute",
+    "pick": "resolveThinDispatch"
+  },
+  "house": {
+    "files": ["grok-bot/lib/seat-doctor.cjs"]
+  }
+}

package/dist/integrations/hooks/plates.cjs

@@ -15,6 +15,11 @@ const PLATE_IDS = Object.freeze([
   "reporting",
   "memory-recall",
   "house",
+  "goggles",
+  "suit",
+  "kits",
+  "host-pack",
+  "glossary",
 ]);
 
 /** Id token, then extra phrases. Equal top scores recall nothing. */
@@ -68,6 +73,24 @@ const CUES = {
     [/GROK_BOT_HOUSE/i, 4],
     [/setup-house/i, 4],
   ],
+  goggles: [
+    [/\bgoggles\b/i, 6],
+  ],
+  suit: [
+    [/suit plate/i, 6],
+    [/plates\/suit\b/i, 6],
+  ],
+  kits: [
+    [/\bkits plate\b/i, 6],
+    [/\bkits\b/i, 5],
+  ],
+  "host-pack": [
+    [/host\s*pack/i, 6],
+    [/host-pack/i, 6],
+  ],
+  glossary: [
+    [/\bglossary\b/i, 6],
+  ],
 };
 
 function platesDir() {