litclaude-ai 0.2.2

package/docs/agents.md

@@ -0,0 +1,67 @@
+# LitClaude Agents
+
+LitClaude agents map the LitClaude team workflow into Claude Code subagents
+with bounded responsibilities.
+
+| Agent | Responsibility | Boundary |
+| --- | --- | --- |
+| `prometheus-planner` | Build implementation plans and identify risks. | Read-only tools, no write/edit/bash tools. |
+| `boulder-executor` | Execute checked plan tasks. | Must follow task acceptance criteria and collect evidence. |
+| `oracle-verifier` | Verify tests, artifacts, and task completion. | Reviews evidence before approval. |
+| `quality-reviewer` | Perform code-review style risk checks. | Findings first, no unrelated rewrites. |
+| `librarian-researcher` | Fetch and summarize external references. | Use primary sources and cite them. |
+| `qa-runner` | Run tmux/manual QA scenarios. | Must clean up sessions and capture receipts. |
+
+The planner is deliberately constrained because the safest Claude Code retrofit
+keeps planning separate from mutation. Executor and QA agents can act only
+inside the plan and evidence contract.
+
+## Review Work Routing
+
+The v0.2.0 workflow parity review route uses five evidence lanes:
+
+| Review lane | Agent routing | Required evidence |
+| --- | --- | --- |
+| goal/constraint verification | `oracle-verifier` with `review-work` and `rules` | Goal, non-goals, acceptance criteria, publish boundary, and constraints checked against current docs/test reads. |
+| hands-on QA execution | `qa-runner` with `start-work` and `review-work` | Automated test output, Manual-QA channels, artifacts, and cleanup receipt. |
+| code quality | `quality-reviewer` with `review-work` and `programming` | Findings-first code review focused on regressions and maintainability. |
+| security | `quality-reviewer` with `review-work` and `programming` | Prompt injection, malformed input, local state, and unsafe command handling risks. |
+| local-first context mining | `librarian-researcher` with `rules` | Local checkout, docs, tests, and ledgers checked before external references. |
+
+The aggregate verdict is PASS, FAIL, or NEEDS-CONTEXT. Broad review work may
+use Dynamic workflow when Claude Code exposes it; isolated edits can use
+`claude --worktree <short-name> --tmux` when a separate checkout is required.
+
+## Dynamic Workflow Delegation
+
+The v0.2.2 `/dynamic-workflow` route makes the delegation map explicit for
+Claude Code Dynamic workflow lanes and subagent spawning. Child assignments
+start with `TASK:` and include `DELIVERABLE`, `SCOPE`, and `VERIFY` so the
+worker knows the artifact, boundary, and proof of completion:
+
+| Delegation lane | Agent | Evidence boundary |
+| --- | --- | --- |
+| plan and dependency order | `prometheus-planner` | Read-only plan with files, tests, Manual-QA channel, and cleanup. |
+| implementation | `boulder-executor` | Smallest checked code change with RED -> GREEN evidence. |
+| acceptance verification | `oracle-verifier` | Goal, criteria, and artifact checks before completion. |
+| manual QA | `qa-runner` | tmux/browser/HTTP/computer-use artifact plus cleanup receipt. |
+| code/security review | `quality-reviewer` | Findings-first review with concrete file references. |
+| local-first context mining | `librarian-researcher` | Repo/docs/history search before external sources. |
+
+`litclaude-ai workflow-check --json` verifies that this route, goal guidance,
+Dynamic workflow guidance, subagent reliability contract, and command/hook
+agreement are present.
+
+## Local Use
+
+Load the plugin from this checkout:
+
+```bash
+claude --plugin-dir ./plugins/litclaude
+```
+
+Then reload after edits:
+
+```text
+/reload-plugins
+```

package/docs/hooks.md

