owflow 0.4.3 → 0.6.0

package/dist/skills/performance-spec/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: owflow:performance-spec
+description: Performance — requirements gathering, specification creation via delegation, diagram refinement, and conditional specification audit. Continues with performance-plan.
+argument-hint: "[task-path-or-identifier]"
+user-invocable: true
+---
+
+# Performance Spec — Requirements, Specification & Conditional Audit (spec-written, spec-audited)
+
+Work step of the performance workflow. Presents the bottleneck analysis, gathers optimization priorities, constraints, and targets, creates the specification via delegation, refines it with diagrams, then offers an independent specification audit. State lives in `orchestrator-state.yml` — this skill reads it on entry and writes results on exit.
+
+## Entry Gate
+
+Resolve the argument BEFORE anything else (see [Gate Contract](../orchestrator-framework/references/gate-contract.md)). The argument may be:
+
+- **Path** (absolute or project-relative) to the task directory — use as-is.
+- **Identifier** — exact directory name inside `.owflow/tasks/performance/` (e.g., `2026-10-02-api-latency`); resolve to its path.
+- **Description** — anything else (free text) is treated as a new performance task description: ask via `question` whether to start a fresh standard task at this step (mid-pipeline bootstrap) or route through `/owflow:performance <description>`; on decline, print the blocked block and STOP.
+- If the argument is **missing**, the path does **not exist**, or matches **no identifier** → print the blocked block, then STOP (never guess or auto-pick a task):
+
+1. Steps that must be completed first (in order), each with its command:
+   - Codebase & bottleneck analysis (`codebase-analysed`, `bottlenecks-identified`) → `/owflow:performance-analyze <task-path>`
+2. List available performance-task identifiers (directories under `.owflow/tasks/performance/`) to resume from, if any.
+3. Hint: `Run /owflow:performance <description> to start a task from scratch, or pass a task path/identifier to resume.`
+
+### Prerequisites
+
+| Required for this skill        | Where verified                                                                              | Produced by                          |
+| ------------------------------ | ------------------------------------------------------------------------------------------- | ------------------------------------ |
+| State file exists              | `<task-path>/orchestrator-state.yml`                                                        | `/owflow:performance <desc>`         |
+| Bottleneck analysis done       | `bottlenecks-identified` in `completed_phases` + `analysis/performance-analysis.md` exists  | `/owflow:performance-analyze <task-path>` |
+
+1. **Read `orchestrator-state.yml`** from the task path. If missing → mid-pipeline bootstrap ([Missing-state Bootstrap](../orchestrator-framework/references/gate-contract.md), starting slug `spec-written`): `question` — create a fresh standard performance task starting at this step, or decline → print `No performance task found at <path>. Run /owflow:performance <description> to start a task from scratch.` and STOP.
+2. **Skip/resume (artifacts before state)**:
+   - If `spec-written` is complete but `implementation/spec.md` is missing → drop the slug and re-run the specification step.
+   - If `spec-written` and `spec-audited` are complete: validate `verification/spec-audit.md` exists; missing → drop `spec-audited` and run the audit sub-step; otherwise report existing results and route to the Exit Gate.
+   - If only `spec-written` is complete: `options.spec_audit_enabled: false` → report the spec summary and route to the Exit Gate (do not re-ask); otherwise (`null` or `true`) skip directly to the audit sub-step — never re-run Requirements Gathering or Specification Creation.
+3. **Audit skip/resume rule (audit-decision guard)**: the audit question is asked while `options.spec_audit_enabled` is `null`, and only then; a resume with `true` and the audit artifact missing goes straight to the auditor without re-asking. On skip, write `options.spec_audit_enabled: false` and NO `spec-audited` entry; a later resume with `false` does not re-ask. The audit is the conditional activation of this skill's second slug.
+4. **Prerequisite check (presence and content)**: `bottlenecks-identified` in `completed_phases` AND `analysis/performance-analysis.md` exists. If missing → print the blocked block, then STOP:
+   - Steps that must be completed first: codebase & bottleneck analysis (`codebase-analysed`, `bottlenecks-identified`).
+   - `Run /owflow:performance-analyze <task-path> first.`
+   - If no task exists yet: `Run /owflow:performance <description> to start a task from scratch.`
+
+## Execute
+
+**Read first**: the [Delegation Rules](../orchestrator-framework/references/delegation-rules.md).
+
+### Requirements Gathering (part of `spec-written`, inline)
+
+1. Present the bottleneck summary from `analysis/performance-analysis.md` (P0-P3 counts and top findings).
+2. `question` for optimization requirements:
+   - Which bottleneck priorities to address? (All P0+P1 / P0 only / specific ones)
+   - Any constraints? (backward compatibility, memory limits, no new dependencies)
+   - Performance targets? (specific response-time or throughput goals, if known)
+3. Save to `analysis/requirements.md`: performance issue description, bottleneck analysis summary, optimization priorities, constraints, targets.
+4. **Standards discovery**: Read `.owflow/docs/INDEX.md` before creating the spec.
+
+### Specification Creation (part of `spec-written`, subagent)
+
+**ANTI-PATTERN — never write spec.md yourself. "The optimization is straightforward" is NOT a reason to skip delegation.**
+
+- ❌ "Let me create the specification..." — STOP. Delegate to `specification-creator`.
+- ❌ "I'll write the spec based on the analysis..." — STOP. Delegate to `specification-creator`.
+
+**INVOKE NOW** (Task tool — never the Skill tool; this is an agent): Task tool - `specification-creator` subagent. Pass (Pattern 7 — accumulated context): task_path, task_type="performance", task_description, requirements_path (`analysis/requirements.md`), project_context_paths (INDEX.md + `performance_context.project_doc_paths` from state), `performance_context.task_characteristics`, `performance_context.bottleneck_priorities`, and relevant `performance_context.phase_summaries` (codebase_analysis, bottleneck_analysis, clarifications). Output: `implementation/spec.md`.
+
+**SELF-CHECK**: Did you just invoke the Task tool with `specification-creator`? Or did you start writing spec.md yourself? If the latter, STOP and invoke the Task tool.
+
+### Diagram Refinement (part of `spec-written`, Skill, content-preserving)
+
+Skill tool - `diagrams-mermaid` on `implementation/spec.md`. Add diagrams that clarify bottleneck flows and optimization boundaries without replacing specification prose: `flowchart` (bottleneck → fix path), optional `sequenceDiagram` (key hot path). Missing context → add an explicit open-questions section instead of inventing entities.
+
+### Specification Audit (`spec-audited`, conditional)
+
+> **ANTI-PATTERN — never audit the specification yourself. "The spec is short" is NOT a reason to skip delegation.**
+>
+> - ❌ "Let me review the spec myself..." — STOP. Delegate to `spec-auditor`.
+> - ❌ "I'll check the spec against the analysis..." — STOP. Delegate to `spec-auditor`.
+
+1. If `options.spec_audit_enabled` is already `true` (resume with `verification/spec-audit.md` missing), skip the question and go to step 2. Otherwise `question` — "Run specification audit? (Recommended)" with "Yes, run audit (Recommended)" first. Pre-select the recommended option when the monolith threshold is met: more than 5 optimizations planned or the spec exceeds 50 lines. The user may skip.
+2. If yes: **INVOKE NOW** (Task tool): Task tool - `spec-auditor` subagent. Pass (Pattern 7 — accumulated context): task_path, spec_path (`implementation/spec.md`), plus the bottleneck priorities and spec summary from `performance_context.phase_summaries.specification` for framing. Output: `verification/spec-audit.md`. Display the verdict (pass / pass-with-concerns / fail), issue counts by severity, and top critical findings.
+3. **SELF-CHECK**: Did you just invoke the Task tool with `spec-auditor`? Or did you review the spec yourself? If the latter, STOP and invoke the Task tool.
+
+**The audit verdict has no separate state slot** — it is recorded in `performance_context.phase_summaries.specification` (the same slot as the spec summary).
+
+## State Update Convention (per step)
+
+Apply after EVERY step above:
+
+1. **Write immediately** — update `orchestrator-state.yml` as soon as the step completes, appending ONLY the step slug actually performed plus that step's fields. Never batch multiple steps into one end-of-skill write:
+   - After the specification step (`spec-written` complete): append `spec-written` to `completed_phases`; set `performance_context.phase_summaries.specification` (approach + scope summary); bump `orchestrator.updated`.
+   - After the audit sub-step (only when it ran): append `spec-audited` to `completed_phases`; set `options.spec_audit_enabled: true` and the audit verdict in `performance_context.phase_summaries.specification`; bump `orchestrator.updated`.
+   - When the user skips the audit: set `options.spec_audit_enabled: false` and note "audit skipped" in `performance_context.phase_summaries.specification` — **no `spec-audited` entry**.
+2. **Timestamp** — set `orchestrator.updated` to the current UTC timestamp on every write.
+3. **Failures** — if the specification or audit fails and cannot be recovered, do NOT append to `completed_phases`; instead append the step's slug (`spec-written` or `spec-audited`) to `orchestrator.failed_phases` and increment `auto_fix_attempts["<slug>"]`.
+4. **Validate** — after every write, re-read the file to confirm values, then run the `verify_template` tool with `filePath: <task-path>/orchestrator-state.yml`, `templateName: orchestrator-state-performance.yml`. Fix any reported issue immediately before proceeding.
+5. **Final check** — before the Exit Gate, one consolidated re-read + `verify_template` run to confirm the full state matches everything performed in this session.
+
+## Recovery
+
+| Step                              | Max Attempts | Strategy                                                                        |
+| --------------------------------- | ------------ | ------------------------------------------------------------------------------- |
+| Specification (`spec-written`)    | 2            | Regenerate spec with adjusted requirements                                       |
+| Specification Audit (`spec-audited`) | 2         | Re-run the auditor; on repeated failure report the verdict and offer the skip path |
+
+## Exit Gate
+
+Present results, get user confirmation, then hand off (see [Gate Contract](../orchestrator-framework/references/gate-contract.md)). Never auto-invoke the next skill.
+
+### Results box
+
+```markdown
+## ✅ PERFORMANCE SPEC COMPLETE — <spec title>
+
+**Approach** — [optimization approach in 1 line]
+**Scope** — [N included / M excluded]
+**Audit** — [✅ pass / ⚠ pass-with-concerns / ❌ fail / skipped]: [0 critical / N major / N minor]
+**Priorities** — [P0/P1/P2/P3 addressed]
+
+**Artifacts**
+
+- `analysis/requirements.md`
+- `implementation/spec.md`
+- `verification/spec-audit.md` [conditional]
+```
+
+### Results-acceptance question
+
+Use `question` — "Are these results correct?" with options:
+
+- **Accept** — the specification is good; continue.
+- **Adjust** — regenerate the spec with the user's corrections (priorities, constraints, targets), update state and artifacts, re-present the results box.
+- **Discuss** — walk through a specific part of the spec (scope boundaries, optimization approach, audit findings) in more depth; then re-ask.
+- **Stop here** — print the resume command (`/owflow:performance-spec <task-path>`) and end.
+
+### Next steps (after Accept)
+
+- `→ /owflow:performance-plan <task-path>` — `required` next: breaks the approved spec into grouped, dependency-ordered task groups. Remaining after: implement → verify → finalize.
+
+**Other options**:
+
+- `/owflow:reviews-spec-audit <task-path>` — `optional` — standalone spec re-audit; does not advance phases (verify results, then re-run `/owflow:performance-spec` adjustments if needed)
+- `/owflow:goal-performance <task-path>` — `optional` shortcut: runs all remaining steps in one loop (plan → implement → verify → finalize)
+
+Then STOP.

