owflow 0.1.0 → 0.1.2

package/dist/commands/reviews-reality-check.md

@@ -0,0 +1,110 @@
+---
+name: reviews-reality-check
+description: Comprehensive reality assessment of completed work to verify it actually works and is production-ready
+---
+
+**ACTION REQUIRED**: This command delegates to a different skill. The `<command-name>` tag refers to THIS command, not the target. Call the Task tool with subagent_type="reality-assessor" NOW. Pass the task path in the prompt. Do not read files, explore code, or execute workflow steps yourself.
+
+You are running a comprehensive reality check using the `reality-assessor` agent.
+
+## Your Task
+
+You are performing no-nonsense reality assessment to determine if completed work actually works and solves the business problem.
+
+## Parse User Request
+
+**Determine the following from the user's request:**
+
+1. **Task path**:
+   - If provided: Use the specified task directory path
+   - If not provided: Use question to ask for task path
+
+## Your Instructions
+
+**Invoke the reality-assessor agent NOW using the Task tool:**
+
+```
+Task Tool:
+- subagent_type: reality-assessor
+- description: Reality assessment
+- prompt: |
+    You are the reality-assessor agent. Assess the reality of completion for: [task-path]
+
+    Your task:
+    1. Load all available verification reports (implementation-verifier, pragmatic-review.md, code-review-report.md, spec-audit.md)
+    2. Assess claimed completion (check implementation-plan.md markers, test results, verification status)
+    3. Validate functional completeness:
+       - Run tests yourself (don't trust reports)
+       - Test end-to-end workflows (not just unit tests)
+       - Try error scenarios (invalid inputs, edge cases, realistic data)
+       - Test integration with dependent systems
+       - Test under realistic conditions
+    4. Identify reality gaps (functionality, quality, production readiness)
+    5. Check integration points (data flow, API contracts, auth, external systems)
+    6. Generate reality assessment report with clear deployment decision
+
+    Save report to: verification/reality-check.md
+
+    Focus on: Does this ACTUALLY work for intended purpose? Functional reality over technical perfection.
+
+    Provide clear deployment decision: ✅ Ready | ⚠️ Issues Found | ❌ Not Ready
+```
+
+**Wait for the agent to complete before proceeding.**
+
+The reality-assessor agent will:
+
+1. Review all available verification reports
+2. Validate claimed completions through independent testing
+3. Test end-to-end functionality (not just isolated tests)
+4. Identify gaps between claims and reality
+5. Check integration with rest of system
+6. Assess production readiness
+7. Provide pragmatic action plan (if gaps exist)
+8. Make clear GO/NO-GO deployment decision
+
+## Examples
+
+**Example 1**: Reality check before deployment
+
+```
+User: /reviews-reality-check .owflow/tasks/development/2025-11-17-payment-processing/
+```
+
+**Example 2**: Verify claimed completion
+
+```
+User: /reviews-reality-check .owflow/tasks/development/2025-11-17-login-timeout/
+```
+
+**Example 3**: Production readiness check
+
+```
+User: /reviews-reality-check .owflow/tasks/development/2025-11-17-user-dashboard/ --production
+```
+
+## What to Expect
+
+The reality-assessor will provide:
+
+- Reality vs claims gap analysis
+- Critical gaps preventing deployment (Critical severity)
+- Quality gaps affecting reliability (High/Medium severity)
+- Integration issues with system components
+- Functional completeness percentage assessment
+- Pragmatic action plan with specific steps
+- Clear deployment decision (✅ Ready | ⚠️ Issues | ❌ Not Ready)
+- Evidence-based assessment (test results, error messages, observed behavior)
+
+## Notes
+
+- This is validation only - no code will be modified
+- Runs actual tests and workflows, doesn't just read reports
+- Tests with realistic data and scenarios
+- Checks production configuration and deployment readiness
+- Focus on: Does it ACTUALLY work and solve the problem?
+- Severity levels guide deployment decision:
+  - **Critical**: Must fix before deployment (prevents GO decision)
+  - **High**: Should fix soon (allows conditional GO with monitoring)
+  - **Medium**: Can deploy with known issues
+  - **Low**: Minor issues, acceptable

