@haoyiyin/workflow 0.2.11 → 0.3.1

package/src/persistence/index.ts

@@ -1,8 +1,14 @@
 /**
- * Persistence layer exports
+ * Persistence layer entry point
+ *
+ * Provides STATE.md and PLAN.md management for workflow state persistence.
  */
+
+// Managers
 export { StateMdManager } from './state-md.js'
 export { PlanMdManager } from './plan-md.js'
+
+// Types
 export type {
   Task,
   Wave,
@@ -11,7 +17,7 @@ export type {
   VerificationResult,
   DimensionResult,
   WorkflowState,
-  StateMdManager as IStateMdManager,
-  PlanMdManager as IPlanMdManager,
-  PersistenceManager
+  StateMdManager as StateMdManagerInterface,
+  PlanMdManager as PlanMdManagerInterface,
+  PersistenceManager,
 } from './types.js'

package/src/persistence/plan-md.ts

@@ -3,7 +3,7 @@
  */
 import { promises as fs } from 'fs'
 import { dirname } from 'path'
-import type { Plan, Task, PlanMdManager as IPlanMdManager } from './types.js'
+import type { Plan, Task, Wave, PlanMdManager as IPlanMdManager } from './types.js'
 
 export class PlanMdManager implements IPlanMdManager {
   private planPath: string
@@ -20,9 +20,16 @@ export class PlanMdManager implements IPlanMdManager {
     await fs.writeFile(this.planPath, content, 'utf-8')
   }
 
-  async readPlan(): Promise<Plan> {
-    const content = await fs.readFile(this.planPath, 'utf-8')
-    return this.parsePlan(content)
+  async readPlan(): Promise<Plan | null> {
+    try {
+      const content = await fs.readFile(this.planPath, 'utf-8')
+      return this.parsePlan(content)
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null
+      }
+      throw error
+    }
   }
 
   async updateTaskStatus(taskId: string, status: 'pending' | 'in_progress' | 'complete'): Promise<void> {
@@ -35,14 +42,37 @@ export class PlanMdManager implements IPlanMdManager {
     await fs.writeFile(this.planPath, updated, 'utf-8')
   }
 
+  async getNextPendingWave(): Promise<Wave | null> {
+    const plan = await this.readPlan()
+    if (!plan) {
+      return null
+    }
+
+    // Find first wave with pending tasks
+    for (const wave of plan.waves) {
+      const hasPendingTask = wave.tasks.some(task => task.status === 'pending')
+      if (hasPendingTask) {
+        return wave
+      }
+    }
+
+    return null
+  }
+
   private generatePlanMarkdown(plan: Plan): string {
+    const getStatusChar = (status: Task['status']) => {
+      if (status === 'completed') return 'x'
+      if (status === 'in_progress') return '~'
+      return ' '
+    }
+
     return `# Execution Plan
 
 ## Goal
 ${plan.goal}
 
 ## Tasks
-${plan.tasks.map(t => `- [ ] ${t.id}: ${t.description} (${t.estimatedComplexity})`).join('\n')}
+${plan.tasks.map(t => `- [${getStatusChar(t.status)}] ${t.id}: ${t.description} (${t.estimatedComplexity})`).join('\n')}
 
 ## Dependencies
 ${Object.entries(plan.dependencies).length > 0
@@ -51,7 +81,7 @@ ${Object.entries(plan.dependencies).length > 0
     }
 
 ## Waves
-${plan.waves.map(w => `- ${w.id}: ${w.tasks.join(', ')}`).join('\n')}
+${plan.waves.map(w => `- ${w.id}: ${w.tasks.map(t => t.id).join(', ')}`).join('\n')}
 
 ## Verification Criteria
 ${plan.verificationCriteria.map(c => `- ${c}`).join('\n')}
@@ -60,9 +90,6 @@ ${plan.verificationCriteria.map(c => `- ${c}`).join('\n')}
 - Total Tasks: ${plan.tasks.length}
 - Parallel Waves: ${plan.waves.length}
 - Estimated Duration: ${plan.estimatedDuration}ms
-
-## Rationale
-${plan.rationale}
 `
   }
 
@@ -73,19 +100,22 @@ ${plan.rationale}
     const wavesMatch = content.match(/## Waves\n([\s\S]*?)(?=\n## |$)/)
     const criteriaMatch = content.match(/## Verification Criteria\n([\s\S]*?)(?=\n## |$)/)
     const durationMatch = content.match(/- Estimated Duration: (\d+)/)
-    const rationaleMatch = content.match(/## Rationale\n([\s\S]*?)(?=\n## |$)/)
 
     // Parse tasks
     const tasks: Task[] = []
     if (tasksMatch) {
       const taskLines = tasksMatch[1].split('\n').filter(l => l.trim().startsWith('- ['))
       for (const line of taskLines) {
-        const match = line.match(/- \[[x\s~]]\s+(\w+):\s+(.+)\s+\((\w+)\)/)
+        const match = line.match(/- \[(.)\]\s+(\w+):\s+(.+)\s+\((\w+)\)/)
         if (match) {
+          const statusChar = match[1]
+          const status = statusChar === 'x' ? 'completed' : statusChar === '~' ? 'in_progress' : 'pending'
           tasks.push({
-            id: match[1],
-            description: match[2],
-            estimatedComplexity: match[3] as 'low' | 'medium' | 'high'
+            id: match[2],
+            description: match[3],
+            status,
+            dependencies: [],
+            estimatedComplexity: match[4] as 'low' | 'medium' | 'high'
           })
         }
       }
@@ -103,16 +133,21 @@ ${plan.rationale}
       }
     }
 
+    // Build task map for wave parsing
+    const taskMap = new Map<string, Task>(tasks.map(t => [t.id, t]))
+
     // Parse waves
-    const waves = []
+    const waves: Wave[] = []
     if (wavesMatch) {
       const waveLines = wavesMatch[1].split('\n').filter(l => l.trim().startsWith('- '))
       for (const line of waveLines) {
         const match = line.match(/- (\w+):\s*(.+)/)
         if (match) {
+          const taskIds = match[2].split(',').map(s => s.trim()).filter(s => s)
+          const waveTasks = taskIds.map(id => taskMap.get(id)).filter((t): t is Task => t !== undefined)
           waves.push({
             id: match[1],
-            tasks: match[2].split(',').map(s => s.trim()).filter(s => s)
+            tasks: waveTasks
           })
         }
       }
@@ -134,8 +169,7 @@ ${plan.rationale}
       dependencies,
       waves,
       verificationCriteria,
-      estimatedDuration: durationMatch ? parseInt(durationMatch[1], 10) : 0,
-      rationale: rationaleMatch?.[1]?.trim() || ''
+      estimatedDuration: durationMatch ? parseInt(durationMatch[1], 10) : 0
     }
   }
 }

package/src/persistence/state-md.ts

@@ -36,10 +36,7 @@ ${goal}
 <!-- Populated by verify phase -->
 
 ## Token Usage
-- Plan Phase: 0
-- Execute Phase: 0
-- Verify Phase: 0
-- Total: 0 / 1000000
+0
 `
     await fs.writeFile(this.statePath, content, 'utf-8')
   }
@@ -65,7 +62,14 @@ ${goal}
 
   async recordTaskComplete(taskId: string, result: TaskResult): Promise<void> {
     const content = await fs.readFile(this.statePath, 'utf-8')
-    const entry = `- [x] ${taskId}: ${result.success ? '✓' : '✗'} (${result.duration}ms) - ${result.notes || ''}\n`
+    const entry = `- [x] ${taskId}: ✓ (${result.duration}ms) - ${result.notes || ''}\n`
+    const updated = this.appendToSection(content, 'Completed Tasks', entry)
+    await fs.writeFile(this.statePath, updated, 'utf-8')
+  }
+
+  async recordTaskFailed(taskId: string, error?: string): Promise<void> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    const entry = `- [x] ${taskId}: ✗ FAILED${error ? ` - ${error}` : ''}\n`
     const updated = this.appendToSection(content, 'Completed Tasks', entry)
     await fs.writeFile(this.statePath, updated, 'utf-8')
   }
@@ -77,6 +81,15 @@ ${goal}
     await fs.writeFile(this.statePath, updated, 'utf-8')
   }
 
+  async updateTokenUsage(tokens: number): Promise<void> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    const updated = content.replace(
+      /## Token Usage\n\d+/,
+      `## Token Usage\n${tokens}`
+    )
+    await fs.writeFile(this.statePath, updated, 'utf-8')
+  }
+
   async readCurrentState(): Promise<WorkflowState> {
     const content = await fs.readFile(this.statePath, 'utf-8')
     return this.parseState(content)
@@ -91,7 +104,7 @@ ${plan.goal}
 ${plan.tasks.map(t => `- ${t.id}: ${t.description} (${t.estimatedComplexity})`).join('\n')}
 
 ### Waves (${plan.waves.length})
-${plan.waves.map(w => `- ${w.id}: ${w.tasks.join(', ')}`).join('\n')}
+${plan.waves.map(w => `- ${w.id}: ${w.tasks.map(t => t.id).join(', ')}`).join('\n')}
 
 ### Verification Criteria
 ${plan.verificationCriteria.map(c => `- ${c}`).join('\n')}
@@ -99,8 +112,8 @@ ${plan.verificationCriteria.map(c => `- ${c}`).join('\n')}
 ### Estimated Duration
 ${plan.estimatedDuration}ms
 
-### Rationale
-${plan.rationale}
+### Dependencies
+${Object.entries(plan.dependencies).map(([taskId, deps]) => `- ${taskId}: ${deps.join(', ') || 'none'}`).join('\n')}
 `
   }
 
@@ -141,27 +154,36 @@ ${results.join('\n')}
     const phaseMatch = content.match(/- Phase: (\w+)/)
     const goalMatch = content.match(/## Goal\n(.+)/)
     const startedMatch = content.match(/- Started: (.+)/)
-    const totalMatch = content.match(/### Tasks \((\d+)\)/)
+    const lastUpdatedMatch = content.match(/- Last Updated: (.+)/)
+    const tokenMatch = content.match(/## Token Usage\n(\d+)/)
     const completedMatch = content.match(/## Completed Tasks\n([\s\S]*?)(?=\n## |$)/)
 
-    const completedTasks = completedMatch
-      ? completedMatch[1].split('\n').filter(l => l.trim().startsWith('- [x]')).length
-      : 0
-
-    const totalTasks = totalMatch ? parseInt(totalMatch[1], 10) : 0
+    const completedTasks: string[] = []
+    const failedTasks: string[] = []
+
+    if (completedMatch) {
+      const lines = completedMatch[1].split('\n').filter(l => l.trim().startsWith('- [x]'))
+      for (const line of lines) {
+        const taskIdMatch = line.match(/- \[x\] ([^:]+):/)
+        if (taskIdMatch) {
+          if (line.includes('✗ FAILED')) {
+            failedTasks.push(taskIdMatch[1])
+          } else {
+            completedTasks.push(taskIdMatch[1])
+          }
+        }
+      }
+    }
 
     return {
       goal: goalMatch?.[1] || '',
       phase: (phaseMatch?.[1] as WorkflowState['phase']) || 'planning',
-      started: startedMatch?.[1] || new Date().toISOString(),
-      lastUpdated: new Date().toISOString(),
-      totalTasks,
-      completedTasks: [],
-      tokenUsage: {
-        used: 0,
-        limit: 1000000,
-        percentage: 0
-      }
+      startedAt: startedMatch?.[1] || new Date().toISOString(),
+      lastUpdated: lastUpdatedMatch?.[1] || new Date().toISOString(),
+      completedTasks,
+      failedTasks,
+      totalTasks: 0,
+      tokenUsage: { used: tokenMatch ? parseInt(tokenMatch[1], 10) : 0, limit: 1000000, percentage: 0 }
     }
   }
 }

package/src/persistence/types.ts

@@ -5,67 +5,45 @@
 export interface Task {
   id: string
   description: string
+  status: 'pending' | 'in_progress' | 'completed' | 'failed'
+  dependencies: string[]
   estimatedComplexity: 'low' | 'medium' | 'high'
   relatedFiles?: string[]
-  verificationCriteria?: string[]
 }
 
 export interface Wave {
   id: string
-  tasks: string[]
+  tasks: Task[]
 }
 
 export interface Plan {
   goal: string
   tasks: Task[]
-  dependencies: Record<string, string[]>
   waves: Wave[]
+  dependencies: Record<string, string[]>
   verificationCriteria: string[]
   estimatedDuration: number
-  rationale: string
+}
+
+export interface WorkflowState {
+  goal: string
+  phase: 'discovery' | 'planning' | 'executing' | 'verifying' | 'completed' | 'failed' | 'idle'
+  startedAt: string
+  lastUpdated: string
+  completedTasks: string[]
+  failedTasks: string[]
+  totalTasks: number
+  tokenUsage: { used: number; limit: number; percentage: number }
 }
 
 export interface TaskResult {
   taskId: string
   success: boolean
-  filesModified: string[]
-  testsAdded: string[]
   duration: number
   notes: string
+  filesModified?: string[]
+  testsAdded?: string[]
   error?: string
-  phases?: { phase: string; status: string; command?: string; evidence?: string }[]
-  worktreePath?: string
-  branchName?: string
-}
-
-export interface VerificationResult {
-  success: boolean
-  dimensions: {
-    goals?: DimensionResult
-    quality?: DimensionResult
-    tests?: DimensionResult
-  }
-}
-
-export interface DimensionResult {
-  success: boolean
-  details?: unknown
-  evidence?: string[]
-  gaps?: string[]
-}
-
-export interface WorkflowState {
-  goal: string
-  phase: 'planning' | 'executing' | 'verifying' | 'complete'
-  started: string
-  lastUpdated: string
-  totalTasks: number
-  completedTasks: TaskResult[]
-  tokenUsage: {
-    used: number
-    limit: number
-    percentage: number
-  }
 }
 
 export interface StateMdManager {
@@ -73,17 +51,36 @@ export interface StateMdManager {
   updatePhase(phase: WorkflowState['phase']): Promise<void>
   recordPlan(plan: Plan): Promise<void>
   recordTaskComplete(taskId: string, result: TaskResult): Promise<void>
+  recordTaskFailed(taskId: string, error?: string): Promise<void>
   recordVerification(verification: VerificationResult): Promise<void>
+  updateTokenUsage(tokens: number): Promise<void>
   readCurrentState(): Promise<WorkflowState>
 }
 
 export interface PlanMdManager {
   writePlan(plan: Plan): Promise<void>
-  readPlan(): Promise<Plan>
+  readPlan(): Promise<Plan | null>
   updateTaskStatus(taskId: string, status: 'pending' | 'in_progress' | 'complete'): Promise<void>
+  getNextPendingWave(): Promise<Wave | null>
 }
 
 export interface PersistenceManager {
   state: StateMdManager
   plan: PlanMdManager
 }
+
+export interface VerificationResult {
+  success: boolean
+  dimensions: {
+    goals?: DimensionResult
+    quality?: DimensionResult
+    tests?: DimensionResult
+  }
+}
+
+export interface DimensionResult {
+  success: boolean
+  details?: unknown
+  evidence?: string[]
+  gaps?: string[]
+}

package/src/pi-extension.ts

@@ -1,111 +1,73 @@
 /**
- * PI Extension - yi-workflow dispatcher
+ * PI Extension - yi-workflow router interceptor
  *
- * Intercepts regular chat and dispatches to appropriate skills.
- * Ensures THIN DISPATCHER pattern: main agent NEVER does work.
+ * ALL user input → /skill:router
+ * Router skill handles ALL routing logic (5-layer GSD).
+ * Extension does NOT classify intent — that's the router's job.
  */
 
-import { classifyIntent } from "./extension/classifier.js";
-
-// Extension API is provided by PI at runtime
-// We use 'any' to avoid compile-time dependency
 export default function (pi: any) {
-  // Store transformed input for before_agent_start to detect
   let transformedInput: string | null = null;
 
-  // Intercept user input before processing
+  // Intercept ALL user input → route to router skill
   pi.on("input", async (event: any, ctx: any) => {
-    // Skip if user already used a slash command
+    // Skip slash commands (user explicitly calling a skill)
     if (event.text.startsWith("/")) {
       return { action: "continue" };
     }
 
-    // Classify intent
-    const intent = classifyIntent(event.text);
-    const targetSkill = intent.skill || "quick-task";
-
-    // Determine reason for dispatch
-    let reason = intent.reason;
-    if (!intent.skill) {
-      const needsExternal = /^(what|how|why|when|where|who|search|find|look|weather|time|price|stock|translate)/i.test(event.text);
-      if (needsExternal) {
-        reason = "External query - needs subagent";
-      } else {
-        reason = "Default dispatch - no direct execution allowed";
-      }
-    }
-
-    ctx.ui.notify(
-      `[yi-workflow] Dispatching to /skill:${targetSkill} (${reason})`,
-      "info"
-    );
-
-    // Transform to explicit skill command with instruction not to analyze
-    const transformedText = `=== SKILL COMMAND ===\n/skill:${targetSkill}\n\nINPUT:\n${event.text}\n\n=== DO NOT ANALYZE ===\nYou MUST call the skill above immediately. NO thinking. NO planning. NO analysis. Just call the skill.`;
+    // Store for before_agent_start
+    transformedInput = event.text;
+
+    // Transform ALL input to router skill call
+    // The router skill does 5-layer routing internally
+    const transformedText = [
+      "=== ROUTER DISPATCH ===",
+      "/skill:router",
+      "",
+      "USER REQUEST:",
+      event.text,
+      "",
+      "=== INSTRUCTIONS ===",
+      "Call the router skill above IMMEDIATELY.",
+      "Do NOT analyze, plan, or execute the request yourself.",
+      "Do NOT use any tools (Read, Edit, Bash, etc.).",
+      "The router skill will determine the correct target skill.",
+    ].join("\n");
+
+    ctx.ui.notify("[yi-workflow] → router", "info");
 
-    // Store for before_agent_start hook
-    transformedInput = transformedText;
-
-    // Transform input - this will be passed to main agent
     return {
       action: "transform",
       text: transformedText,
     };
   });
 
-  // Log when session starts
   pi.on("session_start", async (event: any, ctx: any) => {
-    ctx.ui.notify("yi-workflow extension loaded", "info");
+    ctx.ui.notify("yi-workflow router active", "info");
   });
 
-  // CRITICAL: Inject THIN DISPATCHER rules into system prompt
-  // This ensures main agent NEVER executes work directly
+  // Minimal system prompt injection — just reinforce router dispatch
   pi.on("before_agent_start", async (event: any, ctx: any) => {
     const systemPrompt = event.systemPrompt || "";
-
-    // Get the user input (either from event or from transformed global)
     const userInput = transformedInput || event.userInput || "";
 
-    // Detect if this input was transformed to a skill command
-    const isSkillCommand = userInput.startsWith("/skill:");
-
-    // Prepend THIN DISPATCHER constraints
-    const thinDispatcherRules = `
-╔══════════════════════════════════════════════════════════════════╗
-║              THIN DISPATCHER PROTOCOL [ABSOLUTE]                 ║
-╚══════════════════════════════════════════════════════════════════╝
+    const isRouterCommand = userInput.includes("/skill:router");
 
-YOU ARE A THIN DISPATCHER. YOUR ONLY JOB IS TO DISPATCH TO SKILLS.
+    const rules = `
+## ROUTER DISPATCH RULE (MANDATORY)
 
-⚠️ ABSOLUTE RULE #1: If user input starts with "/skill:", you MUST call that skill.
-⚠️ ABSOLUTE RULE #2: You NEVER execute work yourself - only dispatch.
-⚠️ ABSOLUTE RULE #3: Tools (Read, Edit, Bash, etc.) are FORBIDDEN unless in subagent.
+You MUST follow this rule for ALL user messages:
 
-FORBIDDEN ACTIONS (VIOLATION = PROTOCOL BREACH):
-- Reading files (use /skill:review-diff)
-- Writing/editing files (use /skill:execute-plan)
-- Running commands (use /skill:quick-task)
-- Writing code directly (use /skill:tdd or /skill:execute-plan)
-- Using any tool directly (use /skill:quick-task to dispatch subagent)
+1. If input contains "/skill:router" → CALL THE ROUTER SKILL IMMEDIATELY
+2. You MUST NOT use any tools directly (Read, Edit, Bash, Grep, etc.)
+3. You MUST NOT analyze, plan, or execute user requests yourself
+4. Your ONLY action is: call /skill:router and return its output
 
-CURRENT INPUT: "${userInput}"
-IS_SKILL_COMMAND: ${isSkillCommand ? "YES - MUST CALL SKILL" : "NO"}
-
-${isSkillCommand ? `
-╔══════════════════════════════════════════════════════════════════╗
-║ ⚠️  MANDATORY: CALL THE SKILL BELOW  ⚠️                          ║
-╚══════════════════════════════════════════════════════════════════╝
-The input starts with "/skill:". You MUST call that skill.
-DO NOT process this input as a regular conversation.
-DO NOT use tools directly.
-CALL THE SKILL: "${userInput.split(" ")[0]}"
-` : ""}
+CURRENT REQUEST: ${isRouterCommand ? "ROUTER DISPATCH — CALL SKILL NOW" : "Normal message"}
 `;
 
-    // Prepend to system prompt
-    event.systemPrompt = thinDispatcherRules + "\n\n" + systemPrompt;
-
-    // Reset transformed input for next turn
+    event.systemPrompt = rules + "\n\n" + systemPrompt;
     transformedInput = null;
 
     return { action: "continue" };