lazyclaude-ai 0.1.5 → 0.1.7

package/CHANGELOG.md

@@ -0,0 +1,11 @@
+# Changelog
+
+## 0.1.7 - Unreleased
+
+- Expand the LazyCodex port audit beyond skill frontmatter into upstream OMO
+  component coverage.
+- Ship the original `ai-slop-remover` skill alias alongside the LazyClaude
+  `remove-ai-slops` skill.
+- Include LazyCodex programming and debugging auxiliary reference packs so the
+  Claude plugin carries the same deep language/runtime guidance, not only short
+  summary skills.

package/README.md

@@ -9,7 +9,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-lazyclaude--ai-cb3837" />
-  <img src="https://img.shields.io/badge/version-0.1.5-2ea44f" />
+  <img src="https://img.shields.io/badge/version-0.1.7-2ea44f" />
   <img src="https://img.shields.io/badge/Claude%20Code-plugin-blueviolet" />
   <img src="https://img.shields.io/badge/license-MIT-blue" />
 </p>
@@ -19,7 +19,7 @@
 > [!NOTE]
 > LazyClaude is a quiet personal distribution for bringing LazyCodex-style prompt engineering into Claude Code. It installs as `lazyclaude@lazyclaude-ai`, so normal `claude` launches can load the LazyClaude skills and hooks without a long `--plugin-dir` command.
 
-This checkout is prepared as `lazyclaude-ai@0.1.5` for personal install
+This checkout is prepared as `lazyclaude-ai@0.1.7` for personal install
 convenience. The repo can remain private and quiet; publishing to npm here does
 not imply public repo promotion, marketplace publication, or advertisement.
 Future package releases still require explicit user approval.
@@ -34,7 +34,13 @@ Future package releases still require explicit user approval.
 - **Dynamic workflow/worktree guidance** - large or parallel tasks are steered
   toward Claude Code Dynamic workflow orchestration and Dynamic worktree
   isolation
-- **Claude skills** - `ulw-plan`, `ulw-loop`, `start-work`, `rules`, `lsp`, `programming`, and `review-work`
+- **Claude skills** - a richer LazyCodex-style corpus: `programming`,
+  `debugging`, `refactor`, `ai-slop-remover`, `remove-ai-slops`, `review-work`,
+  `frontend-ui-ux`, `comment-checker`, `rules`, `lsp`, `ultragoal`,
+  `ulw-plan`, `ulw-loop`, and `start-work`
+- **LazyCodex auxiliary packs** - ships `programming/references`,
+  `programming/scripts`, and `debugging/references` for deeper language and
+  runtime guidance
 - **Workflow agents** - planner, executor, verifier, reviewer, librarian, and QA runner
 - **Local marketplace registration** - Claude can resolve `claude plugin details lazyclaude@lazyclaude-ai`
 - **MCP and LSP helpers** - plugin-local stdio MCP plus TypeScript-family LSP doctor
@@ -49,14 +55,14 @@ npx --yes lazyclaude-ai install
 ```
 
 If you are currently inside this repository checkout, which has the same
-package name as the registry package, `npx --yes lazyclaude-ai@0.1.5 install`
+package name as the registry package, `npx --yes lazyclaude-ai@0.1.7 install`
 can resolve the local same-name source checkout and fail with
 `sh: lazyclaude-ai: command not found`. From a fresh directory, the normal
 install command works:
 
 ```bash
 cd /tmp
