docs: complete Wasp fullstack essentials integration

Complete all 4 action items from wasp-fullstack-essentials-eval.md resource evaluation (score 3/5). Framework-agnostic insights only, promotional content excluded. Changes (3 sections): 1. Background tasks workflow (Section 9.5) - New subsection: "Background Tasks for Fullstack Development" - When to background tasks (5 scenarios table) - Fullstack workflow pattern with examples - Context rot prevention strategies - Limitations and workarounds - Integration with teleportation - /tasks monitoring guide - ~100 lines added to Section 9.5 "Tight Feedback Loops" 2. Chrome DevTools MCP (mcp-servers-ecosystem.md) - New server entry in "Browser Automation" section - Official Anthropic server (not community) - Comparison table vs Playwright MCP (debugging vs testing) - Setup and configuration - Use cases and limitations - Updated stats: 3 browser servers (was 2), 6 official servers (was 5) - ~60 lines added to Browser Automation section 3. Convention-over-config for AI (Section 9.18.1) - New subsection: "Convention-Over-Configuration for AI Agents" - Why opinionated frameworks reduce agent cognitive load - Comparison table: custom vs opinionated architectures - Examples: Next.js, Rails, Phoenix, Django - Real-world impact on agent productivity - Trade-offs analysis - Connection to CLAUDE.md sizing (token reduction) - ~60 lines added to Section 9.18.1 Total additions: ~220 lines (workflow patterns + MCP server + AX framework) Source evaluation: docs/resource-evaluations/wasp-fullstack-essentials-eval.md Primary sources: llmstxt.org (llms.txt), official docs (background tasks, Chrome DevTools MCP), existing Section 9.18 (Marmelab/AX framework) Related commits: - 783c43b: llms.txt conceptual documentation (completed earlier) Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>
2026-02-09 10:00:53 +01:00 · 2026-02-09 10:00:53 +01:00 · 17846b1179
commit 17846b1179
parent 783c43baed
9 changed files with 871 additions and 6 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -8,6 +8,80 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).

 ### Added

+- **Opus 4.6 Integration**: Comprehensive documentation update for Claude Opus 4.6 features (Feb 2026)
+  - **Adaptive Thinking**: Replaced budget-based thinking with dynamic depth calibration
+    - Effort parameter: `low|medium|high|max` (API only, default: high)
+    - API syntax: `thinking: {"type": "adaptive", "effort": "high"}`
+    - CLI: Same Alt+T toggle (no per-request control)
+    - Deprecation: `budget_tokens` no longer functional on Opus 4.6
+    - Section: Extended Thinking (line 9911), API Breaking Changes (line 10044)
+  - **Fast Mode** (`/fast` command, v2.1.36+): 2.5x faster responses, 6x price
+    - CLI: `/fast` command (toggle, persists across sessions)
+    - API: `speed: "fast"` + beta header `fast-mode-2026-02-01`
+    - Pricing: $30/$150 per 1M tokens (vs $5/$25 standard)
+    - Added to Commands Table (line 16279), Pricing Model (line 1722)
+  - **Pricing Tiers**: Updated pricing table with Opus 4.6 three-tier model
+    - Standard: $5/$25 per 1M tokens (200K context)
+    - 1M Context Beta: $10/$37.50 per 1M tokens (requests >200K)
+    - Fast Mode: $30/$150 per 1M tokens (2.5x speed)
+  - **API Breaking Changes**: Documented removed and deprecated features
+    - `assistant-prefill` removed (use system prompts instead)
+    - `budget_tokens` deprecated (use adaptive thinking)
+- **Auto-Memories** (v2.1.32+): Automatic context capture across sessions
+  - Opt-in feature, per-project storage
+  - Automatically identifies: decisions, preferences, patterns, known issues
+  - Separate from CLAUDE.md (personal vs team-level)
+  - Comparative table: CLAUDE.md vs auto-memories (line 3999)
+  - Section: Memory Files (line 3986)
+- **Context Management**: "Summarize from here" feature (v2.1.32+)
+  - Right-click message → summarize from that point forward
+  - More precise than full `/compact`
+  - Added to Context Recovery Strategies (line 1470)
+- **Debug Command** (`/debug`, v2.1.30+): Systematic troubleshooting
+  - Added to Commands Table (line 16280)
+  - Purpose: Error investigation and debugging workflows
+- **Agent Teams Enhancements** (v2.1.32+)
+  - Hook events: `TeammateIdle` and `TaskCompleted` in events table (line 6972)
+  - Agent frontmatter: `memory` field for pre-populated context (line 4849)
+  - Enables persistent agent context without repeating project details
+- **Xcode Integration** (Feb 2026): Native Claude Agent SDK support
+  - Xcode 26.3 RC+ includes built-in Claude assistant
+  - Same harness as Claude Code CLI
+  - Section: IDE Integration (line 10834)
+  - Clarified: Claude Agent SDK ≠ Claude Code (shared framework, different products)
+- **machine-readable/reference.yaml**: 24 new entries
+  - Auto-memories, fast mode, debug command, Opus 4.6 features
+  - Hook events (TeammateIdle, TaskCompleted)
+  - Agent memory field, Xcode integration, adaptive thinking
+  - Updated: 2026-02-09
+
+### Changed
+
+- **Pricing Model**: Updated default model from "Sonnet 3.5" to "Sonnet 4.5" (line 1720)
+- **Model References**: 8 mentions "Opus 4.5" updated to "Opus 4.6" or context-appropriate version
+  - Status line example, Trinity pattern description, TDD workflow, benchmarks
+- **Comparative Tools Table**: Corrected PowerPoint capability
+  - Before: "No PPTX output capability"
+  - After: "Limited PPTX (via Claude in PowerPoint add-in, research preview)"
+  - Note: Claude in PowerPoint exists but limited to add-in (line 17251)
+
+### Security
+
+- **CVE Update**: Added Claude Code v2.1.34 security fix to security-hardening.md
+  - Critical sandbox bypass vulnerability patched
+  - Recommendation: **Upgrade to v2.1.34+ immediately**
+  - Details undisclosed pending broader adoption
+  - Added to CVE Summary table (guide/security-hardening.md)
+
+### Documentation
+
+- **Fact-Checking**: All Opus 4.6 details verified via Perplexity Pro
+  - Pricing confirmed: $5/$25 (standard), $10/$37.50 (1M), $30/$150 (fast)
+  - Adaptive thinking syntax validated: effort parameter, API examples
+  - Fast mode behavior confirmed: 2.5x speed, 6x cost, persistent toggle
+  - Auto-memories verified: opt-in, per-project, cross-session recall
+  - Sources: Anthropic official docs, pricepertoken.com, eesel.ai, help.apiyi.com
+
 - **Templates**: Session handoff template based on Robin Lorenz's context engineering approach
  - Structured handoff at 85% context to prevent auto-compact degradation
  - Research-backed rationale (LLM performance drop 50-70% at high context)
