lazyclaude-ai 0.1.0 → 0.1.2

package/README.md

@@ -5,80 +5,86 @@ simple local activation, prompt-triggered ultrawork discipline,
 planner/executor/reviewer agents, lifecycle hooks, MCP scaffolding, and
 LSP-backed code checks.
 
-LazyClaude is intended as a quiet personal distribution. It can be prepared for
-public npm installation convenience without advertising, public repo promotion,
-or Claude marketplace publication. Do not run `npm publish`, mutate a
-marketplace, or promote this as publicly available without explicit user
-approval. Until that approval is given, this package is not published.
+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.
 
-## Fresh PC Install
+## Quick Install
 
-Use one of these npm-compatible entrypoints on a new machine:
+Use the npm package from any machine:
 
 ```bash
-npx lazyclaude-ai install
-bunx lazyclaude-ai install
-npm install -g lazyclaude-ai
-lazyclaude install
+npx --yes lazyclaude-ai install
+```
+
+Validate the installed plugin:
+
+```bash
+npx --yes lazyclaude-ai doctor
 ```
 
-The installer copies the packaged Claude Code plugin into a LazyClaude-managed
-user directory and prints the exact launch command:
+Launch Claude Code normally:
 
 ```bash
-claude --plugin-dir ~/.lazyclaude/current/plugins/lazyclaude
+claude
 ```
 
-Validate the install:
+Alternative entrypoints:
 
 ```bash
-lazyclaude doctor
+bunx lazyclaude-ai install
+npm install -g lazyclaude-ai
+lazyclaude install
 ```
 
-Launch Claude Code through the installed plugin:
+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:
 
 ```bash
-lazyclaude run -- --help
-lazyclaude run
+npm exec --prefix "$(mktemp -d)" --yes --package lazyclaude-ai -- lazyclaude install
 ```
 
 Remove only LazyClaude-managed install state:
 
 ```bash
-lazyclaude uninstall
+npx --yes lazyclaude-ai uninstall
 ```
 
-Set `LAZYCLAUDE_HOME=/some/path` to install into a custom directory for testing
-or isolated machines.
+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 Install
+## Local Development
 
-Use the plugin directly from this checkout while it is under development:
+Use the plugin directly from this checkout while editing it:
 
 ```bash
 claude --plugin-dir ./plugins/lazyclaude
 ```
 
-If you already have an OMC/omc Claude plugin installed, do not co-load it with
-LazyClaude during this local MVP test. LazyClaude intentionally avoids a root
-Claude marketplace skeleton now, so it can be loaded directly by
-path without competing with an existing OMC marketplace or plugin namespace.
-If your user-level Claude config still enables OMC, Claude may create a local
-`.omc/` state directory during smoke tests; LazyClaude ignores and excludes that
-directory from git and npm package surfaces.
-
 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 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.
+
 ## ULW Usage
 
-Start Claude Code from this repo:
+LazyClaude is available in normal Claude Code sessions after install:
 
 ```bash
-claude --plugin-dir ./plugins/lazyclaude
+claude
 ```
 
 Then type one of these prompts in Claude Code:
@@ -92,13 +98,13 @@ $start-work plans/lazyclaude-retrofit.md
 ```
 
 Expected behavior: LazyClaude's prompt hook adds `ULTRAWORK MODE ENABLED`
-context, then the matching skill/agent instructions steer Claude toward
-test-first work, real manual QA evidence, cleanup receipts, and no publish step
-without approval.
+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/command activation:
+you want explicit LazyClaude skill or command activation:
 
 ```text
 /lazyclaude:ulw-loop <what you want executed with evidence>
@@ -106,6 +112,17 @@ you want explicit LazyClaude skill/command activation:
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+## 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
+```
+
 The package alias can be inspected without installing anything globally:
 
 ```bash
@@ -113,12 +130,13 @@ node bin/lazyclaude-ai.js --dry-run install
 node bin/lazyclaude-ai.js --dry-run doctor
 ```
 
-## Local Development
+## Verification
 
 ```bash
 npm test
 npm run validate:plugin
 npm run qa:tmux
