@dzhechkov/skills-feature-adr 1.1.0 → 1.3.0

package/README.md

@@ -9,14 +9,17 @@
 ## Quick Start
 
 ```bash
-# One-command install via npx
-npx @dzhechkov/skills-feature-adr
+# Core install (feature-adr pipeline only)
+npx @dzhechkov/skills-feature-adr init
+
+# Full install with learning + knowledge extraction
+npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor
 
 # Or install globally
 npm install -g @dzhechkov/skills-feature-adr
-skills-feature-adr init
+skills-feature-adr init --with-learning --knowledge-extractor
 
-# Install into a project that already has @dzhechkov/keysarium
+# Already have @dzhechkov/keysarium? Just install core (learning & harvest included)
 npx @dzhechkov/skills-feature-adr init
 ```
 
@@ -44,7 +47,10 @@ Everything is installed into your project's `.claude/` directory and works nativ
 
 ```bash
 npx @dzhechkov/skills-feature-adr                    # Full install (same as init)
-npx @dzhechkov/skills-feature-adr init               # Install all components
+npx @dzhechkov/skills-feature-adr init               # Install core components
+npx @dzhechkov/skills-feature-adr init --with-learning                  # + reward learning
+npx @dzhechkov/skills-feature-adr init --knowledge-extractor            # + knowledge extractor
+npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor  # + both
 npx @dzhechkov/skills-feature-adr init --force       # Overwrite existing files
 npx @dzhechkov/skills-feature-adr init --dry-run     # Preview without making changes
 npx @dzhechkov/skills-feature-adr update             # Update to latest version
@@ -209,6 +215,50 @@ After installation, feature-adr auto-detects agentic-qe when you use the `--full
 
 ---
 
+## Optional Features: Learning & Knowledge Extraction
+
+Feature ADR can be extended with reward learning and knowledge extraction — no additional packages required.
+
+### `--with-learning` — Reward Learning
+
+Adds the Memory Protocol and Reward Tracker. The pipeline **learns from your feedback** at every checkpoint:
+- Stores reward scores based on your responses (immediate approval = 1.0, minor adjustments = 0.7, rework = 0.3)
+- Loads historical patterns at the start of each step
+- Detects domain-specific bottlenecks and skill effectiveness trends
+
+```bash
+npx @dzhechkov/skills-feature-adr init --with-learning
+```
+
+**Installs:** `lib/memory-protocol.md`, `lib/reward-tracker.md`, `.claude/rules/reward-learning.md`
+
+### `--knowledge-extractor` — Knowledge Harvesting
+
+Adds the Knowledge Extractor skill with the `/harvest` command. After completing a feature, extract reusable patterns:
+
+```bash
+npx @dzhechkov/skills-feature-adr init --knowledge-extractor
+
+# After completing a feature:
+/harvest features/<feature-slug>/
+```
+
+**Installs:** `.claude/skills/knowledge-extractor/` (5 agents, 7 categories, 8 quality gates), `.claude/commands/harvest.md`
+
+### Both at once
+
+```bash
+npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor
+```
+
+### Already using `@dzhechkov/keysarium`?
+
+> **If you have `@dzhechkov/keysarium` installed, these flags are not needed.**
+> Keysarium already includes reward learning, knowledge extraction, and more.
+> The installer auto-detects keysarium and skips optional components to avoid duplication.
+
+---
+
 ## Shared Skills
 
 Feature ADR uses these skills from `@dzhechkov/keysarium` (if installed):

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.1.0",
-  "description": "Adaptive Feature Development skill pack for Claude Code — 11-step pipeline with Complexity Router (S/M/L/XL), ADR-driven architecture, 15 agentic-qe skills, and multi-agent fleet QE. Supports --full-qe and --full-qe-extended modes.",
+  "version": "1.3.0",
+  "description": "Adaptive Feature Development skill pack for Claude Code — 11-step pipeline with Complexity Router (S/M/L/XL), ADR-driven architecture, 15 agentic-qe skills, multi-agent fleet QE. Supports --full-qe, --full-qe-extended, --with-learning, and --knowledge-extractor modes.",
   "main": "src/cli.js",
   "bin": {
     "skills-feature-adr": "./bin/cli.js"
@@ -30,7 +30,10 @@
     "quality-engineering",
     "agentic-qe",
     "shift-left",
-    "fleet-qe"
+    "fleet-qe",
+    "reward-learning",
+    "knowledge-extractor",
+    "harvest"
   ],
   "author": "dzhechko",
   "license": "MIT",

