lazyclaude-ai 0.1.2 → 0.1.4

package/README.md

@@ -1,22 +1,62 @@
-# LazyClaude
+<p align="center"><img src="./cover.png" width="100%" /></p>
+
+<h1 align="center">LazyClaude</h1>
+<p align="center">
+  <em>Claude Code-native LazyCodex workflows: prompt hooks, ultrawork skills, agents, MCP, and LSP helpers.</em>
+</p>
+<p align="center">
+  <a href="#quick-start">Quick Start</a> · <a href="#ulw-usage">ULW Usage</a> · <a href="#commands">Commands</a> · <a href="./README_ko-KR.md">한국어</a>
+</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/Claude%20Code-plugin-blueviolet" />
+  <img src="https://img.shields.io/badge/license-MIT-blue" />
+</p>
+
+---
+
+> [!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
+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.
+
+## Features
+
+- **Natural Claude launch** - install once with `npx`, then run plain `claude`
+- **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
+- **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`
+- **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
+- **Safe uninstall** - removes only LazyClaude-managed state
+
+## Quick Start
+
+### Install
 
-LazyClaude is a Claude Code-native retrofit of the LazyCodex workflow style:
-simple local activation, prompt-triggered ultrawork discipline,
-planner/executor/reviewer agents, lifecycle hooks, MCP scaffolding, and
-LSP-backed code checks.
-
-The current public package is `lazyclaude-ai@0.1.1`, and this checkout prepares
-the next `0.1.2` patch 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.
-
-## Quick Install
+```bash
+npx --yes lazyclaude-ai install
+```
 
-Use the npm package from any machine:
+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`
+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
-npx --yes lazyclaude-ai install
+cd /tmp
+npx --yes lazyclaude-ai@0.1.3 install
 ```
 
 Validate the installed plugin:
@@ -31,7 +71,7 @@ Launch Claude Code normally:
 claude
 ```
 
-Alternative entrypoints:
+### Alternative Entrypoints
 
 ```bash
 bunx lazyclaude-ai install
@@ -39,8 +79,9 @@ npm install -g lazyclaude-ai
 lazyclaude install
 ```
 
-If you need the explicit `npm exec` form, use a fresh prefix so npm does not
-confuse the registry package with a same-name source checkout:
+If you need the explicit `npm exec` form while standing inside the source
+checkout, use a fresh prefix so npm does not confuse the registry package with
+a same-name source checkout:
 
 ```bash
 npm exec --prefix "$(mktemp -d)" --yes --package lazyclaude-ai -- lazyclaude install
@@ -52,42 +93,26 @@ Remove only LazyClaude-managed install state:
 npx --yes lazyclaude-ai uninstall
 ```
 
-The installer registers `lazyclaude@lazyclaude-ai` in Claude Code's user plugin
-registry under `~/.claude/plugins` and enables it in `settings.json`
-`enabledPlugins`, so you do not need to type a long `--plugin-dir` command every
-time. Set `CLAUDE_CONFIG_DIR=/some/path` and `LAZYCLAUDE_HOME=/some/path` only
-for isolated tests.
-
-## Local Development
+## How Install Works
 
-Use the plugin directly from this checkout while editing it:
-
-```bash
-claude --plugin-dir ./plugins/lazyclaude
-```
-
-Inside Claude Code, reload local plugin metadata after edits:
-
-```text
-/reload-plugins
-```
+The installer registers `lazyclaude@lazyclaude-ai` in Claude Code's user plugin
+registry under `~/.claude/plugins`, enables it in `settings.json`
+`enabledPlugins`, and writes a LazyClaude-managed local marketplace entry in
+`known_marketplaces.json`. That marketplace metadata is what lets Claude show
+the skill and hook inventory in `claude plugin details`.
 
-If an OMC/omc Claude plugin is installed, do not co-load it with LazyClaude
-while testing this MVP. Local checkout tests use `--plugin-dir`, and npm installs
-create only a LazyClaude-managed local marketplace under the user's LazyClaude
-home. The checkout does not ship a root Claude marketplace skeleton. If
-user-level OMC creates a local `.omc/` state directory during smoke tests,
-LazyClaude ignores and excludes that directory from git and npm package surfaces.
+Use `CLAUDE_CONFIG_DIR=/some/path` and `LAZYCLAUDE_HOME=/some/path` only for
+isolated tests.
 
 ## ULW Usage
 
-LazyClaude is available in normal Claude Code sessions after install:
+After install, start Claude Code:
 
 ```bash
 claude
 ```
 
-Then type one of these prompts in Claude Code:
+Then type one of these prompts:
 
 ```text
 ulw
@@ -98,13 +123,24 @@ $start-work plans/lazyclaude-retrofit.md
 ```
 
 Expected behavior: LazyClaude's prompt hook adds `ULTRAWORK MODE ENABLED`
-context, then the matching skill and agent instructions steer Claude toward
-test-first work, manual QA evidence, cleanup receipts, and explicit approval
-before future release steps.
-
-Plain `ulw` is hook context activation, so it may not show a separate Skill
-tool invocation in Claude Code history. Use visible namespaced commands when
-you want explicit LazyClaude skill or command activation:
+context and shows `LazyClaude ULW hook active` as a visible hook message. The
+hook also tells Claude to treat plain `ulw` as `/lazyclaude:ulw-loop` /
+`Skill(ulw-loop)` semantics before ordinary task execution, then the matching
+skill and agent instructions steer Claude toward test-first work, native goal
+handling, manual QA evidence, cleanup receipts, and explicit approval before
+future release steps.
+
+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.
+
+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
+namespaced commands when you want explicit LazyClaude skill activation:
 
 ```text
 /lazyclaude:ulw-loop <what you want executed with evidence>
@@ -114,14 +150,14 @@ you want explicit LazyClaude skill or command activation:
 
 ## Commands
 
-```bash
-npx --yes lazyclaude-ai install
-npx --yes lazyclaude-ai doctor
-npx --yes lazyclaude-ai path
-npx --yes lazyclaude-ai run -- --help
-npx --yes lazyclaude-ai update
-npx --yes lazyclaude-ai uninstall
-```
+| Command | Purpose |
+| --- | --- |
+| `npx --yes lazyclaude-ai install` | Install and enable the Claude Code plugin |
+| `npx --yes lazyclaude-ai doctor` | Validate files, Claude plugin validation, and plugin details |
+| `npx --yes lazyclaude-ai path` | Print the installed Claude plugin path |
+| `npx --yes lazyclaude-ai run -- --help` | Run plain `claude` after verifying install state |
+| `npx --yes lazyclaude-ai update` | Reinstall the current package version |
+| `npx --yes lazyclaude-ai uninstall` | Remove LazyClaude-managed install state |
 
 The package alias can be inspected without installing anything globally:
 
@@ -130,6 +166,27 @@ node bin/lazyclaude-ai.js --dry-run install
 node bin/lazyclaude-ai.js --dry-run doctor
 ```
 
+## Local Development
+
+Use the plugin directly from this checkout while editing it:
+
+```bash
+claude --plugin-dir ./plugins/lazyclaude
+```
+
+Inside Claude Code, reload local plugin metadata after edits:
+
+```text
+/reload-plugins
+```
+
+If an OMC/omc Claude plugin is installed, do not co-load it with LazyClaude
+while testing. Local checkout tests use `--plugin-dir`, and npm installs create
+only a LazyClaude-managed local marketplace under the user's LazyClaude home.
+The checkout does not ship a root Claude marketplace skeleton. If user-level
+OMC creates a local `.omc/` state directory during smoke tests, LazyClaude
+ignores and excludes that directory from git and npm package surfaces.
+
 ## Verification
 
 ```bash
@@ -146,30 +203,25 @@ version probe evidence instead of failing mysteriously.
 
 ## Safety Model
 
-LazyClaude is intentionally local-first:
-
 - Hooks read Claude Code event JSON from stdin and return bounded JSON context.
 - Hooks do not execute user prompt text.
-- The ultrawork prompt hook returns constant guidance and does not echo prompt
-  text back into the context.
-- Any `.omc/`, `.omo/`, or `evidence/` local state is ignored and is not
-  included in the LazyClaude npm package.
+- The ultrawork prompt hook returns constant guidance and does not echo prompt text.
+- `.omc/`, `.omo/`, and `evidence/` local state are ignored and excluded from the npm package.
 - The planner agent is read-only and has no edit tools.
 - MCP and LSP helpers are local stdio commands.
-- Future publication, remote marketplace mutation, and package release all
-  require explicit user approval.
-
-## MVP Scope
-
-- Package/bin: `lazyclaude-ai`
-- Friendly bin alias: `lazyclaude`
-- Plugin namespace: `lazyclaude`
-- Claude Code platform: `claude-code`
-- Skills: ultrawork planning, ultrawork loop, start-work, rules, LSP,
-  programming, review-work
-- Agents: planner, executor, verifier, reviewer, librarian, QA runner
-- Hooks: session-start, user-prompt-submit, post-tool-use, post-compact
-- Config: local MCP server and TypeScript-family LSP doctor
+- Future publication, remote marketplace mutation, and package releases require explicit user approval.
+
+## Project Map
+
+| Surface | Path |
+| --- | --- |
+| CLI | `bin/lazyclaude-ai.js` |
+| Claude plugin | `plugins/lazyclaude/` |
+| Skills | `plugins/lazyclaude/skills/` |
+| Agents | `plugins/lazyclaude/agents/` |
+| Hooks | `plugins/lazyclaude/hooks/hooks.json` |
+| MCP | `plugins/lazyclaude/.mcp.json` |
+| 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

package/README_ko-KR.md

@@ -1,25 +1,68 @@
-# LazyClaude
-
-LazyClaude는 LazyCodex 스타일의 작업 흐름을 Claude Code에 맞게 옮긴
-개인용 배포판입니다. 간단한 프롬프트 트리거, ultrawork 규칙, 플래너와
-실행자 에이전트, hooks, MCP scaffold, LSP doctor를 Claude Code 플러그인
-형태로 제공합니다.
-
-현재 공개 npm 패키지는 `lazyclaude-ai@0.1.1`이고, 이 checkout은 다음
-`0.1.2` 패치 배포 후보를 준비합니다. 목적은 다른 PC에서도 빠르게
-설치하기 위한 개인용 배포물입니다. 저장소는 비공개 저장소로 유지할 수
-있고, npm 배포가 곧 홍보, 공개 저장소 운영, Claude marketplace 등록을
-의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
+<p align="center"><img src="./cover.png" width="100%" /></p>
+
+<h1 align="center">LazyClaude</h1>
+<p align="center">
+  <em>Claude Code 안에서 쓰는 LazyCodex 스타일 워크플로우: prompt hook, ultrawork skill, agent, MCP, LSP helper.</em>
+</p>
+<p align="center">
+  <a href="#빠른-시작">빠른 시작</a> · <a href="#ulw-사용법">ULW 사용법</a> · <a href="#명령어">명령어</a> · <a href="./README.md">English</a>
+</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/Claude%20Code-plugin-blueviolet" />
+  <img src="https://img.shields.io/badge/license-MIT-blue" />
+</p>
+
+---
+
+[English](./README.md) | **한국어**
+
+---
+
+> [!NOTE]
+> LazyClaude는 LazyCodex 스타일의 prompt engineering을 Claude Code로 가져오기 위한 조용한 개인용 배포판입니다. `lazyclaude@lazyclaude-ai`로 설치되므로, 매번 긴 `--plugin-dir` 없이 일반 `claude` 실행에서 LazyClaude skill과 hook을 불러올 수 있습니다.
+
+현재 공개 npm 패키지는 `lazyclaude-ai@0.1.3`입니다. 목적은 다른 PC에서도
+빠르게 설치하기 위한 개인용 배포물입니다. 저장소는 비공개 저장소로
+유지할 수 있고, npm 배포가 곧 홍보, 공개 저장소 운영, Claude marketplace
+등록을 의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
 진행합니다.
 
-## 빠른 설치
+## 기능
 
-새 환경에서는 아래 한 줄을 사용합니다.
+- **자연스러운 Claude 실행** - 한 번 `npx`로 설치한 뒤에는 plain `claude`
+- **ULW prompt hook** - `ulw`, `ultrawork`, `$ulw-plan`, `$ulw-loop` 트리거
+- **Native goal guidance** - Claude Code가 `/goal` 또는 `get_goal`,
+  `create_goal`, `update_goal` 같은 goal surface를 제공하면 이를 우선
+  사용하도록 유도
+- **Dynamic workflow/worktree guidance** - 크거나 병렬적인 작업은 Claude
+  Code Dynamic workflow와 Dynamic worktree 격리 쪽으로 유도
+- **Claude skills** - `ulw-plan`, `ulw-loop`, `start-work`, `rules`, `lsp`, `programming`, `review-work`
+- **워크플로우 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
+- **안전한 uninstall** - LazyClaude가 관리한 상태만 제거
+
+## 빠른 시작
+
+### 설치
 
 ```bash
 npx --yes lazyclaude-ai install
 ```
 
+현재 위치가 이 저장소 checkout이면, registry package와 같은 package name을
+가진 same-name source checkout 안에 있는 상태입니다. 이 경우
+`npx --yes lazyclaude-ai@0.1.3 install`이 local checkout을 먼저 해석해서
+`sh: lazyclaude-ai: command not found`로 실패할 수 있습니다. 새 폴더에서는
+일반 설치 명령이 정상 동작합니다.
+
+```bash
+cd /tmp
+npx --yes lazyclaude-ai@0.1.3 install
+```
+
 설치 상태를 확인합니다.
 
 ```bash
@@ -32,7 +75,7 @@ npx --yes lazyclaude-ai doctor
 claude
 ```
 
-대체 진입점은 다음과 같습니다.
+### 대체 진입점
 
 ```bash
 bunx lazyclaude-ai install
@@ -41,7 +84,8 @@ lazyclaude install
 ```
 
 현재 checkout처럼 package 이름이 같은 폴더 안에서 `npm exec`를 직접 쓸
-때는 fresh prefix를 주는 편이 안전합니다.
+때는 registry package와 same-name source checkout이 섞이지 않도록 fresh
+prefix를 주는 편이 안전합니다.
 
 ```bash
 npm exec --prefix "$(mktemp -d)" --yes --package lazyclaude-ai -- lazyclaude install
@@ -53,35 +97,16 @@ LazyClaude가 관리한 설치 상태만 제거하려면 다음을 사용합니
 npx --yes lazyclaude-ai uninstall
 ```
 
+## 설치 방식
+
 installer는 `lazyclaude@lazyclaude-ai`를 Claude Code user plugin registry
-아래의 `~/.claude/plugins`에 등록하고 `settings.json`의 `enabledPlugins`와
+아래의 `~/.claude/plugins`에 등록하고 `settings.json`의 `enabledPlugins`,
 LazyClaude 전용 local marketplace 항목, `known_marketplaces.json`을 함께
-기록합니다. 따라서 매번 긴 `--plugin-dir` 명령을 입력할 필요가 없습니다.
-격리 테스트가 필요할 때만
-`CLAUDE_CONFIG_DIR=/some/path`와 `LAZYCLAUDE_HOME=/some/path`를 지정하세요.
+기록합니다. 이 marketplace metadata가 있어야 Claude가
+`claude plugin details`에서 skill과 hook inventory를 해석합니다.
 
-## 로컬 개발
-
-이 저장소에서 바로 플러그인을 테스트할 때는 다음처럼 실행합니다.
-
-```bash
-claude --plugin-dir ./plugins/lazyclaude
-```
-
-Claude Code 안에서 플러그인 메타데이터를 다시 읽고 싶으면 다음 명령을
-사용합니다.
-
-```text
-/reload-plugins
-```
-
-기존 OMC/omc Claude 플러그인이 설치되어 있다면 MVP 테스트 중에는
-LazyClaude와 함께 co-load하지 않는 것을 권장합니다. 로컬 checkout 테스트는
-`--plugin-dir`로 직접 로드하고, npm 설치는 사용자 홈 아래에 LazyClaude가
-관리하는 local marketplace만 만듭니다. root Claude marketplace skeleton은
-저장소 checkout에 배포하지 않습니다. user-level OMC가 검증 중 `.omc/`
-상태 디렉터리를 만들더라도 LazyClaude는 이를 git 및 npm package surface에서
-제외합니다.
+격리 테스트가 필요할 때만 `CLAUDE_CONFIG_DIR=/some/path`와
+`LAZYCLAUDE_HOME=/some/path`를 지정하세요.
 
 ## ULW 사용법
 
@@ -102,13 +127,24 @@ $start-work plans/lazyclaude-retrofit.md
 ```
 
 기대 동작은 LazyClaude prompt hook이 `ULTRAWORK MODE ENABLED` 컨텍스트를
-추가하고, skill 및 agent 지시문이 Claude를 test-first 작업, 실제 수동 QA
-증거, cleanup receipt, 향후 release step의 명시적 승인 쪽으로 유도하는
-것입니다.
-
-단순히 `ulw`라고 입력하는 것은 hook context activation이므로 Claude Code
-history에 별도 Skill tool invocation으로 보이지 않을 수 있습니다. 명시적인
-LazyClaude command activation을 보고 싶다면 namespaced command를 사용합니다.
+추가하고 `LazyClaude ULW hook active`라는 visible hook message를 보여주는
+것입니다. 또한 plain `ulw`를 일반 작업 실행 전 `/lazyclaude:ulw-loop` /
+`Skill(ulw-loop)` semantics로 처리하라고 Claude에게 지시합니다. 그 뒤 skill
+및 agent 지시문이 Claude를 test-first 작업, native goal 처리, 실제 수동 QA
+증거, cleanup receipt, 향후 release step의 명시적 승인 쪽으로 유도합니다.
+
+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도 함께 고려하도록
+유도합니다.
+
+단순히 `ulw`라고 입력하는 것은 hook context activation입니다. Claude Code
+history에는 별도 Skill tool invocation이 아니라 hook guidance로 보일 수
+있습니다. 명시적인 LazyClaude skill activation을 보고 싶다면 namespaced
+command를 사용합니다.
 
 ```text
 /lazyclaude:ulw-loop <증거 기반으로 실행할 작업>
@@ -118,14 +154,14 @@ LazyClaude command activation을 보고 싶다면 namespaced command를 사용
 
 ## 명령어
 
-```bash
-npx --yes lazyclaude-ai install
-npx --yes lazyclaude-ai doctor
-npx --yes lazyclaude-ai path
-npx --yes lazyclaude-ai run -- --help
-npx --yes lazyclaude-ai update
-npx --yes lazyclaude-ai uninstall
-```
+| 명령어 | 용도 |
+| --- | --- |
+| `npx --yes lazyclaude-ai install` | Claude Code plugin 설치 및 활성화 |
+| `npx --yes lazyclaude-ai doctor` | 파일, Claude validation, plugin details 검증 |
+| `npx --yes lazyclaude-ai path` | 설치된 Claude plugin 경로 출력 |
+| `npx --yes lazyclaude-ai run -- --help` | 설치 상태를 확인한 뒤 plain `claude` 실행 |
+| `npx --yes lazyclaude-ai update` | 현재 package version 재설치 |
+| `npx --yes lazyclaude-ai uninstall` | LazyClaude가 관리한 설치 상태 제거 |
 
 전역 설치 없이 checkout 내부 bin을 확인할 수도 있습니다.
 
@@ -134,6 +170,29 @@ node bin/lazyclaude-ai.js --dry-run install
 node bin/lazyclaude-ai.js --dry-run doctor
 ```
 
+## 로컬 개발
+
+이 저장소에서 바로 플러그인을 테스트할 때는 다음처럼 실행합니다.
+
+```bash
+claude --plugin-dir ./plugins/lazyclaude
+```
+
+Claude Code 안에서 플러그인 메타데이터를 다시 읽고 싶으면 다음 명령을
+사용합니다.
+
+```text
+/reload-plugins
+```
+
+기존 OMC/omc Claude 플러그인이 설치되어 있다면 테스트 중에는 LazyClaude와
+함께 co-load하지 않는 것을 권장합니다. 로컬 checkout 테스트는
+`--plugin-dir`로 직접 로드하고, npm 설치는 사용자 홈 아래에 LazyClaude가
+관리하는 local marketplace만 만듭니다. root Claude marketplace skeleton은
+저장소 checkout에 배포하지 않습니다. user-level OMC가 검증 중 `.omc/`
+상태 디렉터리를 만들더라도 LazyClaude는 이를 git 및 npm package surface에서
+제외합니다.
+
 ## 검증
 
 ```bash
@@ -150,29 +209,25 @@ probe evidence를 남깁니다.
 
 ## 안전 모델
 
-- Hook은 Claude Code event JSON을 stdin으로 읽고 제한된 JSON context를
-  반환합니다.
+- Hook은 Claude Code event JSON을 stdin으로 읽고 제한된 JSON context를 반환합니다.
 - Hook은 사용자 프롬프트 텍스트를 실행하지 않습니다.
-- ultrawork prompt hook은 고정된 guidance를 반환하며 prompt text를 다시
-  echo하지 않습니다.
-- `.omc/`, `.omo/`, `evidence/` 같은 로컬 상태는 ignore되며 npm 패키지에
-  포함되지 않습니다.
+- ultrawork prompt hook은 고정된 guidance를 반환하며 prompt text를 다시 echo하지 않습니다.
+- `.omc/`, `.omo/`, `evidence/` 같은 로컬 상태는 ignore되며 npm 패키지에 포함되지 않습니다.
 - planner agent는 read-only이며 edit tool을 갖지 않습니다.
 - MCP와 LSP helper는 local stdio command입니다.
-- 향후 publish, remote marketplace 변경, 새 package release는 모두 명시적
-  승인 후 진행합니다.
-
-## 범위
-
-- Package/bin: `lazyclaude-ai`
-- Friendly bin alias: `lazyclaude`
-- Plugin namespace: `lazyclaude`
-- Claude Code platform: `claude-code`
-- Skills: ultrawork planning, ultrawork loop, start-work, rules, LSP,
-  programming, review-work
-- Agents: planner, executor, verifier, reviewer, librarian, QA runner
-- Hooks: session-start, user-prompt-submit, post-tool-use, post-compact
-- Config: local MCP server and TypeScript-family LSP doctor
+- 향후 publish, remote marketplace 변경, 새 package release는 모두 명시적 승인 후 진행합니다.
+
+## 프로젝트 지도
+
+| Surface | Path |
+| --- | --- |
+| CLI | `bin/lazyclaude-ai.js` |
+| Claude plugin | `plugins/lazyclaude/` |
+| Skills | `plugins/lazyclaude/skills/` |
+| Agents | `plugins/lazyclaude/agents/` |
+| Hooks | `plugins/lazyclaude/hooks/hooks.json` |
+| MCP | `plugins/lazyclaude/.mcp.json` |
+| LSP | `plugins/lazyclaude/.lsp.json` |
 
 영문 설명은 `README.md`, LazyCodex 출처 고정 정보는 `REFERENCE.md`,
 Codex-to-Claude 변환 표는 `docs/migration.md`를 참고하세요.

package/RELEASE_CHECKLIST.md

@@ -1,9 +1,7 @@
 # LazyClaude Release Checklist
 
-Status: quiet public npm package `lazyclaude-ai@0.1.1` is published for
-personal install convenience after explicit user approval. This checkout is
-prepared as the next `0.1.2` patch candidate until the user explicitly approves
-another publish.
+Status: quiet public npm package `lazyclaude-ai@0.1.3` is published for
+personal install convenience 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
@@ -45,6 +43,16 @@ local marketplace metadata needed by `claude plugin details`. Do not ask users
 to type a generated command that shells out to `npx --yes lazyclaude-ai path` for
 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`
+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:
+
+```bash
+npm exec --prefix "$(mktemp -d)" --yes --package lazyclaude-ai -- lazyclaude install
+```
+
 ## Quiet Public NPM Package Release Or Update
 
 Use this track only when the user explicitly approves making a new package

package/docs/hooks.md

@@ -25,8 +25,22 @@ $start-work
 ```
 
 When a trigger is present, the hook returns additional context containing
-`ULTRAWORK MODE ENABLED`. That context is guidance for Claude Code; it is not
-executed as a command.
+`ULTRAWORK MODE ENABLED` and a visible `LazyClaude ULW hook active` system
+message. That context is guidance for Claude Code; it is not executed as a
+command. The guidance tells Claude to treat plain `ulw` as
+`/lazyclaude:ulw-loop` / `Skill(ulw-loop)` semantics before ordinary task
+execution.
+
+LazyClaude follows the LazyCodex 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.
+
+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.
 
 Plain `ulw` therefore activates hook context, not a visible Skill tool call.
 For a visible LazyClaude command/skill invocation, use the namespaced Claude

package/docs/migration.md

@@ -9,6 +9,8 @@ of surface, and a conservative local fallback where it does not.
 | Codex CLI prompt engineering | Claude Code skills | `plugins/lazyclaude/skills/*/SKILL.md` |
 | 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 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` |
@@ -43,6 +45,21 @@ a LazyClaude-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
+
+LazyCodex goal integration is model-facing guidance around goal tools; it does
+not type a `/goal` slash command for the user. LazyClaude mirrors that contract:
+ULW hook context and ULW 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.
+
+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.
+
 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
 longer ships a root marketplace skeleton; direct `--plugin-dir` loading avoids

package/generate_cover.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import TypeAlias
+
+import numpy as np
+from PIL import Image, ImageDraw, ImageFilter, ImageFont
+
+WIDTH = 2560
+HEIGHT = 1280
+CORNER_RADIUS = 80
+ROOT = Path(__file__).resolve().parent
+OUT_PATH = ROOT / "cover.png"
+ReadableFont: TypeAlias = ImageFont.FreeTypeFont | ImageFont.ImageFont
+
+
+def make_blob(size: tuple[int, int], color: tuple[int, int, int, int], cx: int, cy: int, rx: int, ry: int) -> Image.Image:
+    layer = Image.new("RGBA", size, (0, 0, 0, 0))
+    draw = ImageDraw.Draw(layer)
+    draw.ellipse([cx - rx, cy - ry, cx + rx, cy + ry], fill=color)
+    return layer
+
+
+def load_font(size: int, *, bold: bool) -> ReadableFont:
+    candidates = [
+        ("/System/Library/Fonts/Menlo.ttc", 1 if bold else 0),
+        ("/System/Library/Fonts/Supplemental/Courier New Bold.ttf", 0),
+        ("/Library/Fonts/Arial Unicode.ttf", 0),
+    ]
+    for path, index in candidates:
+        try:
+            return ImageFont.truetype(path, size, index=index)
+        except OSError:
+            continue
+    return ImageFont.load_default(size=size)
+
+
+def draw_text_layer(text: str, x: int, y: int, font: ReadableFont, color: tuple[int, int, int, int]) -> Image.Image:
+    layer = Image.new("RGBA", (WIDTH, HEIGHT), (0, 0, 0, 0))
+    ImageDraw.Draw(layer).text((x, y), text, font=font, fill=color)
+    return layer
+
+
+def centered_position(draw: ImageDraw.ImageDraw, text: str, font: ReadableFont, y: int) -> tuple[int, int, int]:
+    bbox = draw.textbbox((0, 0), text, font=font)
+    text_width = bbox[2] - bbox[0]
+    text_height = bbox[3] - bbox[1]
+    return int((WIDTH - text_width) // 2 - bbox[0]), int(y - bbox[1]), int(text_height)
+
+
+def main() -> None:
+    canvas = Image.new("RGBA", (WIDTH, HEIGHT), (9, 12, 18, 255))
+
+    blobs = [
+        ((30, 144, 255, 180), 560, 380, 760, 520, 120),
+        ((0, 210, 160, 150), 1880, 820, 820, 480, 120),
+        ((160, 80, 255, 140), 1350, 180, 780, 360, 110),
+        ((255, 210, 80, 90), 820, 1040, 620, 300, 90),
+    ]
+    for color, cx, cy, rx, ry, blur in blobs:
+        blob = make_blob((WIDTH, HEIGHT), color, cx, cy, rx, ry).filter(ImageFilter.GaussianBlur(radius=blur))
+        canvas = Image.alpha_composite(canvas, blob)
+
+    canvas = canvas.filter(ImageFilter.GaussianBlur(radius=7))
+
+    rng = np.random.default_rng(42)
+    noise = rng.integers(0, 255, (HEIGHT, WIDTH), dtype=np.uint8)
+    grain_alpha = (noise * 0.16).astype(np.uint8)
+    grain = Image.fromarray(np.stack([noise, noise, noise, grain_alpha], axis=-1).astype(np.uint8), "RGBA")
+    canvas = Image.alpha_composite(canvas, grain)
+
+    title = "LazyClaude"
+    subtitle = "Claude Code workflows with hooks, skills, agents, MCP, and LSP"
+    title_font = load_font(220, bold=True)
+    subtitle_font = load_font(58, bold=False)
+
+    measure = ImageDraw.Draw(Image.new("RGBA", (WIDTH, HEIGHT), (0, 0, 0, 0)))
+    title_x, title_y, title_h = centered_position(measure, title, title_font, 445)
+    subtitle_x, subtitle_y, _ = centered_position(measure, subtitle, subtitle_font, title_y + title_h + 88)
+
+    for color, blur in [
+        ((80, 210, 255, 70), 22),
+        ((150, 255, 220, 85), 10),
+        ((255, 255, 255, 120), 4),
+    ]:
+        glow = draw_text_layer(title, title_x, title_y, title_font, color).filter(ImageFilter.GaussianBlur(radius=blur))
+        canvas = Image.alpha_composite(canvas, glow)
+
+    canvas = Image.alpha_composite(canvas, draw_text_layer(title, title_x, title_y, title_font, (255, 255, 255, 246)))
+    canvas = Image.alpha_composite(canvas, draw_text_layer(subtitle, subtitle_x, subtitle_y, subtitle_font, (218, 232, 240, 220)))
+
+    label_font = load_font(44, bold=False)
+    package = json.loads((ROOT / "package.json").read_text(encoding="utf8"))
+    label = f"lazyclaude-ai@{package['version']}"
+    label_x, label_y, _ = centered_position(measure, label, label_font, 930)
+    pill = Image.new("RGBA", (WIDTH, HEIGHT), (0, 0, 0, 0))
+    pill_draw = ImageDraw.Draw(pill)
+    label_bbox = pill_draw.textbbox((label_x, label_y), label, font=label_font)
+    pad_x = 42
+    pad_y = 24
+    pill_draw.rounded_rectangle(
+        [label_bbox[0] - pad_x, label_bbox[1] - pad_y, label_bbox[2] + pad_x, label_bbox[3] + pad_y],
+        radius=42,
+        fill=(5, 10, 18, 145),
+        outline=(255, 255, 255, 42),
+        width=2,
+    )
+    pill_draw.text((label_x, label_y), label, font=label_font, fill=(232, 244, 247, 230))
+    canvas = Image.alpha_composite(canvas, pill)
+
+    mask = Image.new("L", (WIDTH, HEIGHT), 0)
+    ImageDraw.Draw(mask).rounded_rectangle([(0, 0), (WIDTH - 1, HEIGHT - 1)], radius=CORNER_RADIUS, fill=255)
+    canvas.putalpha(mask)
+    canvas = canvas.filter(ImageFilter.GaussianBlur(radius=1))
+    canvas.save(OUT_PATH, "PNG", dpi=(400, 400))
+    print(f"Saved: {OUT_PATH}")
+    print(f"Size: {canvas.size}")
+    print(f"Mode: {canvas.mode}")
+
+
+if __name__ == "__main__":
+    main()

package/package.json

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

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

@@ -1,7 +1,7 @@
 {
   "name": "lazyclaude",
   "description": "Claude Code-native LazyCodex-style workflow plugin.",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": {
     "name": "LazyClaude contributors"
   },

package/plugins/lazyclaude/bin/lazyclaude-hook.js

@@ -21,18 +21,32 @@ const hookEventNames = {
   "post-compact": "PostCompact",
 };
 
-const writeContext = (additionalContext) => {
+const writeContext = (additionalContext, systemMessage) => {
+  const payload = {
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: hookEventNames[eventName],
+      additionalContext,
+    },
+  };
+  if (systemMessage) {
+    payload.systemMessage = systemMessage;
+  }
   console.log(
-    JSON.stringify({
-      continue: true,
-      hookSpecificOutput: {
-        hookEventName: hookEventNames[eventName],
-        additionalContext,
-      },
-    }),
+    JSON.stringify(payload),
   );
 };
 
+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.",
+  "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.",
+].join(" ");
+
 const input = readInput();
 
 switch (eventName) {
@@ -45,7 +59,7 @@ switch (eventName) {
     const prompt = typeof input.prompt === "string" ? input.prompt : "";
     const activates = /\b(?:ultrawork|ulw)\b|\$(?:ulw-plan|ulw-loop|start-work)\b/u.test(prompt);
     if (activates) {
-      writeContext("ULTRAWORK MODE ENABLED. Use evidence-bound planning, tests, manual QA, and cleanup receipts.");
+      writeContext(ultraworkContext, "LazyClaude ULW hook active: ulw-loop guidance injected.");
     } else {
       writeContext("LazyClaude prompt hook checked: no workflow activation.");
     }

package/plugins/lazyclaude/skills/start-work/SKILL.md

@@ -17,3 +17,16 @@ first unchecked top-level checkbox. For every checkbox:
 7. Mark the checkbox complete only after all evidence is captured.
 
 The durable ledger is `.omo/start-work/ledger.jsonl`.
+
+## Native Goal + Dynamic Workflow
+
+Before the first checkbox, use Claude Code's native goal surface when available:
+call `get_goal`, call `create_goal` with the plan objective when no matching
+active goal exists, and do not call `update_goal` until all top-level checkboxes
+and verification gates are complete or the plan is genuinely blocked. If the
+user invokes `/goal`, respect that native Claude Code session goal; LazyClaude
+does not auto-type or send `/goal` text.
+
+For independent checkbox waves, prefer Dynamic workflow orchestration or
+subagents with explicit evidence paths. For risky or parallel edits, use
+Dynamic worktree isolation and keep every command in the selected worktree.

package/plugins/lazyclaude/skills/ulw-loop/SKILL.md

@@ -12,3 +12,18 @@ automation.
 
 Keep a ledger of decisions, evidence, cleanup receipts, and remaining work.
 Never claim completion from tests alone.
+
+## Native Goal + Dynamic Workflow
+
+Use Claude Code's native goal surface when it is available. If the session
+exposes model-facing goal tools, call `get_goal` before execution, call
+`create_goal` only when no matching active goal exists, and call `update_goal`
+only after every success criterion has real evidence or when the work is truly
+blocked. If the user chooses `/goal`, treat it as Claude Code's native session
+goal command; LazyClaude must not auto-type or send `/goal` text for them.
+
+For broad work, consider Claude Code Dynamic workflow orchestration before
+serial execution. Keep each worker or workflow branch tied to concrete criteria,
+artifacts, and cleanup receipts. Use Dynamic worktree isolation for risky or
+parallel edits, and keep all mutations inside the active Claude Code
+workspace/worktree.

package/plugins/lazyclaude/skills/ulw-plan/SKILL.md

@@ -12,7 +12,16 @@ Use Claude Code surfaces directly:
 
 - read/search files for grounding
 - use subagents only for read-only research or plan review
+- include native goal handling: `get_goal`, `create_goal`, and delayed
+  `update_goal` when Claude Code exposes those tools, or a user-managed `/goal`
+  condition when the user chooses that surface
+- include Dynamic workflow and Dynamic worktree guidance for independent,
+  parallel, risky, or long-running implementation lanes
 - write only plan artifacts and drafts
 - include concrete tests, manual QA, cleanup, and non-publish guardrails
 
+Do not auto-type or send `/goal` text. LazyClaude plans should describe the
+native goal surface and the exact completion condition the user or Claude Code
+should bind.
+
 When `$ARGUMENTS` is present, treat it as the planning brief.