@@ -0,0 +1,134 @@
+# LitClaude Hooks
+
+LitClaude hooks translate the LitClaude prompt workflow into Claude Code hook
+events while keeping execution local and bounded.
+
+## Hook Events
+
+| Event | Runner | Purpose |
+| --- | --- | --- |
+| `SessionStart` | `plugins/litclaude/bin/litclaude-hook.js session-start` | Adds a compact rules-loaded context line. |
+| `UserPromptSubmit` | `plugins/litclaude/bin/litclaude-hook.js user-prompt-submit` | Detects litwork/lit prompts and injects workflow context. |
+| `PostToolUse` | `plugins/litclaude/bin/litclaude-hook.js post-tool-use` | Reminds the session to run post-edit checks. |
+| `PostCompact` | `plugins/litclaude/bin/litclaude-hook.js post-compact` | Resets compacted rule context after summarization. |
+
+## Workflow Trigger Phrases
+
+The `UserPromptSubmit` hook activates on any of these phrases:
+
+```text
+lit
+litwork
+$lit-plan
+/lit-plan
+/litclaude:lit-plan
+$lit-loop
+/lit-loop
+/litclaude:lit-loop
+$deep-interview
+/deep-interview
+/litclaude:deep-interview
+$dynamic-workflow
+/dynamic-workflow
+/litclaude:dynamic-workflow
+$review-work
+/review-work
+/litclaude:review-work
+$litgoal
+/litgoal
+/litclaude:litgoal
+$start-work
+/start-work
+/litclaude:start-work
+```
+
+When a LIT trigger is present, the hook returns additional context containing
+`LITWORK MODE ENABLED` and a visible `LitClaude lit hook active` system
+message. For `/deep-interview`, it returns `DEEP INTERVIEW MODE ENABLED` while
+still routing to `/litclaude:deep-interview` / `Skill(deep-interview)`.
+That context is guidance for Claude Code; it is not executed as a command. The
+guidance tells Claude to treat plain `lit` as `/litclaude:lit-loop` /
+`Skill(lit-loop)` semantics before ordinary task execution.
+
+LitClaude follows the LitClaude goal pattern as model-facing run context, not
+as slash-command injection. If Claude Code exposes the native goal surface, the
+guidance tells Claude to inspect `get_goal`, call `create_goal` only when no
+matching goal is active, and delay `update_goal` until verified completion or a
+genuine blocker. It may also point Claude toward the user-visible `/goal`
+surface, but it does not auto-type `/goal` or send slash command text.
+
+If goal tools are unavailable or not exposed in the running Claude Code session,
+the hook context keeps the local evidence ledger authoritative. It may suggest
+`/goal <completion condition>` before long execution, but it should not repeat
+fallback chatter on every LIT turn.
+
+For broad work, the same context ports the LitClaude model-facing principle to
+Claude Code's exposed orchestration surfaces: if `Workflow` is available, call
+the `Workflow` tool before serial execution and bind every lane to evidence and
+cleanup. If isolated edits need a model-facing worktree lane, use
+`EnterWorktree`; when only the CLI surface is available, the actionable launch
+form is `claude --worktree <short-name> --tmux`.
+
+`/dynamic-workflow` and `$dynamic-workflow` are the v0.2.2 consolidated route
+for that behavior. They load `/litclaude:dynamic-workflow` / `Skill(lit-loop)`,
+then map subagent delegation to `prometheus-planner`, `boulder-executor`,
+`oracle-verifier`, `qa-runner`, `quality-reviewer`, and `librarian-researcher`.
+The hook also reminds child assignments to use `TASK:`, `DELIVERABLE`, `SCOPE`,
+and `VERIFY`, with short wait cycles and fallback only after missing
+deliverables, acknowledgement-only replies, or `BLOCKED:` reports. Run
+`litclaude-ai workflow-check --json` to verify the hook route, goal guidance,
+Dynamic workflow guidance, subagent reliability, and command/hook agreement
+before full QA.
+
+When SessionStart sees transcript context-pressure markers, the hook adds a
+bounded resume reminder to reread `HANDOFF.md`, the active plan, the start-work
+ledger, Boulder state, and `git status --short` before edits.
+
+Plain `lit` therefore activates hook context, not a visible Skill tool call.
+For a visible LitClaude command/skill invocation, use the namespaced Claude
+Code commands. The shorter slash aliases above are also recognized by the prompt
+hook so they route to the same discipline instead of falling through to plain
+`lit` loop activation:
+
+```text
+/litclaude:lit-loop <goal>
+/litclaude:dynamic-workflow <parallel or delegated objective>
+/litclaude:lit-plan <planning brief>
+/litclaude:start-work plans/example-plan.md
+```
+
+These are real Claude Code command files in `plugins/litclaude/commands/`.
+
+`/deep-interview` is the clarification route. It loads
+`/litclaude:deep-interview` / `Skill(deep-interview)` guidance and should run
+before `/lit-plan` when a request lacks non-goals, decision boundaries, or
+acceptance criteria.
+
+`/review-work` and `$review-work` load `/litclaude:review-work` /
+`Skill(review-work)`. That route runs the v0.2.0 workflow parity 5-lane review:
+goal/constraint verification, hands-on QA execution, code quality, security,
+and local-first context mining. `/litgoal` and `$litgoal` load
+`/litclaude:litgoal` / `Skill(litgoal)` for durable local goal state and
+the litgoal CLI.
+
+## Safety
+
+Hooks parse JSON from stdin and return JSON to Claude Code. The hook does not
+execute prompt text and does not echo prompt text into the returned context;
+prompt text is not executed or echoed. The litwork detector returns constant
+workflow guidance, so a prompt cannot become a shell command through the hook
+response. Malformed hook input and malformed litgoal JSON should surface a controlled error instead of a misleading success response.
+
+## Local Smoke
+
+Run the hook fixture directly:
+
+```bash
+node plugins/litclaude/bin/litclaude-hook.js user-prompt-submit < fixtures/hooks/user-prompt-litwork.json
+```
+
+Reload local plugin metadata in Claude Code after hook edits:
+
+```text
+/reload-plugins
+```

