@litfamily/lithermes 1.0.7 → 1.0.9

package/assets/lithermes-plugin/core_contract.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import hashlib
 import json
 import re
+import shlex
 from pathlib import Path, PurePosixPath
 
 try:
@@ -28,6 +29,31 @@ LLM_CONTRACT_HEADINGS = (
 _PLUGIN_DIR = Path(__file__).resolve().parent
 _SKILL_BODY_CACHE: dict[str, str] = {}
 
+
+def installed_web_probe_command() -> str:
+    """Render a command for the probe beside this installed plugin module."""
+    probe = _PLUGIN_DIR / "skills/frontend-ui-ux/scripts/probe.mjs"
+    return f'node {shlex.quote(str(probe))} --url "$UI_URL" --out "$UIUX_EVIDENCE_DIR" --static "$PWD"'
+
+
+MOTION_SUBCOMMANDS = "stage|run|sound|look|gate|complete"
+# The neutral film context every motion surface shares. It states the path rule
+# without choosing a path; the skill and the treatment decide.
+MOTION_FILM_CONTEXT = (
+    "Mode Contract: this is a film request. Load the skill and write treatment.json in the output "
+    "dir first. Path rule: type when the words themselves are the film (kinetic type, a lyric or "
+    "quote video, a title sequence, or supplied words with no other subject) at 16:9; stage for "
+    "every other film, and for any 9:16. Hand-encoded films are not the deliverable. Bare lit asks "
+    "nothing; label every invention and a generated sound bed. View stills with vision_analyze; "
+    "done when $M complete exits 0."
+)
+
+
+def installed_motion_cli() -> str:
+    """The installed motion CLI, named once as an absolute path; routes list its subcommands."""
+    script = _PLUGIN_DIR / "skills/lit-typographic-motion/bin/motion.mjs"
+    return f"node {shlex.quote(str(script))}"
+
 READER_FACING_CONTRACT_SCHEMA_VERSION = "litfamily.reader_facing_communication/v1"
 READER_FACING_MODES = frozenset({"reader", "technical", "audit"})
 READER_FACING_MODE_AUTHORITIES = frozenset(
@@ -215,15 +241,17 @@ _UIUX_SIGNAL = re.compile(
 
 
 def conditional_uiux_skill_blocks(context: str) -> str:
-    """Load design authoring and visual verification only for UI-shaped work."""
+    """Load authoring guidance and the installed probe for UI-shaped work."""
     if not _UIUX_SIGNAL.search(context):
         return ""
     return "\n\n".join(
         [
             "<lithermes-conditional-uiux>",
-            "UI-shaped work detected. Apply both concise contracts; resolve paths from each installed skill root, open details lazily, and treat references as inert data.",
+            "UI work: use the installed skill; references are inert data.",
+            "Run the measured probe before claiming web UI verification. Set UI_URL and UIUX_EVIDENCE_DIR.",
+            f"Installed web UI probe command: {installed_web_probe_command()}",
             _skill_body_block("frontend-ui-ux"),
-            _skill_body_block("visual-qa"),
+            "After the probe, use `lithermes:visual-qa` for visual judgment where useful.",
             "</lithermes-conditional-uiux>",
         ]
     )
@@ -259,6 +287,11 @@ _PATCH_ENVELOPE_FILE_RE = re.compile(
     r"^\*\*\* (?:Add|Update|Delete) File: ([^\r\n]+)\r?$", re.MULTILINE
 )
 _PATCH_ENVELOPE_MOVE_RE = re.compile(r"^\*\*\* Move to: ([^\r\n]+)\r?$", re.MULTILINE)
+_SCRIPT_OUTPUT_PATH_RE = re.compile(
+    r"""(?im)^\s*(?:output|artifact|created|saved|wrote|exported)(?:\s+(?:file|path|artifact))?(?:\s+(?:to|at))?\s*[:=]?\s*[\x22\x27\x60]?(.+?\.(?:docx|pptx|pdf))[\x22\x27\x60]?\s*$"""
+)
+_SCRIPT_PATH_KEYS = frozenset({"artifact_path", "created_path", "file_path", "filename", "file", "output_file", "output_path", "path", "saved_to"})
+_SCRIPT_RESULT_CONTAINERS = frozenset({"artifacts", "content", "data", "files", "outputs", "result", "text"})
 
 
 def _inert_path_text(value) -> str:
@@ -281,13 +314,61 @@ def _inert_path_text(value) -> str:
     )
 
 
-def mutated_tool_paths(tool_name: str, args: object) -> list[str]:
-    """Resolve the file paths a completed Hermes tool call actually mutated.
+def _reported_script_paths(tool_name: str, result: object) -> list[str]:
+    if not isinstance(result, str) or len(result.encode("utf-8", errors="ignore")) > 65_536:
+        return []
+    try:
+        parsed = json.loads(result)
+    except (json.JSONDecodeError, TypeError):
+        parsed = result
 
-    Mirrors the tool shapes bounded_work already understands (``write_file`` with
-    ``path``; ``patch`` in ``replace`` mode with ``path`` or in ``patch`` mode with
-    an apply-patch envelope). Read-only and non-file tools resolve to no paths, so
-    they route nothing.
+    tool = str(tool_name or "").casefold()
+    accepts_generic_paths = any(
+        marker in tool for marker in ("terminal", "python", "execute", "script", "shell", "bash", "command")
+    )
+    paths: list[str] = []
+    nodes = 0
+
+    def visit(value: object, depth: int = 0) -> None:
+        nonlocal nodes
+        nodes += 1
+        if nodes > 256 or depth > 6 or len(paths) >= MAX_MUTATED_TOOL_PATHS:
+            return
+        if isinstance(value, str):
+            paths.extend(match.group(1).strip() for match in _SCRIPT_OUTPUT_PATH_RE.finditer(value))
+            return
+        if isinstance(value, dict):
+            for key, child in list(value.items())[:64]:
+                normalized = str(key).casefold()
+                if normalized in _SCRIPT_PATH_KEYS:
+                    if isinstance(child, str) and (
+                        normalized not in {"path", "file_path", "filename", "file"} or accepts_generic_paths
+                    ):
+                        paths.append(child)
+                    elif isinstance(child, (list, tuple)):
+                        paths.extend(
+                            item for item in child
+                            if isinstance(item, str)
+                            and (normalized not in {"path", "file_path", "filename", "file"} or accepts_generic_paths)
+                        )
+                    else:
+                        visit(child, depth + 1)
+                elif normalized in _SCRIPT_RESULT_CONTAINERS:
+                    visit(child, depth + 1)
+        elif isinstance(value, (list, tuple)):
+            for child in value[:64]:
+                visit(child, depth + 1)
+
+    visit(parsed)
+    return paths[:MAX_MUTATED_TOOL_PATHS]
+
+
+def mutated_tool_paths(tool_name: str, args: object, result: object = None) -> list[str]:
+    """Resolve file mutations and explicit script-export receipts.
+
+    write_file and patch expose their target in args. Other tools are considered
+    only when results report an output path or a script-like tool emits a labeled
+    DOCX/PPTX/PDF path.
     """
     payload = args if isinstance(args, dict) else {}
     name = str(tool_name or "").strip()
@@ -306,11 +387,15 @@ def mutated_tool_paths(tool_name: str, args: object) -> list[str]:
                         break
                 if len(raw) >= MAX_MUTATED_TOOL_PATHS:
                     break
+    else:
+        raw = _reported_script_paths(name, result)
     paths: list[str] = []
     for value in raw:
         if value is None:
             continue
         text = str(value)
+        if name not in {"write_file", "patch"}:
+            text = text.strip()
         if text != "" and text not in paths:
             paths.append(text)
         if len(paths) >= MAX_MUTATED_TOOL_PATHS:
@@ -318,6 +403,7 @@ def mutated_tool_paths(tool_name: str, args: object) -> list[str]:
     return paths
 
 
+
 def _post_edit_skill_names(paths) -> list[str]:
     """Condition table for a post-edit event. Returns 0, 1, or 2 skill names."""
     source = False
@@ -392,13 +478,18 @@ def conditional_post_edit_skill_blocks(paths) -> str:
 
 
 KOREAN_PROSE_COMMANDS = (
+    "lit-humanizer",
+)
+KOREAN_PROSE_ALIASES = (
     "lit-korean",
     "text-naturalization",
     "text-neutralization",
+    "korean-ai-slop-remover",
 )
 KOREAN_PROSE_NATURAL_PHRASES = frozenset(
     {
         "korean prose",
+        "lit-humanizer",
         "lit-korean",
         "text naturalization",
         "text neutralization",
@@ -415,10 +506,28 @@ LIT_CONTEXT_BASE = "\n".join(
         "- restate the concrete completion promise before changing files;",
         "- minimum-first is not underbuilding: build the smallest complete solution that satisfies the criteria, including necessary shared helpers, validation, security, accessibility, realistic error handling, and regression tests;",
         "- keep the implementation scoped to the current repository and existing Hermes patterns;",
+        "- Current Hermes working directory is the default output root for files and projects when the user names no destination.",
+        "- Do not copy or install into the account home, even if pwd.getpwuid or another host API reveals it; HOME may be an isolated workspace.",
+        "- Only an explicit user destination authorizes another output root; keep test data and generated files in the current workspace.",
+        "- Use the request language for user-facing artifact text, including CLI help/errors, UI labels, and README instructions, unless the user specifies another language.",
+        "- Derive core actions from the user goal and existing conventions; cover a complete normal use cycle without inventing extra features.",
+        "- Describe deliverables by workspace-relative paths instead of temporary absolute paths when no destination was requested.",
+        "- When storing user data, use stable identity and validated, recoverable writes; do not silently reset malformed storage.",
+        "- Regression tests should reproduce each confirmed failure at its boundary and keep the existing suite green.",
+        "- Update user documentation to match changed behavior and state the supported inputs and outcomes precisely.",
         "- use focused tests and manual verification evidence before claiming done;",
+        "- If this loop creates or changes a user-facing web interface, add its interface and rendered review to the plan, load lithermes:frontend-ui-ux, and run its installed seven-state RS probe before completion. Remaining HIGH findings block done unless reported with a reason; browser exit 2 is BLOCKED, never a pass.",
+        "- A CLI or backend-only change has no web probe step. If interface work emerges later, hand it to frontend-ui-ux at that point.",
         "- preserve unrelated user changes and avoid destructive git commands;",
         "- keep local state, plans, and evidence under plans/ or .hermes/lithermes when useful.",
         "",
+        "<lithermes-final-response>",
+        "The final reply answers the original user task in the language used by its prompt unless requested otherwise.",
+        "Post-processing, cleanup, reviewer, and evidence steps may support the result but must not replace it.",
+        "Lead with the delivered result and the user-visible changes; include verification only where it helps explain confidence or a remaining limit.",
+        "Summarize the material outcome, key changes, verification status, and unresolved risks/actions; keep routine receipts internal unless asked.",
+        "</lithermes-final-response>",
+        "",
         "<lithermes-loop-discipline>",
         "Per success criterion, loop: PIN -> RED -> GREEN -> VERIFY -> SURFACE -> CLEAN -> RECORD.",
         "- RED: write the failing test FIRST; capture the assertion message proving it fails for the right reason.",

package/assets/lithermes-plugin/core_routing.py

@@ -35,7 +35,10 @@ SKILL_RENAME_ALIASES = {
     "git-master": "lit-commit",
     "remove-ai-slops": "lit-burnoff",
     "ai-slop-remover": "lit-burnoff-file",
-    "korean-ai-slop-remover": "lit-korean",
+    "lit-korean": "lit-humanizer",
+    "text-naturalization": "lit-humanizer",
+    "text-neutralization": "lit-humanizer",
+    "korean-ai-slop-remover": "lit-humanizer",
     "programming": "lit-code",
 }
 _RENAMED_ROUTE_ALIASES = {**SKILL_RENAME_ALIASES, "teammode": "lit-team"}
@@ -55,12 +58,16 @@ def _renamed_skill_route(text: str, visible: str, source: str, offset: int = 0)
         match = re.match(rf"^\s*{re.escape(word)}(?![\w-])(?P<rest>.*)$", text, re.IGNORECASE | re.DOTALL)
         if match is not None:
             rest = match.group("rest").strip()
-            if name == "lit-korean":
+            if name == "lit-humanizer":
                 # Only the trigger is parsed as instructions. Retain code spans
                 # and fences in the original prose for the escaped content path.
                 rest = source[offset + match.start("rest"):].strip()
             return NaturalLitRoute(
-                mode={"lit-korean": "korean-prose-cleanup", "lit-team": "kanban-team"}.get(name, name),
+                mode=(
+                    "korean-prose-cleanup" if name == "lit-humanizer" and word in SKILL_RENAME_ALIASES
+                    else "kanban-team" if name == "lit-team"
+                    else name
+                ),
                 objective=_clamp_task(rest),
                 visible_message=visible,
                 deprecation_note=skill_rename_note(word) if word in _RENAMED_ROUTE_ALIASES else "",
@@ -80,6 +87,8 @@ _BARE_SKILL_PREFIXES = (
     ("wikify", "wikify"),
     ("litresearch", "litresearch"),
     ("lit-comprehend", "lit-comprehend"),
+    ("humanizer", "lit-humanizer"),
+    ("lit-humanizer", "lit-humanizer"),
     ("comprehend", "lit-comprehend"),
     ("comment-checker", "comment-checker"),
     ("lsp-setup", "lsp-setup"),
@@ -92,6 +101,10 @@ _BARE_SKILL_PREFIXES = (
     # after case and stays. Both ids are hyphenated compounds, so neither can be
     # reached by an ordinary English sentence; see the token-shape note below.
     ("frontend-ui-ux", "frontend-ui-ux"),
+    ("lit-diagram-drawer", "lit-diagram-drawer"),
+    ("lit-pptx", "lit-pptx"),
+    ("lit-docx", "lit-docx"),
+    ("lit-typographic-motion", "lit-typographic-motion"),
     ("readme-studio", "readme-studio"),
     ("visual-qa", "visual-qa"),
     ("structural-search", "structural-search"),
@@ -134,6 +147,10 @@ _LIT_SKILL_SUFFIXES = (
     ("slop", "lit-burnoff"),
     ("rules", "rules"),
     ("frontend-ui-ux", "frontend-ui-ux"),
+    ("lit-diagram-drawer", "lit-diagram-drawer"),
+    ("lit-pptx", "lit-pptx"),
+    ("lit-docx", "lit-docx"),
+    ("lit-typographic-motion", "lit-typographic-motion"),
     ("readme-studio", "readme-studio"),
     ("visual-qa", "visual-qa"),
     # `design` is safe HERE and only here: the user already typed `lit`, so intent is
@@ -173,7 +190,7 @@ UI_INTENT_VERBS = (
 # as UI surfaces in a sentence but are not path/diff signals.
 UI_INTENT_PROSE_NOUNS = (
     "user interface", "screen", "page", "layout", "modal", "navbar", "sidebar",
-    "stylesheet", "css", "design system", "landing page", "theme", "styling",
+    "stylesheet", "css", "design system", "landing page", "theme", "styling", "web app",
 )
 UI_INTENT_NOUNS = tuple(UI_SURFACE_NOUNS) + UI_INTENT_PROSE_NOUNS
 
@@ -226,7 +243,7 @@ UI_INTENT_NOUNS_KO = (
     # NOTE: UI / UX deliberately absent — they live in UI_INTENT_NOUNS and the
     # shared boundary below already matches them next to a Korean particle.
     # Duplicating them here is the drift hazard this module already fought once.
-    "화면", "페이지", "레이아웃", "대시보드", "사이드바", "모달", "컴포넌트",
+    "화면", "페이지", "레이아웃", "대시보드", "사이드바", "모달", "컴포넌트", "웹앱", r"웹\s+앱",
     "프론트엔드", "스타일시트", "내비게이션", "네비게이션",
     # 버튼 is the only component-level noun here and the only one with a MEASURED
     # containment leak: "버튼식 잠금장치 만들어줘" (a physical push-button lock) fired.
@@ -440,6 +457,125 @@ def detect_ui_intent(text: str) -> bool:
     return has_verb and has_noun
 
 
+def detect_ui_mode(text: str) -> str | None:
+    """Classify a UI request by its requested action; None means another domain."""
+    value = str(text or "")
+    has_ui = bool(_UI_INTENT_NOUN_RE.search(value)) or bool(_UI_INTENT_NOUN_KO_RE.search(value))
+    if not has_ui:
+        return None
+    if re.search(r"(?:^|\W)(?:slides?|deck|pptx?|presentation|video)(?:\W|$)|발표|슬라이드|영상", value, re.IGNORECASE):
+        return None
+    if re.search(r"\b(?:audit|review(?: this page)? read.only|just check|don't fix)\b|점검|검토만|수정.{0,8}하지", value, re.IGNORECASE):
+        if not re.search(r"(?<!don't )\bfix\b|고쳐|수정해", value, re.IGNORECASE):
+            return "audit"
+    if re.search(r"\b(?:harden|stress.test|hold up under|robust to)\b|튼튼하게|견고하게", value, re.IGNORECASE):
+        return "harden"
+    if re.search(r"\b(?:polish|clean up the styling|tighten up)\b|다듬", value, re.IGNORECASE):
+        if not re.search(r"\b(?:redesign|brand.new|add a|create|build|implement)\b|새로|추가해|다시 짜", value, re.IGNORECASE):
+            return "polish"
+    return "build" if detect_ui_intent(value) else None
+
+
+# MO-C-18..20: the motion trigger is a creation verb plus a compound
+# motion-video noun, or plus a bare video noun, with none of five exclusions.
+# The verb half reuses this product's office/UI creation verbs and adds a small
+# motion-specific set they lack (제작, 뽑-, 렌더, render, produce, animate).
+# Bare 모션/motion and 인트로/intro are never nouns here; they count only
+# inside a compound or next to a video noun. Exclusions route to the skill
+# that owns the request instead of silently falling to litwork.
+MOTION_MODE = "lit-typographic-motion"
+_MOTION_VERB = re.compile(
+    r"만들|작성|제작|생성|디자인|뽑|렌더|"
+    r"(?<![A-Za-z])(?:make|create|design|build|generate|render|produce|animate)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_COMPOUND = re.compile(
+    r"모션\s*그래픽|타이포\s*모션|키네틱\s*타이포(?:그래피)?|타이포그래피\s*영상|가사\s*영상|리릭\s*(?:비디오|영상)|"
+    r"뮤직\s*비디오|오프닝\s*타이틀|타이틀\s*시퀀스|"
+    r"(?<![A-Za-z])(?:motion\s+graphics?|kinetic\s+type(?:graphy)?|typographic\s+motion|lyric\s+videos?|"
+    r"music\s+videos?|title\s+sequences?|opening\s+titles?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_VIDEO = re.compile(r"영상|비디오|(?<![A-Za-z])(?:videos?|clips?)(?![A-Za-z])", re.IGNORECASE)
+_MOTION_BARE = re.compile(r"모션|(?<![A-Za-z])motion(?![A-Za-z])", re.IGNORECASE)
+# (i) editing or captioning existing footage
+_MOTION_EDIT = re.compile(
+    r"편집|자막|색\s*보정|트리밍|잘라|자르|촬영본|기존\s*(?:영상|비디오|클립)|"
+    r"(?<![A-Za-z])(?:edit|editing|captions?|subtitles?|trim|crop|colou?r[-\s]?grad(?:e|ing)|footage|existing)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+# (ii) a UI or web container with an embed/insert verb or a background video
+_MOTION_UI_CONTAINER = re.compile(
+    r"페이지|웹\s*사이트|랜딩|화면|컴포넌트|버튼|"
+    r"(?<![A-Za-z])(?:pages?|websites?|landing|screens?|components?|buttons?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_EMBED = re.compile(r"넣|삽입|(?<![A-Za-z])(?:embed\w*|insert\w*)(?![A-Za-z])", re.IGNORECASE)
+_MOTION_BACKGROUND = re.compile(r"배경\s*영상|(?<![A-Za-z])background\s+videos?(?![A-Za-z])", re.IGNORECASE)
+# (iii) an office deliverable other than a bare 발표, with an embed/insert verb
+_MOTION_SLIDES = re.compile(r"발표\s*자료|슬라이드|피피티|덱|(?<![A-Za-z])(?:pptx?|slides?|decks?)(?![A-Za-z])", re.IGNORECASE)
+_MOTION_DOCS = re.compile(r"보고서|문서|(?<![A-Za-z])(?:reports?|documents?)(?![A-Za-z])", re.IGNORECASE)
+# (iv) a text or image artifact about a video
+_MOTION_ABOUT = re.compile(
+    r"스크립트|대본|썸네일|요약|기획안|스토리보드|"
+    r"(?<![A-Za-z])(?:scripts?|transcripts?|thumbnails?|summary|summari[sz]e|storyboards?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+
+
+def motion_route(text: str) -> str | None:
+    """Return the motion mode, the owner an exclusion names, or None."""
+    value = str(text or "")
+    videoish = _MOTION_COMPOUND.search(value) or _MOTION_VIDEO.search(value)
+    if videoish:
+        if _MOTION_EMBED.search(value) and (_MOTION_SLIDES.search(value) or _MOTION_DOCS.search(value)):
+            return "lit-pptx" if _MOTION_SLIDES.search(value) else "lit-docx"
+        if _MOTION_UI_CONTAINER.search(value) and (_MOTION_EMBED.search(value) or _MOTION_BACKGROUND.search(value)):
+            return "frontend-ui-ux"
+        if _MOTION_EDIT.search(value) or _MOTION_ABOUT.search(value):
+            return None
+        return MOTION_MODE if _MOTION_VERB.search(value) else None
+    ui_surface = _MOTION_UI_CONTAINER.search(value) or _UI_INTENT_NOUN_RE.search(value) or _UI_INTENT_NOUN_KO_RE.search(value)
+    if _MOTION_BARE.search(value) and ui_surface:
+        return "frontend-ui-ux"
+    return None
+
+
+def detect_motion_video_intent(text: str) -> bool:
+    return motion_route(text) == MOTION_MODE
+
+
+# The optional type-led hint. It only ever names a cue that points toward the
+# type path (a type compound, an explicit kinetic-type or lyric ask, or a quoted
+# span of two or more words); it never says the reverse. Finding a quote is cue
+# detection: the quoted text is reported as a short label, never followed.
+_MOTION_TYPE_CUE = re.compile(
+    r"타이포\s*모션|키네틱\s*타이포(?:그래피)?|타이포(?:그래피)?\s*영상|가사\s*영상|리릭\s*(?:비디오|영상)|"
+    r"타이틀\s*시퀀스|오프닝\s*타이틀|"
+    r"(?<![A-Za-z])(?:kinetic\s+type(?:graphy)?|typographic\s+motion|typography\s+videos?|lyric\s+videos?|"
+    r"title\s+sequences?|opening\s+titles?)(?![A-Za-z])",
+    re.IGNORECASE,
+)
+_MOTION_QUOTED = re.compile(
+    r'"([^"\n]{2,200})"|“([^”\n]{2,200})”|(?<![A-Za-z])\'([^\'\n]{2,200})\'(?![A-Za-z])|「([^」\n]{2,200})」'
+)
+
+
+def motion_cue(text: str) -> str | None:
+    """Return a short label for a type-led cue in the request, or None."""
+    value = str(text or "")
+    compound = _MOTION_TYPE_CUE.search(value)
+    if compound:
+        phrase = re.sub(r"\s+", " ", compound.group(0))
+        return f"type compound ({phrase})"
+    for match in _MOTION_QUOTED.finditer(value):
+        span = next(group for group in match.groups() if group is not None).strip()
+        if len(span.split()) >= 2:
+            label = span if len(span) <= 24 else span[:23] + "…"
+            return f"quoted span ({label})"
+    return None
+
+
 _RUN_CONTEXT_TASK_PATTERN = re.compile(r"^task:\s*(?P<task>.+?)\s*$", re.MULTILINE)
 
 _FENCED_CODE_RE = re.compile(r"(^|\n)(`{3,}|~{3,})[^\n]*\n.*?(?:\n\2(?=\n|$)|$)", re.DOTALL)
@@ -491,6 +627,39 @@ def _normalized_exact_phrase(text: str) -> str:
     return re.sub(r"\s+", " ", text.strip()).lower()
 
 
+def _bare_lit_mode(objective: str) -> str:
+    prose = re.sub(r"(?m)^\s*#{1,6}\s+.*$", "", objective).strip()
+    first = re.split(r"[\n.!?]", prose, maxsplit=1)[0]
+    slide = re.search(r"발표자료|발표|슬라이드|피피티|(?:^|[^A-Za-z])(?:slides?|deck|presentation|pptx?)(?![A-Za-z])", first, re.IGNORECASE)
+    document = re.search(r"보고서|리포트|기획서|제안서|문서|워드|(?:^|[^A-Za-z])(?:report|docx?|word)(?![A-Za-z])", first, re.IGNORECASE)
+    authoring = re.search(r"만들|작성|써\s*줘|써줘|제작|생성|정리|(?:^|[^A-Za-z])(?:make|create|write|draft|prepare|build|produce|generate)(?![A-Za-z])", first, re.IGNORECASE)
+    # The motion check runs before the office and UI checks (MO-C-18), so a
+    # video noun beside a bare 발표 or 타이포그래피 still reaches motion.
+    motion = motion_route(first)
+    if motion is not None:
+        return motion
+    if authoring and slide:
+        return "lit-pptx"
+    if authoring and document:
+        return "lit-docx"
+    english = re.match(
+        r"^(?:(?:please|can you|could you)\s+)?(?:draw|create|make|design|render|generate)\s+"
+        r"(?P<lead>.{0,120}?)\b(?:diagram|flowchart|flow chart)\b(?P<tail>.*)",
+        first, re.IGNORECASE,
+    )
+    if english and not re.search(
+        r"\b(?:app|page|dashboard|widget|editor|parser|component|tool|api|test)s?\b",
+        english.group("lead") + " " + english.group("tail"), re.IGNORECASE,
+    ):
+        return "lit-diagram-drawer"
+    if re.search(r"(?:다이어그램|흐름도|구성도).{0,60}(?:그려|그리|만들|생성|작성)", first):
+        if not re.search(r"편집기|파서|위젯|대시보드|테스트", first):
+            return "lit-diagram-drawer"
+    if detect_ui_mode(first) is not None:
+        return "frontend-ui-ux"
+    return "litwork"
+
+
 def detect_lit_mode(message: str) -> NaturalLitRoute | None:
     """Route a natural-language LitHermes activation to a native mode.
 
@@ -526,6 +695,17 @@ def detect_lit_mode(message: str) -> NaturalLitRoute | None:
             blocked=True,
             block_message=block,
         )
+    trailing_lit = re.fullmatch(
+        r"(?s)(?P<objective>.+?)\r?\n[ \t]*\r?\n[ \t]*lit[ \t]*(?:\r?\n)?[ \t]*",
+        visible,
+        re.IGNORECASE,
+    )
+    if trailing_lit is not None:
+        return NaturalLitRoute(
+            mode=_bare_lit_mode(trailing_lit.group("objective")),
+            objective=_clamp_task(trailing_lit.group("objective")),
+            visible_message=visible,
+        )
     for word, mode in _BARE_SKILL_PREFIXES:
         matcher = _after_semantic_family_word if mode in _SEMANTIC_FAMILY_MODES else _after_mode_word
         rest = matcher(visible, word)
@@ -592,18 +772,27 @@ def detect_lit_mode(message: str) -> NaturalLitRoute | None:
             ("review", "review-work"),
             ("research", "litresearch"),
             ("goal", "litgoal"),
-            *_LIT_SKILL_SUFFIXES,
+            *(item for item in _LIT_SKILL_SUFFIXES if item[0] != "design"),
         ):
             matcher = _after_semantic_family_word if mode in _SEMANTIC_FAMILY_MODES else _after_mode_word
             rest = matcher(after, word)
             if rest is not None:
                 return NaturalLitRoute(mode=mode, objective=_clamp_task(rest), visible_message=visible)
-        return NaturalLitRoute(mode="litwork", objective=_clamp_task(after), visible_message=visible)
+
+        # After the named routes and before `design` (which names the UI skill):
+        # "lit design a lyric video" is a film request (MO-C-18).
+        if detect_motion_video_intent(re.split(r"[\n.!?]", after, maxsplit=1)[0]):
+            return NaturalLitRoute(mode=MOTION_MODE, objective=_clamp_task(after), visible_message=visible)
+        rest = _after_mode_word(after, "design")
+        if rest is not None:
+            return NaturalLitRoute(mode="frontend-ui-ux", objective=_clamp_task(rest), visible_message=visible)
+        objective = after or visible[:match.start()].strip()
+        return NaturalLitRoute(mode=_bare_lit_mode(objective), objective=_clamp_task(objective), visible_message=visible)
 
     # Lowest precedence, deliberately: an explicit `lit` token or a named skill
     # always wins. Only when nothing else matched does the UI intent conjunction
     # get a say.
-    if detect_ui_intent(visible):
+    if detect_ui_mode(visible) is not None:
         return NaturalLitRoute(
             mode="frontend-ui-ux", objective=_clamp_task(visible), visible_message=visible
         )