package/dist/skills/performance-verify/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: owflow:performance-verify
+description: Performance — verification options prompt, comprehensive implementation verification, and user-driven fix loop. Continues with performance-finalize.
+argument-hint: "[task-path-or-identifier]"
+user-invocable: true
+---
+
+# Performance Verify — Verification Options & Issue Resolution (options-chosen, verification-done)
+
+Work step of the performance workflow. Lets the user pick which additional verification checks run, writes the chosen `options.*` to state BEFORE verification starts, then delegates comprehensive verification with a fix-then-reverify loop. State lives in `orchestrator-state.yml` — this skill reads it on entry and writes results on exit.
+
+## Entry Gate
+
+Resolve the argument BEFORE anything else (see [Gate Contract](../orchestrator-framework/references/gate-contract.md)). The argument may be:
+
+- **Path** (absolute or project-relative) to the task directory — use as-is.
+- **Identifier** — exact directory name inside `.owflow/tasks/performance/` (e.g., `2026-10-02-api-latency`); resolve to its path.
+- **Description** — anything else (free text) is treated as a new performance task description: ask via `question` whether to start a fresh standard task at this step (mid-pipeline bootstrap) or route through `/owflow:performance <description>`; on decline, print the blocked block and STOP.
+- If the argument is **missing**, the path does **not exist**, or matches **no identifier** → print the blocked block, then STOP (never guess or auto-pick a task):
+
+1. Steps that must be completed first (in order), each with its command:
+   - Codebase & bottleneck analysis (`codebase-analysed`, `bottlenecks-identified`) → `/owflow:performance-analyze <task-path>`
+   - Requirements, specification & conditional audit (`spec-written`, `spec-audited`) → `/owflow:performance-spec <task-path>`
+   - Implementation planning (`plan-created`) → `/owflow:performance-plan <task-path>`
+   - Implementation (`implementation-done`) → `/owflow:performance-implement <task-path>`
+2. List available performance-task identifiers (directories under `.owflow/tasks/performance/`) to resume from, if any.
+3. Hint: `Run /owflow:performance <description> to start a task from scratch, or pass a task path/identifier to resume.`
+
+### Prerequisites
+
+| Required for this skill | Where verified                                                       | Produced by                               |
+| ----------------------- | -------------------------------------------------------------------- | ----------------------------------------- |
+| State file exists       | `<task-path>/orchestrator-state.yml`                                 | `/owflow:performance <desc>`              |
+| Implementation done     | `implementation-done` in `completed_phases` + `implementation/work-log.md` exists | `/owflow:performance-implement <task-path>` |
+
+1. **Read `orchestrator-state.yml`** from the task path. If missing → mid-pipeline bootstrap ([Missing-state Bootstrap](../orchestrator-framework/references/gate-contract.md), starting slug `options-chosen`): `question` — create a fresh standard performance task starting at this step, or decline → print `No performance task found at <path>. Run /owflow:performance <description> to start a task from scratch.` and STOP.
+2. **Skip/resume + options idempotence rule**: if `options-chosen` is in `completed_phases` AND at least one `orchestrator.options.*` review flag is non-null, the options are already chosen — report them and route straight to the verification-done step; do NOT re-ask. If `verification-done` is also complete (validated against `verification/implementation-verification.md`), report existing results and route to the Exit Gate; if that artifact is missing, drop `verification-done` and re-run verification.
+3. **Prerequisite check (presence and content)**: `implementation-done` in `completed_phases` AND `implementation/work-log.md` exists. If missing → print the blocked block, then STOP:
+   - Steps that must be completed first: implementation (`implementation-done`).
+   - `Run /owflow:performance-implement <task-path> first` (or the command for the earliest missing earlier step: `/owflow:performance-analyze`, `/owflow:performance-spec`, or `/owflow:performance-plan`).
+   - If no task exists yet: `Run /owflow:performance <description> to start a task from scratch.`
+
+## Execute
+
+**Read first**: the [Delegation Rules](../orchestrator-framework/references/delegation-rules.md) and [Issue Resolution](../orchestrator-framework/references/orchestrator-patterns.md) (Section 6).
+
+### Verification Options (`options-chosen`, inline)
+
+**Step 1**: Display the verification plan:
+
+```
+Verification Plan:
+  Obligatory (always run):
+    ✓ Completeness check
+    ✓ Test suite (skipped — passed during implementation; re-enabled after fixes)
+
+  Recommended (adjustable):
+    ✓ Code review — quality and security analysis
+    ✓ Pragmatic review — detects over-engineering
+    ✓ Reality check — validates the optimization solves the problem
+    ✓ Production readiness — deployment readiness checks
+```
+
+**Step 2**: `question` (multi-select) — "Which additional verification checks?" Options, pre-selected from state where non-null: "Code review (Recommended)", "Pragmatic review (Recommended)", "Reality check (Recommended)", "Production readiness (Recommended)".
+
+**Step 3**: Write the chosen flags to `orchestrator.options.*` (`code_review_enabled`, `pragmatic_review_enabled`, `reality_check_enabled`, `production_check_enabled`) and auto-set `skip_test_suite: true` (safe ONLY because `implementation-plan-executor` already ended with a full test-suite run; it is cleared before re-verification if fixes are applied). **WRITE `options.*` BEFORE the verification step below invokes `implementation-verifier`** — the verifier reads these flags from state and executes them without re-prompting; this is the one ordering constraint it cannot recover from.
+
+**State write**: append `options-chosen` to `completed_phases`; write the chosen `options.*` and `skip_test_suite`; bump `orchestrator.updated`; re-read + `verify_template` (see State Update Convention).
+
+### Verification & Issue Resolution (`verification-done`)
+
+**Step 1**: **INVOKE NOW** (Skill tool — never the Task tool; this skill spawns its own subagents): Skill tool - `implementation-verifier`. Pass: task_path, task_description, the chosen verification options, and `verification_context` if re-verifying. The verifier reads `options.*` from state and executes the enabled reviews without re-prompting.
+
+**SELF-CHECK**: Did you just invoke the Skill tool with `implementation-verifier`? Or did you start running checks yourself? If the latter, STOP and invoke the Skill tool.
+
+**Step 2**: Display the detailed issue breakdown grouped by category and severity:
+
+```
+Verification Results:
+  Critical ([N]):
+    - [category]: [description] — [file:line] [fixable/manual]
+  Warning ([N]):
+    - [category]: [description] — [file:line] [fixable/manual]
+  Info ([N]):
+    - [description] (listed for awareness, not actionable)
+```
+
+**Step 3**: Gate on status — `passed` → skip to the state write. `passed_with_issues` or `failed` → fix loop (Step 4).
+
+**Step 4**: User-driven fix loop (max 3 iterations):
+
+1. Present critical + warning issues as a numbered list.
+2. `question` — "Which issues should I fix?" Options: "Fix all fixable issues" / "Let me choose specific issues" / "Skip fixes, proceed as-is".
+3. Fix the selected issues; **immediately** log each to `verification_context.fixes_applied` in state (not deferred to the end).
+4. After fixes: set `skip_test_suite: false` (code changed, tests must re-run).
+5. `question` — "Re-run verification to check fixes?" → re-invoke `implementation-verifier` → back to Step 2, or "No, proceed to next step".
+6. **Immediately** update `verification_context.reverify_count` and `verification_context.last_status` in state after each verifier run and after each fix-loop iteration.
+
+**Exit conditions**: no critical issues remain → proceed; the user explicitly chooses to proceed with issues → proceed with issues logged; max 3 iterations → `question` "Proceed with known issues?" / "Stop workflow". **MUST NOT proceed with unresolved critical issues unless the user explicitly approves.**
+
+**State write**: append `verification-done` to `completed_phases` only at skill exit — status `passed`, or user-approved proceed with issues logged. Bump `orchestrator.updated`. On failure: append `verification-done` to `failed_phases`, increment `auto_fix_attempts["verification-done"]`. Then re-read state + run `verify_template`.
+
+## State Update Convention (per step)
+
+Apply after EVERY step above:
+
+1. **Write immediately** — update `orchestrator-state.yml` as soon as the step completes, appending ONLY the step slug actually performed plus that step's fields. Never defer writes to the end of the skill:
+   - Append `options-chosen` with the chosen `options.*` and `skip_test_suite` right after the options prompt, before verification starts.
+   - Append `verification-done` only at skill exit: status `passed`, or user-approved proceed with issues logged.
+   - Update `verification_context.last_status`, `issues_found`, `fixes_applied`, and `reverify_count` immediately after each `implementation-verifier` run and after each fix-loop iteration, so an interruption loses nothing.
+2. **Timestamp** — set `orchestrator.updated` to the current UTC timestamp on every write.
+3. **Failures** — if `implementation-verifier` itself fails or the workflow stops with unresolved critical issues, do NOT append `verification-done` to `completed_phases`; append it to `orchestrator.failed_phases` and increment `auto_fix_attempts["verification-done"]`.
+4. **Validate** — after every write, re-read the file to confirm values, then run the `verify_template` tool with `filePath: <task-path>/orchestrator-state.yml`, `templateName: orchestrator-state-performance.yml`. Fix any reported issue immediately before proceeding.
+5. **Final check** — before the Exit Gate, one consolidated re-read + `verify_template` run to confirm the full state matches everything performed in this session.
+
+## Recovery
+
+| Step                                          | Max Attempts | Strategy                                                                                  |
+| --------------------------------------------- | ------------ | ----------------------------------------------------------------------------------------- |
+| Verification Options (`options-chosen`)       | 1            | Re-ask the multi-select once if the answer is unusable; the recommended defaults stay      |
+| Verification & Issue Resolution (`verification-done`) | 3    | Fix-then-reverify cycles; after 3 iterations ask the user to proceed with known issues or stop |
+
+## Exit Gate
+
+Present results, get user confirmation, then hand off (see [Gate Contract](../orchestrator-framework/references/gate-contract.md)). Never auto-invoke the next skill.
+
+### Results box
+
+```markdown
+## ✅ PERFORMANCE VERIFY COMPLETE — <task name>
+
+**Overall status** — [✅ passed / ⚠ passed_with_issues / ❌ failed]
+**Issues found** — [total] ([critical] C / [warning] W / [info] I)
+**Fixed** — [count]
+**Remaining** — [by severity]
+
+**Artifacts**
+
+- `verification/implementation-verification.md`
+- `verification/code-review-report.md` [if run]
+- `verification/pragmatic-review.md` [if run]
+- `verification/reality-check.md` [if run]
+- `verification/production-readiness-report.md` [if run]
+```
+
+### Results-acceptance question
+
+Use `question` — "Are these results correct?" with options:
+
+- **Accept** — verification outcome is good (including approved proceed-with-issues); continue.
+- **Adjust** — run additional fixes and/or another verification round (within the fix-loop limits), then re-present the results box.
+- **Discuss** — walk through specific findings (issue details, fixability assessment, measurement caveats) in more depth; then re-ask.
+- **Stop here** — print the resume command (`/owflow:performance-verify <task-path>`) and end.
+
+### Next steps (after Accept)
+
+- `→ /owflow:performance-finalize <task-path>` — `required` to close the workflow: final summary, commit guidance, and post-completion measurement hints. Remaining after: none — workflow ends.
+
+**Other options**:
+
+- `/owflow:reviews-code <task-path>` / `/owflow:reviews-pragmatic <task-path>` — `optional` — standalone re-runs of individual reviews; do not advance phases
+- `/owflow:goal-performance <task-path>` — `optional` shortcut: finishes the remaining step in one loop (finalize)
+
+Then STOP.

