lithermes-ai 0.5.1 → 0.8.0

package/README.md

@@ -57,12 +57,14 @@ Restart any running Hermes CLI or Hermes gateway process. Then open Hermes and t
 - Interactive install spinner keeps terminal installs lively while redirected or scripted installs stay plain; use `npx lithermes-ai install --yes --no-spinner` for quiet terminal installs.
 - `start-work`: open or dry-run a LitHermes plan inside Hermes.
 - LitHermes workflow skill set: `ai-slop-remover`, `comment-checker`,
-  `debugging`, `frontend-ui-ux`, `lsp`, `programming`, `refactor`,
+  `debugging`, `deep-interview`, `frontend-ui-ux`, `git-master`, `init-deep`,
+  `lsp`, `programming`, `refactor`,
   `remove-ai-slops`, `review-work`, `rules`, `start-work`, `lit-plan`,
   `litgoal`, and `litwork` are installed as `lithermes:*` skills.
-- The full plugin payload — the `pre_llm_call` / `subagent_stop` /
-  `on_session_start` hooks, every skill, and the durable goal tooling — ships in
-  the bundle exactly as installed, so each release is reproducible and auditable.
+- The full plugin payload — the `pre_llm_call` / `subagent_stop` hooks, every
+  skill, and the durable goal tooling — ships in the bundle exactly as installed,
+  so each release is reproducible and auditable. Repo-rule loading is handled by
+  Hermes' native context-files feature, not a LitHermes hook.
 
 ## Requirements
 

package/README_Ko-KR.md

@@ -57,10 +57,11 @@ npx lithermes-ai install --yes
 - interactive install spinner가 terminal 설치는 더 생동감 있게 보여주고, redirect/script 설치는 기존처럼 plain output을 유지합니다. 조용한 terminal 설치가 필요하면 `npx lithermes-ai install --yes --no-spinner`를 사용합니다.
 - `start-work`: LitHermes plan을 Hermes 작업으로 엽니다.
 - LitHermes workflow skill set: `ai-slop-remover`, `comment-checker`,
-  `debugging`, `frontend-ui-ux`, `lsp`, `programming`, `refactor`,
+  `debugging`, `deep-interview`, `frontend-ui-ux`, `git-master`, `init-deep`,
+  `lsp`, `programming`, `refactor`,
   `remove-ai-slops`, `review-work`, `rules`, `start-work`, `lit-plan`,
   `litgoal`, `litwork`가 `lithermes:*` skill로 함께 설치됩니다.
-- 전체 plugin payload — `pre_llm_call` / `subagent_stop` / `on_session_start`
+- 전체 plugin payload — `pre_llm_call` / `subagent_stop`
   hook, 모든 skill, durable goal tooling — 이 설치 상태 그대로 번들에 들어가므로,
   각 릴리스는 재현 가능하고 감사할 수 있습니다.
 

package/assets/lithermes-plugin/README.md

@@ -14,7 +14,9 @@ first-class Hermes skills:
   session goal manager; criteria + evidence use the durable `goal_*` tools.
 - Explicit skills are available as:
   `lithermes:ai-slop-remover`, `lithermes:comment-checker`,
-  `lithermes:debugging`, `lithermes:frontend-ui-ux`, `lithermes:lsp`,
+  `lithermes:debugging`, `lithermes:deep-interview`,
+  `lithermes:frontend-ui-ux`, `lithermes:git-master`,
+  `lithermes:init-deep`, `lithermes:lsp`,
   `lithermes:programming`, `lithermes:refactor`,
   `lithermes:remove-ai-slops`, `lithermes:review-work`,
   `lithermes:rules`, `lithermes:start-work`, `lithermes:lit-plan`,
@@ -36,5 +38,6 @@ plugins:
 The bundled workflow reference is adapted for LitHermes command names and
 Hermes gateway behavior. LitHermes runs entirely on Hermes-native primitives
 (`delegate_task`, the durable `goal_*` tools, and the `pre_llm_call` /
-`subagent_stop` / `on_session_start` hooks) and ships no external
-prompt-runtime installer in the plugin payload.
+`subagent_stop` hooks) and ships no external
+prompt-runtime installer in the plugin payload. Repo-rule loading is handled by
+Hermes' native context-files feature, not a LitHermes hook.

package/assets/lithermes-plugin/__init__.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import functools
 from pathlib import Path
 from typing import Any
 
@@ -22,10 +23,22 @@ PORTED_SKILLS = [
         "debugging",
         "Run the LitHermes hypothesis-driven debugging workflow.",
     ),
+    (
+        "deep-interview",
+        "Run the LitHermes Socratic deep-interview clarity gate before planning.",
+    ),
     (
         "frontend-ui-ux",
         "Apply the LitHermes frontend UI/UX review discipline.",
     ),
