sdtk-kit 0.3.2 → 0.3.4

package/assets/toolkit/toolkit/scripts/install-codex-skills.ps1

@@ -1,7 +1,15 @@
 param(
+  [ValidateSet('project', 'user')]
+  [string]$Scope = 'user',
   [switch]$Force
 )
 
+# Gate C0: Codex does not support project-local skills
+if ($Scope -eq 'project') {
+  Write-Error "Codex does not support project-local skills. Use --scope user instead."
+  exit 1
+}
+
 $ErrorActionPreference = 'Stop'
 Set-StrictMode -Version Latest
 

package/assets/toolkit/toolkit/scripts/uninstall-claude-skills.ps1

@@ -0,0 +1,139 @@
+param(
+  [string]$ProjectPath,
+  [ValidateSet('project', 'user')]
+  [string]$Scope = 'project',
+  [string]$SkillName,
+  [switch]$All,
+  [switch]$BackupExisting,
+  [string]$BackupPath
+)
+
+$ErrorActionPreference = 'Stop'
+Set-StrictMode -Version Latest
+
+function Backup-Directory {
+  param(
+    [Parameter(Mandatory = $true)][string]$SourcePath,
+    [Parameter(Mandatory = $true)][string]$BackupRoot,
+    [Parameter(Mandatory = $true)][string]$Name
+  )
+
+  if (-not (Test-Path -LiteralPath $SourcePath)) {
+    return $null
+  }
+
+  New-Item -ItemType Directory -Force -Path $BackupRoot | Out-Null
+  $dest = Join-Path $BackupRoot $Name
+  if (Test-Path -LiteralPath $dest) {
+    Remove-Item -LiteralPath $dest -Recurse -Force
+  }
+  Copy-Item -LiteralPath $SourcePath -Destination $dest -Recurse -Force
+  return $dest
+}
+
+if ($All -and $SkillName) {
+  throw "Use either -All or -SkillName, not both."
+}
+
+$toolkitRoot = Resolve-Path (Join-Path $PSScriptRoot '..')
+$skillsSrc = Join-Path $toolkitRoot 'skills-claude'
+if (-not (Test-Path -LiteralPath $skillsSrc)) {
+  throw "Missing toolkit Claude skills source directory: $skillsSrc"
+}
+
+$managedSkillNames = Get-ChildItem -LiteralPath $skillsSrc -Directory | Select-Object -ExpandProperty Name
+if (-not $managedSkillNames -or $managedSkillNames.Count -eq 0) {
+  throw "No managed Claude skills found in: $skillsSrc"
+}
+
+$targetNames = @()
+if ($SkillName) {
+  if ($managedSkillNames -notcontains $SkillName) {
+    throw "Skill '$SkillName' is not in managed Claude skills list. Known skills: $($managedSkillNames -join ', ')"
+  }
+  $targetNames = @($SkillName)
+} elseif ($All) {
+  $targetNames = @($managedSkillNames)
+} else {
+  $targetNames = @($managedSkillNames)
+}
+
+# Resolve destination based on scope
+if ($Scope -eq 'user') {
+  $skillsDest = Join-Path $HOME '.claude/skills'
+} else {
+  if (-not $ProjectPath) {
+    $ProjectPath = (Resolve-Path (Join-Path $toolkitRoot '..')).Path
+  }
+  $projectRoot = Resolve-Path -LiteralPath $ProjectPath
+  $skillsDest = Join-Path $projectRoot '.claude/skills'
+}
+
+if (-not (Test-Path -LiteralPath $skillsDest)) {
+  Write-Host "Claude skills directory not found: $skillsDest"
+  exit 0
+}
+
+$backupRootResolved = $null
+if ($BackupExisting) {
+  if (-not $BackupPath -or $BackupPath.Trim().Length -eq 0) {
+    $timestamp = Get-Date -Format 'yyyyMMdd-HHmmss'
+    $parentDir = if ($Scope -eq 'user') { Join-Path $HOME '.claude' } else { $projectRoot }
+    $BackupPath = Join-Path $parentDir (Join-Path 'skills-backups' ("uninstall-" + $timestamp))
+  }
+  New-Item -ItemType Directory -Force -Path $BackupPath | Out-Null
+  $backupRootResolved = (Resolve-Path -LiteralPath $BackupPath).Path
+  Write-Host "Backup mode enabled: $backupRootResolved"
+}
+
+$removed = New-Object System.Collections.Generic.List[string]
+$missing = New-Object System.Collections.Generic.List[string]
+
+foreach ($name in $targetNames) {
+  $dest = Join-Path $skillsDest $name
+  if (-not (Test-Path -LiteralPath $dest)) {
+    $missing.Add($name) | Out-Null
+    Write-Warning "Skill not installed, skipping: $name"
+    continue
+  }
+
+  if ($BackupExisting) {
+    $backupDest = Backup-Directory -SourcePath $dest -BackupRoot $backupRootResolved -Name $name
+    if ($backupDest) {
+      Write-Host "Backed up: $name -> $backupDest"
+    }
+  }
+
+  Remove-Item -LiteralPath $dest -Recurse -Force
+  $removed.Add($name) | Out-Null
+  Write-Host "Uninstalled: $name"
+}
+
+# Also remove references directory if uninstalling all
+if ($All -or (-not $SkillName)) {
+  $refDir = Join-Path $skillsDest 'references'
+  if (Test-Path -LiteralPath $refDir) {
+    if ($BackupExisting) {
+      Backup-Directory -SourcePath $refDir -BackupRoot $backupRootResolved -Name 'references' | Out-Null
+      Write-Host "Backed up: references -> $backupRootResolved/references"
+    }
+    Remove-Item -LiteralPath $refDir -Recurse -Force
+    Write-Host "Removed references directory."
+  }
+}
+
+Write-Host ""
+Write-Host "Uninstall summary:"
+Write-Host "- Scope: $Scope"
+Write-Host "- Destination: $skillsDest"
+Write-Host "- Removed: $($removed.Count)"
+if ($removed.Count -gt 0) {
+  $removed | ForEach-Object { Write-Host "  - $_" }
+}
+Write-Host "- Missing/Skipped: $($missing.Count)"
+if ($missing.Count -gt 0) {
+  $missing | ForEach-Object { Write-Host "  - $_" }
+}
+if ($backupRootResolved) {
+  Write-Host "- Backup directory: $backupRootResolved"
+}