--- a/docs/resource-evaluations/om-nalinde-30-concepts-infographic.md
+++ b/docs/resource-evaluations/om-nalinde-30-concepts-infographic.md
@ -0,0 +1,167 @@
+# Resource Evaluation: "30 Claude Code Concepts" - Om Nalinde (LinkedIn)
+
+**URL**: https://www.linkedin.com/posts/that-aum_if-youre-just-getting-started-with-claude-activity-7425498761629601792-nyO6
+**Date de publication**: 6 février 2026
+**Auteur**: Om Nalinde (LinkedIn)
+**Format**: Infographic visuelle (30 cartes, grid 5x6)
+**Engagement**: 731 likes, 61 commentaires
+**Date d'évaluation**: 9 février 2026
+
+---
+
+## Score: 2/5 (Marginal)
+
+**Justification**: Glossaire visuel de 30 concepts Claude Code sans profondeur technique. Le guide couvre déjà 22/30 concepts en détail. Aucune information nouvelle intégrable, aucun code, aucun workflow. Erreur factuelle sur "Slack Integration". Auteur non vérifié techniquement.
+
+---
+
+## Résumé du contenu
+
+- Infographic "cheat sheet" listant 30 concepts en 5 catégories:
+  - **Core** (6): Claude Code, CLI, CLAUDE.md, Context, Compaction, Checkpoints
+  - **Configuration** (6): Permissions, MCP, Tool Use, Commands, Plan Mode, Background Tasks
+  - **Extensibility** (6): Subagents, Hooks, Skills, Plugins, Agent SDK, Worktrees
+  - **Integration** (6): VS Code, JetBrains, GitHub Actions, Chrome, Slack, Headless
+  - **Features** (6): Inline Diffs, @Mentions, LSP, Model Selection, Ultrathink, Settings
+- Chaque concept = 1 titre + 1 description d'une ligne (~15 mots)
+- Post texte promet un guide "100 Pro Hacks" à venir
+- Format visuel attrayant, zéro code, zéro profondeur technique
+
+---
+
+## Comparatif avec le guide
+
+| Concept | Infographic | Guide actuel | Gap? |
+|---------|-------------|--------------|------|
+| **Core (6)** | 1 ligne/concept | Sections dédiées (centaines de lignes) | ❌ |
+| **Configuration (6)** | 1 ligne/concept | Sections dédiées + exemples | ❌ |
+| **Extensibility (6)** | 1 ligne/concept | Sections dédiées + templates | ❌ |
+| **Background Tasks** | 1 ligne | Références dispersées, pas de section | ✅ PARTIAL |
+| **Agent SDK** | 1 ligne | Mention Xcode uniquement | ✅ PARTIAL |
+| **VS Code/JetBrains** | 1 ligne chacun | 5-6 lignes chacun | ✅ PARTIAL |
+| **Chrome** | 1 ligne | 1 ligne | ❌ |
+| **Slack** | 1 ligne | ABSENT (mais info inexacte) | ⚠️ |
+| **Headless** | 1 ligne | Bien documenté | ❌ |
+| **LSP Support** | 1 ligne | BARELY mentionné | ✅ PARTIAL |
+| **@Mentions** | 1 ligne | Présent dans tables, pas de section | ✅ PARTIAL |
+| **Inline Diffs** | 1 ligne | BARELY mentionné | ✅ PARTIAL |
+| **Worktrees/Ultrathink/Settings** | 1 ligne chacun | Bien documentés | ❌ |
+
+**Couverture**: 22/30 concepts déjà bien documentés dans le guide.
+
+---
+
+## Fact-Check
+
+| Affirmation | Vérifiée? | Source |
+|-------------|-----------|--------|
+| "Claude in Chrome - Browser extension for live debugging" | ✅ | v2.0.72 Beta (claude-code-releases.yaml:313) |
+| "Slack Integration - Mention Claude in Slack for PRs" | ❌ **INEXACT** | MCP server Slack existe (v2.1.13) mais PAS de feature native "@claude dans Slack". L'infographic confond MCP server avec integration native type GitHub. |
+| "Agent SDK - Dev toolkit to build custom agents" | ✅ | Produit Anthropic séparé (TypeScript/Python), distinct de Claude Code |
+| "Plugins - Bundled packages you can install" | ✅ | Plugin system documenté (v2.1.x) |
+| "Background Tasks - Long-running processes" | ✅ | Feature existante (Ctrl+B, /tasks) |
+| "LSP Support - Go-to-definition, find references" | ✅ | Ajouté dans v2.0.74 (releases:328) |
+| "Inline Diffs - Visual side-by-side display" | ✅ | Feature IDE extensions |
+
+**Erreur factuelle**: "Slack Integration" tel que décrit n'existe pas dans Claude Code. Il existe un MCP server Slack (OAuth, channels), mais ce n'est PAS la même chose qu'une intégration native permettant de "@claude" dans Slack pour des PRs.
+
+---
+
+## Valeur ajoutée
+
+**Pour utilisateurs débutants**:
+- Format visuel attrayant comme point d'entrée
+- Liste des 30 concepts principaux en un coup d'œil
+- Peut servir de checklist "ai-je exploré ce concept?"
+
+**Pour le guide**:
+- ❌ Aucune information technique nouvelle
+- ❌ Aucun code, workflow, ou exemple intégrable
+- ❌ Profondeur nulle (1 ligne par concept)
+- ⚠️ Erreur factuelle sur Slack réduit la crédibilité
+
+**Gaps identifiés** (indépendants de cette ressource):
+
+L'analyse a révélé 8 concepts sous-couverts dans le guide:
+
+| # | Gap | Priorité | Justification |
+|---|-----|----------|---------------|
+| 1 | Background Tasks (section dédiée) | **Haute** | Feature officielle, références dispersées, aucune section dédiée |
+| 2 | IDE Extensions (VS Code + JetBrains) | **Haute** | 5-6 lignes chacun pour des surfaces d'intégration majeures |
+| 3 | LSP Support | **Moyenne** | Feature v2.0.74, pas de section dans le guide |
+| 4 | Agent SDK | **Moyenne** | Produit séparé, mérite clarification vs Claude Code |
+| 5 | @Mentions (@path) | **Moyenne** | Présent dans tables mais pas de section dédiée |
+| 6 | Claude in Chrome | **Moyenne** | Beta v2.0.72, 1 seule ligne dans le guide |
+| 7 | Inline Diffs | **Basse** | Feature UI implicite, pas critique |
+| 8 | GitHub @claude mentions | **Basse** | Feature distincte du CI/CD headless déjà documenté |
+
+**Note**: Ces gaps sont des **lacunes du guide à traiter séparément**, pas de la valeur apportée par cette infographic.
+
+---
+
+## Challenge technique
+
+**Points soulevés par technical-writer**:
+
+1. **Argument pour 1/5**:
+   - Contenu = repackaging de 30 termes sans profondeur
+   - Aucune valeur intégrable
+   - Erreur Slack réduit crédibilité
+   - Auteur non vérifié techniquement
+
+2. **Argument pour 3/5**:
+   - Aucun argument solide trouvé
+   - L'engagement (731 likes) ne valide pas la profondeur technique
+   - Pas de credentials vérifiées (contrairement à Wooldridge qui a été bumped 2→3)
+
+3. **Angle mort identifié**:
+   - L'engagement élevé signale une **demande pour du contenu entry-level/visuel**, pas une validation de qualité technique
+
+**Score ajusté**: 2/5 (inchangé)
+
+---
+
+## Crédibilité de l'auteur
+
+**Om Nalinde** (LinkedIn @that-aum):
+- ❌ Pas de credentials techniques vérifiables via Perplexity
+- ❌ Pas de contributions open-source identifiables
+- ❌ Pas d'expertise Claude Code démontrée
+- ✅ Engagement élevé sur LinkedIn (731 likes)
+- ⚠️ Promet un "100 Pro Hacks" guide à venir (non publié à ce jour)
+
+**Comparaison**:
+- Wooldridge (score 3/5): PhD + livre publié + credentials vérifiées
+- Om Nalinde (score 2/5): Engagement LinkedIn uniquement
+
+---
+
+## Décision finale
+
+**Action**: Ne pas intégrer
+
+**Raisons**:
+1. Aucune information technique nouvelle
+2. Couverture déjà existante pour 22/30 concepts
+3. Erreur factuelle sur Slack Integration
+4. Format glossaire non compatible avec la profondeur du guide
+5. Auteur non vérifié techniquement
+
+**Actions dérivées**:
+- ✅ Tracer les 8 gaps identifiés comme améliorations futures (indépendamment de cette ressource)
+- ✅ Considérer la création d'une infographic officielle basée sur le guide (format visuel demandé par la communauté)
+
+**Confiance**: Haute (contenu vérifié, challenge effectué, fact-check complet)
+
+---
+
+## Métadonnées
+
+- **Evaluateur**: Claude Sonnet 4.5 (via research + technical-writer challenge)
+- **Méthode**: Comparative analysis + fact-check (claude-code-releases.yaml) + challenge
+- **Sources**: LinkedIn post, claude-code-releases.yaml, Perplexity research
+- **Version du guide**: 3.9.9
+- **Fichiers consultés**:
+  - `machine-readable/claude-code-releases.yaml`
+  - `guide/ultimate-guide.md`
+  - `docs/resource-evaluations/README.md`
--- a/docs/resource-evaluations/weller-session-migration-skill.md
+++ b/docs/resource-evaluations/weller-session-migration-skill.md
@ -0,0 +1,209 @@
+# Resource Evaluation: claude-migrate-session Skill
+
+**Author**: Jim Weller (inspired by Alexis Laporte)
+**Type**: Community Skill
+**Date Evaluated**: 2026-02-09
+**Evaluator**: Claude Code Ultimate Guide Team
+**Score**: 3/5 (Pertinent - Complément utile)
+
+---
+
+## Executive Summary
+
+A bash skill that automates cross-folder session migration for Claude Code. Addresses a real gap (GitHub issue #1516) but has zero community adoption. Manual filesystem operations are safer and recommended over this automation tool.
+
+---
+
+## Source Information
+
+| Field | Value |
+|-------|-------|
+| **LinkedIn Post** | https://www.linkedin.com/posts/jwweller_claude-code-skill-that-clones-a-claude-session-activity-7426010179659309056-ZaUH |
+| **GitHub Repository** | https://github.com/jimweller/dotfiles/tree/main/dotfiles/claude-code/skills/claude-migrate-session |
+| **Publication Date** | February 2026 |
+| **Last Updated** | February 2026 |
+| **License** | Not specified (personal dotfiles) |
+| **Stars/Forks** | 0/0 (as of 2026-02-09) |
+| **Issues/PRs** | 0/0 |
+
+---
+
+## What It Does
+
+**Problem solved**: Native `--resume` command is limited to the current working directory. When you move a project or want to fork a session to a new folder, the session becomes inaccessible.
+
+**Solution provided**:
+1. **Global search**: Finds sessions across all projects with keyword filtering
+2. **Interactive selection**: Filters results, excludes current directory sessions
+3. **Automated migration**: Copies `.jsonl` + subagents directory, generates new UUID
+4. **Resume command**: Provides `claude --resume <new-id>` for immediate use
+
+**Technical implementation**:
+- Uses ripgrep for performance
+- Filtering support (`cleanupPeriodDays: 90` for large histories)
+- Bash scripts: `search.sh` + `migrate.sh`
+- Command syntax: `/claude-migrate-session <source> <target>`
+
+---
+
+## Evaluation Criteria
+
+### 1. Accuracy (4/5)
+
+**Strengths**:
+- ✅ Correctly identifies the architectural limitation (CWD-scoped sessions)
+- ✅ Preserves full context (`.jsonl` + subagents)
+- ✅ Generates independent copies (new UUID)
+
+**Weaknesses**:
+- ⚠️ No explicit handling of hardcoded paths in session context
+- ⚠️ No validation of MCP server compatibility
+- ⚠️ No warning about secrets in `.jsonl` files
+
+### 2. Relevance (3/5)
+
+**Confirmed gap**: GitHub issue #1516 documents community requests for cross-folder resume.
+
+**But**:
+- Niche use case (estimated 1-5% of users)
+- Alternative manual approach is trivial (`mv ~/.claude/projects/...`)
+- Zero adoption (0 stars/forks) suggests limited real-world demand
+
+### 3. Completeness (2/5)
+
+**Missing critical elements**:
+- ❌ No error handling examples
+- ❌ No edge case documentation (secrets, paths, MCP mismatches)
+- ❌ No testing strategy or test results
+- ❌ No security considerations
+- ❌ No rollback mechanism
+
+### 4. Quality (3/5)
+
+**Code quality**: Clean bash implementation, uses standard tools (ripgrep).
+
+**Documentation quality**:
+- ✅ Clear 4-step workflow explanation
+- ⚠️ Minimal usage examples
+- ❌ No troubleshooting guide
+- ❌ No comparison with manual approach
+
+### 5. Practicality (2/5)
+
+**Barriers to adoption**:
+- Requires installation from personal dotfiles (not a standard package)
+- No community validation (0 usage stats)
+- Manual approach is simpler and safer for most cases
+
+**When it makes sense**:
+- Frequent session forking workflows
+- Large session histories (ripgrep optimization beneficial)
+- Automation preference over manual control
+
+---
+
+## Comparative Analysis
+
+| Aspect | Weller Skill | Manual Approach | Claude Guide |
+|--------|--------------|-----------------|--------------|
+| **Cross-folder migration** | ✅ Automated | ✅ Manual (30 sec) | ❌ Not documented |
+| **Complexity** | ⚠️ Requires skill install | ✅ Zero dependencies | N/A |
+| **Safety** | ⚠️ Untested edge cases | ✅ Explicit control | N/A |
+| **Adoption** | ❌ 0 stars/forks | ✅ Native filesystem ops | N/A |
+| **Maintenance** | ⚠️ Personal repo | ✅ Self-maintained | N/A |
+
+---
+
+## Integration Decision
+
+**Integrated as**: Section addition in `guide/observability.md`
+
+**Rationale**:
+1. **Gap confirmed**: GitHub issue #1516 validates the problem
+2. **Manual approach prioritized**: Safer, simpler, zero dependencies
+3. **Community tool mentioned**: Attribution with honest caveats (0 adoption)
+4. **Risks documented**: Secrets, paths, MCP mismatches explicitly warned
+
+**Placement**: `guide/observability.md` § "Session Resume Limitations & Cross-Folder Migration" (40 lines)
+
+**Priority**: P2 (Important, not urgent) - integrate after critical guide updates
+
+---
+
+## Fact-Check Results
+
+| Claim | Verified | Source |
+|-------|----------|--------|
+| "Clones sessions cross-folder" | ✅ | SKILL.md + LinkedIn post |
+| "Inspired by Alexis Laporte" | ✅ | LinkedIn post attribution |
+| "Uses ripgrep for performance" | ✅ | LinkedIn post |
+| "cleanupPeriodDays: 90" | ✅ | LinkedIn post |
+| "14 likes, 3 comments" | ✅ | LinkedIn engagement metrics |
+| "GitHub issue #1516 exists" | ✅ | Perplexity search confirmed |
+| "0 stars/forks" | ✅ | GitHub repo metadata |
+| "Widely adopted" | ❌ | Contradicted by 0 stars/forks |
+
+---
+
+## Risks of Non-Integration
+
+**Low risk**:
+- 95%+ users won't need cross-folder migration (based on use case analysis)
+- Manual workaround exists and is well-documented in community discussions
+- No significant community pressure (minimal GitHub issue activity)
+
+**Opportunity cost of NOT integrating**:
+- Users facing this niche issue would discover manual solution via web search anyway
+- Guide completeness improved marginally (covers 1-5% more use cases)
+
+---
+
+## Technical Writer Challenge Results
+
+**Initial score**: 4/5
+**Challenged score**: 3/5 (adjusted down)
+
+**Key corrections**:
+- Adoption metrics (0 stars/forks) reduce score
+- Alternative manual approach is simpler → reduces uniqueness value
+- Edge cases and risks not addressed by skill → reduces quality score
+- Niche use case (1-5%) → reduces overall relevance
+
+**Integration recommendation refined**:
+- From: "200-300 line workflow + skill template"
+- To: "40-line section with manual approach + skill mention"
+
+---
+
+## Recommendations
+
+### For Guide Maintainers
+
+1. **Document manual approach first** (recommended solution)
+2. **Mention community skill** (attribution + honest caveats)
+3. **Warn about risks** (secrets, paths, MCP mismatches)
+4. **Link GitHub issue #1516** (feature request tracking)
+
+### For Users
+
+1. **Prefer manual approach** for safety and control
+2. **Test skill thoroughly** before production use (0 community validation)
+3. **Audit `.jsonl` files** for secrets before migration
+4. **Verify MCP compatibility** between source and target projects
+
+### For Skill Author (Jim Weller)
+
+1. **Add comprehensive testing** (edge cases, different project types)
+2. **Document security considerations** (secrets, credentials handling)
+3. **Provide rollback mechanism** (undo failed migrations)
+4. **Consider submitting to Claude Code official skills** for broader visibility
+
+---
+
+## Conclusion
+
+**Score: 3/5** - Addresses a real but niche gap with minimal adoption. Manual approach is safer and simpler for most users. Integration as lightweight documentation (40 lines) is appropriate given the use case frequency and lack of community validation.
+
+**Action**: Integrated in `guide/observability.md` with manual approach prioritized and community tool mentioned with caveats.
+
+**Confidence**: High (based on GitHub issue confirmation, Perplexity search validation, and repository inspection)
--- a/guide/architecture.md
+++ b/guide/architecture.md
@ -1063,6 +1063,7 @@ Since v2.1.7 (January 2026), Claude Code uses **lazy loading** for MCP tool defi
 | Token overhead (5-server setup) | ~55K | ~8.7K | **85% reduction** |
 | Opus 4 tool selection accuracy | 49% | 74% | +25 points |
 | Opus 4.5 tool selection accuracy | 79.5% | 88.1% | +8.6 points |
+| Opus 4.6 adaptive thinking | N/A | Auto-calibrated | Dynamic depth |

 **Configuration** (v2.1.9+):

--- a/guide/mcp-servers-ecosystem.md
+++ b/guide/mcp-servers-ecosystem.md
@ -415,6 +415,63 @@ npm install @browserbasehq/mcp-server-browserbase

 ---

+#### Chrome DevTools MCP
+
+**Official Anthropic server** for Chrome DevTools Protocol integration. Provides debugging and inspection capabilities via Chrome's native DevTools APIs.
+
+**Use Case**: Debugging web applications, inspecting runtime state, monitoring network requests, and analyzing performance. Complements Playwright MCP (testing) with development-focused debugging capabilities.
+
+**Key Features**:
+
+| Capability | Details |
+|------------|---------|
+| Console Access | Read browser console logs, errors, warnings |
+| Network Monitor | Inspect HTTP requests, responses, headers |
+| DOM Inspection | Query DOM structure, element properties |
+| JavaScript Execution | Execute arbitrary JS in page context |
+| Performance Profiling | CPU profiles, memory snapshots |
+
+**Setup**:
+
+```bash
+npm install @modelcontextprotocol/server-chrome-devtools
+```
+
+**Configuration**:
+
+```json
+{
+  "mcpServers": {
+    "chrome-devtools": {
+      "command": "npx",
+      "args": ["@modelcontextprotocol/server-chrome-devtools"]
+    }
+  }
+}
+```
+
+**When to Use**:
+
+| Scenario | Use Chrome DevTools MCP | Use Playwright MCP |
+|----------|------------------------|-------------------|
+| Debug runtime errors | ✅ Console logs, stack traces | ❌ Limited error visibility |
+| Inspect network calls | ✅ Full request/response details | ⚠️ Basic navigation only |
+| Test user interactions | ❌ Not designed for testing | ✅ Click, type, navigate |
+| Profile performance | ✅ CPU/memory profiling | ❌ No profiling tools |
+| Automate workflows | ❌ Manual debugging focus | ✅ E2E test automation |
+
+**Limitations**:
+- Requires Chrome browser running with DevTools Protocol enabled
+- Manual setup (launch Chrome with `--remote-debugging-port`)
+- Not suitable for automated testing (use Playwright for that)
+- Performance overhead when profiling enabled
+
+**Resources**:
+- **npm**: https://www.npmjs.com/package/@modelcontextprotocol/server-chrome-devtools
+- **Chrome DevTools Protocol**: https://chromedevtools.github.io/devtools-protocol/
+
+---
+
 ### DevOps & Infrastructure

 #### Kubernetes MCP (Red Hat)
@ -1043,7 +1100,7 @@ Servers evaluated but not included in the validated list:

 | Category | Servers | Use Cases |
 |----------|---------|-----------|
-| **Browser Automation** | 2 (Playwright, Browserbase) | Testing, data extraction, web scraping |
+| **Browser Automation** | 3 (Playwright, Browserbase, Chrome DevTools) | Testing, debugging, data extraction |
 | **DevOps/Infrastructure** | 2 (Vercel, Kubernetes) | Deployment, cluster management |
 | **Security/Code Analysis** | 1 (Semgrep) | Vulnerability scanning, secure coding |
 | **Documentation/Knowledge** | 1 (Context7) | API reference, code examples |
@ -1052,7 +1109,7 @@ Servers evaluated but not included in the validated list:

 ### Maintainer Types

- **Official Servers** (5): Playwright (Microsoft), Browserbase, Semgrep, Context7, Kubernetes (Red Hat)
+- **Official Servers** (6): Playwright (Microsoft), Browserbase, Semgrep, Context7, Kubernetes (Red Hat), Chrome DevTools (Anthropic)
 - **Community Servers** (3): Linear, Vercel, MCP-Compose (well-designed, actively maintained)

 ---
--- a/guide/observability.md
+++ b/guide/observability.md
@ -114,6 +114,95 @@ See [session-search.sh](../examples/scripts/session-search.sh) for the complete

 ---

+### Session Resume Limitations & Cross-Folder Migration
+
+**TL;DR**: Native `--resume` is limited to the current working directory by design. For cross-folder migration, use manual filesystem operations (recommended) or community automation tools (untested).
+
+#### Why Resume is Directory-Scoped
+
+Claude Code stores sessions at `~/.claude/projects/<encoded-path>/` where `<encoded-path>` is derived from your project's absolute path. For example:
+- Project at `/home/user/myapp` → Sessions in `~/.claude/projects/-home-user-myapp-/`
+- Project moved to `/home/user/projects/myapp` → Claude looks for `~/.claude/projects/-home-user-projects-myapp-/` (different directory)
+
+**Design rationale**: Sessions store absolute file paths, project-specific context (MCP server configs, `.claudeignore` rules, environment variables). Cross-folder resume would require path rewriting and context validation, which isn't implemented yet.
+
+**Related**: GitHub issue [#1516](https://github.com/anthropics/claude-code/issues/1516) tracks community requests for native cross-folder support.
+
+#### Manual Migration (Recommended)
+
+**When moving a project folder:**
+
+```bash
+# Before moving project
+cd ~/.claude/projects/
+ls -la  # Note the current encoded path
+
+# Move your project
+mv /old/location/myapp /new/location/myapp
+
+# Rename session directory to match new path
+cd ~/.claude/projects/
+mv -- -old-location-myapp- -new-location-myapp-
+
+# Verify
+cd /new/location/myapp
+claude --continue  # Should resume successfully
+```
+
+**When forking sessions to a new project:**
+
+```bash
+# Copy session files (preserves original)
+cd ~/.claude/projects/
+cp -n ./-source-project-/*.jsonl ./-target-project-/
+
+# Copy subagents directory if exists
+if [ -d ./-source-project-/subagents ]; then
+  cp -r ./-source-project-/subagents ./-target-project-/
+fi
+
+# Resume in target project
+cd /path/to/target/project
+claude --continue
+```
+
+#### ⚠️ Migration Risks & Caveats
+
+**Before migrating sessions, verify compatibility:**
+
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| **Hardcoded secrets** | Credentials exposed in new context | Audit `.jsonl` files before migration, redact if needed |
+| **Absolute paths** | File references break if paths differ | Verify paths exist in target, or accept broken references |
+| **MCP server configs** | Source MCP servers missing in target | Install matching MCP servers before resuming |
+| **`.claudeignore` rules** | Different ignore patterns | Review differences, merge if needed |
+| **Environment variables** | `process.env` context mismatch | Check `.env` files compatibility |
+
+**When NOT to migrate sessions:**
+
+- Conflicting dependencies (e.g., different Node.js versions, package managers)
+- Database state differences (migrations applied in source, not in target)
+- Authentication context (API tokens, OAuth sessions specific to source project)
+- Security boundaries (migrating from private to public repo)
+
+#### Community Automation Tool
+
+**claude-migrate-session** by Jim Weller (inspired by Alexis Laporte) automates the manual process above:
+
+- **Repository**: [jimweller/dotfiles](https://github.com/jimweller/dotfiles/tree/main/dotfiles/claude-code/skills/claude-migrate-session)
+- **Features**: Global search with filtering, preserves `.jsonl` + subagents, uses ripgrep for performance
+- **Status**: Personal dotfiles (0 stars/forks as of Feb 2026), limited adoption
+- **Command**: `/claude-migrate-session <source> <target>`
+
+**⚠️ Caveat**: This tool has minimal community testing. The manual approach is safer and gives you explicit control over what gets migrated. Test thoroughly before using in production workflows.
+
+**Use cases for migration:**
+- Forking prototype work into production codebase
+- Moving debugging session to isolated test repository
+- Continuing architecture discussion in a new project
+
+---
+
 ### Multi-Agent Orchestration Monitoring

 For monitoring multiple concurrent Claude Code instances via external orchestrators (Gas Town, multiclaude), see:
--- a/guide/security-hardening.md
+++ b/guide/security-hardening.md
@ -46,7 +46,7 @@ MITIGATION: Version pinning + hash verification + monitoring

 This attack exploits the one-time approval model: once you approve an MCP, updates execute automatically without re-consent.

-#### CVE Summary (2025)
+#### CVE Summary (2025-2026)

 | CVE | Severity | Impact | Mitigation |
 |-----|----------|--------|------------|
@ -54,8 +54,11 @@ This attack exploits the one-time approval model: once you approve an MCP, updat
 | **CVE-2025-54135** | High (8.6) | RCE in Cursor via prompt injection rewriting mcp.json | File integrity monitoring hook |
 | **CVE-2025-54136** | High | Persistent team backdoor via post-approval config tampering | Git hooks + hash verification |
 | **CVE-2025-49596** | Critical (9.4) | RCE in MCP Inspector tool | Update to patched version |
+| **Claude Code v2.1.34** | High | Sandbox bypass (undisclosed) | **Update to v2.1.34+ immediately** |

-**Source**: [Cymulate EscapeRoute](https://cymulate.com/blog/cve-2025-53109-53110-escaperoute-anthropic/), [Checkpoint MCPoison](https://research.checkpoint.com/2025/cursor-vulnerability-mcpoison/), [Cato CurXecute](https://www.catonetworks.com/blog/curxecute-rce/)
+**v2.1.34 Security Fix (Feb 2026)**: Claude Code v2.1.34 patched a critical sandbox bypass vulnerability. **Upgrade immediately** if running v2.1.33 or earlier. Details undisclosed pending broader adoption.
+
+**Source**: [Cymulate EscapeRoute](https://cymulate.com/blog/cve-2025-53109-53110-escaperoute-anthropic/), [Checkpoint MCPoison](https://research.checkpoint.com/2025/cursor-vulnerability-mcpoison/), [Cato CurXecute](https://www.catonetworks.com/blog/curxecute-rce/), Claude Code CHANGELOG

 #### Attack Patterns

--- a/guide/ultimate-guide.md
+++ b/guide/ultimate-guide.md
@ -3659,9 +3659,56 @@ Leader creates shared task queue → Teammates self-organize and claim tasks

 > ⚠️ **Note**: This is an experimental feature. Capabilities may change or be removed in future releases. Always verify current behavior with official documentation.

-### Split-Role Sub-Agents
+### Agent Anti-Patterns: Roles vs Context Control

-Beyond generic sub-agents, **split-role orchestration** assigns distinct expert personas to different agents for multi-perspective analysis.
+> **"Subagents are not for anthropomorphizing roles, they are for controlling context"** - Dex Horty
+
+**Common Mistake**: Creating agents as if building a human team with job titles.
+
+❌ **Wrong** (Anthropomorphizing):
+```
+- Frontend Agent (role: UI developer)
+- Backend Agent (role: API engineer)
+- QA Agent (role: tester)
+- Security Agent (role: security expert)
+```
+
+**Why this fails**: Agents aren't humans with expertise areas. They're **context isolation tools** for computational efficiency.
+
+✅ **Right** (Context Control):
+```
+- Agent for isolated dependency analysis (scope: package.json + lock files only)
+- Agent for parallel file processing (scope: batch edits without main context pollution)
+- Agent for fresh security audit (scope: security-focused analysis without prior assumptions)
+- Agent for independent module testing (scope: test execution without interfering with main workflow)
+```
+
+**Key differences**:
+
+| Anthropomorphizing (Wrong) | Context Control (Right) |
+|----------------------------|-------------------------|
+| "Security expert agent" | "Security audit with isolated context" |
+| "Frontend developer agent" | "UI component analysis (scope: src/components/ only)" |
+| "Code reviewer agent" | "PR review without main context pollution" |
+| Mimics human team structure | Optimizes computational resources |
+| Based on job roles | Based on scope/context boundaries |
+
+**When to use agents** (good reasons):
+- **Isolate context**: Prevent pollution of main conversation context
+- **Parallel processing**: Independent operations that can run concurrently
+- **Scope limitation**: Restrict analysis to specific files/directories
+- **Fresh perspective**: Analyze without baggage from previous reasoning
+- **Resource optimization**: Offload heavy operations to separate context window
+
+**When NOT to use agents** (bad reasons):
+- ❌ Creating a fake team with job titles
+- ❌ Roleplaying different "expertise" personas
+- ❌ Mimicking human organizational structure
+- ❌ Splitting work by discipline (frontend/backend/QA) instead of by context boundaries
+
+### Scope-Focused Agents
+
+Beyond generic sub-agents, **scope-focused orchestration** assigns distinct **context boundaries** to different agents for multi-perspective analysis.

 **The Pattern**: Instead of one agent reviewing everything, spawn specialized agents that each bring a different lens:

@ -11007,6 +11054,154 @@ fi

 💡 **Tip**: Faster loops catch more bugs. Invest in making your test suite fast.

+### Background Tasks for Fullstack Development
+
+**Problem**: Fullstack development often requires long-running processes (dev servers, watchers) that block the main Claude session, preventing iterative frontend work.
+
+**Solution**: Use `Ctrl+B` to background tasks and maintain tight feedback loops across the stack.
+
+#### When to Background Tasks
+
+| Scenario | Background Command | Why |
+|----------|-------------------|-----|
+| **Dev server running** | `pnpm dev` → `Ctrl+B` | Keeps server alive while iterating on frontend |
+| **Test watcher** | `pnpm test --watch` → `Ctrl+B` | Monitor test results while coding |
+| **Build watcher** | `pnpm build --watch` → `Ctrl+B` | Detect build errors without blocking session |
+| **Database migration** | `pnpm migrate` → `Ctrl+B` | Long-running migration, work on other features |
+| **Docker compose** | `docker compose up` → `Ctrl+B` | Infrastructure running, develop application |
+
+#### Fullstack Workflow Pattern
+
+```bash
+# 1. Start backend dev server
+pnpm dev:backend
+# Press Ctrl+B to background
+
+# 2. Now Claude can iterate on frontend
+"Update the login form UI to match Figma designs"
+# Claude can read files, make changes, all while backend runs
+
+# 3. Check server logs when needed
+/tasks  # View background task status
+
+# 4. Bring server back to foreground if needed
+# (Currently: no built-in foreground command, restart if needed)
+```
+
+#### Real-World Example: API + Frontend Iteration
+
+**Traditional (blocked) flow:**
+```bash
+$ pnpm dev:backend
+# Server starts... Claude waits... session blocked
+# Cannot iterate on frontend until server stops
+# Kill server → work on frontend → restart server → repeat
+```
+
+**Background task flow:**
+```bash
+$ pnpm dev:backend
+# Server starts...
+$ Ctrl+B  # Background the server
+# Claude is now free to work
+
+"Add loading state to the API calls"
+# Claude iterates on frontend
+# Backend still running, can test immediately
+# Tight feedback loop maintained
+```
+
+#### Context Rot Prevention
+
+**Problem**: Long-running background tasks can cause context rot—Claude loses awareness of what's running.
+
+**Solution**: Check task status periodically:
+
+```bash
+# Before major changes
+/tasks
+
+# Output example:
+# Task 1 (background): pnpm dev:backend
+#   Status: Running (35 minutes)
+#   Last output: Server listening on :3000
+```
+
+**Best practices:**
+- Background tasks at session start (setup phase)
+- Check `/tasks` before major architecture changes
+- Restart backgrounded tasks if context is lost
+- Use descriptive commands (`pnpm dev:backend` not just `npm run dev`)
+
+#### Limitations
+
+- **No foreground command**: Cannot bring tasks back to foreground (yet)
+- **Context loss**: Long-running tasks may lose relevance to current work
+- **Output not streamed**: Background task output not visible unless checked
+- **Session-scoped**: Background tasks tied to Claude session, killed on exit
+
+**Workaround for foreground**: If you need to interact with a backgrounded task, restart it in foreground:
+```bash
+# Can't foreground task directly
+# Instead: check status, then restart if needed
+/tasks  # See what's running
+# Ctrl+C to stop current session interaction
+# Restart the command you need in foreground
+```
+
+#### Integration with Teleportation
+
+When using session teleportation (web → local), background tasks are **not** transferred:
+- Web sessions cannot background tasks
+- Teleported sessions start with clean slate
+- Restart required dev servers after teleportation
+
+**Teleport workflow:**
+```bash
+# 1. Teleport session from web to local
+claude --teleport
+
+# 2. Restart dev environment
+pnpm dev:backend
+Ctrl+B  # Background
+
+# 3. Continue work locally with full feedback loops
+```
+
+#### Monitoring Background Tasks
+
+```bash
+/tasks  # View all background tasks
+
+# Output includes:
+# - Task ID
+# - Command run
+# - Runtime duration
+# - Recent output (last few lines)
+# - Status (running, completed, failed)
+```
+
+**Use `/tasks` when:**
+- Starting new feature work (verify infrastructure running)
+- Debugging (check for error output in background tasks)
+- Before committing (ensure tests passed in background)
+- Session feels slow (check if background tasks consuming resources)
+
+#### Disabling Background Tasks
+
+```bash
+# Environment variable (v2.1.4+)
+export CLAUDE_CODE_DISABLE_BACKGROUND_TASKS=true
+claude
+
+# Useful when:
+# - Debugging Claude Code itself
+# - Running in resource-constrained environments
+# - Avoiding accidental backgrounding
+```
+
+💡 **Key insight**: Background tasks optimize fullstack workflows by decoupling infrastructure (servers, watchers) from iterative development. Use them strategically to maintain tight feedback loops across the entire stack.
+
 ## 9.6 Todo as Instruction Mirrors

 **Reading time**: 5 minutes
@ -14181,6 +14376,69 @@ Netlify coined "Agent Experience" as the agent equivalent of Developer Experienc
 - ❌ Stable legacy code (don't refactor just for agents)
 - ❌ Small scripts (<100 lines, agents handle fine)

+#### Convention-Over-Configuration for AI Agents
+
+**Problem**: Every configuration decision adds cognitive load for agents. Custom architectures require extensive CLAUDE.md documentation to prevent hallucinations.
+
+**Solution**: Choose opinionated frameworks that reduce decision space through enforced conventions.
+
+**Why opinionated frameworks help agents:**
+
+| Aspect | Custom Architecture | Opinionated Framework |
+|--------|---------------------|----------------------|
+| **File organization** | Agent must learn your structure | Standard conventions (e.g., Next.js `app/`, Rails MVC) |
+| **Routing** | Custom logic, must be documented | Convention-based (file = route) |
+| **Data access** | Multiple patterns possible | Single pattern enforced (e.g., Rails Active Record) |
+| **Testing setup** | Agent must discover your approach | Framework provides defaults |
+| **CLAUDE.md size** | Large (must document everything) | Smaller (conventions already known) |
+
+**Examples of opinionated frameworks:**
+
+- **Next.js**: `app/` directory structure, file-based routing, server components conventions
+- **Rails**: MVC structure, Active Record patterns, generator conventions
+- **Phoenix (Elixir)**: Context boundaries, schema conventions, LiveView patterns
+- **Django**: Apps structure, settings conventions, admin interface patterns
+
+**Real-world impact:**
+
+When agents work with opinionated frameworks, they:
+- Make fewer mistakes (fewer choices = fewer wrong choices)
+- Generate boilerplate faster (know the patterns)
+- Require less CLAUDE.md documentation (conventions replace custom instructions)
+- Produce more consistent code (follow framework idioms)
+
+**Trade-offs:**
+
+| Benefit | Cost |
+|---------|------|
+| Faster agent onboarding | Less architectural flexibility |
+| Smaller CLAUDE.md files | Framework lock-in |
+| Fewer hallucinations | Must accept framework opinions |
+| Consistent patterns | Learning curve for team |
+
+**Connection to CLAUDE.md sizing:**
+
+Convention-over-configuration directly reduces CLAUDE.md token requirements:
+
+```markdown
+# Custom Architecture (500+ lines CLAUDE.md)
+## File Organization
+- API routes in `src/endpoints/`
+- Business logic in `src/domain/`
+- Data access in `src/repositories/`
+- Validation in `src/validators/`
+... (extensive documentation of custom patterns)
+
+# Next.js (50 lines CLAUDE.md)
+## Project Context
+We use Next.js 14 with App Router.
+... (minimal context, rest is framework conventions)
+```
+
+**Recommendation**: For greenfield projects with AI-assisted development, prefer opinionated frameworks unless architectural constraints require custom design. The reduction in agent cognitive load often outweighs loss of flexibility.
+
+**See also**: [CLAUDE.md sizing guidelines (Section 3.2)](#32-claudemd-best-practices) for token optimization patterns.
+
 ---

 ### 9.18.2 Domain Knowledge Embedding
--- a/machine-readable/reference.yaml
+++ b/machine-readable/reference.yaml
@ -36,6 +36,13 @@ deep_dive:
  # Session management
  session_search: "guide/observability.md:29"
  session_search_script: "examples/scripts/session-search.sh"
+  session_resume_limitations: "guide/observability.md:117"
+  session_cross_folder_migration: "guide/observability.md:117"
+  session_migration_manual: "guide/observability.md:135"
+  session_migration_risks: "guide/observability.md:157"
+  session_migration_community_tool: "guide/observability.md:175"
+  session_migration_issue: "https://github.com/anthropics/claude-code/issues/1516"
+  session_migration_weller_skill: "https://github.com/jimweller/dotfiles/tree/main/dotfiles/claude-code/skills/claude-migrate-session"
  # Cost optimization - Local execution bridge
  bridge_script: "examples/scripts/bridge.py"
  bridge_schema: "examples/scripts/bridge-plan-schema.json"