@dzhechkov/skills-feature-adr 1.2.0 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dzhechkov/skills-feature-adr",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "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": {

package/src/commands/init.js

@@ -167,14 +167,21 @@ async function run(options) {
     installedFiles.push(...files);
   }
 
-  // ── e2) Install optional components ────────────────────────────────────
+  // ── e2) Install optional components — track which actually installed ──
+  // Components whose template source is missing return [] from installComponent;
+  // we must NOT record them in the manifest, otherwise `update` reports
+  // "Unknown component" on subsequent runs.
+  const installedOptionalKeys = [];
   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);
+    if (files.length > 0) {
+      installedFiles.push(...files);
+      installedOptionalKeys.push(key);
+    }
   }
 
   // ── f) Write manifest ──────────────────────────────────────────────────
@@ -182,13 +189,14 @@ async function run(options) {
   const pkg = readJSON(pkgPath);
   const version = pkg ? pkg.version : '0.0.0';
 
-  const allKeys = [...componentKeys, ...optionalKeys];
+  // Only manifest components whose templates were actually present on disk
+  const allKeys = [...componentKeys, ...installedOptionalKeys];
   const manifest = createManifest(version, allKeys, installedFiles.sort());
 
-  // Track optional features in manifest
+  // Track optional features in manifest based on actual installs
   manifest.optional = {
-    withLearning: optionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'learning'),
-    knowledgeExtractor: optionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'knowledge-extractor'),
+    withLearning: installedOptionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'learning'),
+    knowledgeExtractor: installedOptionalKeys.some((k) => OPTIONAL_COMPONENTS[k]?.group === 'knowledge-extractor'),
   };
 
   writeManifest(targetDir, manifest);
@@ -204,7 +212,7 @@ async function run(options) {
     const comp = COMPONENTS[key];
     console.log(`  ${green('\u2713')} ${comp.label}`);
   }
-  for (const key of optionalKeys) {
+  for (const key of installedOptionalKeys) {
     const comp = OPTIONAL_COMPONENTS[key];
     console.log(`  ${green('\u2713')} ${comp.label} ${yellow('[optional]')}`);
   }

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)',

package/templates/.claude/commands/harvest.md

@@ -0,0 +1,49 @@
+# Harvest — Ритуал извлечения знаний из проекта
+
+## Использование
+```
+/harvest [путь к директории или "all"] [only категория1,категория2]
+```
+
+## Аргумент
+$ARGUMENTS
+
+## Скилл
+
+```
+Read: .claude/skills/knowledge-extractor/SKILL.md
+```
+
+Загрузи knowledge-extractor skill и следуй его Pipeline Protocol.
+
+## Парсинг аргументов
+
+1. **Путь:** Первый аргумент — путь к директории исследования или `"all"` для всех директорий в `researches/`
+2. **Scope filter:** Если после пути есть `only X,Y` — передай как `{SCOPE_FILTER}` в skill
+   - Допустимые значения: `skills`, `commands`, `hooks`, `rules`, `templates`, `patterns`, `snippets`
+   - Множественные через запятую: `only rules,templates`
+3. Если аргументов нет — запроси путь у пользователя
+
+## Примеры
+
+```
+/harvest researches/bank-kc-automation/          ← полный harvest одной директории
+/harvest researches/bank-kc-automation/ only patterns  ← только паттерны
+/harvest all                                     ← все исследования
+/harvest all only rules,templates                ← все исследования, только правила и шаблоны
+/harvest features/add-user-auth/                 ← harvest фичи (не только исследования)
+```
+
+## Параллелизация
+
+Если путь = `"all"`:
+1. Получи список всех директорий в `researches/`
+2. Для каждой директории запусти отдельную harvest сессию
+3. Каждая сессия создаёт свой findings JSON и проходит полный pipeline
+4. По завершении всех сессий — объедини отчёты
+
+## Суть
+
+Систематический процесс извлечения и организации полезных знаний после завершения проекта. Использует 5 параллельных агентов-экстракторов, 7-категорийную классификацию, 8 блокирующих quality gates, и автоматическое размещение артефактов.
+
+Pipeline: Extract (5 agents) → Classify (7 categories) → User Checkpoint → Gate (8 checks) → Integrate (auto-place)