package/dist/commands/reviews-spec-audit.md

@@ -0,0 +1,114 @@
+---
+name: reviews-spec-audit
+description: Independent specification audit to verify completeness and clarity before implementation
+---
+
+**ACTION REQUIRED**: This command delegates to a different skill. The `<command-name>` tag refers to THIS command, not the target. Call the Task tool with subagent_type="spec-auditor" NOW. Pass the spec path in the prompt. Do not read files, explore code, or execute workflow steps yourself.
+
+You are running an independent specification audit using the `spec-auditor` agent.
+
+## Your Task
+
+You are performing senior auditor review of specifications to verify completeness, clarity, and implementability.
+
+## Parse User Request
+
+**Determine the following from the user's request:**
+
+1. **Specification path**:
+   - If provided: Use the specified spec file path
+   - If not provided: Use question to ask for spec.md path
+
+2. **Audit type**:
+   - **Pre-implementation**: Audit spec before building (default)
+   - **Post-implementation**: Audit spec vs actual implementation (if implementation exists)
+
+## Your Instructions
+
+**Invoke the spec-auditor agent NOW using the Task tool:**
+
+```
+Task Tool:
+- subagent_type: spec-auditor
+- description: Specification audit
+- prompt: |
+    You are the spec-auditor agent. Audit the specification at: [spec-path]
+
+    Your task:
+    1. Read and comprehend the specification thoroughly
+    2. [If pre-implementation]: Identify ambiguities, missing details, unclear sections
+    3. [If post-implementation]: Examine actual implementation independently
+    4. [If post-implementation]: Compare specification vs implementation
+    5. Categorize gaps (Missing/Incomplete/Incorrect/Extra/Ambiguous)
+    6. Assign severity to each finding (Critical/High/Medium/Low)
+    7. Request clarification for ambiguous specifications
+    8. Generate comprehensive audit report
+
+    [If post-implementation]:
+    - Use az CLI to verify Azure resources if applicable
+    - Use gh CLI to verify GitHub integration if applicable
+    - Examine codebase, database schemas, API endpoints, configurations
+    - Trust nothing, verify everything independently
+
+    Save report to: verification/spec-audit.md
+
+    Focus on: Evidence-based assessment. Every finding must have file:line references or clear evidence.
+```
+
+**Wait for the agent to complete before proceeding.**
+
+The spec-auditor agent will:
+
+1. Thoroughly read and understand specification
+2. Identify ambiguities, unclear sections, missing details
+3. (If post-impl) Independently examine actual implementation
+4. (If post-impl) Compare specification vs implementation using external tools
+5. Categorize gaps with evidence
+6. Assign severity with justification
+7. Ask clarifying questions for ambiguities
+8. Provide recommendations for compliance
+
+## Examples
+
+**Example 1**: Pre-implementation spec audit
+
+```
+User: /reviews-spec-audit .owflow/tasks/development/2025-11-17-user-auth/implementation/spec.md
+```
+
+**Example 2**: Post-implementation audit
+
+```
+User: /reviews-spec-audit .owflow/tasks/development/2025-11-17-user-auth/ --post-implementation
+```
+
+**Example 3**: Audit with clarification focus
+
+```
+User: /reviews-spec-audit spec.md --focus=ambiguity
+```
+
+## What to Expect
+
+The spec-auditor will provide:
+
+- Specification completeness assessment
+- Ambiguities and unclear sections identified
+- (If post-impl) Gaps between spec and implementation (Missing/Incomplete/Incorrect/Extra)
+- All findings with evidence (file:line references or absence proof)
+- Severity assessment (Critical/High/Medium/Low)
+- Clarification questions for stakeholders
+- Compliance status (✅ Compliant | ⚠️ Mostly Compliant | ❌ Non-Compliant)
+- Specific recommendations for each finding
+
+## Notes
+
+- This is analysis only - no code or specs will be modified
+- Senior auditor perspective: healthy skepticism, verify independently
+- Uses external tools (az CLI, gh CLI) for deployment verification
+- Focus on functional reality, not theoretical compliance
+- Severity levels guide prioritization:
+  - **Critical**: Breaks core functionality, blocks deployment
+  - **High**: Important feature missing/incorrect
+  - **Medium**: Nice-to-have missing, workarounds exist
+  - **Low**: Minor discrepancy, low user impact

