@comfanion/workflow 4.38.1-dev.7 → 4.38.1-dev.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.38.1-dev.7",
+  "version": "4.38.1-dev.9",
   "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": "4.38.1-dev.7",
-  "buildDate": "2026-01-27T10:45:27.366Z",
+  "version": "4.38.1-dev.9",
+  "buildDate": "2026-01-27T11:30:42.898Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/plugins/custom-compaction.ts

@@ -911,6 +911,74 @@ This is /dev-epic autopilot mode. Execute stories sequentially until epic done.`
 4. Update todo/story when task complete`
   }
 
+  function buildBriefing(agent: string | null, ss: SessionState | null, ctx: SessionContext, readCommands: string): string {
+    const lines: string[] = []
+
+    // 1. WHO you are
+    if (agent) {
+      lines.push(`You are @${agent} (→ .opencode/agents/${agent}.md).`)
+    }
+
+    // 2. WHAT you are doing
+    if (ss) {
+      const cmd = ss.command || "unknown command"
+      if (ss.epic) {
+        lines.push(`You are executing ${cmd} ${ss.epic.id}: ${ss.epic.title}.`)
+      } else if (ss.story) {
+        lines.push(`You are executing ${cmd} ${ss.story.id}: ${ss.story.title}.`)
+      } else {
+        lines.push(`You are executing ${cmd}.`)
+      }
+    } else if (ctx.activeCommand) {
+      lines.push(`You are executing ${ctx.activeCommand}.`)
+    }
+
+    // 3. WHERE you stopped
+    if (ss?.story) {
+      const task = ss.story.current_task || "review"
+      lines.push(`You were on story ${ss.story.id}: ${ss.story.title}, task ${task}.`)
+      if (ss.story.completed_tasks.length > 0) {
+        lines.push(`Completed: ${ss.story.completed_tasks.join(", ")}.`)
+      }
+      if (ss.story.pending_tasks.length > 0) {
+        lines.push(`Remaining: ${ss.story.pending_tasks.join(", ")}.`)
+      }
+    } else if (ss?.epic) {
+      lines.push(`Epic progress: ${ss.epic.progress}.`)
+    } else if (ctx.story) {
+      lines.push(`You were on story: ${ctx.story.title}, task ${ctx.story.currentTask || "review"}.`)
+    }
+
+    // 4. WHAT to do next
+    if (ss?.next_action) {
+      lines.push(`\nNext action: ${ss.next_action}`)
+    }
+
+    // 5. READ these files
+    lines.push(`\n${readCommands}`)
+
+    // 6. KEY DECISIONS (if any)
+    if (ss?.key_decisions && ss.key_decisions.length > 0) {
+      lines.push(`\nKey decisions from your session:`)
+      for (const d of ss.key_decisions) {
+        lines.push(`- ${d}`)
+      }
+    }
+
+    // 7. TODO status (brief)
+    if (ctx.todos.length > 0) {
+      const inProgress = ctx.todos.filter(t => t.status === "in_progress")
+      const pending = ctx.todos.filter(t => t.status === "pending")
+      const completed = ctx.todos.filter(t => t.status === "completed")
+      lines.push(`\nTODO: ${completed.length} done, ${inProgress.length} in progress, ${pending.length} pending.`)
+    }
+
+    // 8. RULES
+    lines.push(`\nDO NOT ask user what to do. Read files above, then resume automatically.`)
+
+    return lines.join("\n")
+  }
+
   return {
     // Track active agent from chat messages
     "chat.message": async (input, output) => {
@@ -967,24 +1035,10 @@ This is /dev-epic autopilot mode. Execute stories sequentially until epic done.`
       const instructions = await formatInstructions(ctx)
       const readCommands = await generateReadCommands(agent, ctx.story, ctx.activeCommand, ctx.sessionState)
 
-      // Agent identity reminder
-      const agentIdentity = agent 
-        ? `You are @${agent} (.opencode/agents/${agent}.md). Load your persona and continue.`
-        : "You are an AI assistant helping with this project."
-
-      output.context.push(`# Session Continuation
-
-${agentIdentity}
-
-${readCommands}
-
----
-
-${context}
-
----
-
-${instructions}`)
+      // Build agentic briefing
+      const ss = ctx.sessionState
+      const briefing = buildBriefing(agent, ss, ctx, readCommands)
+      output.context.push(briefing)
       
       await log(directory, `  -> output.context pushed (${output.context.length} items)`)
       await log(directory, `=== COMPACTION DONE ===`)

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

@@ -82,9 +82,11 @@ metadata:
       
       <action name="execute-story">
         Follow /dev-story logic:
-        - Create nested TODO for tasks
-        - Implement all tasks (RED/GREEN/REFACTOR)
-        - Clear task TODO when done
+        - Read ONE story file
+        - Execute tasks ONE BY ONE (or parallel if independent)
+        - NEVER delegate entire story to @coder in one prompt
+        - After each task: verify, mark done, next task
+        - Clear task TODO when story done
       </action>
       
       <action name="mark-done">

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

@@ -90,18 +90,28 @@ metadata:
     </example>
   </phase>
 
-  <phase name="3-delegate" title="Delegate to @coder">
-    <action>Formulate task using template below</action>
-    <action>Call @coder with full context</action>
-    <rule>@coder writes code. Give direction, NOT solution.</rule>
-  </phase>
-
-  <phase name="4-verify" title="Verify & Mark Done">
-    <action>Run tests</action>
-    <action>Check "Done when" criteria</action>
-    <action>Mark task ✅ in story file</action>
-    <action>Update .opencode/session-state.yaml (see format below)</action>
-    <next>Next task or story complete</next>
+  <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>
+    <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>
+    </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>
 
 </workflow>
@@ -168,9 +178,16 @@ This file survives compaction and tells the agent where to resume.
 </template>
 
 <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>
+  <rule name="verify-between">
+    After each task: run tests, verify, mark done, THEN next task.
+  </rule>
   <rule name="no-code">
     Give direction, NOT solution. @coder writes implementation.
   </rule>