@litfamily/litmuse 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## 0.1.2 — 2026-10-27
+
+- Three new skills, so LitMuse now has 42. `lit-schematic` draws P&IDs with ISA-5.1 tags and control loops, apparatus figures for papers and isometric cutaways, as editable SVG with a QA gate. `lit-hijack` studies a tool you point it at and rebuilds what you want from it clean-room, with a gate after each phase. `lit-adhd` (also `lit-rewind`) is a briefing across your recent Muse sessions: what each one asked, did and is waiting on, with a single next step that a bare `go` picks up.
+- Workflow stacks: a lit route started inside another one pauses the first, and `lit continue` picks it back up. start-work waits for a typed `lit start plans/<name>.md` before it acts on a plan, and a bare `go` follows the next step the brief suggested.
+- The LIT card (`/lit-status`, `litmuse status --card`) shows a row per open thread, an amber `YOUR TURN` headline when Muse waits on you, and a rainbow headline for every way of opening `lit-adhd` (`/lit-adhd`, `/litmuse:lit-adhd`, `lit-rewind`).
+- Slides: five new tonalities (`bauhaus`, `computational-brutalism`, `neo-brutalism`, `newsroom`, `riso`), hero and decoration on every pack, grid zones, and JetBrains Mono as a face for titles and labels beside Pretendard. The slide, document, interface, diagram, schematic, README and film skills ask which theme or style you want before building, unless you already named one or said to choose.
+- Films: house styles, a storyboard board you see before the full render, a 3D stage and an original layered score made for each film.
+- The README has a gallery of real renders from these skills.
+- Security fixes from review: the session brief masks secrets more reliably, including those in URLs and environment values; streamed downloads have size caps; three.js is pinned; and `lit-hijack` and the film asset downloads connect only to the address they checked and re-check every redirect, which closes a DNS-rebinding gap.
+- The hook code changed, so Muse asks you to approve the LitMuse hooks again after the update; `npx @litfamily/litmuse install` lists them and asks once.
+
 ## 0.1.1 — 2026-10-26
 
 - The README studio's HyperFrames and Remotion cover templates pin newer `hono` and `fast-uri` in their lockfiles, picking up upstream fixes. A fresh template setup installs these versions.

package/README.md

@@ -133,6 +133,26 @@ The snapshot names the trigger, the session, the route, the plan with its open r
 
 <p align="center"><img src="./docs/assets/handoff/latest.webp" width="960" alt="The handoff snapshot: trigger, session, the lit-plan route, the plan with 0 ticked and 2 open rows, and recent ledger lines." /></p>
 
+## What you can make
+
+Four real outputs rendered on a Mac during the quality parity round, each opened, read, and fixed until it looked right:
+
+<p align="center"><img src="./docs/assets/parity/lit-adhd-brief.png" width="960" alt="The lit-adhd brief in a real terminal: rainbow headline, one active session card with goal and work time, tools, the finished commit, and a boxed recommended next step." /></p>
+
+`lit-adhd` briefs your live sessions: session cards with status badges, an ended table, and a boxed recommended step — colour on TTY, no internal field names leaking.
+
+<p align="center"><img src="./docs/assets/parity/lit-pptx-deck.png" width="960" alt="A lit-pptx status deck: KPI row and a column chart of suite growth per wave." /></p>
+
+`lit-pptx` compiles real decks from data: this one charts the port's own test-suite growth, wave by wave.
+
+<p align="center"><img src="./docs/assets/parity/lit-schematic-pid.png" width="960" alt="A lit-schematic P&ID: a sodium hypochlorite dosing skid with tank TK-101, duty and standby dosing pumps, a relief-valve spillback, instrument bubbles, line numbers, a drawn-symbol legend, and title block EX-PID-001." /></p>
+
+`lit-schematic` draws QA-checked P&IDs: a dosing skid with real symbols, a drawn legend, line numbers, and a title block — seven look rounds until every label read cleanly.
+
+<p align="center"><img src="./docs/assets/parity/lit-frontend-page.png" width="960" alt="A frontend-ui-ux gallery page: dark ledger, phosphor accents, one plate per render, checked at phone, tablet, and desktop widths." /></p>
+
+`frontend-ui-ux` builds the page around them: one gallery, one plate per render, checked at phone, tablet, and desktop widths.
+
 ## What you get
 
 **39 skills**, each a dense Muse skill loaded on demand, with the references, scripts, templates and engines it needs inside its own folder. The catalog only holds their short descriptions, about 3.7 KB in total, so they keep their place even next to a large personal skill collection.

package/README_ko-KR.md

