lazyclaude-ai 0.1.4 → 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.3-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.
 
-The current public package is `lazyclaude-ai@0.1.3` 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.
@@ -30,11 +30,17 @@ Future package releases still require explicit user approval.
 - **ULW prompt hooks** - type `ulw`, `ultrawork`, `$ulw-plan`, or `$ulw-loop`
 - **Native goal guidance** - ULW context points Claude toward `/goal` or
   model-facing `get_goal`, `create_goal`, and delayed `update_goal` when those
-  surfaces exist
+  surfaces exist, and gives a clear fallback when goal tools are unavailable
 - **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.3 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.3 install
+npx --yes lazyclaude-ai@0.1.7 install
 ```
 
 Validate the installed plugin:
@@ -134,9 +140,15 @@ LazyClaude does not auto-type `/goal` or send slash command text for you.
 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. For large independent work, the guidance also
-points Claude toward Dynamic workflow orchestration and Dynamic worktree
-isolation.
+completion or a genuine blocker. When goal tools are unavailable or not exposed,
+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
+`EnterWorktree`. If only the CLI surface is available for a fresh isolated lane,
+use `claude --worktree <short-name> --tmux`.
 
 Plain `ulw` is hook context activation. Claude may still show it as hook
 guidance rather than a separate Skill tool invocation in history. Use visible
@@ -148,6 +160,10 @@ namespaced commands when you want explicit LazyClaude skill activation:
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+Those namespaced commands are shipped as real Claude Code command files under
+`plugins/lazyclaude/commands/`, so `/lazyclaude:ulw-loop` should load the
+command body, then the matching skill guidance.
+
 ## Commands
 
 | Command | Purpose |
@@ -224,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.3-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을 불러올 수 있습니다.
 
-현재 공개 npm 패키지는 `lazyclaude-ai@0.1.3`입니다. 목적은 다른 PC에서도
+현재 checkout은 `lazyclaude-ai@0.1.7` 배포용으로 준비되어 있습니다. 목적은 다른 PC에서도
 빠르게 설치하기 위한 개인용 배포물입니다. 저장소는 비공개 저장소로
 유지할 수 있고, npm 배포가 곧 홍보, 공개 저장소 운영, Claude marketplace
 등록을 의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
@@ -35,10 +35,16 @@
 - **ULW prompt hook** - `ulw`, `ultrawork`, `$ulw-plan`, `$ulw-loop` 트리거
 - **Native goal guidance** - Claude Code가 `/goal` 또는 `get_goal`,
   `create_goal`, `update_goal` 같은 goal surface를 제공하면 이를 우선
-  사용하도록 유도
+  사용하도록 유도하고, 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.3 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.3 install
+npx --yes lazyclaude-ai@0.1.7 install
 ```
 
 설치 상태를 확인합니다.
@@ -137,9 +143,14 @@ LazyClaude는 `/goal`을 대신 입력하거나 slash command text를 자동 전
 않습니다. 대신 hook과 ULW skill이 run context를 보강합니다. Claude Code의
 native goal surface가 있으면 `get_goal`을 먼저 확인하고, matching active
 goal이 없을 때만 `create_goal`을 호출하며, `update_goal`은 검증 완료 또는
-진짜 blocker가 있을 때까지 미루도록 안내합니다. 큰 독립 작업에서는 Dynamic
-workflow orchestration과 Dynamic worktree isolation도 함께 고려하도록
-유도합니다.
+진짜 blocker가 있을 때까지 미루도록 안내합니다. goal tools are unavailable,
+즉 model-facing goal tools가 이 Claude Code session에 노출되지 않은 경우에는
+로컬 evidence ledger를 기준으로 계속 진행하고, 긴 실행 전에 필요한 경우에만
+정확한 `/goal <completion condition>`를 제안합니다. 큰 독립 작업에서는
+같은 원칙을 Claude Code가 노출한 orchestration surface에 적용합니다.
+`Workflow`가 노출되면 `Workflow` tool을 호출하고, isolated edit lane이
+model-facing worktree를 필요로 하면 `EnterWorktree`를 사용합니다. CLI surface만
+가능한 새 격리 lane에서는 `claude --worktree <short-name> --tmux`를 사용합니다.
 
 단순히 `ulw`라고 입력하는 것은 hook context activation입니다. Claude Code
 history에는 별도 Skill tool invocation이 아니라 hook guidance로 보일 수