package/templates/.claude/rules/reward-learning.md

@@ -0,0 +1,124 @@
+# Reward Learning Rules
+
+## Purpose
+
+Govern how the Keysarium pipeline integrates with the Reward-Calibrated Learning System. These rules define when and how to call `memory_query()` and `memory_store()`, how reward scores are assigned, and how historical patterns influence phase execution.
+
+## Core Protocol
+
+Read `lib/memory-protocol.md` for the full protocol specification.
+Read `lib/reward-tracker.md` for analytics and pattern detection.
+
+## When to Call memory_query()
+
+**Trigger:** At the START of every pipeline phase (Phase 0 through Phase 5).
+
+**Protocol:**
+1. Before loading the phase's governance shard, check if `.keysarium/memory/` exists.
+2. If it exists, call `memory_query()` with the current context:
+   - `phase`: Current phase identifier (e.g., "phase-2")
+   - `domain`: Detected domain from Phase 0 (or "unknown" if Phase 0 has not run yet)
+   - `slug`: Current case slug
+   - `skill`: Skill about to be loaded for this phase
+3. Log the number of patterns loaded.
+4. If relevant patterns are found, incorporate the top 3 into the phase brief:
+   - Include high-reward approaches from similar past cases
+   - Apply actionable advice from domain patterns
+   - Note any bottleneck warnings for the current phase/domain combination
+5. If no patterns are found (first run or no relevant data), proceed normally.
+
+**Exception:** Phase 0 (Discovery) may not have a domain yet. Query with `domain: "unknown"` to load cross-domain patterns.
+
+## When to Call memory_store()
+
+**Trigger:** At every CHECKPOINT, after the user responds.
+
+**Protocol:**
+1. After displaying the checkpoint banner and receiving user response.
+2. Classify the user response into a reward level (see Reward Assignment below).
+3. Call `memory_store()` with:
+   - The phase result (artifacts created, promise tag emitted)
+   - The reward score and label
+   - Context metadata (upstream promises, patterns loaded, agent count)
+   - Outcome metadata (user response, iteration count)
+4. Log the stored reward.
+5. Continue with the checkpoint protocol as normal (proceed / adjust / redo).
+
+**Exception:** If the session ends without a user response at the checkpoint, do NOT store a record. Only explicit user responses generate reward data.
+
+## Reward Assignment
+
+Map the user's checkpoint response to a reward score:
+
+| User Response Pattern | Reward | Label | Examples |
+|----------------------|--------|-------|----------|
+| Immediate approval | 1.0 | excellent | "ok", "ок", "next", "продолжай", "good", single-word approval |
+| Minor adjustments | 0.7 | good | "углуби X", "expand section Y", "add one more competitor", feedback on 1 area |
+| Significant rework | 0.3 | needs_work | "rework the approach", "this misses the point of X and Y", feedback on 3+ areas |
+| Complete restart | 0.0 | failed | "start over", "this is wrong", "redo this phase completely" |
+
+### Classification Rules
+
+1. **Count the areas of feedback:** 0 areas = 1.0, 1 area = 0.7, 2+ areas = 0.3, full restart = 0.0
+2. **Positive feedback with minor note** counts as 1.0 (e.g., "great work, just fix the typo")
+3. **Multiple rounds:** If user gives feedback more than twice on the same phase, cap reward at 0.3
+4. **Ambiguous responses:** Default to 0.7 (assume minor adjustment)
+
+## Integration with Promise Tags
+
+Every `memory_store()` call includes the promise tag emitted at the checkpoint:
+
+| Phase | Promise Tag in Record |
+|-------|----------------------|
+| Phase 0 | `DISCOVERY_COMPLETE` |
+| Phase 1 | `CASE_EXPLORED` |
+| Phase 2 | `RESEARCH_PARANOID_PASSED` |
+| Phase 2.5 | `CJM_VALIDATED` |
+| Phase 3 | `SOLUTION_DESIGNED` |
+| Phase 4 | `ARCHITECTURE_DEFINED` |
+| Phase 5 | `PRESENTATION_READY` |
+
+If a promise is `_INCOMPLETE`, the reward should be 0.3 or lower.
+
+## Integration with Feedback Loops
+
+This system adds a new feedback loop to the Variable Registry (see `.claude/rules/feedback-loops.md`):
+
+### Loop 7: Memory -> All Phases
+
+| Property | Value |
+|----------|-------|
+| Direction | `.keysarium/memory/` -> Phase 0-5 start |
+| Variable | `{MEMORY_PATTERNS}` |
+| Payload | Top reward records + domain patterns from memory_query() |
+| Consumers | All phases (loaded at phase start) |
+| Persistence | `.keysarium/memory/{domain}/{slug}/` |
+
+**Contract:** `memory_query()` is called before each phase starts. Empty result is acceptable (first run).
+
+## Retention Policy
+
+- **Default:** 90 days from record creation
+- **Configuration:** Set in `.keysarium/memory/config.json` via `retention_days`
+- **Enforcement:** Expired records are purged during `memory_query()` calls
+- **Override:** Set `retention_days: 0` to disable expiration (keep forever)
+- **Manual purge:** Delete `.keysarium/memory/` directory to reset all memory
+
+## Error Handling
+
+| Situation | Behavior |
+|-----------|----------|
+| `.keysarium/memory/` does not exist | `memory_query()` returns empty; `memory_store()` creates it |
+| `config.json` missing | Use defaults (90 days, 10 max results, enabled) |
+| Corrupted JSON file during query | Skip file, log warning, continue with other records |
+| Write failure during store | Log error, continue pipeline (memory is non-blocking) |
+| Unknown domain | Store under `unknown/` directory |
+
+## Rules Summary
+
+1. **ALWAYS** call `memory_query()` at the start of every phase
+2. **ALWAYS** call `memory_store()` at every checkpoint after user responds
+3. **NEVER** block the pipeline if memory operations fail
+4. **NEVER** store a record without an explicit user response
+5. **ALWAYS** log memory operations (patterns loaded, reward stored)
+6. Memory operations are **advisory** -- they enhance quality but are not mandatory gates

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

