lithermes-ai 0.5.1 → 0.6.0

package/README.md

@@ -57,12 +57,13 @@ 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`, `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,10 @@ 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`, `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,8 @@ 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:lsp`,
   `lithermes:programming`, `lithermes:refactor`,
   `lithermes:remove-ai-slops`, `lithermes:review-work`,
   `lithermes:rules`, `lithermes:start-work`, `lithermes:lit-plan`,
@@ -36,5 +37,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

@@ -22,6 +22,10 @@ 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.",
@@ -170,6 +174,12 @@ def register(ctx) -> None:
         description="Open or dry-run a LitHermes plan against a workspace",
         args_hint="[plan-name] [--worktree PATH] [--dry-run]",
     )
+    ctx.register_command(
+        "deep-interview",
+        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

@@ -805,6 +805,46 @@ def command_litgoal(raw_args: str) -> dict[str, str]:
     }
 
 
+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-14T02:25:40.475Z",
   "source": "source-reference",
-  "sourceHash": "367df25c50e5d54bb516cda93fe453be2ec0821924be0136dfbb9e24b117494a",
+  "sourceHash": "09f07fa73866ccb4c0a7dc271d4d1ce45a9ac662ff911fab6f4a6d6e7db73c07",
   "files": [
+    {
+      "path": "NOTICE.md",
+      "sha256": "452ad24ca1ecd65e2f2ab0f21ff6c1cefb13aacf0db875f327b62027106685ab"
+    },
+    {
+      "path": "README.md",
+      "sha256": "32bbef20afd99f774502c2b4cbf2e2326d40c4e4cd71108645849dddcc2608c4"
+    },
     {
       "path": "__init__.py",
-      "sha256": "3e6b2e469e0ff805391ee741e640274e58e15da330f6d7eec4b0e06618755cfd"
+      "sha256": "e545ac92efb1a8d50c467b21b180eb41dad5e9a19379a8cbe5086956c21c3654"
     },
     {
       "path": "core.py",
-      "sha256": "8fa2e7263e99c16fbb337df468d769890df1d98e2683614646b243dbd23c3ff2"
+      "sha256": "c8cac49c17e573dabc59c4d5aa56402a71320f62145fabf9552e7fdb648f340a"
     },
     {
       "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": "e90d47b24dc2cb5340d9485929ba40e62b2b5d6858951992c414701f015286fe"
     },
     {
       "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,8 +136,8 @@
       "sha256": "0123de928e1e88186487adfee0b69d7a886c596fdd0c5132256cf9319fea466e"
     },
     {
-      "path": "skills/debugging/SKILL.md",
-      "sha256": "aff2ca5765f490ed1e45d2eaa77c48db3ef98cec12fa10ebff3f91b82eab1254"
+      "path": "skills/deep-interview/SKILL.md",
+      "sha256": "4f8e7217b72724921cdc68b5214cc99d7b45ec51fd05b237fac20c75fc35988c"
     },
     {
       "path": "skills/frontend-ui-ux/SKILL.md",
@@ -159,6 +163,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 +215,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 +227,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 +275,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 +283,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 +331,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 +343,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 +363,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 +391,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 +415,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 +451,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 +465,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.6.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/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.6.0",
   "description": "npx/bunx installer for the LitHermes Hermes plugin",
   "license": "MIT",
   "repository": {