@@ -152,6 +163,10 @@ command를 사용합니다.
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+이 namespaced command들은 `plugins/lazyclaude/commands/` 아래 실제 Claude Code
+command file로 배포됩니다. 따라서 `/lazyclaude:ulw-loop`는 command body를 먼저
+로드하고, 이어서 대응 skill guidance를 따라가야 합니다.
+
 ## 명령어
 
 | 명령어 | 용도 |
@@ -230,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: quiet public npm package `lazyclaude-ai@0.1.3` is published for
-personal install convenience after explicit user approval.
+Status: this checkout is prepared for quiet public npm package
+`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.3 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

@@ -38,9 +38,17 @@ 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.
 
-For broad work, the same context can steer Claude toward Dynamic workflow
-orchestration and Dynamic worktree isolation so independent work proceeds with
-bounded evidence paths and without mutating unrelated workspace state.
+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 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
+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`.
 
 Plain `ulw` therefore activates hook context, not a visible Skill tool call.
 For a visible LazyClaude command/skill invocation, use the namespaced Claude
@@ -52,6 +60,8 @@ Code commands:
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+These are real Claude Code command files in `plugins/lazyclaude/commands/`.
+
 ## Safety
 
 Hooks parse JSON from stdin and return JSON to Claude Code. The hook does not

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,10 +7,11 @@ 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 |
-| Codex parallel orchestration | Claude Code Dynamic workflow and Dynamic worktree surfaces | Use Dynamic workflow for broad independent work and Dynamic worktree isolation for risky or parallel edits |
+| Codex 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 |
 | Codex hooks | Claude Code hooks | `plugins/lazyclaude/hooks/hooks.json` |
 | Codex MCP helpers | Claude Code plugin MCP config | `plugins/lazyclaude/.mcp.json` |
 | Codex LSP integration | Claude Code plugin LSP config | `plugins/lazyclaude/.lsp.json` |