package/dist/templates/orchestrator-state-migration.yml

@@ -1,18 +1,27 @@
 orchestrator:
   started_phase: null
+  entry_point: null
   completed_phases: []
   failed_phases: []
   auto_fix_attempts:
-    phase-1: 0
-    phase-2: 0
-    phase-3: 0
-    phase-4: 0
-    phase-5: 0
-    phase-6: 0
-    phase-7: 0
-    phase-8: 0
+    state-analysed: 0
+    target-planned: 0
+    strategy-specified: 0
+    plan-created: 0
+    migration-executed: 0
+    options-chosen: 0
+    verification-done: 0
+    issues-resolved: 0
+    docs-generated: 0
+    task-completed: 0
   options:
-    docs_enabled: false
+    docs_enabled: null
+    skip_test_suite: null
+    code_review_enabled: null
+    code_review_scope: null
+    pragmatic_review_enabled: null
+    production_check_enabled: null
+    reality_check_enabled: null
   created: "YYYY-MM-DDTHH:MM:SSZ"
   updated: "YYYY-MM-DDTHH:MM:SSZ"
   task_path: null
@@ -40,6 +49,22 @@ migration_context:
   breaking_changes: []
   rollback_plan_created: false
   dual_run_configured: false
+  clarifications_resolved: null
+  phase_summaries:
+    analyze:
+      summary: null
+    target:
+      summary: null
+    spec:
+      summary: null
+    plan:
+      summary: null
+    implement:
+      summary: null
+    verify:
+      summary: null
+    fix:
+      summary: null
 
 external_research:
   performed: false
