minimal-vibe-coding-kit 0.5.1 → 0.5.2

package/.cursor/skills/sequential-thinking/examples/linear-reasoning.md

@@ -1,210 +1,29 @@
-# Linear Reasoning - Example
+# Linear Reasoning Example
 
-## Scenario: API Performance Optimization
+## Case: Repair A Broken Skill Reference
 
-**Problem:** API response times are slow (800ms P95)
+The validator should reject an operational link that points to a missing local file.
 
-**Pattern:** Linear Sequence (straightforward problem with clear steps)
+~~~text
+Thought 1/5: Completion means every link from SKILL.md resolves inside the packaged skill.
+Thought 2/5 [HYPOTHESIS]: A renamed reference left one stale target.
+Thought 3/5 [VERIFICATION]: The link audit reports references/old-output.md; the file does not exist.
+Thought 4/5: Update the target to references/output-schema.md and add the link audit to validation.
+Thought 5/5 [FINAL]: The targeted audit and full kit validation pass; the package dry-run includes the referenced file.
+~~~
 
-**Estimated thoughts:** 6
+## Public Summary
 
----
+~~~markdown
+## Reasoning Summary
 
-## Thought Sequence
+Current focus: Restore skill-reference integrity.
+Evidence:
+- references/old-output.md is missing.
+- references/output-schema.md is packaged.
+Decision: Point the skill at the existing output contract and retain a regression check.
+Next action: Review the one-link diff.
+Validation: Run the kit validator and package dry-run.
+~~~
 
-### Thought 1: Problem Statement
-
-**Input:**
-```bash
-/sequential-thinking "Problem: API P95 latency is 800ms, users complaining about slowness. Need to optimize." thoughtNumber=1 totalThoughts=6 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 1,
-  "thoughtContent": "Problem: API P95 latency is 800ms, users complaining about slowness. Need to optimize.",
-  "totalThoughts": 6,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 1,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 99
-  }
-}
-```
-
----
-
-### Thought 2: Measurement & Data Collection
-
-**Input:**
-```bash
-/sequential-thinking "Measured endpoint breakdown: /users takes 650ms, /products takes 120ms, /orders takes 400ms. The /users endpoint is the bottleneck." thoughtNumber=2 totalThoughts=6 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 2,
-  "thoughtContent": "Measured endpoint breakdown: /users takes 650ms, /products takes 120ms, /orders takes 400ms. The /users endpoint is the bottleneck.",
-  "totalThoughts": 6,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 2,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 98,
-    "recentThoughts": [
-      {"number": 2, "preview": "Measured endpoint breakdown: /users takes 650ms..."},
-      {"number": 1, "preview": "Problem: API P95 latency is 800ms, users comp..."}
-    ]
-  }
-}
-```
-
----
-
-### Thought 3: Root Cause Analysis
-
-**Input:**
-```bash
-/sequential-thinking "Profiled /users endpoint: 600ms spent in database query. Query analysis shows N+1 problem - fetching user roles individually in a loop instead of batch query." thoughtNumber=3 totalThoughts=6 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 3,
-  "thoughtContent": "Profiled /users endpoint: 600ms spent in database query. Query analysis shows N+1 problem - fetching user roles individually in a loop instead of batch query.",
-  "totalThoughts": 6,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 3,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 97
-  }
-}
-```
-
----
-
-### Thought 4: Solution Design
-
-**Input:**
-```bash
-/sequential-thinking "Solution: Use JOIN query to fetch users with roles in single database roundtrip. Expected improvement: 600ms → 50ms (12x faster). Implementation: Modify UserRepository.getUsers() to use eager loading." thoughtNumber=4 totalThoughts=6 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 4,
-  "thoughtContent": "Solution: Use JOIN query to fetch users with roles in single database roundtrip. Expected improvement: 600ms → 50ms (12x faster). Implementation: Modify UserRepository.getUsers() to use eager loading.",
-  "totalThoughts": 6,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 4,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 96
-  }
-}
-```
-
----
-
-### Thought 5: Implementation & Validation
-
-**Input:**
-```bash
-/sequential-thinking "Implemented eager loading. Testing results: P95 latency reduced from 800ms → 180ms (4.4x improvement). All functionality working correctly. N+1 problem eliminated." thoughtNumber=5 totalThoughts=6 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 5,
-  "thoughtContent": "Implemented eager loading. Testing results: P95 latency reduced from 800ms → 180ms (4.4x improvement). All functionality working correctly. N+1 problem eliminated.",
-  "totalThoughts": 6,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 5,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 95
-  }
-}
-```
-
----
-
-### Thought 6: Conclusion & Next Steps
-
-**Input:**
-```bash
-/sequential-thinking "Conclusion: Optimization successful. Next steps: 1) Add database indexes on foreign keys for further improvement, 2) Monitor latency metrics for next week, 3) Apply same pattern to /orders endpoint. Analysis complete." thoughtNumber=6 totalThoughts=6 nextThoughtNeeded=false
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 6,
-  "thoughtContent": "Conclusion: Optimization successful. Next steps: 1) Add database indexes on foreign keys for further improvement, 2) Monitor latency metrics for next week, 3) Apply same pattern to /orders endpoint. Analysis complete.",
-  "totalThoughts": 6,
-  "nextThoughtNeeded": false,
-  "branches": [],
-  "thoughtHistoryLength": 6,
-  "status": "complete",
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 94,
-    "recentThoughts": [
-      {"number": 6, "preview": "Conclusion: Optimization successful. Next steps..."},
-      {"number": 5, "preview": "Implemented eager loading. Testing results: P9..."},
-      {"number": 4, "preview": "Solution: Use JOIN query to fetch users with r..."}
-    ]
-  }
-}
-```
-
----
-
-## Analysis Summary
-
-**Pattern Used:** Linear Sequence  
-**Total Thoughts:** 6  
-**Revisions:** 0  
-**Branches:** 0  
-**Result:** Clear, actionable solution  
-
-**Thought Breakdown:**
-1. Problem identification ✅
-2. Data collection ✅
-3. Root cause analysis ✅
-4. Solution design ✅
-5. Implementation & validation ✅
-6. Conclusion & next steps ✅
-
-**Time:** ~10 minutes  
-**Outcome:** 4.4x performance improvement
-
----
-
-## Why Linear Pattern Worked
-
-✅ **Clear problem**: Slow API with measurable metrics  
-✅ **Predictable steps**: Measure → Analyze → Fix → Validate  
-✅ **Single solution**: N+1 problem had clear fix  
-✅ **No branches needed**: Solution path was obvious once identified  
-
-**When to use linear:** Problems with clear causation and straightforward solutions.
-
----
-
-**For other patterns, see:**
-- [revision-pattern.md](revision-pattern.md) - Correcting assumptions
-- [branching-exploration.md](branching-exploration.md) - Multiple approaches
-- [adaptive-depth.md](adaptive-depth.md) - Uncertain scope
+This is linear because each result determines the next check; no material alternative needs a branch.

