create-ai-project 1.20.9 → 1.22.0

package/.claude/skills-ja/subagents-orchestration-guide/SKILL.md

@@ -124,6 +124,27 @@ description: サブエージェントのタスク分担と連携を調整。規
 
 ## 構造化レスポンス仕様
 
+すべてのサブエージェント呼び出しは **Agent ツール** を使用し、以下を渡す:
+- `subagent_type`: エージェント名（例: "task-executor"）
+- `description`: 簡潔なタスク記述（3〜5語）
+- `prompt`: 成果物のパスを含む具体的な指示
+
+### オーケストレーターの許可ツール
+
+オーケストレーターは以下のツールのみで作業を統制する:
+
+| ツール | 用途 |
+|------|------|
+| Agent | サブエージェントの呼び出し |
+| AskUserQuestion | ユーザー確認・質問 |
+| TaskCreate / TaskUpdate | 進捗追跡 |
+| Bash | シェル操作（git commit、ls、検証コマンド） |
+| Read | サブエージェント間の情報橋渡しのための成果物ドキュメント参照 |
+
+実装作業（Edit、Write、MultiEdit）はすべてサブエージェントが実施する。オーケストレーター自身は行わない。
+
+### サブエージェント応答形式
+
 サブエージェントはJSON形式で応答。オーケストレーター判断に必要なフィールド：
 
 | Agent | 主要フィールド | 判断ロジック |
@@ -136,8 +157,8 @@ description: サブエージェントのタスク分担と連携を調整。規
 | document-reviewer | approvalReady (true/false) | trueで次ステップへ。falseで修正を依頼 |
 | design-sync | sync_status (NO_CONFLICTS/CONFLICTS_FOUND) | CONFLICTS_FOUND時: 矛盾をユーザーに提示してから進む |
 | integration-test-reviewer | status (approved/needs_revision/blocked), requiredFixes | needs_revision時: 同じ task_file と requiredFixes[] を渡してルーティング先の executor を Fix Mode で再実行 |
-| security-reviewer | status (approved/approved_with_notes/needs_revision/blocked), findings, notes, requiredFixes | needs_revision時: 影響ファイルをTarget Filesに含めた統合修正タスクファイルを作成し、その task_file と requiredFixes[] を渡してexecutor を Fix Mode で起動（build/implementレシピ参照） |
-| acceptance-test-generator | status, generatedFiles (integration: path\|null, e2e: path\|null), budgetUsage, e2eAbsenceReason (E2E 出力時は null。それ以外は no_multi_step_journey \| below_threshold_user_confirmed) | ファイルの存在を確認し、不在理由（e2eAbsenceReason）を添えて work-planner に渡す |
+| security-reviewer | status (approved/approved_with_notes/needs_revision/blocked), findings, notes, requiredFixes | needs_revision時: `requiredFixes[].location` から影響ファイルパスを抽出して Target Files に投入した統合修正タスクファイルを作成し、その task_file と `requiredFixes[]` 配列を渡してルーティング先の executor を Fix Mode で起動。続いて quality-fixer を実行し、最後に security-reviewer を再起動して解消を検証する。blocked 時: ブロッキング findings を添えてユーザーにエスカレーション — エージェント層の権限外の修正である |
+| acceptance-test-generator | status, generatedFiles.{integration,fixtureE2e,serviceE2e}（レーンごとに path\|null）, budgetUsage（レーン別）, e2eAbsenceReason（E2Eレーンごと。出力時は null。reason の enum 定義は acceptance-test-generator と integration-e2e-testing スキルが所有） | 非nullの各 `generatedFiles.<lane>` パスがディスク上に存在することを確認し、レーン別のパスと不在理由を work-planner に渡す |
 
 ### quality-fixer blockedハンドリング
 
@@ -186,6 +207,15 @@ quality-fixerが `status: "blocked"` を返した場合、`reason`で判別：
 
 注: 小規模スケールでも実装ステップは task-executor を介して標準の4ステップサイクル（`task-executor → エスカレーション判定 → quality-fixer → commit`）で実行する。オーケストレーターによる直接編集は行わない。
 
+### Implementation Readinessマーカー
+
+Medium / Large規模では、一括承認後、作業計画書のヘッダに `Implementation Readiness:` 行が含まれる（work-plannerが`pending`を出力する。`ready` または `escalated` への昇格は外部オーケストレーションの関心事である）。マーカーは以下3値のいずれかを取る:
+- `pending` — work-plannerが設定する初期状態
+- `ready` — readiness検証が完了し残存ギャップなし。タスク実行サイクルを安全に開始できる
+- `escalated` — readiness検証は完了したが残存ギャップが存在し、実行前にユーザー判断が必要
+
+`pending`から先へマーカーを昇格させるプロデューサと、task-executor呼び出し前にマーカーを読むコンシューマは、いずれも外部オーケストレーションが所有する。本ガイドはエージェント層の上位にあるオーケストレーターを呼び出さない。エージェントは明示的に依頼された場合にのみマーカーを読み書きする。
+
 ## レイヤー横断オーケストレーション
 
 requirement-analyzerが複数レイヤー（backend + frontend）にまたがる機能と判定した場合（`crossLayerScope`で判断）、以下の拡張を適用。ステップ番号は大規模フロー基準。中規模フローではDesign Doc作成がステップ2から始まるため、同じパターンをステップ2a/2b/3/4として適用する。
