lazyclaude-ai 0.1.1 → 0.1.3

package/README.md

@@ -1,19 +1,48 @@
-# LazyClaude
-
-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.0`, and this checkout prepares
-the next `0.1.1` 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
-
-Use the npm package from any machine:
+<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
 
 ```bash
 npx --yes lazyclaude-ai install
@@ -31,7 +60,7 @@ Launch Claude Code normally:
 claude
 ```
 
-Alternative entrypoints:
+### Alternative Entrypoints
 
 ```bash
 bunx lazyclaude-ai install
@@ -52,41 +81,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
-
-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:
+## How Install Works
 
-```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. LazyClaude is loaded directly by `--plugin-dir` and 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,12 +112,20 @@ $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.
+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, 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:
+you want explicit LazyClaude skill activation:
 
 ```text
 /lazyclaude:ulw-loop <what you want executed with evidence>
@@ -113,14 +135,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:
 
@@ -129,6 +151,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
@@ -145,30 +188,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,20 +1,52 @@
-# LazyClaude
-
-LazyClaude는 LazyCodex 스타일의 작업 흐름을 Claude Code에 맞게 옮긴
-개인용 배포판입니다. 간단한 프롬프트 트리거, ultrawork 규칙, 플래너와
-실행자 에이전트, hooks, MCP scaffold, LSP doctor를 Claude Code 플러그인
-형태로 제공합니다.
-
-현재 공개 npm 패키지는 `lazyclaude-ai@0.1.0`이고, 이 checkout은 다음
-`0.1.1` 패치 배포 후보를 준비합니다. 목적은 다른 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
@@ -32,7 +64,7 @@ npx --yes lazyclaude-ai doctor
 claude
 ```
 
-대체 진입점은 다음과 같습니다.
+### 대체 진입점
 
 ```bash
 bunx lazyclaude-ai install
@@ -53,32 +85,16 @@ LazyClaude가 관리한 설치 상태만 제거하려면 다음을 사용합니
 npx --yes lazyclaude-ai uninstall
 ```
 
-installer는 `lazyclaude@lazyclaude-ai`를 Claude Code user plugin registry
-아래의 `~/.claude/plugins`에 등록하고 `settings.json`의 `enabledPlugins`에
-활성 상태를 기록합니다. 따라서 매번 긴 `--plugin-dir` 명령을 입력할
-필요가 없습니다. 격리 테스트가 필요할 때만
-`CLAUDE_CONFIG_DIR=/some/path`와 `LAZYCLAUDE_HOME=/some/path`를 지정하세요.
-
-## 로컬 개발
-
-이 저장소에서 바로 플러그인을 테스트할 때는 다음처럼 실행합니다.
-
-```bash
-claude --plugin-dir ./plugins/lazyclaude
-```
-
-Claude Code 안에서 플러그인 메타데이터를 다시 읽고 싶으면 다음 명령을
-사용합니다.
+## 설치 방식
 
-```text
-/reload-plugins
-```
+installer는 `lazyclaude@lazyclaude-ai`를 Claude Code user plugin registry
+아래의 `~/.claude/plugins`에 등록하고 `settings.json`의 `enabledPlugins`,
+LazyClaude 전용 local marketplace 항목, `known_marketplaces.json`을 함께
+기록합니다. 이 marketplace metadata가 있어야 Claude가
+`claude plugin details`에서 skill과 hook inventory를 해석합니다.
 
-기존 OMC/omc Claude 플러그인이 설치되어 있다면 MVP 테스트 중에는
-LazyClaude와 함께 co-load하지 않는 것을 권장합니다. LazyClaude는
-`--plugin-dir`로 직접 로드하며 root Claude marketplace skeleton을 배포하지
-않습니다. user-level OMC가 검증 중 `.omc/` 상태 디렉터리를 만들더라도
-LazyClaude는 이를 git 및 npm package surface에서 제외합니다.
+격리 테스트가 필요할 때만 `CLAUDE_CONFIG_DIR=/some/path`와
+`LAZYCLAUDE_HOME=/some/path`를 지정하세요.
 
 ## ULW 사용법
 
@@ -99,13 +115,21 @@ $start-work plans/lazyclaude-retrofit.md
 ```
 
 기대 동작은 LazyClaude prompt hook이 `ULTRAWORK MODE ENABLED` 컨텍스트를
