@comfanion/workflow 4.39.0 → 4.39.2

package/src/opencode/skills/dev-story/SKILL.md

@@ -38,34 +38,11 @@ metadata:
     <goal>~70KB context, NOT 200KB+</goal>
   </phase>
 
-  <phase name="2-transform" title="Transform Story Task → Executable Instruction">
-    <step n="1" name="read-docs">
-      Story has "Required Reading", task has "Read First".
-      Open each → find sections → extract patterns, signatures, constraints.
-    </step>
-    <step n="2" name="find-patterns">
-      From "Read First" paths, find existing similar code.
-      Note structure, imports, error handling → becomes "Pattern Reference".
-    </step>
-    <step n="3" name="build-context">
-      @coder doesn't see story. Provide:
-      - Existing files (paths + what they contain)
-      - Patterns to follow (link to similar code)
-      - What was done (results of previous tasks)
-      - Imports (what packages to use)
-    </step>
-    <step n="4" name="add-direction">
-      Story has "Approach". Expand with:
-      - Interface signatures (method names, params, return types)
-      - Error handling (what errors to return)
-      - Validation rules
-    </step>
-    <step n="5" name="verification">
-      Story has "Done when". Add:
-      - Specific test commands
-      - Files that must compile
-      - Test coverage expectations
-    </step>
+  <phase name="2-plan" title="Plan Task Execution">
+    <step n="1">Read story tasks, determine execution order based on dependencies</step>
+    <step n="2">Identify which tasks are independent (can run in parallel) vs sequential</step>
+    <step n="3">For each task, note: what to do + which files/patterns are relevant context</step>
+    <step n="4">Do NOT read source files that only @coder needs — save your context for orchestration</step>
   </phase>
 
   <phase name="2b-todo" title="Create TODO with IDs">
@@ -90,28 +67,15 @@ metadata:
     </example>
   </phase>
 
-  <phase name="3-execute" title="Execute Tasks — One by One or Parallel">
-    <critical>DO NOT delegate entire story to @coder in one prompt!</critical>
-    <strategy>
-      For each task in TODO:
-      1. Check task dependencies (from story file)
-      2. If independent tasks exist → delegate in parallel (different files only)
-      3. If task depends on previous → delegate ONE task, wait for result
-      4. After @coder returns → verify, mark done, then next task
-    </strategy>
+  <phase name="3-execute" title="Execute Tasks">
     <loop>
-      <step n="1">Pick next task(s) from TODO</step>
-      <step n="2">Transform task → executable instruction (phase 2)</step>
-      <step n="3">Delegate to @coder using template below</step>
-      <step n="4">Verify result: tests pass, files compile</step>
-      <step n="5">Mark task ✅ in story file + TODO</step>
-      <step n="6">Update .opencode/session-state.yaml</step>
-      <step n="7">Next task or story complete</step>
+      <step n="1">Pick next task(s) from TODO (parallel if independent, otherwise one)</step>
+      <step n="2">Delegate to @coder with a brief: what to do + context file paths</step>
+      <step n="3">Verify result: tests pass, files compile</step>
+      <step n="4">Mark task done in story file + TODO</step>
+      <step n="5">Update .opencode/session-state.yaml</step>
+      <step n="6">Next task or story complete</step>
     </loop>
-    <parallel-rules>
-      OK to parallel: T01 (domain) + T02 (dto) — different files, no deps
-      NOT OK: T03 (service) depends on T01 (domain) — wait for T01 first
-    </parallel-rules>
   </phase>
 
   <phase name="4-review" title="Review BEFORE Done">
@@ -155,86 +119,25 @@ key_decisions:
 
 This file survives compaction and tells the agent where to resume.
 
-## Task Template for @coder
+## Brief Format for @coder
 
-<template name="coder-task">
-```markdown
-## Task: [Name] (Task IDs)
+Each @coder call = ONE task. Brief contains:
+- **What**: task goal in 1-2 sentences
+- **Context**: file paths (story, source, patterns to follow)
+- **Methodology**: TDD ("write failing test first") or STUB ("create stub first") per config.yaml
 
-[One line goal]
-
-### Skills
-- Use `doc-todo` for TODO comments
-
-### Context
-- [Existing file]: [what to use from it]
-- Existing pattern: [path to similar code]
-
-### Output Files
-- [path/to/create.ext]
-
-### Requirements
-1. [What to implement with signatures]
-2. [Another requirement]
-
-### Pattern Reference
-→ [path/to/similar/code.ext]
-
-### Error Handling
-[How to handle errors]
-
-### Done When
-- [ ] File compiles
-- [ ] Tests pass
-- [ ] [Specific criterion]
-```
-</template>
+@coder reads the files and figures out implementation details.
 
 <rules name="delegation">
