lazyclaude-ai 0.1.3 → 0.1.5

package/README.md

@@ -9,7 +9,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-lazyclaude--ai-cb3837" />
-  <img src="https://img.shields.io/badge/version-0.1.3-2ea44f" />
+  <img src="https://img.shields.io/badge/version-0.1.5-2ea44f" />
   <img src="https://img.shields.io/badge/Claude%20Code-plugin-blueviolet" />
   <img src="https://img.shields.io/badge/license-MIT-blue" />
 </p>
@@ -19,7 +19,7 @@
 > [!NOTE]
 > LazyClaude is a quiet personal distribution for bringing LazyCodex-style prompt engineering into Claude Code. It installs as `lazyclaude@lazyclaude-ai`, so normal `claude` launches can load the LazyClaude skills and hooks without a long `--plugin-dir` command.
 
-The current public package is `lazyclaude-ai@0.1.3` for personal install
+This checkout is prepared as `lazyclaude-ai@0.1.5` for personal install
 convenience. The repo can remain private and quiet; publishing to npm here does
 not imply public repo promotion, marketplace publication, or advertisement.
 Future package releases still require explicit user approval.
@@ -30,7 +30,7 @@ Future package releases still require explicit user approval.
 - **ULW prompt hooks** - type `ulw`, `ultrawork`, `$ulw-plan`, or `$ulw-loop`
 - **Native goal guidance** - ULW context points Claude toward `/goal` or
   model-facing `get_goal`, `create_goal`, and delayed `update_goal` when those
-  surfaces exist
+  surfaces exist, and gives a clear fallback when goal tools are unavailable
 - **Dynamic workflow/worktree guidance** - large or parallel tasks are steered
   toward Claude Code Dynamic workflow orchestration and Dynamic worktree
   isolation
@@ -48,6 +48,17 @@ Future package releases still require explicit user approval.
 npx --yes lazyclaude-ai install
 ```
 
+If you are currently inside this repository checkout, which has the same
+package name as the registry package, `npx --yes lazyclaude-ai@0.1.5 install`
+can resolve the local same-name source checkout and fail with
+`sh: lazyclaude-ai: command not found`. From a fresh directory, the normal
+install command works:
+
+```bash
+cd /tmp
+npx --yes lazyclaude-ai@0.1.5 install
+```
+
 Validate the installed plugin:
 
 ```bash
@@ -68,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
@@ -111,21 +123,29 @@ $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, native goal handling, manual QA evidence, cleanup receipts,
-and explicit approval before future release steps.
+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, so it may not show a separate Skill
-tool invocation in Claude Code history. Use visible namespaced commands when
-you want explicit LazyClaude skill activation:
+completion or a genuine blocker. When goal tools are unavailable or not exposed,
+LazyClaude now tells Claude to say that plainly and ask you to bind the native
+session goal with an exact `/goal <completion condition>` before long execution.
+For large independent work, LazyClaude applies the same principle to Claude
+Code's available orchestration surfaces: when `Workflow` is exposed, call the
+`Workflow` tool; when isolated edits need a model-facing worktree lane, use
+`EnterWorktree`. If only the CLI surface is available for a fresh isolated lane,
+use `claude --worktree <short-name> --tmux`.
+
+Plain `ulw` is hook context activation. Claude may still show it as hook
+guidance rather than a separate Skill tool invocation in history. Use visible
+namespaced commands when you want explicit LazyClaude skill activation:
 
 ```text
 /lazyclaude:ulw-loop <what you want executed with evidence>
@@ -133,6 +153,10 @@ you want explicit LazyClaude skill activation:
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+Those namespaced commands are shipped as real Claude Code command files under
+`plugins/lazyclaude/commands/`, so `/lazyclaude:ulw-loop` should load the
+command body, then the matching skill guidance.
+
 ## Commands
 
 | Command | Purpose |

package/README_ko-KR.md

@@ -9,7 +9,7 @@
 </p>
 <p align="center">
   <img src="https://img.shields.io/badge/npm-lazyclaude--ai-cb3837" />
-  <img src="https://img.shields.io/badge/version-0.1.3-2ea44f" />
+  <img src="https://img.shields.io/badge/version-0.1.5-2ea44f" />
   <img src="https://img.shields.io/badge/Claude%20Code-plugin-blueviolet" />
   <img src="https://img.shields.io/badge/license-MIT-blue" />
 </p>
@@ -23,7 +23,7 @@
 > [!NOTE]
 > LazyClaude는 LazyCodex 스타일의 prompt engineering을 Claude Code로 가져오기 위한 조용한 개인용 배포판입니다. `lazyclaude@lazyclaude-ai`로 설치되므로, 매번 긴 `--plugin-dir` 없이 일반 `claude` 실행에서 LazyClaude skill과 hook을 불러올 수 있습니다.
 
-현재 공개 npm 패키지는 `lazyclaude-ai@0.1.3`입니다. 목적은 다른 PC에서도
+현재 checkout은 `lazyclaude-ai@0.1.5` 배포용으로 준비되어 있습니다. 목적은 다른 PC에서도
 빠르게 설치하기 위한 개인용 배포물입니다. 저장소는 비공개 저장소로
 유지할 수 있고, npm 배포가 곧 홍보, 공개 저장소 운영, Claude marketplace
 등록을 의미하지는 않습니다. 새 버전 배포는 항상 별도의 명시적 승인 후에
@@ -35,7 +35,7 @@
 - **ULW prompt hook** - `ulw`, `ultrawork`, `$ulw-plan`, `$ulw-loop` 트리거
 - **Native goal guidance** - Claude Code가 `/goal` 또는 `get_goal`,
   `create_goal`, `update_goal` 같은 goal surface를 제공하면 이를 우선
-  사용하도록 유도
+  사용하도록 유도하고, goal tools are unavailable 상황의 fallback도 명시
 - **Dynamic workflow/worktree guidance** - 크거나 병렬적인 작업은 Claude
   Code Dynamic workflow와 Dynamic worktree 격리 쪽으로 유도
 - **Claude skills** - `ulw-plan`, `ulw-loop`, `start-work`, `rules`, `lsp`, `programming`, `review-work`
@@ -52,6 +52,17 @@
 npx --yes lazyclaude-ai install
 ```
 