package/.cursor/skills/sequential-thinking/examples/revision-pattern.md

@@ -1,304 +1,23 @@
-# Revision Pattern - Example
+# Revision Pattern Example
 
-## Scenario: Authentication Strategy Selection
+## Case: Correct A Contrast Assumption
 
-**Problem:** Choose authentication method for new API
+A debug diagram uses white text on the strong red suspect color.
 
-**Pattern:** Revision Chain (initial assumptions proved wrong)
+~~~text
+Thought 1/6: Assume the existing red and white pair meets normal-text contrast.
+Thought 2/6: Plan to reuse it in every high-risk node.
+Thought 3/6 [VERIFICATION]: The measured ratio is 3.28:1; the assumption is false.
+Thought 4/6 [REVISION of Thought 1]: Use #111111 text on #FA5252; discard the white-text rollout from Thought 2.
+Thought 5/6 [VERIFICATION]: The replacement measures 5.75:1 and remains visually distinct in the render.
+Thought 6/6 [FINAL]: Keep the ink-text rule and assert a minimum ratio of 4.5:1.
+~~~
 
-**Initial estimate:** 5 thoughts  
-**Actual:** 8 thoughts (with 2 revisions)
+## Revision Cascade
 
----
+- Thought 1: invalid.
+- Thought 2: discard because it depended on Thought 1.
+- Thought 3: retain as evidence.
+- Later styling guidance: update wherever it repeats the invalid pairing.
 
