@comfanion/workflow 4.33.1 → 4.35.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.33.1",
+  "version": "4.35.0",
   "description": "Initialize OpenCode Workflow system for AI-assisted development with semantic code search",
   "type": "module",
   "bin": {

package/src/build-info.json

@@ -1,6 +1,6 @@
 {
   "version": "3.0.0",
-  "buildDate": "2026-01-24T12:13:18.909Z",
+  "buildDate": "2026-01-24T13:22:48.754Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/agents/coder.md

@@ -16,12 +16,12 @@ tools:
   glob: true
   grep: true
   list: true
-  skill: false       # No skill loading - just execute
+  skill: true       # No skill loading - just execute
   question: false    # No questions - execute or fail
   bash: true         # Full bash for tests, builds
   webfetch: false    # No web access
-  todowrite: false   # Subagent - no todo
-  todoread: false
+  todowrite: true   # Not available for subagents (Claude internal tools)
+  todoread: true    # Not available for subagents
   lsp: true          # Code intelligence
 
 # Permissions - fast execution, no prompts

package/src/opencode/agents/dev.md

@@ -48,14 +48,57 @@ permission:
     <r>Find and use `**/project-context.md` and `CLAUDE.md` as source of truth</r>
   </rules>
   
-  <dev-story-workflow hint="When executing dev-story skill">
+  <dev-story-workflow hint="When executing /dev-story command" critical="FOLLOW THIS EXACTLY">
+    <!-- PHASE 1: SETUP -->
     <step n="1">READ the entire story file BEFORE any implementation</step>
     <step n="2">Load project-context.md and CLAUDE.md if available</step>
-    <step n="3">Execute tasks/subtasks IN ORDER as written in story file</step>
-    <step n="4">For each task: follow red-green-refactor cycle</step>
-    <step n="5">Mark task [x] ONLY when implementation AND tests are complete</step>
-    <step n="6">Run full test suite after each task - NEVER proceed with failing tests</step>
+    <step n="3">CREATE TODO LIST from story tasks using todowrite:
+      - Each task becomes a TODO item
+      - Set priority based on task order (first = high)
+      - All tasks start as "pending"
+    </step>
+    <step n="4">Mark story status as "in-progress"</step>
+    
+    <!-- PHASE 2: IMPLEMENTATION LOOP -->
+    <step n="5">FOR EACH TASK in order:
+      a) Update TODO: mark current task as "in_progress"
+      b) Call @coder with specific task instructions:
+         - Include task requirements
+         - Include acceptance criteria
+         - Include relevant file paths
+         - Request: test first, then implement
+      c) VERIFY @coder result:
+         - Check tests exist and pass
+         - Check implementation matches AC
+         - If failed: retry or HALT
+      d) Update TODO: mark task as "completed"
+      e) Update story file: mark task [x]
+      f) Run test suite - HALT if failures
+    </step>
+    
+    <!-- PHASE 3: FINALIZATION -->
+    <step n="6">Run FULL test suite - all tests must pass</step>
+    <step n="7">Update story file: File List, Change Log, Dev Agent Record</step>
+    <step n="8">Clear TODO list (all done)</step>
+    <step n="9">Mark story status as "review"</step>
   </dev-story-workflow>
+  
+  <todo-usage hint="How to use TODO for tracking">
+    <create>
+      todowrite([
+        { id: "story-task-1", content: "Task 1: Create entity", status: "pending", priority: "high" },
+        { id: "story-task-2", content: "Task 2: Add repository", status: "pending", priority: "medium" },
+        ...
+      ])
+    </create>
+    <update-progress>
+      todoread() → get current list
+      todowrite([...list with task.status = "in_progress"])
+    </update-progress>
+    <mark-complete>
+      todowrite([...list with task.status = "completed"])
+    </mark-complete>
+  </todo-usage>
 </activation>
 
 <persona>

package/src/opencode/commands/dev-story.md

@@ -1,6 +1,6 @@
 # /dev-story Command
 
-Implement a story using red-green-refactor cycle.
+Implement a story using red-green-refactor cycle with TODO tracking.
 
 ## Usage
 
@@ -18,16 +18,48 @@ This command invokes the **Dev** agent (Amelia).
 
 ## Process
 
+### Phase 1: Setup
 1. Find or load story file
 2. Load project context (CLAUDE.md, project-context.md)
-3. Mark story as `in-progress`
-4. For each task/subtask:
+3. **Create TODO list from story tasks** (for progress tracking)
+4. Mark story as `in-progress`
+
+### Phase 2: Implementation (for each task)
+5. **Mark task as `in_progress` in TODO**
+6. Delegate to @coder:
    - 🔴 RED: Write failing test
    - 🟢 GREEN: Implement minimal code to pass
    - 🔵 REFACTOR: Improve while keeping tests green