-npx --yes lazyclaude-ai@0.1.5 install
+npx --yes lazyclaude-ai@0.1.7 install
 ```
 
 Validate the installed plugin:
@@ -135,8 +141,9 @@ Instead, the hook and ULW skills add run-context guidance: use Claude Code's
 native goal surface when available, inspect `get_goal`, call `create_goal` only
 when no matching goal is active, and reserve `update_goal` for verified
 completion or a genuine blocker. When goal tools are unavailable or not exposed,
-LazyClaude now tells Claude to say that plainly and ask you to bind the native
-session goal with an exact `/goal <completion condition>` before long execution.
+LazyClaude keeps the local evidence ledger authoritative and may suggest an
+exact `/goal <completion condition>` before long execution without repeatedly
+printing fallback chatter.
 For large independent work, LazyClaude applies the same principle to Claude
 Code's available orchestration surfaces: when `Workflow` is exposed, call the
 `Workflow` tool; when isolated edits need a model-facing worktree lane, use
@@ -233,5 +240,6 @@ version probe evidence instead of failing mysteriously.
 | LSP | `plugins/lazyclaude/.lsp.json` |
 
 See `README_ko-KR.md` for Korean setup notes, `REFERENCE.md` for the pinned
-LazyCodex source, and `docs/migration.md` for the Codex-to-Claude migration
-table.
+LazyCodex source, `docs/migration.md` for the Codex-to-Claude migration table,
+`docs/lazycodex-port-audit.md` for the current port audit, and `CHANGELOG.md`
+for release notes.

package/README_ko-KR.md

@@ -9,7 +9,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-lazyclaude--ai-cb3837" />
-  <img src="https://img.shields.io/badge/version-0.1.5-2ea44f" />
+  <img src="https://img.shields.io/badge/version-0.1.7-2ea44f" />
   <img src="https://img.shields.io/badge/Claude%20Code-plugin-blueviolet" />
   <img src="https://img.shields.io/badge/license-MIT-blue" />
 </p>
@@ -23,7 +23,7 @@
 > [!NOTE]
 > LazyClaude는 LazyCodex 스타일의 prompt engineering을 Claude Code로 가져오기 위한 조용한 개인용 배포판입니다. `lazyclaude@lazyclaude-ai`로 설치되므로, 매번 긴 `--plugin-dir` 없이 일반 `claude` 실행에서 LazyClaude skill과 hook을 불러올 수 있습니다.
 
-현재 checkout은 `lazyclaude-ai@0.1.5` 배포용으로 준비되어 있습니다. 목적은 다른 PC에서도
+현재 checkout은 `lazyclaude-ai@0.1.7` 배포용으로 준비되어 있습니다. 목적은 다른 PC에서도
 빠르게 설치하기 위한 개인용 배포물입니다. 저장소는 비공개 저장소로
 유지할 수 있고, npm 배포가 곧 홍보, 공개 저장소 운영, Claude marketplace
 등록을 의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
@@ -38,7 +38,13 @@
   사용하도록 유도하고, goal tools are unavailable 상황의 fallback도 명시
 - **Dynamic workflow/worktree guidance** - 크거나 병렬적인 작업은 Claude
   Code Dynamic workflow와 Dynamic worktree 격리 쪽으로 유도
-- **Claude skills** - `ulw-plan`, `ulw-loop`, `start-work`, `rules`, `lsp`, `programming`, `review-work`
+- **Claude skills** - LazyCodex 스타일을 더 풍부하게 옮긴 corpus:
+  `programming`, `debugging`, `refactor`, `ai-slop-remover`, `remove-ai-slops`,
+  `review-work`, `frontend-ui-ux`, `comment-checker`, `rules`, `lsp`,
+  `ultragoal`, `ulw-plan`, `ulw-loop`, `start-work`
+- **LazyCodex auxiliary packs** - `programming/references`,
+  `programming/scripts`, `debugging/references`까지 포함해서 언어별,
+  런타임별 세부 지침을 보존
 - **워크플로우 agents** - planner, executor, verifier, reviewer, librarian, QA runner
 - **Local marketplace 등록** - `claude plugin details lazyclaude@lazyclaude-ai`에서 inventory 확인
 - **MCP와 LSP helper** - plugin-local stdio MCP와 TypeScript 계열 LSP doctor
@@ -54,13 +60,13 @@ npx --yes lazyclaude-ai install
 
 현재 위치가 이 저장소 checkout이면, registry package와 같은 package name을
 가진 same-name source checkout 안에 있는 상태입니다. 이 경우
-`npx --yes lazyclaude-ai@0.1.5 install`이 local checkout을 먼저 해석해서
+`npx --yes lazyclaude-ai@0.1.7 install`이 local checkout을 먼저 해석해서
 `sh: lazyclaude-ai: command not found`로 실패할 수 있습니다. 새 폴더에서는
 일반 설치 명령이 정상 동작합니다.
 
 ```bash
 cd /tmp