-추가하고, skill 및 agent 지시문이 Claude를 test-first 작업, 실제 수동 QA
-증거, cleanup receipt, 향후 release step의 명시적 승인 쪽으로 유도하는
-것입니다.
+추가하고, 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으로 보이지 않을 수 있습니다. 명시적인
-LazyClaude command activation을 보고 싶다면 namespaced command를 사용합니다.
+LazyClaude skill activation을 보고 싶다면 namespaced command를 사용합니다.
 
 ```text
 /lazyclaude:ulw-loop <증거 기반으로 실행할 작업>
@@ -115,14 +139,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을 확인할 수도 있습니다.
 
@@ -131,6 +155,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
@@ -147,29 +194,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.0` is published for
-personal install convenience after explicit user approval. This checkout is
-prepared as the next `0.1.1` 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
@@ -40,9 +38,10 @@ Use this track after an approved npm package version exists:
 3. Start Claude Code with the normal `claude` command.
 
 The installer should register `lazyclaude@lazyclaude-ai` in Claude Code's user
-plugin registry and `settings.json` `enabledPlugins`. Do not ask users to type a
-generated command that shells out to `npx --yes lazyclaude-ai path` for normal
-npm installs.
+plugin registry, `settings.json` `enabledPlugins`, and the LazyClaude-managed
+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.
 
 ## Quiet Public NPM Package Release Or Update
 
@@ -92,10 +91,13 @@ rollback action with user approval:
 Local checkout testing still uses `claude --plugin-dir ./plugins/lazyclaude`.
 NPM installs should use the global Claude user plugin registry and normal
 `claude` launches. A root Claude marketplace file is intentionally not shipped
-because users may already have an OMC/omc marketplace or plugin installed. Do
-not add a local or remote marketplace entry without explicit user approval. If
-user-level OMC creates `.omc/` state during validation, keep it ignored and
-confirm it is absent from the package dry-run.
+because users may already have an OMC/omc marketplace or plugin installed. The
+npm installer creates a LazyClaude-managed local marketplace under
+`LAZYCLAUDE_HOME` and registers only `lazyclaude-ai` in Claude's user marketplace
+metadata so skills and hooks appear in `claude plugin details`. Do not add a
+remote marketplace entry without explicit user approval. If user-level OMC
+creates `.omc/` state during validation, keep it ignored and confirm it is
+absent from the package dry-run.
 
 ## Rollback
 

package/bin/lazyclaude-ai.js

@@ -43,9 +43,13 @@ const currentRoot = (home = lazyHome()) => join(home, "current");
 const pluginPathForRoot = (installRoot) => join(installRoot, "plugins", "lazyclaude");
 const claudePluginRoot = (home = claudeHome()) => join(home, "plugins", "cache", "lazyclaude-ai", "lazyclaude", version);
 const installedPluginsPath = (home = claudeHome()) => join(home, "plugins", "installed_plugins.json");
+const knownMarketplacesPath = (home = claudeHome()) => join(home, "plugins", "known_marketplaces.json");
 const claudeSettingsPath = (home = claudeHome()) => join(home, "settings.json");
 const pluginKey = "lazyclaude@lazyclaude-ai";
+const marketplaceName = "lazyclaude-ai";
 const intendedPluginPath = (home = claudeHome()) => claudePluginRoot(home);