@@ -133,6 +133,26 @@ Muse의 `/hud`는 켜고 끄는 고정 항목 목록이라서 플러그인 글
 
 <p align="center"><img src="./docs/assets/handoff/latest.webp" width="960" alt="인계 스냅샷. 실행 계기와 세션, lit-plan 경로, 0개 체크와 2개 열린 행의 계획, 최근 기록 줄을 보여 줍니다." /></p>
 
+## 만들 수 있는 것
+
+품질 패리티 라운드에서 Mac에서 직접 렌더한 결과물 4종입니다. 파일을 열어 눈으로 읽고, 어색한 곳은 고쳐 다시 렌더했습니다.
+
+<p align="center"><img src="./docs/assets/parity/lit-adhd-brief.png" width="960" alt="실제 터미널의 lit-adhd 브리프. 무지개 헤드라인, 목표와 작업 시간이 적힌 활성 세션 카드 하나, 도구, 완료된 커밋, 박스형 권장 다음 단계." /></p>
+
+`lit-adhd`는 실행 중 세션을 브리핑합니다. 상태 뱃지가 달린 세션 카드와 종료 표, 박스형 권장 다음 단계 — 터미널 색상 그대로, 내부 필드 이름은 새지 않습니다.
+
+<p align="center"><img src="./docs/assets/parity/lit-pptx-deck.png" width="960" alt="lit-pptx 상태 덱. KPI 행과 웨이브별 스위트 증가 막대 차트." /></p>
+
+`lit-pptx`는 자료로 실제 덱을 엮습니다. 이 덱은 포팅 웨이브별 테스트 스위트 증가를 그립니다.
+
+<p align="center"><img src="./docs/assets/parity/lit-schematic-pid.png" width="960" alt="lit-schematic P&ID. 탱크 TK-101, 상용·예비 도징 펌프, 릴리프 밸브 스필백, 계장 버블, 라인 번호, 심벌 범례, EX-PID-001 타이틀 블록을 갖춘 차아염소산나트륨 도징 스키드." /></p>
+
+`lit-schematic`은 QA를 통과한 P&ID를 그립니다. 실제 심벌과 범례, 라인 번호, 타이틀 블록을 갖춘 도징 스키드이며, 모든 라벨이 읽힐 때까지 일곱 번 고쳐 그렸습니다.
+
+<p align="center"><img src="./docs/assets/parity/lit-frontend-page.png" width="960" alt="frontend-ui-ux 갤러리 페이지. 어두운 원장과 형광 악센트, 렌더마다 플레이트 하나, 휴대전화·태블릿·데스크톱 너비에서 확인." /></p>
+
+`frontend-ui-ux`는 이를 감싸는 페이지를 만듭니다. 렌더 한 종마다 플레이트 하나인 갤러리이며, 휴대전화·태블릿·데스크톱 너비에서 확인했습니다.
+
 ## 들어 있는 것
 
 **스킬 39개.** 필요할 때 불러오는 밀도 높은 Muse 스킬이며, 각 스킬에 필요한 참고 문서, 스크립트, 템플릿, 엔진이 그 스킬 폴더 안에 함께 들어 있습니다. 카탈로그에는 짧은 설명만 올라가며, 모두 합쳐 약 3.7 KB라서 개인 스킬이 많은 환경에서도 자리를 지킵니다.

package/bin/litmuse.mjs

@@ -13,6 +13,7 @@ import { checkUpdate } from '../lib/update-check.mjs';
 import { runtime } from '../lib/runtime.mjs';
 import { buildCard, renderCard } from '../lib/stage-card.mjs';
 import { styleCommand } from '../lib/style.mjs';
