@comfanion/workflow 4.38.1-dev.1 → 4.38.1-dev.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@comfanion/workflow",
-  "version": "4.38.1-dev.1",
+  "version": "4.38.1-dev.12",
   "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.1",
-  "buildDate": "2026-01-27T01:03:19.105Z",
+  "version": "4.38.1-dev.12",
+  "buildDate": "2026-01-27T11:55:26.654Z",
   "files": [
     "config.yaml",
     "FLOW.yaml",

package/src/opencode/agents/reviewer.md

@@ -6,7 +6,7 @@ temperature: 0.1     # Low temperature for precise analysis
 #model: openai/gpt-5.2-codex  # Best at finding bugs and security issues
 model: anthropic/claude-sonnet-4-5  # Best at finding bugs and security issues
 
-# Tools - Read-only for review (no writes)
+# Tools - Read-only for code, but CAN write review findings to story/epic files
 tools:
   read: true
   glob: true
@@ -18,12 +18,14 @@ tools:
   bash: true         # For running tests
   todowrite: false   # Reviewer doesn't manage todos
   todoread: true
-  edit: false        # Reviewer doesn't edit code
-  write: false       # Reviewer doesn't write files
+  edit: true         # To append ## Review section to story/epic files
+  write: false       # Reviewer doesn't write new files
 
-# Permissions - read-only analysis
+# Permissions - read-only for code, write ONLY to story/epic docs
 permission:
-  edit: deny         # Reviewer only reports, doesn't fix
+  edit:
+    "docs/sprint-artifacts/**/*.md": allow   # Story and epic files
+    "*": deny                                # Everything else read-only
   bash:
     "*": deny
     # Tests
@@ -116,10 +118,17 @@ permission:
     <action>If failures → include in review report as HIGH priority</action>
   </phase>
 
-  <phase name="6. Report">
-    <action>Categorize issues: High/Medium/Low</action>
-    <action>Provide specific fixes for each issue</action>
-    <action>Return verdict: APPROVE | CHANGES_REQUESTED | BLOCKED</action>
+  <phase name="6. Write to Story File">
+    <action>Append `### Review #N` block to the story file's `## Review` section (see code-review skill for format)</action>
+    <action>Determine N by counting existing `### Review #` blocks + 1</action>
+    <action>Include: verdict, summary, test/lint results, action items with file:line</action>
+    <critical>NEVER overwrite previous reviews — always APPEND. History is preserved for analytics.</critical>
+  </phase>
+
+  <phase name="7. Return Summary to Caller">
+    <action>Return SHORT summary so calling agent does NOT re-read the story file</action>
+    <action>Format: verdict + action items list (caller uses this directly)</action>
+    <critical>Caller (@dev) uses YOUR output, not the file. Keep it actionable.</critical>
   </phase>
 </workflow>
 
@@ -220,38 +229,33 @@ permission:
   </category>
 </review_checklist>
 
-<output_format>
-## Code Review: {{story_title}}
-
-**Reviewer:** @reviewer (Marcus)
-**Date:** {{date}}
-**Model:** GPT-5.2 Codex
-
-### Verdict: {{APPROVE | CHANGES_REQUESTED | BLOCKED}}
-
-### Summary
-{{1-2 sentence summary}}
-
-### Issues Found
-
-#### HIGH Priority (Must Fix)
-- **[Security]** `path/file.ts:42` - {{issue}}
-  - **Fix:** {{specific fix}}
-
-#### MEDIUM Priority (Should Fix)
-- **[Performance]** `path/file.ts:100` - {{issue}}
-  - **Fix:** {{specific fix}}
-
-#### LOW Priority (Nice to Have)
-- **[Style]** `path/file.ts:15` - {{issue}}
-
-### What's Good
-- {{positive feedback}}
-
-### Action Items
-- [ ] [HIGH] Fix {{issue}}
-- [ ] [MED] Add {{test/improvement}}
-  </output_format>
+<output_format hint="TWO outputs: file + return summary">
+
+  <file_output hint="Appended to story file ## Review section — full details for analytics">
+    ### Review #{{N}} — {{YYYY-MM-DD}}
+    **Verdict:** {{APPROVE | CHANGES_REQUESTED | BLOCKED}}
+    **Reviewer:** @reviewer (Marcus)
+    **Summary:** {{1-2 sentences}}
+    **Tests:** {{PASS | FAIL — details}}
+    **Lint:** {{PASS | FAIL — details}}
+    #### Action Items (if CHANGES_REQUESTED/BLOCKED)
+    - [ ] [HIGH] `path/file.ts:42` — {{issue}} → Fix: {{fix}}
+    - [ ] [MED] `path/file.ts:100` — {{issue}} → Fix: {{fix}}
+    #### What's Good (if APPROVE)
+    - {{positive feedback}}
+  </file_output>
+
+  <return_summary hint="Returned to calling agent — short, actionable, NO re-read needed">
+    **VERDICT: {{APPROVE | CHANGES_REQUESTED | BLOCKED}}**
+    {{IF CHANGES_REQUESTED or BLOCKED:}}
+    Action items:
+    - [HIGH] `path/file.ts:42` — {{issue}} → {{fix}}
+    - [MED] `path/file.ts:100` — {{issue}} → {{fix}}
+    {{IF APPROVE:}}
+    All good. No issues found.
+  </return_summary>
+
+</output_format>
 
 </agent>
 
@@ -269,4 +273,7 @@ permission:
 - Make architecture decisions (→ @architect)
 - Write documentation (→ @pm)
 
+**What I Write:**
+- `## Review` section in story files (append history: Review #1, #2, ...)
+
 **My Model:** GPT-5.2 Codex (best at finding bugs)

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

@@ -39,9 +39,20 @@ interface StoryContext {
   fullContent: string
 }
 
+interface SessionState {
+  command: string | null       // /dev-sprint, /dev-epic, /dev-story
+  agent: string | null
+  sprint: { number: number; status: string } | null
+  epic: { id: string; title: string; file: string; progress: string } | null
+  story: { id: string; title: string; file: string; current_task: string | null; completed_tasks: string[]; pending_tasks: string[] } | null
+  next_action: string | null
+  key_decisions: string[]
+}
+
 interface SessionContext {
   todos: TaskStatus[]
   story: StoryContext | null
+  sessionState: SessionState | null
   relevantFiles: string[]
   activeAgent: string | null
   activeCommand: string | null  // /dev-story, /dev-epic, /dev-sprint
@@ -169,7 +180,7 @@ export const CustomCompactionPlugin: Plugin = async (ctx) => {
   /**
    * Generate Read commands that agent MUST execute after compaction
    */
-  async function generateReadCommands(agent: string | null, story: StoryContext | null, activeCommand: string | null): Promise<string> {
+  async function generateReadCommands(agent: string | null, story: StoryContext | null, activeCommand: string | null, sessionState: SessionState | null): Promise<string> {
     const agentKey = (typeof agent === 'string' ? agent.toLowerCase() : null) || "default"
     const filesToRead = [...(MUST_READ_FILES[agentKey] || MUST_READ_FILES.default)]
     
@@ -179,17 +190,23 @@ export const CustomCompactionPlugin: Plugin = async (ctx) => {
       filesToRead.unshift(`.opencode/commands/${commandFile}`)
     }
     
-    // For dev/coder: add epic state file if in epic workflow
+    // For dev/coder: add session-state.yaml as priority read
     if ((agentKey === "dev" || agentKey === "coder")) {
-      const epicState = await getActiveEpicState()
-      if (epicState) {
-        // Epic state file (has all context)
-        filesToRead.unshift(epicState.statePath.replace(directory + "/", ""))
-      }
+      // Session state is most important — has everything
+      filesToRead.unshift(".opencode/session-state.yaml")
       
-      // Then story file if active
-      if (story) {
-        filesToRead.unshift(story.path)  // Story first!
+      // Then story file (from session state or StoryContext)
+      const storyFile = sessionState?.story?.file || story?.path
+      if (storyFile) {
+        filesToRead.unshift(storyFile)  // Story first!
+      }
+
+      // Epic state as backup (only if no session state)
+      if (!sessionState) {
+        const epicState = await getActiveEpicState()
+        if (epicState) {
+          filesToRead.unshift(epicState.statePath.replace(directory + "/", ""))
+        }
       }
     }
     
@@ -304,85 +321,113 @@ DO NOT skip this step. DO NOT ask user what to do. Just read these files first.`
     }
   }
 
+  /**
+   * PRIMARY source: session-state.yaml written by AI agent.
+   * Falls back to getActiveEpicState() + getActiveStory() if missing.
+   */
+  async function getSessionState(): Promise<SessionState | null> {
+    try {
+      const statePath = join(directory, ".opencode", "session-state.yaml")
+      const content = await readFile(statePath, "utf-8")
+      await log(directory, `  session-state.yaml found, parsing...`)
+
+      // Simple regex YAML parser for flat/nested fields
+      const str = (key: string): string | null => {
+        const m = content.match(new RegExp(`^${key}:\\s*["']?(.+?)["']?\\s*$`, 'm'))
+        return m ? m[1].trim() : null
+      }
+      const nested = (parent: string, key: string): string | null => {
+        const section = content.match(new RegExp(`^${parent}:\\s*\\n((?:  .+\\n?)*)`, 'm'))
+        if (!section) return null
+        const m = section[1].match(new RegExp(`^\\s+${key}:\\s*["']?(.+?)["']?\\s*$`, 'm'))
+        return m ? m[1].trim() : null
+      }
+      const list = (parent: string, key: string): string[] => {
+        const val = nested(parent, key)
+        if (!val) return []
+        // Handle [T1, T2] or T1, T2
+        const clean = val.replace(/^\[/, '').replace(/\]$/, '')
+        return clean.split(',').map(s => s.trim()).filter(Boolean)
+      }
+
+      // Parse key_decisions as list
+      const decisions: string[] = []
+      const decMatch = content.match(/^key_decisions:\s*\n((?:\s+-\s*.+\n?)*)/m)
+      if (decMatch) {
+        const items = decMatch[1].matchAll(/^\s+-\s*["']?(.+?)["']?\s*$/gm)
+        for (const item of items) {
+          decisions.push(item[1])
+        }
+      }
+
+      const state: SessionState = {
+        command: str('command'),
+        agent: str('agent'),
+        sprint: nested('sprint', 'number') ? {
+          number: parseInt(nested('sprint', 'number') || '0'),
+          status: nested('sprint', 'status') || 'unknown'
+        } : null,
+        epic: nested('epic', 'id') ? {
+          id: nested('epic', 'id') || '',
+          title: nested('epic', 'title') || '',
+          file: nested('epic', 'file') || '',
+          progress: nested('epic', 'progress') || ''
+        } : null,
+        story: nested('story', 'id') ? {
+          id: nested('story', 'id') || '',
+          title: nested('story', 'title') || '',
+          file: nested('story', 'file') || '',
+          current_task: nested('story', 'current_task'),
+          completed_tasks: list('story', 'completed_tasks'),
+          pending_tasks: list('story', 'pending_tasks')
+        } : null,
+        next_action: str('next_action'),
+        key_decisions: decisions
+      }
+
+      await log(directory, `  parsed: command=${state.command}, epic=${state.epic?.id}, story=${state.story?.id}`)
+      return state
+    } catch {
+      await log(directory, `  session-state.yaml not found, using fallback`)
+      return null
+    }
+  }
+
   async function getActiveStory(): Promise<StoryContext | null> {
     try {
-      // First, try to find epic state file
+      let storyPath: string | null = null
+
+      // First, try epic state file for story path
       const epicState = await getActiveEpicState()
-      if (epicState) {
-        // Parse epic state to get current story
-        const storyPathMatch = epicState.content.match(/next_action:\s*["']?Execute\s+(.+?)["']?$/m)
-        if (storyPathMatch) {
-          const storyFileName = storyPathMatch[1]
-          // Find story file
-          const sprintMatch = epicState.statePath.match(/sprint-(\d+)/)
-          if (sprintMatch) {
-            const storyPath = `docs/sprint-artifacts/sprint-${sprintMatch[1]}/stories/${storyFileName}`
-            const storyContent = await readFile(join(directory, storyPath), "utf-8")
-            
-            const titleMatch = storyContent.match(/^#\s+(.+)/m)
-            const statusMatch = storyContent.match(/\*\*Status:\*\*\s*(\w+)/i)
-            
-            const completedTasks: string[] = []
-            const pendingTasks: string[] = []
-            let currentTask: string | null = null
-            
-            // Parse tasks with more detail
-            const taskRegex = /- \[([ x])\]\s+\*\*T(\d+)\*\*[:\s]+(.+?)(?=\n|$)/g
-            let match
-            while ((match = taskRegex.exec(storyContent)) !== null) {
-              const [, checked, taskId, taskName] = match
-              const taskInfo = `T${taskId}: ${taskName.trim()}`
-              if (checked === "x") {
-                completedTasks.push(taskInfo)
-              } else {
-                if (!currentTask) currentTask = taskInfo
-                pendingTasks.push(taskInfo)
-              }
-            }
-            
-            // Parse acceptance criteria
-            const acceptanceCriteria: string[] = []
-            const acSection = storyContent.match(/## Acceptance Criteria[\s\S]*?(?=##|$)/i)
-            if (acSection) {
-              const acRegex = /- \[([ x])\]\s+(.+?)(?=\n|$)/g
-              while ((match = acRegex.exec(acSection[0])) !== null) {
-                const [, checked, criteria] = match
-                acceptanceCriteria.push(`${checked === "x" ? "✅" : "⬜"} ${criteria.trim()}`)
-              }
-            }
+      if (epicState?.nextStoryPath) {
+        storyPath = epicState.nextStoryPath
+      }
 
-            return {
-              path: storyPath,
-              title: titleMatch?.[1] || "Unknown Story",
-              status: statusMatch?.[1] || "unknown",
-              currentTask,
-              completedTasks,
-              pendingTasks,
-              acceptanceCriteria,
-              fullContent: storyContent
-            }
+      // Fallback: try sprint-status.yaml
+      if (!storyPath) {
+        try {
+          const sprintStatusPath = join(directory, "docs", "sprint-artifacts", "sprint-status.yaml")
+          const content = await readFile(sprintStatusPath, "utf-8")
+          const inProgressMatch = content.match(/status:\s*in-progress[\s\S]*?path:\s*["']?([^"'\n]+)["']?/i)
+          if (inProgressMatch) {
+            storyPath = inProgressMatch[1]
           }
+        } catch {
+          // No sprint-status.yaml
         }
       }
-      
-      // Fallback: try old sprint-status.yaml format
-      const sprintStatusPath = join(directory, "docs", "sprint-artifacts", "sprint-status.yaml")
-      const content = await readFile(sprintStatusPath, "utf-8")
-      
-      const inProgressMatch = content.match(/status:\s*in-progress[\s\S]*?path:\s*["']?([^"'\n]+)["']?/i)
-      if (!inProgressMatch) return null
 
-      const storyPath = inProgressMatch[1]
+      if (!storyPath) return null
+
+      // Parse story file
       const storyContent = await readFile(join(directory, storyPath), "utf-8")
-      
       const titleMatch = storyContent.match(/^#\s+(.+)/m)
       const statusMatch = storyContent.match(/\*\*Status:\*\*\s*(\w+)/i)
-      
+
       const completedTasks: string[] = []
       const pendingTasks: string[] = []
       let currentTask: string | null = null
-      
-      // Parse tasks with more detail
+
       const taskRegex = /- \[([ x])\]\s+\*\*T(\d+)\*\*[:\s]+(.+?)(?=\n|$)/g
       let match
       while ((match = taskRegex.exec(storyContent)) !== null) {
@@ -395,8 +440,7 @@ DO NOT skip this step. DO NOT ask user what to do. Just read these files first.`
           pendingTasks.push(taskInfo)
         }
       }
-      
-      // Parse acceptance criteria
+
       const acceptanceCriteria: string[] = []
       const acSection = storyContent.match(/## Acceptance Criteria[\s\S]*?(?=##|$)/i)
       if (acSection) {
@@ -478,31 +522,118 @@ DO NOT skip this step. DO NOT ask user what to do. Just read these files first.`
   }
 
   async function buildContext(agent: string | null): Promise<SessionContext> {
+    // PRIMARY: try session-state.yaml (written by AI agent)
+    const sessionState = await getSessionState()
+    
     const [todos, story] = await Promise.all([
       getTodoList(),
-      getActiveStory()
+      // If session state has story path, use it; otherwise parse files
+      sessionState?.story?.file 
+        ? readStoryFromPath(sessionState.story.file)
+        : getActiveStory()
     ])
     
     const epicState = await getActiveEpicState()
     const relevantFiles = await getRelevantFiles(agent, story)
-    const activeCommand = await detectActiveCommand(todos, epicState)
+    
+    // Command: from session state or detected from TODOs
+    const activeCommand = sessionState?.command || await detectActiveCommand(todos, epicState)
 
-    return { todos, story, relevantFiles, activeAgent: agent, activeCommand }
+    return { todos, story, sessionState, relevantFiles, activeAgent: agent, activeCommand }
+  }
+
+  /** Read and parse a story file by path */
+  async function readStoryFromPath(storyPath: string): Promise<StoryContext | null> {
+    try {
+      const storyContent = await readFile(join(directory, storyPath), "utf-8")
+      const titleMatch = storyContent.match(/^#\s+(.+)/m)
+      const statusMatch = storyContent.match(/\*\*Status:\*\*\s*(\w+)/i)
+
+      const completedTasks: string[] = []
+      const pendingTasks: string[] = []
+      let currentTask: string | null = null
+
+      const taskRegex = /- \[([ x])\]\s+\*\*T(\d+)\*\*[:\s]+(.+?)(?=\n|$)/g
+      let match
+      while ((match = taskRegex.exec(storyContent)) !== null) {
+        const [, checked, taskId, taskName] = match
+        const taskInfo = `T${taskId}: ${taskName.trim()}`
+        if (checked === "x") {
+          completedTasks.push(taskInfo)
+        } else {
+          if (!currentTask) currentTask = taskInfo
+          pendingTasks.push(taskInfo)
+        }
+      }
+
+      const acceptanceCriteria: string[] = []
+      const acSection = storyContent.match(/## Acceptance Criteria[\s\S]*?(?=##|$)/i)
+      if (acSection) {
+        const acRegex = /- \[([ x])\]\s+(.+?)(?=\n|$)/g
+        while ((match = acRegex.exec(acSection[0])) !== null) {
+          const [, checked, criteria] = match
+          acceptanceCriteria.push(`${checked === "x" ? "✅" : "⬜"} ${criteria.trim()}`)
+        }
+      }
+
+      return {
+        path: storyPath,
+        title: titleMatch?.[1] || "Unknown Story",
+        status: statusMatch?.[1] || "unknown",
+        currentTask,
+        completedTasks,
+        pendingTasks,
+        acceptanceCriteria,
+        fullContent: storyContent
+      }
+    } catch {
+      return null
+    }
   }
 
   async function formatDevContext(ctx: SessionContext): Promise<string> {
     const sections: string[] = []
-    
-    // Check if we're in epic workflow
-    const epicState = await getActiveEpicState()
-    
-    if (epicState) {
-      // Epic/Sprint workflow mode - show epic progress
-      const progress = epicState.totalStories > 0 
-        ? ((epicState.completedCount / epicState.totalStories) * 100).toFixed(0) 
-        : 0
+    const ss = ctx.sessionState
+
+    // SESSION STATE available — use it (primary source)
+    if (ss) {
+      let header = `## 🎯 Session State (from session-state.yaml)\n`
+      header += `**Command:** ${ss.command || "unknown"}\n`
+      
+      if (ss.sprint) {
+        header += `**Sprint:** #${ss.sprint.number} (${ss.sprint.status})\n`
+      }
+      if (ss.epic) {
+        header += `**Epic:** ${ss.epic.id} — ${ss.epic.title}\n`
+        header += `**Epic File:** \`${ss.epic.file}\`\n`
+        header += `**Epic Progress:** ${ss.epic.progress}\n`
+      }
+      if (ss.story) {
+        header += `\n**Story:** ${ss.story.id} — ${ss.story.title}\n`
+        header += `**Story File:** \`${ss.story.file}\` ← READ THIS FIRST\n`
+        header += `**Current Task:** ${ss.story.current_task || "all done"}\n`
+        header += `**Completed:** ${ss.story.completed_tasks.join(", ") || "none"}\n`
+        header += `**Pending:** ${ss.story.pending_tasks.join(", ") || "none"}\n`
+      }
+      
+      header += `\n### Next Action (DO THIS NOW)\n\`\`\`\n${ss.next_action || "Check TODO list"}\n\`\`\`\n`
+      
+      if (ss.key_decisions.length > 0) {
+        header += `\n### Key Technical Decisions\n`
+        header += ss.key_decisions.map(d => `- ${d}`).join("\n")
+      }
+      
+      sections.push(header)
+    }
+    // FALLBACK: parse epic state file
+    else {
+      const epicState = await getActiveEpicState()
+      if (epicState) {
+        const progress = epicState.totalStories > 0 
+          ? ((epicState.completedCount / epicState.totalStories) * 100).toFixed(0) 
+          : 0
 
-      sections.push(`## 🎯 Epic Workflow: ${epicState.epicTitle}
+        sections.push(`## 🎯 Epic Workflow: ${epicState.epicTitle}
 
 **Epic ID:** ${epicState.epicId}
 **Epic State:** \`${epicState.statePath}\` ← READ THIS FIRST
@@ -525,7 +656,10 @@ ${epicState.nextStoryPath ? `**Next Story:** \`${epicState.nextStoryPath}\` ←
 💡 **Note:** If this is part of /dev-sprint, after epic completes:
 1. Update sprint-status.yaml (mark epic done)
 2. Continue to next epic automatically`)
-    } else if (ctx.story) {
+      }
+    }
+    
+    if (!ss && ctx.story) {
       // Regular story mode
       const s = ctx.story
       const total = s.completedTasks.length + s.pendingTasks.length
@@ -777,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) => {
@@ -831,26 +1033,12 @@ This is /dev-epic autopilot mode. Execute stories sequentially until epic done.`
       
       const context = await formatContext(ctx)
       const instructions = await formatInstructions(ctx)
-      const readCommands = await generateReadCommands(agent, ctx.story, ctx.activeCommand)
-
-      // 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}
-
----
+      const readCommands = await generateReadCommands(agent, ctx.story, ctx.activeCommand, ctx.sessionState)
 
-${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 ===`)