@@ -321,21 +351,13 @@ requirement-analyzerが複数レイヤー（backend + frontend）にまたがる
 
    #### *1 acceptance-test-generator → work-planner
 
-   **acceptance-test-generatorへの入力**:
-   - Design Doc: [パス]
-   - UI Spec: [パス]（存在する場合）
+   **acceptance-test-generatorへの入力**: Design Doc のパス、UI Spec のパス（存在する場合）。
 
-   **オーケストレーター確認項目**:
-   - `generatedFiles.integration`が有効なパスであり（nullでない場合）、ファイルが存在すること
-   - `generatedFiles.e2e`が有効なパスであり（nullでない場合）、ファイルが存在すること
-   - `generatedFiles.e2e`がnullの場合、`e2eAbsenceReason`が存在すること — これは意図的な不在であり、エラーではない
+   **オーケストレーターの検証**: 非nullの各 `generatedFiles.<lane>` パスがディスク上に存在すること。nullのレーンごとに `e2eAbsenceReason.<lane>` が存在すること — これは意図的な不在であり、エラーではない。
 
-   **work-plannerへの入力**:
-   - 統合テストファイル: [パス]（各フェーズの実装と同時に作成・実行）
-   - E2Eテストファイル: [パス]またはnull（提供された場合のみ最終フェーズで実行）
-   - E2E不在理由: [理由]（E2Eがnullの場合 — work-plannerがE2Eギャップチェックをスキップするために渡す）
+   **work-plannerへの入力**: 統合テスト / fixture-e2e / service-integration-e2e の各ファイルパス（レーンごとに値またはnull）、レーン別の不在理由、およびタイミングガイダンス — 統合テストは各フェーズ実装と並行して作成、fixture-e2e テストは UI 機能フェーズと並行して作成、service-integration-e2e テストは最終フェーズでのみ実行。
 
-   **エラー時**: 統合テストファイル生成が予期せず失敗した場合（status != completed）はユーザーにエスカレーション。E2Eがnullかつ不在理由が妥当な場合はエラーではない。
+   **エラー時**: status != completed で統合テストファイル生成が予期せず失敗した場合はユーザーにエスカレーションする。E2Eレーンがnullかつ妥当な不在理由がある場合はエラーではない。
 3. **ADRステータス管理**: ユーザー判断後のADRステータス更新（Accepted/Rejected）
 
 ## 重要な制約

package/.claude/skills-ja/task-analyzer/references/skills-index.yaml

@@ -86,11 +86,6 @@ skills:
     size: small
     key-references:
       - "プロジェクト固有（経験則）"
-    sections:
-      - "プロジェクト概要"
-      - "ドメイン制約"
-      - "開発フェーズ"
-      - "ディレクトリ規約"
 
   documentation-criteria:
     skill: "documentation-criteria"

package/.husky/pre-commit

@@ -1 +1,2 @@
 npx lint-staged
+npm run check:skills-index

package/CHANGELOG.md