package/docs/lsp.md

@@ -0,0 +1,40 @@
+# LitClaude LSP
+
+LitClaude includes a Claude Code plugin LSP config and a local doctor command
+for TypeScript-family projects.
+
+## Configuration
+
+`plugins/litclaude/.lsp.json` declares a TypeScript language server command:
+
+```json
+["typescript-language-server", "--stdio"]
+```
+
+It covers `.ts`, `.tsx`, `.js`, `.jsx`, `.mjs`, and `.cjs` files.
+
+## Doctor
+
+Run the doctor locally:
+
+```bash
+node plugins/litclaude/bin/litclaude-lsp-doctor.js
+```
+
+If `typescript-language-server` is unavailable, the doctor exits successfully
+with installation guidance so local smoke tests can distinguish an environment
+gap from a plugin failure.
+
+`litclaude doctor` also prints the LitClaude LSP server names from the
+installed `.lsp.json`. If Claude Code reports load errors for official LSP
+plugins such as `rust-analyzer-lsp`, `pyright-lsp`, or `gopls-lsp`, LitClaude
+reports those as external binary warnings rather than LitClaude plugin errors.
+
+## Claude Code Reload
+
+After changing `.lsp.json`, restart Claude Code with the local plugin directory
+or use:
+
+```text
+/reload-plugins
+```

package/docs/migration.md