+현재 위치가 이 저장소 checkout이면, registry package와 같은 package name을
+가진 same-name source checkout 안에 있는 상태입니다. 이 경우
+`npx --yes lazyclaude-ai@0.1.5 install`이 local checkout을 먼저 해석해서
+`sh: lazyclaude-ai: command not found`로 실패할 수 있습니다. 새 폴더에서는
+일반 설치 명령이 정상 동작합니다.
+
+```bash
+cd /tmp
+npx --yes lazyclaude-ai@0.1.5 install
+```
+
 설치 상태를 확인합니다.
 
 ```bash
@@ -73,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
@@ -115,21 +127,29 @@ $start-work plans/lazyclaude-retrofit.md
 ```
 
 기대 동작은 LazyClaude prompt hook이 `ULTRAWORK MODE ENABLED` 컨텍스트를
-추가하고, skill 및 agent 지시문이 Claude를 test-first 작업, native goal
-처리, 실제 수동 QA 증거, cleanup receipt, 향후 release step의 명시적 승인
-쪽으로 유도하는 것입니다.
+추가하고 `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으로 보이지 않을 수 있습니다. 명시적인
-LazyClaude skill activation을 보고 싶다면 namespaced command를 사용합니다.
+진짜 blocker가 있을 때까지 미루도록 안내합니다. goal tools are unavailable,
+즉 model-facing goal tools가 이 Claude Code session에 노출되지 않은 경우에는
+그 한계를 먼저 말하고, 긴 실행 전에 정확한 `/goal <completion condition>`로
+native session goal을 묶어달라고 요청하도록 했습니다. 큰 독립 작업에서는
+같은 원칙을 Claude Code가 노출한 orchestration surface에 적용합니다.
+`Workflow`가 노출되면 `Workflow` tool을 호출하고, isolated edit lane이
+model-facing worktree를 필요로 하면 `EnterWorktree`를 사용합니다. CLI surface만
+가능한 새 격리 lane에서는 `claude --worktree <short-name> --tmux`를 사용합니다.
+
+단순히 `ulw`라고 입력하는 것은 hook context activation입니다. Claude Code
+history에는 별도 Skill tool invocation이 아니라 hook guidance로 보일 수
+있습니다. 명시적인 LazyClaude skill activation을 보고 싶다면 namespaced
+command를 사용합니다.
 
 ```text
 /lazyclaude:ulw-loop <증거 기반으로 실행할 작업>
@@ -137,6 +157,10 @@ LazyClaude skill activation을 보고 싶다면 namespaced command를 사용합
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+이 namespaced command들은 `plugins/lazyclaude/commands/` 아래 실제 Claude Code
+command file로 배포됩니다. 따라서 `/lazyclaude:ulw-loop`는 command body를 먼저
+로드하고, 이어서 대응 skill guidance를 따라가야 합니다.
+
 ## 명령어
 
 | 명령어 | 용도 |