-npx --yes lazyclaude-ai@0.1.5 install
+npx --yes lazyclaude-ai@0.1.7 install
 ```
 
 설치 상태를 확인합니다.
@@ -139,8 +145,8 @@ native goal surface가 있으면 `get_goal`을 먼저 확인하고, matching act
 goal이 없을 때만 `create_goal`을 호출하며, `update_goal`은 검증 완료 또는
 진짜 blocker가 있을 때까지 미루도록 안내합니다. goal tools are unavailable,
 즉 model-facing goal tools가 이 Claude Code session에 노출되지 않은 경우에는
-그 한계를 먼저 말하고, 긴 실행 전에 정확한 `/goal <completion condition>`로
-native session goal을 묶어달라고 요청하도록 했습니다. 큰 독립 작업에서는
+로컬 evidence ledger를 기준으로 계속 진행하고, 긴 실행 전에 필요한 경우에만
+정확한 `/goal <completion condition>`를 제안합니다. 큰 독립 작업에서는
 같은 원칙을 Claude Code가 노출한 orchestration surface에 적용합니다.
 `Workflow`가 노출되면 `Workflow` tool을 호출하고, isolated edit lane이
 model-facing worktree를 필요로 하면 `EnterWorktree`를 사용합니다. CLI surface만
@@ -239,4 +245,5 @@ probe evidence를 남깁니다.
 | LSP | `plugins/lazyclaude/.lsp.json` |
 
 영문 설명은 `README.md`, LazyCodex 출처 고정 정보는 `REFERENCE.md`,
-Codex-to-Claude 변환 표는 `docs/migration.md`를 참고하세요.
+Codex-to-Claude 변환 표는 `docs/migration.md`, 현재 port audit은
+`docs/lazycodex-port-audit.md`, release notes는 `CHANGELOG.md`를 참고하세요.

package/REFERENCE.md

@@ -7,7 +7,7 @@ Claude docs snapshot: 2026-05-31
 
 - Repository: https://github.com/code-yeongyu/lazycodex
 - Pinned tree: https://github.com/code-yeongyu/lazycodex/tree/3fb8802e314dc0a1f23481dd3782cdca26b92dc2
-- Observed reference clone: `/tmp/lazycodex-ref`
+- Observed reference clone: `/tmp/lazycodex-reference`
 
 ## Migration Table
 
@@ -15,6 +15,7 @@ Claude docs snapshot: 2026-05-31
 | --- | --- | --- |
 | `.codex-plugin/plugin.json` | `.claude-plugin/plugin.json` | Plugin identity and component paths are translated, not copied. |
 | Codex skills | Claude Code `skills/<name>/SKILL.md` | Skills keep workflow intent and remove Codex-only tool names. |
+| Codex skill reference packs | Claude Code skill auxiliary files | `programming/references`, `programming/scripts`, and `debugging/references` are packaged with Claude-safe coordination wording. |
 | Codex hooks | Claude Code `hooks/hooks.json` | Hook events are mapped to Claude tool names and JSON stdin behavior. |
 | Codex MCP config | Claude Code `.mcp.json` | Local helper tools stay plugin-scoped. |
 | Codex LSP MCP component | Claude Code `.lsp.json` | MVP starts with TypeScript/JavaScript. |

package/RELEASE_CHECKLIST.md

@@ -1,7 +1,7 @@
 # LazyClaude Release Checklist
 
 Status: this checkout is prepared for quiet public npm package
-`lazyclaude-ai@0.1.5` after explicit user approval.
+`lazyclaude-ai@0.1.7` after explicit user approval.
 
 DO NOT publish a new version of LazyClaude, run `npm publish`, push release
 tags, or add a remote Claude Code marketplace entry without explicit user
@@ -44,7 +44,7 @@ to type a generated command that shells out to `npx --yes lazyclaude-ai path` fo
 normal npm installs.
 
 Run fresh-machine QA from a fresh directory, not from this repository checkout.
-Inside the same-name source checkout, `npx --yes lazyclaude-ai@0.1.5 install`
+Inside the same-name source checkout, `npx --yes lazyclaude-ai@0.1.7 install`
 can resolve the local package and fail with `sh: lazyclaude-ai: command not
 found`. Use `cd /tmp` for the fresh directory scenario, or use the explicit
 fresh-prefix form:

package/docs/hooks.md

@@ -39,10 +39,9 @@ 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 tells Claude to say that explicitly and ask the user to bind the
-native session goal with `/goal <completion condition>` before long execution.
-LazyClaude then continues with its ledger fallback when the user declines or the
-surface is absent.
+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 ULW turn.
 
 For broad work, the same context ports the LazyCodex model-facing principle to
 Claude Code's exposed orchestration surfaces: if `Workflow` is available, call

package/docs/lazycodex-port-audit.md

@@ -0,0 +1,78 @@
+# LazyCodex Port Audit
+
+Reference snapshot: `code-yeongyu/lazycodex` commit
+`3fb8802e314dc0a1f23481dd3782cdca26b92dc2`.
+
+This document tracks the LazyCodex/OMO surfaces checked during the deeper
+LazyClaude port pass. The goal is to keep future updates honest: if the upstream
+plugin grows a new user-facing skill, hook, or runtime behavior, this map should
+make the missing LazyClaude target obvious.
+
+## Ported Runtime Concepts
+
+| LazyCodex / OMO source | LazyClaude target | Status |
+| --- | --- | --- |
+| `components/comment-checker` | `skills/comment-checker`, `PostToolUse` hook guidance | Ported as Claude-native skill and hook prompt guidance. |
+| `components/lsp` | `.lsp.json`, `.mcp.json`, `bin/lazyclaude-lsp-doctor.js`, `skills/lsp` | Ported as lightweight Claude Code LSP/MCP helper rather than vendoring the full Codex MCP package. |
+| `components/rules` | `skills/rules`, `SessionStart` / `PostCompact` hook behavior | Ported as Claude session rule guidance and cache-reset messaging. |
+| `components/ultragoal` | `skills/ultragoal`, `ulw-*`, `start-work` goal guidance | Ported to Claude-native goal wording, preserving evidence/ledger/quality-gate discipline. |
+| `components/ultrawork` | `commands/ulw-loop.md`, `commands/ulw-plan.md`, `skills/ulw-loop`, `skills/ulw-plan` | Ported to Claude skills, commands, agents, workflow/worktree guidance, and UserPromptSubmit hook injection. |
+| `components/telemetry` | No runtime telemetry | Intentionally not ported as network telemetry. LazyClaude remains quiet/local by default. |
+
+## Ported Skill Corpus
+
+LazyCodex aggregate skills include:
+
+- `ai-slop-remover`
+- `comment-checker`
+- `debugging`
+- `frontend-ui-ux`
+- `lsp`
+- `programming`
+- `refactor`
+- `remove-ai-slops`
+- `review-work`
+- `rules`
+- `ultragoal`
+
+LazyClaude now ships those names or Claude-native equivalents, plus LazyClaude
+workflow additions:
+
+- `start-work`
+- `ulw-loop`
+- `ulw-plan`
+
+The original `ai-slop-remover` name is preserved as an alias-style skill so
+upstream LazyCodex prompts that call that name still have a matching Claude
+surface. `remove-ai-slops` remains the broader LazyClaude cleanup skill.
+
+## Auxiliary Packs
+
+The deeper LazyCodex skills rely on files beyond `SKILL.md`. LazyClaude 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. OpenCode-only
+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 Non-Ports
+
+The following upstream repository content was audited but not copied into the
+runtime package:
+
+- LazyCodex web/landing app: not part of the Claude Code plugin runtime.
+- GitHub Actions and npm publish workflows: this repository uses manual user
+  publication.
+- OMO telemetry network component: omitted to keep LazyClaude local and quiet.
+- Full component TypeScript packages for rules/comment-checker/LSP/ultragoal:
+  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.

package/docs/migration.md

@@ -7,6 +7,7 @@ of surface, and a conservative local fallback where it does not.
 | Codex surface | Claude Code surface | LazyClaude implementation |
 | --- | --- | --- |
 | Codex CLI prompt engineering | Claude Code skills | `plugins/lazyclaude/skills/*/SKILL.md` |
+| Codex auxiliary skill packs | Claude Code skill auxiliary files | `programming/references`, `programming/scripts`, and `debugging/references` are included where portable |
 | Codex ultrawork plan mode | Claude Code skill plus planner agent | `ulw-plan` and `prometheus-planner` |
 | Codex execution loop | Claude Code skill plus executor agent | `ulw-loop`, `start-work`, and `boulder-executor` |
 | Codex 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 |
@@ -56,8 +57,9 @@ 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, LazyClaude should not
-pretend the native goal was bound. It should state the limitation and ask the
-user to run `/goal <completion condition>` before long-running ULW execution.
+pretend the native goal was bound. It keeps the local evidence ledger
+authoritative and may suggest `/goal <completion condition>` before
+long-running ULW execution without repeatedly printing fallback chatter.
 
 When the user explicitly chooses Claude Code `/goal`, that native session goal
 remains user-visible and user-controlled. LazyClaude does not auto-type

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaude-ai",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Claude Code-native LazyCodex-style workflow distribution.",
   "type": "module",
   "bin": {
@@ -14,6 +14,7 @@
     "scripts",
     "README.md",
     "README_ko-KR.md",
+    "CHANGELOG.md",
     "cover.png",
     "generate_cover.py",
     "REFERENCE.md",

package/plugins/lazyclaude/.claude-plugin/plugin.json

@@ -1,12 +1,12 @@
 {
   "name": "lazyclaude",
   "description": "Claude Code-native LazyCodex-style workflow plugin.",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "author": {
     "name": "LazyClaude contributors"
   },
-  "homepage": "https://github.com/code-yeongyu/lazycodex",
-  "repository": "https://github.com/code-yeongyu/lazycodex",
+  "homepage": "https://github.com/wjgoarxiv/lazyclaude",
+  "repository": "https://github.com/wjgoarxiv/lazyclaude",
   "license": "MIT",
   "keywords": ["claude-code", "hooks", "skills", "agents", "lsp", "workflow"],
   "skills": "./skills",

package/plugins/lazyclaude/skills/ai-slop-remover/SKILL.md

@@ -0,0 +1,142 @@
+---
+name: ai-slop-remover
+description: "Removes AI-generated code smells from a SINGLE file while preserving functionality. For multiple files, run per file in parallel."
+---
+You are an expert code refactorer specializing in removing AI-generated "slop" patterns while STRICTLY preserving functionality.
+
+**INPUT**: Exactly ONE file path. If multiple paths provided, REJECT and instruct to run one LazyClaude pass per file.
+
+---
+
+## DETECTION CRITERIA (Specific)
+
+### 1. Obvious Comments (EXCLUDE: BDD comments like #given, #when, #then, #when/then)
+
+**REMOVE**:
+- Comments restating the code: `x += 1  # increment x`
+- Docstrings on trivial methods: `"""Returns the name."""` for `def get_name(): return self.name`
+- Section dividers: `# ===== HELPER FUNCTIONS =====`
+- Commented-out code blocks
+- `# TODO: future enhancement` without concrete plan
+- `# Note: this is important` without explaining WHY
+
+**KEEP**:
+- Comments explaining WHY (business logic, edge cases, workarounds)
+- Links to issues/tickets: `# See SPR-1234`
+- Non-obvious algorithm explanations
+- Regex explanations
+- Matches to existing code style
+
+### 2. Over-Defensive Code
+
+**REMOVE**:
+- Null checks for values that CANNOT be None (e.g., Django request in view)
+- `if x is not None and x.attr is not None:` when x is guaranteed
+- Try-except around code that can't raise (e.g., dict literal access)
+- `isinstance()` checks for statically typed parameters
+- Default values for required parameters: `def foo(x: str = "")` when empty string is invalid
+- Backward-compat shims: `_old_name = new_name  # deprecated`
+- `# removed` or `# deleted` comments for removed code
+- Re-exports of unused items
+- Verbose, duplicated, or redundant code / test cases
+
+**KEEP**:
+- Validation at system boundaries (user input, external API responses)
+- Error handling for I/O operations
+- Null checks for nullable DB fields
+- assertions in test code to matching type expectations
+
+### 3. Spaghetti Nesting (2+ levels deep)
+
+**REFACTOR**:
+- Nested if-else chains -> early returns / guard clauses
+- `if x: if y: if z:` -> `if not x: return` / `if not y: return`
+- Nested loops with conditionals -> extract to helper OR use comprehensions
+- Complex ternary `a if b else (c if d else e)` -> explicit if-else
+
+---
+
+## PROCESS
+
+### Step 1: Read & Analyze
+Read the file. Identify ALL slop instances with line numbers.
+
+### Step 2: Deep Consideration (CRITICAL)
+For EACH identified issue, think:
+- **Functionality Impact**: Will removing this change behavior? If ANY doubt, SKIP.
+- **Test Coverage**: Are there tests that might break? If uncertain, SKIP.
+- **Context Dependency**: Is this "slop" actually necessary for this specific codebase? (e.g., defensive code for known flaky external API)
+- **Readability Trade-off**: Will removal make code LESS readable? If yes, SKIP.
+
+**RULE**: When in doubt, DO NOT CHANGE. False negatives are better than breaking code.
+
+### Step 3: Execute Changes
+Make changes using Claude Code edit tools. One logical change at a time.
+
+### Step 4: Detailed Report
+
+**OUTPUT FORMAT**:
+
+```
+## AI Slop Removed: {filename}
+
+### Analysis Summary
+- Total issues found: N
+- Issues fixed: M
+- Issues skipped (safety): K
+
+### Changes Made
+
+#### Change 1: [Category] Line X-Y
+**Before**: [original code snippet]
+**After**: [modified code snippet]
+**Why this is slop**: [Explain why this pattern is problematic]
+**Why safe to remove**: [Explain why functionality is preserved]
+**Impact**: None - purely cosmetic improvement
+
+---
+
+### Skipped Issues (Preserved for Safety)
+
+#### Skipped 1: Line X
+**Reason**: [Why you chose not to change this]
+
+### Summary
+- Removed N obvious comments
+- Simplified M defensive patterns
+- Flattened K nested structures
+- Preserved L patterns that looked like slop but serve purpose
+```
+
+---
+
+## SAFETY RULES
+
+1. **NEVER remove error handling for I/O, network, or file operations**
+2. **NEVER simplify validation for user input or external data**
+3. **NEVER change public API signatures**
+4. **NEVER remove type hints (even redundant-looking ones)**
+5. **If a pattern appears in multiple places, it might be intentional - ASK before bulk removal**
+6. **Preserve all BDD test comments (#given, #when, #then)**
+
+When finished, your report should be detailed enough that a reviewer can understand EXACTLY what changed and feel confident the changes are safe.
+
+---
+
+## WHEN NO SLOP FOUND
+
+If the file is clean, report:
+
+```
+## AI Slop Analysis: {filename}
+
+### Result: No AI Slop Detected
+
+This file is clean. Here's why:
+
+**Comments**: N comments found, all explain WHY not WHAT
+**Defensive Code**: Null checks present are appropriate (e.g., checks external API response)
+**Code Structure**: Maximum nesting depth acceptable, early returns used appropriately
+
+**Conclusion**: This code appears to be human-written or well-reviewed AI code. No changes needed.
+```

package/plugins/lazyclaude/skills/comment-checker/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: comment-checker
+description: "Comment hygiene workflow adapted from LazyCodex: keep comments useful, remove stale narration, and preserve intent-bearing notes."
+---
+
+# Comment Checker
+
+Use this skill after code edits or documentation rewrites where comments may
+become stale. The goal is not fewer comments; it is comments that carry intent
+the code or tests cannot express.
+
+## Keep Comments That Explain
+
+Keep comments when they explain:
+
+- why a compatibility path exists
+- why a safety boundary is conservative
+- why a file is generated or packaged
+- why a fallback exists for a specific runtime behavior
+- why a test asserts a policy rather than exact prose
+
+## Remove Comments That Narrate
+
+Remove or rewrite comments that merely repeat code:
+
+- "read the file"
+- "set the variable"
+- "loop through items"
+- "return result"
+
+If the comment is only true because the current implementation happens to work
+that way, prefer a clearer name or a test.
+
+## LazyClaude-Specific Checks
+
+- Comments about Claude registry writes must match actual paths.
+- Comments about `/goal` must not imply the plugin can type it silently.
+- Comments about `--dry-run` must distinguish inspection from final proof.
+- Comments about package contents must match `package.json.files`.
+- Comments in tests should explain policy assertions, not every regex.
+
+## Review Flow
+
+1. Search changed files for comments.
+2. For each comment, ask whether the next maintainer would be worse off without
+   it.
+3. Delete narration.
+4. Update stale intent comments.
+5. Run tests touching the changed files.
+
+## Evidence
+
+For code comments, evidence is the diff plus tests. For docs comments or
+markdown policy notes, evidence is docs tests and one manual scan of the
+rendered or packaged surface when relevant.

package/plugins/lazyclaude/skills/debugging/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: debugging
+description: "Systematic Claude Code debugging workflow adapted from LazyCodex: reproduce, localize, explain root cause, patch minimally, and verify the real failing surface."
+---
+
+# Debugging
+
+Use this skill when behavior is broken, surprising, flaky, or contradicted by
+evidence. Do not patch from vibes. First make the failure reproducible.
+
+## Debugging Loop
+
+1. Reproduce the failure with the smallest command or scenario.
+2. Capture exact output, exit code, log, or transcript.
+3. State expected vs actual behavior.
+4. Localize the failing boundary.
+5. Patch minimally.
+6. Re-run the original reproduction.
+7. Add or update a regression test.
+8. Run one real-surface QA scenario.
+
+## Reproduction Standards
+
+A good reproduction is:
+
+- runnable from the project root
+- deterministic or has a bounded flake note
+- small enough for the next agent to rerun
+- tied to one expected observable
+
+For LazyClaude examples:
+
+- `printf ... | node plugins/lazyclaude/bin/lazyclaude-hook.js user-prompt-submit`
+- `npm exec --yes --package ./ -- lazyclaude-ai --dry-run install`
+- `CLAUDE_CONFIG_DIR=$(mktemp -d) node bin/lazyclaude-ai.js install`
+- `node --test test/hooks.test.mjs --test-name-pattern ultrawork`
+
+## Root Cause Discipline
+
+Explain the mechanism, not just the symptom. "The test failed" is not a root
+cause. "The command markdown mentions `$ARGUMENTS`, which Claude renders empty
+and tests reject as a broken placeholder" is a root cause.
+
+## Common LazyClaude Failure Classes
+
+- npm same-name source checkout causes `npx lazyclaude-ai` resolution confusion.
+- `npm publish` requires OTP and fails with `EOTP`.
+- CLI smoke uses unsupported `--version` and receives usage.
+- Claude Code exposes `/goal` as a slash command but not model-facing tools.
+- Plugin manifest version differs from `package.json`.
+- Hook JSON parsing fails with stack traces instead of controlled errors.
+- Package `files` omit a new skill or command.
+
+## Patch Rules
+
+- Patch the failing boundary, not an unrelated symptom.
+- Keep compatibility aliases unless a breaking change is intentional.
+- Add tests before production behavior changes.
+- Do not broaden catch blocks without asserting the new error path.
+- Do not call network or publish in tests.
+
+## Evidence
+
+Record:
+
+- failing command and output
+- changed file
+- regression test
+- passing command and output
+- manual QA artifact and cleanup