package/src/cli.js

@@ -10,7 +10,7 @@ function showBanner() {
   console.log('');
   console.log(cyan('\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557'));
   console.log(cyan('\u2551') + bold('   FEATURE-ADR \u2014 Adaptive Feature Development          ') + cyan('\u2551'));
-  console.log(cyan('\u2551') + '   9-step pipeline with Complexity Router (S/M/L/XL)   ' + cyan('\u2551'));
+  console.log(cyan('\u2551') + '   11-step pipeline with Complexity Router (S/M/L/XL)  ' + cyan('\u2551'));
   console.log(cyan('\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D'));
   console.log('');
 }
@@ -37,20 +37,24 @@ function showHelp() {
   console.log('  ' + green('doctor') + '    Check Feature ADR installation health');
   console.log('');
   console.log(bold('Options:'));
-  console.log('  ' + yellow('--force') + '      Overwrite existing files without prompting');
-  console.log('  ' + yellow('--dry-run') + '    Show what would be done without making changes');
-  console.log('  ' + yellow('--help, -h') + '   Show this help message');
-  console.log('  ' + yellow('--version, -v') + ' Show version number');
+  console.log('  ' + yellow('--force') + '                Overwrite existing files without prompting');
+  console.log('  ' + yellow('--dry-run') + '              Show what would be done without making changes');
+  console.log('  ' + yellow('--with-learning') + '        Add reward learning (memory protocol + reward tracker)');
+  console.log('  ' + yellow('--knowledge-extractor') + '  Add knowledge extractor skill (/harvest)');
+  console.log('  ' + yellow('--help, -h') + '             Show this help message');
+  console.log('  ' + yellow('--version, -v') + '          Show version number');
   console.log('');
   console.log(bold('Examples:'));
   console.log(dim('  $ ') + 'npx @dzhechkov/skills-feature-adr init');
+  console.log(dim('  $ ') + 'npx @dzhechkov/skills-feature-adr init --with-learning');
+  console.log(dim('  $ ') + 'npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor');
   console.log(dim('  $ ') + 'npx @dzhechkov/skills-feature-adr init --force');
-  console.log(dim('  $ ') + 'npx @dzhechkov/skills-feature-adr update --dry-run');
   console.log(dim('  $ ') + 'npx @dzhechkov/skills-feature-adr doctor');
   console.log('');
   console.log(bold('Integration:'));
   console.log('  Works alongside @dzhechkov/keysarium and @dzhechkov/skills-bto.');
-  console.log('  Install all three for the full toolkit.');
+  console.log('  If @dzhechkov/keysarium is already installed, --with-learning and');
+  console.log('  --knowledge-extractor are not needed (already included in keysarium).');
   console.log('');
 }
 