+const marketplaceRoot = (home = lazyHome()) => join(home, "marketplaces", marketplaceName);
+const marketplacePluginPath = (home = lazyHome()) => join(marketplaceRoot(home), "plugins", "lazyclaude");
 const sourcePluginPath = () => join(root, "plugins", "lazyclaude");
 
 const printUsage = () => {
@@ -88,23 +92,98 @@ const writeClaudeSettings = (settings, home = claudeHome()) => {
   writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
 };
 
-const enableClaudePlugin = (home = claudeHome()) => {
+const readKnownMarketplaces = (home = claudeHome()) => {
+  const path = knownMarketplacesPath(home);
+  if (!existsSync(path)) return {};
+  return JSON.parse(readFileSync(path, "utf8"));
+};
+
+const writeKnownMarketplaces = (knownMarketplaces, home = claudeHome()) => {
+  const path = knownMarketplacesPath(home);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(knownMarketplaces, null, 2)}\n`);
+};
+
+const marketplaceSource = (marketplacePath) => ({
+  source: "directory",
+  path: marketplacePath,
+});
+
+const writeLocalMarketplace = (legacyHome = lazyHome()) => {
+  const rootPath = marketplaceRoot(legacyHome);
+  const targetPlugin = marketplacePluginPath(legacyHome);
+  rmSync(rootPath, { recursive: true, force: true });
+  mkdirSync(dirname(targetPlugin), { recursive: true });
+  cpSync(sourcePluginPath(), targetPlugin, { recursive: true });
+  const marketplaceManifestPath = join(rootPath, ".claude-plugin", "marketplace.json");
+  mkdirSync(dirname(marketplaceManifestPath), { recursive: true });
+  writeFileSync(
+    marketplaceManifestPath,
+    `${JSON.stringify(
+      {
+        $schema: "https://anthropic.com/claude-code/marketplace.schema.json",
+        name: marketplaceName,
+        description: "Local LazyClaude npm-installed marketplace.",
+        owner: {
+          name: "LazyClaude contributors",
+        },
+        plugins: [
+          {
+            name: "lazyclaude",
+            description: packageJson.description,
+            author: {
+              name: "LazyClaude contributors",
+            },
+            source: "./plugins/lazyclaude",
+            category: "development",
+            homepage: "https://github.com/code-yeongyu/lazycodex",
+          },
+        ],
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  return rootPath;
+};
+
+const registerMarketplace = (marketplacePath, home = claudeHome()) => {
   const settings = readClaudeSettings(home);
   settings.enabledPlugins = settings.enabledPlugins ?? {};
   settings.enabledPlugins[pluginKey] = true;
+  settings.extraKnownMarketplaces = settings.extraKnownMarketplaces ?? {};
+  settings.extraKnownMarketplaces[marketplaceName] = {
+    source: marketplaceSource(marketplacePath),
+  };
   writeClaudeSettings(settings, home);
+
+  const knownMarketplaces = readKnownMarketplaces(home);
+  knownMarketplaces[marketplaceName] = {
+    source: marketplaceSource(marketplacePath),
+    installLocation: marketplacePath,
+    lastUpdated: new Date().toISOString(),
+  };
+  writeKnownMarketplaces(knownMarketplaces, home);
 };
 
-const disableClaudePlugin = (home = claudeHome()) => {
+const unregisterMarketplace = (home = claudeHome()) => {
   const settingsPath = claudeSettingsPath(home);
-  if (!existsSync(settingsPath)) return;
-  const settings = readClaudeSettings(home);
-  if (!settings.enabledPlugins) return;
-  delete settings.enabledPlugins[pluginKey];
-  writeClaudeSettings(settings, home);
+  if (existsSync(settingsPath)) {
+    const settings = readClaudeSettings(home);
+    if (settings.enabledPlugins) delete settings.enabledPlugins[pluginKey];
+    if (settings.extraKnownMarketplaces) delete settings.extraKnownMarketplaces[marketplaceName];
+    writeClaudeSettings(settings, home);
+  }
+
+  const knownPath = knownMarketplacesPath(home);
+  if (existsSync(knownPath)) {
+    const knownMarketplaces = readKnownMarketplaces(home);
+    delete knownMarketplaces[marketplaceName];
+    writeKnownMarketplaces(knownMarketplaces, home);
+  }
 };
 
-const registerClaudePlugin = (installRoot, home = claudeHome()) => {
+const registerClaudePlugin = (installRoot, marketplacePath, home = claudeHome()) => {
   const registry = readInstalledPlugins(home);
   const now = new Date().toISOString();
   const existing = registry.plugins[pluginKey]?.[0] ?? {};
@@ -120,7 +199,7 @@ const registerClaudePlugin = (installRoot, home = claudeHome()) => {
     },
   ];
   writeInstalledPlugins(registry, home);
-  enableClaudePlugin(home);
+  registerMarketplace(marketplacePath, home);
 };
 
 const unregisterClaudePlugin = (home = claudeHome()) => {
@@ -158,10 +237,12 @@ const install = ({ dryRun }) => {
   const legacyHome = lazyHome();
   const targetPlugin = claudePluginRoot(home);
   const sourcePlugin = sourcePluginPath();
+  const targetMarketplace = marketplaceRoot(legacyHome);
 
   if (dryRun) {
     process.stdout.write(`DRY_RUN: install LazyClaude ${version}\n`);
     process.stdout.write(`Would copy: ${sourcePlugin} -> ${targetPlugin}\n`);
+    process.stdout.write(`Would create local marketplace: ${targetMarketplace}\n`);
     process.stdout.write(`Would register Claude plugin: ${pluginKey}\n`);
     process.stdout.write("Launch with: claude\n");
     return;
@@ -174,7 +255,8 @@ const install = ({ dryRun }) => {
   rmSync(targetPlugin, { recursive: true, force: true });
   mkdirSync(dirname(targetPlugin), { recursive: true });
   cpSync(sourcePlugin, targetPlugin, { recursive: true });
-  registerClaudePlugin(targetPlugin, home);
+  const localMarketplace = writeLocalMarketplace(legacyHome);
+  registerClaudePlugin(targetPlugin, localMarketplace, home);
 
   const legacyRoot = versionRoot(legacyHome);
   rmSync(legacyRoot, { recursive: true, force: true });
@@ -184,6 +266,7 @@ const install = ({ dryRun }) => {
 
   process.stdout.write(`INSTALL_PASS: LazyClaude ${version} installed\n`);
   process.stdout.write(`Claude plugin: ${pluginKey}\n`);
+  process.stdout.write(`Marketplace: ${localMarketplace}\n`);
   process.stdout.write(`Plugin path: ${intendedPluginPath(home)}\n`);
   process.stdout.write("Launch with: claude\n");
 };
@@ -229,6 +312,13 @@ const doctor = ({ dryRun }) => {
       fail("Claude plugin validation failed.");
     }
     process.stdout.write("CLAUDE_PLUGIN_VALIDATE_PASS\n");
+    const details = spawnSync("claude", ["plugin", "details", pluginKey], { encoding: "utf8" });
+    if (details.status !== 0) {
+      if (details.stdout) process.stderr.write(details.stdout);
+      if (details.stderr) process.stderr.write(details.stderr);
+      fail("Claude plugin details failed.");
+    }
+    process.stdout.write("CLAUDE_PLUGIN_DETAILS_PASS\n");
   }
 
   process.stdout.write(`Plugin path: ${pluginPath}\n`);
@@ -261,13 +351,14 @@ const uninstall = ({ dryRun }) => {
   const home = lazyHome();
   const pluginCacheRoot = join(claudeHome(), "plugins", "cache", "lazyclaude-ai");
   if (dryRun) {
-    process.stdout.write(`DRY_RUN: remove ${join(home, "lazyclaude-ai")}, ${currentRoot(home)}, ${pluginCacheRoot}, ${pluginKey}, and its enabledPlugins entry\n`);
+    process.stdout.write(`DRY_RUN: remove ${join(home, "lazyclaude-ai")}, ${currentRoot(home)}, ${marketplaceRoot(home)}, ${pluginCacheRoot}, ${pluginKey}, and its marketplace/settings entries\n`);
     return;
   }
   rmSync(currentRoot(home), { recursive: true, force: true });
   rmSync(join(home, "lazyclaude-ai"), { recursive: true, force: true });
+  rmSync(marketplaceRoot(home), { recursive: true, force: true });
   unregisterClaudePlugin();
-  disableClaudePlugin();
+  unregisterMarketplace();
   rmSync(pluginCacheRoot, { recursive: true, force: true });
   process.stdout.write("UNINSTALL_PASS\n");
 };

package/docs/hooks.md

@@ -28,6 +28,17 @@ 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.
 
+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
 Code commands:

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` |
@@ -38,9 +40,25 @@ claude
 ```
 
 The installer writes the user plugin cache, `plugins/installed_plugins.json`,
-and the `settings.json` `enabledPlugins` entry for `lazyclaude@lazyclaude-ai`.
+the `settings.json` `enabledPlugins` entry for `lazyclaude@lazyclaude-ai`, and
+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 Claude marketplace entry.
+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

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.1",
+  "version": "0.1.3",
   "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.1",
+  "version": "0.1.3",
   "author": {
     "name": "LazyClaude contributors"
   },

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

@@ -33,6 +33,15 @@ const writeContext = (additionalContext) => {
   );
 };
 
+const ultraworkContext = [
+  "ULTRAWORK MODE ENABLED.",
+  "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 +54,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);
     } 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.

package/scripts/qa-portable-install.sh

@@ -71,13 +71,35 @@ if [ ! -f "$TMP_CLAUDE_HOME/settings.json" ]; then
   echo "INSTALL_FAIL"
   exit 1
 fi
+if [ ! -f "$TMP_CLAUDE_HOME/plugins/known_marketplaces.json" ]; then
+  echo "INSTALL_FAIL: Claude known marketplaces missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+if [ ! -f "$TMP_HOME/marketplaces/lazyclaude-ai/.claude-plugin/marketplace.json" ]; then
+  echo "INSTALL_FAIL: LazyClaude local marketplace missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
 node -e 'const fs = require("fs"); const p = process.argv[1]; const registry = JSON.parse(fs.readFileSync(`${p}/plugins/installed_plugins.json`, "utf8")); const entry = registry.plugins["lazyclaude@lazyclaude-ai"]?.[0]; if (!entry || entry.scope !== "user" || !entry.installPath.includes("/plugins/cache/lazyclaude-ai/lazyclaude/")) process.exit(1);' "$TMP_CLAUDE_HOME"
-node -e 'const fs = require("fs"); const p = process.argv[1]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); if (settings.enabledPlugins?.["lazyclaude@lazyclaude-ai"] !== true) process.exit(1);' "$TMP_CLAUDE_HOME"
+node -e 'const fs = require("fs"); const p = process.argv[1]; const h = process.argv[2]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); const market = settings.extraKnownMarketplaces?.["lazyclaude-ai"]; if (settings.enabledPlugins?.["lazyclaude@lazyclaude-ai"] !== true || market?.source?.source !== "directory" || market.source.path !== `${h}/marketplaces/lazyclaude-ai`) process.exit(1);' "$TMP_CLAUDE_HOME" "$TMP_HOME"
+node -e 'const fs = require("fs"); const p = process.argv[1]; const h = process.argv[2]; const known = JSON.parse(fs.readFileSync(`${p}/plugins/known_marketplaces.json`, "utf8")); const market = known["lazyclaude-ai"]; if (market?.source?.source !== "directory" || market.installLocation !== `${h}/marketplaces/lazyclaude-ai`) process.exit(1);' "$TMP_CLAUDE_HOME" "$TMP_HOME"
 echo "INSTALL_PASS" >> "$EVIDENCE"
 
 run_step DOCTOR node "$ROOT/bin/lazyclaude-ai.js" doctor
 echo "DOCTOR_PASS" >> "$EVIDENCE"
 
+if command -v claude >/dev/null 2>&1; then
+  run_step CLAUDE_PLUGIN_DETAILS claude plugin details lazyclaude@lazyclaude-ai
+  if ! grep -q "Skills (7)" "$EVIDENCE" || ! grep -q "ulw-loop" "$EVIDENCE" || ! grep -q "ulw-plan" "$EVIDENCE" || ! grep -q "Hooks (4)" "$EVIDENCE"; then
+    echo "CLAUDE_PLUGIN_DETAILS_FAIL: expected LazyClaude skills/hooks inventory" >> "$EVIDENCE"
+    echo "CLAUDE_PLUGIN_DETAILS_FAIL"
+    exit 1
+  fi
+else
+  echo "CLAUDE_PLUGIN_DETAILS_SKIP: claude executable not found" >> "$EVIDENCE"
+fi
+
 run_step DRY_RUN_UNINSTALL node "$ROOT/bin/lazyclaude-ai.js" --dry-run uninstall
 if [ ! -d "$PLUGIN_PATH" ]; then
   echo "DRY_RUN_UNINSTALL_FAIL: plugin removed during dry-run" >> "$EVIDENCE"
@@ -91,6 +113,7 @@ if [ -e "$TMP_HOME/current" ] || [ -e "$TMP_HOME/lazyclaude-ai" ] || [ -e "$TMP_
   exit 1
 fi
 node -e 'const fs = require("fs"); const p = process.argv[1]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); if (settings.enabledPlugins?.["lazyclaude@lazyclaude-ai"] !== undefined) process.exit(1);' "$TMP_CLAUDE_HOME"
+node -e 'const fs = require("fs"); const p = process.argv[1]; const settings = JSON.parse(fs.readFileSync(`${p}/settings.json`, "utf8")); const known = JSON.parse(fs.readFileSync(`${p}/plugins/known_marketplaces.json`, "utf8")); if (settings.extraKnownMarketplaces?.["lazyclaude-ai"] !== undefined || known["lazyclaude-ai"] !== undefined) process.exit(1);' "$TMP_CLAUDE_HOME"
 echo "UNINSTALL_PASS" >> "$EVIDENCE"
 
 cleanup