jettypod 4.4.45 → 4.4.47

package/lib/database.js

@@ -203,6 +203,39 @@ function initSchema() {
         }
       });
 
+      db.run(`
+        CREATE TABLE IF NOT EXISTS skill_executions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          work_item_id INTEGER NOT NULL,
+          skill_name TEXT NOT NULL,
+          status TEXT DEFAULT 'in_progress',
+          step_reached INTEGER DEFAULT 1,
+          context_json TEXT,
+          started_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          completed_at DATETIME,
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )
+      `, (err) => {
+        if (err) {
+          throw new Error(`Failed to create skill_executions table: ${err.message}`);
+        }
+      });
+
+      db.run(`
+        CREATE TABLE IF NOT EXISTS workflow_gates (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          work_item_id INTEGER NOT NULL,
+          gate_name TEXT NOT NULL,
+          passed_at DATETIME,
+          UNIQUE(work_item_id, gate_name),
+          FOREIGN KEY (work_item_id) REFERENCES work_items(id)
+        )
+      `, (err) => {
+        if (err) {
+          throw new Error(`Failed to create workflow_gates table: ${err.message}`);
+        }
+      });
+
       // Migrations: Add columns if they don't exist (for databases created before these columns were in base schema)
       const handleAlterError = (columnName) => (err) => {
         if (err && !err.message.includes('duplicate column')) {

package/lib/work-commands/index.js

@@ -1629,10 +1629,82 @@ async function mergeWork(options = {}) {
   }
 }
 
+/**
+ * Create a worktree for writing BDD tests for a feature
+ * @param {number} featureId - Feature ID to create test worktree for
+ * @returns {Promise<Object>} Worktree info with path and branch
+ * @throws {Error} If feature not found or not in correct phase
+ */
+async function testsWork(featureId) {
+  if (!featureId || isNaN(featureId) || featureId < 1) {
+    return Promise.reject(new Error('Invalid feature ID'));
+  }
+
+  const paths = getPaths();
+
+  if (!fs.existsSync(paths.jettypodDir)) {
+    return Promise.reject(new Error('JettyPod not initialized. Run: jettypod init'));
+  }
+
+  if (!fs.existsSync(paths.dbPath)) {
+    return Promise.reject(new Error('Work database not found. Run: jettypod init'));
+  }
+
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    // Get feature work item
+    db.get(
+      `SELECT * FROM work_items WHERE id = ? AND type = 'feature'`,
+      [featureId],
+      async (err, feature) => {
+        if (err) {
+          return reject(new Error(`Database error: ${err.message}`));
+        }
+
+        if (!feature) {
+          return reject(new Error(`Feature #${featureId} not found`));
+        }
+
+        // Create worktree with tests/ prefix
+        try {
+          const gitRoot = getGitRoot();
+          const worktreeResult = await worktreeManager.createWorktree(feature, {
+            repoPath: gitRoot,
+            branchPrefix: 'tests/feature',
+            pathPrefix: 'tests-'
+          });
+
+          // Set as current work
+          setCurrentWork({
+            id: feature.id,
+            type: feature.type,
+            title: feature.title,
+            status: feature.status || 'in_progress',
+            worktreePath: worktreeResult.worktree_path,
+            branchName: worktreeResult.branch_name
+          });
+
+          console.log(`✅ Created test worktree: ${worktreeResult.worktree_path}`);
+          console.log(`📁 IMPORTANT: Use absolute paths for file operations:`);
+          console.log(`   ${worktreeResult.worktree_path}/features/your-feature.feature (correct)`);
+          console.log(`   features/your-feature.feature (wrong - creates in main repo)`);
+          console.log(`\nWorking on tests for: [#${feature.id}] ${feature.title}`);
+
+          resolve(worktreeResult);
+        } catch (worktreeErr) {
+          reject(new Error(`Failed to create test worktree: ${worktreeErr.message}`));
+        }
+      }
+    );
+  });
+}
+
 module.exports = {
   startWork,
   stopWork,
   getCurrentWork,
   cleanupWorktrees,
-  mergeWork
+  mergeWork,
+  testsWork
 };