@@ -5,6 +5,55 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.22.0] - 2026-05-10
+
+### Added
+
+- **External Resources section in project-context skill** (skills) — Captures access methods for resources outside the repository (design source, design system, schema source, secret store, IaC source, deployment trigger) across four domains: frontend, backend, API contract, infrastructure. Each domain reference (`references/external-resources-{frontend,backend,api,infra}.md`) defines four structured axes plus a self-declaration phase. Per-axis output schema records three fields: Source type, Location, Access method. Multiple-instance and cross-axis-reference rules cover primary/analytics splits and resources shared across domains
+- **Template-driven /project-inject command** (commands) — Section catalog and hearing protocol live in `.claude/skills/project-context/references/template.md`; new dimensions are added by editing the template. Section-level hearing supports five dispositions (`add` / `keep` / `update` / `remove` / `skip`) for incremental updates without re-running the full flow. Vagueness rejection filter sends back subjective rules for measurable rephrasing during hearing
+
+### Changed
+
+- **project-context skill scope** (skills) — Expanded from domain constraints / development phase / directory conventions to also cover external-resource access methods. Description frontmatter advertises all four axes with explicit "Use when" trigger phrases (session start, project structure check, domain rules, external resources). Configured SKILL.md is shaped by /project-inject from the catalog; unconfigured stub ships as a minimal one-line invitation to run /project-inject
+- **skills-index validator: dynamic-content skills allowed** (tooling) — `scripts/check-skills-index.mjs` treats yaml entries with no sections as dynamic content (logged, skipped) rather than failing. Releases the prior implicit requirement that every skill have at least one static section, removing the need for stub-padding workarounds for skills whose content is populated at runtime
+
+## [1.21.0] - 2026-05-03
+
+### Added
+
+- **prepare-implementation recipe** (commands) — New optional readiness phase between work-plan approval and the build/implement phase. Verifies five readiness criteria (Verification Strategy references, E2E preconditions, Phase 1 observability, UI rendering surface, local lane procedure), generates Phase 0 prep tasks through the standard 4-step cycle when gaps exist, and exits no-op when readiness is already satisfied. Routes prep-only targets (`docs/**`, `scripts/**`, `tests/fixtures/**`, `tests/e2e/data/**`) to the backend executor; mixed/unrecognized targets escalate. Persists `## Implementation Readiness Report` into the work plan body and promotes the header marker to `ready` or `escalated`
+- **Implementation Readiness gate** (agents, commands) — work-planner emits `Implementation Readiness: pending` in the plan header for medium/large scale. build / front-build / implement read the marker and halt-and-confirm via AskUserQuestion when the status is `pending` or `escalated`. subagents-orchestration-guide describes the marker contract abstractly (values: `pending` | `ready` | `escalated`)
+- **E2E lane split (fixture-e2e / service-integration-e2e)** (agents, skills) — fixture-e2e: browser harness with mocked backend / fixture-driven state, MAX 3 per feature, runs alongside the UI feature phase, ROI ≥ 20 floor for non-reserved slots. service-integration-e2e: against a running local stack, MAX 1-2 per feature, executed only in the final phase, ROI > 50 beyond the reserved slot. acceptance-test-generator output schema replaces `generatedFiles.e2e` with `generatedFiles.{integration, fixtureE2e, serviceE2e}`; `e2eAbsenceReason` becomes a per-lane object whose enum is lane-specific (`no_real_service_dependency` is service-lane-only). work-planner E2E gap check evaluates each lane independently. integration-e2e-testing skill, e2e-design reference, and frontend-typescript-testing/references/e2e updated with lane definitions, ROI thresholds by lane, and Fixture-Based Backend patterns (`page.route()` interception, fixture loaders)
+- **UI Spec Component → Task Mapping** (agents, skills) — work-planner produces a UI Spec Component → Task Mapping table when a UI Spec is among the inputs. task-decomposer propagates matching component sections (with state hints) into each task's Investigation Targets. ui-spec-designer enforces component heading uniqueness with a disambiguation rule. plan-template / ui-spec-template carry the new sections
+- **Connection Map** (agents, skills) — work-planner produces a Connection Map table when implementation crosses runtime/deployment boundaries (with strict inclusion criteria — separate processes, serialized contract, observable failure signal — and explicit exclusion of in-process imports). task-decomposer propagates boundary context to implementation tasks on each side via Investigation Targets and a "Boundary Context" note
+- **Per-finding routing in review recipes** (commands) — review / front-review Step 4 changes from a single fix-all toggle to per-finding routing: `c` (code-side fix), `d` (design-side update), `s` (skip), with an "accept all recommended" default offer. New Step 5d invokes technical-designer (update mode) → document-reviewer → design-sync (when multiple Design Docs exist) before code-side fixes. Recommendation rule keys off existing code-reviewer schema only (`acceptanceCriteria` status, `identifierMismatches` rename pattern, `qualityFindings` categories) — no fuzzy intent inference. Early exit when verdict is `pass` and all finding arrays are empty
+- **Consumed Task Set restriction** (commands) — build / front-build / implement compute a restricted Consumed Task Set excluding prep, overview, completion, review-fix, and integration-test patterns. Layer-aware consumption per the routing table: build owns `*-task-*` and `*-backend-task-*`; front-build owns only `*-frontend-task-*`. `$ARGUMENTS` takes priority over auto-resolution. Auto-resolution to most-recent plan requires positive backend-signal verification (Target Files match backend markers, Design Doc filename identifies as backend, or title/objective explicitly says backend) AND zero frontend signals; otherwise stops and asks for `$ARGUMENTS`
+- **Final Cleanup pattern** (commands) — Each task-creating recipe (build / front-build / implement / review / front-review / add-integration-tests / prepare-implementation) deletes its consumed task files at completion. implement is scale-agnostic and cleans all three layer patterns
+- **subagents-orchestration-guide: Orchestrator's Permitted Tools subsection** (skills) — Explicit table of orchestrator-permitted tools (Agent / AskUserQuestion / TaskCreate / TaskUpdate / Bash / Read) with the constraint that all implementation work is performed by subagents
+- **subagents-orchestration-guide: Implementation Readiness Marker subsection** (skills) — Documents the marker contract abstractly (values, producer, consumer) with the explicit note that promotion beyond `pending` and consumption before execution are external orchestration concerns
+- **scripts/check-skills-index.mjs** (tooling) — Deterministic consistency checker that walks every entry in `.claude/skills-{en,ja}/task-analyzer/references/skills-index.yaml`, extracts H2 headings from each corresponding `SKILL.md`, and exits non-zero on any order or text mismatch. Scope is narrow (sections are deterministic; tags / typical-use remain manual). Wired as `npm run check:skills-index` and registered in `.husky/pre-commit`
+
+### Changed
+
+- **acceptance-test-generator: lane-aware ROI selection** (agents) — Phase 3 push-down analysis adds a lane assignment step (default fixture-e2e for UI journeys; promote to service-integration-e2e only when verification depends on real cross-service behavior). Phase 4 selection algorithm reserves slots per lane (fixture-e2e reserved for any user-facing journey; service-integration-e2e reserved only when real cross-service correctness is required) and applies per-lane ROI gates. Generation Report contract expanded to per-lane fields with a per-lane absence-reason matrix
+- **work-planner: scale-aware readiness emission and lane-aware test placement** (agents) — Header MUST include `Implementation Readiness: pending` for medium/large. E2E gap check evaluates fixture-e2e and service-integration-e2e independently. Test placement rules split into integration / fixture-e2e (alongside UI feature phase) / service-integration-e2e (final phase only). Quality Checklist gains UI Spec Component → Task Mapping, Connection Map, and the readiness-marker entry
+- **task-decomposer: layer-aware naming convention clarified** (agents) — Bare `*-task-*` is reserved for backend single-layer per Layer-Aware Agent Routing. Frontend single-layer must use `*-frontend-task-*`. Multi-layer uses both `*-backend-task-*` and `*-frontend-task-*`. Investigation Targets gain rows for frontend component implementation, frontend integration / fixture-e2e tests, and cross-package boundary implementation. UI Spec Propagation and Connection Map Propagation sections describe how table rows flow into task files
+- **subagents-orchestration-guide: per-lane test info routing and security-reviewer fix runbook** (skills) — acceptance-test-generator → work-planner handover documents per-lane paths and absence reasons plus timing guidance. The security-reviewer row replaces the prior cross-recipe reference with an inline runbook (consolidated fix task file → routed executor in Fix Mode → quality-fixer → re-invoke security-reviewer; on `blocked`, escalate)
+- **plan-template: Implementation Readiness header line and new section blocks** (skills) — Header carries the readiness marker on its own line for medium/large scale so downstream parsers extract a bare status (small scale uses task-template instead). New `## UI Spec Component → Task Mapping` and `## Connection Map` sections with reference-key rules and gap status semantics
+- **ui-spec-template: component heading uniqueness call-out** (skills) — `### Component: [ComponentName]` (Japanese: `### コンポーネント: [ComponentName]`) carries a uniqueness rule that downstream agents reference components by exact heading text
+- **All command files: $ARGUMENTS-honoring resolution** (commands) — When `$ARGUMENTS` is provided it is used directly. Auto-resolution from task files is the fallback; the resolution table cleanly separates `$ARGUMENTS`-supplied paths from layer-verified auto-resolved paths. front-build stops rather than auto-fallback when only frontend tasks are missing
+- **integration-e2e-testing: ROI thresholds by lane** (skills) — Replaces the single E2E threshold with a per-lane table. Reserved slot rules apply per lane and override the threshold; below-floor candidates beyond the reserved slot are not emitted (budget intentionally unfilled rather than padded with low-value tests). Includes worked examples for both lanes
+- **frontend-typescript-testing/references/e2e: lane selection guidance** (skills) — New Lane Selection table maps each lane to its backend setup and applicable patterns. Fixture-Based Backend (fixture-e2e) section documents `page.route()` interception and fixture loader patterns. E2E Environment Prerequisites section now explicitly scopes to service-integration-e2e
+- **Dependency direction enforcement** (skills) — subagents-orchestration-guide no longer names specific recipes in the security-reviewer row; the actionable runbook is inline. acceptance-test-generator, task-decomposer, ui-spec-designer, work-planner reference cross-cutting concerns abstractly via guide section names
+
+### Fixed
+
+- **skills-index drift between yaml and SKILL.md headings** (tooling) — pre-commit `check:skills-index` catches future drift before commit. All 26 skills (13 en + 13 ja) currently consistent
+- **Dangling section references in command files** (commands) — Command files referencing `subagents-orchestration-guide "Orchestrator's Permitted Tools"` resolve to a real section in the guide
+- **acceptance-test-generator integration test example budget header** (agents) — Updated from the pre-lane-split `Budget Used: 2/3 integration, 0/2 E2E` to the new schema (`2/3 integration, 0/3 fixture-e2e, 0/2 service-integration-e2e`)
+- **front-build orphan command line** (commands) — Removed an isolated `! ls -la docs/plans/*.md | head -10` left between the Scope Boundary block and the autonomous-mode prompt
+- **frontend-typescript-testing/references/e2e Skeleton Comment Format** (skills) — Skeleton format requires the `@lane:` annotation and shows lane-specific `@dependency` choices (`full-ui (mocked backend)` for fixture-e2e, `full-system` for service-integration-e2e), matching the lane contract
+
 ## [1.20.9] - 2026-05-01
 
 ### Added