package/assets/toolkit/toolkit/skills-claude/api-design-spec/SKILL.md

@@ -0,0 +1,76 @@
+---
+name: api-design-spec
+description: Generate detailed API design markdown from OpenAPI YAML and API flow list using Excel-style structure rules. Use when you need field-level request/response tables + per-endpoint process flow images for implementation/review handoff.
+---
+
+## Required Inputs (read before proceeding)
+Read the following artifacts for the current feature:
+1. `docs/api/[FeaturePascal]_API.yaml` — API contract
+2. `docs/api/[feature_snake]_api_flow_list.txt` — flow list
+
+## Input
+$ARGUMENTS
+
+# SDTK API Design Detail Spec
+
+## Outputs
+- `docs/api/[FEATURE_KEY]_API_DESIGN_DETAIL.md`
+- Supporting generated assets:
+  - `docs/api/flows/*.puml`
+  - `docs/api/images/*.svg`
+
+## Required Inputs
+- Feature key (`FEATURE_KEY`)
+- API contract YAML:
+  - Preferred: `docs/api/[FeaturePascal]_API.yaml`
+  - Fallback: a specified YAML file path
+- API flow list:
+  - Preferred: `docs/api/[feature_snake]_api_flow_list.txt`
+  - Fallback: a specified flow list path
+
+## Core Rules
+- Apply `.claude/skills/references/API_DESIGN_FLOWCHART_CREATION_RULES.md` first.
+- Keep endpoint contracts consistent with source YAML.
+- Keep process flow source synchronized with flow list (`*_api_flow_list.txt`).
+- Keep one visible flowchart per API section (embed image), avoid duplicate preview rendering.
+- Keep `Process Flow` sections implementation-readable:
+  - include YAML-derived flow summary / notes / login bullets
+  - keep error sections aligned with actual flow exits, not `None`
+
+## Generation Procedure
+1. Resolve input files (`yaml`, `flow_list`, `output`).
+2. Parse YAML endpoints (method, path, request schema, success/error schema).
+3. Parse flow blocks from flow list (`@startuml ... @enduml`) and map by `METHOD + path`.
+4. Generate detailed markdown sections per API:
+   - Flow summary / notes / login bullets from YAML `description`
+   - Process flow source block (`text` fenced block)
+   - Embedded flowchart image
+   - Path parameter table
+   - Request table (hierarchy levels + type + format + required)
+   - Success response table
+   - Error response table (explicit schema if defined, otherwise shared envelope + inferred business statuses from flow)
+5. Generate/update `.puml` per API under `docs/api/flows`.
+6. Render `.svg` images under `docs/api/images`.
+7. Validate:
+   - every API section has one embedded image
+   - every embed path exists
+   - no render error image output
+   - markdown tables keep `No` sequential numbering
+
+## Script
+- `scripts/generate_api_design_detail.py`
+
+### Typical command
+```bash
+python scripts/generate_api_design_detail.py \
+  --feature-key SCHEDULE_WHITEBOARD \
+  --yaml "docs/api/ScheduleWhiteboard_API.yaml" \
+  --flow-list "docs/api/schedule_whiteboard_api_flow_list.txt" \
+  --output "docs/api/SCHEDULE_WHITEBOARD_API_DESIGN_DETAIL.md"
+```
+
+## Orchestrator Integration (Hybrid)
+- `apiDesignDetailMode` in `sdtk.config.json` controls orchestration behavior:
+  - `auto` (default): generate API design detail when ARCH has API scope and YAML/flow sources are available.
+  - `on`: always generate API design detail for API scope (fail if required sources are missing).
+  - `off`: skip unless user explicitly requests.