-## Thought Sequence
-
-### Thought 1: Initial Hypothesis
-
-**Input:**
-```bash
-/sequential-thinking "Hypothesis: JWT tokens are best for stateless API authentication. Plan to implement JWT with RS256 signing." thoughtNumber=1 totalThoughts=5 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 1,
-  "thoughtContent": "Hypothesis: JWT tokens are best for stateless API authentication. Plan to implement JWT with RS256 signing.",
-  "totalThoughts": 5,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 1,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 99
-  }
-}
-```
-
----
-
-### Thought 2: Implementation Planning
-
-**Input:**
-```bash
-/sequential-thinking "JWT Implementation plan: 1) Generate RSA key pair, 2) Create /login endpoint returning access token, 3) Add middleware to verify tokens on protected routes, 4) Set token expiry to 1 hour." thoughtNumber=2 totalThoughts=5 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 2,
-  "thoughtContent": "JWT Implementation plan: 1) Generate RSA key pair, 2) Create /login endpoint returning access token, 3) Add middleware to verify tokens on protected routes, 4) Set token expiry to 1 hour.",
-  "totalThoughts": 5,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 2,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 98
-  }
-}
-```
-
----
-
-### Thought 3: Discovery (Contradiction)
-
-**Input:**
-```bash
-/sequential-thinking "Wait - just learned we need to support third-party OAuth providers (Google, GitHub) for social login. Pure JWT won't work because we need to integrate with external identity providers." thoughtNumber=3 totalThoughts=5 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 3,
-  "thoughtContent": "Wait - just learned we need to support third-party OAuth providers (Google, GitHub) for social login. Pure JWT won't work because we need to integrate with external identity providers.",
-  "totalThoughts": 5,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 3,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 97
-  }
-}
-```
-
----
-
-### Thought 4: Revision #1 (Correcting Hypothesis)
-
-**Input:**
-```bash
-/sequential-thinking "REVISION: My thought #1 was wrong. We don't need pure JWT - we need OAuth2 with OpenID Connect (OIDC). This allows both social login (external providers) and traditional login (internal users), with JWTs as the token format." thoughtNumber=4 totalThoughts=5 nextThoughtNeeded=true isRevision=true revisesThought=1
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 4,
-  "thoughtContent": "REVISION: My thought #1 was wrong. We don't need pure JWT - we need OAuth2 with OpenID Connect (OIDC). This allows both social login (external providers) and traditional login (internal users), with JWTs as the token format.",
-  "totalThoughts": 5,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 4,
-  "revisionOf": 1,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 96,
-    "revisionsMade": 1,
-    "revisedThoughts": [1]
-  }
-}
-```
-
----
-
-### Thought 5: New Implementation Plan (Based on Revision)
-
-**Input:**
-```bash
-/sequential-thinking "Revised plan using OAuth2/OIDC: 1) Integrate Auth0 or Keycloak as identity provider, 2) Configure social providers (Google, GitHub), 3) Implement authorization code flow, 4) Store provider tokens, 5) Map external users to internal user model." thoughtNumber=5 totalThoughts=8 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 5,
-  "thoughtContent": "Revised plan using OAuth2/OIDC: 1) Integrate Auth0 or Keycloak as identity provider, 2) Configure social providers (Google, GitHub), 3) Implement authorization code flow, 4) Store provider tokens, 5) Map external users to internal user model.",
-  "totalThoughts": 8,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 5,
-  "totalThoughtsAdjusted": true,
-  "originalEstimate": 5,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 95
-  }
-}
-```
-
----
-
-### Thought 6: Security Consideration
-
-**Input:**
-```bash
-/sequential-thinking "Security review: Need to validate provider tokens, implement PKCE flow for SPAs, store refresh tokens securely (encrypted), handle token expiry and refresh logic." thoughtNumber=6 totalThoughts=8 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 6,
-  "thoughtContent": "Security review: Need to validate provider tokens, implement PKCE flow for SPAs, store refresh tokens securely (encrypted), handle token expiry and refresh logic.",
-  "totalThoughts": 8,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 6,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 94
-  }
-}
-```
-
----
-
-### Thought 7: Provider Selection Discovery
-
-**Input:**
-```bash
-/sequential-thinking "Researching providers: Auth0 is expensive ($150/mo), Keycloak is open-source but complex to self-host. Actually, AWS Cognito might be best - integrates with our existing AWS infrastructure, supports social login, and costs $0.0055 per MAU." thoughtNumber=7 totalThoughts=8 nextThoughtNeeded=true
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 7,
-  "thoughtContent": "Researching providers: Auth0 is expensive ($150/mo), Keycloak is open-source but complex to self-host. Actually, AWS Cognito might be best - integrates with our existing AWS infrastructure, supports social login, and costs $0.0055 per MAU.",
-  "totalThoughts": 8,
-  "nextThoughtNeeded": true,
-  "branches": [],
-  "thoughtHistoryLength": 7,
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 93
-  }
-}
-```
-
----
-
-### Thought 8: Revision #2 (Update Provider Choice)
-
-**Input:**
-```bash
-/sequential-thinking "REVISION: Revising thought #5 - Using AWS Cognito instead of Auth0/Keycloak. Updated plan: 1) Create Cognito User Pool, 2) Configure Google/GitHub as identity providers, 3) Use Cognito SDK for token verification, 4) Implement refresh token rotation, 5) Use Cognito Hosted UI for login flows." thoughtNumber=8 totalThoughts=8 nextThoughtNeeded=false isRevision=true revisesThought=5
-```
-
-**Output:**
-```json
-{
-  "thoughtNumber": 8,
-  "thoughtContent": "REVISION: Revising thought #5 - Using AWS Cognito instead of Auth0/Keycloak. Updated plan: 1) Create Cognito User Pool, 2) Configure Google/GitHub as identity providers, 3) Use Cognito SDK for token verification, 4) Implement refresh token rotation, 5) Use Cognito Hosted UI for login flows.",
-  "totalThoughts": 8,
-  "nextThoughtNeeded": false,
-  "branches": [],
-  "thoughtHistoryLength": 8,
-  "revisionOf": 5,
-  "status": "complete",
-  "sessionContext": {
-    "sessionId": "conversation",
-    "remainingThoughts": 92,
-    "revisionsMade": 2,
-    "revisedThoughts": [1, 5]
-  }
-}
-```
-
----
-
-## Revision Chain Visualization
-
-```
-Thought 1: JWT hypothesis
-  ↓
-Thought 2: JWT implementation plan
-  ↓
-Thought 3: ⚠️ Discovery: Need OAuth providers
-  ↓
-Thought 4: 🔄 REVISION of #1 → OAuth2/OIDC needed
-  ↓
-Thought 5: OAuth2 implementation plan (Auth0/Keycloak)
-  ↓
-Thought 6: Security considerations
-  ↓
-Thought 7: ⚠️ Discovery: AWS Cognito better fit
-  ↓
-Thought 8: 🔄 REVISION of #5 → AWS Cognito plan
-```
-
----
-
-## Analysis
-
-### Pattern: Revision Chain
-- **Revisions:** 2 (thoughts #4 and #8)
-- **Revised thoughts:** #1 (JWT), #5 (Provider choice)
-- **Reason for revisions:**
-  - #1: New requirement (social login) invalidated pure JWT
-  - #5: Cost analysis favored different provider
-
-### Why Revisions Were Necessary
-1. ✅ **New information** emerged (social login requirement)
-2. ✅ **Cost analysis** changed decision (AWS vs Auth0)
-3. ✅ **Initial assumption** was wrong (JWT insufficient)
-
-### Benefits of Revision Pattern
-- ✅ Transparent reasoning evolution
-- ✅ Complete audit trail (original thoughts preserved)
-- ✅ Shows learning and adaptation
-- ✅ Final plan is well-informed
-
-### Outcome
-**Final solution:** AWS Cognito with OAuth2/OIDC
-- Supports social login ✅
-- Cost-effective ($5.50 per 1000 users) ✅
-- Integrates with existing AWS ✅
-- Secure token handling ✅
-
----
-
-## Key Takeaways
-
-### When to Use Revision Pattern
-1. Initial assumptions might be wrong
-2. Requirements discovered during analysis
-3. Cost/trade-off analysis changes decision
-4. New information contradicts earlier thoughts
-
-### Revision Best Practices
-- ✅ Explicitly mark as revision (`isRevision=true`)
-- ✅ Reference specific thought (`revisesThought=N`)
-- ✅ Explain what changed and why
-- ✅ Update subsequent thoughts based on revision
-
-### Comparison with Linear Pattern
-| Aspect | Linear | Revision Chain |
-|--------|--------|----------------|
-| **Assumptions** | Stable | Evolving |
-| **Information** | Complete upfront | Discovered during |
-| **Path** | Straight | Zigzag |
-| **Thoughts** | 5-8 | 8-12 (more iterations) |
-| **Complexity** | Low | Medium |
-
----
-
-**For other patterns:**
-- [linear-reasoning.md](linear-reasoning.md) - Straightforward analysis
-- [branching-exploration.md](branching-exploration.md) - Multiple approaches
-- [adaptive-depth.md](adaptive-depth.md) - Uncertain scope
+A revision is not complete until dependent checkpoints are reassessed.

package/.cursor/skills/sequential-thinking/references/advanced-techniques.md

@@ -0,0 +1,98 @@
+# Advanced Sequential Thinking Techniques
+
+Maintained by Minimal Vibe Coding Kit. These techniques extend the public-checkpoint contract with kit-native cases. They do not expose private chain-of-thought.
+
+## Spiral Refinement
+
+Revisit one artifact as evidence becomes more precise.
+
+~~~text
+Thought 1/6: The package dry-run omits one skill.
+Thought 2/6 [VERIFICATION]: The canonical and mirror directories all exist.
+Thought 3/7: Refine the scope to package inclusion and manifest derivation.
+Thought 4/7 [VERIFICATION]: The manifest is correct; one package path is missing.
+Thought 5/6: Contract the plan because mirror edits are unnecessary.
+Thought 6/6 [FINAL]: Patch the package path and rerun validation plus the dry-run.
+~~~
+
+Each return narrows the problem; it does not restart the investigation.
+
+## Multi-Branch Convergence
+
+Explore distinct designs, then close them with evidence.
+
+~~~text
+Thought 2/7 [BRANCH strict-local from Thought 1]: Reject every unresolved documentation link.
+Thought 3/7 [BRANCH snapshot-aware from Thought 1]: Preserve upstream links and record their origin.
+Thought 4/7 [VERIFICATION]: Operational skill links must resolve locally; snapshot links legitimately point upstream.
+Thought 5/7 [CONVERGENCE]: Validate local operational links and convert snapshot-only paths to pinned official URLs.
+Thought 6/7 [VERIFICATION]: The link audit reports zero unresolved relative targets.
+Thought 7/7 [FINAL]: Keep the hybrid rule and its regression check.
+~~~
+
+A branch without CONVERGENCE is unfinished.
+
+## Uncertainty Management
+
+Turn an unknown into a bounded decision.
+
+~~~text
+Thought 2/5: Browser rendering availability is unknown.
+Thought 3/5 [BRANCH renderer-present from Thought 2]: Capture screenshots and inspect computed colors.
+Thought 4/5 [BRANCH renderer-absent from Thought 2]: Parse locally, record the visual limitation, and avoid claiming visual verification.
+Thought 5/5 [CONVERGENCE]: Use the first available trusted method; never invent a screenshot result.
+~~~
+
+Prefer a result robust to both scenarios. Otherwise identify the smallest fact or permission that resolves the branch.
+
+## Revision Cascade Management
+
+Reassess every conclusion that depended on a corrected fact.
+
+~~~text
+Thought 1/6: Assume white text is accessible on the strong red token.
+Thought 2/6: Reuse that pairing in the debug heat map.
+Thought 3/6 [VERIFICATION]: The measured contrast is 3.28:1, below the 4.5:1 target.
+Thought 4/6 [REVISION of Thought 1]: Use ink text on strong red; discard the inherited white-text rule.
+Thought 5/6 [VERIFICATION]: Ink on red measures 5.75:1 and the rendered label remains legible.
+Thought 6/6 [FINAL]: Keep the accessible pairing and add a contrast assertion.
+~~~
+
+The revision names the old claim, the new evidence, and the affected downstream work.
+
+## Meta-Thinking Calibration
+
+Pause speculation when the method stops producing evidence.
+
+~~~text
+Thought 4/7 [META]: Rewording the preset cannot prove the stale gallery is fixed. Switch from prose review to a pinned render.
+Thought 5/7 [VERIFICATION]: The timeline still shows auto-derived accent colors in the gallery.
+Thought 6/7 [REVISION of Thought 3]: Update the executable example, not only the reference recipe.
+Thought 7/7 [FINAL]: Screenshot and computed-style checks confirm the gallery now matches the preset.
+~~~
+
+META should change the next action, not merely announce difficulty.
+
+## Parallel Constraint Satisfaction
+
+Analyze independent constraints, then intersect the feasible set.
+
+~~~text
+Thought 1/7: A preview must satisfy security, reproducibility, and visual fidelity.
+Thought 2/7 [BRANCH security from Thought 1]: Pinned official assets and strict rendering only.
+Thought 3/7 [BRANCH reproducibility from Thought 1]: Versioned runtime and deterministic example data.
+Thought 4/7 [BRANCH fidelity from Thought 1]: Screenshot plus color and contrast assertions.
+Thought 5/7 [CONVERGENCE]: A pinned sandbox gallery with no callbacks satisfies all three.
+Thought 6/7 [VERIFICATION]: Syntax, security probe, render, and visual checks pass.
+Thought 7/7 [FINAL]: Keep the gallery and document its exact test boundary.
+~~~
+
+If no option satisfies every hard constraint, name the constraint requiring user direction.
+
+## Adjustment Rules
+
+- Expand the estimated total when new dependencies, affected callers, or verification steps appear.
+- Contract only after evidence removes work, and never below the current checkpoint number.
+- Keep no more than three branches open.
+- Use META after repeated revisions or speculative edits fail to reduce uncertainty.
+- Use FINAL only after hypotheses are resolved, branches converge, and validation is explicit.