-5. Mark task complete `[x]` only when tests pass
-6. Update story file (File List, Change Log, Dev Agent Record)
-7. Mark story as `review` when all tasks complete
+7. Verify @coder result (tests pass)
+8. **Mark task as `completed` in TODO**
+9. Mark task `[x]` in story file
+
+### Phase 3: Finalization
+10. Run full test suite
+11. Update story file (File List, Change Log, Dev Agent Record)
+12. **Clear TODO** (all tasks done)
+13. Mark story as `review`
+
+## TODO Workflow
+
+```
+┌─────────────────────────────────────────────────┐
+│  @dev reads story → creates TODO:               │
+│  ┌─────────────────────────────────────────┐    │
+│  │ [ ] Task 1: Create User entity          │    │
+│  │ [ ] Task 2: Add repository              │    │
+│  │ [ ] Task 3: Write integration tests     │    │
+│  └─────────────────────────────────────────┘    │
+│                                                 │
+│  For each task:                                 │
+│  1. @dev marks [→] in_progress in TODO          │
+│  2. @dev calls @coder with task details         │
+│  3. @coder implements (no TODO access)          │
+│  4. @dev verifies result                        │
+│  5. @dev marks [✓] completed in TODO            │
+│  6. @dev marks [x] in story file                │
+└─────────────────────────────────────────────────┘
+```
 
 ## Skills Loaded
 

package/src/opencode/config.yaml

@@ -233,7 +233,7 @@ vectorizer:
   auto_index: true
   
   # Debounce time in ms (wait before indexing after file change)
-  debounce_ms: 2000
+  debounce_ms: 1000
   
   # Indexes to maintain
   indexes:

package/src/opencode/plugins/file-indexer.ts

@@ -5,13 +5,15 @@ import fs from "fs/promises"
 /**
  * File Indexer Plugin
  * 
- * Automatically reindexes changed files for semantic search.
+ * Automatically manages semantic search indexes:
+ * - On session start/resume: freshen existing indexes (update stale files)
+ * - On file edit: queue file for reindexing (debounced)
  * 
  * Configuration in .opencode/config.yaml:
  *   vectorizer:
  *     enabled: true       # Master switch
  *     auto_index: true    # Enable this plugin
- *     debounce_ms: 2000   # Wait time before indexing
+ *     debounce_ms: 100   # Wait time before indexing
  * 
  * Debug mode: set DEBUG=file-indexer or DEBUG=* to see logs
  */
@@ -22,7 +24,7 @@ const DEBUG = process.env.DEBUG?.includes('file-indexer') || process.env.DEBUG =
 const DEFAULT_CONFIG = {
   enabled: true,
   auto_index: true,
-  debounce_ms: 2000,
+  debounce_ms: 1000,
   indexes: {
     code: { enabled: true, extensions: ['.js', '.ts', '.jsx', '.tsx', '.py', '.go', '.rs', '.java', '.kt', '.swift', '.c', '.cpp', '.h', '.hpp', '.cs', '.rb', '.php', '.scala', '.clj'] },
     docs: { enabled: true, extensions: ['.md', '.mdx', '.txt', '.rst', '.adoc'] },
@@ -108,6 +110,58 @@ async function isVectorizerInstalled(projectRoot: string): Promise<boolean> {
   }
 }
 
+async function hasIndex(projectRoot: string, indexName: string): Promise<boolean> {
+  try {
+    await fs.access(path.join(projectRoot, ".opencode", "vectors", indexName, "hashes.json"))
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * Ensure index exists and is fresh on session start
+ */
+async function ensureIndexOnSessionStart(projectRoot: string, config: VectorizerConfig): Promise<void> {
+  if (!await isVectorizerInstalled(projectRoot)) {
+    debug('Session start: vectorizer not installed, skipping')
+    return
+  }
+  
+  try {
+    const vectorizerModule = path.join(projectRoot, ".opencode", "vectorizer", "index.js")
+    const { CodebaseIndexer } = await import(`file://${vectorizerModule}`)
+    
+    // Check each enabled index
+    for (const [indexName, indexConfig] of Object.entries(config.indexes)) {
+      if (!indexConfig.enabled) continue
+      
+      const indexExists = await hasIndex(projectRoot, indexName)
+      
+      if (!indexExists) {
+        // No index - need full indexing (but don't block session, just log)
+        debug(`Session start: index "${indexName}" not found, run: npx @comfanion/workflow index --index ${indexName}`)
+        continue
+      }
+      
+      // Index exists - freshen it (update stale files)
+      debug(`Session start: freshening index "${indexName}"...`)
+      const indexer = await new CodebaseIndexer(projectRoot, indexName).init()
+      const stats = await indexer.freshen()
+      
+      if (stats.updated > 0 || stats.deleted > 0) {
+        debug(`Session start: ${indexName} - updated ${stats.updated}, deleted ${stats.deleted}`)
+      } else {
+        debug(`Session start: ${indexName} - index is fresh`)
+      }
+      
+      await indexer.unloadModel()
+    }
+  } catch (e) {
+    debug(`Session start error: ${(e as Error).message}`)
+  }
+}
+
 async function processPendingFiles(projectRoot: string, config: VectorizerConfig): Promise<void> {
   if (pendingFiles.size === 0) return
   
@@ -196,10 +250,21 @@ export const FileIndexerPlugin: Plugin = async ({ directory }) => {
     }, config.debounce_ms + 100)
   }
 
+  // Track if we've already freshened this session
+  let sessionFreshened = false
+  
   return {
     event: async (ctx) => {
       const event = ctx.event
       
+      // Freshen index on session start/resume
+      if ((event.type === "session.started" || event.type === "session.resumed") && !sessionFreshened) {
+        sessionFreshened = true
+        debug(`${event.type}: checking indexes...`)
+        // Run async, don't block
+        ensureIndexOnSessionStart(directory, config).catch(e => debug(`Error: ${e.message}`))
+      }
+      
       if (event.type === "file.edited") {
         const props = (event as any).properties || {}
         const filePath = props.file || props.path || props.filePath