package/lib/worktree-manager.js

@@ -29,6 +29,8 @@ const VALID_STATUSES = ['active', 'merging', 'cleanup_pending', 'corrupted'];
  * @param {Object} options - Optional configuration
  * @param {string} options.repoPath - Path to git repository (defaults to process.cwd())
  * @param {Object} options.db - Database connection (defaults to global database)
+ * @param {string} options.branchPrefix - Branch prefix (defaults to 'feature/work')
+ * @param {string} options.pathPrefix - Worktree path prefix (defaults to '')
  * @returns {Promise<Object>} Worktree record with id, work_item_id, branch_name, worktree_path, status
  */
 async function createWorktree(workItem, options = {}) {
@@ -85,9 +87,11 @@ async function createWorktree(workItem, options = {}) {
 
   // Generate branch name and worktree path
   const titleSlug = slugify(workItem.title || 'item');
-  const branchName = `feature/work-${workItem.id}-${titleSlug}`;
+  const branchPrefix = options.branchPrefix || 'feature/work';
+  const pathPrefix = options.pathPrefix || '';
+  const branchName = `${branchPrefix}-${workItem.id}-${titleSlug}`;
   const worktreeBasePath = path.join(gitRoot, '.jettypod-work');
-  const worktreePath = path.join(worktreeBasePath, `${workItem.id}-${titleSlug}`);
+  const worktreePath = path.join(worktreeBasePath, `${pathPrefix}${workItem.id}-${titleSlug}`);
 
   let worktreeId = null;
   let branchCreated = false;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.45",
+  "version": "4.4.47",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {

package/skills-templates/chore-mode/SKILL.md

@@ -78,6 +78,14 @@ Implementation Plan:
 
 **Your task:** Create an isolated worktree for this chore.
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b feature/...
+❌ git branch feature/...
+```
+**ALWAYS use `jettypod work start`** - it handles branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 ```bash
 jettypod work start [chore-id]
 ```

package/skills-templates/feature-planning/SKILL.md

@@ -13,20 +13,23 @@ When this skill is activated, you are helping discover the best approach for a f
 
 ## 🔑 Critical Command Distinction
 
-**Two different commands, two different purposes:**
+**Four different commands, four different purposes:**
 
 | Command | Used For | When | Phase |
 |---------|----------|------|-------|
-| `work implement <feature-id>` | Transition feature to implementation phase | During feature planning (Step 8B) | Feature Planning |
-| `work start <chore-id>` | Start implementing a specific chore | After feature planning complete (Step 8D) | Speed Mode |
+| `work implement <feature-id>` | Transition feature to implementation phase | After chores created (Step 8C) | Feature Planning |
+| `work tests start <feature-id>` | Create worktree for test authoring | After transition (Step 8D) | Feature Planning |
+| `work tests merge <feature-id>` | Merge tests to main, cleanup worktree | After tests validated (Step 8D) | Feature Planning |
+| `work start <chore-id>` | Start implementing a specific chore | After tests merged (Step 8E) | Speed Mode |
 
-**CRITICAL:** Both commands are run by **Claude**, not the user. The distinction is:
-- `work implement` = Ends feature planning, creates chores
-- `work start` = Creates worktree/branch for chore (does NOT auto-invoke speed-mode)
+**CRITICAL:** All commands are run by **Claude**, not the user. The distinction is:
+- `work implement` = Ends feature planning, transitions to implementation phase
+- `work tests start/merge` = Write and land BDD tests in isolated worktree
+- `work start` = Creates worktree/branch for chore implementation
 
-**🛑 STOP GATE:** DO NOT run `work start` until Step 8D. If you're in Steps 1-8C, use `work implement` only.
+**🛑 STOP GATE:** DO NOT run `work start` until Step 8E. Tests must be merged to main first.
 
-**🛑 HANDOFF REQUIREMENT:** After `work start`, you MUST invoke speed-mode using the Skill tool. See Step 8D.
+**🛑 HANDOFF REQUIREMENT:** After `work start`, you MUST invoke speed-mode using the Skill tool. See Step 8E.
 
 ---
 
@@ -224,9 +227,9 @@ Example:
 
 **WAIT for user to confirm or adjust the integration contract.**
 
-#### Step 6B: Generate BDD Scenarios AND Step Definitions
+#### Step 6B: Propose BDD Scenarios (DO NOT WRITE YET)
 
-**CRITICAL:** BDD scenarios and step definitions must ALWAYS be created together. Never create scenarios without step definitions.
+**CRITICAL:** Do NOT write files yet. Display the proposed scenarios for user confirmation. Files will be written in Step 8D inside an isolated worktree.
 
 **Feature slug:** Derive `FEATURE_SLUG` from the feature title:
 - Lowercase
@@ -234,43 +237,79 @@ Example:
 - Remove special characters
 - Examples: "Email Password Login" → "email-password-login", "User's Profile (v2)" → "users-profile-v2"
 
-Based on chosen approach, generate:
+Based on chosen approach, **display** the proposed scenarios to the user:
 
-**A. Scenario file** at `features/[feature-slug].feature` using Write tool:
+```
+📋 Proposed BDD Scenarios
 
-1. **Create file** at `features/[feature-slug].feature` using Write tool
-2. **FIRST scenario MUST be the Integration Scenario** from Step 6A (proves reachability)
-3. **Include all "make it work" scenarios**:
-   - All success paths - required functionality AND optional features
-   - Multiple valid workflows if the feature supports them
-   - Success variations (different outcomes that are all correct)
-   - NO error handling scenarios (added in stable mode)
-   - NO validation failures (added in stable mode)
-   - NO security/compliance scenarios (added in production mode)
+**Feature file:** features/[feature-slug].feature
+**Step definitions:** features/step_definitions/[feature-slug].steps.js
+```
 
-**B. Step definitions file** at `features/step_definitions/[feature-slug].steps.js` using Write tool:
+Then show the full Gherkin content:
 
-1. **Create file** at `features/step_definitions/[feature-slug].steps.js`
-2. **Implement all Given/When/Then steps** from the scenarios
-3. **Follow existing patterns** - check other `.steps.js` files for conventions
-4. **Include**:
-   - Test environment setup/cleanup
-   - All Given steps (setup state)
-   - All When steps (execute actions)
-   - All Then steps (verify outcomes)
+```gherkin
+Feature: [Feature Name]
+  [Brief description based on chosen UX approach]
 
-**C. Update database** with scenario file path (run from project root):
+  Epic: [Epic name if applicable]
+  Approach: [Chosen approach name]
 
-```bash
-sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/${FEATURE_SLUG}.feature' WHERE id = ${FEATURE_ID}"
+  # Integration Contract:
+  # Entry Point: [from Step 6A]
+  # Caller Code: [from Step 6A]
+
+# INTEGRATION SCENARIO (REQUIRED - proves feature is reachable)
+Scenario: User can reach [feature] from [entry point]
+  Given I am on [existing entry point users can access]
+  When I [navigate/click/invoke to reach the feature]
+  Then I [see/access the feature]
+
+# FEATURE SCENARIOS (required + optional functionality)
+Scenario: [Core functionality - required workflow]
+  Given [initial state]
+  When [user takes main action]
+  Then [expected successful outcome]
+  And [observable UI/system state change]
+
+Scenario: [Optional feature 1 - if applicable]
+  Given [initial state]
+  When [user uses optional feature]
+  Then [feature works correctly]
+
+# SPEED MODE: All success scenarios above (integration + required + optional)
+# STABLE MODE: Will add error handling, validation failures, edge cases
 ```
 
-Replace `${FEATURE_SLUG}` and `${FEATURE_ID}` with actual values. Example:
-```bash
-sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/email-password-login.feature' WHERE id = 42"
+Then list the step definitions that will be created:
+
+```
+**Step definitions to implement:**
+• Given I am on [entry point] - [brief implementation note]
+• When I [action] - [brief implementation note]
+• Then I [outcome] - [brief implementation note]
+[etc.]
+
+Does this capture the feature correctly? Any scenarios to add/change?
 ```
 
-**Proceed to Step 6.5.**
+**Scenario content requirements:**
+- **FIRST scenario MUST be the Integration Scenario** from Step 6A (proves reachability)
+- **Include all "make it work" scenarios**:
+  - All success paths - required functionality AND optional features
+  - Multiple valid workflows if the feature supports them
+  - Success variations (different outcomes that are all correct)
+  - NO error handling scenarios (added in stable mode)
+  - NO validation failures (added in stable mode)
+  - NO security/compliance scenarios (added in production mode)
+
+**WAIT for user confirmation.**
+
+- If user confirms → Proceed to Step 7
+- If user requests changes → Revise scenarios and display again
+- **Store the confirmed scenarios in memory** - you'll write them in Step 8D
+
+**Proceed to Step 7.**
 
 **Template for speed mode (make it work):**
 
@@ -395,102 +434,9 @@ Scenario: Prevent unauthorized access
 
 </details>
 
-### Step 6.5: Validate BDD Infrastructure
-
-**CRITICAL:** After creating both scenario and step definition files, validate them with cucumber dry-run to catch errors immediately.
-
-**Run this command** (replace `${FEATURE_SLUG}` with actual slug):
-
-```bash
-npx cucumber-js --dry-run features/${FEATURE_SLUG}.feature
-```
-
-Example:
-```bash
-npx cucumber-js --dry-run features/email-password-login.feature
-```
-
-**What the output means:**
-
-✅ **Success** - No errors, all steps have definitions:
-```
-0 scenarios
-0 steps
-```
-(Dry-run doesn't execute, so 0 is correct)
-
-❌ **Undefined steps** - Missing step definitions:
-```
-Undefined. Implement with the following snippet:
-  Given('I am on the login page', function () {
-    ...
-  });
-```
-→ Add the missing step definition to your `.steps.js` file
-
-❌ **Syntax error** - Invalid Gherkin:
-```
-Parse error in features/foo.feature
-```
-→ Fix the feature file syntax
-
-❌ **Duplicate steps** - Multiple definitions match:
-```
-Multiple step definitions match
-```
-→ Remove or rename one of the duplicate step definitions
-
-**If validation fails:**
-1. Read the error message carefully
-2. Fix the step definitions or scenario file
-3. Re-run the dry-run command
-4. **Loop until validation passes** - do NOT proceed to Step 7 until green
-
-**If validation succeeds:**
-Display: "✅ BDD infrastructure validated - all steps have definitions"
-
-**Proceed to Step 6.6.**
-
-**Note:** Unit tests are created during speed mode implementation, not during feature planning. Feature planning focuses on BDD scenarios (user experience); speed mode handles unit tests (implementation details).
-
-### Step 6.6: Commit BDD Files to Main
-
-**CRITICAL:** The BDD files must be committed to main BEFORE creating worktrees. If you skip this step, worktrees won't have the scenario files and speed-mode will fail.
-
-**Commit the BDD files:**
-
-```bash
-git add features/${FEATURE_SLUG}.feature features/steps/${FEATURE_SLUG}.* features/step_definitions/${FEATURE_SLUG}.*
-git commit -m "test: Add BDD scenarios for ${FEATURE_TITLE}
-
-- Feature file: features/${FEATURE_SLUG}.feature
-- Step definitions for speed mode scenarios"
-
-git push
-```
-
-Replace `${FEATURE_SLUG}` and `${FEATURE_TITLE}` with actual values. Example:
-```bash
-git add features/email-password-login.feature features/steps/email-password-login.* features/step_definitions/email-password-login.*
-git commit -m "test: Add BDD scenarios for Email Password Login
-
-- Feature file: features/email-password-login.feature
-- Step definitions for speed mode scenarios"
-
-git push
-```
-
-**Why this matters:**
-- Worktrees are created from the current branch (usually main)
-- If BDD files aren't committed, they won't exist in the worktree
-- Speed-mode will fail trying to run tests against non-existent files
-- **Push is required** so other assistants/machines have the latest main
-
-**Proceed to Step 7.**
-
 ### Step 7: Propose Speed Mode Chores
 
-**CRITICAL:** After BDD validation passes, analyze the codebase and propose technical implementation chores. **DO NOT CREATE CHORES YET** - the feature must transition to implementation mode first (Step 8).
+**CRITICAL:** After user confirms the BDD scenarios, analyze the codebase and propose technical implementation chores. **DO NOT CREATE CHORES YET** - the feature must transition to implementation mode first (Step 8).
 
 **Your analysis should consider:**
 - The BDD scenarios (integration + all success paths)
@@ -633,6 +579,147 @@ After successful transition, display:
 ✅ Feature transitioned to implementation phase
 ✅ Created X chores for speed mode
 
+Now I'll write the BDD tests in an isolated worktree...
+```
+
+**Proceed to Step 8D.**
+
+#### Step 8D: Write Tests in Isolated Worktree
+
+**CRITICAL:** Tests are written in an isolated worktree, not directly on main. This ensures agent failures don't leave uncommitted garbage on main.
+
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b tests/...
+❌ git branch tests/...
+```
+**ALWAYS use jettypod commands** - they handle branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
+**Sub-step 1: Create test worktree**
+
+```bash
+jettypod work tests start ${FEATURE_ID}
+```
+
+This creates:
+- Worktree at `.jettypod-work/tests-<id>-<slug>/`
+- Branch `tests/feature-<id>-<slug>`
+
+**Capture the worktree path from output** - you'll need it for file operations.
+
+Example output:
+```
+✅ Created test worktree: /path/to/.jettypod-work/tests-42-email-login
+Branch: tests/feature-42-email-login
+
+Write your BDD files to:
+  <worktree>/features/email-login.feature
+  <worktree>/features/step_definitions/email-login.steps.js
+
+When done, run: jettypod work tests merge 42
+```
+
+**🛑 STOP AND CHECK:** Verify worktree was created successfully. If you see an error, investigate before continuing.
+
+**Sub-step 2: Write BDD files in the worktree**
+
+Using the scenarios you confirmed in Step 6B, write the files using **absolute paths to the worktree**:
+
+**A. Write scenario file** using Write tool:
+```
+<worktree_path>/features/${FEATURE_SLUG}.feature
+```
+
+**B. Write step definitions file** using Write tool:
+```
+<worktree_path>/features/step_definitions/${FEATURE_SLUG}.steps.js
+```
+
+**Step definition requirements:**
+1. Implement all Given/When/Then steps from the scenarios
+2. Follow existing patterns - check other `.steps.js` files for conventions
+3. Include test environment setup/cleanup
+4. All Given steps (setup state)
+5. All When steps (execute actions)
+6. All Then steps (verify outcomes)
+
+**Sub-step 3: Validate BDD infrastructure**
+
+Run cucumber dry-run **from within the worktree**:
+
+```bash
+cd <worktree_path> && npx cucumber-js --dry-run features/${FEATURE_SLUG}.feature
+```
+
+**What the output means:**
+
+✅ **Success** - No errors, all steps have definitions:
+```
+0 scenarios
+0 steps
+```
+(Dry-run doesn't execute, so 0 is correct)
+
+❌ **Undefined steps** - Missing step definitions:
+```
+Undefined. Implement with the following snippet:
+  Given('I am on the login page', function () {
+    ...
+  });
+```
+→ Add the missing step definition to your `.steps.js` file
+
+❌ **Syntax error** - Invalid Gherkin:
+```
+Parse error in features/foo.feature
+```
+→ Fix the feature file syntax
+
+❌ **Duplicate steps** - Multiple definitions match:
+```
+Multiple step definitions match
+```
+→ Remove or rename one of the duplicate step definitions
+
+**If validation fails:**
+1. Read the error message carefully
+2. Fix the step definitions or scenario file **in the worktree**
+3. Re-run the dry-run command
+4. **Loop until validation passes** - do NOT proceed until green
+
+**If validation succeeds:**
+Display: "✅ BDD infrastructure validated - all steps have definitions"
+
+**Sub-step 4: Update database with scenario file path**
+
+```bash
+sqlite3 .jettypod/work.db "UPDATE work_items SET scenario_file = 'features/${FEATURE_SLUG}.feature' WHERE id = ${FEATURE_ID}"
+```
+
+**Sub-step 5: Merge tests to main**
+
+```bash
+jettypod work tests merge ${FEATURE_ID}
+```
+
+This will:
+- Commit changes in the worktree
+- Merge to main
+- Push to remote
+- Clean up the worktree
+
+**🛑 STOP AND CHECK:** Verify merge succeeded:
+- ✅ "Tests merged to main" → Proceed to Step 8E
+- ❌ Error → Investigate, worktree still exists for debugging
+
+**After successful merge, display:**
+
+```
+✅ Feature transitioned to implementation phase
+✅ Created X chores for speed mode
+✅ BDD tests merged to main
+
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 🎯 Feature Planning Complete!
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -648,9 +735,11 @@ After successful transition, display:
 Start this one? [yes / pick different / done for now]
 ```
 
-#### Step 8D: Start First Chore
+**Proceed to Step 8E.**
+
+#### Step 8E: Start First Chore
 
-**Feature planning is now complete.** The feature has been transitioned to implementation phase and chores are ready.
+**Feature planning is now complete.** The feature has been transitioned to implementation phase, tests are on main, and chores are ready.
 
 The completion message above already includes your recommendation. Now:
 
@@ -675,6 +764,14 @@ End feature-planning skill without starting a chore. Do NOT invoke speed-mode.
 
 **After user picks a chore, execute these steps IN ORDER:**
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b feature/...
+❌ git branch feature/...
+```
+**ALWAYS use `jettypod work start`** - it handles branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 **Step 1: Start the chore (creates worktree and branch):**
 ```bash
 jettypod work start [chore-id]
@@ -763,14 +860,15 @@ Before completing feature planning, ensure:
 - [ ] Exactly 3 approaches suggested
 - [ ] Winner chosen (with prototypes or without)
 - [ ] **Integration Contract defined** (entry point, caller code, integration scenario)
-- [ ] **Integration Scenario is FIRST scenario** in feature file
-- [ ] BDD scenarios written (integration + all success paths)
-- [ ] Step definitions written for ALL scenario steps
-- [ ] Scenarios file exists at `features/[feature-slug].feature`
-- [ ] Step definitions file exists at `features/step_definitions/[feature-slug].steps.js`
-- [ ] BDD infrastructure validated with dry-run (Step 6.5)
-- [ ] Feature transitioned to implementation with `work implement`
-- [ ] **At least one Integration Chore created** (wires feature into app)
-- [ ] Speed mode chores created
-- [ ] First chore started with `work start [chore-id]` (Step 8D)
-- [ ] **Speed-mode skill invoked using Skill tool** (Step 8D)
+- [ ] **Integration Scenario is FIRST scenario** in proposed scenarios
+- [ ] BDD scenarios **proposed and confirmed** by user (Step 6B)
+- [ ] **At least one Integration Chore proposed** (wires feature into app)
+- [ ] Speed mode chores proposed and confirmed (Step 7)
+- [ ] Chores created in database (Step 8B)
+- [ ] Feature transitioned to implementation with `work implement` (Step 8C)
+- [ ] **Test worktree created** with `work tests start` (Step 8D)
+- [ ] **BDD files written** in worktree (Step 8D)
+- [ ] **BDD infrastructure validated** with dry-run (Step 8D)
+- [ ] **Tests merged to main** with `work tests merge` (Step 8D)
+- [ ] First chore started with `work start [chore-id]` (Step 8E)
+- [ ] **Speed-mode skill invoked using Skill tool** (Step 8E)