package/assets/toolkit/toolkit/skills-claude/api-doc/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: api-doc
+description: Generate OpenAPI 3.x YAML and PlantUML flow diagrams for a feature following this toolkit's API conventions. Use when you need to create/update docs/api/* (API spec + flow list) from BA_SPEC/ARCH_DESIGN.
+---
+
+## Required Inputs (read before proceeding)
+Read the following artifacts for the current feature:
+1. `docs/specs/BA_SPEC_*.md` — business rules, use cases
+2. `docs/architecture/ARCH_DESIGN_*.md` — system components, data model
+
+## Input
+$ARGUMENTS
+
+# SDTK API Documentation
+
+## Outputs
+- `docs/api/[FeaturePascal]_API.yaml`
+- `docs/api/[FEATURE_KEY]_ENDPOINTS.md`
+- `docs/api/[feature_snake]_api_flow_list.txt`
+- Optional downstream (via `/api-design-spec`):
+  - `docs/api/[FEATURE_KEY]_API_DESIGN_DETAIL.md`
+
+## Inputs (minimum)
+- Feature name/key
+- Entities + key fields
+- Use cases (UC-xx) + business rules (BR-xx)
+- Auth/permission model
+
+## Process
+1. Read `docs/specs/BA_SPEC_[FEATURE_KEY].md` and/or `docs/architecture/ARCH_DESIGN_[FEATURE_KEY].md`.
+2. Read and apply split API rule sources:
+   - `.claude/skills/references/YAML_CREATION_RULES.md` for YAML contract rules
+   - `.claude/skills/references/API_DESIGN_FLOWCHART_CREATION_RULES.md` for flow list / flowchart rules
+3. Define endpoints mapped to UC-xx; keep path naming consistent across CRUD/search/list/mst patterns.
+4. For each endpoint, document request/response schema and error cases.
+5. Generate/update endpoint markdown (`[FEATURE_KEY]_ENDPOINTS.md`) with summary tables, API type grouping, and screen-logic mapping.
+6. Generate PlantUML flows including: auth, permission check, validation, main logic, error exits.
+7. Ensure traceability notes reference UC/BR where relevant.
+8. Validate English output hygiene when generating English artifacts:
+   - no mixed-language leftovers in narrative text
+   - no mojibake/encoding corruption markers
+   - terminology consistency across endpoint detail, summary tables, and flow labels
+9. If orchestrator mode requires API design detail generation (`apiDesignDetailMode=auto/on`), handoff to `/api-design-spec` after YAML + flow list are updated.
+
+## Reference
+- Deeper analysis: `docs/specs/API_DOC_SKILL_ANALYSIS.md` (if present).