@@ -21,7 +70,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **subagents-orchestration-guide: scale-aware Small Scale flow** (skills) — Small Scale (1-2 files) flow now declares that work-planner emits a single task-template-format file directly under `docs/plans/tasks/` and that path is what task-executor receives as `task_file`. Document Requirement table Small row carries the same contract
 - **work-planner: `scale` input parameter and Output Mode by Scale table** (agents) — `scale: small | medium | large` controls output: `small` produces a single task-template-format file under `docs/plans/tasks/` (no separate plan + decomposition); `medium` / `large` produce a plan-template-format work plan under `docs/plans/`. Step 7 branches accordingly
 - **All JSON-returning agents: Output Protocol section** (agents) — Single-sentence directive that the final message is exactly one JSON object matching the schema below (begins with `{`, ends with `}`, no code fence) and that progress text appears only in earlier messages
-- **Self-Validation [BLOCKING — before output] sections** (agents) — Replaces former `## Output Self-Check` blocks across JSON-returning agents. Includes return-to-step recovery rule when any item is unsatisfied. Applied to both EN and JA mirrors
+- **Self-Validation [BLOCKING — before output] sections** (agents) — Replaces former `## Output Self-Check` blocks across JSON-returning agents. Includes return-to-step recovery rule when any item is unsatisfied
 - **subagents-orchestration-guide: explicit subagent prompt construction rules** (skills) — Two new rules: subagents see only the Agent tool prompt and files they read (so paths, prior JSON, parameters, scope constraints must be injected explicitly); every `[placeholder]` in the call examples must be replaced with concrete values before invoking the Agent tool
 - **task-template: `## Investigation Notes` section** (skills) — New section between Investigation Targets and Implementation Steps. Implementation observations are appended here before implementation begins
 