+    (
+        "git-master",
+        "Run the LitHermes git-history specialist for commits, rebases, blame, and bisect.",
+    ),
+    (
+        "init-deep",
+        "Generate a hierarchical AGENTS.md knowledge base with the LitHermes onboarding workflow.",
+    ),
     (
         "lsp",
         "Use Hermes' native LSP diagnostics with LitHermes LSP guidance.",
@@ -103,6 +116,16 @@ def _handle_lithermes_cli(args) -> int:
     return 1
 
 
+def _ignited(handler):
+    """Wrap a slash-command handler so its display prints the LITBURN banner."""
+
+    @functools.wraps(handler)
+    def wrapped(user_args):
+        return core.ignite(handler(user_args))
+
+    return wrapped
+
+
 def register(ctx) -> None:
     base = Path(__file__).resolve().parent
 
@@ -124,52 +147,58 @@ def register(ctx) -> None:
 
     ctx.register_command(
         "lit-plan",
-        core.command_lit_plan,
+        _ignited(core.command_lit_plan),
         description="Create a durable Litwork implementation plan",
         args_hint='"what to build"',
     )
     ctx.register_command(
         "litwork-plan",
-        core.command_lit_plan,
+        _ignited(core.command_lit_plan),
         description="Alias for /lit-plan",
         args_hint='"what to build"',
     )
     ctx.register_command(
         "lit",
-        core.command_lit,
+        _ignited(core.command_lit),
         description="Start an Litwork run and execute the task immediately",
         args_hint='"task" [--completion-promise TEXT] [--strategy reset|continue]',
     )
     ctx.register_command(
         "lit-loop",
-        core.command_lit_loop,
+        _ignited(core.command_lit_loop),
         description="Start an Litwork run and execute the task immediately",
         args_hint='"task" [--completion-promise TEXT] [--strategy reset|continue]',
     )
     ctx.register_command(
         "litwork-loop",
-        core.command_lit_loop,
+        _ignited(core.command_lit_loop),
         description="Alias for /lit-loop",
         args_hint='"task" [--completion-promise TEXT] [--strategy reset|continue]',
     )
     ctx.register_command(
         "litgoal",
-        core.command_litgoal,
+        _ignited(core.command_litgoal),
         description="Open or inspect the LitHermes litgoal durable runtime",
         args_hint='["objective"] [--worktree PATH]',
     )
     ctx.register_command(
         "review-work",
-        core.command_review_work,
+        _ignited(core.command_review_work),
         description="Run the LitHermes 5-lane review orchestrator on the current diff",
         args_hint="[--base REF]",
     )
     ctx.register_command(
         "start-work",
-        core.command_start_work,
+        _ignited(core.command_start_work),
         description="Open or dry-run a LitHermes plan against a workspace",
         args_hint="[plan-name] [--worktree PATH] [--dry-run]",
     )
+    ctx.register_command(
+        "deep-interview",
+        _ignited(core.command_deep_interview),
+        description="Run the LitHermes Socratic clarity gate before planning/execution",
+        args_hint="[--quick|--standard|--deep] <idea>",
+    )
 
     for name, description in PORTED_SKILLS:
         ctx.register_skill(

package/assets/lithermes-plugin/core.py

@@ -33,9 +33,16 @@ DIRECT_LIT_PATTERN = re.compile(r"^\s*(?:lit|litwork)\b\s+(?P<task>.+?)\s*$", re
 MAX_TASK_LEN = 4000
 _SLUG_PATTERN = re.compile(r"[^a-z0-9]+")
 
+# Deterministic ignite banner. Printed verbatim on every LitHermes slash-command
+# display (the only user-visible plugin channel); also instructed into LIT_CONTEXT
+# for the bare-`lit` keyword path (best-effort — that path only reaches the model).
+LITBURN_BANNER = "🔥 LITBURN IGNITED 🔥"
+
+
 LIT_CONTEXT = "\n".join(
     [
         "<lithermes-litwork>",
+        f"FIRST, open your reply with this exact line so the user sees Litwork engage: {LITBURN_BANNER}",
         "The user invoked Litwork/LitHermes. Operate in a durable, evidence-first loop:",
         "- restate the concrete completion promise before changing files;",
         "- keep the implementation scoped to the current repository and existing Hermes patterns;",
@@ -210,9 +217,53 @@ def _extract_run_context_task(message: str) -> str:
     return _clamp_task(m.group("task")) if m else ""
 
 
+# Slash-command handlers are dispatched as handler(user_args) with NO session_id,
+# so they cannot bind the native /goal themselves. They instead embed this marker
+# in their agent_message; pre_llm_call (which DOES receive session_id) reads it and
+# performs the bind. /lit & /lit-loop bind via the run-context block; /litgoal &
+# /lit-plan declare an objective and bind via this marker.
+_BIND_GOAL_PATTERN = re.compile(
+    r"<lithermes-bind-goal>(?P<obj>.+?)</lithermes-bind-goal>", re.DOTALL
+)
+
+
+def _extract_bind_goal(message: str) -> str:
+    m = _BIND_GOAL_PATTERN.search(message)
+    return _clamp_task(m.group("obj")) if m else ""
+
+
+def bind_goal_marker(objective: str) -> str:
+    """Render the bind-goal marker a command embeds so pre_llm_call binds /goal."""
+    objective = (objective or "").strip()
+    return f"<lithermes-bind-goal>{objective}</lithermes-bind-goal>" if objective else ""
+
+
+def ignite(result: str | dict[str, str]) -> str | dict[str, str]:
+    """Prepend the LITBURN banner to a command result's user-visible display.
+
+    ``display`` is the one channel Hermes prints to the user verbatim
+    (cli.py _cprint), so the banner deterministically fires on every LitHermes
+    slash command. agent_message (model-facing) is left untouched.
+    """
+    if isinstance(result, dict):
+        display = result.get("display")
+        if display and not str(display).startswith(LITBURN_BANNER):
+            return {**result, "display": f"{LITBURN_BANNER}\n{display}"}
+        return result
+    if isinstance(result, str) and result.strip() and not result.startswith(LITBURN_BANNER):
+        return f"{LITBURN_BANNER}\n{result}"
+    return result
+
+
 def pre_llm_call(**kwargs: Any) -> dict[str, str] | None:
     user_message = str(kwargs.get("user_message") or "")
     session_id = str(kwargs.get("session_id") or "")
+    # /litgoal & /lit-plan declare an objective via the bind-goal marker. Bind it
+    # (we have session_id here) and stop — those messages are self-contained.
+    bind_obj = _extract_bind_goal(user_message)
+    if bind_obj:
+        bind_native_goal(session_id, bind_obj)
+        return None
     # The /lit command injects a run-context message. Bind the native goal from
     # it (we have session_id here), then skip re-injecting context.
     if "<lithermes-run-context>" in user_message:
@@ -629,6 +680,7 @@ def build_plan_agent_message(brief: str, plan: Path, workspace: Path) -> str:
             "goal tools (goal_set / goal_add_criterion / goal_evidence / goal_complete) and inspect",
             "with `hermes lithermes goal status`.",
             "</lithermes-plan-context>",
+            bind_goal_marker(brief),
         ]
     )
 
@@ -799,12 +851,58 @@ def command_litgoal(raw_args: str) -> dict[str, str]:
         "Load the lithermes:litgoal skill for the full discipline.",
         "</lithermes-litgoal-command>",
     ]
+    # When an objective is given, bind the native /goal too (pre_llm_call reads
+    # this marker — slash handlers have no session_id). Inspect-only /litgoal
+    # (no objective) leaves any active goal untouched.
+    marker = bind_goal_marker(objective)
+    if marker:
+        agent_lines.append(marker)
     return {
         "display": f"{intro}\nState dir: {lithermes_dir(workspace) / 'litgoal'}",
         "agent_message": "\n".join(agent_lines),
     }
 
 
+def command_deep_interview(raw_args: str) -> dict[str, str]:
+    args = parse_args(raw_args)
+    workspace = workspace_from_option(args.options.get("worktree"))
+    # `--quick|--standard|--deep` are bare profile flags, but parse_args greedily
+    # binds the next bare word as a flag value — so `--quick build a widget` would
+    # consume "build". Recover any such word back into the idea text.
+    profile = "standard"
+    for flag in ("deep", "quick", "standard"):
+        value = args.options.get(flag)
+        if value:
+            profile = flag
+            if isinstance(value, str):
+                args.positional.insert(0, value)
+            break
+    idea = _join_positional(args.positional)
+    agent_lines = [
+        idea or "Run a deep-interview clarification pass before planning.",
+        "",
+        "<lithermes-deep-interview-command>",
+        f"workspace: {workspace}",
+        f"profile: {profile}",
+        "Run the LitHermes deep-interview clarity gate — load the lithermes:deep-interview skill",
+        "and follow it. This is a requirements mode, NOT implementation:",
+        "- one Socratic question per round, intent before detail; re-score ambiguity each round;",
+        "- gather repo facts with read-only search / delegate_task before asking the user;",
+        "- keep Non-goals + Decision Boundaries explicit and run one pressure pass before crystallizing;",
+        "- persist state under .hermes/lithermes/deep-interview/<slug>-state.json so it can resume.",
+        "When the spec is ready, do NOT build here — hand off: /lit-plan to plan it, or /lit-loop to",
+        "execute it, carrying the non-goals, decision boundaries, and acceptance criteria forward.",
+        "</lithermes-deep-interview-command>",
+    ]
+    return {
+        "display": (
+            f"Opened the LitHermes deep-interview clarity gate ({profile} profile).\n"
+            "Requirements mode — clarifies, then hands off to /lit-plan or /lit-loop."
+        ),
+        "agent_message": "\n".join(agent_lines),
+    }
+
+
 def command_start_work(raw_args: str) -> str | dict[str, str]:
     args = parse_args(raw_args)
     workspace = workspace_from_option(args.options.get("worktree"))

package/assets/lithermes-plugin/payload-version.json

@@ -1,15 +1,23 @@
 {
-  "syncedAt": "2026-06-13T16:58:49.114Z",
+  "syncedAt": "2026-06-14T03:56:58.019Z",
   "source": "source-reference",
-  "sourceHash": "367df25c50e5d54bb516cda93fe453be2ec0821924be0136dfbb9e24b117494a",
+  "sourceHash": "23886fd1b52dc30433f8886ba15ccedbc3d134ba8f0b99b7a90a83d07c0351fe",
   "files": [
+    {
+      "path": "NOTICE.md",
+      "sha256": "452ad24ca1ecd65e2f2ab0f21ff6c1cefb13aacf0db875f327b62027106685ab"
+    },
+    {
+      "path": "README.md",
+      "sha256": "e0bc7d60f61a8d35df9f6287876e236e59e80e871261558701375a12cc4e4feb"
+    },
     {
       "path": "__init__.py",
-      "sha256": "3e6b2e469e0ff805391ee741e640274e58e15da330f6d7eec4b0e06618755cfd"
+      "sha256": "14951813219a77f7074ff8ca36e26cc46b66b0987f28dbcf1827c9bcfa98d65c"
     },
     {
       "path": "core.py",
-      "sha256": "8fa2e7263e99c16fbb337df468d769890df1d98e2683614646b243dbd23c3ff2"
+      "sha256": "da2888e70b560697eaf81fe29d0b92a36e8e0563ab3bcab95c34472533faa937"
     },
     {
       "path": "litgoal/__init__.py",
@@ -39,17 +47,9 @@
       "path": "litgoal/tools.py",
       "sha256": "2e12124666c4dab32087af11c76c970656077e449cca1dbb4f299bab2efdd24a"
     },
-    {
-      "path": "NOTICE.md",
-      "sha256": "452ad24ca1ecd65e2f2ab0f21ff6c1cefb13aacf0db875f327b62027106685ab"
-    },
     {
       "path": "plugin.yaml",
-      "sha256": "a0410a79f149a0c6b3a8de49bc2c19a1b73123e4a272390f2f4bceafe0df4bb2"
-    },
-    {
-      "path": "README.md",
-      "sha256": "d67b9f8d74aa861483cc28144eefc417493a3d2ac3cf6a6204c77235886b6d6c"
+      "sha256": "4b8a31a093d883cf1714250564955c3d8ca87889887780515a7df15ed317e732"
     },
     {
       "path": "skills/ai-slop-remover/SKILL.md",
@@ -57,7 +57,11 @@
     },
     {
       "path": "skills/comment-checker/SKILL.md",
-      "sha256": "5e87a8f2b11f2a2068297cf77a1690b2eb9bc8ab45c4106668f2bdca1ca2f6db"
+      "sha256": "2fb1c4de76d1cc340b63f92141d36d0a351325d9c9411b9af622dd8b6fca5567"
+    },
+    {
+      "path": "skills/debugging/SKILL.md",
+      "sha256": "aff2ca5765f490ed1e45d2eaa77c48db3ef98cec12fa10ebff3f91b82eab1254"
     },
     {
       "path": "skills/debugging/references/methodology/00-setup.md",
@@ -132,13 +136,21 @@
       "sha256": "0123de928e1e88186487adfee0b69d7a886c596fdd0c5132256cf9319fea466e"
     },
     {
-      "path": "skills/debugging/SKILL.md",
-      "sha256": "aff2ca5765f490ed1e45d2eaa77c48db3ef98cec12fa10ebff3f91b82eab1254"
+      "path": "skills/deep-interview/SKILL.md",
+      "sha256": "4f8e7217b72724921cdc68b5214cc99d7b45ec51fd05b237fac20c75fc35988c"
     },
     {
       "path": "skills/frontend-ui-ux/SKILL.md",
       "sha256": "914667044f135563658ceac733a085a6bbdd71a00a5f4030f73d43444e0388f7"
     },
+    {
+      "path": "skills/git-master/SKILL.md",
+      "sha256": "31d59a91767423094fd84ed668c8b8c7e14d515cd17e3845d91a0ce4aa0144c8"
+    },
+    {
+      "path": "skills/init-deep/SKILL.md",
+      "sha256": "f571334ad9150fd93ef57fcc9dd85d240812649975811e63045ff2a72e84260b"
+    },
     {
       "path": "skills/lit-plan/SKILL.md",
       "sha256": "1f09901f9bb8f19b92add59c3613231228c8b5b7adbefae1cb3eb5cf7c3c61dc"
@@ -159,6 +171,14 @@
       "path": "skills/lsp/SKILL.md",
       "sha256": "3e793aaa158156dd60ec11add7375050bbeeb7b3eb77497f1c432d0842abff5c"
     },
+    {
+      "path": "skills/programming/SKILL.md",
+      "sha256": "ffb201197e7386c848f8efb9b90d0a024d7b8000e8bea1b13b0ed7a83627a56b"
+    },
+    {
+      "path": "skills/programming/references/go/README.md",
+      "sha256": "faedb8ab4e13f4ff03ad3497f3ed44df1b5b71463b741a58ee61b60ddb68b188"
+    },
     {
       "path": "skills/programming/references/go/backend-stack.md",
       "sha256": "1ba7769bfe7cd7a001251fabf01133a9df7eaae700705eecb3261955e4cfbfa9"
@@ -203,10 +223,6 @@
       "path": "skills/programming/references/go/one-liners.md",
       "sha256": "ff354a8700a9987ad21f4fb0cf4d5695857cae093c42358bc3eef13826f8ddfb"
     },
-    {
-      "path": "skills/programming/references/go/README.md",
-      "sha256": "faedb8ab4e13f4ff03ad3497f3ed44df1b5b71463b741a58ee61b60ddb68b188"
-    },
     {
       "path": "skills/programming/references/go/sqlc-pgx.md",
       "sha256": "26243d7b26e3ffadce87b4f78739e6582c69d5c144af89f2ef55c076b5e1b399"
@@ -219,6 +235,10 @@
       "path": "skills/programming/references/go/type-patterns.md",
       "sha256": "87d930ed6cdc57b3c20aae802679a4f419f77b5fcf4a630a6973271cc62545c7"
     },
+    {
+      "path": "skills/programming/references/python/README.md",
+      "sha256": "23ef4282a10fce99de314ddc3c8d93eca79c92f256c87cf8caa54a2ee703e738"
+    },
     {
       "path": "skills/programming/references/python/async-anyio.md",
       "sha256": "26e069cfc9debf45ff1629d0246a6831c64a33f8e595976f8cb19d4b5647ca95"
@@ -263,10 +283,6 @@
       "path": "skills/programming/references/python/pyproject-strict.md",
       "sha256": "655eb106a165d3730d656a9689ac98a00abf7d32cc89f2decaf33ddf43ac0e45"
     },
-    {
-      "path": "skills/programming/references/python/README.md",
-      "sha256": "23ef4282a10fce99de314ddc3c8d93eca79c92f256c87cf8caa54a2ee703e738"
-    },
     {
       "path": "skills/programming/references/python/textual-tui.md",
       "sha256": "bf59c001a76b30777882b2c729321d809a2a81bf75b720e72da1c38a3e7708d9"
@@ -275,18 +291,22 @@
       "path": "skills/programming/references/python/type-patterns.md",
       "sha256": "4fa0bf3c7e82c6a7141c54aac9e1703cd9ce86122903dbe2fe00700930ca4626"
     },
-    {
-      "path": "skills/programming/references/rust-ub/miri-sanitizers-loom.md",
-      "sha256": "b3b56208978286dd975440fa1f28d01b9ed05b23d33a1faaa904e62ca310c4e8"
-    },
     {
       "path": "skills/programming/references/rust-ub/README.md",
       "sha256": "25300ebe1a467f47695959b00964ded8c560e51bb5d92dffe178f9d3f24b87a9"
     },
+    {
+      "path": "skills/programming/references/rust-ub/miri-sanitizers-loom.md",
+      "sha256": "b3b56208978286dd975440fa1f28d01b9ed05b23d33a1faaa904e62ca310c4e8"
+    },
     {
       "path": "skills/programming/references/rust-ub/ub-taxonomy.md",
       "sha256": "7c0b369732920f6e59e67fa2f7a9a10fa4ba5b0a23b95ddd1aa2c4011a661326"
     },
+    {
+      "path": "skills/programming/references/rust/README.md",
+      "sha256": "7502ee277c86df00388ea7cdbc5b54fc743d4eacab8b4015cd00ad0483ead727"
+    },
     {
       "path": "skills/programming/references/rust/async-tokio.md",
       "sha256": "48e54d0b4be71fe1765e9bc62e0073a767abd966e29d4b456ae1326d0dc7b760"
@@ -319,10 +339,6 @@
       "path": "skills/programming/references/rust/proptest-insta.md",
       "sha256": "be787a4e174f55062931b70c53027a6c46423e3473608b315ac800b52325c3d1"
     },
-    {
-      "path": "skills/programming/references/rust/README.md",
-      "sha256": "7502ee277c86df00388ea7cdbc5b54fc743d4eacab8b4015cd00ad0483ead727"
-    },
     {
       "path": "skills/programming/references/rust/type-state.md",
       "sha256": "3dc21686fa0b2f1cb0c6206e38b800aa8b9ecf482d02faa9c1c4fd925da051e5"
@@ -335,6 +351,10 @@
       "path": "skills/programming/references/rust/zero-cost-safety.md",
       "sha256": "a03623f9e0d80cdb5c2addddb97b27932c84adb5232b2d659442ba5e74e37bbb"
     },
+    {
+      "path": "skills/programming/references/typescript/README.md",
+      "sha256": "c54f997b70659b574ce805196aefd9978354da5f73d5fdb6defbce1abf11041e"
+    },
     {
       "path": "skills/programming/references/typescript/backend-hono.md",
       "sha256": "7df19dd33da142423412ad4a0fa67a8b800e79d200adc62e20d05bcb15ff8e4f"
@@ -351,10 +371,6 @@
       "path": "skills/programming/references/typescript/error-handling.md",
       "sha256": "5d99ea45d454723b1d8292357a7a20b434801101336863df89e000c67bf1e807"
     },
-    {
-      "path": "skills/programming/references/typescript/README.md",
-      "sha256": "c54f997b70659b574ce805196aefd9978354da5f73d5fdb6defbce1abf11041e"
-    },
     {
       "path": "skills/programming/references/typescript/tsconfig-strict.md",
       "sha256": "e844903aa4dcf9c5e45592eccbbf04d6146c602c70067c72be74f523b0e2134d"
@@ -383,6 +399,14 @@
       "path": "skills/programming/scripts/go/templates/AGENTS.md.tmpl",
       "sha256": "ac81f2614b1417dfc5b0ca21c40ee74c357b55a97c92cb02db84ac418587c744"
     },
+    {
+      "path": "skills/programming/scripts/go/templates/README.md.tmpl",
+      "sha256": "b0780490defb300a8ec5cd46555074ab58f9147d298964ff5ce2a40d24dde066"
+    },
+    {
+      "path": "skills/programming/scripts/go/templates/Taskfile.yml",
+      "sha256": "eb59766ea776398a4109383dc279c13673dbad3645f1a2a4f70da92bd08f48b6"
+    },
     {
       "path": "skills/programming/scripts/go/templates/ci.yml",
       "sha256": "8403a5a4dd6d55773aa651600dc95d01bfc2462ce6756903ec3d2a4330371df7"
@@ -399,18 +423,10 @@
       "path": "skills/programming/scripts/go/templates/main.go.tmpl",
       "sha256": "de00e3621a5e9e7c4639936f3822bdffc512c7fd04bc089144f0e3f49c8e31a5"
     },
-    {
-      "path": "skills/programming/scripts/go/templates/README.md.tmpl",
-      "sha256": "b0780490defb300a8ec5cd46555074ab58f9147d298964ff5ce2a40d24dde066"
-    },
     {
       "path": "skills/programming/scripts/go/templates/run.go",
       "sha256": "b59b73b7d0fe0122531d4523b8d72be3517bee015af41358e18edb18f183823f"
     },
-    {
-      "path": "skills/programming/scripts/go/templates/Taskfile.yml",
-      "sha256": "eb59766ea776398a4109383dc279c13673dbad3645f1a2a4f70da92bd08f48b6"
-    },
     {
       "path": "skills/programming/scripts/python/check-no-excuse-rules.py",
       "sha256": "2b2f629dcbbf05f2ab533d23ecab0825d5c6d091e5a5837090200e93afdc0767"
@@ -443,10 +459,6 @@
       "path": "skills/programming/scripts/typescript/new-project.ts",
       "sha256": "495e5add86f0ca9819f537e51083c34b6480e1f7d147ded7c9cf93fdbe48ccc5"
     },
-    {
-      "path": "skills/programming/SKILL.md",
-      "sha256": "ffb201197e7386c848f8efb9b90d0a024d7b8000e8bea1b13b0ed7a83627a56b"
-    },
     {
       "path": "skills/refactor/SKILL.md",
       "sha256": "d4e160e256b5a5e1fae4170edeee7a6bc8e2338bbebec797e24f07ea70687a10"
@@ -461,7 +473,7 @@
     },
     {
       "path": "skills/rules/SKILL.md",
-      "sha256": "7c56770fb7e62260c90db6d1d934a2c858e75418b8785f9eee031f0c8630c39f"
+      "sha256": "bc0a046745c455b5abb5ff8966d1d19245bf41576a44ed9be2c7917198ddbc03"
     },
     {
       "path": "skills/start-work/SKILL.md",

package/assets/lithermes-plugin/plugin.yaml

@@ -1,5 +1,5 @@
 name: lithermes
-version: 0.5.1
+version: 0.8.0
 description: "Hermes-native workflow toolkit: litgoal durable runtime, 5-lane review orchestrator, Litwork commands, skills, and prompt steering."
 author: "Hermes Agent"
 kind: standalone

package/assets/lithermes-plugin/skills/comment-checker/SKILL.md

@@ -5,9 +5,9 @@ description: Use after edits to self-review the comments you just wrote or touch
 
 # Comment Checker
 
-Hermes plugins expose only `pre_llm_call`, `subagent_stop`, and `on_session_start`
-hooks — there is **no** per-edit hook that fires after a write or edit. So this is not
-an automatic gate; it is a discipline **you self-apply** immediately after you change a
+The LitHermes plugin registers only the `pre_llm_call` and `subagent_stop` hooks —
+it wires **no** per-edit hook that fires after a write or edit. So this is not an
+automatic gate; it is a discipline **you self-apply** immediately after you change a
 file. Treat every successful write/edit/patch as the trigger to run the checklist below
 on the comments in that diff before you move on.
 

package/assets/lithermes-plugin/skills/deep-interview/SKILL.md

@@ -0,0 +1,307 @@
+---
+name: deep-interview
+description: Socratic deep-interview loop that turns a vague idea into an execution-ready spec, using a quantitative ambiguity score to gate when requirements are clear enough to build. Use this BEFORE planning or implementation whenever a request is broad, underspecified, or missing acceptance criteria — or when the user says "interview me", "ask me everything", "don't assume", or "deep interview". Invoke directly with /deep-interview.
+argument-hint: "[--quick|--standard|--deep] <idea or vague description>"
+---
+
+<Purpose>
+Deep Interview is an intent-first Socratic clarification loop that runs before planning or implementation. It turns vague ideas into execution-ready specifications by asking targeted questions about why the user wants a change, how far it should go, what should stay out of scope, and what the implementer may decide without confirmation. In LitHermes it is the clarity gate that feeds `/lit-plan` and then `/lit-loop`.
+</Purpose>
+
+<Use_When>
+- The request is broad, ambiguous, or missing concrete acceptance criteria
+- The user says "deep interview", "interview me", "ask me everything", or "don't assume"
+- The user wants to avoid misaligned implementation from underspecified requirements
+- You need a clear requirements artifact before handing off to planning or implementation
+</Use_When>
+
+<Do_Not_Use_When>
+- The request already has concrete file/symbol targets and clear acceptance criteria
+- The user explicitly asks to skip planning/interview and execute immediately
+- The user asks for lightweight, open-ended brainstorming only
+- A complete spec/plan already exists and execution should start
+</Do_Not_Use_When>
+
+<Why_This_Exists>
+Execution quality is usually bottlenecked by intent clarity, not just missing implementation detail. A single expansion pass often misses why the user wants a change, where the scope should stop, which tradeoffs are unacceptable, and which decisions still require user approval. This workflow applies Socratic pressure + quantitative ambiguity scoring so downstream planning and execution begin with an explicit, testable, intent-aligned spec.
+</Why_This_Exists>
+
+<Depth_Profiles>
+| Profile | Flag | Target ambiguity | Max rounds | Use for |
+|---------|------|-----------------:|-----------:|---------|
+| Quick | `--quick` | ≤ 30% | 5 | Fast pre-spec pass |
+| Standard *(default)* | `--standard` | ≤ 20% | 12 | Full requirement interview |
+| Deep | `--deep` | ≤ 15% | 20 | High-rigor exploration |
+
+If no flag is provided, use **Standard**.
+</Depth_Profiles>
+
+<Execution_Policy>
+- Ask ONE question per round (never batch)
+- Ask about intent and boundaries before implementation detail
+- Target the weakest clarity dimension each round after applying the stage-priority rules below
+- Treat every answer as a claim to pressure-test before moving on: the next question should usually demand evidence or examples, expose a hidden assumption, force a tradeoff or boundary, or reframe root cause vs symptom
+- Do not rotate to a new clarity dimension just for coverage when the current answer is still vague; stay on the same thread until one layer deeper, one assumption clearer, or one boundary tighter
+- Before crystallizing, complete at least one explicit pressure pass that revisits an earlier answer with a deeper, assumption-focused, or tradeoff-focused follow-up
+- Gather codebase facts with read-only search tools (or a read-only `delegate_task` exploration child) before asking the user about internals
+- Keep exploration prompts narrow and concrete; fall back to the user only for facts that can't be discovered directly
+- Always run a preflight context intake before the first interview question
+- Reduce user effort: ask only the highest-leverage unresolved question, and never ask the user for codebase facts you can discover yourself
+- For brownfield work, prefer evidence-backed confirmation questions such as "I found X in Y. Should this change follow that pattern?"
+- Ask each round as one concise plain-text question (the Hermes reply channel has no structured multiple-choice prompt); render the ambiguity meter immediately above it
+- Re-score ambiguity after each answer and show progress transparently
+- Do not hand off to execution while ambiguity remains above threshold unless the user explicitly opts to proceed with warning
+- Do not crystallize or hand off while `Non-goals` or `Decision Boundaries` remain unresolved, even if the weighted ambiguity threshold is met
+- Treat early exit as a safety valve, not the default success path
+- Persist progress to a state file after each round so the interview can resume if interrupted
+</Execution_Policy>
+
+<Steps>
+
+## Phase 0: Preflight Context Intake
+
+1. Parse `{{ARGUMENTS}}` and derive a short task slug.
+2. Attempt to load the latest relevant context snapshot from `.hermes/lithermes/deep-interview/{slug}-context.md`.
+3. If no snapshot exists, create a minimum context snapshot with:
+   - Task statement
+   - Desired outcome
+   - Stated solution (what the user asked for)
+   - Probable intent hypothesis (why they likely want it)
+   - Known facts/evidence
+   - Constraints
+   - Unknowns/open questions
+   - Decision-boundary unknowns
+   - Likely codebase touchpoints
+4. Save the snapshot to `.hermes/lithermes/deep-interview/{slug}-context.md` and reference it in the state file.
+
+## Phase 1: Initialize
+
+1. Parse `{{ARGUMENTS}}` and depth profile (`--quick|--standard|--deep`).
+2. Detect project context:
+   - Classify **brownfield** (existing codebase target) vs **greenfield** using read-only search.
+   - For brownfield, collect relevant codebase context before questioning.
+3. Initialize the state file at `.hermes/lithermes/deep-interview/{slug}-state.json`. Set `threshold` and `max_rounds` from the chosen profile (see the Depth Profiles table) — the values below are illustrative:
+
+```json
+{
+  "active": true,
+  "current_phase": "deep-interview",
+  "state": {
+    "interview_id": "<uuid>",
+    "profile": "quick|standard|deep",
+    "type": "greenfield|brownfield",
+    "initial_idea": "<user input>",
+    "rounds": [],
+    "current_ambiguity": 1.0,
+    "threshold": 0.2,
+    "max_rounds": 12,
+    "challenge_modes_used": [],
+    "codebase_context": null,
+    "current_stage": "intent-first",
+    "current_focus": "intent",
+    "context_snapshot_path": ".hermes/lithermes/deep-interview/<slug>-context.md"
+  }
+}
+```
+
+4. Announce kickoff with a compact banner so the user immediately understands the contract (profile, target, budget, starting point). Render it before the first question:
+
+```
+🎯 Deep Interview · {Quick|Standard|Deep} · {greenfield|brownfield}
+   Goal      turn "{short initial idea}" into an execution-ready spec
+   Target    ambiguity ≤ {threshold}%   ·   Budget   up to {max_rounds} rounds
+   Starting  ambiguity {score}%   ·   One question per round, intent before detail
+```
+
+## Phase 2: Socratic Interview Loop
+
+Repeat until ambiguity `<= threshold`, the pressure pass is complete, the readiness gates are explicit, the user exits with warning, or max rounds are reached.
+
+### 2a) Generate next question
+Use:
+- Original idea
+- Prior Q&A rounds
+- Current dimension scores
+- Brownfield context (if any)
+- Activated challenge mode injection (Phase 3)
+
+Target the lowest-scoring dimension, but respect stage priority:
+- **Stage 1 — Intent-first:** Intent, Outcome, Scope, Non-goals, Decision Boundaries
+- **Stage 2 — Feasibility:** Constraints, Success Criteria
+- **Stage 3 — Brownfield grounding:** Context Clarity (brownfield only)
+
+Follow-up pressure ladder after each answer:
+1. Ask for a concrete example, counterexample, or evidence signal behind the latest claim
+2. Probe the hidden assumption, dependency, or belief that makes the claim true
+3. Force a boundary or tradeoff: what would you explicitly not do, defer, or reject?
+4. If the answer still describes symptoms, reframe toward essence / root cause before moving on
+
+Prefer staying on the same thread for multiple rounds when it has the highest leverage. Breadth without pressure is not progress.
+
+Detailed dimensions:
+- Intent Clarity — why the user wants this
+- Outcome Clarity — what end state they want
+- Scope Clarity — how far the change should go
+- Constraint Clarity — technical or business limits that must hold
+- Success Criteria Clarity — how completion will be judged
+- Context Clarity — existing codebase understanding (brownfield only)
+
+`Non-goals` and `Decision Boundaries` are mandatory readiness gates. Ask about them early and keep revisiting them until they are explicit.
+
+### 2b) Ask the question
+Lead with a one-glance ambiguity meter so the user always sees how close the spec is to ready and how much budget remains. The meter is a *draining gauge*: the filled cells represent the ambiguity that still remains, and a `┊` tick marks the target — the job each round is to drain the filled edge down to or under the tick.
+
+```
+Round {n}/{max_rounds}  ·  Stage {1-3}: {stage name}  ·  Focus: {weakest_dimension}
+Ambiguity  {score}%  [███████░░░░░░░░░░░░░░░]  target ≤ {threshold}%
+```
+
+Then ask exactly one plain-text question.
+
+### 2c) Score ambiguity
+Score each weighted dimension in `[0.0, 1.0]` with justification + gap.
+
+Greenfield: `ambiguity = 1 - (intent × 0.30 + outcome × 0.25 + scope × 0.20 + constraints × 0.15 + success × 0.10)`
+
+Brownfield: `ambiguity = 1 - (intent × 0.25 + outcome × 0.20 + scope × 0.20 + constraints × 0.15 + success × 0.10 + context × 0.10)`
+
+Readiness gate:
+- `Non-goals` must be explicit
+- `Decision Boundaries` must be explicit
+- A pressure pass must be complete: at least one earlier answer has been revisited with an evidence, assumption, or tradeoff follow-up
+- If either gate is unresolved, or the pressure pass is incomplete, continue interviewing even when weighted ambiguity is below threshold
+
+### 2d) Report progress
+After scoring, show a compact breakdown so the user sees *what moved* and *what's still blocking readiness*. The readiness gates are shown every round (not just at the end), because they can block crystallization even when the weighted score is already under threshold.
+
+```
+Clarity
+  Intent      ▓▓▓▓▓▓▓▓░░  0.80   why they want it — clear
+  Outcome     ▓▓▓▓▓▓░░░░  0.60   end state — partially defined
+  Scope       ▓▓▓▓░░░░░░  0.40   ← weakest, next focus
+  Constraints ▓▓▓▓▓▓▓░░░  0.70   limits mostly known
+  Success     ▓▓▓░░░░░░░  0.30   no acceptance criteria yet
+  (Context)   ▓▓▓▓▓░░░░░  0.50   brownfield only
+
+Readiness gates
+  ✅ Non-goals explicit      ⬜ Decision Boundaries      ✅ Pressure pass done
+        → blocked by: Decision Boundaries (not yet explicit)
+
+Ambiguity {prev}% → {new}%   ·   Next: {weakest_dimension}
+```
+
+Use `✅` for met gates and `⬜` for open ones, and name what's blocking. If all gates are met and ambiguity is under threshold, say so plainly: "All gates met — ready to crystallize."
+
+### 2e) Persist state
+Append the round result and updated scores to the state file.
+
+### 2f) Round controls
+- Do not offer early exit before the first explicit assumption probe and one persistent follow-up have happened
+- Round 4+: allow explicit early exit with risk warning. Make it visible once available — add a quiet footer line, e.g. `(You can say "good enough" to stop early and crystallize with the current clarity.)`
+- Soft warning at profile midpoint (e.g., round 3/6/10 depending on profile): surface remaining budget, e.g. `⚠️ Round {n}/{max_rounds} — {remaining} rounds left before the cap.`
+- Hard cap at profile `max_rounds`
+
+## Phase 3: Challenge Modes (assumption stress tests)
+
+Use each mode once when applicable. These are normal escalation tools, not rare rescue moves:
+
+- **Contrarian** (round 2+ or immediately when an answer rests on an untested assumption): challenge core assumptions
+- **Simplifier** (round 4+ or when scope expands faster than outcome clarity): probe minimal viable scope
+- **Essence** (round 5+ and ambiguity > 0.25, or when the user keeps describing symptoms): ask for essence-level reframing
+
+Track used modes in the state file to prevent repetition.
+
+## Phase 4: Crystallize Artifacts
+
+When threshold is met (or user exits with warning / hard cap):
+
+1. Write the interview transcript summary to `.hermes/lithermes/deep-interview/{slug}-transcript.md`.
+2. Write the execution-ready spec to `.hermes/lithermes/deep-interview/{slug}-spec.md`.
+
+Spec should include:
+- Metadata (profile, rounds, final ambiguity, threshold, context type)
+- Context snapshot reference/path (for downstream reuse)
+- Clarity breakdown table
+- Intent (why the user wants this)
+- Desired Outcome
+- In-Scope
+- Out-of-Scope / Non-goals
+- Decision Boundaries (what the implementer may decide without confirmation)
+- Constraints
+- Testable acceptance criteria
+- Assumptions exposed + resolutions
+- Pressure-pass findings (which answer was revisited, and what changed)
+- Brownfield evidence vs inference notes for any repository-grounded confirmation questions
+- Technical context findings
+- Full or condensed transcript
+
+## Phase 5: Handoff
+
+Deep-interview is a requirements mode. When the spec is ready, hand off to planning or implementation — do **not** implement directly here. The spec is the requirements source of truth: preserve intent, non-goals, decision boundaries, acceptance criteria, and any residual-risk warning across the handoff.
+
+Present a short menu of next steps and let the user choose:
+
+```
+Spec ready → .hermes/lithermes/deep-interview/{slug}-spec.md   ·   final ambiguity {score}%{ · residual risk: <reason>}
+
+  1. Plan    /lit-plan — turn the spec into a detailed implementation/architecture plan first
+  2. Build   /lit-loop — implement directly; the spec is strong enough to start
+  3. Refine  keep interviewing — ambiguity or boundaries are still too loose
+```
+
+When handing the spec to `/lit-plan` or `/lit-loop`:
+- Pass the spec file as the requirements source of truth; don't re-run the interview unless the user asks to refine.
+- Carry the non-goals, decision boundaries, and acceptance criteria forward as binding constraints.
+
+**Residual-Risk Rule:** if the interview ended via early exit, hard-cap completion, or proceed-with-warning, state that residual risk explicitly in the handoff so the downstream step knows it inherited a partially clarified brief.
+
+</Steps>
+
+<Tool_Usage>
+- Use read-only search tools (or a read-only `delegate_task` exploration child) for codebase fact gathering
+- Ask each interview round as a single concise plain-text question; keep the same stage order
+- Persist round state to `.hermes/lithermes/deep-interview/{slug}-state.json` for resumability; read it back to resume
+- Read/write the context snapshot at `.hermes/lithermes/deep-interview/{slug}-context.md`
+- Save transcript and spec artifacts to `.hermes/lithermes/deep-interview/{slug}-transcript.md` and `.hermes/lithermes/deep-interview/{slug}-spec.md`
+</Tool_Usage>
+
+<Escalation_And_Stop_Conditions>
+- User says stop/cancel/abort -> persist state and stop
+- Ambiguity stalls for 3 rounds (+/- 0.05) -> force Essence mode once
+- Max rounds reached -> proceed with explicit residual-risk warning
+- All dimensions >= 0.9 -> allow early crystallization even before max rounds
+</Escalation_And_Stop_Conditions>
+
+<Final_Checklist>
+- [ ] Preflight context snapshot exists at `.hermes/lithermes/deep-interview/{slug}-context.md`
+- [ ] Progress strip (round budget + ambiguity bar) shown each round
+- [ ] Readiness-gate status (`Non-goals`, `Decision Boundaries`, pressure pass) shown each round with what's blocking
+- [ ] Intent-first stage priority used before implementation detail
+- [ ] Weakest-dimension targeting used within the active stage
+- [ ] At least one explicit assumption probe happened before crystallization
+- [ ] At least one persistent follow-up / pressure pass deepened a prior answer
+- [ ] Challenge modes triggered at thresholds (when applicable)
+- [ ] Transcript written to `.hermes/lithermes/deep-interview/{slug}-transcript.md`
+- [ ] Spec written to `.hermes/lithermes/deep-interview/{slug}-spec.md`
+- [ ] Brownfield questions use evidence-backed confirmation when applicable
+- [ ] Next-step handoff menu presented (`/lit-plan` / `/lit-loop` / Refine)
+- [ ] No direct implementation performed in this mode
+</Final_Checklist>
+
+<Advanced>
+## Resume
+
+If interrupted, rerun the skill. Resume by reading the persisted state file (`.hermes/lithermes/deep-interview/{slug}-state.json`) and continuing from the last completed round.
+
+## Recommended pipeline
+
+```
+deep-interview  →  /lit-plan  →  /lit-loop
+```
+
+- Stage 1 (deep-interview): clarity gate — this skill
+- Stage 2 (`/lit-plan`): feasibility + architecture gate
+- Stage 3 (`/lit-loop`): build + QA + validation gate
+</Advanced>
+
+Task: {{ARGUMENTS}}

package/assets/lithermes-plugin/skills/git-master/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: git-master
+description: "MUST USE whenever a task needs a commit or git-history investigation. Covers atomic commits, staging, commit-message style, rebase, squash, fixup/autosquash, blame, bisect, reflog, git log -S/-G, and questions like who wrote this or when was this added. Do not use for ordinary code edits unless the user asks for git work."
+---
+
+# Git Master
+
+The LitHermes git-history specialist for Hermes. Use this skill when the user
+asks you to operate on Git history or answer a Git-history question. Be exact,
+conservative, and evidence-led. Read the repository state before you infer anything.
+
+## LitHermes publish boundary
+
+Commit, push, force-push, and history rewrites are outward-facing or hard-to-reverse
+operations. Per LitHermes discipline, do **not** commit, push, force-push, reset,
+stash-pop, or rewrite history unless the user explicitly authorized that exact
+operation. Investigative requests report findings and stop.
+
+## Mode Gate
+
+Classify the request first:
+
+- `COMMIT`: stage and commit local changes.
+- `REBASE`: rebase, squash, fixup, autosquash, reorder, split, or otherwise rewrite branch history.
+- `HISTORY`: answer when, where, who, why, or which commit changed something.
+- `STATUS`: inspect branch, diff, or working-tree state without changing it.
+
+If the request is only investigative, report findings and stop.
+
+## Ground Truth
+
+Gather independent facts first (these are read-only and safe to run in parallel):
+
+```bash
+git status --short
+git diff --stat
+git diff --staged --stat
+git branch --show-current
+git log -30 --oneline
+git rev-parse --abbrev-ref @{upstream}
+git merge-base HEAD origin/main
+git merge-base HEAD origin/master
+```
+
+Missing upstream or missing `main`/`master` is normal. Fall back to the best
+available branch or report the missing fact. Never treat a failed lookup as proof.
+
+## Commit Mode
+
+Commit only the user's requested changes. Preserve unrelated dirty work.
+
+1. Detect message style from recent history (`git log -30 --pretty=format:%s`). Use the
+   dominant local pattern, language, and casing. Do not default to Conventional
+   Commits unless the repo already uses them.
+2. Inspect the full diff, not only filenames. Separate unrelated user edits from the
+   requested commit.
+3. Build atomic groups by behavior, module, and revertability. Keep implementation and
+   its direct tests together.
+4. Prefer multiple commits for unrelated concerns. A single commit is acceptable only
+   when the changed files form one indivisible behavior or the user explicitly asks for one.
+5. Stage by path or hunk so each commit contains only its atomic group.
+6. Before each commit, verify `git diff --staged --stat` and enough staged diff to prove
+   the group is right.
+7. Commit with the detected style. After each commit, verify `git log -1 --oneline`.
+
+Grouping rules:
+
+- Split different features, modules, generated artifacts, config, docs, and test-only
+  changes unless they are inseparable.
+- Keep generated files with the source change that produced them when omitting them
+  would leave the repo inconsistent.
+- Never hide failing or unrelated changes inside a broad commit.
+- Follow the user's git conventions (e.g. no AI/co-author attribution when the repo or
+  the user's rules forbid it).
+
+Final report: list commit hashes, messages, and any remaining uncommitted files.
+
+## Rebase Mode
+
+History rewriting is a shared-impact operation.
+
+- Never rebase or rewrite `main`, `master`, `dev`, release branches, or a protected
+  branch unless the user explicitly named that exact operation.
+- If commits may already be pushed, ask before force-pushing. Use `--force-with-lease`,
+  never plain `--force`.
+- If the worktree is dirty, preserve it intentionally before rebasing. Do not stash-pop
+  over conflicts without checking what changed.
+- For fixups, prefer `git commit --fixup=<hash>` then
+  `GIT_SEQUENCE_EDITOR=: git rebase -i --autosquash <base>`.
+- For conflicts, read the conflicting files and resolve by intent. Do not choose
+  ours/theirs blindly.
+- If a rebase goes wrong, run `git rebase --abort` first. Use reflog only after
+  explaining the recovery path.
+
+After rewriting, run the relevant tests or at least the project's cheapest smoke check,
+then show the new branch log from base to HEAD.
+
+## History Mode
+
+Choose the Git tool by the question:
+
+- `git log -S "text"`: when the count of an exact string changed.
+- `git log -G "regex"`: when diffs touched lines matching a pattern.
+- `git blame -L start,end -- file`: who last changed specific lines.
+- `git log --follow -- file`: history across renames for one file.
+- `git show <hash>`: inspect the commit that appears relevant.
+- `git bisect`: find the first bad commit when there is a deterministic pass/fail
+  command and known good/bad bounds.
+- `git reflog`: recover or explain recent local history movement.
+
+Always cite the exact command evidence in the answer: commit hash, subject, file path,
+and line or diff context when relevant. If the evidence is ambiguous, say what remains
+unproven.
+
+## Safety Checks
+
+Before any write to Git history:
+
+- Current branch is known.
+- Dirty work is accounted for.
+- Upstream/pushed status is known or explicitly unknown.
+- The operation matches an explicit user request and authorization.
+- Recovery path is known (`rebase --abort`, reflog hash, or untouched worktree).
+
+Before finishing:
+
+- Run the most relevant verification available for the changed behavior or history
+  operation (Manual QA evidence where a behavior changed).
+- Report commands that passed and any command you could not run.
+- Leave the worktree state explicit.

package/assets/lithermes-plugin/skills/init-deep/SKILL.md

@@ -0,0 +1,198 @@
+---
+name: init-deep
+description: "Initialize a hierarchical AGENTS.md knowledge base for a repository — a root AGENTS.md plus complexity-scored subdirectory files. Use when the user wants to bootstrap or refresh project knowledge for Hermes, onboard a codebase, generate AGENTS.md guidance (reading any existing CLAUDE.md for context), or map an unfamiliar repo. Adapted for Hermes: discovery and parallel generation via delegate_task children + Hermes lsp tools."
+---
+
+# Init-Deep — hierarchical AGENTS.md generator (Hermes)
+
+Generate hierarchical `AGENTS.md` files: a root knowledge base plus complexity-scored subdirectory
+files. This is the LitHermes onboarding/knowledge-base skill, re-authored for Hermes surfaces:
+read-only `delegate_task` children for discovery, Hermes' `lsp` tools for the code map, and parallel
+`delegate_task` fan-out for generation. (`AGENTS.md` is the file Hermes loads natively as project
+context — see the `lithermes:rules` skill.)
+
+## Usage
+
+```
+init-deep                 # Update mode: modify existing AGENTS.md + create new where warranted
+init-deep --create-new    # Read existing → remove all → regenerate from scratch
+init-deep --max-depth=2   # Limit directory depth (default: 3)
+```
+
+## Workflow (high level)
+
+1. **Discovery + analysis** (concurrent) — read-only `delegate_task` children + local bash structure +
+   `lsp` code map + read existing AGENTS.md.
+2. **Score & decide** — determine AGENTS.md locations from merged findings.
+3. **Generate** — root first, then subdirectories in parallel.
+4. **Review** — deduplicate, trim, validate.
+
+Track all four phases explicitly and report each one `pending → in_progress → completed` as you go
+(Hermes has no TodoWrite tool; keep the running state in your reply or a working note).
+
+## Phase 1 — Discovery + analysis (concurrent)
+
+Mark "discovery" in_progress.
+
+### Fan out read-only discovery children immediately
+
+Dispatch the discovery lanes as read-only `delegate_task` children — pass a `tasks` array so they run
+concurrently and the parent blocks until all return. Each child is self-contained (goal + scope +
+"read-only, return findings only"). Suggested lanes (one child each):
+
+- **Structure** — predict standard patterns for the detected language; report deviations only.
+- **Entry points** — find main/entry files; report non-standard organization.
+- **Conventions** — find config files (`.eslintrc`, `pyproject.toml`, `.editorconfig`, …); report
+  project-specific rules.
+- **Anti-patterns** — find `DO NOT` / `NEVER` / `ALWAYS` / `DEPRECATED` markers; list forbidden patterns.
+- **Build/CI** — find `.github/workflows`, `Makefile`, `Taskfile`; report non-standard patterns.
+- **Tests** — find test configs and structure; report unique conventions.
+
+**Dynamic scaling** — after the bash pass below, add MORE `delegate_task` children based on project
+scale (never a static count):
+
+| Factor | Threshold | Additional children |
+|--------|-----------|---------------------|
+| Total files | >100 | +1 per 100 files |
+| Total lines | >10k | +1 per 10k lines |
+| Directory depth | ≥4 | +2 for deep exploration |
+| Large files (>500 lines) | >10 files | +1 for complexity hotspots |
+| Monorepo | detected | +1 per package/workspace |
+| Multiple languages | >1 | +1 per language |
+
+```bash
+total_files=$(find . -type f -not -path '*/node_modules/*' -not -path '*/.git/*' | wc -l)
+total_lines=$(find . -type f \( -name "*.ts" -o -name "*.py" -o -name "*.go" \) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | tail -1 | awk '{print $1}')
+large_files=$(find . -type f \( -name "*.ts" -o -name "*.py" \) -not -path '*/node_modules/*' -exec wc -l {} + 2>/dev/null | awk '$1 > 500 {c++} END {print c+0}')
+max_depth=$(find . -type d -not -path '*/node_modules/*' -not -path '*/.git/*' | awk -F/ '{print NF}' | sort -rn | head -1)
+```
+
+For very broad repos, split the fan-out across several `delegate_task` batches rather than one giant
+batch, but keep every child read-only.
+
+### Main session: concurrent local analysis
+
+While the discovery children run, the main session does:
+
+**1. Bash structural analysis**
+```bash
+# Directory depth distribution
+find . -type d -not -path '*/.*' -not -path '*/node_modules/*' -not -path '*/dist/*' -not -path '*/build/*' | awk -F/ '{print NF-1}' | sort -n | uniq -c
+# Files per directory (top 30)
+find . -type f -not -path '*/.*' -not -path '*/node_modules/*' | sed 's|/[^/]*$||' | sort | uniq -c | sort -rn | head -30
+# Existing knowledge bases
+find . -type f \( -name "AGENTS.md" -o -name "CLAUDE.md" \) -not -path '*/node_modules/*' 2>/dev/null
+```
+
+**2. Read existing AGENTS.md** — for each file found, read it and extract key insights,
+conventions, and anti-patterns into an EXISTING map. With `--create-new`, read ALL existing files
+first (preserve context), THEN delete, THEN regenerate.
+
+**3. LSP code map (if available)** — use Hermes' `lsp` tools: `lsp.status` to list configured servers,
+then `lsp.symbols` for entry-point/workspace symbols (`class` / `interface` / `function`) and
+`lsp.find_references` on the top exports to gauge centrality. If no server is configured, fall back to
+the discovery children + plain search. (See the `lithermes:lsp` skill.)
+
+Merge bash + LSP + existing + child findings. Mark "discovery" completed.
+
+## Phase 2 — Scoring & location decision
+
+Mark "scoring" in_progress.
+
+### Scoring matrix
+
+| Factor | Weight | High threshold | Source |
+|--------|--------|----------------|--------|
+| File count | 3× | >20 | bash |
+| Subdir count | 2× | >5 | bash |
+| Code ratio | 2× | >70% | bash |
+| Unique patterns | 1× | has own config | child |
+| Module boundary | 2× | has `index.ts`/`__init__.py` | bash |
+| Symbol density | 2× | >30 symbols | LSP |
+| Export count | 2× | >10 exports | LSP |
+| Reference centrality | 3× | >20 refs | LSP |
+
+### Decision rules
+
+| Score | Action |
+|-------|--------|
+| Root (`.`) | ALWAYS create |
+| >15 | Create AGENTS.md |
+| 8–15 | Create if it is a distinct domain |
+| <8 | Skip (parent covers it) |
+
+Mark "scoring" completed.
+
+## Phase 3 — Generate AGENTS.md
+
+Mark "generate" in_progress.
+
+**File-writing rule:** if `AGENTS.md` already exists at the target path, edit it in place; if not,
+create it. NEVER overwrite an existing file — check existence first (via the discovery results or a
+read).
+
+### Root AGENTS.md (full treatment)
+
+```markdown
+# PROJECT KNOWLEDGE BASE
+**Generated:** {TIMESTAMP}  **Commit:** {SHORT_SHA}  **Branch:** {BRANCH}
+
+## OVERVIEW
+{1–2 sentences: what + core stack}
+
+## STRUCTURE
+{tree with non-obvious purposes only}
+
+## WHERE TO LOOK
+| Task | Location | Notes |
+
+## CODE MAP
+{from LSP — skip if unavailable or project <10 files}
+
+## CONVENTIONS
+{ONLY deviations from standard}
+
+## ANTI-PATTERNS (THIS PROJECT)
+{explicitly forbidden here}
+
+## COMMANDS
+{dev / test / build}
+
+## NOTES
+{gotchas}
+```
+
+Quality gate: 50–150 lines, no generic advice, no obvious info.
+
+### Subdirectory AGENTS.md (parallel)
+
+Generate each non-root location in parallel — dispatch one writing `delegate_task` child per location
+(batch them in one `delegate_task` call). Each child gets a `TASK:` line plus `DELIVERABLE` (the
+AGENTS.md), `SCOPE` (this directory only), and `VERIFY` (30–80 lines, never repeats parent content;
+sections: OVERVIEW 1 line, STRUCTURE if >5 subdirs, WHERE TO LOOK, CONVENTIONS if different,
+ANTI-PATTERNS). Wait for all. Mark "generate" completed.
+
+## Phase 4 — Review & deduplicate
+
+Mark "review" in_progress. For each generated file: remove generic advice, remove parent duplicates,
+trim to the size limits, verify telegraphic style. Mark "review" completed.
+
+## Final report
+
+```
+=== init-deep complete ===
+Mode: {update | create-new}
+Files: [OK] ./AGENTS.md (root, {N} lines) · [OK] ./src/hooks/AGENTS.md ({N} lines)
+Dirs analyzed: {N} · Created: {N} · Updated: {N}
+Hierarchy: ./AGENTS.md └── src/hooks/AGENTS.md
+```
+
+## Anti-patterns
+
+- **Static child count** — vary discovery `delegate_task` children by project size/depth (see the scaling table).
+- **Sequential execution** — run discovery children + LSP concurrently; generate subdirectories in parallel.
+- **Ignoring existing** — ALWAYS read existing AGENTS.md first, even with `--create-new`.
+- **Over-documenting** — not every directory needs an AGENTS.md.
+- **Redundancy** — a child file never repeats its parent.
+- **Generic content** — remove anything that applies to all projects.
+- **Verbose style** — telegraphic or die.

package/assets/lithermes-plugin/skills/rules/SKILL.md

@@ -1,41 +1,45 @@
 ---
 name: rules
-description: Use when the user asks about LitHermes repo-rule loading, injected project rules, supported rule file locations, matching, or environment configuration.
+description: Use when the user asks about LitHermes/Hermes repo-rule loading, injected project context files, supported file locations, discovery order, or how repository instructions reach the model.
 ---
 
 # Repo Rules
 
-Repo Rules is automatic once the LitHermes plugin is enabled. It loads project
-instructions from your repository and surfaces them to the model as context:
+Repo-rule loading in a LitHermes workspace is provided by **Hermes' native
+context-files feature**, not by a LitHermes plugin engine. Hermes discovers and
+injects your repository instruction files automatically; the LitHermes plugin
+does not register its own rules hook (it registers only `pre_llm_call` and
+`subagent_stop`) and does not re-implement rule loading. This skill documents how
+the native behavior works so you can rely on it and apply matched guidance.
 
-- static project instructions are injected on `on_session_start` and on `pre_llm_call`
-- file-specific rules are surfaced as guidance the model self-applies whenever it
-  edits a matching file (there is no per-edit plugin hook in Hermes; the matching
-  rule text is treated as a standing instruction the model checks before/after edits)
+## What Hermes loads
 
-Loaded rule text is injected as additional context and is deduplicated per session.
-Repo Rules never rewrites tool output — it only adds context.
+At session start Hermes loads the project context file from your working
+directory into the system prompt. As the agent reads files in subdirectories
+during the session, it **progressively discovers** context files there and
+injects them when they become relevant — so subdirectory guidance appears only
+when needed and the system prompt stays cache-stable.
 
-Supported project sources:
+Only **one** project context type is loaded per session (first match wins):
 
-- `AGENTS.md`
-- `CLAUDE.md`
-- `CONTEXT.md`
-- `.hermes/rules/**/*.md`
-- `.claude/rules/**/*.md`
-- `.cursor/rules/**/*.md`
-- `.github/instructions/**/*.md`
-- `.github/copilot-instructions.md`
+1. `.hermes.md` / `HERMES.md` — project instructions (highest priority)
+2. `AGENTS.md` — primary project conventions / architecture
+3. `CLAUDE.md` — Claude Code context files (also detected)
+4. `.cursorrules` — Cursor IDE conventions
+5. `.cursor/rules/*.mdc` — Cursor IDE rule modules
 
-Supported environment knobs:
+`SOUL.md` is loaded independently as the agent identity and is global to the
+Hermes instance (read from `HERMES_HOME/SOUL.md` only), not per-project.
 
-- `HERMES_RULES_DISABLED=1`
-- `HERMES_RULES_MODE=both|static|dynamic|off`
-- `HERMES_RULES_MAX_RULE_CHARS=<number>`
-- `HERMES_RULES_MAX_RESULT_CHARS=<number>`
-- `HERMES_RULES_ENABLED_SOURCES=AGENTS.md,.hermes/rules`
+Discovered context files go through Hermes' security scan, so malicious or
+prompt-injecting files are blocked before they reach the model.
 
-Static mode loads only repo-root instruction files; dynamic mode loads only the
-file-specific rules matched against the current edit target; `both` (the default)
-loads each as appropriate. State and dedupe bookkeeping live under
-`.hermes/lithermes/`.
+## How LitHermes uses it
+
+- There is no per-edit plugin hook in Hermes' LitHermes plugin, so file-specific
+  guidance you read from a discovered `AGENTS.md`/`CLAUDE.md` is a **standing
+  instruction you self-apply** before and after edits to matching files.
+- Repo rules only add context; they never rewrite tool output.
+
+For the authoritative, version-specific details (priority, subdirectory
+discovery, and the security scan) see the Hermes "Context Files" documentation.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lithermes-ai",
-  "version": "0.5.1",
+  "version": "0.8.0",
   "description": "npx/bunx installer for the LitHermes Hermes plugin",
   "license": "MIT",
   "repository": {