@@ -0,0 +1,209 @@
+# LitClaude Migration
+
+LitClaude maps workflow disciplines into Claude Code-native surfaces. The goal
+is behavior parity where Claude Code exposes the same kind of surface, and a
+conservative local fallback where it does not.
+
+> **Upgrading from `lazyclaude-ai`?** See [Upgrading from lazyclaude-ai](#upgrading-from-lazyclaude-ai)
+> at the bottom — the project was renamed and a few local paths/env vars changed.
+
+| Reference surface | Claude Code surface | LitClaude implementation |
+| --- | --- | --- |
+| CLI prompt engineering | Claude Code skills | `plugins/litclaude/skills/*/SKILL.md` |
+| Auxiliary skill packs | Claude Code skill auxiliary files | `programming/references`, `programming/scripts`, and `debugging/references` are included where portable |
+| Litwork plan mode | Claude Code skill plus planner agent | `lit-plan` and `prometheus-planner` |
+| Clarification interview | Claude Code skill plus command | `deep-interview` asks one Socratic question per round, persists state under `deep-interview/`, and hands a spec to planning or execution |
+| Execution loop | Claude Code skill plus executor agent | `lit-loop`, `start-work`, and `boulder-executor` |
+| 5-lane review | Claude Code command, skill, and agents | `review-work` runs goal/constraint verification, hands-on QA execution, code quality, security, and local-first context mining |
+| Durable goal runtime | Package CLI plus local state | `litgoal` writes criteria, evidence, checkpoints, steering, and blockers under `.litclaude/litgoal/` |
+| Goal-tool guidance | Claude Code native goal surface | `/goal` when user-selected, or model-facing `get_goal`, `create_goal`, and verified-final `update_goal` guidance when exposed |
+| Parallel orchestration | Claude Code Dynamic workflow and Dynamic worktree surfaces | Call `Workflow` for broad independent work when exposed; use `EnterWorktree` or the CLI worktree path for risky or parallel edits |
+| Dynamic workflow readiness | Claude Code command plus package diagnostic | `/dynamic-workflow` and `workflow-check --json` verify goal, Dynamic workflow, and subagent delegation surfaces |
+| Hooks | Claude Code hooks | `plugins/litclaude/hooks/hooks.json` |
+| MCP helpers | Claude Code plugin MCP config | `plugins/litclaude/.mcp.json` |
+| LSP integration | Claude Code plugin LSP config | `plugins/litclaude/.lsp.json` |
+| Package alias | npm package bin alias | `litclaude-ai` |
+| Review/research agents | Claude Code agents | `quality-reviewer`, `oracle-verifier`, `librarian-researcher` |
+
+## Local Plugin Flow
+
+Use the local plugin path while developing from this checkout:
+
+```bash
+claude --plugin-dir ./plugins/litclaude
+```
+
+For fresh machines, the quiet npm distribution path is:
+
+```bash
+npx --yes litclaude-ai install
+bunx litclaude-ai install
+litclaude doctor
+```
+
+Launch Claude Code normally after install:
+
+```bash
+claude
+```
+
+The installer writes the user plugin cache, `plugins/installed_plugins.json`,
+the `settings.json` `enabledPlugins` entry for `litclaude@litclaude-ai`, and
+a LitClaude-managed local marketplace entry in `known_marketplaces.json`.
+This keeps installation convenient without requiring public repo promotion,
+manual `--plugin-dir` launch commands, or a remote Claude marketplace entry.
+
+## Goal And Dynamic Workflow Parity
+
+Reference goal integration is model-facing guidance around goal tools; it does
+not type a `/goal` slash command for the user. LitClaude mirrors that contract:
+lit hook context and lit skills mention Claude Code's native goal surface, ask
+Claude to inspect `get_goal`, create a goal with `create_goal` only when no
+matching active goal exists, and defer `update_goal` until the evidence gate has
+passed or a real blocker is recorded.
+
+Current Claude Code sessions may not expose model-facing goal tools to the
+model. When goal tools are unavailable or not exposed, LitClaude should not
+pretend the native goal was bound. It keeps the local evidence ledger
+authoritative and may suggest `/goal <completion condition>` before
+long-running lit execution without repeatedly printing fallback chatter.
+
+When the user explicitly chooses Claude Code `/goal`, that native session goal
+remains user-visible and user-controlled. LitClaude does not auto-type
+`/goal`. For multi-lane work, LitClaude follows the same model-facing tool
+principle where Claude Code exposes it: call the `Workflow` tool before serial
+execution, bind each lane to criteria and evidence, and use `EnterWorktree` for
+isolated model-facing worktree lanes. When only the CLI surface is available,
+the concrete isolated-lane launch form is `claude --worktree <short-name> --tmux`.
+
+`/dynamic-workflow`, `$dynamic-workflow`, and `/litclaude:dynamic-workflow`
+consolidate that behavior into one route. The route keeps `/goal`
+user-controlled, calls model-facing goal tools only when exposed, and maps
+subagent delegation to `prometheus-planner`, `boulder-executor`,
+`oracle-verifier`, `qa-runner`, `quality-reviewer`, and `librarian-researcher`.
+Child assignments use `TASK:`, `DELIVERABLE`, `SCOPE`, and `VERIFY`;
+`workflow-check --json` now verifies both subagent reliability and command/hook
+agreement. Operators can verify availability with:
+
+```bash
+litclaude-ai workflow-check --json
+```
+
+Long `$start-work` runs can also use `litclaude-ai start-work-next --json` to
+recover the active plan, ledger path, and first unchecked top-level task from
+local `.litclaude` state after a compacted or interrupted session.
+
+## Review And Litgoal Parity
+
+The workflow parity surface is local-first and evidence-bound. It does not imply
+that an npm publish or remote marketplace publication has happened.
+`/review-work`, `$review-work`, and `/litclaude:review-work` run the 5-lane
+review contract: goal/constraint verification, hands-on QA execution, code
+quality, security, and local-first context mining. Manual-QA channels must
+produce artifacts, and all spawned sessions, servers, ports, browser tabs, and
+temp directories need a cleanup receipt before completion.
+
+`/litgoal`, `$litgoal`, and `/litclaude:litgoal` bind long work to the
+litgoal runtime in `plugins/litclaude/lib/litgoal/`. The local state lives
+under `.litclaude/litgoal/`, and current docs/test reads are the authority if
+stale state contradicts the checkout.
+
+Use these CLI commands for durable state:
+
+```bash
+litclaude litgoal create-goals --brief "<brief>" --json
+litclaude litgoal record-evidence --criterion <id> --status pass --json '{"artifact":"...","cleanup":"..."}'
+litclaude litgoal checkpoint --status active --note "<progress>" --json
+litclaude litgoal steer --kind scope --note "<what changed and why>" --json
+```
+
+Malformed evidence JSON, unknown criteria, corrupt state, or invalid steering
+kinds must fail with a controlled error.
+
+If OMC/omc is already installed in Claude Code, keep it disabled or start a
+separate Claude Code session without OMC while testing LitClaude. This repo no
+longer ships a root marketplace skeleton; direct `--plugin-dir` loading avoids
+local marketplace collision. If a user-level OMC plugin still runs, it may
+create `.omc/` local state in the checkout; LitClaude treats that as quarantined
+external state and keeps it ignored and outside packaged artifacts.
+
+Reload plugin metadata after changing skills, agents, hooks, MCP, or LSP:
+
+```text
+/reload-plugins
+```
+
+## Publication Boundary
+
+LitClaude may be prepared as a quiet public npm package for personal install
+convenience, but any `npm publish`, marketplace registration, or remote
+distribution step requires explicit user approval. Until that approval exists,
+uninstalling is either `litclaude uninstall` for npm-installed copies or
+removing the local `--plugin-dir` usage and reloading Claude Code.
+
+## Upgrading from lazyclaude-ai
+
+LitClaude was formerly published as **`lazyclaude-ai`** (the `lazyclaude` plugin,
+`💤LAZYCLAUDE` HUD). The rebrand to **`litclaude-ai`** / **`litclaude`** is a new,
+independent npm package — the old `lazyclaude-ai` is untouched on npm. To migrate
+an existing local install:
+
+| Old (`lazyclaude`) | New (`litclaude`) |
+| --- | --- |
+| npm package `lazyclaude-ai` | `litclaude-ai` |
+| bins `lazyclaude` / `lazyclaude-ai` | `litclaude` / `litclaude-ai` |
+| installer state dir `~/.lazyclaude` (`LAZYCLAUDE_HOME`) | `~/.litclaude` (`LITCLAUDE_HOME`) |
+| per-project runtime state `.omo/` | `.litclaude/` |
+| env vars `LAZYCLAUDE_*` | `LITCLAUDE_*` (e.g. `LAZYCLAUDE_HUD_ACCENT` → `LITCLAUDE_HUD_ACCENT`) |
+| slash commands `/lazyclaude:<cmd>` | `/litclaude:<cmd>` |
+| plugin key `lazyclaude@lazyclaude-ai` | `litclaude@litclaude-ai` |
+
+Steps:
+
+```bash
+# 1. Remove the old install (if present)
+lazyclaude uninstall    # or remove the old --plugin-dir usage
+
+# 2. Install LitClaude
+npx --yes litclaude-ai install
+litclaude doctor
+
+# 3. (Optional) carry over existing per-project loop/goal state
+mv .omo .litclaude      # run inside any project that had local LazyClaude state
+
+# 4. Update any custom env vars you set: LAZYCLAUDE_* -> LITCLAUDE_*
+```
+
+The host config dir `~/.claude` and `CLAUDE_*` host variables are unchanged —
+those are owned by Claude Code, not by this plugin.
+
+## Own-vocabulary rename: ulw -> lit family
+
+The workflow vocabulary has been renamed from the `ulw`/`ultrawork`/`ultragoal`
+family to the `lit` family:
+
+| Old | New |
+| --- | --- |
+| `ulw` (trigger keyword) | `lit` |
+| `ultrawork` | `litwork` |
+| `ulw-loop` (skill/command) | `lit-loop` |
+| `ulw-plan` (skill/command) | `lit-plan` |
+| `ultragoal` (skill/command/lib/CLI) | `litgoal` |
+| `/litclaude:ulw-loop` | `/litclaude:lit-loop` |
+| `/litclaude:ulw-plan` | `/litclaude:lit-plan` |
+| `/litclaude:ultragoal` | `/litclaude:litgoal` |
+| `litclaude-ai ultragoal` | `litclaude-ai litgoal` |
+| `.litclaude/ultragoal/` (local state) | `.litclaude/litgoal/` |
+
+The `lit` keyword fires `lit-loop` via the hook. Typing `litwork` also fires it.
+The bare `lit` trigger includes a soft-confirm step so a stray English "lit" is
+recoverable.
+
+Skills/commands that do NOT change: `review-work`, `start-work`,
+`deep-interview`, `dynamic-workflow`.
+
+To migrate existing local state:
+
+```bash
+mv .litclaude/ultragoal .litclaude/litgoal   # inside any project with existing state
+```

package/docs/workflow-compatibility-audit.md

@@ -0,0 +1,119 @@
+# Workflow Compatibility Audit
+
+Reference workflow snapshot:
+`3fb8802e314dc0a1f23481dd3782cdca26b92dc2`.
+
+This document tracks the reference workflow surfaces checked during the deeper
+LitClaude compatibility pass. The goal is to keep future updates honest: if the
+reference grows a new user-facing skill, hook, or runtime behavior, this map should
+make the missing LitClaude target obvious.
+
+## Workflow Parity Matrix
+
+| Reference workflow category | LitClaude target | Status | Reason / acceptance signal |
+| --- | --- | --- | --- |
+| review-work 5-lane orchestration | `commands/review-work.md`, `skills/review-work`, `agents/quality-reviewer.md`, `agents/oracle-verifier.md`, `agents/qa-runner.md`, `agents/librarian-researcher.md` | Implemented | `review-work` is the v0.2.0 workflow parity 5-lane review route: scout / skeptic / implementer / edge-case / decision ledger discipline is represented as goal/constraint verification, hands-on QA execution, code quality, security, and local-first context mining with an aggregate verdict. |
+| litgoal state/runtime | `commands/litgoal.md`, `skills/litgoal`, `plugins/litclaude/lib/litgoal/`, `.litclaude/litgoal/`, `bin/litclaude-ai.js litgoal ...` commands | Implemented | `litgoal` now has durable state, ledger, checkpoint, steering, quality gate, and review blocker commands through `litclaude litgoal create-goals`, `record-evidence`, `checkpoint`, `steer`, and `record-review-blockers`. |
+| LIT/start-work discipline | `commands/lit-loop.md`, `commands/lit-plan.md`, `commands/start-work.md`, `skills/lit-loop`, `skills/lit-plan`, `skills/start-work` | Implemented | Existing LIT/start-work surfaces require plan reading, ledger updates, publish boundary checks, verification, manual QA artifacts, cleanup receipts, resume checkpoints, and evidence artifacts. |
+| hook trigger safety | `hooks/hooks.json`, `bin/litclaude-hook.js`, `test/hooks.test.mjs`, `docs/hooks.md` | Implemented | Hooks use `UserPromptSubmit` trigger detection, exact workflow aliases, near-miss fixtures, prompt injection safe context, and no auto-type behavior for slash commands. |
+| agent/command routing | `agents/*.md`, `commands/*.md`, `.claude-plugin/plugin.json`, command discovery tests | Implemented | Agents and commands route planner, executor, verifier, reviewer, librarian, and QA responsibilities into Claude Code surfaces, including review-work and litgoal command files. |
+| docs/package payload | `README.md`, `README_ko-KR.md`, `docs/*.md`, `package.json`, `.claude-plugin/plugin.json`, `test/workspace-hygiene.test.mjs` | Implemented | Docs, package payload, manifest, install metadata, and package allowlist are covered by tests; v0.2.0 docs describe local parity without implying publish completion. |
+| excluded/deferred telemetry | No runtime telemetry package; docs omission note | Omitted | Telemetry is omitted and any network telemetry remains deferred by reason: LitClaude should stay local and quiet unless the user explicitly requests an observable reporting feature. |
+
+## Runtime Concepts
+
+| Reference surface | LitClaude target | Status |
+| --- | --- | --- |
+| prompt activation | `hooks/hooks.json`, `bin/litclaude-hook.js`, `commands/lit-loop.md`, `commands/lit-plan.md`, `commands/deep-interview.md`, `commands/start-work.md` | UserPromptSubmit detects workflow triggers and injects compact Claude Code guidance. |
+| comment-checker | `skills/comment-checker`, `PostToolUse` hook guidance | Claude-native comment hygiene skill plus post-edit reminder. |
+| lsp | `.lsp.json`, `.mcp.json`, `bin/litclaude-lsp-doctor.js`, `skills/lsp` | Lightweight Claude Code LSP/MCP helper rather than vendoring a full external package. |
+| rules | `skills/rules`, `SessionStart` / `PostCompact` hook behavior | Claude session rule guidance and cache-reset messaging. |
+| litgoal | `commands/litgoal.md`, `skills/litgoal`, `plugins/litclaude/lib/litgoal/`, `lit-*`, `start-work` goal guidance | Claude-native goal wording with evidence/ledger/quality-gate discipline and durable CLI state. |
+| litwork | `commands/lit-loop.md`, `commands/lit-plan.md`, `skills/lit-loop`, `skills/lit-plan` | Claude skills, commands, agents, workflow/worktree guidance, and hook injection. |
+| clarification interview | `commands/deep-interview.md`, `skills/deep-interview` | Socratic requirements mode with ambiguity scoring, persisted state, and a handoff to planning/execution. |
+| agents | `agents/*.md` | Planner, executor, verifier, reviewer, librarian, and QA runner roles. |
+| mcp | `.mcp.json`, `bin/litclaude-mcp.js` | Plugin-local stdio helper surface. |
+| install metadata | `bin/litclaude-ai.js`, `.claude-plugin/plugin.json`, local marketplace metadata | Installer writes Claude user plugin registry and LitClaude-owned local marketplace records. |
+| telemetry | No runtime telemetry | Intentionally omitted as network telemetry. LitClaude remains quiet/local by default. |
+
+## Skill Corpus
+
+LitClaude includes the compatibility skill corpus:
+
+- `ai-slop-remover`
+- `comment-checker`
+- `debugging`
+- `frontend-ui-ux`
+- `lsp`
+- `programming`
+- `refactor`
+- `remove-ai-slops`
+- `review-work`
+- `rules`
+- `litgoal`
+
+LitClaude now ships those names or Claude-native equivalents, plus LitClaude
+workflow additions:
+
+- `start-work`
+- `review-work`
+- `litgoal`
+- `lit-loop`
+- `lit-plan`
+
+## v0.2.0 Operator Contract
+
+The v0.2.0 workflow parity documentation is intentionally local-first. It does
+not claim npm publication, remote marketplace registration, or public promotion.
+The publish boundary remains explicit user approval, and uninstall remains
+limited to LitClaude-managed state.
+
+Review work uses a 5-lane review: goal/constraint verification, hands-on QA
+execution, code quality, security, and local-first context mining. Manual-QA
+channels must leave artifacts and a cleanup receipt. Litgoal state is managed
+with:
+
+```bash
+litclaude litgoal create-goals --brief "<brief>" --json
+litclaude litgoal record-evidence --criterion <id> --status pass --json '{"artifact":"...","cleanup":"..."}'
+litclaude litgoal checkpoint --status active --note "<progress>" --json
+litclaude litgoal steer --kind scope --note "<what changed and why>" --json
+```
+
+Current docs/test reads override stale state during audits. Prompt text is not
+executed or echoed, and malformed input should produce a controlled error.
+
+The original `ai-slop-remover` command-facing name is preserved as an
+alias-style skill so older operator muscle memory still has a matching Claude
+surface. `remove-ai-slops` remains the broader LitClaude cleanup skill.
+
+## Auxiliary Packs
+
+The deeper workflow skills rely on files beyond `SKILL.md`. LitClaude now
+packages the high-value portable auxiliary packs:
+
+- `programming/references`
+- `programming/scripts`
+- `debugging/references`
+
+These packs carry language/runtime-specific guidance for TypeScript, Python,
+Rust, Go, debugging methodology, runtime probes, and tool usage. Non-Claude
+coordination examples in the debugging references were rewritten as Claude
+workflow/subagent pseudocode so they do not instruct Claude Code to call missing
+tools literally.
+
+## Deliberate Omissions
+
+The following reference workflow content was audited but not copied into the
+runtime package:
+
+- Web/landing app: not part of the Claude Code plugin runtime.
+- GitHub Actions and npm publish workflows: this repository uses manual user
+  publication.
+- Telemetry network component: omitted to keep LitClaude local and quiet.
+- Full component TypeScript packages for rules/comment-checker/LSP/litgoal:
+  represented by Claude-native hook/skill/MCP/LSP surfaces where portable, not
+  vendored wholesale.
+
+If any of those become desired runtime features, they should be introduced with
+their own tests and explicit user approval.