wogiflow 1.5.13 → 1.6.0

package/.claude/commands/wogi-compact.md

@@ -95,7 +95,17 @@ Provide this information for the compaction system:
 **Context to Preserve**:
 - [Important context that should survive compaction]
 
+**⚠️ ROUTING ENFORCEMENT (MANDATORY — survives compaction)**:
+Every new user message after resuming from this compacted context MUST be
+routed through a `/wogi-*` command BEFORE any other action. This includes
+questions, conversations, follow-ups, and implementation requests.
+Do NOT answer directly from compacted memory. Do NOT skip routing because
+"the answer seems obvious." The routing requirement applies unconditionally.
+If no Natural Language Detection match → invoke `/wogi-start` with the full
+user message as args.
+
 **ON RESUME**: Check `.workflow/state/ready.json` for pending work.
+Route ALL new user messages through `/wogi-start` or a matching `/wogi-*` command.
 ```
 
 ## Context Pressure Monitoring

package/.claude/commands/wogi-export.md

@@ -1,14 +1,16 @@
 Export workflow configuration as a shareable profile.
 
-**v2.1**: Enhanced with rules, learnings, and templates export.
+**v3.0**: Complete enforcement profile — exports everything needed to enforce identical code standards across projects, while excluding session-specific data.
 
 ## Usage
 
 ```bash
 /wogi-export my-team              # Core files only
-/wogi-export my-team --rules      # Include rules and decisions
+/wogi-export my-team --rules      # Include rules, decisions, review checklists, tech stack
 /wogi-export my-team --learnings  # Include feedback patterns and skill learnings
