@litfamily/litgrok 1.0.25 → 1.0.27

package/.grok/hooks/lit-mark.mjs

@@ -104,6 +104,48 @@ export function lockup(productName) {
   return standard.map((row, index) => row.padEnd(28) + (index === 5 ? `  ${label}` : ''));
 }
 
+// The psychedelic rewind hue for the lit-adhd card and ignition mark: one hue at a time at a
+// steady lightness, so the card never flashes. `motion` is 'full' (a 24-second hue cycle),
+// 'subtle' (a slow 96-second drift) or 'off' (one still rainbow frame). Returns [r, g, b].
+export function rewindHue(nowMs, motion = 'full') {
+  return hueToRgb(rewindBaseAngle(nowMs, motion));
+}
+
+// One full wheel across a run of `total` cells, so each cell of a pill or mark takes its own
+// step round the wheel at the same steady lightness. Colour moves only on fixed glyphs.
+export function rewindCellRgb(nowMs, motion, index, total) {
+  const base = rewindBaseAngle(nowMs, motion);
+  const step = total > 1 ? 360 / total : 0;
+  return hueToRgb((((base + step * index) % 360) + 360) % 360);
+}
+
+function rewindBaseAngle(nowMs, motion = 'full') {
+  if (motion !== 'subtle' && motion !== 'off' && motion !== 'full') motion = 'full';
+  const time = Number.isFinite(nowMs) ? nowMs : 0;
+  const hue = motion === 'off' ? 280 : (((time % 96_000) + 96_000) % 96_000) / 96_000 * 360;
+  const period = motion === 'subtle' ? 1 : 4;
+  return (((hue * period) % 360) + 360) % 360;
+}
+
+function hueToRgb(angle) {
+  const saturation = 0.85;
+  const lightness = 0.62;
+  const chroma = (1 - Math.abs(2 * lightness - 1)) * saturation;
+  const part = chroma * (1 - Math.abs(((angle / 60) % 2) - 1));
+  const match = lightness - chroma / 2;
+  let red;
+  let green;
+  let blue;
+  if (angle < 60) [red, green, blue] = [chroma, part, 0];
+  else if (angle < 120) [red, green, blue] = [part, chroma, 0];
+  else if (angle < 180) [red, green, blue] = [0, chroma, part];
+  else if (angle < 240) [red, green, blue] = [0, part, chroma];
+  else if (angle < 300) [red, green, blue] = [part, 0, chroma];
+  else [red, green, blue] = [chroma, 0, part];
+  const channel = (value) => Math.max(0, Math.min(255, Math.round((value + match) * 255)));
+  return [channel(red), channel(green), channel(blue)];
+}
+
 export function colorize(rows, { mode = 'none' } = {}) {
   if (!['truecolor', '256', 'none'].includes(mode)) throw new TypeError('Invalid color mode');
   if (mode === 'none') return [...rows];

package/.grok/hooks/lit-status-line.mjs

@@ -5,6 +5,7 @@ import { closeSync, constants, fstatSync, openSync, readFileSync, readSync, real
 import { dirname, isAbsolute, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { resolveAutoHandoff } from './auto-handoff.mjs';
+import { rewindCellRgb } from './lit-mark.mjs';
 import { readHudRecordForCwd, writeContextRecord } from './litgrok-hud-state.mjs';
 import { STAGES, readWorkflowState } from './workflow-stage.mjs';
 
@@ -38,17 +39,17 @@ const GLYPHS = {
   basic: {
     fire: '🔥', tick: '✓', cross: '✗', dot: '·', lit: '━', unlit: '─', run: '●', warn: '⚠', elbow: '└', next: '▸', sep: '│',
     full: '▮', empty: '▯', rail: '▎', ellipsis: '…', spinner: BRAILLE, bar: ['█', '░', ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']],
-    timer: '', tools: (n) => plural(n, 'tool'), agents: (n) => plural(n, 'agent'), git: 'git ',
+    timer: '', burst: '★', tools: (n) => plural(n, 'tool'), agents: (n) => plural(n, 'agent'), git: 'git ',
   },
   nerd: {
     fire: '🔥', tick: '', cross: '', dot: '·', lit: '━', unlit: '─', run: '', warn: '', elbow: '└', next: '▸', sep: '│',
     full: '▮', empty: '▯', rail: '▎', ellipsis: '…', spinner: BRAILLE, bar: ['█', '░', ['', '▏', '▎', '▍', '▌', '▋', '▊', '▉']],
-    timer: ' ', tools: (n) => ` ${n}`, agents: (n) => ` ${n}`, git: ' ',
+    timer: ' ', burst: '★', tools: (n) => ` ${n}`, agents: (n) => ` ${n}`, git: ' ',
   },
   ascii: {
     fire: '', tick: '+', cross: 'x', dot: '-', lit: '=', unlit: '-', run: '*', warn: '!', elbow: '`', next: '>', sep: '|',
     full: '#', empty: '-', rail: '|', ellipsis: '~', spinner: ['|', '/', '-', '\\'], bar: ['#', '-', ['']],
-    timer: '', tools: (n) => plural(n, 'tool'), agents: (n) => plural(n, 'agent'), git: 'git ',
+    timer: '', burst: '*', tools: (n) => plural(n, 'tool'), agents: (n) => plural(n, 'agent'), git: 'git ',
   },
 };
 // Grok's own tool names, shortened to the words people know them by. Any other name shows as sent.
@@ -158,9 +159,17 @@ function painter(depth) {
   return {
     depth,
     fg: (text, role, bold = false) => (depth && text ? `${bold ? '\u001b[1m' : ''}${sgr(ROLES[role], depth)}${text}\u001b[0m` : text),
+    hue: (text, rgb, bold = false) => (depth && text ? `${bold ? '\u001b[1m' : ''}${sgr(rgb, depth)}${text}\u001b[0m` : text),
   };
 }
 
+// The rewind look's motion: 'full' cycles the hue, 'subtle' drifts it slowly, 'off' holds one still
+// rainbow frame. Anything else is 'full'.
+function hudMotion(env = process.env) {
+  const motion = (env.LITGROK_HUD_MOTION ?? 'full').toLowerCase();
+  return motion === 'off' || motion === 'subtle' ? motion : 'full';
+}
+
 // A filled chip on the pink (the brand) or the accent (the current stage) with dark text and a space of
 // padding each side; a Nerd Font gives it rounded caps, and without colour it falls back to brackets.
 function chip(text, background, paint, nerd, open = '(', close = ')') {
@@ -474,13 +483,68 @@ function disciplineName(name, glyphs, cells = Infinity) {
   return clipCells(name, Math.min(cells, name === 'lit-scientific-visualization' ? 32 : 24), glyphs.ellipsis);
 }
 
+// The look registry: a discipline maps to one look, and every route that runs a skill goes through
+// the collector's discipline, so bare words, slash commands, skill loads and aliases all select it.
+// Grok's one line can only tint and label, so a look is a tint plus a label (the card adds the pill).
+const LOOKS = { 'lit-adhd': 'rewind', 'review-work': 'lanes' };
+function lookOf(discipline, stage = null) {
+  if (typeof discipline === 'string' && Object.hasOwn(LOOKS, discipline)) return LOOKS[discipline];
+  if (stage === 'review') return 'lanes';
+  return 'plain';
+}
+
+// review-work's six lanes. Progress is real only: the test lane follows the workflow test verdict
+// and a lane with no report stays dim, never a fake fill.
+const REVIEW_LANES = ['behavior', 'test', 'safety', 'integration', 'documentation', 'regression'];
+function laneStates(workflow) {
+  const verdict = workflow?.test?.verdict;
+  return REVIEW_LANES.map((name) => ({
+    name,
+    state: name === 'test' && (verdict === 'pass' || verdict === 'fail') ? verdict : 'unreported',
+  }));
+}
+
+// Waiting on the user: a held plan gate (the typed start-work boundary) or a live Ask tool call.
+// The next UserPromptSubmit starts a new turn, so the label stops the moment the user types.
+function waitingOf(activity) {
+  if (!activity) return null;
+  if (activity.planGate) return { reason: 'plan gate' };
+  if (activity.live?.name === 'ask_user_question') return { reason: 'question' };
+  return null;
+}
+
 // The ignition mark of the one-line row: the pink 🔥 LIT chip, then IGNITED · <discipline> 🔥 in the accent.
 // Without colour it reads 🔥 LIT IGNITED · <discipline> 🔥. A narrow row clips the discipline, never the frame.
+// While lit-adhd is the discipline the mark keeps its shape but the discipline rides a hue that turns
+// (one still rainbow frame when the HUD motion is off): the tint, never a flash.
 function ignitionSegment(discipline, glyphs, paint, nerd, options = {}) {
   const label = glyphs.fire ? `${glyphs.fire} LIT` : 'LIT';
   const brand = chip(label, 'pink', paint, nerd, '', '');
   const build = (name) => `${brand.plain} IGNITED ${glyphs.dot} ${name}${glyphs.fire ? ` ${glyphs.fire}` : ''}`;
   const frame = width(build(''));
+  const ignitionLook = options.look ?? lookOf(discipline);
+  if (ignitionLook === 'rewind') {
+    // Each cell of the mark past the brand rides its own step round the wheel (one still rainbow
+    // frame when the HUD motion is off): the tint, never a flash.
+    const motion = hudMotion();
+    const when = options.now ?? Date.now();
+    const rainbow = (text) => {
+      const cells = [...text];
+      return cells.map((cell, index) => paint.hue(cell, rewindCellRgb(when, motion, index, cells.length), true)).join('');
+    };
+    return segment(build(disciplineName(discipline, glyphs)), (text) => `${brand.painted}${rainbow(text.slice(brand.plain.length))}`, {
+      ...options, minCells: frame + 1, shrink: (cells) => build(disciplineName(discipline, glyphs, Math.max(1, cells - frame))),
+    });
+  }
+  if (ignitionLook === 'lanes') {
+    const lanes = options.lanes ?? laneStates(null);
+    const reported = lanes.filter((lane) => lane.state !== 'unreported').length;
+    const full = build(`REVIEW ${reported}/${lanes.length}`);
+    return segment(full, (text) => `${brand.painted}${paint.fg(text.slice(brand.plain.length), 'accent', true)}`, {
+      ...options, minCells: frame + 1,
+      shrink: (cells) => (cells < width(full) ? clipCells(full, Math.max(1, cells), glyphs.ellipsis) : full),
+    });
+  }
   return segment(build(disciplineName(discipline, glyphs)), (text) => `${brand.painted}${paint.fg(text.slice(brand.plain.length), 'accent', true)}`, {
     ...options, minCells: frame + 1, shrink: (cells) => build(disciplineName(discipline, glyphs, Math.max(1, cells - frame))),
   });
@@ -498,11 +562,23 @@ function figureLeads(figures, glyphs, paint, afterMark) {
 // handoff percent, cost and branch. It is the whole HUD between workflows and in LITGROK_HUD_LINES=1
 // mode. A narrow row gives up the branch, the handoff percent, the cost and the version, then clips the
 // model name and last the discipline.
-function compactRow({ status, discipline, version, glyphs, paint, nerd, handoff, maxCells }) {
+function compactRow({ status, discipline, version, glyphs, paint, nerd, handoff, maxCells, looks = null, phase = null }) {
   const [model, context, ...extras] = figureSegments(status, { glyphs, paint, handoff });
-  const figures = [model, context, ...(discipline ? [ignitionSegment(discipline, glyphs, paint, nerd, { clip: 1 })] : []), ...extras];
+  const figures = [model, context];
+  if (discipline) {
+    figures.push(looks?.look === 'lanes'
+      ? ignitionSegment(discipline, glyphs, paint, nerd, { clip: 1, lanes: looks.lanes, look: looks.look })
+      : ignitionSegment(discipline, glyphs, paint, nerd, { clip: 1 }));
+  }
+  figures.push(...extras);
   const left = [brandSegment(version, glyphs, paint, { clip: 3 }), ...figureLeads(figures, glyphs, paint, true)];
-  return layoutLine({ left, separator: { plain: ' ', painted: ' ' }, rail: { plain: '', painted: '' }, maxCells, ellipsis: glyphs.ellipsis });
+  const right = [];
+  if (looks?.waiting) right.push(segment(`YOUR TURN · ${looks.waiting.reason}`, (text) => paint.fg(text, 'yellow', true), {
+    drop: 0.6, clip: 3, minCells: width('YOUR TURN'),
+    shrink: (cells) => (cells < width(`YOUR TURN · ${looks.waiting.reason}`) ? clipCells('YOUR TURN', Math.max(1, cells), glyphs.ellipsis) : `YOUR TURN · ${looks.waiting.reason}`),
+  }));
+  if (looks?.burst) right.push(segment(`${glyphs.burst} complete${phase?.timer ? ` ${phase.timer}` : ''}`, (text) => paint.fg(text, 'pink', true), { drop: 1 }));
+  return layoutLine({ left, right, separator: { plain: ' ', painted: ' ' }, rail: { plain: '', painted: '' }, maxCells, ellipsis: glyphs.ellipsis });
 }
 
 // The current stage's label: its name, the plan's checked tasks while working, and a tick once the
@@ -584,14 +660,50 @@ function railFor(paint, glyphs) {
 // The card's title: the mark, the pink 🔥 LIT chip and the discipline, then at the right edge the turn's
 // tool calls and subagents beside its state, as the family card's corner reads (● 1m42s running,
 // ✓ complete, ⚠ a warning, idle).
-function titleLine({ discipline, version, glyphs, paint, nerd, phase, warning, activity, maxCells, rail }) {
+function titleLine({ discipline, version, glyphs, paint, nerd, phase, warning, activity, maxCells, rail, now, looks = null }) {
   const brand = chip(glyphs.fire ? `${glyphs.fire} LIT` : 'LIT', 'pink', paint, nerd);
   const name = discipline ?? 'workflow';
+  const look = looks?.look ?? lookOf(discipline);
+  const lanes = look === 'lanes' ? (looks?.lanes ?? laneStates(null)) : null;
+  const reported = lanes ? lanes.filter((lane) => lane.state !== 'unreported').length : 0;
+  // The rewind pill rides the wheel cell by cell, like the ignition mark below. The lanes pill
+  // names review-work's six lanes; a lane with a verdict takes its colour, the rest stay dim.
+  const nameText = look === 'rewind' ? `✺ REWIND ${disciplineName(name, glyphs)}`
+    : lanes ? `REVIEW ${lanes.map((lane) => lane.name).join(' · ')}` : `${glyphs.dot} ${disciplineName(name, glyphs)}`;
+  const paintLane = (laneName) => {
+    const state = lanes.find((lane) => lane.name === laneName)?.state;
+    if (state === 'pass') return paint.fg(laneName, 'green', true);
+    if (state === 'fail') return paint.fg(laneName, 'red', true);
+    return paint.fg(laneName, 'dim');
+  };
+  const namePaint = look === 'rewind'
+    ? (text) => {
+      const motion = hudMotion();
+      const when = now ?? Date.now();
+      const cells = [...text];
+      return cells.map((cell, index) => paint.hue(cell, rewindCellRgb(when, motion, index, cells.length), true)).join('');
+    }
+    : lanes
+      ? (text) => {
+        const prefix = 'REVIEW ';
+        if (!text.startsWith(prefix)) return paint.fg(text, 'accent', true);
+        const names = text.slice(prefix.length).split(' · ');
+        const painted = names.map((laneName) => (lanes.some((lane) => lane.name === laneName)
+          ? paintLane(laneName) : paint.fg(laneName, 'accent', true)));
+        return `${paint.fg(prefix, 'accent', true)}${painted.join(paint.fg(' · ', 'dim'))}`;
+      }
+      : (text) => `${paint.fg(glyphs.dot, 'dim')} ${paint.fg(text.slice(glyphs.dot.length + 1), discipline ? 'accent' : 'dim', Boolean(discipline))}`;
+  const shrinkName = lanes
+    ? (cells) => {
+      const short = `REVIEW ${reported}/${lanes.length}`;
+      return cells < width(nameText) ? clipCells(short, Math.max(1, cells), glyphs.ellipsis) : nameText;
+    }
+    : (cells) => `${glyphs.dot} ${disciplineName(name, glyphs, Math.max(1, cells - width(glyphs.dot) - 1))}`;
   const left = [
     brandSegment(version, glyphs, paint, { clip: 3 }),
     { ...segment(brand.plain, () => brand.painted), lead: ' | ', leadPainted: paint.fg(' | ', 'accent') },
-    segment(`${glyphs.dot} ${disciplineName(name, glyphs)}`, (text) => `${paint.fg(glyphs.dot, 'dim')} ${paint.fg(text.slice(glyphs.dot.length + 1), discipline ? 'accent' : 'dim', Boolean(discipline))}`, {
-      clip: 0.5, minCells: width(glyphs.dot) + 2, shrink: (cells) => `${glyphs.dot} ${disciplineName(name, glyphs, Math.max(1, cells - width(glyphs.dot) - 1))}`,
+    segment(nameText, namePaint, {
+      clip: 0.5, minCells: lanes ? width(`REVIEW ${reported}/${lanes.length}`) : width(glyphs.dot) + 2, shrink: shrinkName,
     }),
   ];
   const right = [];
@@ -600,10 +712,16 @@ function titleLine({ discipline, version, glyphs, paint, nerd, phase, warning, a
     if (phase.phase === 'running' && activity.agents > 0) parts.push(glyphs.agents(activity.agents));
     if (parts.length > 0) right.push(segment(parts.join(` ${glyphs.dot} `), (text) => paint.fg(text, 'dim'), { drop: 4 }));
   }
-  if (warning) right.push(segment(`${glyphs.warn} ${warning[1]}`, (text) => paint.fg(text, 'yellow', true), { drop: 1 }));
+  if (looks?.waiting) right.push(segment(`YOUR TURN · ${looks.waiting.reason}`, (text) => paint.fg(text, 'yellow', true), {
+    drop: 0.6, clip: 3, minCells: width('YOUR TURN'),
+    shrink: (cells) => (cells < width(`YOUR TURN · ${looks.waiting.reason}`) ? clipCells('YOUR TURN', Math.max(1, cells), glyphs.ellipsis) : `YOUR TURN · ${looks.waiting.reason}`),
+  }));
+  else if (warning) right.push(segment(`${glyphs.warn} ${warning[1]}`, (text) => paint.fg(text, 'yellow', true), { drop: 1 }));
   if (phase.phase === 'running') right.push(segment(`${glyphs.run} ${phase.timer ? `${glyphs.timer}${phase.timer}` : 'running'}`, (text) => paint.fg(text, 'accent', true), { drop: 2 }));
-  else if (phase.phase === 'complete') right.push(segment(`${glyphs.tick} complete ${phase.timer}`, (text) => paint.fg(text, 'green', true), { drop: 2 }));
-  else if (!warning) right.push(segment('idle', (text) => paint.fg(text, 'dim'), { drop: 2 }));
+  else if (phase.phase === 'complete') {
+    if (looks?.burst) right.push(segment(`${glyphs.burst} complete ${phase.timer}`, (text) => paint.fg(text, 'pink', true), { drop: 2 }));
+    else right.push(segment(`${glyphs.tick} complete ${phase.timer}`, (text) => paint.fg(text, 'green', true), { drop: 2 }));
+  } else if (!warning && !looks?.waiting) right.push(segment('idle', (text) => paint.fg(text, 'dim'), { drop: 2 }));
   return layoutLine({ left, right, separator: { plain: ' ', painted: ' ' }, rail, maxCells, ellipsis: glyphs.ellipsis });
 }
 
@@ -681,10 +799,8 @@ function render(input) {
     handoff = { active: false, percent: null };
   }
   const version = installedVersion();
-  const shared = { status: input, discipline, version, glyphs, paint, nerd, handoff, maxCells };
-  if (process.env.LITGROK_HUD_LINES === '1') return [compactRow(shared)];
-
   const now = Date.now();
+  const shared = { status: input, discipline, version, glyphs, paint, nerd, handoff, maxCells, now };
   let activity = null;
   try {
     activity = turnActivity(readLedgerTail(input), input?.prompt_id);
@@ -697,15 +813,22 @@ function render(input) {
   } catch {
     workflow = null;
   }
-  // The card shows while a discipline is active or the session has a workflow stage; otherwise the
-  // HUD is the single row.
-  if (!discipline && !workflow?.stage) return [compactRow(shared)];
   const turn = turnState(input, activity, now);
   const phase = phaseOf(now, activity, turn);
+  const looks = {
+    look: lookOf(discipline, workflow?.stage ?? null),
+    lanes: laneStates(workflow),
+    waiting: waitingOf(activity),
+    burst: phase.phase === 'complete' && workflow?.stage === 'done',
+  };
+  if (process.env.LITGROK_HUD_LINES === '1') return [compactRow({ ...shared, looks, phase })];
+  // The card shows while a discipline is active or the session has a workflow stage; otherwise the
+  // HUD is the single row.
+  if (!discipline && !workflow?.stage) return [compactRow({ ...shared, looks, phase })];
   const warning = warningText(input, activity, handoff);
   const live = turn.running ? activity?.live ?? null : null;
   const rail = railFor(paint, glyphs);
-  const lines = [titleLine({ ...shared, phase, warning, activity: phase.phase === 'idle' ? null : activity, rail })];
+  const lines = [titleLine({ ...shared, phase, warning, activity: phase.phase === 'idle' ? null : activity, rail, looks })];
   if (workflow?.stage) lines.push(mapLine(workflow, { paint, glyphs, nerd, running: turn.running, now }, rail, maxCells));
   const detail = detailLine({ workflow, live, warning, glyphs, paint, now, maxCells, rail });
   if (detail) lines.push(detail);

package/.grok/hooks/record-passive-event.mjs

@@ -32,7 +32,12 @@ const TOOL_EVENTS = new Set(['PostToolUse', 'PostToolUseFailure']);
 const RECORD_SCHEMA = 'litgrok.hook-event/v1';
 // A finished call by one of these tools cannot have changed a plan file, so it skips the plan reread.
 const READ_ONLY_TOOLS = /^(?:read_file|grep|list_dir|glob|todo_write|web_search|web_fetch|read|ls)$/iu;
-const HUD_DISCIPLINE_PATTERN = /(?:^|[\s/])(lit-scientific-visualization|lit-handoff|lit-brainstorm|autoconference|autoresearch|lit-plan|litwork|lit)(?=$|[^\w-])/iu;
+const HUD_DISCIPLINE_PATTERN = /(?:^|[\s/])(lit-scientific-visualization|lit-handoff|lit-brainstorm|lit-adhd|lit-rewind|autoconference|autoresearch|lit-plan|litwork|review-work|lit)(?=$|[^\w-])/iu;
+// The skill also runs from bare words, the rule and the catalog, where no prompt names it. Its
+// collector starting is the run, so that call switches the card to the rewind look. The command
+// text is only inspected, never stored: the ledger keeps the tool name alone.
+const ADHD_COLLECTOR_SCRIPT = /lit-adhd\/scripts\/rewind\.mjs/u;
+const ADHD_COLLECTOR_RUN = /(?:^|[\s"'])(?:--brief|--json)(?:$|[\s"'=])/u;
 
 function maskCode(text) {
   return text.replace(/[^\r\n]/gu, '\u0000');
@@ -93,7 +98,9 @@ function hudDisciplineFromPrompt(prompt) {
   const match = HUD_DISCIPLINE_PATTERN.exec(visiblePromptText(prompt));
   if (!match) return null;
   const token = match[1].toLowerCase();
-  return token === 'lit' ? 'litwork' : token;
+  if (token === 'lit') return 'litwork';
+  if (token === 'lit-rewind') return 'lit-adhd';
+  return token;
 }
 
 class RecorderError extends Error {
@@ -445,6 +452,18 @@ export async function recordPassiveEvent(expectedEvent) {
     if (expectedEvent === 'UserPromptSubmit') {
       hudDiscipline = continued ?? (entry?.discipline !== undefined ? entry.discipline : hudDisciplineFromPrompt(event.prompt));
     }
+    if (expectedEvent === 'PreToolUse') {
+      const command = event?.toolInput?.command ?? event?.toolInput?.cmd;
+      if (typeof command === 'string' && ADHD_COLLECTOR_SCRIPT.test(command) && ADHD_COLLECTOR_RUN.test(command)) {
+        writeHudRecords({
+          env: process.env,
+          sessionId: environment.sessionId,
+          cwd: environment.eventCwd,
+          workspaceRoot: environment.realWorkspaceRoot,
+          discipline: 'lit-adhd',
+        });
+      }
+    }
     if (discipline !== null) record.discipline = discipline;
     if (entry?.stage && continued !== 'lit-brainstorm') record.stage = entry.stage;
     // Only the verdict and one count of a test run are kept, never the command or its output.

package/.grok/hooks/session-start.mjs

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import { renderMark } from './lit-mark.mjs';
 import { claimSessionIgnition } from './record-passive-event.mjs';
+import { adhdSuggestion } from '../skills/lit-adhd/scripts/lib/suggest.mjs';
 
 // Decode once: a multi-byte character can straddle two pipe chunks.
 const chunks = [];
@@ -16,6 +19,20 @@ try {
   if (bytes > 1024 * 1024) throw new Error('EVENT_TOO_LARGE');
   event = JSON.parse(Buffer.concat(chunks).toString('utf8'));
   if (claimSessionIgnition(event)) process.stdout.write(`${renderMark({ args: process.argv.slice(2) }).join('\n')}\n`);
+  // One nudge toward the catch-up brief per day, only when this project has other recent sessions.
+  // Best effort: a broken suggestion never breaks session start.
+  try {
+    const home = process.env.HOME || homedir();
+    const line = adhdSuggestion({
+      storeDir: join(home, '.grok', 'sessions'),
+      projectRoot: event.realWorkspaceRoot ?? event.workspaceRoot ?? event.cwd ?? process.cwd(),
+      sessionId: event.sessionId ?? process.env.GROK_SESSION_ID,
+      stateRoot: event.realWorkspaceRoot ?? event.workspaceRoot ?? event.cwd ?? process.cwd(),
+    });
+    if (line) process.stdout.write(`${line}\n`);
+  } catch {
+    // No suggestion; session start continues.
+  }
 } catch (error) {
   process.stderr.write(`LitGrok session-start: ${error.code || 'EVENT_INVALID'}\n`);
   process.exitCode = 1;

package/.grok/hooks/workflow-stage.mjs

@@ -60,21 +60,24 @@ const SPACED_PLAN_PATTERN = /^\s*\/?lit\s+plan(?=$|[^\w-])/iu;
 const SPACED_REVIEW_PATTERN = /^\s*\/?lit\s+review(?=$|[^\w-])/iu;
 // Open brainstorming is no workflow stage: it names its own discipline and leaves the row where it was.
 const BRAINSTORM_PATTERN = /^\s*\/?(?:lit-brainstorm|lit\s+(?:brainstorm|brainstorming|ideation|ideate|idea|ideas))(?=$|[^\w-])/iu;
+// Catch-up is no workflow stage either: it names its own discipline and leaves the row where it was.
+const ADHD_PATTERN = /^\s*\/?(?:lit-adhd|lit-rewind|lit\s+(?:adhd|rewind))(?=$|[^\w-])/iu;
 
 /**
  * The stage a prompt names and how it enters it: 'switch' for a named skill (`discipline` is 'lit-plan' for the
  * spaced `lit plan`, null for the spaced `lit review`), 'continue' or 'restart' for lit. A brainstorm prompt
- * carries the discipline 'lit-brainstorm' and no stage.
+ * carries the discipline 'lit-brainstorm' and no stage; a catch-up prompt carries 'lit-adhd' and no stage.
  */
 export function entryFromPrompt(visibleText) {
   if (typeof visibleText !== 'string') return null;
   if (BRAINSTORM_PATTERN.test(visibleText)) return { stage: null, entry: 'switch', discipline: 'lit-brainstorm' };
+  if (ADHD_PATTERN.test(visibleText)) return { stage: null, entry: 'switch', discipline: 'lit-adhd' };
   const match = STAGE_PATTERN.exec(visibleText);
   if (!match) return null;
   const token = match[1].toLowerCase();
   if (token !== 'lit') return { stage: STAGE_OF[token], entry: 'switch' };
   if (SPACED_PLAN_PATTERN.test(visibleText)) return { stage: STAGE_OF['lit-plan'], entry: 'switch', discipline: 'lit-plan' };
-  if (SPACED_REVIEW_PATTERN.test(visibleText)) return { stage: STAGE_OF['review-work'], entry: 'switch', discipline: null };
+  if (SPACED_REVIEW_PATTERN.test(visibleText)) return { stage: STAGE_OF['review-work'], entry: 'switch', discipline: 'review-work' };
   return { stage: STAGE_OF.lit, entry: RESTART_PATTERN.test(visibleText) ? 'restart' : 'continue' };
 }
 

package/.grok/rules/00-litgrok.md

@@ -122,11 +122,24 @@ Exclusions are checked before the trigger and route away even when a video noun
 - (iii) an Office deliverable other than a bare 발표 — 발표자료, 슬라이드, PPT, 덱, 보고서, 문서, slides, deck, pptx, report, document — with 넣, 삽입, embed or insert: that Office skill;
 - (iv) a text or image about a video — 스크립트, 대본, 썸네일, 요약, 기획안, script, transcript, thumbnail, summary, storyboard: its own task;
 - (v) motion on an interface with no video noun — 버튼, 호버, button, hover, motion tokens, reduced motion: `frontend-ui-ux`.
+- (vi) a drawing of real equipment, even as an HTML page or a loop: `lit-schematic`.
 
 Film context: this is a film request. Load `lit-typographic-motion` from `.grok/skills/lit-typographic-motion/` (project) or `~/.grok/skills/lit-typographic-motion/` (user) and write `treatment.json` in the run's output directory first. Path rule: the type path when the words themselves are the film; the stage path for every other film, including anything with shapes, drawn objects, diagrams or imagery; a 9:16 film always takes the stage path. Every frame and track passes through the skill's renderer; hand-encoded films are not the deliverable. Never claim a hook routed the prompt.
 
 Film commands, run from the skill root: `node scripts/motion.mjs` with `make`, `stage`, `sound`, `look`, `gate`, `verify` (each takes `--out <dir>`); a README cover loop uses `cover` and `cover-gate` (references/cover.md); pre-warm outside the session with `npm exec --yes --package @litfamily/litgrok@<installed version> -- litgrok motion-runtime install`.
 
+## Equipment drawings
+
+For an authorized bare `lit` request to draw real process or lab equipment, or `/lit-schematic`, load `lit-schematic` from `.grok/skills/lit-schematic/` (project) or `~/.grok/skills/lit-schematic/` (user). Triggers: P&ID, PFD, BFD, 공정도, 계장도, 장치도, 모식도, 배치도, 계통도, 단면도, apparatus, isometric cutaway, equipment layout. Measured-data plots go to `lit-scientific-visualization`, software or business diagrams to `lit-diagram-drawer`, a report or deck about a drawing to its Office skill, an interface that shows one to `frontend-ui-ux`.
+
+## Brief over sessions
+
+For an authorized bare `lit` request to catch up on every recent session of the repository, or `/lit-adhd` or `/lit-rewind`, load `lit-adhd` from `.grok/skills/lit-adhd/` (project) or `~/.grok/skills/lit-adhd/` (user). Triggers: adhd, rewind, where was I, catch up, 어디까지, 브리핑. It runs read-only and prints the drawn brief; it never edits plans or files. One session's own state is `lit-recap`; many sessions' state is this skill.
+
+## Mechanism ports
+
+For an authorized bare `lit` request to port someone else's published technique into a skill or system, or `/lit-hijack`, load `lit-hijack` from `.grok/skills/lit-hijack/` (project) or `~/.grok/skills/lit-hijack/` (user). Triggers: hijack, hijacking, 하이재킹, 하이잭. The route words directly after `lit` win over trigger or owner words later in the prompt. Finding sources first goes to `litresearch`, planning the port to `lit-plan`, executing it to `start-work`, and reviewing the diff to `review-work`. A request that only draws equipment goes to `lit-schematic` even when it names a port; a topic with no sources goes to `litresearch` first.
+
 ## Office output selection
 
 For an authorized bare `lit` request, choose `lit-docx` for a report, doc, docx, Word, 보고서, 리포트, 기획서, 제안서, 문서, or 워드, and `lit-pptx` for slides, deck, presentation, PPT, pptx, 발표자료, 발표, 슬라이드, 덱, or 피피티. If both groups occur, use both skills. A file asked for as Markdown or plain text (`report.md`, `.txt`) is no Office file: write plain Markdown for its reader, without front matter or `:::` blocks, and load neither skill. Put figures with units or periods in a table and asked-for decisions in a numbered list. Judge the task's intent, not stray quoted words or file contents.

package/.grok/skills/frontend-ui-ux/ATTRIBUTION.md

@@ -0,0 +1,23 @@
+# ATTRIBUTION / NOTICE: frontend-ui-ux craft floor, slop register and interface probe
+
+The craft-floor and slop-register rules (`references/craft-floor.md`,
+`references/slop-register.md`), the interface probe (`scripts/interface-probe.mjs` and its
+modules) and the build, polish, audit and harden modes were written for LitGrok after studying
+public projects, credited below. **No source file, prose, fixture or golden file from any studied
+project is vendored, copied or redistributed here.** A guard test fails if any packed file is
+byte-identical to a listed reference skill file.
+
+The UI/UX Pro Max design data keeps its own notice in `THIRD-PARTY-NOTICE.txt`, which is pinned
+to that dataset's provenance; these credits live here so the two records stay independent.
+
+---
+
+- **jakubkrehel/skills** (https://github.com/jakubkrehel/skills),
+  Copyright (c) 2026 Jakub Krehel, MIT License, consulted at upstream commit `267330e`. Its
+  mode, review-format and routing-governance mechanisms were re-expressed.
+- **ui-skills.com playbook** (https://www.ui-skills.com/playbook), sourced from
+  **ibelick/ui-skills** (https://github.com/ibelick/ui-skills),
+  Copyright (c) 2026 Julien Thibeaut, MIT License. Its anti-slop entries and responsive and
+  polish values were cross-checked and re-expressed.
+
+This file ships as long as those references and the probe ship; remove it only with them.

package/.grok/skills/frontend-ui-ux/SKILL.md

@@ -10,12 +10,13 @@ argument-hint: "<surface and intended outcome>"
 Use Grok Build's selected skill and authorized repository tools. A clear build request proceeds to implementation and rendered inspection; a contract alone is not delivery. Review-only and plan-only requests authorize no edits. Incidental mentions are not requests; infer a bare target only when one frontend is unambiguous.
 
 Read references/production.md when deciding whether to clarify or build.
+Ask a numbered choice of house style first (recommended first); skip only when the prompt names it or says you choose.
 Read references/complete-contract.md for the v1beta2 contract and validation limits.
 Read references/probe-loop.md for the required rendered check and fix cycle.
 
 Record direction and inventory, then implement. Evolve and validate the `litfamily.design-contract/v1beta2` contract as decisions settle; retain its evidence requirements. Respect explicit art direction and existing tokens, or use the authored editorial/pixel profile in the production reference.
 
-Resolve resources from the exact selected SKILL.md parent; bind its absolute path as FRONTEND_SKILL_ROOT and quote it, including spaces. Run scripts/verify-canonical-corpus.mjs before corpus use. Run scripts/validate-design-contract.mjs to validate the task contract. Run scripts/query-design-intelligence.mjs when retrieval helps. Run scripts/import-design-intelligence.mjs before trusting its dataset. See the complete contract for rooted commands.
+Resolve resources from the exact selected SKILL.md parent; bind its absolute path as FRONTEND_SKILL_ROOT and quote it, including spaces. Run scripts/verify-canonical-corpus.mjs before corpus use. Run scripts/validate-design-contract.mjs to validate the task contract. Run scripts/query-design-intelligence.mjs when retrieval helps. Run scripts/import-design-intelligence.mjs before trusting its dataset. Run scripts/design-lock.mjs init --family <landing|workspace|settings> when the lock is missing. Run scripts/pixel-art.mjs init <style-id> to see the pixels first. Run scripts/interface-probe.mjs <built-page-or-directory> --out <task-evidence-directory> when the page stands. See the complete contract for rooted commands.
 
 ## Reference routes
 
@@ -27,6 +28,7 @@ Load references/craft-floor.md when checking numeric craft or responsive rules.
 Load references/composition.md when reading order, columns, or density is undecided.
 Load references/creative-directions.md when comparing visual directions.
 Load references/evidence-review.md when preparing observations or an independent verdict.
+Load references/house-styles.md when naming the style, then lock it with design-lock.
 Load references/implementation-platforms.md when rendering or styling changes.
 Load references/inclusive-interface.md when keyboard, semantics, CJK, IME, or preferences matter.
 Load references/interaction-motion.md when states, feedback, focus, or motion need specification.
@@ -34,6 +36,7 @@ Load references/motion-guide.md when planning animation timing, scroll choreogra
 Load references/operating-lanes.md when selecting or recording the lane.
 Load references/performance-delivery.md when budgets or critical-path evidence matter.
 Load references/product-direction.md when the user, completion condition, or non-goal is unclear.
+Load references/production-interview.md before the production round.
 Load references/redesign-playbook.md when changing an existing visual language.
 Load references/system-foundations.md when token layers or primitives need grounding.
 Load references/slop-register.md when reviewing generic patterns and functional tells.

package/.grok/skills/frontend-ui-ux/examples/phase-3-readme-ab/README.md

@@ -0,0 +1,9 @@
+# Phase 3 README A/B example slot
+
+Add one directory per completed run under this path. Each case directory contains:
+
+- `before.md` and `after.md`: the README copy before and after the design pass.
+- `before.png` and `after.png`: matching screenshots from the same viewport and state.
+
+Record the prompt, viewport, and run date in the case notes. Add a case only after both
+versions have been rendered and reviewed.