@@ -39,15 +88,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **subagents-orchestration-guide: Subagent I/O table updates** (skills) — task-executor row carries the full `escalation_type` enum and Fix Mode signal description; quality-fixer row documents `filesModified`; integration-test-reviewer / security-reviewer rows describe Fix Mode routing (security-reviewer routes through a consolidated fix task file)
 - **task-decomposer: English canonical headings in generated tasks** (agents) — Task Structuring step explicitly instructs use of task-template's English headings (`## Target Files`, `## Investigation Targets`, `## Implementation Steps (TDD: Red-Green-Refactor)`, `## Quality Assurance Mechanisms`, `## Operation Verification Methods`, `## Completion Criteria`) with a note that headings are not translated, so executor extraction stays consistent across language environments
 - **task-template: machine-read identifiers preserved as English** (skills) — Section headings and `Metadata:` keys (`Dependencies:`, `Provides:`, `Size:`, `Deliverable:`) kept as English so executor parsing remains language-independent. Body prose remains natural Japanese
-- **JA mirror: routing markers naturalized in frontmatter** (agents) — "Use when / Use PROACTIVELY / MUST BE USED PROACTIVELY" replaced with natural Japanese ("使用するシーン: / 積極的に使用するシーン: / 必ず積極的に使用するシーン:"); keyword pairs that aid routing preserved
-- **JA mirror: terminology unified** (commands, skills) — `step N` → ステップN; `cross-layer` → レイヤー横断; `Layer-Aware Agent Routing` → レイヤー別エージェントルーティング; `INVOKE` → 呼び出す; `consolidated fix task file` → 統合修正タスクファイル; `stub-detection` → 未完成実装検出
-- **Compression of six largest agent files** (agents) — task-executor.md 459 → 315; task-executor-frontend.md 428 → 303; quality-fixer.md 409 → 275; quality-fixer-frontend.md 453 → 316; technical-designer.md 471 → 429; technical-designer-frontend.md 471 → 409. All decision criteria, escalation_types, Fix Mode contract, Gate ordering, and JSON schemas preserved
+- **Japanese routing markers in agent frontmatter** (agents) — "Use when / Use PROACTIVELY / MUST BE USED PROACTIVELY" rendered as "使用するシーン: / 積極的に使用するシーン: / 必ず積極的に使用するシーン:" in JA agents; keyword pairs that aid routing preserved
+- **Japanese terminology in commands and skills** (commands, skills) — Standardized JA renderings: `step N` → ステップN; `cross-layer` → レイヤー横断; `Layer-Aware Agent Routing` → レイヤー別エージェントルーティング; `INVOKE` → 呼び出す; `consolidated fix task file` → 統合修正タスクファイル; `stub-detection` → 未完成実装検出
+- **Six largest agent files compressed** (agents) — task-executor / -frontend, quality-fixer / -frontend, technical-designer / -frontend reduced in length. All decision criteria, `escalation_type` enum, Fix Mode contract, Gate ordering, and JSON schemas preserved
 
 ### Fixed
 
-- **subagents-orchestration-guide: acceptance-test-generator I/O row information loss** (skills) — Restored fields lost in an earlier translation pass: `budgetUsage`, `integration: path|null` (was `string`), `e2eAbsenceReason` enum values (`no_multi_step_journey | below_threshold_user_confirmed`), and the "verify files exist" instruction
+- **subagents-orchestration-guide: acceptance-test-generator I/O row restored to full contract** (skills) — Row carries `budgetUsage`, `integration: path|null` (was `string`), `e2eAbsenceReason` enum values (`no_multi_step_journey | below_threshold_user_confirmed`), and the "verify files exist" instruction
 - **task-executor / -frontend: typo** (agents) — テスト嚗空化 → テスト空洞化 in Step 2 Quality Standard Violation Check