package/RELEASE_CHECKLIST.md

@@ -1,7 +1,7 @@
 # LazyClaude Release Checklist
 
-Status: quiet public npm package `lazyclaude-ai@0.1.3` is published for
-personal install convenience after explicit user approval.
+Status: this checkout is prepared for quiet public npm package
+`lazyclaude-ai@0.1.5` 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
@@ -43,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.5 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,11 @@ $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
@@ -35,9 +38,18 @@ matching goal is active, and delay `update_goal` until verified completion or a
 genuine blocker. It may also point Claude toward the user-visible `/goal`
 surface, but it does not auto-type `/goal` or send slash command text.
 
-For broad work, the same context can steer Claude toward Dynamic workflow
-orchestration and Dynamic worktree isolation so independent work proceeds with
-bounded evidence paths and without mutating unrelated workspace state.
+If goal tools are unavailable or not exposed in the running Claude Code session,
+the hook context tells Claude to say that explicitly and ask the user to bind the
+native session goal with `/goal <completion condition>` before long execution.
+LazyClaude then continues with its ledger fallback when the user declines or the
+surface is absent.
+
+For broad work, the same context ports the LazyCodex model-facing principle to
+Claude Code's exposed orchestration surfaces: if `Workflow` is available, call
+the `Workflow` tool before serial execution and bind every lane to evidence and
+cleanup. If isolated edits need a model-facing worktree lane, use
+`EnterWorktree`; when only the CLI surface is available, the actionable launch
+form is `claude --worktree <short-name> --tmux`.
 
 Plain `ulw` therefore activates hook context, not a visible Skill tool call.
 For a visible LazyClaude command/skill invocation, use the namespaced Claude