@@ -54,11 +55,19 @@ 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, LazyClaude should not
+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
-`/goal`. For multi-lane work, LazyClaude should prefer Dynamic workflow
-orchestration where available and Dynamic worktree isolation when parallel or
-risky edits might otherwise collide.
+`/goal`. For multi-lane work, LazyClaude 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`.
 
 If OMC/omc is already installed in Claude Code, keep it disabled or start a
 separate Claude Code session without OMC while testing LazyClaude. This repo no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaude-ai",
-  "version": "0.1.4",
+  "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.3",
+  "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/bin/lazyclaude-hook.js

@@ -41,10 +41,11 @@ const ultraworkContext = [
   "ULTRAWORK MODE ENABLED.",
   "Treat this prompt as an explicit request to use LazyClaude ulw-loop discipline now; load or follow /lazyclaude:ulw-loop / Skill(ulw-loop) semantics before ordinary task execution.",
   "Use evidence-bound planning, tests, manual QA, and cleanup receipts.",
-  "Native goal integration: when Claude Code exposes /goal or model-facing goal tools, first inspect get_goal, call create_goal with an objective-only payload when no matching goal is active, and reserve update_goal for verified completion or a genuine blocker.",
+  "Native goal tool integration: only when Claude Code exposes model-facing goal tools, first inspect get_goal, call create_goal with an objective-only payload when no matching goal is active, and reserve update_goal for verified completion or a genuine blocker.",
+  "Native /goal fallback: if model-facing goal tools are unavailable or not exposed, say so explicitly and ask the user to bind the native Claude Code goal with /goal <completion condition>; continue with the LazyClaude ledger fallback when they decline or the surface is absent.",
   "Do not auto-type or inject the user's slash commands; treat /goal as Claude Code's native goal surface, not as prompt text for this hook to send.",
-  "Dynamic workflow: for large independent work, prefer Claude Code Dynamic workflows or subagents with explicit criteria and artifacts.",
-  "Dynamic worktree: isolate risky or parallel edits in the active Claude Code worktree/workspace and never mutate unrelated user state.",
+  "Dynamic workflow integration: when Claude Code exposes the Workflow tool and the task is broad, risky, parallel, or long-running, call the Workflow tool before serial execution and bind each lane to explicit criteria, artifacts, and cleanup receipts.",
+  "Dynamic worktree integration: when Claude Code exposes EnterWorktree and isolated edits are needed, use EnterWorktree for the selected lane; otherwise use or recommend claude --worktree <short-name> --tmux. Never mutate unrelated user state.",
 ].join(" ");
 
 const input = readInput();

package/plugins/lazyclaude/commands/start-work.md

@@ -0,0 +1,21 @@
+---
+description: Execute a checked plan with LazyClaude start-work discipline.
+argument-hint: '<plan-file>'
+---
+
+Use the `start-work` skill for the user's current plan file or command
+arguments.
+
+Before the first checkbox, bootstrap Claude Code-native workflow state:
+
+- Use `get_goal` and `create_goal` only if model-facing goal tools are exposed.
+- If goal tools are unavailable, ask the user to set a native `/goal` completion
+  condition for the plan before multi-turn execution.
+- For broad, risky, parallel, or long-running checkbox waves, call the
+  `Workflow` tool when Claude Code exposes it.
+- For isolated edit lanes, use `EnterWorktree` when exposed; otherwise launch
+  or recommend `claude --worktree <short-name> --tmux`.
+
+Then execute the first unchecked top-level checkbox with failing-test-first
+implementation, automated verification, manual QA evidence, cleanup receipts,
+and ledger updates.

package/plugins/lazyclaude/commands/ulw-loop.md

@@ -0,0 +1,24 @@
+---
+description: Run LazyClaude ULW loop discipline with goal and Dynamic workflow bootstrap.
+argument-hint: '<objective>'
+---
+
+Use the `ulw-loop` skill for the user's current objective or command arguments.
+
+Before implementation, bootstrap Claude Code-native workflow state:
+
+1. If model-facing goal tools are available in this session, inspect `get_goal`,
+   call `create_goal` only when no matching goal exists, and reserve
+   `update_goal` for verified completion or a genuine blocker.
+2. If goal tools are unavailable, state that plainly and ask the user to bind
+   the native Claude Code goal with this exact surface before long execution:
+   `/goal <completion condition for the current objective>`.
+3. For broad, risky, parallel, or long-running work, call the `Workflow` tool
+   when Claude Code exposes it. Bind every lane to explicit criteria, evidence
+   artifacts, and cleanup receipts.
+4. When isolated edits are needed, use `EnterWorktree` when Claude Code exposes
+   it. If only the CLI surface is available, tell the user the concrete launch
+   form: `claude --worktree <short-name> --tmux`.
+
+Then continue with evidence-bound success criteria, tests, manual QA artifacts,
+cleanup receipts, and explicit release approval boundaries.

package/plugins/lazyclaude/commands/ulw-plan.md

@@ -0,0 +1,22 @@
+---
+description: Plan LazyClaude work with explicit goal, Dynamic workflow, and QA criteria.
+argument-hint: '<planning brief>'
+---
+
+Use the `ulw-plan` skill for the user's current planning brief or command
+arguments.
+
+The plan must include Claude Code-native bootstrap steps:
+
+- If model-facing goal tools are exposed, use `get_goal`, `create_goal`, and
+  delayed `update_goal` exactly as native goal state, not as slash-command text.
+- If goal tools are unavailable, include the exact user-visible `/goal`
+  completion condition to bind before execution.
+- For independent, risky, parallel, or long-running work, include when Claude
+  should call the `Workflow` tool and how each lane proves its evidence.
+- For isolated edit lanes, include when to use `EnterWorktree`; if only the CLI
+  surface is available, include `claude --worktree <short-name> --tmux`, plus
+  evidence paths and cleanup.
+
+Write the plan under `plans/` and keep it executable: concrete files, tests,
+manual QA, cleanup, and publish/remote-mutation guardrails.

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.
+```