-- **JA mirror: stale references and English residue** (agents, commands, skills) — Task Registration old wording, "JSON format is mandatory" boilerplate, "Output Self-Check" sections, and "Final response is the JSON output" checklist items removed in favor of the new Output Protocol / Self-Validation [BLOCKING] structure. Awkward spacing around contract terms (`ルーティング先のexecutor`, `executorをFix Mode`, `task-template を用いて 統合`) corrected
+- **Japanese content cleanup** (agents, commands, skills) — Legacy "JSON format is mandatory" boilerplate, "Output Self-Check" sections, "Final response is the JSON output" checklist items, and prior Task Registration wording removed (superseded by the Output Protocol / Self-Validation [BLOCKING] structure also added this release). Spacing around inline contract terms (`ルーティング先のexecutor`, `executorをFix Mode`, `task-template を用いて 統合`) tightened
 
 ## [1.20.8] - 2026-04-17
 

package/README.ja.md

@@ -135,6 +135,7 @@ Claude Codeで利用できる主要なコマンド
 | `/task` | スキルに基づいた単一タスクの実行 | バグ修正、小規模な変更 |
 | `/design` | 設計書の作成 | アーキテクチャの計画時 |
 | `/plan` | 設計書から作業計画書を作成 | 設計承認後 |
+| `/prepare-implementation` | `/build` 実行可能な状態にする（readinessを検証しギャップを解消） | `/build`の前に計画が実装可能であることを担保したいとき |
 | `/build` | 既存の計画から実行 | 作業の再開時 |
 | `/review` | コードの準拠性確認 | 実装完了後 |
 | `/diagnose` | 問題診断ワークフロー | デバッグ、トラブルシューティング |
@@ -178,9 +179,9 @@ Claude Codeで利用できる主要なコマンド
 | `documentation-criteria` | PRD、ADR、Design Doc、UI Spec基準 |
 | `technical-spec` | アーキテクチャ、環境設定、ビルドコマンド |
 | `implementation-approach` | 戦略パターン、タスク分解 |
-| `integration-e2e-testing` | 統合/E2Eテスト設計、ROIベース選択、ジャーニー定義 |
+| `integration-e2e-testing` | 統合テストと二レーンE2E（fixture-e2e / service-integration-e2e）、ROIベース選択、ジャーニー定義 |
 | `frontend-typescript-rules` | Reactコンポーネント設計、Props駆動パターン |
-| `frontend-typescript-testing` | React Testing Library、MSW、Playwright E2E |
+| `frontend-typescript-testing` | React Testing Library、MSW、Playwright E2E（fixture / service-integrationパターン） |
 | `frontend-technical-spec` | Reactアーキテクチャ、環境設定、データフロー |
 | `project-context` | AIの実行精度のためのプロジェクト前提情報（`/project-inject`で設定） |
 

package/README.md

@@ -135,6 +135,7 @@ Essential commands for Claude Code:
 | `/task` | Single task with skill-based precision | Bug fixes, small changes |
 | `/design` | Create design docs only | Architecture planning |
 | `/plan` | Create work plan from design | After design approval |
+| `/prepare-implementation` | Get the plan ready for `/build` (verify readiness and resolve gaps) | Before `/build` to ensure the plan is implementable |
 | `/build` | Execute from existing plan | Resume work |
 | `/review` | Check code compliance | Post-implementation |
 | `/diagnose` | Problem diagnosis workflow | Debugging, troubleshooting |
@@ -178,9 +179,9 @@ This boilerplate provides the principles used in agentic implementation workflow
 | `documentation-criteria` | PRD, ADR, Design Doc, UI Spec standards |
 | `technical-spec` | Architecture, environment, build commands |
 | `implementation-approach` | Strategy patterns, task decomposition |
-| `integration-e2e-testing` | Integration/E2E test design, ROI-based selection, journey definition |
+| `integration-e2e-testing` | Integration tests and two-lane E2E (fixture-e2e / service-integration-e2e), ROI-based selection, journey definition |
 | `frontend-typescript-rules` | React component design, Props-driven patterns |
-| `frontend-typescript-testing` | React Testing Library, MSW, Playwright E2E |
+| `frontend-typescript-testing` | React Testing Library, MSW, Playwright E2E (fixture and service-integration patterns) |
 | `frontend-technical-spec` | React architecture, environment, data flow |
 | `project-context` | Project-specific prerequisites for AI accuracy (set via `/project-inject`) |
 

package/docs/guides/en/use-cases.md

@@ -77,9 +77,10 @@ Creates design documents, conducts LLM self-review, requests user review as need
 Execute Design → Plan → Build individually. You can work more incrementally by specifying phases directly in the command arguments.
 
 ```bash
-/design                    # Create design docs
-/plan                      # Create work plan
-/build implement phase 1   # Execute implementation (with phase specification)
+/design                          # Create design docs
+/plan                            # Create work plan
+/prepare-implementation          # (Optional) Bring the plan to implement-ready state
+/build implement phase 1         # Execute implementation (with phase specification)
 ```
 
 ## Want to resume work?