+npm run qa:portable
 npm run pack:dry-run
 ```
 
@@ -126,26 +144,6 @@ npm run pack:dry-run
 available on the machine, the smoke harness records a controlled skip with the
 version probe evidence instead of failing mysteriously.
 
-## Rollback And Uninstall
-
-For npm-installed LazyClaude, run:
-
-```bash
-lazyclaude uninstall
-```
-
-Because the local MVP can also be loaded with
-`claude --plugin-dir ./plugins/lazyclaude`, checkout rollback is local and
-reversible:
-
-1. Stop the Claude Code session that loaded the plugin.
-2. Start Claude Code without the `--plugin-dir` flag.
-3. Remove any temporary plugin-dir reference you added for testing.
-4. Run `/reload-plugins` in any remaining Claude Code session that should stop
-   seeing LazyClaude.
-
-No global install step is required for this MVP.
-
 ## Safety Model
 
 LazyClaude is intentionally local-first:
@@ -154,16 +152,17 @@ LazyClaude is intentionally local-first:
 - 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/` directory created by a user-level OMC plugin is ignored and is not
-  included in the LazyClaude package.
+- Any `.omc/`, `.omo/`, or `evidence/` local state is ignored and is not
+  included in the LazyClaude npm package.
 - The planner agent is read-only and has no edit tools.
 - MCP and LSP helpers are local stdio commands.
-- Publication, remote marketplace mutation, and package release all require
-  explicit user approval.
+- 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,
@@ -172,5 +171,6 @@ LazyClaude is intentionally local-first:
 - Hooks: session-start, user-prompt-submit, post-tool-use, post-compact
 - Config: local MCP server and TypeScript-family LSP doctor
 
-See `REFERENCE.md` for the pinned LazyCodex source. See `docs/migration.md` for
-the Codex-to-Claude migration table.
+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.

package/README_ko-KR.md

@@ -0,0 +1,178 @@
+# 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 등록을
+의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
+진행합니다.
+
+## 빠른 설치
+
+새 환경에서는 아래 한 줄을 사용합니다.
+
+```bash
+npx --yes lazyclaude-ai install
+```
+
+설치 상태를 확인합니다.
+
+```bash
+npx --yes lazyclaude-ai doctor
+```
+
+설치 후에는 일반적인 `claude` 명령으로 Claude Code를 실행합니다.
+
+```bash
+claude
+```
+
+대체 진입점은 다음과 같습니다.
+
+```bash
+bunx lazyclaude-ai install
+npm install -g lazyclaude-ai
+lazyclaude install
+```
+
+현재 checkout처럼 package 이름이 같은 폴더 안에서 `npm exec`를 직접 쓸
+때는 fresh prefix를 주는 편이 안전합니다.
+
+```bash
+npm exec --prefix "$(mktemp -d)" --yes --package lazyclaude-ai -- lazyclaude install
+```
+
+LazyClaude가 관리한 설치 상태만 제거하려면 다음을 사용합니다.
+
+```bash
+npx --yes lazyclaude-ai uninstall
+```
+
+installer는 `lazyclaude@lazyclaude-ai`를 Claude Code user plugin registry
+아래의 `~/.claude/plugins`에 등록하고 `settings.json`의 `enabledPlugins`와
+LazyClaude 전용 local marketplace 항목, `known_marketplaces.json`을 함께
+기록합니다. 따라서 매번 긴 `--plugin-dir` 명령을 입력할 필요가 없습니다.
+격리 테스트가 필요할 때만
+`CLAUDE_CONFIG_DIR=/some/path`와 `LAZYCLAUDE_HOME=/some/path`를 지정하세요.
+
+## 로컬 개발
+
+이 저장소에서 바로 플러그인을 테스트할 때는 다음처럼 실행합니다.
+
+```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에서
+제외합니다.
+
+## ULW 사용법
+
+설치 후에는 일반적인 `claude` 명령에서 LazyClaude를 사용할 수 있습니다.
+
+```bash
+claude
+```
+
+그다음 Claude Code에 아래 프롬프트 중 하나를 입력합니다.
+
+```text
+ulw
+ultrawork
+$ulw-plan <계획이 필요한 작업>
+$ulw-loop <증거 기반으로 실행할 작업>
+$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를 사용합니다.
+
+```text
+/lazyclaude:ulw-loop <증거 기반으로 실행할 작업>
+/lazyclaude:ulw-plan <계획이 필요한 작업>
+/lazyclaude:start-work plans/lazyclaude-retrofit.md
+```
+
+## 명령어
+
+```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
+```
+
+전역 설치 없이 checkout 내부 bin을 확인할 수도 있습니다.
+
+```bash
+node bin/lazyclaude-ai.js --dry-run install
+node bin/lazyclaude-ai.js --dry-run doctor
+```
+
+## 검증
+
+```bash
+npm test
+npm run validate:plugin
+npm run qa:tmux
+npm run qa:portable
+npm run pack:dry-run
+```
+
+`validate:plugin`과 `qa:tmux`는 로컬 검증용입니다. Claude Code가 없는
+환경에서는 smoke harness가 모호한 실패 대신 controlled skip과 version
+probe evidence를 남깁니다.
+
+## 안전 모델
+
+- Hook은 Claude Code event JSON을 stdin으로 읽고 제한된 JSON context를
+  반환합니다.
+- Hook은 사용자 프롬프트 텍스트를 실행하지 않습니다.
+- 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
+
+영문 설명은 `README.md`, LazyCodex 출처 고정 정보는 `REFERENCE.md`,
+Codex-to-Claude 변환 표는 `docs/migration.md`를 참고하세요.