package/dist/commands/standards-discover.md

@@ -0,0 +1,37 @@
+---
+name: standards-discover
+description: Discover coding standards from project configuration files, code patterns, documentation, and external sources (PRs, CI/CD)
+argument-hint: [task description]
+generated-from-skill: true
+---
+
+CRITICAL INSTRUCTION: You MUST invoke the standards-discover skill immediately as your FIRST action.
+
+Use the Skill tool with these exact parameters:
+name: "standards-discover"
+prompt: "$ARGUMENTS"
+
+DO NOT:
+
+- Analyze the task before invoking the skill
+- Decide the task is "straightforward" and skip the skill
+- Substitute your own approach or workflow
+- Execute any part of the workflow yourself
+
+WHY: The user explicitly chose this workflow by using /standards-discover.
+Invoke the skill now and let it orchestrate the complete workflow.
+
+---
+
+## About This Workflow
+
+Discover coding standards from project configuration files, code patterns, documentation, and external sources (PRs, CI/CD)
+
+The skill handles:
+
+- Task directory creation and state management
+- Phase execution with interactive gates
+- Subagent delegation for specialized work
+- Pause/resume capability
+
+See `skills/standards-discover/SKILL.md` for complete workflow documentation.

package/dist/commands/standards-update.md

@@ -0,0 +1,37 @@
+---
+name: standards-update
+description: Update or create project standards from conversation context or explicit description
+argument-hint: "[description of standard/convention] [--from=PATH]"
+generated-from-skill: true
+---
+
+CRITICAL INSTRUCTION: You MUST invoke the standards-update skill immediately as your FIRST action.
+
+Use the Skill tool with these exact parameters:
+name: "standards-update"
+prompt: "$ARGUMENTS"
+
+DO NOT:
+
+- Analyze the task before invoking the skill
+- Decide the task is "straightforward" and skip the skill
+- Substitute your own approach or workflow
+- Execute any part of the workflow yourself
+
+WHY: The user explicitly chose this workflow by using /standards-update.
+Invoke the skill now and let it orchestrate the complete workflow.
+
+---
+
+## About This Workflow
+
+Update or create project standards from conversation context or explicit description
+
+The skill handles:
+
+- Task directory creation and state management
+- Phase execution with interactive gates
+- Subagent delegation for specialized work
+- Pause/resume capability
+
+See `skills/standards-update/SKILL.md` for complete workflow documentation.

package/dist/commands/work.md