@@ -204,6 +205,20 @@ Use when not adopting the full design-to-implementation process via `/implement`
 Creates work plan from Design Doc. Also creates integration/E2E tests required for implementation.
 Use when not adopting the full design-to-implementation process via `/implement`.
 
+### /prepare-implementation
+**Purpose**: Bring the work plan to implement-ready state
+**Args**: [work plan path] (optional)
+**Prerequisite**: Approved work plan must exist
+**Process**:
+1. Load work plan and verify five readiness criteria (Verification Strategy references, E2E preconditions, Phase 1 observability, UI rendering surface, local lane procedure)
+2. Generate Phase 0 prep tasks for any failing criteria
+3. User confirmation gate before executing prep tasks
+4. Execute prep tasks via the standard 4-step cycle
+5. Re-scan and promote the work plan's `Implementation Readiness:` header to `ready` or `escalated`
+
+Brings the work plan to implement-ready state before `/build`. Resolves gaps via Phase 0 prep tasks (fixture entries, seed scripts, local startup docs, etc.) so the implementation is observable from the first phase, then promotes the readiness marker accordingly. Exits no-op when readiness already holds, so it is safe to invoke unconditionally.
+Use when not adopting the full design-to-implementation process via `/implement`, or when extra confidence in plan readiness is wanted before a long autonomous build run.
+
 ### /build
 **Purpose**: Automated implementation execution
 **Args**: [task file name] (optional)

package/docs/guides/ja/use-cases.md

@@ -77,9 +77,10 @@ LLMが規模を自動判定して、必要なドキュメントを作成して
 設計 → 計画 → 実装を個別に実行してください。コマンド引数でさらに詳細なフェーズを指定することで、より段階的な作業が可能になります。
 
 ```bash
-/design                    # 設計書作成
-/plan                      # 作業計画作成
-/build フェーズ1まで実装して  # 実装実行（フェーズ指定）
+/design                          # 設計書作成
+/plan                            # 作業計画作成
+/prepare-implementation          # （任意）作業計画書をimplement-readyにする
+/build フェーズ1まで実装して       # 実装実行（フェーズ指定）
 ```
 
 ## 途中から実装を再開したいときは？
@@ -194,6 +195,20 @@ Agentic Coding（LLMが自律的に判断し、実装タスクを遂行する）
 Design Docから作業計画書を作成します。また、実装に必要な結合/E2Eテストも同時に作成します。
 `/implement`による設計〜実装の一連のプロセスを採用しない場合に、活用してください。
 