@@ -49,6 +61,8 @@ Code commands:
 /lazyclaude:start-work plans/lazyclaude-retrofit.md
 ```
 
+These are real Claude Code command files in `plugins/lazyclaude/commands/`.
+
 ## Safety
 
 Hooks parse JSON from stdin and return JSON to Claude Code. The hook does not

package/docs/migration.md

@@ -10,7 +10,7 @@ of surface, and a conservative local fallback where it does not.
 | Codex ultrawork plan mode | Claude Code skill plus planner agent | `ulw-plan` and `prometheus-planner` |
 | Codex execution loop | Claude Code skill plus executor agent | `ulw-loop`, `start-work`, and `boulder-executor` |
 | Codex goal-tool guidance | Claude Code native goal surface | `/goal` when user-selected, or model-facing `get_goal`, `create_goal`, and verified-final `update_goal` guidance when exposed |
-| Codex parallel orchestration | Claude Code Dynamic workflow and Dynamic worktree surfaces | Use Dynamic workflow for broad independent work and Dynamic worktree isolation for risky or parallel edits |
+| Codex parallel orchestration | Claude Code Dynamic workflow and Dynamic worktree surfaces | Call `Workflow` for broad independent work when exposed; use `EnterWorktree` or the CLI worktree path for risky or parallel edits |
 | Codex hooks | Claude Code hooks | `plugins/lazyclaude/hooks/hooks.json` |
 | Codex MCP helpers | Claude Code plugin MCP config | `plugins/lazyclaude/.mcp.json` |
 | Codex LSP integration | Claude Code plugin LSP config | `plugins/lazyclaude/.lsp.json` |
@@ -54,11 +54,18 @@ Claude to inspect `get_goal`, create a goal with `create_goal` only when no
 matching active goal exists, and defer `update_goal` until the evidence gate has
 passed or a real blocker is recorded.
 
+Current Claude Code sessions may not expose model-facing goal tools to the
+model. When goal tools are unavailable or not exposed, LazyClaude should not
+pretend the native goal was bound. It should state the limitation and ask the
+user to run `/goal <completion condition>` before long-running ULW execution.
+
 When the user explicitly chooses Claude Code `/goal`, that native session goal
 remains user-visible and user-controlled. LazyClaude does not auto-type
-`/goal`. For multi-lane work, LazyClaude should prefer Dynamic workflow
-orchestration where available and Dynamic worktree isolation when parallel or
-risky edits might otherwise collide.
+`/goal`. For multi-lane work, LazyClaude follows the same model-facing tool
+principle where Claude Code exposes it: call the `Workflow` tool before serial
+execution, bind each lane to criteria and evidence, and use `EnterWorktree` for
+isolated model-facing worktree lanes. When only the CLI surface is available,
+the concrete isolated-lane launch form is `claude --worktree <short-name> --tmux`.
 
 If OMC/omc is already installed in Claude Code, keep it disabled or start a
 separate Claude Code session without OMC while testing LazyClaude. This repo no

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lazyclaude-ai",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Claude Code-native LazyCodex-style workflow distribution.",
   "type": "module",
   "bin": {

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

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

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

@@ -21,25 +21,31 @@ 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.",
+  "Native goal tool integration: only when Claude Code exposes model-facing goal tools, first inspect get_goal, call create_goal with an objective-only payload when no matching goal is active, and reserve update_goal for verified completion or a genuine blocker.",
+  "Native /goal fallback: if model-facing goal tools are unavailable or not exposed, say so explicitly and ask the user to bind the native Claude Code goal with /goal <completion condition>; continue with the LazyClaude ledger fallback when they decline or the surface is absent.",
   "Do not auto-type or inject the user's slash commands; treat /goal as Claude Code's native goal surface, not as prompt text for this hook to send.",
-  "Dynamic workflow: for large independent work, prefer Claude Code Dynamic workflows or subagents with explicit criteria and artifacts.",
-  "Dynamic worktree: isolate risky or parallel edits in the active Claude Code worktree/workspace and never mutate unrelated user state.",
+  "Dynamic workflow integration: when Claude Code exposes the Workflow tool and the task is broad, risky, parallel, or long-running, call the Workflow tool before serial execution and bind each lane to explicit criteria, artifacts, and cleanup receipts.",
+  "Dynamic worktree integration: when Claude Code exposes EnterWorktree and isolated edits are needed, use EnterWorktree for the selected lane; otherwise use or recommend claude --worktree <short-name> --tmux. Never mutate unrelated user state.",
 ].join(" ");
 
 const input = readInput();
@@ -54,7 +60,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(ultraworkContext);
+      writeContext(ultraworkContext, "LazyClaude ULW hook active: ulw-loop guidance injected.");
     } else {
       writeContext("LazyClaude prompt hook checked: no workflow activation.");
     }

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

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

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

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

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

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

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

@@ -27,6 +27,14 @@ 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.
+If goal tools are unavailable or not exposed in this Claude Code session, state
+that limitation before execution and ask the user to bind a native
+`/goal <plan completion condition>` when the plan is long-running. Continue with
+the Boulder and ledger fallback when no native goal can be bound.
+
+For broad, risky, parallel, or long-running checkbox waves, use Dynamic workflow
+orchestration and call `Workflow` when Claude Code exposes it. Each workflow lane must have explicit evidence
+paths and cleanup receipts. For risky or parallel edits, use Dynamic worktree
+isolation: call `EnterWorktree` when it is exposed, keep every command in the
+selected worktree, and when only the CLI surface is available use or recommend
+`claude --worktree <short-name> --tmux`.

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

@@ -22,8 +22,16 @@ 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.
+If goal tools are unavailable or not exposed in this Claude Code session, state
+that limitation explicitly. Before long execution, ask the user to bind the
+native Claude Code goal with a concrete `/goal <completion condition>` command,
+then continue with a local ledger fallback when they choose not to.
+
+For broad, risky, parallel, or long-running work, use Dynamic workflow
+orchestration and call the `Workflow` tool when Claude Code exposes it instead
+of merely mentioning workflow guidance. Keep each worker or workflow branch tied
+to concrete criteria, artifacts, and cleanup receipts. Use Dynamic worktree
+isolation for risky or parallel edits: call
+`EnterWorktree` when Claude Code exposes it, keep all mutations inside the active
+Claude Code workspace/worktree, and when only the CLI surface is available use
+or recommend `claude --worktree <short-name> --tmux`.

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

@@ -14,9 +14,12 @@ Use Claude Code surfaces directly:
 - 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
+  condition when goal tools are unavailable or not exposed
 - include Dynamic workflow and Dynamic worktree guidance for independent,
-  parallel, risky, or long-running implementation lanes
+  parallel, risky, or long-running implementation lanes: call `Workflow` when
+  Claude Code exposes it, call `EnterWorktree` when isolated edits
+  need a model-facing worktree lane, and include
+  `claude --worktree <short-name> --tmux` when only the CLI surface is available
 - write only plan artifacts and drafts
 - include concrete tests, manual QA, cleanup, and non-publish guardrails
 

package/scripts/qa-portable-install.sh

@@ -91,7 +91,7 @@ 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
+  if ! grep -Eq "Skills \\([0-9]+\\)" "$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