package/RELEASE_CHECKLIST.md

@@ -1,10 +1,13 @@
 # LazyClaude Release Checklist
 
-Status: quiet public npm package candidate; currently unpublished until explicit
-user approval.
+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.
 
-DO NOT publish LazyClaude, run `npm publish`, push release tags, or add a
-remote Claude Code marketplace entry without 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
+approval.
 
 This release path is for personal install convenience, not advertisement,
 public repo promotion, or a public launch campaign.
@@ -14,6 +17,7 @@ public repo promotion, or a public launch campaign.
 - `npm test`
 - `npm run validate:plugin`
 - `npm run qa:tmux`
+- `npm run qa:portable`
 - `npm run pack:dry-run`
 
 ## Local / Private Checkout Use
@@ -27,10 +31,24 @@ Use this track when testing from the current checkout:
 
 No npm publication is required for this track.
 
-## Quiet Public NPM Package Release
+## Fresh Machine NPM Install Use
 
-Use this track only when the user explicitly approves making the package
-installable through `npm`, `npx`, and `bunx`.
+Use this track after an approved npm package version exists:
+
+1. Run `npx --yes lazyclaude-ai install`.
+2. Run `npx --yes lazyclaude-ai doctor`.
+3. Start Claude Code with the normal `claude` command.
+
+The installer should register `lazyclaude@lazyclaude-ai` in Claude Code's user
+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
+
+Use this track only when the user explicitly approves making a new package
+version installable through `npm`, `npx`, and `bunx`.
 
 1. Confirm the target package name and version with the user.
 2. Review `REFERENCE.md` and `docs/migration.md` for accurate attribution.
@@ -72,15 +90,25 @@ rollback action with user approval:
 
 ## Marketplace Boundary
 
-LazyClaude is tested through `claude --plugin-dir ./plugins/lazyclaude`. 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.
+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. 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
 
 If a local test load causes problems, stop Claude Code, restart without
 `claude --plugin-dir ./plugins/lazyclaude`, and run `/reload-plugins` in any
 remaining session that should drop the local plugin metadata.
+
+If an npm-installed LazyClaude copy causes problems, run:
+
+```bash
+npx --yes lazyclaude-ai uninstall
+```

package/bin/lazyclaude-ai.js

@@ -8,6 +8,7 @@ import {
   readFileSync,
   rmSync,
   symlinkSync,
+  writeFileSync,
 } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