-  <rule name="task-by-task" critical="true">
-    Delegate ONE task at a time (or parallel group if independent).
-    NEVER delegate entire story as one big prompt.
-  </rule>
-  <rule name="parallel">
-    Each task gets full context. No shared state. Different files only.
+  <rule name="one-task" critical="true">
+    ONE task per @coder call. Independent tasks can run in parallel (multiple agents in one message).
   </rule>
   <rule name="verify-between">
-    After each task: run tests, verify, mark done, THEN next task.
+    After each task: verify result, mark done, THEN next task.
   </rule>
-  <rule name="no-code">
-    Give direction, NOT solution. @coder writes implementation.
-  </rule>
-  <rule name="methodology">
-    TDD: "Write failing test first, then implement"
-    STUB: "Create stub first, write tests, then implement"
+  <rule name="task-scope">
+    Good task: logically complete unit (service, handler, entity). Single responsibility. Testable independently.
+    Split when: multiple unrelated responsibilities.
+    Combine when: too granular, same file, same concern.
   </rule>
 </rules>
-
-<task-boundaries>
-  <good>Logically complete unit (service, handler, entity). Single responsibility. Testable independently.</good>
-  <split-when>Multiple unrelated responsibilities. No logical connection.</split-when>
-  <combine-when>Too granular. Same file, same concern.</combine-when>
-</task-boundaries>
-
-<patterns>
-  <pattern name="new-service">
-    Context: domain entities, repository interface, existing service
-    Requirements: interface, constructor, methods
-    Pattern: existing service structure
-  </pattern>
-  <pattern name="new-handler">
-    Context: service interface, DTOs, existing handler
-    Requirements: handler struct, methods, error mapping
-    Pattern: existing handler structure
-  </pattern>
-  <pattern name="new-tests">
-    Context: code to test, existing test examples
-    Requirements: test scenarios, mocks
-    Pattern: existing test structure
-  </pattern>
-</patterns>
-
-<critical>
-  ✅ PROVIDE: pattern references, interface signatures, requirements, error approach
-  ❌ DO NOT: full implementations, ready-to-copy code, complete structs
-</critical>

package/src/opencode/skills/story-writing/SKILL.md