@@ -50,6 +75,21 @@ external_research:
 verification_context:
   last_status: null
   issues_found: null
+  compatibility_status: null
   fixes_applied: []
   decisions_made: []
   reverify_count: 0
+
+migration_outputs:
+  current_state_analysis: null
+  clarifications: null
+  target_state_plan: null
+  requirements: null
+  spec: null
+  rollback_plan: null
+  dual_run_plan: null
+  implementation_plan: null
+  work_log: null
+  implementation_verification: null
+  compatibility_test_results: null
+  migration_guide: null

package/dist/templates/orchestrator-state-performance.yml

@@ -1,17 +1,18 @@
 orchestrator:
   started_phase: null
+  entry_point: null
   completed_phases: []
   failed_phases: []
   auto_fix_attempts:
-    phase-1: 0
-    phase-2: 0
-    phase-3: 0
-    phase-4: 0
-    phase-5: 0
-    phase-6: 0
-    phase-7: 0
-    phase-8: 0
-    phase-9: 0
+    codebase-analysed: 0
+    bottlenecks-identified: 0
+    spec-written: 0
+    spec-audited: 0
+    plan-created: 0
+    implementation-done: 0
+    options-chosen: 0
+    verification-done: 0
+    task-completed: 0
   options:
     spec_audit_enabled: null
     skip_test_suite: true
@@ -39,11 +40,21 @@ performance_context:
     p1: 0
     p2: 0
     p3: 0
+  project_doc_paths: []
+  task_characteristics:
+    has_reproducible_defect: false
+    modifies_existing_code: false
+    creates_new_entities: false
+    involves_data_operations: false
+    ui_heavy: false
   phase_summaries:
     codebase_analysis: { key_files: [], summary: null }
     bottleneck_analysis:
       { bottlenecks: [], summary: null, user_data_incorporated: false }
     specification: { summary: null }
+    clarifications: { summary: null }
+    planning: { summary: null }
+    implementation: { summary: null }
 
 verification_context:
   last_status: null

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owflow",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "description": "Spec-driven development AI workflow for OpenCode",
   "type": "module",
   "main": "dist/index.js",