package/assets/toolkit/toolkit/skills-claude/arch/SKILL.md

@@ -0,0 +1,70 @@
+---
+name: arch
+description: Solution Architect workflow for SDTK. Use when you need to convert BA_SPEC + PM backlog into technical architecture, API contracts (OpenAPI), and UI layout docs; update SHARED_PLANNING.md / QUALITY_CHECKLIST.md and handoff to DEV.
+---
+
+## SDTK Pipeline Rules (always apply)
+1. Pipeline: PM Initiation → BA Analysis → PM Planning → Architecture Design → Development + Review → QA Validation
+2. After completing phase work: update SHARED_PLANNING.md + QUALITY_CHECKLIST.md
+3. If unclear: log OQ-xx in artifact, escalate to PM (PM asks user if needed)
+4. Traceability: REQ → BR/UC/AC → design → backlog → code/tests → QA
+5. Code review must be COMPLETE before QA phase can start
+6. Do not skip phases. If inputs missing, ask focused questions.
+
+## Prerequisites (verify before proceeding)
+Read QUALITY_CHECKLIST.md and verify:
+- Phase 2 BA Analysis gate must show all items [x] Done.
+- Phase 2+ PM Planning gate must show all items [x] Done.
+
+If prerequisites NOT met: report which gate is missing, suggest user run the prerequisite phase first.
+
+## Current Context
+- Config: !`node -e "try{process.stdout.write(require('fs').readFileSync('sdtk.config.json','utf8'))}catch{process.stdout.write('{}')}"`
+- Pipeline: !`node -e "try{process.stdout.write(require('fs').readFileSync('SHARED_PLANNING.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- Gates: !`node -e "try{process.stdout.write(require('fs').readFileSync('QUALITY_CHECKLIST.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- State: !`node -e "try{process.stdout.write(require('fs').readFileSync('.sdtk/orchestration-state.json','utf8'))}catch{process.stdout.write('{}')}"`
+
+## Input
+$ARGUMENTS
+
+If no arguments provided, read current feature context from SHARED_PLANNING.md.
+
+# SDTK ARCH (Solution Architecture)
+
+## Outputs
+- `docs/architecture/ARCH_DESIGN_[FEATURE_KEY].md`
+- If applicable:
+  - `docs/api/[FeaturePascal]_API.yaml`
+  - `docs/api/[FEATURE_KEY]_ENDPOINTS.md`
+  - `docs/api/[FEATURE_KEY]_API_DESIGN_DETAIL.md`
+  - `docs/api/[feature_snake]_api_flow_list.txt`
+  - `docs/database/DATABASE_SPEC_[FEATURE_KEY].md`
+  - `docs/design/DESIGN_LAYOUT_[FEATURE_KEY].md`
+  - `docs/specs/[FEATURE_KEY]_FLOW_ACTION_SPEC.md`
+
+## Process
+1. Read BA spec + PRD/backlog.
+2. Read `sdtk.config.json` for project stack assumptions (backend/frontend/db/auth).
+3. If architecture output includes API contracts/flows, read and apply the split API rule sources before defining endpoints/flows:
+   - `.claude/skills/references/YAML_CREATION_RULES.md`
+   - `.claude/skills/references/API_DESIGN_FLOWCHART_CREATION_RULES.md`
+4. If architecture output includes screen flow-action specs, read and apply rules from `.claude/skills/references/FLOW_ACTION_SPEC_CREATION_RULES.md` (global numbering policy).
+5. If API detail spec is required, use skill `/api-design-spec` to build/update `docs/api/[FEATURE_KEY]_API_DESIGN_DETAIL.md` using YAML + flow list.
+6. For complex UI flow-action specs, use skill `/screen-design-spec` to build/update `docs/specs/[FEATURE_KEY]_FLOW_ACTION_SPEC.md`.
+7. Define:
+   - System components + data model
+   - API endpoints and flows (if backend changes)
+   - Screen layouts (if UI changes)
+   - Security/authz decisions
+8. Create/update:
+   - OpenAPI YAML + API endpoint markdown
+   - API flow list
+   - API design detail spec (when `orchestration.apiDesignDetailMode` is `auto/on`)
+   - Database spec (if DB impact exists)
+   - Flow-action spec and design layout (if UI impact exists)
+9. Ensure mapping UC/BR -> DB/API/screens and run output hygiene checks:
+   - EN artifacts use English narrative text (except clearly marked original-language appendix blocks).
+   - No mojibake/encoding corruption in markdown/yaml/txt outputs.
+10. If anything is unclear: record OQ-xx in ARCH_DESIGN "Open Questions" and escalate to PM (suggest user run `/pm` for a decision if still missing info).
+11. Update shared state + Phase 3 checklist.
+12. Handoff: suggest user run `/dev` to implement the design.