package/templates/.claude/skills/explore/references/questioning-techniques.md

@@ -0,0 +1,151 @@
+# Advanced Questioning Techniques
+
+Reference for sophisticated question patterns when standard approaches don't yield clarity.
+
+## Socratic Techniques
+
+### Clarifying Questions
+When answers are vague or use undefined terms:
+- "What do you mean by [term]?"
+- "Can you give me a specific example of [concept]?"
+- "How would you explain this to someone unfamiliar with your context?"
+
+### Assumption Probing
+When hidden assumptions might be distorting the problem:
+- "What would have to be true for this approach to work?"
+- "What are you taking for granted here that might not be true?"
+- "If you were wrong about [assumption], how would that change things?"
+
+### Consequence Exploration
+When second-order effects matter:
+- "If this succeeds, what problems might it create?"
+- "Who might be affected that we haven't considered?"
+- "What's the worst realistic outcome if this goes wrong?"
+
+### Perspective Shifting
+When stuck in one frame:
+- "How would [competitor/user/skeptic] view this?"
+- "If you had to argue against this approach, what would you say?"
+- "What would you advise someone else in this situation?"
+
+## Techniques for Specific Blockers
+
+### When user presents solution as requirement
+"I need a mobile app for X"
+
+**Approach:** Trace back to underlying need
+- "What problem would the mobile app solve?"
+- "How do users handle this today without the app?"
+- "If a mobile app wasn't an option, how else might you solve this?"
+
+### When user can't articulate success
+"I'll know it when I see it"
+
+**Approach:** Use concrete scenarios
+- "Imagine it's 6 months from now and this was a huge success—describe what's happening"
+- "If you had to bet money on one metric improving, what would it be?"
+- "What would your boss/customer/user say that would prove this worked?"
+
+### When constraints seem impossible
+"We need enterprise features but have startup budget"
+
+**Approach:** Separate hard from soft constraints
+- "If you had to prioritize: which constraint is truly immovable?"
+- "What's the minimum viable version that would still be valuable?"
+- "What could you trade off to make this feasible?"
+
+### When user is emotionally invested
+User seems attached to a specific solution
+
+**Approach:** Validate, then explore
+- "It sounds like you've thought about this a lot. What led you to this approach?"
+- "What would make you reconsider this direction?"
+- "What's the strongest argument against this that you've heard?"
+
+### When multiple stakeholders with conflicting needs
+"My boss wants X but users want Y"
+
+**Approach:** Map the conflict explicitly
+- "Let's map out who wants what. What does your boss's ideal outcome look like?"
+- "Where exactly do these needs conflict?"
+- "Is there a version that gives each party their most important thing?"
+
+## Question Formulation Patterns
+
+### The Magic Wand
+Removes artificial constraints to reveal true desires:
+"If you could wave a magic wand and have any outcome, what would you choose?"
+
+### The Premortem
+Surfaces hidden risks:
+"Imagine this failed spectacularly—what went wrong?"
+
+### The Constraint Inversion
+Challenges assumptions about limitations:
+"What if [constraint] wasn't a factor—would you approach this differently?"
+
+### The Minimum Viable Success
+Defines the essential core:
+"What's the smallest version of this that would still be valuable?"
+
+### The Regret Test
+Clarifies priorities over time:
+"In a year, what would you regret not having done?"
+
+### The Opportunity Cost
+Reveals trade-offs:
+"What else could you do with the time/money/effort this would require?"
+
+### The Outsider View
+Escapes insider bias:
+"How would you explain this problem to someone completely outside your industry?"
+
+## Red Flags and Responses
+
+| Red Flag | What It Might Mean | How to Probe |
+|----------|-------------------|--------------|
+| "Everyone knows..." | Unexamined assumption | "Help me understand—what's the evidence for this?" |
+| "We've always done it this way" | Inertia, not strategy | "What originally drove this approach? Is that still true?" |
+| "It's obvious that..." | Blind spot | "Walk me through why this is obvious—I want to make sure I understand" |
+| "We just need to..." | Oversimplification | "What could go wrong with this approach?" |
+| "ASAP" | Artificial urgency | "What specifically happens if this takes longer?" |
+| No constraints mentioned | Hidden constraints | "What would disqualify a solution even if it technically works?" |
+| Very specific solution stated | Solution fixation | "What problem does this solve? Are there other ways to solve it?" |
+
+## Calibrating Question Depth
+
+### Light Touch (1-2 questions per dimension)
+Use when:
+- User is experienced and already has clarity
+- Task is straightforward
+- Time is genuinely constrained
+- User shows frustration
+
+### Deep Exploration (3-5 questions per dimension)
+Use when:
+- High stakes decision
+- Multiple stakeholders
+- Technical complexity
+- User seems uncertain
+- Contradictions in answers
+
+### Signs to Stop Questioning
+- User is repeating themselves
+- Answers are becoming terse
+- You have enough for a clear brief
+- User explicitly says "that's enough"
+- Remaining questions are nice-to-know, not need-to-know
+
+## Cultural Considerations
+
+Some users may:
+- View detailed questions as distrust
+- Expect to define solutions themselves
+- Be uncomfortable with "why" questions
+- Prefer to give context incrementally
+
+**Adaptive responses:**
+- Frame questions as "helping me help you better"
+- Acknowledge their expertise: "You know this space—help me understand..."
+- Use "what" instead of "why" when appropriate
+- Offer to explain why you're asking