-/wogi-export my-team --full       # Include everything
+/wogi-export my-team --skills     # Include skill definitions (skill.md files)
+/wogi-export my-team --templates  # Include workflow templates (HBS, story, bug report)
+/wogi-export my-team --full       # Include everything (recommended)
 ```
 
 ## Options
@@ -16,61 +18,62 @@ Export workflow configuration as a shareable profile.
 | Flag | Includes |
 |------|----------|
 | (none) | CLAUDE.md, agents/, config.json |
-| `--rules` | + decisions.md, .claude/rules/ |
-| `--learnings` | + feedback-patterns.md, skill learnings |
-| `--templates` | + project and roadmap templates |
-| `--full` | All of the above |
-| `--include-decisions` | Legacy: just decisions.md |
-| `--include-app-map` | Include app-map.md (usually project-specific) |
-
-## Export Categories
+| `--rules` | + decisions.md, .claude/rules/ (recursive), .workflow/agents/, .claude/docs/stack.md |
+| `--learnings` | + feedback-patterns.md, skill knowledge (patterns.md, learnings.md) |
+| `--skills` | + .claude/skills/*/skill.md (skill definitions) |
+| `--templates` | + .workflow/templates/ (HBS), templates/ (story/bug), state templates |
+| `--full` | All of the above + pattern extraction |
+| `--include-app-map` | Include app-map.md (project-specific, not in --full) |
+| `--extract-patterns` | Scan codebase and extract patterns (included in --full) |
+| `--resolve-conflicts` | Interactive conflict resolution (with --extract-patterns) |
+| `--analysis-mode MODE` | Analysis depth: `balanced` (default), `deep` |
+| `--include-examples` | Include code snippets as pattern examples |
+
+## What Gets Exported (Generic Enforcement)
 
 **Core (always included):**
-- CLAUDE.md - Core workflow instructions
-- agents/*.md - Agent personas
-- .workflow/config.json - Configuration
+- `CLAUDE.md` - Core workflow instructions
+- `agents/*.md` - Agent personas (11 files)
+- `.workflow/config.json` - Configuration and quality gates
+
+**Rules & Standards (`--rules`):**
+- `.workflow/state/decisions.md` - All coding rules and patterns
+- `.claude/rules/**/*.md` - Recursive rule tree (security, code-style, architecture, operations)
+- `.workflow/agents/*.md` - Review checklists (security.md, performance.md)
+- `.claude/docs/stack.md` - Tech stack definition
 
-**Rules & Decisions (`--rules`):**
-- .workflow/state/decisions.md - Project rules
-- .claude/rules/*.md - Auto-synced coding rules
+**Skills (`--skills`):**
+- `.claude/skills/*/skill.md` - Skill definition files
 
 **Learnings (`--learnings`):**
-- .workflow/state/feedback-patterns.md - Team learnings
-- .claude/skills/*/knowledge/ - Skill patterns and learnings
+- `.workflow/state/feedback-patterns.md` - Team learnings and patterns
+- `.claude/skills/*/knowledge/` - Skill patterns and learnings
 
 **Templates (`--templates`):**
-- templates/project-template.md - Project spec template
-- templates/roadmap-template.md - Roadmap template
-
-## Output
-
-```
-╔══════════════════════════════════════════════════════════╗
-║  Exporting Profile: my-team                               ║
-╚══════════════════════════════════════════════════════════╝
+- `.workflow/templates/` - HBS templates for CLAUDE.md generation (claude-md.hbs, partials/)
+- `templates/` - Story, bug report, correction, task templates
+- `.workflow/state/*.template` - State file init templates
+
+## What is EXCLUDED (Session-Specific)
+
+These are NEVER exported regardless of flags:
+- `request-log.md` - Session request history
+- `progress.md` - Session progress notes
+- `session-state.json` - Current session state
+- `ready.json` - Active task queue
+- `epics.json` - Active epics
+- `prompt-history.json` - Prompt history
+- `last-review.json` - Last review results
+- `app-map.md` - Project-specific component registry (opt-in with --include-app-map)
+- `function-map.md` - Project-specific function registry
+- `api-map.md` - Project-specific API registry
 
-Core Files:
-  ✓ CLAUDE.md
-  ✓ agents/ (11 personas)
-  ✓ config.json
-
-Rules & Decisions:
-  ✓ decisions.md
-  ✓ .claude/rules/ (3 rules)
-
-Learnings:
-  ✓ feedback-patterns.md
-  ✓ skill learnings (2 skills)
-
-╔══════════════════════════════════════════════════════════╗
-║  ✓ Profile exported successfully                          ║
-╚══════════════════════════════════════════════════════════╝
+## CLI
 
-  File: wogi-profiles/my-team.zip
-  Size: 45K
+Run the export script directly:
 
-Share this file with team members.
-Import with: ./scripts/flow import-profile my-team.zip
+```bash
+./scripts/flow export-profile my-team --full
 ```
 
 ## Import a Profile
@@ -82,19 +85,12 @@ npm install wogiflow
 npx flow import-profile ~/my-team.zip
 ```
 
-## CLI
-
-Run the export script directly:
-
-```bash
-./scripts/flow export-profile my-team --full
-```
-
 ## What This Enables
 
-Share with your team:
-- Refined agent instructions and personas
-- Coding conventions and decisions
-- Skill-specific patterns and learnings
-- Quality gate configuration
-- Template structures
+Export from project A, import into project B → identical code standards:
+- Same coding rules and conventions enforced
+- Same security patterns checked
+- Same review checklists applied
+- Same quality gates and config
+- Same skill definitions available
+- No session history or project-specific state carried over

package/.claude/commands/wogi-extract-review.md

@@ -1,179 +1,230 @@
-# /wogi-extract-review - Zero-Loss Task Extraction with Mandatory Review
+# /wogi-extract-review - Zero-Loss Extraction with Automated Pipeline
 
-Extract tasks from long input with 100% capture rate and mandatory human review.
+Extract tasks from long input with 100% capture rate, then automatically process them into organized stories — all in one seamless flow.
 
-**Scope**: This command does NOT modify source code files. It processes input text into structured tasks. All file modifications happen downstream via `/wogi-start`.
+**Scope**: This command does NOT modify source code files. It processes input text into structured stories in `ready.json`. All file modifications happen downstream via `/wogi-start`.
 
 ## Purpose
 
-When processing transcripts, meeting notes, or long prompts, this command ensures NOTHING is missed by:
-1. Capturing EVERY distinct statement (no filtering)
-2. Deduplicating similar items
-3. Requiring explicit human review and confirmation
-4. Only proceeding when user confirms the list is complete
+When processing transcripts, meeting notes, or long prompts, this command ensures NOTHING is missed by running a fully automated pipeline:
+
+1. **Extract** — Capture EVERY distinct statement (zero-loss, 5 extraction strategies)
+2. **Review** — Auto-confirm high-confidence items, present medium/low for batch review
+3. **Topics** — Group confirmed statements into logical topics
+4. **Map** — Associate every statement to a topic
+5. **Orphans** — Detect and resolve unmapped statements
+6. **Contradictions** — Auto-resolve with temporal ordering, ask user only when uncertain
+7. **Clarify** — Collect ALL questions in one batch, present to user
+8. **Stories** — Generate stories with user story format, acceptance criteria, and source tracing
+9. **Export** — Add stories to `ready.json` and save to `.workflow/changes/`
+
+**The user's only touchpoint**: answering clarifying questions (if any). Zero manual commands needed.
 
 ## Philosophy
 
 **OLD approach (lossy):** Input → Filter → Filter → Output (70-80% lost)
-**NEW approach (zero-loss):** Input → Capture All → Dedupe → Review → Confirm → Output (100% captured)
+**NEW approach (zero-loss, automated):** Input → Capture All → Dedupe → Auto-Review → Topics → Map → Orphans → Contradictions → Clarify → Stories → ready.json (100% captured, zero manual steps)
 
-## Usage
-
-```bash
-# Start zero-loss extraction
-flow extract-zero-loss start
+## For Claude — Automated Orchestration Protocol
 
-# Or pipe content
-cat transcript.txt | flow extract-zero-loss start
+When this command is invoked (directly or via longInputGate auto-routing), you MUST orchestrate the entire pipeline automatically. Follow these steps in sequence:
 
-# Check review status
-flow extract-zero-loss status
+### Phase 1: Extract (Zero-Loss)
 
-# View items by category
-flow extract-zero-loss show pending
-flow extract-zero-loss show high      # High confidence items
-flow extract-zero-loss show medium    # Medium confidence
-flow extract-zero-loss show low       # Low confidence
-flow extract-zero-loss show filler    # Potential filler
+```javascript
+const { extractZeroLoss } = require('./scripts/flow-zero-loss-extraction');
+const result = extractZeroLoss(inputText);
+```
 
-# Review actions
-flow extract-zero-loss confirm <id>           # Confirm as task
-flow extract-zero-loss remove <id> "<reason>" # Remove (reason required!)
-flow extract-zero-loss merge <src> <target>   # Merge duplicate
+Display to user:
+```
+Extracted N statements using 5 strategies.
+Breakdown: X high-confidence, Y medium, Z low, W filler.
+```
 
-# Bulk actions
-flow extract-zero-loss confirm-high           # Confirm all high-confidence
-flow extract-zero-loss dismiss-filler         # Dismiss filler items
+### Phase 2: Auto-Review
 
-# Complete review (MANDATORY before proceeding)
-flow extract-zero-loss complete
-
-# Get confirmed tasks
-flow extract-zero-loss tasks
+```javascript
+const { autoReview, batchConfirm, autoComplete } = require('./scripts/flow-extraction-review');
+const reviewResult = autoReview(result);
 ```
 
-## Review Workflow
+This auto-confirms high-confidence items and dismisses filler. Display to user:
 
-### Step 1: Start Extraction
 ```
-flow extract-zero-loss start < transcript.txt
+Auto-Review:
+  ✓ X high-confidence items confirmed
+  ✓ W filler items dismissed
+  ? Y medium-confidence items for review
+  ? Z low-confidence items for review
 ```
 
-This extracts EVERYTHING from the input using multiple strategies:
-- Sentence boundaries
-- Line breaks
-- Speaker changes
-- List items (bullets, numbers)
-- Comma-separated items with action verbs
+**If medium/low items exist**, present them as a numbered batch using `AskUserQuestion`:
+- Medium items: numbered list, user can approve all or reject specific numbers
+- Low items: numbered list with AI recommendation per item
 
-### Step 2: Quick Review High-Confidence Items
-```
-flow extract-zero-loss show high
+After user responds, call:
+```javascript
+batchConfirm(confirmedIds, rejectedIds);
+const completionResult = autoComplete();
+const confirmedTasks = completionResult.confirmed_tasks;
 ```
 
-These items almost certainly contain tasks. Review and confirm or adjust.
+**If NO medium/low items** (all were high or filler), call `autoComplete()` directly.
 
-### Step 3: Review Medium-Confidence Items
-```
-flow extract-zero-loss show medium
-```
+### Phase 3: Topic Extraction (AI-Driven)
 
-Many valid tasks here. Review carefully.
+Read the confirmed tasks and generate topics. Group related statements into coherent topics. Create a topics array:
 
-### Step 4: Review Low-Confidence Items
+```javascript
+const topics = [
+  { title: "User Authentication", keywords: ["login", "auth", "password"], description: "..." },
+  { title: "Dashboard Layout", keywords: ["dashboard", "layout", "widgets"], description: "..." }
+];
 ```
-flow extract-zero-loss show low
+
+### Phase 4: Run Full Pipeline (Passes 2-4)
+
+```javascript
+const { runFullPipeline } = require('./scripts/flow-long-input');
+const pipelineResult = runFullPipeline({
+  transcript: inputText,
+  topics: topics,
+  contentType: 'transcript'
+});
 ```
 
-Some may be tasks phrased informally. Don't skip!
+This chains: statement mapping → orphan check → contradiction resolution.
 
-### Step 5: Handle Filler (Optional)
+Display summary:
 ```
-flow extract-zero-loss dismiss-filler
+Pipeline Complete:
+  Topics: N
+  Statements mapped: X/Y (Z% coverage)
+  Orphans: A found, B resolved, C new topics created
+  Contradictions: D found, E auto-resolved, F need clarification
 ```
 
-Dismiss conversational filler like "um", "okay", "thanks".
+### Phase 5: Clarification Questions (User Touchpoint)
 
-### Step 6: Confirm Completeness (MANDATORY)
-```
-flow extract-zero-loss complete
+Check `pipelineResult.clarification_questions`. If any exist:
+
+```javascript
+if (pipelineResult.clarification_questions.length > 0) {
+  // Present ALL questions in one batch using AskUserQuestion
+  // Contradiction questions: "You said X but later said Y. Which do you prefer?"
+  // Orphan questions: "You mentioned X — which feature does this relate to?"
+}
 ```
 
-User must explicitly confirm the task list is complete before proceeding.
+Use `AskUserQuestion` to present all questions at once. After user answers, apply resolutions:
 
-## Integration with Long-Input Processing
+```javascript
+const { resolveContradictionWithChoice } = require('./scripts/flow-long-input');
+// For each contradiction answer:
+resolveContradictionWithChoice(contradictionId, userChoice);
+```
 
-After zero-loss extraction and review:
-1. Confirmed tasks become the input for topic extraction
-2. Topics are generated from the confirmed task list
-3. Standard 4-pass processing continues
-4. Final output creates stories in `ready.json` via `/wogi-story`
-5. Each story then executes through the full `/wogi-start` pipeline
+**If zero clarification questions**, skip this phase entirely — fully autonomous.
 
-```bash
-# Full flow
-cat transcript.txt | flow extract-zero-loss start
-flow extract-zero-loss confirm-high
-# ... manual review ...
-flow extract-zero-loss complete
-flow long-input topics    # Now uses confirmed tasks
-flow long-input pass2
-flow long-input pass3
-flow long-input pass4
+### Phase 6: Generate Stories and Export
+
+```javascript
+const { generateAndExportStories } = require('./scripts/flow-long-input-stories');
+const exportResult = await generateAndExportStories({ featureName: 'extract-review' });
 ```
 
-## Why This Matters
+Display final summary:
+```
+Pipeline Complete!
+  Input: N raw statements
+  Output: M stories added to ready.json
 
-> "When I work with my employees, when we have a meeting, even if it takes an hour or two, when I give a task, an employee will write it down, add a comment on Figma, add it to Jira, write it down in his notebook, but nothing is getting missed."
+  Stories:
+  1. wf-XXXXXXXX — "Story Title" (X criteria, Y% coverage)
+  2. wf-XXXXXXXX — "Story Title" (X criteria, Y% coverage)
 
-This system ensures:
-- **100% capture rate** - Nothing is auto-filtered
-- **Explicit confirmation** - User reviews everything
-- **Audit trail** - Track what was confirmed vs removed
-- **Reason required** - Can't remove without explanation
+  Files saved to: .workflow/changes/extract-review/
+  Run /wogi-start to begin implementing.
+```
 
 ## Confidence Levels
 
 Items are scored (not filtered!) by confidence:
 
-**High Confidence** - Contains explicit requirement signals:
-- "We need to add..."
-- "Should display..."
-- "Must have..."
-- "I would like..."
-- "Change X to Y"
+**High Confidence** — Contains explicit requirement signals:
+- "We need to add...", "Should display...", "Must have..."
+- "I would like...", "Change X to Y"
+
+**Medium Confidence** — Contains softer signals:
+- "Maybe we could...", "What if we...", "Going to need..."
+
+**Low Confidence** — No clear signals but may be tasks:
+- Short statements, Questions, Partial sentences
+
+**Filler** — Conversational noise (still captured!):
+- "Um", "Okay", "Thanks", "Can you hear me?", "Makes sense"
 
-**Medium Confidence** - Contains softer signals:
-- "Maybe we could..."
-- "What if we..."
-- "Going to need..."
+## Contradiction Auto-Resolution
 
-**Low Confidence** - No clear signals but may be tasks:
-- Short statements
-- Questions
-- Partial sentences
+Contradictions are resolved automatically using temporal ordering:
 
-**Filler** - Conversational noise (still captured!):
-- "Um", "Okay", "Thanks"
-- "Can you hear me?"
-- "Makes sense"
+1. **Correction phrases** ("actually", "instead", "no wait", "scratch that") → later statement wins (high confidence)
+2. **Same speaker** → +15% confidence boost
+3. **Later position** → +10% confidence for significant distance
+4. **Additive patterns** ("also add X") → NOT a contradiction, both kept
+5. **Auto-resolve at >= 0.8 confidence** → silently resolved
+6. **Below 0.8 confidence** → presented as clarifying question to user
+
+The superseded statement is marked and excluded from story generation.
 
 ## Files
 
 | File | Location |
 |------|----------|
-| Extraction module | `scripts/flow-zero-loss-extraction.js` |
+| Extraction engine | `scripts/flow-zero-loss-extraction.js` |
 | Review module | `scripts/flow-extraction-review.js` |
+| Long-input pipeline | `scripts/flow-long-input.js` |
+| Story generation | `scripts/flow-long-input-stories.js` |
 | Review session | `.workflow/tmp/long-input/review-session.json` |
+| Active digest | `.workflow/tmp/long-input/active-digest.json` |
 
-## For Claude
+## Advanced Mode (Manual CLI)
 
-When processing long transcripts:
+For power users who want step-by-step control:
 
-1. **Always use zero-loss extraction** for meeting transcripts and reviews
-2. **Present items by confidence level** to the user
-3. **Never skip low-confidence items** - user must explicitly dismiss
-4. **Require completeness confirmation** before proceeding to topic extraction
-5. **Log all confirmed tasks** for audit trail
+```bash
+# Step 1: Extract
+flow extract-zero-loss start < transcript.txt
 
-The goal is **100% task capture rate**, not 90%.
+# Step 2: Review manually
+flow extract-zero-loss show high
+flow extract-zero-loss confirm-high
+flow extract-zero-loss show medium
+flow extract-zero-loss show low
+flow extract-zero-loss dismiss-filler
+flow extract-zero-loss complete
+
+# Step 3: Run pipeline passes manually
+flow long-input topics
+flow long-input pass2
+flow long-input pass3
+flow long-input pass4
+
+# Step 4: Generate and export stories
+flow long-input generate-stories
+flow long-input present
+flow long-input finalize
+```
+
+## Why This Matters
+
+> "When I work with my employees, when we have a meeting, even if it takes an hour or two, when I give a task, an employee will write it down, add a comment on Figma, add it to Jira, write it down in his notebook, but nothing is getting missed."
+
+This system ensures:
+- **100% capture rate** — Nothing is auto-filtered
+- **Zero manual commands** — AI orchestrates the entire pipeline
+- **Smart contradiction resolution** — Later statements override earlier ones
+- **One user touchpoint** — Only clarifying questions when AI can't auto-resolve
+- **Audit trail** — Track what was confirmed, removed, or auto-resolved
+- **Source tracing** — Every story traces back to original statements