@@ -16,6 +16,12 @@ metadata:
 
 ```xml
 <story_rules>
+  <before_writing critical="MANDATORY">
+    <action>Read template file first</action>
+    <path>./template.md</path>
+    <focus>Lines 103-158 for task Approach examples</focus>
+  </before_writing>
+  
   <definition>Story = Smallest working increment (one layer/feature)</definition>
   
   <sizes>
@@ -47,6 +53,22 @@ metadata:
     <result>Each story = increment, Epic = working module</result>
   </vertical_slice>
   
+  <task_approach critical="MANDATORY">
+    <rule>Every task MUST have Approach section</rule>
+    <format>Numbered list of high-level steps (WHAT to do)</format>
+    <forbidden>
+      <code_blocks>No code in Approach section</code_blocks>
+      <implementation>No detailed implementation</implementation>
+      <ready_solutions>No copy-paste code</ready_solutions>
+    </forbidden>
+    <example_good>
+      1. Create struct with fields from Unit doc
+      2. Add constructor with validation
+      3. Write tests: happy path + errors
+    </example_good>
+    <example_bad>Define struct: type Foo struct { ... }</example_bad>
+  </task_approach>
+  
   <status_values>
     <draft>Being written</draft>
     <ready>Ready for dev</ready>
@@ -59,69 +81,52 @@ metadata:
 
 ---
 
-## Example: MEDIUM Project Story
-
-```yaml
-id: ORD-S01-01
-epic: ORD-E01
-status: ready
-size: M
-```
-
-# Story: Order Domain Layer
-
-## Goal
+## Template & Format
 
-Implement domain entities and value objects for Order Management.
+**BEFORE writing any story:** Read the template file:
 
-**Context:** Part of Epic 01 (Order Management). Focuses on domain layer.
+→ `./template.md`
 
-## Units Affected
+**Key sections in template:**
+- Lines 103-158: Full task example with **Approach** section
+- Lines 119-122: Shows correct Approach format (high-level steps)
 
-| Unit | Action | Description |
-|------|--------|-------------|
-| → Unit: `Order` | Create | New entity |
-
-## Required Reading
-
-| Document | Section | Why |
-|----------|---------|-----|
-| → `CLAUDE.md` | All | Project patterns |
-| → `docs/coding-standards/` | All | **MANDATORY** |
-| → Unit: `Order` | Data Model | Field definitions |
+---
 
-## Acceptance Criteria
+## Task Structure (MANDATORY)
 
-- [ ] Order entity created with all fields
-- [ ] Validation logic implemented
-- [ ] Tests pass (>80% coverage)
-- [ ] Follows coding-standards
+Each task MUST include these sections:
 
-## Tasks
+1. **Goal** - what this task achieves
+2. **Read First** - table with documentation links
+3. **Output Files** - what files to create
+4. **Approach** - high-level steps (MANDATORY)
+5. **Done when** - completion criteria
 
-| ID | Task | Deps | Status |
-|----|------|------|--------|
-| T1 | Order entity | - | ⬜ |
-| T2 | Value objects | - | ⬜ |
-| T3 | Unit tests | T1, T2 | ⬜ |
+### Approach Section Rules
 
-### T1: Order Entity
+**CRITICAL:** Every task MUST have **Approach** section.
 
-**Goal:** Create Order entity with business rules
+**Approach = High-level steps (WHAT to do), NOT code (HOW to implement).**
 
-**Read First:**
-| Document | Section | What to Look For |
-|----------|---------|------------------|
-| → `docs/coding-standards/` | Domain Layer | Entity patterns |
-| → Unit: `Order` | Data Model | All fields |
+✅ **CORRECT:**
+```markdown
+**Approach:**
+1. Create Order struct with fields from Unit doc
+2. Add NewOrder() constructor with validation
+3. Add Validate() method for business rules
+4. Write tests: valid order, validation errors
+```
 
-**Output Files:**
-- `internal/order/domain/order.go`
-- `internal/order/domain/order_test.go`
+❌ **WRONG (has code):**
+```markdown
+**Approach:**
+1. Define struct:
+   ```go
+   type Order struct { ID string }
+   ```
+```
 
-**Done when:**
-- [ ] Entity created
-- [ ] Follows coding-standards
-- [ ] Tests pass
+**Golden Rule:** If you see code blocks in Approach → STOP, remove them.
 
-See `template.md` for full format.
+Point to patterns, don't write implementation.

package/src/opencode/vectorizer.yaml

@@ -1,45 +0,0 @@
-vectorizer:
-  # Enable/disable vectorizer functionality
-  enabled: true
-
-  # Auto-index files when they change (requires file-indexer plugin)
-  auto_index: true
-
-  # Debounce time in ms (wait before indexing after file change)
-  debounce_ms: 1000
-
-  # Indexes to maintain - each has pattern (what to include) and ignore (what to skip)
-  indexes:
-
-    # Documentation index - markdown, text files
-    docs:
-      enabled: true
-      pattern: "docs/**/*.{md,mdx,txt,rst,adoc}"
-      ignore: []
-
-    # Configuration index - yaml, json, toml
-    config:
-      enabled: false
-      pattern: "**/*.{yaml,yml,json,toml,ini}"
-      ignore:
-        - "**/node_modules/**"
-        - "**/.git/**"
-        - "**/dist/**"
-        - "**/build/**"
-        - "**/.opencode/**"
-        - "**/docs/**"
-        - "**/vendor/**"
-        - "**/__pycache__/**"
-        - "**/*.min.js"
-        - "**/*.bundle.js"
-        - "**/package-lock.json"
-        - "**/yarn.lock"
-
-  # Global exclude patterns (applied to ALL indexes, in addition to per-index ignore)
-  exclude:
-    - node_modules
-    - vendor
-    - dist
-    - build
-    - out
-    - __pycache__