@litfamily/litmuse 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## 0.1.3 — 2026-10-28
+
+- After you save a plan, typing `go` within 30 minutes starts it. A plan saved by another session, or an older one, does not.
+- lit-plan checks that every command touching a path outside the project is covered by a `Scope roots:` line, and start-work points to that check. A command quoted in a code block or inline code is treated as text and does not count.
+- The LIT card is clearer about other sessions: running ones come first, then idle ones, each named by its skill and, inside herdr, its pane. A finished start-work stays as done for a minute and then leaves. When a newer LitMuse is installed than the one this session loaded, the card says `restart to <version>`.
+- `lit-adhd` reads your plans before transcripts, keeps finished plans as complete, picks up the `## Next` section of this worktree's handoff, marks sessions as done or idle, and opens with a three-line summary. Its next step no longer repeats one that is already done.
+- A linked git worktree keeps its own `.litmuse` state instead of writing into the main checkout's.
+- New `TRADEMARK.md`: the code stays MIT; the LitMuse and LitFamily names and art are covered there.
+- 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.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.
@@ -158,7 +178,7 @@ The document, diagram, README-cover and figure skills ship pinned engines (`offi
 
 **4 commands**: `/lit <route> <task>`, `/lit-korean <file or text>`, `/lit-status`, `/lit-hud`.
 
-**10 hooks**: SessionStart (LitMuse context and routes; after a compaction it re-injects the saved handoff once, and it adds the answer style you chose with `litmuse style`), UserPromptSubmit (`lit` activation; a later `lit` while its route is active continues it, `lit <other route>` switches, a bare `lit` resumes a started plan, `lit new` or `lit restart` starts over), PreToolUse (during lit-plan: writes through write_file, edit_file, apply_patch or delete_file stay inside `plans/` and `.litmuse/`, shell commands are read-only, and only read-only LitMuse agents may be spawned; on every route: guards against clustered negations and clustered hedges that a write adds to Markdown or text prose), PostToolUse (the tool ledger, plus the whole-line comments an edit added for comment-checker and an advisory lit-humanizer check on written prose; on the motion route it also notes each render and each image `read_file` opened), PostToolUseFailure (ledger), Stop (a lit-plan turn ends after its plan file exists; a motion turn ends when the skill's done-check passes on the last render, or after two holds with a plain not-done notice; start-work keeps going while plan rows are open and litgoal while criteria are open, each at most 3 holds in a row without progress), PreCompact (writes `.litmuse/handoff/latest.md` before Muse compacts), SubagentStart (the return format for child agents), SubagentStop and SessionEnd (ledger lines). The hooks also keep a live record of the route, plan progress and running child agents, which `/lit-status` and `npx @litfamily/litmuse status --card` show, because Muse's `/hud` shows fixed fields only.
+**10 hooks**: SessionStart (LitMuse context and routes; after a compaction it re-injects the saved handoff once, and it adds the answer style you chose with `litmuse style`), UserPromptSubmit (`lit` activation; a later `lit` while its route is active continues it, `lit <other route>` switches, a bare `lit` resumes a started plan, `lit new` or `lit restart` starts over), PreToolUse (during lit-plan: writes through write_file, edit_file, apply_patch or delete_file stay inside `plans/` and `.litmuse/`, shell commands are read-only, and only read-only LitMuse agents may be spawned; on every route: guards against clustered negations and clustered hedges that a write adds to Markdown or text prose), PostToolUse (the tool ledger, plus the whole-line comments an edit added for comment-checker and an advisory lit-humanizer check on written prose; on the motion route it also notes each render and each image `read_file` opened), PostToolUseFailure (ledger), Stop (a lit-plan turn ends after its plan file exists, and a one-word `go` in the same session within 30 minutes then starts that plan with start-work; a motion turn ends when the skill's done-check passes on the last render, or after two holds with a plain not-done notice; start-work keeps going while plan rows are open and litgoal while criteria are open, each at most 3 holds in a row without progress), PreCompact (writes `.litmuse/handoff/latest.md` before Muse compacts), SubagentStart (the return format for child agents), SubagentStop and SessionEnd (ledger lines). The hooks also keep a live record of the route, plan progress and running child agents, plus each session's liveness (PostToolUse says alive, Stop idle, SessionEnd ended), which `/lit-status` and `npx @litfamily/litmuse status --card` show, because Muse's `/hud` shows fixed fields only. The card lists other sessions of the project running first, then idle, keeps a finished start-work as done for a minute, names a herdr pane session `<skill> · <pane>`, and says `restart to <version>` when a newer LitMuse was installed after the session started.
 
 **11 agents**, spawned as `litmuse/<name>`: lit-planner, lit-executor, lit-verifier, qa-runner, quality-reviewer, librarian-researcher, and five Korean prose agents. Reviewers and the Korean agents get read and search tools only.
 
@@ -195,3 +215,5 @@ LitMuse is one of the seven LitFamily packages, and the seven armored robots on
 ## License
 
 MIT, © LitMuse contributors. LitMuse is an independent community project and is not affiliated with or endorsed by Meta.
+
+The LitMuse and LitFamily names, logos and mascot art are covered by [TRADEMARK.md](./TRADEMARK.md).

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라서 개인 스킬이 많은 환경에서도 자리를 지킵니다.
@@ -158,7 +178,7 @@ Muse의 `/hud`는 켜고 끄는 고정 항목 목록이라서 플러그인 글
 
 **명령 4개**: `/lit <경로> <작업>`, `/lit-korean <파일 또는 글>`, `/lit-status`, `/lit-hud`.
 
-**훅 10개**: SessionStart(LitMuse 컨텍스트와 경로 표. 컴팩션 뒤에는 저장해 둔 인계 메모를 한 번 다시 넣고, `litmuse style`로 고른 답변 스타일도 더함), UserPromptSubmit(맨 앞의 `lit` 활성화. 같은 경로가 이미 켜져 있으면 이어서 진행, 다른 경로면 전환, 맨 `lit`은 시작한 계획을 재개, `lit new`·`lit restart`는 새로 시작), PreToolUse(lit-plan 동안 write_file·edit_file·apply_patch·delete_file 쓰기는 `plans/`와 `.litmuse/` 안으로 제한하고 셸 명령은 읽기 전용만 허용, 자식 에이전트는 읽기 전용 LitMuse 에이전트만 허용, 모든 경로에서 쓰기가 Markdown이나 텍스트 글에 새로 더하는 부정문 몰림과 얼버무림 몰림 검사), PostToolUse(도구 기록, 편집이 새로 더한 한 줄 주석을 comment-checker에 넘기고 쓴 글에는 lit-humanizer 참고 검사. 모션 경로에서는 렌더 실행과 `read_file`로 연 이미지도 기록), PostToolUseFailure(기록), Stop(lit-plan 턴은 계획 파일이 생긴 뒤 끝남. 모션 턴은 마지막 렌더가 스킬의 완료 검사를 통과하면 끝나고, 두 번 붙잡은 뒤에는 아직 끝나지 않았다고 분명히 말하게 함. start-work는 계획 행이, litgoal은 기준이 남아 있으면 이어 가되 진전 없이 연속 3번까지만 붙잡음), PreCompact(Muse가 컴팩션하기 전에 `.litmuse/handoff/latest.md`를 씀), SubagentStart(자식 에이전트의 보고 형식), SubagentStop·SessionEnd(기록 줄). 훅은 경로, 계획 진행, 실행 중인 자식 에이전트도 실시간 기록으로 남기며, Muse의 `/hud`는 고정 항목만 보여 주므로 이 기록은 `/lit-status`와 `npx @litfamily/litmuse status --card`로 봅니다.
+**훅 10개**: SessionStart(LitMuse 컨텍스트와 경로 표. 컴팩션 뒤에는 저장해 둔 인계 메모를 한 번 다시 넣고, `litmuse style`로 고른 답변 스타일도 더함), UserPromptSubmit(맨 앞의 `lit` 활성화. 같은 경로가 이미 켜져 있으면 이어서 진행, 다른 경로면 전환, 맨 `lit`은 시작한 계획을 재개, `lit new`·`lit restart`는 새로 시작), PreToolUse(lit-plan 동안 write_file·edit_file·apply_patch·delete_file 쓰기는 `plans/`와 `.litmuse/` 안으로 제한하고 셸 명령은 읽기 전용만 허용, 자식 에이전트는 읽기 전용 LitMuse 에이전트만 허용, 모든 경로에서 쓰기가 Markdown이나 텍스트 글에 새로 더하는 부정문 몰림과 얼버무림 몰림 검사), PostToolUse(도구 기록, 편집이 새로 더한 한 줄 주석을 comment-checker에 넘기고 쓴 글에는 lit-humanizer 참고 검사. 모션 경로에서는 렌더 실행과 `read_file`로 연 이미지도 기록), PostToolUseFailure(기록), Stop(lit-plan 턴은 계획 파일이 생긴 뒤 끝나고, 같은 세션에서 30분 안에 `go` 한 단어를 입력하면 그 계획을 start-work로 시작. 모션 턴은 마지막 렌더가 스킬의 완료 검사를 통과하면 끝나고, 두 번 붙잡은 뒤에는 아직 끝나지 않았다고 분명히 말하게 함. start-work는 계획 행이, litgoal은 기준이 남아 있으면 이어 가되 진전 없이 연속 3번까지만 붙잡음), PreCompact(Muse가 컴팩션하기 전에 `.litmuse/handoff/latest.md`를 씀), SubagentStart(자식 에이전트의 보고 형식), SubagentStop·SessionEnd(기록 줄). 훅은 경로, 계획 진행, 실행 중인 자식 에이전트와 세션별 활동 상태(PostToolUse는 alive, Stop은 idle, SessionEnd는 ended)도 실시간 기록으로 남기며, Muse의 `/hud`는 고정 항목만 보여 주므로 이 기록은 `/lit-status`와 `npx @litfamily/litmuse status --card`로 봅니다. 카드는 같은 프로젝트의 다른 세션을 실행 중인 것부터 쉬는 것 순으로 보여 주고, 끝난 start-work는 1분 동안 done으로 두었다가 지우며, herdr 창 세션은 `<skill> · <pane>`으로 표시하고, 세션 시작 뒤 더 새 LitMuse가 설치되면 `restart to <버전>`을 띄웁니다.
 
 **에이전트 11개**, `litmuse/<이름>`으로 띄웁니다: lit-planner, lit-executor, lit-verifier, qa-runner, quality-reviewer, librarian-researcher, 그리고 한국어 글 에이전트 다섯. 리뷰어와 한국어 에이전트는 읽기와 검색 도구만 씁니다.
 
@@ -195,3 +215,5 @@ LitMuse는 LitFamily 패키지 일곱 개 가운데 하나이고, 표지의 로
 ## 라이선스
 
 MIT, © LitMuse contributors. LitMuse는 독립 커뮤니티 프로젝트이며 Meta와 제휴하거나 Meta의 보증을 받은 프로젝트가 아닙니다.
+
+LitMuse와 LitFamily 이름, 로고, 마스코트 그림에는 [TRADEMARK.md](./TRADEMARK.md)가 적용됩니다.

package/TRADEMARK.md

@@ -0,0 +1,12 @@
+# Trademark policy
+
+The code in this repository is free to use under the MIT License (see `LICENSE`). The names **LitMuse**
+and **LitFamily**, and the logos and mascot art, are not part of that license.
+
+- You can fork, change and share the code under MIT.
+- If you publish a changed version, give it a different name and logo, and do not suggest that the
+  LitMuse maintainers made or endorse it.
+- You can say in plain text that your project is "based on LitMuse" or "a fork of LitMuse".
+- Unchanged copies, such as mirrors and package caches, may keep the name.
+
+Questions: open an issue at https://github.com/wjgoarxiv/litmuse/issues.

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,14 @@
 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 { latestFile, readLiveness, readStage, stageFile, workspaceHash } from '../plugin/hooks/lib/stage.mjs';
+import { newerThan } from '../plugin/hooks/lib/common.mjs';
+import { readManifest } from './bundle.mjs';
+import { paths } from './paths.mjs';
+import { gauge } from '../plugin/lib/rewind/gauge.mjs';
+import { REVIEW_LANES, projectKey, resolveProjectStateRoot } from '../plugin/hooks/lib/workflow-stack.mjs';
+
+// The hooks write `.litmuse` at the project state root, which may sit above the card's cwd.
+const stacksDir = (cwd) => join(resolveProjectStateRoot(cwd), '.litmuse', 'workflow-stack');
 
 export function fmtDuration(ms) {
   const s = Math.max(0, Math.floor(ms / 1000));
@@ -28,9 +36,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 +69,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 +83,168 @@ 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 = stacksDir(cwd);
+    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 other sessions as below), 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,
+});
+
+// Other sessions of this project come from two sources: their fresh workflow stacks and their liveness
+// records (alive, idle, ended, written by the hooks). Each reads `running`, `idle` or `done`; a session
+// that ended, or whose start-work plan is fully ticked, reads `done` for a minute and then leaves the
+// card. Running rows come first, then paused and idle ones, then done; ties keep the name order. A
+// session started in a herdr pane is named `<skill> · <pane>` instead of by its id, and a session with
+// no stack still gets a row (skill from its stage record, else `session`), even as the only row.
+const DONE_SHOW_MS = 60 * 1000;
+const OTHER_RANK = Object.freeze({ running: 0, paused: 1, idle: 1, done: 2 });
+const fileKey = (session) => String(session).replace(/[^A-Za-z0-9_-]/gu, '_').slice(0, 128);
+
+const finishedAt = (frame, live, cwd) => {
+  if (live?.state === 'ended') return Date.parse(live.at);
+  if (frame?.skill === 'start-work' && frame.ref?.plan) {
+    const plan = planProgress(cwd, frame.ref.plan);
+    if (plan && plan.total > 0 && plan.done >= plan.total && Number.isFinite(plan.mtimeMs)) return plan.mtimeMs;
+  }
+  return null;
+};
+
+function otherRows({ cwd, own, names, stacks, env, now, goal }) {
+  const others = new Map();
+  for (const name of names) {
+    const path = join(stacks, name);
+    let mtime = 0;
+    try {
+      mtime = statSync(path).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (now - mtime > SIBLING_FRESH_MS) continue;
+    const top = readStackFile(path)?.frames.at(-1);
+    if (top?.stage) others.set(name.replace(/\.json$/, ''), { frame: top });
+  }
+  const root = projectKey(cwd);
+  for (const live of readLiveness(env)) {
+    if (typeof live.session !== 'string' || typeof live.cwd !== 'string' || live.session === own) continue;
+    if (projectKey(live.cwd) !== root) continue;
+    const entry = others.get(live.session);
+    if (!entry && live.state !== 'ended' && now - Date.parse(live.at) > SIBLING_FRESH_MS) continue;
+    others.set(live.session, { ...entry, live });
+  }
+  const rows = [];
+  for (const [id, { frame, live }] of [...others].sort(([a], [b]) => a.localeCompare(b))) {
+    const done = finishedAt(frame, live, cwd);
+    if (done !== null && !(now - done <= DONE_SHOW_MS)) continue;
+    const word = done !== null ? 'done' : live?.state === 'idle' ? 'idle' : 'running';
+    const route = frame ? null : readStage(stageFile(cwd, id, env))?.route;
+    const row = frame ? frameRow(frame, id, cwd, goal) : { session: id, skill: typeof route === 'string' && route ? route : 'session', stage: null, gauge: '' };
+    // The status word already says running; an unknown count adds nothing.
+    if (row.gauge === gauge(null, null)) row.gauge = '';
+    rows.push({
+      ...row,
+      status: frame?.status === 'paused' && word !== 'done' ? 'paused' : word,
+      pane: typeof live?.pane === 'string' ? live.pane : null,
+      sibling: true,
+    });
+  }
+  return rows.sort((a, b) => OTHER_RANK[a.status] - OTHER_RANK[b.status]);
+}
+
+export function threadRows({ cwd, session, env = process.env, now = Date.now() }) {
+  const goal = activeGoal(cwd);
+  const stacks = stacksDir(cwd);
+  let dir = [];
+  try {
+    dir = readdirSync(stacks);
+  } catch { /* no stacks yet: liveness may still name other sessions */ }
+  const own = session ? fileKey(session) : null;
+  const rows = [];
+  if (own) {
+    const stack = readStackFile(join(stacks, `${own}.json`));
+    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));
+    }
+  }
+  const names = dir.filter((entry) => entry.endsWith('.json') && entry !== `${own}.json`);
+  rows.push(...otherRows({ cwd, own, names, stacks, env, now, goal }));
+  return { rows: rows.slice(0, THREAD_CAP), omitted: Math.max(0, rows.length - THREAD_CAP) };
+}
+
+// The restart chip: the installed bundle carries a newer version than the code this session loaded at
+// SessionStart, so the hooks and skills in use are older until Muse restarts. Unknown either way: no chip.
+function restartTo(rec, env) {
+  if (typeof rec?.loadedVersion !== 'string') return null;
+  try {
+    const installed = readManifest(paths(env).stage).version;
+    return typeof installed === 'string' && newerThan(installed, rec.loadedVersion) ? installed : null;
+  } catch {
+    return null;
+  }
+}
+
 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, env, 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 +252,81 @@ 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),
+    restartTo: restartTo(rec, env),
   };
 }
 
+// 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.restartTo) out.push(`restart to ${card.restartTo}: LitMuse was updated after this session loaded it`);
+  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 name = thread.pane ? `${thread.skill} · ${thread.pane}` : thread.skill;
+      const where = thread.sibling && !thread.pane ? ` (${thread.session})` : '';
+      out.push(`${branch} ${name}${thread.stage ? ` ${thread.stage}` : ''} ${thread.status}${thread.gauge ? ` ${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 +334,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.3",
   "description": "Installer for LitMuse: skills, hooks and agents that help Meta's Muse Code plan, build, check and hand off work.",
   "keywords": [
     "muse",
@@ -47,7 +47,8 @@
     "README.md",
     "README_ko-KR.md",
     "CHANGELOG.md",
-    "LICENSE"
+    "LICENSE",
+    "TRADEMARK.md"
   ],
   "publishConfig": {
     "access": "public"

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

@@ -2,7 +2,7 @@
   "schemaVersion": 1,
   "name": "litmuse",
   "displayName": "LitMuse",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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"
+          "aa3c8c817b3b5263"
         ],
         "timeoutMs": 5000
       },
@@ -247,7 +262,7 @@
           "node",
           "hooks/user-prompt-submit.mjs",
           "--digest",
-          "91a1d749ba4c3fd3"
+          "17cbcfe331b17df6"
         ],
         "timeoutMs": 5000,
         "statusMessage": "LitMuse route check"
@@ -259,7 +274,7 @@
           "node",
           "hooks/pre-tool-use.mjs",
           "--digest",
-          "eedfd1f3ebe5cb38"
+          "a46607c7dd5c7dcd"
         ],
         "timeoutMs": 5000
       },
@@ -270,7 +285,7 @@
           "node",
           "hooks/post-tool-use.mjs",
           "--digest",
-          "dac8628eaa6da79a"
+          "0c70692956033463"
         ],
         "timeoutMs": 5000
       },
@@ -281,7 +296,7 @@
           "node",
           "hooks/post-tool-use-failure.mjs",
           "--digest",
-          "b905e80e38695ee0"
+          "6904dd5da8def1dd"
         ],
         "timeoutMs": 5000
       },
@@ -292,7 +307,7 @@
           "node",
           "hooks/stop.mjs",
           "--digest",
-          "d7f72526de2e1053"
+          "ffd3ec1cb2687eb2"
         ],
         "timeoutMs": 5000
       },
@@ -303,7 +318,7 @@
           "node",
           "hooks/subagent-start.mjs",
           "--digest",
-          "20285c4542661b42"
+          "b97c259487df63c1"
         ],
         "timeoutMs": 5000
       },
@@ -314,7 +329,7 @@
           "node",
           "hooks/subagent-stop.mjs",
           "--digest",
-          "35624765c5646ff0"
+          "6d4dbf1e969d4d7b"
         ],
         "timeoutMs": 5000
       },
@@ -325,7 +340,7 @@
           "node",
           "hooks/session-end.mjs",
           "--digest",
-          "6e0bc285570a4cc2"
+          "b0f6069317813e37"
         ],
         "timeoutMs": 5000
       },
@@ -336,7 +351,7 @@
           "node",
           "hooks/pre-compact.mjs",
           "--digest",
-          "9c089c69dc07f94a"
+          "c844b43a044a2533"
         ],
         "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,8 @@ 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) at the project state root (a linked worktree keeps its own), then other sessions of this project from their fresh stack tops and their liveness records (`stage/liveness/<session>.json`: `alive`, `idle`, `ended`). Other sessions read `running`, `idle` or `done`, running first; a session that ended or whose start-work plan is fully ticked reads `done` for one minute, then leaves; a session in a herdr pane is named `<skill> · <pane>`; a lone other session still gets its row. 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.
+   - Restart chip: when the installed bundle (`$XDG_DATA_HOME/litmuse/bundle/.muse-plugin/plugin.json`) is newer than the `loadedVersion` SessionStart recorded, add `restart to <version>`; when either is unknown, add nothing.
    - 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.