@@ -63,6 +67,8 @@ function parseArgs(argv) {
   const flags = {
     force: false,
     dryRun: false,
+    withLearning: false,
+    knowledgeExtractor: false,
     targetDir: process.cwd(),
   };
 
@@ -76,6 +82,12 @@ function parseArgs(argv) {
       case '--dry-run':
         flags.dryRun = true;
         break;
+      case '--with-learning':
+        flags.withLearning = true;
+        break;
+      case '--knowledge-extractor':
+        flags.knowledgeExtractor = true;
+        break;
       case '--help':
       case '-h':
         command = 'help';

package/src/commands/init.js

@@ -8,7 +8,7 @@ const {
   copyDirRecursive, copyDirFiltered, fileExists, readJSON,
   ensureDir, getRelativePaths, getRelativePathsFiltered,
   createManifest, writeManifest, getTemplatesDir,
-  COMPONENTS, MANIFEST_FILE, getComponentFilter,
+  COMPONENTS, OPTIONAL_COMPONENTS, MANIFEST_FILE, getComponentFilter,
 } = require('../utils');
 
 // ---------------------------------------------------------------------------
@@ -47,6 +47,13 @@ function installComponent(key, comp, templatesDir, targetDir) {
     return [];
   }
 
+  // Single file copy (for isFile components)
+  if (comp.isFile) {
+    ensureDir(path.dirname(dest));
+    fs.copyFileSync(src, dest);
+    return [comp.src];
+  }
+
   const filterFn = getComponentFilter(comp);
 
   if (filterFn) {
@@ -58,12 +65,33 @@ function installComponent(key, comp, templatesDir, targetDir) {
   return getRelativePaths(dest).map((rel) => path.join(comp.src, rel));
 }
 
+// Resolve which optional component keys to install based on flags
+function getOptionalKeys(flags, keysariumDetected) {
+  if (keysariumDetected) return []; // keysarium already provides these
+
+  const keys = [];
+
+  if (flags.withLearning) {
+    for (const [key, comp] of Object.entries(OPTIONAL_COMPONENTS)) {
+      if (comp.group === 'learning') keys.push(key);
+    }
+  }
+
+  if (flags.knowledgeExtractor) {
+    for (const [key, comp] of Object.entries(OPTIONAL_COMPONENTS)) {
+      if (comp.group === 'knowledge-extractor') keys.push(key);
+    }
+  }
+
+  return keys;
+}
+
 // ---------------------------------------------------------------------------
 // Main command
 // ---------------------------------------------------------------------------
 
 async function run(options) {
-  const { force, dryRun, targetDir } = options;
+  const { force, dryRun, targetDir, withLearning, knowledgeExtractor } = options;
   const manifestPath = path.join(targetDir, MANIFEST_FILE);
 
   // ── a) Check for existing installation ─────────────────────────────────
@@ -78,12 +106,23 @@ async function run(options) {
 
   // ── b) Detect keysarium integration ────────────────────────────────────
   const keysariumManifest = detectKeysarium(targetDir);
+  const keysariumDetected = !!keysariumManifest;
+
   if (keysariumManifest) {
     showKeysariumIntegration(keysariumManifest);
   }
 
+  // Warn if flags used but keysarium already provides these
+  if (keysariumDetected && (withLearning || knowledgeExtractor)) {
+    console.log('');
+    warn('Keysarium is already installed \u2014 it includes learning and knowledge extraction.');
+    info('Flags --with-learning and --knowledge-extractor are not needed. Skipping optional components.');
+    console.log('');
+  }
+
   // ── c) Determine components ────────────────────────────────────────────
   const componentKeys = Object.keys(COMPONENTS);
+  const optionalKeys = getOptionalKeys(options, keysariumDetected);
   const templatesDir = getTemplatesDir();
 
   // ── d) Show plan ───────────────────────────────────────────────────────
@@ -97,6 +136,16 @@ async function run(options) {
     console.log(`  ${green('+')} ${comp.label}${filterNote}`);
   }
 
+  if (optionalKeys.length > 0) {
+    console.log('');
+    info(bold('Optional components:'));
+    console.log('');
+    for (const key of optionalKeys) {
+      const comp = OPTIONAL_COMPONENTS[key];
+      console.log(`  ${yellow('+')} ${comp.label}`);
+    }
+  }
+
   console.log('');
 
   if (dryRun) {
@@ -104,14 +153,25 @@ async function run(options) {
     process.exit(0);
   }
 
-  // ── e) Install components ──────────────────────────────────────────────
-  const totalComponents = componentKeys.length;
+  // ── e) Install core components ─────────────────────────────────────────
+  const totalComponents = componentKeys.length + optionalKeys.length;
   const installedFiles = [];
+  let stepNum = 0;
 
-  for (let i = 0; i < totalComponents; i++) {
-    const key = componentKeys[i];
+  for (const key of componentKeys) {
+    stepNum++;
     const comp = COMPONENTS[key];
-    step(i + 1, totalComponents, `Installing ${comp.label}...`);
+    step(stepNum, totalComponents, `Installing ${comp.label}...`);
+
+    const files = installComponent(key, comp, templatesDir, targetDir);
+    installedFiles.push(...files);
+  }
+
+  // ── e2) Install optional components ────────────────────────────────────
+  for (const key of optionalKeys) {
+    stepNum++;
+    const comp = OPTIONAL_COMPONENTS[key];
+    step(stepNum, totalComponents, `Installing ${comp.label}...`);
 
     const files = installComponent(key, comp, templatesDir, targetDir);
     installedFiles.push(...files);
@@ -122,7 +182,15 @@ async function run(options) {
   const pkg = readJSON(pkgPath);
   const version = pkg ? pkg.version : '0.0.0';
 
-  const manifest = createManifest(version, componentKeys, installedFiles.sort());
+  const allKeys = [...componentKeys, ...optionalKeys];
+  const manifest = createManifest(version, allKeys, installedFiles.sort());
+
+  // Track optional features in manifest
+  manifest.optional = {
+    withLearning: optionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'learning'),
+    knowledgeExtractor: optionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'knowledge-extractor'),
+  };
+
   writeManifest(targetDir, manifest);
   info(`Created ${MANIFEST_FILE} manifest`);
 
@@ -136,6 +204,10 @@ async function run(options) {
     const comp = COMPONENTS[key];
     console.log(`  ${green('\u2713')} ${comp.label}`);
   }
+  for (const key of optionalKeys) {
+    const comp = OPTIONAL_COMPONENTS[key];
+    console.log(`  ${green('\u2713')} ${comp.label} ${yellow('[optional]')}`);
+  }
 
   console.log('');
   console.log(bold('Next steps:'));
@@ -143,6 +215,14 @@ async function run(options) {
   console.log(`  2. Run ${cyan('/feature-adr [description]')} to start the pipeline`);
   console.log(`  3. The Complexity Router will classify your feature as S/M/L/XL`);
   console.log(`  4. Then the pipeline adapts: fewer steps for S, full DAG for XL`);
+
+  if (manifest.optional.withLearning) {
+    console.log(`  5. Reward learning is active \u2014 pipeline improves from your feedback`);
+  }
+  if (manifest.optional.knowledgeExtractor) {
+    console.log(`  ${manifest.optional.withLearning ? '6' : '5'}. Run ${cyan('/harvest features/<slug>/')} after completing a feature to extract knowledge`);
+  }
+
   console.log('');
 
   console.log(bold('Complexity Tiers:'));
@@ -152,10 +232,19 @@ async function run(options) {
   console.log(`  ${bold('XL')} ${dim('\u2014 30+ files, ~4h+     (Full DAG + multi-agent swarm)')}`);
   console.log('');
 
+  if (!withLearning && !knowledgeExtractor && !keysariumDetected) {
+    console.log(bold('Optional features:'));
+    console.log(`  ${dim('Add reward learning:')}     npx @dzhechkov/skills-feature-adr init --with-learning --force`);
+    console.log(`  ${dim('Add knowledge extractor:')} npx @dzhechkov/skills-feature-adr init --knowledge-extractor --force`);
+    console.log(`  ${dim('Add both:')}                npx @dzhechkov/skills-feature-adr init --with-learning --knowledge-extractor --force`);
+    console.log('');
+  }
+
   if (keysariumManifest) {
     console.log(bold('Integration:'));
     console.log(`  Feature ADR is available alongside your Keysarium pipeline.`);
     console.log(`  Use ${cyan('/casarium')} for research, ${cyan('/feature-adr')} for feature development.`);
+    console.log(`  Learning and knowledge extraction are provided by Keysarium.`);
     console.log('');
   }
 

package/src/utils.js

@@ -247,9 +247,24 @@ function getTemplatesDir() {
 const COMPONENTS = {
   skill: {
     src: '.claude/skills/feature-adr',
-    label: 'Feature ADR Skill (9 modules + 4 references)',
+    label: 'Feature ADR Skill (11 modules + references + agentic-qe)',
     group: 'core',
   },
+  skill_explore: {
+    src: '.claude/skills/explore',
+    label: 'Explore Skill (task clarification)',
+    group: 'deps',
+  },
+  skill_solver: {
+    src: '.claude/skills/problem-solver-enhanced',
+    label: 'Problem Solver Enhanced (TRIZ + Game Theory)',
+    group: 'deps',
+  },
+  skill_frontend: {
+    src: '.claude/skills/frontend-design',
+    label: 'Frontend Design Skill (UI implementation)',
+    group: 'deps',
+  },
   commands: {
     src: '.claude/commands',
     label: 'Feature ADR Command (1 command)',
@@ -270,6 +285,41 @@ const COMPONENTS = {
   },
 };
 
+// Optional components — installed only with explicit flags
+const OPTIONAL_COMPONENTS = {
+  // --with-learning
+  learning_lib_memory: {
+    src: 'lib/memory-protocol.md',
+    label: 'Memory Protocol (reward-calibrated learning)',
+    group: 'learning',
+    isFile: true,
+  },
+  learning_lib_reward: {
+    src: 'lib/reward-tracker.md',
+    label: 'Reward Tracker (analytics & pattern detection)',
+    group: 'learning',
+    isFile: true,
+  },
+  learning_rule: {
+    src: '.claude/rules/reward-learning.md',
+    label: 'Reward Learning Rules',
+    group: 'learning',
+    isFile: true,
+  },
+  // --knowledge-extractor
+  knowledge_extractor_skill: {
+    src: '.claude/skills/knowledge-extractor',
+    label: 'Knowledge Extractor Skill (5 agents, 7 categories, 8 gates)',
+    group: 'knowledge-extractor',
+  },
+  knowledge_extractor_command: {
+    src: '.claude/commands',
+    label: 'Harvest Command (/harvest)',
+    group: 'knowledge-extractor',
+    filter: 'harvest',
+  },
+};
+
 // ===========================================================================
 // Filter helpers
 // ===========================================================================
@@ -328,6 +378,7 @@ module.exports = {
 
   // Components
   COMPONENTS,
+  OPTIONAL_COMPONENTS,
 
   // Filters
   getComponentFilter,

package/templates/.claude/skills/explore/SKILL.md

@@ -0,0 +1,218 @@
+---
+name: explore
+description: >
+  Adaptive task exploration and clarification skill for transforming vague 
+  requests into actionable specifications. Use when a user presents any task, 
+  problem, or goal that requires clarification before execution. Triggers on
+  ambiguous requests, complex multi-part tasks, "I want to...", "help me with...",
+  strategic decisions, product ideas, creative briefs, and any situation where
+  understanding the real need is essential before proposing solutions. Does NOT
+  provide solutions until task is fully explored.
+trust_tier: 1
+trust_tier_label: "Structured"
+trust_tier_path: "Run /bto-test to promote to Tier 2"
+---
+
+# Explore: Adaptive Task Clarification
+
+Transform vague requests into crystal-clear, actionable task specifications through systematic Socratic questioning.
+
+## Core Philosophy
+
+**Never solve before you understand.** Most failed solutions solve the wrong problem. This skill ensures the real problem is understood before any solution is proposed.
+
+Key principles:
+- Questions unlock understanding; answers often hide assumptions
+- The stated goal is rarely the real goal
+- Constraints reveal opportunities
+- Success criteria prevent scope creep
+
+## Task Classification
+
+Before asking questions, classify the task type to select appropriate exploration dimensions:
+
+| Task Type | Indicators | Primary Dimensions |
+|-----------|------------|-------------------|
+| **Product/Feature** | "build", "create app", "develop" | Outcome, Users, Constraints, Success |
+| **Problem Solving** | "fix", "solve", "issue with" | Root Cause, Constraints, Attempted Solutions |
+| **Decision Making** | "should I", "choose between", "evaluate" | Criteria, Tradeoffs, Timeline, Reversibility |
+| **Creative** | "write", "design", "make content" | Audience, Tone, Format, Examples |
+| **Research** | "find out", "analyze", "understand" | Scope, Depth, Sources, Deliverable |
+| **Process/Workflow** | "how to", "improve process" | Current State, Desired State, Blockers |
+
+## Exploration Dimensions
+
+Select 3-5 dimensions based on task type. Each dimension has multiple question variants—choose the most natural for context.
+
+### 1. The Real Objective
+Uncover what success truly looks like, beyond the stated request.
+
+**Questions:**
+- "If this worked perfectly, what would be different in your [work/life/business]?"
+- "What outcome would make you say 'this was absolutely worth it'?"
+- "Is this goal a means to something else, or the end itself?"
+- "If you could wave a magic wand and have any result, what would you choose?"
+
+**Red flags to probe:** Generic goals ("make it better"), proxy metrics, solutions presented as requirements.
+
+### 2. Constraints & Boundaries
+Identify hard limits that shape the solution space.
+
+**Questions:**
+- "What's absolutely off the table—budget, time, technology, or approach-wise?"
+- "What existing systems, processes, or decisions must this work with?"
+- "Who needs to approve this, and what are their non-negotiables?"
+- "What would disqualify a solution, even if it technically works?"
+
+**Red flags to probe:** No constraints mentioned (usually means hidden ones), unrealistic expectations.
+
+### 3. Available Resources
+Understand leverage points and existing assets.
+
+**Questions:**
+- "What do you already have that we could build on—data, tools, people, prior work?"
+- "Who else is involved, and what can they contribute?"
+- "What similar problems have you solved before, and what worked?"
+- "What's your actual capacity to implement this?"
+
+**Red flags to probe:** Overestimated capabilities, unacknowledged dependencies.
+
+### 4. Timeline & Urgency
+Distinguish real deadlines from arbitrary ones.
+
+**Questions:**
+- "What happens if this takes 2x longer than expected?"
+- "Is there a hard deadline, and what's driving it?"
+- "Would you prefer a quick 80% solution or a slower 100% solution?"
+- "What's the cost of delay vs. the cost of getting it wrong?"
+
+**Red flags to probe:** Artificial urgency, no clear driver for deadline.
+
+### 5. Success Criteria
+Define what "done" actually means.
+
+**Questions:**
+- "How will you know this is successful? What will you measure?"
+- "Who decides if this is good enough, and what will they look for?"
+- "What's the minimum viable outcome that would still be valuable?"
+- "In 6 months, what would make you regret the approach we took?"
+
+**Red flags to probe:** Vague criteria ("stakeholders will be happy"), moving targets.
+
+### 6. Attempted Solutions (for problems)
+Learn from what hasn't worked.
+
+**Questions:**
+- "What have you already tried, and why didn't it work?"
+- "What solutions have you considered but rejected?"
+- "What would the obvious solution be, and why isn't that good enough?"
+
+### 7. Audience & Stakeholders (for products/content)
+Understand who this serves.
+
+**Questions:**
+- "Who specifically will use this, and what's their context when they do?"
+- "What does your audience already know or believe about this?"
+- "Who might be negatively affected, and does that matter?"
+
+## Execution Protocol
+
+### Phase 1: Initial Assessment (1 turn)
+
+1. Parse the user's request
+2. Identify what's already clear from context
+3. Classify task type
+4. Select 3-5 most critical dimensions
+5. Note any immediate red flags or assumptions
+
+### Phase 2: Adaptive Questioning (3-7 turns)
+
+**Rules:**
+- Ask ONE question at a time
+- Make questions specific and decision-shaping, not generic
+- Challenge vague answers: "Can you be more specific about...?"
+- Acknowledge answers before next question
+- Skip dimensions already clarified
+- Stop when you have enough to create a clear brief
+
+**Question Sequencing:**
+1. Start with Real Objective (reveals the most)
+2. Follow with Constraints (narrows solution space)
+3. Then Success Criteria (defines done)
+4. Fill gaps with other dimensions as needed
+
+**Adaptive behavior:**
+- If user gives detailed answer → compress follow-ups
+- If user seems frustrated → summarize and ask if they want to continue
+- If contradiction detected → gently probe: "Earlier you mentioned X, but now Y—help me understand?"
+
+### Phase 3: Task Brief Synthesis (1 turn)
+
+After sufficient exploration, synthesize into a **Task Brief**:
+
+```
+## Task Brief
+
+**Objective:** [Clear statement of what we're actually solving]
+
+**Context:** [Relevant background and constraints]
+
+**Success Criteria:**
+- [Measurable criterion 1]
+- [Measurable criterion 2]
+
+**Constraints:**
+- [Hard constraint 1]
+- [Hard constraint 2]
+
+**Resources Available:** [What we can leverage]
+
+**Timeline:** [Deadline and urgency level]
+
+**Key Assumptions:** [Things we're assuming that could change the approach]
+
+**Out of Scope:** [Explicitly excluded items]
+```
+
+Ask user: "Does this capture what you need? Anything to add or correct?"
+
+### Phase 4: Handoff
+
+Once validated, either:
+- Proceed to solution (if user wants immediate help)
+- Export brief for later use
+- Suggest appropriate next steps/skills
+
+## Anti-Patterns to Avoid
+
+❌ **Interrogation mode:** Don't fire questions robotically
+❌ **Assuming context:** Don't skip clarification because you "think" you understand
+❌ **Premature solutions:** Don't hint at solutions before exploration is complete
+❌ **Over-questioning:** Stop when you have enough clarity
+❌ **Generic questions:** Each question should be tailored to this specific task
+❌ **Ignoring signals:** If user provides info proactively, don't re-ask
+
+## Example Flow
+
+**User:** "I want to create a dashboard for my team"
+
+**Claude (Phase 1 assessment):**
+- Task type: Product/Feature
+- Unclear: Who uses it, what data, what decisions it enables, timeline
+- Dimensions needed: Real Objective, Audience, Constraints, Success Criteria
+
+**Claude:** "Before we dive in—what decisions will your team make differently once they have this dashboard? What's the main insight they're missing today?"
+
+*[User answers about tracking project delays]*
+
+**Claude:** "Got it—so the core need is visibility into project health to catch delays early. How do you know a project is delayed today? What's the current process for catching these issues?"
+
+*[Continues adaptively based on answers...]*
+
+## Integration Notes
+
+After exploration, this skill can hand off to:
+- problem-solver-enhanced (for complex problems)
+- goap-research (for research tasks)
+- frontend-design (for UI/product tasks)
+- Any implementation skill with the structured Task Brief