@@ -0,0 +1,284 @@
+---
+name: work
+description: Unified entry point — auto-classifies tasks and routes to appropriate workflow. ALWAYS execute when invoked via slash command.
+---
+
+**NOTE**: This is a multi-step workflow that invokes the task-classifier subagent and orchestrator skills at specific steps. The `<command-name>` tag refers to THIS command only — you MUST still use the Skill tool to invoke those other skills when instructed below. Follow ALL steps in order.
+
+# Unified Work Entry Point
+
+Auto-classifies tasks and routes to the appropriate workflow orchestrator. Supports resuming existing tasks or starting new ones.
+
+## Usage
+
+```bash
+/work [task description | task folder path | issue identifier]
+```
+
+### Input Types
+
+| Input Type       | Example                                                           |
+| ---------------- | ----------------------------------------------------------------- |
+| Task folder path | `.owflow/tasks/development/2025-10-23-login-timeout`              |
+| Folder name only | `2025-10-26-user-auth` (searches all task types)                  |
+| Task description | `"Fix login timeout error on mobile"`                             |
+| GitHub issue     | `#456`, `GH-456`, `https://github.com/owner/repo/issues/456`      |
+| Jira ticket      | `PROJ-456`, `https://company.atlassian.net/browse/PROJ-456`       |
+| Azure DevOps     | `AB#123`, `https://dev.azure.com/org/project/_workitems/edit/123` |
+| No argument      | Prompts for input                                                 |
+
+## Examples
+
+```bash
+# Resume existing task
+/work ".owflow/tasks/development/2025-10-23-login-timeout"
+/work "2025-10-26-user-auth"
+
+# New task (auto-classifies)
+/work "Fix login timeout error on mobile devices"
+/work "Add user authentication with email/password"
+/work "Improve dashboard loading performance"
+
+# From issue tracker
+/work "#456"
+/work "PROJ-123"
+/work "AB#789"
+```
+
+## How It Works
+
+1. **Detect existing task** - If input is a task folder path, route to resume
+2. **Classify new task** - Invoke task-classifier subagent to determine workflow type
+3. **Route to workflow** - Use Skill tool to invoke appropriate orchestrator skill
+
+## Workflow Type Routing
+
+| Classification | Routes To (Skill) |
+| -------------- | ----------------- |
+| development    | `development`     |
+| performance    | `performance`     |
+| migration      | `migration`       |
+| research       | `research`        |
+| product-design | `product-design`  |
+
+---
+
+## Workflow
+
+### Step 1: Parse Input and Detect Task Folder
+
+**Check if input is an existing task folder:**
+
+1. Try path as-is (absolute path)
+2. Try prepending `.owflow/` (relative path)
+3. Search `.owflow/tasks/*/` for folder name match
+
+**If folder exists AND contains `orchestrator-state.yml`:**
+
+- Go to **Step 2: Resume Existing Task**
+
+**If NOT a task folder:**
+
+- Go to **Step 3: Classify & Route New Task**
+
+**If no argument provided:**
+
+- Prompt user: "What would you like to work on?" with input examples
+- Then check if input is task folder or description
+
+### Step 2: Resume Existing Task
+
+**When existing task detected:**
+
+1. Read `orchestrator-state.yml` from task folder
+2. Determine workflow type from folder path:
+
+| Folder            | Workflow Type  |
+| ----------------- | -------------- |
+| `development/`    | development    |
+| `performance/`    | performance    |
+| `migrations/`     | migration      |
+| `research/`       | research       |
+| `product-design/` | product-design |
+
+3. Extract status from state file:
+   - `completed`: null = in-progress, timestamp = finished
+   - `completed_phases`: derive active phase as first phase not in this list
+   - `failed_phases`: array of failed attempts
+
+4. Present status to user with question:
+
+**For In-Progress Tasks:**
+
+```
+Options:
+1. Resume from next incomplete phase
+2. Restart from specific phase
+3. Cancel
+```
+
+**For Completed Tasks:**
+
+```
+Options:
+1. View task details
+2. Create follow-up development task
+3. Re-run verification phase
+4. Cancel
+```
+
+**For Failed Tasks:**
+
+```
+Options:
+1. Resume with fresh attempts (--reset-attempts --clear-failures)
+2. Retry failed phase
+3. Restart from specific phase
+4. Cancel
+```
+
+5. **Route using Skill tool:**
+
+```
+Use Skill tool:
+  skill: "[orchestrator-name]"
+  args: "--resume [task_path] [flags]"
+```
+
+Examples:
+
+- Resume development: `skill: "development"` with `args: "--resume .owflow/tasks/development/2025-10-23-fix"`
+- Restart from phase: `skill: "development"` with `args: "--resume .owflow/tasks/development/2025-10-26-auth --from=verify"`
+- Fresh attempts: `skill: "migration"` with `args: "--resume .owflow/tasks/migrations/2025-10-20-redux --reset-attempts"`
+
+### Step 3: Classify & Route New Task
+
+**For new task descriptions:**
+
+1. **Invoke task-classifier subagent** to determine workflow type:
+
+```
+Use Task tool:
+  subagent_type: "task-classifier"
+  description: "Classify task type"
+  prompt: "Classify this task into a workflow type: [task description].
+           Return structured YAML classification result."
+
+The subagent will:
+- Detect issue identifiers (GitHub, Jira)
+- Fetch issue details if available
+- Analyze codebase context
+- Match keywords and calculate confidence
+- Confirm with user if needed
+- Return classification in YAML format
+```
+
+2. **Parse classification result:**
+
+```yaml
+classification:
+  task_type: [development|performance|migration|research|product-design]
+  confidence: [percentage]
+  reasoning: [explanation]
+```
+
+3. **Route to appropriate workflow using Skill tool:**
+
+```
+Display:
+  Task classified as: [task_type] ([confidence]% confidence)
+  Routing to [task_type] workflow...
+
+Use Skill tool:
+  skill: "[orchestrator-name]"
+  args: "[description]"
+```
+
+**Routing examples:**
+
+- development (92%): `skill: "development"` with `args: "Fix login timeout error"`
+- development (88%): `skill: "development"` with `args: "Add filtering to user table"`
+- performance (95%): `skill: "performance"` with `args: "Optimize slow dashboard queries"`
+
+---
+
+## Error Handling
+
+### Classification Fails
+
+If task-classifier returns error:
+
+```
+Display:
+"Unable to automatically classify this task. Please select manually:"
+
+Use question with options:
+1. Development - Fix bugs, improve features, or add new capabilities
+2. Performance - Optimize speed/efficiency
+3. Migration - Move to new tech/pattern
+4. Research - Investigate and document findings
+5. Product Design - Design features or products before building them
+
+Then route to selected workflow using Skill tool.
+```
+
+### User Cancels
+
+```
+Display:
+"Task cancelled. You can:
+- Run /work again when ready
+- Use specific workflow commands directly:
+  /development, /performance, etc."
+```
+
+---
+
+## Resume Skill Reference
+
+| Workflow Type  | Skill            | Args                                                |
+| -------------- | ---------------- | --------------------------------------------------- |
+| development    | `development`    | `--resume [path] [--from=PHASE] [--reset-attempts]` |
+| performance    | `performance`    | `--resume [path] [--from=PHASE]`                    |
+| migration      | `migration`      | `--resume [path] [--from=PHASE]`                    |
+| research       | `research`       | `--resume [path] [--from=PHASE]`                    |
+| product-design | `product-design` | `--resume [path] [--from=PHASE]`                    |
+
+---
+
+## Integration Notes
+
+### With Task Classifier
+
+The `/work` command delegates classification to the task-classifier subagent via Task tool, which:
+
+- Fetches issue details from GitHub/Jira/Azure DevOps (via MCP, CLI tools, or WebFetch)
+- Analyzes codebase context for better classification
+- Uses confidence-based user confirmation
+- Returns structured classification result
+
+### With Orchestrators
+
+After classification/detection, this command routes to the appropriate orchestrator via Skill tool:
+
+- Each orchestrator handles its specific workflow (spec, plan, implement, verify, etc.)
+- State is persisted in `orchestrator-state.yml` for pause/resume
+- Auto-recovery handles common failures
+
+### With Project Documentation
+
+Uses project documentation for context:
+
+- `.owflow/docs/INDEX.md` - Project overview and standards
+- `.owflow/tasks/` - Existing task directories
+
+---
+
+## Key Behaviors
+
+1. **Single entry point** - One command for all workflow types
+2. **Auto-classification** - Intelligent routing based on task description
+3. **Resume support** - Detects and resumes existing tasks
+4. **Issue integration** - Fetches details from GitHub/Jira/Azure DevOps
+5. **Direct skill invocation** - Uses Skill tool for immediate orchestrator loading
+6. **Graceful fallback** - Manual selection if classification fails