@@ -20,11 +21,11 @@ const version = packageJson.version;
 const usage = `Usage: lazyclaude-ai [--dry-run] <install|doctor|path|run|update|uninstall> [...args]
 
 Commands:
-  install       Copy the packaged LazyClaude plugin into LAZYCLAUDE_HOME.
+  install       Register the packaged LazyClaude plugin in Claude Code.
   doctor        Validate the installed LazyClaude plugin path.
   path          Print the installed Claude plugin path.
-  run -- ...    Run Claude Code with the installed plugin path.
-  update        Reinstall this package version and refresh the current pointer.
+  run -- ...    Run Claude Code after the global plugin install.
+  update        Reinstall this package version and refresh the Claude plugin registry.
   uninstall     Remove LazyClaude-managed install state.
 `;
 
@@ -36,10 +37,19 @@ const parseArgs = (argv) => {
 };
 
 const lazyHome = () => resolve(process.env.LAZYCLAUDE_HOME ?? join(homedir(), ".lazyclaude"));
+const claudeHome = () => resolve(process.env.CLAUDE_CONFIG_DIR ?? process.env.CLAUDE_HOME ?? join(homedir(), ".claude"));
 const versionRoot = (home = lazyHome()) => join(home, "lazyclaude-ai", version);
 const currentRoot = (home = lazyHome()) => join(home, "current");
 const pluginPathForRoot = (installRoot) => join(installRoot, "plugins", "lazyclaude");