package/assets/toolkit/toolkit/skills-claude/ba/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: ba
+description: Business Analyst workflow for SDTK. Use when you need to turn PM initiation into BA_SPEC with glossary, business rules (BR-xx), use cases (UC-xx), acceptance criteria (AC-xx), NFRs, risks, open questions, and a traceability matrix.
+---
+
+## SDTK Pipeline Rules (always apply)
+1. Pipeline: PM Initiation → BA Analysis → PM Planning → Architecture Design → Development + Review → QA Validation
+2. After completing phase work: update SHARED_PLANNING.md + QUALITY_CHECKLIST.md
+3. If unclear: log OQ-xx in artifact, escalate to PM (PM asks user if needed)
+4. Traceability: REQ → BR/UC/AC → design → backlog → code/tests → QA
+5. Code review must be COMPLETE before QA phase can start
+6. Do not skip phases. If inputs missing, ask focused questions.
+
+## Prerequisites (verify before proceeding)
+Read QUALITY_CHECKLIST.md and verify:
+- Phase 1 PM Init gate must show all items [x] Done.
+
+If prerequisites NOT met: report which gate is missing, suggest user run `/pm` first.
+
+## Current Context
+- Config: !`node -e "try{process.stdout.write(require('fs').readFileSync('sdtk.config.json','utf8'))}catch{process.stdout.write('{}')}"`
+- Pipeline: !`node -e "try{process.stdout.write(require('fs').readFileSync('SHARED_PLANNING.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- Gates: !`node -e "try{process.stdout.write(require('fs').readFileSync('QUALITY_CHECKLIST.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- State: !`node -e "try{process.stdout.write(require('fs').readFileSync('.sdtk/orchestration-state.json','utf8'))}catch{process.stdout.write('{}')}"`
+
+## Input
+$ARGUMENTS
+
+If no arguments provided, read current feature context from SHARED_PLANNING.md.
+
+# SDTK BA (Business Analysis)
+
+## Output
+- `docs/specs/BA_SPEC_[FEATURE_KEY].md`
+
+## Process
+1. Read `docs/product/PROJECT_INITIATION_[FEATURE_KEY].md` (and any source requirements).
+2. Produce:
+   - Glossary
+   - BR-xx (numbered)
+   - UC-xx (cover 100% REQ-xx)
+   - AC-xx (mapped to UC/BR)
+   - NFR-xx
+   - Risks + Open Questions
+   - Traceability summary table (REQ → UC/BR/AC)
+3. If source requirements are VI/JP: preserve the original text and add a literal EN translation in appendices.
+4. If anything is unclear: record OQ-xx in BA_SPEC "Open Questions" and escalate to PM (suggest user run `/pm` for a decision if still missing info).
+5. Update `SHARED_PLANNING.md` + `QUALITY_CHECKLIST.md` Phase 2.
+6. Handoff: suggest user run `/pm` to proceed with PRD planning.