+### /prepare-implementation
+**用途**: 作業計画書をimplement-ready状態に持っていく
+**引数**: [作業計画書のパス]（省略可）
+**前提**: 承認済みの作業計画書が存在すること
+**実行内容**:
+1. 作業計画書を読み込み、5つのreadiness基準（検証戦略の参照、E2E前提条件、Phase 1の観測性、UI描画面、ローカルレーン手順）を検証
+2. 失敗した基準に対するPhase 0 prepタスクを生成
+3. prepタスク実行前にユーザー確認
+4. 標準4ステップサイクルでprepタスクを実行
+5. 再スキャン後、作業計画書の `Implementation Readiness:` ヘッダを `ready` または `escalated` に昇格
+
+`/build` 起動前に作業計画書をimplement-ready状態へ持っていきます。Phase 0 prepタスク（fixtureエントリ、seedスクリプト、ローカル起動手順の文書化等）でギャップを解消することで実装を最初のフェーズから観測可能にし、その結果に応じてreadinessマーカーを昇格させます。readiness基準が既に満たされている場合はno-opで終了するため、無条件に呼び出しても安全です。
+`/implement`による設計〜実装の一連のプロセスを採用しない場合や、長時間の自律build前に計画readinessをより確実にしたい場合に活用してください。
+
 ### /build
 **用途**: 実装の自動実行
 **引数**: [タスクファイル名]（省略可）

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-ai-project",
-  "version": "1.20.9",
+  "version": "1.22.0",
   "packageManager": "npm@10.8.2",
   "description": "TypeScript boilerplate with skills and sub-agents for Claude Code. Prevents context exhaustion through role-based task splitting.",
   "keywords": [
@@ -51,6 +51,7 @@
     "check:fix": "biome check --write src",
     "check:unused": "knip --include exports",
     "check:deps": "dpdm --no-warning --no-tree --exit-code circular:1 --ext .ts --exclude \"__tests__|.test.ts$|.spec.ts$\" --tsconfig ./tsconfig.json -T \"src/**/*.ts\"",
+    "check:skills-index": "node scripts/check-skills-index.mjs",
     "check:code": "npm run check && npm run check:unused && npm run check:deps && npm run build",
     "check:all": "npm run check:code && npm run test",
     "cleanup:processes": "bash ./scripts/cleanup-test-processes.sh",

package/scripts/check-skills-index.mjs

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+import { readFile, access } from 'node:fs/promises'
+import { dirname, join, resolve } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const LANGUAGES = ['en', 'ja']
+
+function parseSkillsIndex(content) {
+  const skills = {}
+  const lines = content.split('\n')
+
+  let currentSkill = null
+  let inSections = false
+
+  for (const line of lines) {
+    const skillMatch = /^ {2}([\w-]+):\s*$/.exec(line)
+    if (skillMatch) {
+      currentSkill = skillMatch[1]
+      skills[currentSkill] = { sections: [] }
+      inSections = false
+      continue
+    }
+
+    if (!currentSkill) continue
+
+    if (/^ {4}sections:\s*$/.test(line)) {
+      inSections = true
+      continue
+    }
+
+    if (/^ {4}[\w-]+:/.test(line)) {
+      inSections = false
+      continue
+    }
+
+    if (inSections) {
+      const itemMatch = /^ {6}- "(.*)"\s*$/.exec(line)
+      if (itemMatch) {
+        skills[currentSkill].sections.push(itemMatch[1])
+      }
+    }
+  }
+
+  return skills
+}
+
+function extractH2Headings(markdown) {
+  return markdown
+    .split('\n')
+    .filter((line) => line.startsWith('## '))
+    .map((line) => line.replace(/^## /, '').trim())
+}
+
+function diffArrays(expected, actual) {
+  const max = Math.max(expected.length, actual.length)
+  const mismatches = []
+  for (let i = 0; i < max; i++) {
+    if (expected[i] !== actual[i]) {
+      mismatches.push({ index: i, expected: expected[i] ?? '<missing>', actual: actual[i] ?? '<missing>' })
+    }
+  }
+  return mismatches
+}
+
+async function exists(path) {
+  try {
+    await access(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function checkLanguage(lang) {
+  const skillsDir = join(ROOT, '.claude', `skills-${lang}`)
+  const indexPath = join(skillsDir, 'task-analyzer', 'references', 'skills-index.yaml')
+
+  if (!(await exists(indexPath))) {
+    return { lang, skipped: true, reason: `no skills-index.yaml at ${indexPath}`, failed: 0, total: 0, reports: [] }
+  }
+
+  const indexContent = await readFile(indexPath, 'utf8')
+  const skills = parseSkillsIndex(indexContent)
+  const skillNames = Object.keys(skills)
+
+  if (skillNames.length === 0) {
+    return {
+      lang,
+      skipped: false,
+      failed: 1,
+      total: 0,
+      reports: [`[${lang}] check-skills-index: no skill entries parsed from skills-index.yaml — parser may be broken`],
+    }
+  }
+
+  const reports = []
+  let failed = 0
+
+  for (const name of skillNames) {
+    const skillMdPath = join(skillsDir, name, 'SKILL.md')
+    let markdown
+    try {
+      markdown = await readFile(skillMdPath, 'utf8')
+    } catch {
+      reports.push(`[${lang}] ✗ ${name}: SKILL.md not found at ${skillMdPath} (yaml entry references a non-existent skill)`)
+      failed++
+      continue
+    }
+
+    const expected = skills[name].sections
+    const actual = extractH2Headings(markdown)
+
+    if (expected.length === 0) {
+      reports.push(`[${lang}] - ${name}: dynamic content (no static sections to validate)`)
+      continue
+    }
+
+    const mismatches = diffArrays(expected, actual)
+    if (mismatches.length === 0) {
+      reports.push(`[${lang}] ✓ ${name}: ${expected.length} sections match`)
+    } else {
+      reports.push(`[${lang}] ✗ ${name}: ${mismatches.length} mismatch(es)`)
+      for (const m of mismatches) {
+        reports.push(`         [${m.index}] yaml: "${m.expected}"`)
+        reports.push(`             md:   "${m.actual}"`)
+      }
+      failed++
+    }
+  }
+
+  return { lang, skipped: false, failed, total: skillNames.length, reports }
+}
+
+async function main() {
+  let totalFailed = 0
+  let totalChecked = 0
+  const allReports = []
+
+  for (const lang of LANGUAGES) {
+    const result = await checkLanguage(lang)
+    if (result.skipped) {
+      allReports.push(`[${lang}] skipped: ${result.reason}`)
+      continue
+    }
+    allReports.push(...result.reports)
+    totalFailed += result.failed
+    totalChecked += result.total
+  }
+
+  for (const line of allReports) {
+    console.log(line)
+  }
+
+  if (totalChecked === 0) {
+    console.error('\ncheck-skills-index: no skills checked across any language')
+    process.exit(1)
+  }
+
+  if (totalFailed > 0) {
+    console.error(`\ncheck-skills-index: ${totalFailed} skill(s) failed`)
+    console.error('Either update .claude/skills-<lang>/task-analyzer/references/skills-index.yaml to match the SKILL.md headings,')
+    console.error('or update the SKILL.md headings to match the yaml. Order matters.')
+    process.exit(1)
+  }
+
+  console.log(`\ncheck-skills-index: all ${totalChecked} skill(s) consistent across ${LANGUAGES.join(', ')}`)
+}
+
+main().catch((err) => {
+  console.error(err)
+  process.exit(1)
+})