-const intendedPluginPath = (home = lazyHome()) => pluginPathForRoot(currentRoot(home));
+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 = () => {
@@ -51,9 +61,156 @@ const fail = (message, status = 1) => {
   process.exit(status);
 };
 
-const currentExists = (home = lazyHome()) => existsSync(currentRoot(home));
+const currentExists = (home = claudeHome()) => existsSync(claudePluginRoot(home));
 
-const requireInstalledPluginPath = (home = lazyHome()) => {
+const readInstalledPlugins = (home = claudeHome()) => {
+  const registryPath = installedPluginsPath(home);
+  if (!existsSync(registryPath)) return { version: 2, plugins: {} };
+  const parsed = JSON.parse(readFileSync(registryPath, "utf8"));
+  return {
+    ...parsed,
+    version: parsed.version ?? 2,
+    plugins: parsed.plugins ?? {},
+  };
+};
+
+const writeInstalledPlugins = (registry, home = claudeHome()) => {
+  const registryPath = installedPluginsPath(home);
+  mkdirSync(dirname(registryPath), { recursive: true });
+  writeFileSync(registryPath, `${JSON.stringify(registry, null, 2)}\n`);
+};
+
+const readClaudeSettings = (home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  if (!existsSync(settingsPath)) return {};
+  return JSON.parse(readFileSync(settingsPath, "utf8"));
+};
+
+const writeClaudeSettings = (settings, home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(home);
+  mkdirSync(dirname(settingsPath), { recursive: true });
+  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}\n`);
+};
+
+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 unregisterMarketplace = (home = claudeHome()) => {
+  const settingsPath = claudeSettingsPath(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, marketplacePath, home = claudeHome()) => {
+  const registry = readInstalledPlugins(home);
+  const now = new Date().toISOString();
+  const existing = registry.plugins[pluginKey]?.[0] ?? {};
+  registry.plugins[pluginKey] = [
+    {
+      scope: "user",
+      installPath: installRoot,
+      version,
+      installedAt: existing.installedAt ?? now,
+      lastUpdated: now,
+      installedBy: "lazyclaude-ai",
+      enabled: true,
+    },
+  ];
+  writeInstalledPlugins(registry, home);
+  registerMarketplace(marketplacePath, home);
+};
+
+const unregisterClaudePlugin = (home = claudeHome()) => {
+  const registryPath = installedPluginsPath(home);
+  if (!existsSync(registryPath)) return;
+  const registry = readInstalledPlugins(home);
+  delete registry.plugins[pluginKey];
+  writeInstalledPlugins(registry, home);
+};
+
+const requireInstalledPluginPath = (home = claudeHome()) => {
   if (!currentExists(home)) {
     fail("LazyClaude is not installed. Run `lazyclaude install` first.");
   }
@@ -76,16 +233,18 @@ const resetCurrentPointer = (home, target) => {
 };
 
 const install = ({ dryRun }) => {
-  const home = lazyHome();
-  const targetRoot = versionRoot(home);
-  const targetPlugin = pluginPathForRoot(targetRoot);
+  const home = claudeHome();
+  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 point current: ${currentRoot(home)} -> ${targetRoot}\n`);
-    process.stdout.write(`Launch with: claude --plugin-dir ${intendedPluginPath(home)}\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;
   }
 
@@ -93,14 +252,23 @@ const install = ({ dryRun }) => {
     fail(`Packaged LazyClaude plugin payload is missing: ${sourcePlugin}`);
   }
 
-  rmSync(targetRoot, { recursive: true, force: true });
+  rmSync(targetPlugin, { recursive: true, force: true });
   mkdirSync(dirname(targetPlugin), { recursive: true });
   cpSync(sourcePlugin, targetPlugin, { recursive: true });
-  resetCurrentPointer(home, targetRoot);
+  const localMarketplace = writeLocalMarketplace(legacyHome);
+  registerClaudePlugin(targetPlugin, localMarketplace, home);
+
+  const legacyRoot = versionRoot(legacyHome);
+  rmSync(legacyRoot, { recursive: true, force: true });
+  mkdirSync(dirname(pluginPathForRoot(legacyRoot)), { recursive: true });
+  cpSync(sourcePlugin, pluginPathForRoot(legacyRoot), { recursive: true });
+  resetCurrentPointer(legacyHome, legacyRoot);
 
   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 --plugin-dir ${intendedPluginPath(home)}\n`);
+  process.stdout.write("Launch with: claude\n");
 };
 
 const doctor = ({ dryRun }) => {
@@ -109,10 +277,13 @@ const doctor = ({ dryRun }) => {
     process.stdout.write("DRY_RUN: doctor LazyClaude install\n");
     process.stdout.write(`Would check plugin files under: ${pluginPath}\n`);
     process.stdout.write(`Would run: claude plugin validate ${pluginPath}\n`);
+    process.stdout.write(`Would check Claude plugin registry: ${pluginKey}\n`);
     return;
   }
 
   const pluginPath = requireInstalledPluginPath();
+  const registryEntry = readInstalledPlugins().plugins[pluginKey]?.[0];
+  if (!registryEntry) fail(`LazyClaude is missing from Claude plugin registry: ${pluginKey}`);
   const requiredFiles = [
     ".claude-plugin/plugin.json",
     ".mcp.json",
@@ -141,10 +312,17 @@ 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`);
-  process.stdout.write(`Launch with: claude --plugin-dir ${pluginPath}\n`);
+  process.stdout.write("Launch with: claude\n");
   process.stdout.write("DOCTOR_PASS\n");
 };
 
@@ -155,8 +333,8 @@ const printPath = () => {
 const runClaude = ({ dryRun, rest }) => {
   const separatorIndex = rest.indexOf("--");
   const claudeArgs = separatorIndex === -1 ? rest : rest.slice(separatorIndex + 1);
-  const pluginPath = dryRun ? intendedPluginPath() : requireInstalledPluginPath();
-  const command = ["claude", "--plugin-dir", pluginPath, ...claudeArgs];
+  if (!dryRun) requireInstalledPluginPath();
+  const command = ["claude", ...claudeArgs];
 
   if (dryRun) {
     process.stdout.write(command.join(" "));
@@ -171,12 +349,17 @@ const runClaude = ({ dryRun, rest }) => {
 
 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")} and ${currentRoot(home)}\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();
+  unregisterMarketplace();
+  rmSync(pluginCacheRoot, { recursive: true, force: true });
   process.stdout.write("UNINSTALL_PASS\n");
 };
 

package/docs/migration.md

@@ -26,14 +26,22 @@ claude --plugin-dir ./plugins/lazyclaude
 For fresh machines, the quiet npm distribution path is:
 
 ```bash
-npx lazyclaude-ai install
+npx --yes lazyclaude-ai install
 bunx lazyclaude-ai install
 lazyclaude doctor
-lazyclaude run
 ```
 
-This keeps installation convenient without requiring public repo promotion or a
-Claude marketplace entry.
+Launch Claude Code normally after install:
+
+```bash
+claude
+```
+
+The installer writes the user plugin cache, `plugins/installed_plugins.json`,
+the `settings.json` `enabledPlugins` entry for `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 remote Claude marketplace entry.
 
 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.0",
+  "version": "0.1.2",
   "description": "Claude Code-native LazyCodex-style workflow distribution.",
   "type": "module",
   "bin": {
@@ -13,6 +13,7 @@
     "plugins",
     "scripts",
     "README.md",
+    "README_ko-KR.md",
     "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.0",
+  "version": "0.1.2",
   "author": {
     "name": "LazyClaude contributors"
   },

package/scripts/qa-portable-install.sh

@@ -4,6 +4,7 @@ set -u
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
 EVIDENCE="$ROOT/evidence/portable-qa-install.txt"
 TMP_HOME=""
+TMP_CLAUDE_HOME=""
 
 mkdir -p "$ROOT/evidence"
 : > "$EVIDENCE"
@@ -12,6 +13,9 @@ cleanup() {
   if [ -n "$TMP_HOME" ]; then
     rm -rf "$TMP_HOME"
   fi
+  if [ -n "$TMP_CLAUDE_HOME" ]; then
+    rm -rf "$TMP_CLAUDE_HOME"
+  fi
 }
 trap cleanup EXIT INT TERM
 
@@ -22,7 +26,9 @@ trap cleanup EXIT INT TERM
 } >> "$EVIDENCE"
 
 TMP_HOME="$(mktemp -d "${TMPDIR:-/tmp/}lazyclaude-portable-qa.XXXXXX")"
+TMP_CLAUDE_HOME="$(mktemp -d "${TMPDIR:-/tmp/}lazyclaude-claude-qa.XXXXXX")"
 export LAZYCLAUDE_HOME="$TMP_HOME"
+export CLAUDE_CONFIG_DIR="$TMP_CLAUDE_HOME"
 
 run_step() {
   local label="$1"
@@ -55,11 +61,45 @@ if [ ! -f "$PLUGIN_PATH/.claude-plugin/plugin.json" ]; then
   echo "INSTALL_FAIL"
   exit 1
 fi
+if [ ! -f "$TMP_CLAUDE_HOME/plugins/installed_plugins.json" ]; then
+  echo "INSTALL_FAIL: Claude plugin registry missing" >> "$EVIDENCE"
+  echo "INSTALL_FAIL"
+  exit 1
+fi
+if [ ! -f "$TMP_CLAUDE_HOME/settings.json" ]; then
+  echo "INSTALL_FAIL: Claude settings missing" >> "$EVIDENCE"
+  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 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"
@@ -67,14 +107,17 @@ if [ ! -d "$PLUGIN_PATH" ]; then
 fi
 
 run_step UNINSTALL node "$ROOT/bin/lazyclaude-ai.js" uninstall
-if [ -e "$TMP_HOME/current" ] || [ -e "$TMP_HOME/lazyclaude-ai" ]; then
+if [ -e "$TMP_HOME/current" ] || [ -e "$TMP_HOME/lazyclaude-ai" ] || [ -e "$TMP_CLAUDE_HOME/plugins/cache/lazyclaude-ai" ]; then
   echo "UNINSTALL_FAIL: managed state remains" >> "$EVIDENCE"
   echo "UNINSTALL_FAIL"
   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
 TMP_HOME=""
+TMP_CLAUDE_HOME=""
 echo "CLEANUP: removed portable QA temp home" >> "$EVIDENCE"
 echo "PORTABLE_QA_PASS"