package/assets/toolkit/toolkit/skills-claude/design-layout/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: design-layout
+description: Generate UI screen layout documentation for a feature, including PlantUML @startsalt wireframes and item tables. Use when a feature includes frontend/admin screens and you need docs/design/* deliverables.
+---
+
+## Required Inputs (read before proceeding)
+Read the following artifacts for the current feature:
+1. `docs/specs/BA_SPEC_*.md` — screens + fields
+2. `docs/api/[FEATURE_KEY]_ENDPOINTS.md` — API list
+
+## Input
+$ARGUMENTS
+
+# SDTK Screen Layout Design
+
+## Output
+- `docs/design/DESIGN_LAYOUT_[FEATURE_KEY].md`
+
+## Process
+1. Read BA spec (screens + fields) and API list.
+2. For each screen, include:
+   - PlantUML `@startsalt` wireframe first
+   - API list table
+   - Item table with numbering that matches the wireframe
+3. Keep screen IDs consistent (A-*, B-*, C-*).

package/assets/toolkit/toolkit/skills-claude/dev/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: dev
+description: Developer workflow for SDTK. Use when you need to implement a feature from ARCH_DESIGN + BACKLOG: create an implementation plan, write code + tests, complete mandatory code review gate, and prepare a QA handoff.
+---
+
+## SDTK Pipeline Rules (always apply)
+1. Pipeline: PM Initiation → BA Analysis → PM Planning → Architecture Design → Development + Review → QA Validation
+2. After completing phase work: update SHARED_PLANNING.md + QUALITY_CHECKLIST.md
+3. If unclear: log OQ-xx in artifact, escalate to PM (PM asks user if needed)
+4. Traceability: REQ → BR/UC/AC → design → backlog → code/tests → QA
+5. Code review must be COMPLETE before QA phase can start
+6. Do not skip phases. If inputs missing, ask focused questions.
+
+## Prerequisites (verify before proceeding)
+Read QUALITY_CHECKLIST.md and verify:
+- Phase 3 ARCH Design gate must show all items [x] Done.
+
+If prerequisites NOT met: report which gate is missing, suggest user run `/arch` first.
+
+## Current Context
+- Config: !`node -e "try{process.stdout.write(require('fs').readFileSync('sdtk.config.json','utf8'))}catch{process.stdout.write('{}')}"`
+- Pipeline: !`node -e "try{process.stdout.write(require('fs').readFileSync('SHARED_PLANNING.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- Gates: !`node -e "try{process.stdout.write(require('fs').readFileSync('QUALITY_CHECKLIST.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- State: !`node -e "try{process.stdout.write(require('fs').readFileSync('.sdtk/orchestration-state.json','utf8'))}catch{process.stdout.write('{}')}"`
+
+## Input
+$ARGUMENTS
+
+If no arguments provided, read current feature context from SHARED_PLANNING.md.
+
+# SDTK DEV (Implementation + Code Review)
+
+## Outputs
+- `docs/dev/FEATURE_IMPL_PLAN_[FEATURE_KEY].md`
+- Code + tests (follow repo conventions)
+
+## Process
+1. Read `ARCH_DESIGN_*` + backlog.
+2. Read `sdtk.config.json` for project stack + test/lint commands.
+3. Write `FEATURE_IMPL_PLAN_*` (scope, file list, test plan).
+4. If anything is unclear: record OQ-xx in FEATURE_IMPL_PLAN "Open Questions" and escalate to PM (suggest user run `/pm` for a decision if still missing info).
+5. Implement incrementally with tests.
+6. Complete mandatory code review gate (self + peer checklist; AI peer review allowed).
+7. Update `SHARED_PLANNING.md` + `QUALITY_CHECKLIST.md` Phase 4.
+8. Handoff: suggest user run `/qa` to test (only after code review PASS).

package/assets/toolkit/toolkit/skills-claude/dev-backend/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: dev-backend
+description: Generate/modify Python Django REST Framework backend code following the toolkit conventions (models/views/services/serializers/validation/urls/enums). Use when implementing backend features in that project style.
+---
+
+## Input
+$ARGUMENTS
+
+# SDTK Backend (Toolkit conventions)
+
+## Process
+1. Check whether this repository already has a backend reference module and follow its patterns.
+2. Follow module structure: `src/backend/<module>/{models,view,service,serializers,validation,enum,urls.py}`.
+3. Apply conventions:
+   - Soft delete via `del_flg`
+   - Audit fields (creator/updater/del timestamps)
+   - Permission checks before operations
+   - `transaction.atomic()` for writes
+   - Logging decorator on public endpoints
+4. Add tests for critical business rules and state transitions.

package/assets/toolkit/toolkit/skills-claude/dev-frontend/SKILL.md

@@ -0,0 +1,18 @@
+---
+name: dev-frontend
+description: Generate/modify React frontend code following the toolkit conventions (list/register/edit/detail pages, components, services, React Query hooks, permission checks). Use when implementing frontend features in that project style.
+---
+
+## Input
+$ARGUMENTS
+
+# SDTK Frontend (Toolkit conventions)
+
+## Process
+1. Check whether this repository already has a frontend reference module and follow its patterns.
+2. Follow structure:
+   - `src/frontend/features/{feature}/...`
+   - `src/frontend/services/{feature}/{feature}Service.js`
+   - `src/frontend/services/apiHook/{feature}.js`
+3. Implement screens based on `docs/design/DESIGN_LAYOUT_[FEATURE_KEY].md`.
+4. Preserve patterns: React Query hooks, loading states, permission checks, consistent labels.

package/assets/toolkit/toolkit/skills-claude/orchestrator/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: orchestrator
+description: Orchestrate a full 6-phase SDLC multi-agent workflow (PM/BA/ARCH/DEV/QA) using this repo's conventions: SHARED_PLANNING.md + QUALITY_CHECKLIST.md + docs/* artifacts + phase handoffs.
+---
+
+## SDTK Pipeline Rules (always apply)
+1. Pipeline: PM Initiation → BA Analysis → PM Planning → Architecture Design → Development + Review → QA Validation
+2. After completing phase work: update SHARED_PLANNING.md + QUALITY_CHECKLIST.md
+3. If unclear: log OQ-xx in artifact, escalate to PM (PM asks user if needed)
+4. Traceability: REQ → BR/UC/AC → design → backlog → code/tests → QA
+5. Code review must be COMPLETE before QA phase can start
+6. Do not skip phases. If inputs missing, ask focused questions.
+
+## Current Context
+- Config: !`node -e "try{process.stdout.write(require('fs').readFileSync('sdtk.config.json','utf8'))}catch{process.stdout.write('{}')}"`
+- Pipeline: !`node -e "try{process.stdout.write(require('fs').readFileSync('SHARED_PLANNING.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- Gates: !`node -e "try{process.stdout.write(require('fs').readFileSync('QUALITY_CHECKLIST.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- State: !`node -e "try{process.stdout.write(require('fs').readFileSync('.sdtk/orchestration-state.json','utf8'))}catch{process.stdout.write('{}')}"`
+
+## Input
+$ARGUMENTS
+
+If no arguments provided, read current feature context from SHARED_PLANNING.md.
+
+# SDTK Orchestrator (multi-agent workflow)
+
+## Initialize
+- Ensure feature key + feature name exist (ask if missing).
+- Read `sdtk.config.json` (project stack + commands) if present.
+- Run `sdtk generate --feature-key <KEY> --feature-name "<NAME>"` to create skeleton artifacts.
+
+## Execute pipeline (one phase per turn)
+- Default role: PM (entry point) if user did not specify.
+- Respect role tags: `/pm`, `/ba`, `/arch`, `/dev`, `/qa`.
+- For each phase:
+  - Create/update the phase artifact(s) in `docs/`.
+  - If phase is ARCH and API contract/flow is in scope, invoke `/api-doc` to produce/update `docs/api/[FeaturePascal]_API.yaml`, `docs/api/[FEATURE_KEY]_ENDPOINTS.md`, and `docs/api/[feature_snake]_api_flow_list.txt`.
+  - If phase is ARCH and API detail spec is in scope, invoke `/api-design-spec` to produce/update `docs/api/[FEATURE_KEY]_API_DESIGN_DETAIL.md`.
+  - If phase is ARCH and UI flow behavior is in scope, invoke `/screen-design-spec` to produce/update `docs/specs/[FEATURE_KEY]_FLOW_ACTION_SPEC.md`.
+  - If phase is QA and test-case specification is in scope, invoke `/test-case-spec` to produce/update `docs/qa/[FEATURE_KEY]_TEST_CASE.md`.
+  - Update `SHARED_PLANNING.md` (phase row + activity log).
+  - Update `QUALITY_CHECKLIST.md` (mark items PASS/Pending).
+  - Produce one clear handoff message to the next role.
+
+## API design detail mode (Hybrid)
+- Read `sdtk.config.json` key: `orchestration.apiDesignDetailMode`.
+- Supported values:
+  - `auto` (default): run `/api-design-spec` when ARCH has API scope and YAML + flow list are available.
+  - `on`: always run `/api-design-spec` for API scope (fail fast if required inputs are missing).
+  - `off`: skip API design detail generation unless user explicitly requests it.
+
+## Test-case spec mode (Hybrid)
+- Read `sdtk.config.json` key: `orchestration.testCaseSpecMode`.
+- Supported values:
+  - `auto` (default): run `/test-case-spec` when QA phase requires reusable test-case artifact.
+  - `on`: always run `/test-case-spec` for QA phase (fail fast if required inputs are missing).
+  - `off`: skip test-case spec generation unless user explicitly requests it.
+
+## Guardrails
+- Do not skip phases; if prerequisites are missing, ask focused questions.
+- Keep traceability: REQ -> BR/UC/AC -> design -> backlog -> code/tests -> QA report.
+- Require code review completion before QA handoff.
+- If input requirements are VI/JP: preserve original text + add EN translation in appendix for traceability (at least in Project Initiation and BA spec).

package/assets/toolkit/toolkit/skills-claude/pm/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: pm
+description: Product Manager + meta-orchestrator workflow for SDTK. Use when you need to start a new feature (Phase 1) or produce PM planning artifacts (PRD + BACKLOG) and update SHARED_PLANNING.md / QUALITY_CHECKLIST.md with correct phase handoffs.
+---
+
+## SDTK Pipeline Rules (always apply)
+1. Pipeline: PM Initiation → BA Analysis → PM Planning → Architecture Design → Development + Review → QA Validation
+2. After completing phase work: update SHARED_PLANNING.md + QUALITY_CHECKLIST.md
+3. If unclear: log OQ-xx in artifact, escalate to PM (PM asks user if needed)
+4. Traceability: REQ → BR/UC/AC → design → backlog → code/tests → QA
+5. Code review must be COMPLETE before QA phase can start
+6. Do not skip phases. If inputs missing, ask focused questions.
+
+## Prerequisites (verify before proceeding)
+Read QUALITY_CHECKLIST.md and verify:
+- Phase 1 (PM Init): No prerequisites required.
+- Phase 2+ (PM Planning): BA Analysis gate must show all items [x] Done.
+
+If prerequisites NOT met: report which gate is missing, suggest user run the prerequisite phase first.
+
+## Current Context
+- Config: !`node -e "try{process.stdout.write(require('fs').readFileSync('sdtk.config.json','utf8'))}catch{process.stdout.write('{}')}"`
+- Pipeline: !`node -e "try{process.stdout.write(require('fs').readFileSync('SHARED_PLANNING.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- Gates: !`node -e "try{process.stdout.write(require('fs').readFileSync('QUALITY_CHECKLIST.md','utf8'))}catch{process.stdout.write('Not initialized')}"`
+- State: !`node -e "try{process.stdout.write(require('fs').readFileSync('.sdtk/orchestration-state.json','utf8'))}catch{process.stdout.write('{}')}"`
+
+## Input
+$ARGUMENTS
+
+If no arguments provided, read current feature context from SHARED_PLANNING.md.
+
+# SDTK PM (Entry Point + Planning)
+
+## Outputs
+- Phase 1: `docs/product/PROJECT_INITIATION_[FEATURE_KEY].md`
+- Phase 2+ (after BA spec): `docs/product/PRD_[FEATURE_KEY].md` + `docs/product/BACKLOG_[FEATURE_KEY].md`
+
+## Process
+1. Confirm `FEATURE_KEY` + `FEATURE_NAME` + Phase-1 scope in/out.
+2. Create/update PM artifact(s).
+3. Ensure REQ-xx list is clear and testable.
+4. If requirements are provided in VI/JP: keep the original text in an appendix and add an EN translation (literal) for traceability.
+5. Update `SHARED_PLANNING.md` + `QUALITY_CHECKLIST.md`.
+6. Handoff:
+   - After Project Initiation -> suggest user run `/ba` to analyze requirements
+   - After PRD/Backlog -> suggest user run `/arch` to design architecture
+
+## Clarification And Decisions (PM responsibility)
+- Collect OQ-xx items raised by BA/ARCH/DEV/QA in their respective artifacts.
+- Try to resolve OQ-xx using existing docs and reasonable product/tech decisions.
+- If still missing information from the original input: ask the user (final stakeholder) and record the answer as the resolution.
+- Record decisions in PRD `Decision Log` and update OQ-xx `Resolution` fields in the originating docs.