+import { runRewindCli } from '../plugin/lib/rewind/collect.mjs';
 
 const HELP = `LitMuse ${packageVersion()}: LitFamily workflows for Meta's Muse Code
 
@@ -26,6 +27,7 @@ Commands
   hud          Show the recommended /hud and /theme preset
   style        eli5 | asd-ste100 | off | status: the answer style LitMuse adds to every session
   runtime      status [name] | install <name|all>: the pinned engine runtimes, cached under the LitMuse data dir
+  rewind       Cross-session brief records [--json] [--here] [--since 7d] [--max 12] [--session <id>]
   uninstall    Remove the plugin from Muse and the staged bundle
   help         This text
 
@@ -97,6 +99,8 @@ async function main() {
       return models({ env, flags, print });
     case 'runtime':
       return runtime({ env, flags, args, print });
+    case 'rewind':
+      return runRewindCli(flags.json ? [...args, '--json'] : args, process.cwd(), { env });
     case 'hud':
       print(readFileSync(join(PACKAGE_ROOT, 'docs', 'hud-preset.md'), 'utf8'));
       return 0;

package/lib/stage-card.mjs

@@ -1,6 +1,8 @@
 import { readFileSync, readdirSync, statSync, existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { latestFile, readStage, stageFile, workspaceHash } from '../plugin/hooks/lib/stage.mjs';
+import { gauge } from '../plugin/lib/rewind/gauge.mjs';
+import { REVIEW_LANES } from '../plugin/hooks/lib/workflow-stack.mjs';
 
 export function fmtDuration(ms) {
   const s = Math.max(0, Math.floor(ms / 1000));
@@ -28,9 +30,16 @@ export function planProgress(cwd, planFile) {
     const rows = [...readFileSync(join(cwd, file), 'utf8').matchAll(/^- \[([ xX])\] (\d+)\.\s*(.*)$/gm)];
     if (!rows.length) return null;
     const open = rows.find((r) => r[1] === ' ');
+    let mtimeMs = null;
+    try {
+      mtimeMs = statSync(join(cwd, file)).mtimeMs;
+    } catch {
+      // Readable just now but stat fails: freshness stays unknown.
+    }
     return {
       file, total: rows.length, done: rows.filter((r) => r[1] !== ' ').length,
       next: open ? { row: Number(open[2]), text: open[3].slice(0, 120) } : null,
+      mtimeMs,
     };
   } catch {
     return null;
@@ -54,6 +63,7 @@ export function activeGoal(cwd) {
       slug: best.g.slug ?? null, objective: String(best.g.objective ?? '').slice(0, 200),
       met: criteria.filter((c) => c.status === 'pass').length, total: criteria.length,
       open: criteria.filter((c) => c.status !== 'pass').map((c) => ({ id: c.id, text: String(c.text ?? '').slice(0, 120) })),
+      mtimeMs: best.m,
     };
   } catch {
     return null;
@@ -67,10 +77,109 @@ export function loadStage({ cwd, session, env = process.env }) {
   return entry && entry.session ? readStage(stageFile(cwd, entry.session, env)) : null;
 }
 
+// One rainbow-tinted line at most: a static ANSI gradient, no animation, no blinking, no
+// full-field luminance swing, so it stays flash-safe on any terminal. It marks the adhd turn.
+const RAINBOW = [196, 208, 226, 46, 51, 21, 201];
+export function rainbowLine(text) {
+  let color = 0;
+  let out = '';
+  for (const ch of String(text)) {
+    out += ch === ' ' ? ch : `\u001b[38;5;${RAINBOW[color++ % RAINBOW.length]}m${ch}`;
+  }
+  return `${out}\u001b[0m`;
+}
+
+// Fresh workflow stacks mean recent sessions worth briefing: any stack file touched in 24 h.
+export function freshStacks(cwd, now = Date.now()) {
+  try {
+    const dir = join(cwd, '.litmuse', 'workflow-stack');
+    const day = 24 * 60 * 60 * 1000;
+    return readdirSync(dir).some((name) => name.endsWith('.json') && now - statSync(join(dir, name)).mtimeMs <= day);
+  } catch {
+    return false;
+  }
+}
+
+// Thread rows for the status card, read from the workflow stacks at render time. Every count
+// resolves from exactly one source, in this order: the frame's recorded k/n, the named plan's
+// rows, the active goal's criteria, otherwise the indeterminate pulse. Frames without a stage
+// (a pure `record` spine) and frames older than 24 h are dropped; sibling sessions older than
+// 15 minutes are skipped. Order is fixed (own stack, then siblings by file name), so a repaint
+// with no change is byte-identical.
+const THREAD_CAP = 6;
+const THREAD_STALE_MS = 24 * 60 * 60 * 1000;
+const SIBLING_FRESH_MS = 15 * 60 * 1000;
+
+const readStackFile = (path) => {
+  try {
+    const text = readFileSync(path, 'utf8');
+    if (text.length > 64 * 1024) return null;
+    const parsed = JSON.parse(text);
+    return Array.isArray(parsed.frames) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
+
+const frameGauge = (frame, cwd, goal) => {
+  if (Number.isInteger(frame.n) && Number.isInteger(frame.total)) return gauge(frame.n, frame.total);
+  if (frame.ref?.plan) {
+    const plan = planProgress(cwd, frame.ref.plan);
+    if (plan) return gauge(plan.done, plan.total);
+  }
+  if (goal) return gauge(goal.met, goal.total);
+  return gauge(null, null);
+};
+
+const frameRow = (frame, session, cwd, goal) => ({
+  session,
+  skill: typeof frame.skill === 'string' ? frame.skill : 'unknown',
+  stage: typeof frame.stage === 'string' ? frame.stage : null,
+  status: frame.status === 'paused' ? 'paused' : 'active',
+  gauge: frameGauge(frame, cwd, goal),
+  verdicts: frame.verdicts && typeof frame.verdicts === 'object' ? { ...frame.verdicts } : undefined,
+});
+
+export function threadRows({ cwd, session, now = Date.now() }) {
+  const goal = activeGoal(cwd);
+  let dir = null;
+  try {
+    dir = readdirSync(join(cwd, '.litmuse', 'workflow-stack'));
+  } catch {
+    return [];
+  }
+  const own = session ? `${String(session).replace(/[^A-Za-z0-9_-]/gu, '_').slice(0, 128)}.json` : null;
+  const rows = [];
+  if (own) {
+    const stack = readStackFile(join(cwd, '.litmuse', 'workflow-stack', own));
+    for (const frame of stack?.frames ?? []) {
+      if (!frame.stage) continue;
+      if (frame.at && now - Date.parse(frame.at) > THREAD_STALE_MS) continue;
+      rows.push(frameRow(frame, session, cwd, goal));
+    }
+  }
+  for (const name of dir.filter((entry) => entry.endsWith('.json') && entry !== own).sort()) {
+    const path = join(cwd, '.litmuse', 'workflow-stack', name);
+    let mtime = 0;
+    try {
+      mtime = statSync(path).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (now - mtime > SIBLING_FRESH_MS) continue;
+    const stack = readStackFile(path);
+    const top = stack?.frames.at(-1);
+    if (!top?.stage) continue;
+    rows.push({ ...frameRow(top, name.replace(/\.json$/, ''), cwd, goal), sibling: true });
+  }
+  return { rows: rows.slice(0, THREAD_CAP), omitted: Math.max(0, rows.length - THREAD_CAP) };
+}
+
 export function buildCard({ cwd, session, env = process.env, now = Date.now() }) {
   const rec = loadStage({ cwd, session, env });
   const goal = activeGoal(cwd);
-  if (!rec) return { active: false, route: null, goal, plan: planProgress(cwd, null), lanes: [], now };
+  const threads = threadRows({ cwd, session: rec?.session ?? session ?? null, now });
+  if (!rec) return { active: false, route: null, goal, plan: planProgress(cwd, null), lanes: [], threads, idle: freshStacks(cwd, now), now, noColor: Boolean(env.NO_COLOR) };
   const lanes = (rec.lanes ?? []).map((l) => ({
     id: l.id, type: l.type, status: l.status,
     elapsedMs: (l.endedAt ?? now) - l.startedAt,
@@ -78,15 +187,78 @@ export function buildCard({ cwd, session, env = process.env, now = Date.now() })
   return {
     active: Boolean(rec.route), route: rec.route ?? null, keyword: rec.keyword ?? null, kind: rec.kind ?? null,
     session: rec.session ?? null, activeMs: rec.route && rec.activatedAt ? now - rec.activatedAt : null,
-    plan: planProgress(cwd, rec.plan ?? null), lanes, goal, updated: rec.updated ?? null, now,
+    plan: planProgress(cwd, rec.plan ?? null), lanes, goal, threads, idle: !rec.route && freshStacks(cwd, now), updated: rec.updated ?? null, now, noColor: Boolean(env.NO_COLOR),
   };
 }
 
+// Skill looks (BRIEF-mod-looks). Static TTY only: colour plus a label, never animation —
+// the host has no card animation surface, and NO_COLOR strips even the static colour.
+// The registry maps a card state to its headline paint; the lanes strip and the done burst
+// are extra lines drawn from real reports only, never placeholders.
+const paint = (code, text, color) => (color ? `\u001b[${code}m${text}\u001b[0m` : text);
+
+// Waiting on the user: a paused thread, or a lane that reported failure. A turn where the
+// model asked a question but left no tool state is not visible to the card.
+const waitingOf = (card) => (card.threads?.rows ?? []).some((row) => row.status === 'paused')
+  || (card.lanes ?? []).some((lane) => lane.status === 'failed');
+
+const headlineFor = (card, color) => {
+  if (!card.active) return 'LIT · no active route in this workspace';
+  const route = card.route ?? 'lit-loop';
+  if (waitingOf(card)) return paint('33;1', `LIT · ${route} · YOUR TURN`, color);
+  if (route === 'lit-adhd') return color ? rainbowLine('LIT · lit-adhd · brief on screen') : 'LIT · lit-adhd · brief on screen';
+  return `LIT · ${route}${card.activeMs !== null ? ` · active ${fmtDuration(card.activeMs)}` : ''}${card.kind && card.kind !== 'ignite' ? ` (${card.kind})` : ''}`;
+};
+
+// Canonical review-lane display names, in REVIEW_LANES order; the strip reads the same
+// list, so the two cannot drift apart.
+const REVIEW_LANE_LABELS = Object.freeze({ goal: 'scope', quality: 'package', security: 'security', qa: 'tests+evidence', context: 'surface' });
+const VERDICT_DOT = Object.freeze({ pass: ['32;1', '●'], fail: ['31;1', '●'], running: ['33;1', '◐'], pending: ['33', '○'] });
+
+const laneSegment = (id, verdict, color) => {
+  const label = REVIEW_LANE_LABELS[id] ?? id;
+  const known = verdict ? VERDICT_DOT[verdict] : null;
+  if (!known) return paint('2', `${label} ○`, color);
+  return paint(known[0], `${label} ${known[1]}`, color);
+};
+
+const lanesStrip = (card, color) => {
+  const frame = (card.threads?.rows ?? []).find((row) => row.skill === 'review-work' && row.verdicts);
+  const verdicts = frame?.verdicts ?? {};
+  return `review lanes: ${REVIEW_LANES.map(({ id }) => laneSegment(id, verdicts[id], color)).join(' · ')}`;
+};
+
+// Static TTY cannot play a one-shot animation and settle: a freshly completed plan or goal
+// prints one celebratory line until the freshness window passes, then the card settles on
+// its own. A published release has no signal the card can see.
+const BURST_FRESH_MS = 15 * 60 * 1000;
+const burstOf = (card, now) => {
+  const plan = card.plan;
+  if (plan && plan.total > 0 && plan.done >= plan.total && Number.isFinite(plan.mtimeMs) && now - plan.mtimeMs <= BURST_FRESH_MS) {
+    return `✨ done: ${plan.file} · ${plan.done}/${plan.total} rows ticked ✨`;
+  }
+  const goal = card.goal;
+  if (goal && goal.total > 0 && goal.met >= goal.total && Number.isFinite(goal.mtimeMs) && now - goal.mtimeMs <= BURST_FRESH_MS) {
+    return `✨ goal done: ${goal.objective} ✨`;
+  }
+  return null;
+};
+
 export function renderCard(card) {
   const out = [];
-  out.push(card.active
-    ? `LIT · ${card.route}${card.activeMs !== null ? ` · active ${fmtDuration(card.activeMs)}` : ''}${card.kind && card.kind !== 'ignite' ? ` (${card.kind})` : ''}`
-    : 'LIT · no active route in this workspace');
+  const color = !card.noColor;
+  out.push(headlineFor(card, color));
+  if (!card.active && card.idle) out.push('idle — say `lit adhd` for the cross-session brief');
+  const threads = card.threads?.rows ?? [];
+  if (threads.length) {
+    out.push('threads:');
+    threads.forEach((thread, index) => {
+      const branch = index === threads.length - 1 && !card.threads.omitted ? '└─' : '├─';
+      const where = thread.sibling ? ` (${thread.session})` : '';
+      out.push(`${branch} ${thread.skill}${thread.stage ? ` ${thread.stage}` : ''} ${thread.status} ${thread.gauge}${where}`);
+    });
+    if (card.threads.omitted) out.push(`+${card.threads.omitted} more`);
+  }
   if (card.plan) {
     out.push(`plan ${card.plan.done}/${card.plan.total} · ${card.plan.file}${card.plan.next ? ` · next ${card.plan.next.row}. ${card.plan.next.text}` : ' · all rows ticked'}`);
   }
@@ -94,9 +266,12 @@ export function renderCard(card) {
   const finished = card.lanes.filter((l) => l.status !== 'running');
   if (running.length) out.push(`lanes running: ${running.map((l) => `${l.type} ${fmtDuration(l.elapsedMs)}`).join(', ')}`);
   if (finished.length) out.push(`lanes finished: ${finished.map((l) => `${l.type} ${l.status} ${fmtDuration(l.elapsedMs)}`).join(', ')}`);
+  if (card.route === 'review-work') out.push(lanesStrip(card, color));
   if (card.goal) {
     out.push(`goal: ${card.goal.objective} (${card.goal.met}/${card.goal.total} criteria met)`);
     for (const c of card.goal.open.slice(0, 5)) out.push(`  open ${c.id}: ${c.text}`);
   }
+  const burst = burstOf(card, card.now ?? Date.now());
+  if (burst) out.push(burst);
   return out.join('\n');
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@litfamily/litmuse",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Installer for LitMuse: skills, hooks and agents that help Meta's Muse Code plan, build, check and hand off work.",
   "keywords": [
     "muse",

package/plugin/.muse-plugin/plugin.json

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "name": "litmuse",
   "displayName": "LitMuse",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "LitFamily workflows for Muse Code: bare lit activation, planning, evidence-bound execution, review, research, handoff and Korean prose care.",
   "compat": {
     "source": "native",
@@ -115,6 +115,16 @@
         "path": "skills/lit-handoff/SKILL.md",
         "enabledDefault": true
       },
+      {
+        "id": "lit-hijack",
+        "path": "skills/lit-hijack/SKILL.md",
+        "enabledDefault": true
+      },
+      {
+        "id": "lit-adhd",
+        "path": "skills/lit-adhd/SKILL.md",
+        "enabledDefault": true
+      },
       {
         "id": "lit-init",
         "path": "skills/lit-init/SKILL.md",
@@ -150,6 +160,11 @@
         "path": "skills/lit-diagram-drawer/SKILL.md",
         "enabledDefault": true
       },
+      {
+        "id": "lit-schematic",
+        "path": "skills/lit-schematic/SKILL.md",
+        "enabledDefault": true
+      },
       {
         "id": "lit-typographic-motion",
         "path": "skills/lit-typographic-motion/SKILL.md",
@@ -236,7 +251,7 @@
           "node",
           "hooks/session-start.mjs",
           "--digest",
-          "b8961789243b3149"
+          "11ba46df6010f4d8"
         ],
         "timeoutMs": 5000
       },
@@ -247,7 +262,7 @@
           "node",
           "hooks/user-prompt-submit.mjs",
           "--digest",
-          "91a1d749ba4c3fd3"
+          "c55594062398b5ea"
         ],
         "timeoutMs": 5000,
         "statusMessage": "LitMuse route check"
@@ -259,7 +274,7 @@
           "node",
           "hooks/pre-tool-use.mjs",
           "--digest",
-          "eedfd1f3ebe5cb38"
+          "b98a3b323bb1756c"
         ],
         "timeoutMs": 5000
       },
@@ -270,7 +285,7 @@
           "node",
           "hooks/post-tool-use.mjs",
           "--digest",
-          "dac8628eaa6da79a"
+          "1aae7c29d41747b8"
         ],
         "timeoutMs": 5000
       },
@@ -281,7 +296,7 @@
           "node",
           "hooks/post-tool-use-failure.mjs",
           "--digest",
-          "b905e80e38695ee0"
+          "3f1b940d78192ff9"
         ],
         "timeoutMs": 5000
       },
@@ -292,7 +307,7 @@
           "node",
           "hooks/stop.mjs",
           "--digest",
-          "d7f72526de2e1053"
+          "0bd9020bf0bbc1af"
         ],
         "timeoutMs": 5000
       },
@@ -303,7 +318,7 @@
           "node",
           "hooks/subagent-start.mjs",
           "--digest",
-          "20285c4542661b42"
+          "6694ead2b6e3ac2b"
         ],
         "timeoutMs": 5000
       },
@@ -314,7 +329,7 @@
           "node",
           "hooks/subagent-stop.mjs",
           "--digest",
-          "35624765c5646ff0"
+          "023daac9ec9f7aeb"
         ],
         "timeoutMs": 5000
       },
@@ -325,7 +340,7 @@
           "node",
           "hooks/session-end.mjs",
           "--digest",
-          "6e0bc285570a4cc2"
+          "18f92d375de7d7b0"
         ],
         "timeoutMs": 5000
       },
@@ -336,7 +351,7 @@
           "node",
           "hooks/pre-compact.mjs",
           "--digest",
-          "9c089c69dc07f94a"
+          "dfdcd29de71fafe0"
         ],
         "timeoutMs": 5000
       }

package/plugin/commands/lit-status.md

@@ -1,5 +1,5 @@
 ---
-description: "Read-only LIT card for this workspace: route, time active, plan n/m, running lanes, goal, last handoff"
+description: "Read-only LIT card for this workspace: route, plan n/m, lanes, threads, goal, last handoff"
 argument-hint: "[slug]"
 ---
 Print the LitMuse status card for this workspace. Scope: $ARGUMENTS (empty means everything). Write nothing.
@@ -9,6 +9,7 @@ Print the LitMuse status card for this workspace. Scope: $ARGUMENTS (empty means
    - Route and time active: the newest record from `latest.json` (route, activatedAt, kind), or else the `route` on the last line of the newest `.litmuse/ledger/*.jsonl`.
    - Plan: the plan named in the record, or else the newest `plans/*.md`. Count `- [x] N.` against all `- [ ] N.` and `- [x] N.` rows, and name the first open row.
    - Lanes: the record's `lanes` entries with `status` running, done or failed, and their elapsed time (`endedAt` or now, minus `startedAt`).
+   - Threads: `.litmuse/workflow-stack/<session>.json` frames (paused spines above running sides) plus other sessions' fresh paused tops: a real gauge when the count is known, the `… N steps` fact line otherwise — never a placeholder. Six rows at most, then `+N more`; an idle card offers `lit adhd` instead.
    - Goal: each `.litmuse/goals/*.json` whose status is `active`, with its objective and the criteria that are not `pass`.
 3. Add the first lines of `.litmuse/handoff/latest.md` if present, and the count of tool events and failures in the newest ledger.
 

package/plugin/commands/lit.md

@@ -6,7 +6,7 @@ LitMuse route request: $ARGUMENTS
 
 Treat the line above as a LitMuse request; the prompt hook has already recorded its route.
 
-1. The first word picks the route: loop → lit-loop, plan → lit-plan, work → litwork, goal → litgoal, research → litresearch, review → review-work, start → start-work, recap → lit-recap, status → lit-recap, handoff → lit-handoff, init → lit-init, debug → debugging, interview → deep-interview, crucible → lit-crucible, commit → lit-commit, refactor → refactor, burnoff → lit-burnoff, burnoff-file → lit-burnoff-file, brainstorm → lit-brainstorm, brainstorming → lit-brainstorm, ideation → lit-brainstorm, ideate → lit-brainstorm, idea → lit-brainstorm, ideas → lit-brainstorm, team → lit-team, conference → autoconference, rules → rules, lsp → lsp, diagnostics → lsp, lsp-setup → lsp-setup, motion → lit-typographic-motion, film → lit-typographic-motion, video → lit-typographic-motion, 영상 → lit-typographic-motion, explain → lit-comprehend, humanize → lit-humanizer, korean → lit-humanizer, 다듬어 → lit-humanizer, 윤문 → lit-humanizer. Any other first word means lit-loop, except a task that asks to make a film (a film compound such as kinetic type, lyric video, title sequence, cover loop, 모션그래픽, 가사 영상, or a bare video noun with a making verb), which goes to lit-typographic-motion. Skills without a keyword (frontend-ui-ux, readme-studio, visual-qa, comment-checker, wikify, autoresearch, structural-search, browser-drive, lit-code) are reached through lit-loop or their own `/<skill>` command.
+1. The first word picks the route: loop → lit-loop, plan → lit-plan, work → litwork, goal → litgoal, research → litresearch, review → review-work, start → start-work, recap → lit-recap, status → lit-recap, handoff → lit-handoff, init → lit-init, debug → debugging, interview → deep-interview, crucible → lit-crucible, commit → lit-commit, refactor → refactor, burnoff → lit-burnoff, burnoff-file → lit-burnoff-file, brainstorm → lit-brainstorm, brainstorming → lit-brainstorm, ideation → lit-brainstorm, ideate → lit-brainstorm, idea → lit-brainstorm, ideas → lit-brainstorm, hijack → lit-hijack, hijacking → lit-hijack, 하이재킹 → lit-hijack, 하이잭 → lit-hijack, adhd → lit-adhd, rewind → lit-adhd, approve → start-work, deny → start-work, team → lit-team, conference → autoconference, rules → rules, lsp → lsp, diagnostics → lsp, lsp-setup → lsp-setup, motion → lit-typographic-motion, film → lit-typographic-motion, video → lit-typographic-motion, 영상 → lit-typographic-motion, explain → lit-comprehend, humanize → lit-humanizer, korean → lit-humanizer, 다듬어 → lit-humanizer, 윤문 → lit-humanizer. Any other first word means lit-loop, except a task that asks to make a film (a film compound such as kinetic type, lyric video, title sequence, cover loop, 모션그래픽, 가사 영상, or a bare video noun with a making verb), which goes to lit-typographic-motion. Skills without a keyword (frontend-ui-ux, readme-studio, visual-qa, comment-checker, wikify, autoresearch, structural-search, browser-drive, lit-code) are reached through lit-loop or their own `/<skill>` command.
 2. Load that skill with read_skill using the id `plugin:litmuse:<route>` before any other tool, and follow it. When the hook context says the route is already active or resuming, skip steps 2 and 3: keep the criteria, plan and ledger you have.
 3. Your first output, before any tool call or other text, is the line `🔥 **LIT IGNITED · <route>** 🔥` on its own line, once. When the hook context says the route continues, the line is `🔥 **LIT CONTINUES · <route>** 🔥` instead.
 4. Report in reader mode: the result, any material risk, and the action the user must take.

package/plugin/hooks/lib/digest.mjs

@@ -10,7 +10,7 @@ const PLUGIN = join(LIB, '..', '..');
 
 // Files outside hooks/lib that a hook loads at run time: PostToolUse runs the lit-humanizer detector, and Stop runs the
 // lit-typographic-motion done-check with every engine module it imports.
-const MOTION_DONE = ['node/done.mjs', 'node/cover-assets.mjs', 'core/constants.mjs', 'node/chrome.mjs', 'node/cover-image.mjs', 'node/cover-treatment.mjs', 'node/treatment.mjs', 'node/sound.mjs', 'core/util.mjs', 'node/look.mjs', 'node/stills.mjs', 'node/analysis.mjs', 'core/flash.mjs', 'node/png.mjs'];
+const MOTION_DONE = ['node/done.mjs', 'node/cover-assets.mjs', 'core/constants.mjs', 'node/chrome.mjs', 'node/cover-image.mjs', 'node/cover-treatment.mjs', 'node/treatment.mjs', 'node/sound.mjs', 'node/house.mjs', 'node/styles.mjs', 'node/score.mjs', 'core/presets.mjs', 'core/util.mjs', 'node/look.mjs', 'node/stills.mjs', 'node/analysis.mjs', 'core/flash.mjs', 'node/png.mjs'];
 export const DIGEST_EXTRAS = ['skills/lit-humanizer/scripts/core.mjs', 'skills/lit-humanizer/rules.json', ...MOTION_DONE.map((f) => `skills/lit-typographic-motion/engine/${f}`)];
 
 const listed = (dir, ext) => readdirSync(dir).filter((f) => f.endsWith(ext)).sort().map((f) => join(dir, f));

package/plugin/hooks/lib/next-step.mjs

@@ -0,0 +1,68 @@
+// The `go` half of the lit-adhd brief: the collector writes this session's next-step record
+// under `.litmuse/adhd/`, and a later whole-prompt `go` reads it back and deletes it. The session
+// binding is the file name, so another session's record is never opened. A step older than 30
+// minutes is stale: the brief it came from no longer describes the work.
+import { closeSync, constants, fstatSync, openSync, readFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+
+import { workspaceOf } from './common.mjs';
+import { resolveProjectStateRoot } from './workflow-stack.mjs';
+
+// The whole prompt, nothing more: `go`, `lit go`, `ㄱㄱ`, `고` or `진행`, with trailing punctuation.
+const GO_PROMPT = /^\s*(?:(?:lit\s+)?go|ㄱㄱ|고|진행)[\s.!?]*$/iu;
+export const isGoPrompt = (prompt) => typeof prompt === 'string' && prompt.length <= 64 && GO_PROMPT.test(prompt);
+
+export const NEXT_STEP_MAX_AGE_MS = 30 * 60_000;
+const KINDS = new Set(['resume-frame', 'approve-boundary', 'continue-work', 'start-plan', 'none']);
+
+const nextStepFile = (cwd, sessionId) => {
+  const id = String(sessionId ?? 'session').replace(/[^A-Za-z0-9_-]/gu, '_').slice(0, 128) || 'session';
+  return join(resolveProjectStateRoot(cwd), '.litmuse', 'adhd', `next-${id}.json`);
+};
+
+/**
+ * Reads and deletes this session's next-step record. Returns `{kind, target}` when the record is
+ * whole and at most 30 minutes old, otherwise null; a stale or unreadable record is deleted all
+ * the same. Never throws.
+ */
+export const takeNextStep = (payload, now = Date.now()) => {
+  const sessionId = typeof payload?.session_id === 'string' && payload.session_id ? payload.session_id : null;
+  if (!sessionId) return null;
+  let cwd = null;
+  try {
+    cwd = workspaceOf(payload);
+  } catch {
+    return null;
+  }
+  if (!cwd) return null;
+  const path = nextStepFile(cwd, sessionId);
+  let text;
+  try {
+    const fd = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try {
+      const stat = fstatSync(fd);
+      if (!stat.isFile() || stat.size > 16_384) return null;
+      text = readFileSync(fd, 'utf8');
+    } catch {
+      return null;
+    } finally {
+      try {
+        closeSync(fd);
+      } catch { /* already closed */ }
+    }
+  } catch {
+    return null;
+  } finally {
+    try {
+      unlinkSync(path);
+    } catch { /* nothing to consume */ }
+  }
+  try {
+    const record = JSON.parse(text);
+    const age = now - Date.parse(record.at);
+    if (!KINDS.has(record.kind) || !(age >= -60_000 && age <= NEXT_STEP_MAX_AGE_MS)) return null;
+    return { kind: record.kind, target: record.target && typeof record.target === 'object' ? record.target : null };
+  } catch {
+    return null;
+  }
+};