@mind-fold/open-flow 0.2.15 → 0.2.16

package/dist/templates/commands/onboard-developer.txt

@@ -72,6 +72,56 @@ workflow/
 \-- scripts/                # Automation tools
 ```
 
+### Understanding structure/ subdirectories
+
+**frontend/** - Single-layer frontend knowledge:
+- Component patterns (how to write components in THIS project)
+- State management rules (Redux? Zustand? Context?)
+- Styling conventions (CSS modules? Tailwind? Styled-components?)
+- Hook patterns (custom hooks, data fetching)
+
+**backend/** - Single-layer backend knowledge:
+- API design patterns (REST? GraphQL? tRPC?)
+- Database conventions (query patterns, migrations)
+- Error handling standards
+- Logging and monitoring rules
+
+**flows/** - Cross-layer integration knowledge:
+
+This is the CRITICAL directory that many developers overlook. It answers questions that NEITHER frontend nor backend docs can answer alone:
+
+**WHY flows/ EXISTS**:
+When a feature spans multiple layers (frontend + backend + database), there are integration concerns that don't belong in either layer's docs:
+- How does data flow from UI click to database write and back?
+- What's the contract between frontend and backend for this feature?
+- What happens when one layer changes - what must the other layer update?
+- How do we handle cross-layer error propagation?
+- What's the deployment order when both layers change?
+
+**WHAT flows/ CONTAINS**:
+1. **Feature flow documentation**: End-to-end data flow for complex features
+2. **API contracts**: Shared type definitions, request/response schemas
+3. **Cross-layer checklists**: "When changing X, also check Y"
+4. **Integration patterns**: How layers communicate in this project
+5. **Deployment guides**: Order of operations for multi-layer changes
+
+**WHEN TO READ flows/**:
+- Before implementing ANY feature that touches both frontend and backend
+- When debugging issues that might be integration-related
+- Before making API changes
+- When planning new features
+
+**EXAMPLE**:
+A "user authentication" flow doc might include:
+- Frontend: What happens when user clicks login
+- API: What endpoint is called, what's the request/response format
+- Backend: How credentials are validated, session created
+- Database: What gets stored, what gets returned
+- Error cases: How each layer handles auth failures
+- Security: Token handling, refresh logic
+
+Without flows/ documentation, AI treats frontend and backend as isolated islands. With flows/, AI understands how the layers work TOGETHER.
+
 ---
 
 ## COMMAND DEEP DIVE
@@ -158,6 +208,71 @@ This causes "context drift" - AI starts following guidelines but gradually rever
 
 ---
 
+### /check-cross-layer - Multi-Dimension Verification
+
+**WHY IT EXISTS**:
+`/check-frontend` and `/check-backend` verify code within a single layer. But most bugs don't come from lack of technical skill - they come from "didn't think of it":
+- Changed a constant in one place, missed 5 other places using it
+- Modified database schema, forgot to update the API layer
+- Created a new utility function, but similar one already exists
+- Fixed a bug in one component, but 3 other components have the same bug
+
+**THE CORE INSIGHT**:
+Real-world changes have multiple "dimensions" that need checking:
+1. **Cross-layer data flow**: Does data flow correctly from UI -> API -> Service -> Database and back?
+2. **Code reuse**: Are there duplicate definitions? Should this be a shared constant?
+3. **Consistency**: Is the same concept displayed the same way in different places?
+4. **Impact scope**: Did you check ALL files affected by this change?
+
+**WHAT IT ACTUALLY DOES**:
+1. Identifies which dimensions your change involves
+2. For each dimension, runs targeted checks:
+
+**Dimension A - Cross-Layer Data Flow** (when changes touch 3+ layers):
+- Trace read flow: Database -> Service -> API -> Hook -> Component
+- Trace write flow: Component -> Hook -> API -> Service -> Database
+- Check types passed correctly between layers
+- Check errors propagated to UI
+- Check loading states at each layer
+
+**Dimension B - Code Reuse** (when modifying constants/config):
+- Search: How many places define this value?
+- If 2+ places -> Should extract to shared constant
+- After modification, all usage sites updated?
+
+**Dimension B2 - New Utilities** (when creating helper functions):
+- Search for existing similar utilities first
+- If similar exists, extend instead of duplicate
+- If new, is it in the right location?
+
+**Dimension B3 - Batch Modifications** (after fixing multiple files):
+- Did you check ALL files with similar patterns?
+- Any files missed?
+- Should this pattern be abstracted?
+
+**Dimension C - Import Paths** (when creating new files):
+- Using correct path aliases?
+- No circular imports?
+- Consistent with project convention?
+
+**Dimension D - Same-Layer Consistency** (when modifying display logic):
+- Search for other components using same concept
+- Are displays consistent?
+- Should they share configuration?
+
+**WHY THIS MATTERS**:
+- Without check-cross-layer: You fix one bug, but miss 5 related places. You create a utility that already exists. You change a constant but miss half the usages.
+- With check-cross-layer: Systematic verification across all dimensions. No "didn't think of it" bugs.
+
+**ANALOGY**: Like a pre-flight checklist for pilots. Not because pilots don't know how to fly, but because complex systems have many dimensions that are easy to overlook.
+
+**RELATED DOCUMENTS** (referenced by this command):
+- `workflow/structure/flows/pre-implementation-checklist.md` - Questions BEFORE coding
+- `workflow/structure/flows/code-reuse-thinking-guide.md` - Pattern recognition
+- `workflow/structure/flows/cross-layer-thinking-guide.md` - Data flow analysis
+
+---
+
 ### /finish-work - Holistic Pre-Commit Review
 
 **WHY IT EXISTS**:

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@mind-fold/open-flow",
-	"version": "0.2.15",
+	"version": "0.2.16",
 	"description": "AI-assisted development workflow initializer for Cursor, Claude Code and more",
 	"type": "module",
 	"main": "./dist/index.js",