opencode-athena 0.8.1-beta.0 → 0.8.1-beta.2

package/commands/athena-review-story.md

@@ -1,405 +1,110 @@
 ---
-description: 3-phase party review of BMAD stories with parallel agent analysis and informed discussion
+description: 3-phase party review of BMAD stories with Oracle and BMAD agents
 ---
 
-# Athena Review Story - Enhanced Party Review (3-Phase)
+# Athena Review Story
 
-Run a comprehensive "party review" on BMAD stories **after story creation but before development**.
+Run a comprehensive party review of BMAD stories **before development** to catch security, logic, best practice, and performance gaps.
 
-**Architecture:**
-- **Phase 1**: Background agent performs Oracle analysis (saves context)
-- **Phase 2**: Parallel BMAD agents analyze from their perspectives
-- **Phase 3**: Athena-orchestrated informed discussion with pre-informed agents
+## Instructions
 
----
-
-## Phase 1: Automated Review (Background Agent)
-
-### Step 1.1: Parse Arguments
-
-The command receives: `$ARGUMENTS`
+You receive: `$ARGUMENTS`
 
-**Scope Detection:**
-- Epic: `2`, `epic-2` → Reviews all stories in epic
-- Story: `2.3`, `story-2-3` → Deep dive on single story
-- Path: `docs/stories/story-2-3.md` → Explicit file
-- Flag: `--thorough` → Force advanced model
-
-### Step 1.2: Spawn Background Review Agent
-
-This review runs in a **separate context** to preserve main session tokens.
-
-```
-Use background_task to spawn a review agent:
+Parse the identifier from arguments (e.g., "2", "epic-2", "2.3", "story-2-3", or file path).
 
-background_task({
-  agent: "oracle",
-  description: "Party review of {identifier}",
-  prompt: `
-You are performing a party review for Athena.
+### Step 1: Phase 1 - Oracle Analysis
 
-1. Call the athena_review_story tool:
-   athena_review_story({ identifier: "{identifier}", thorough: {thorough} })
+Call `athena_story_review_analyze` with the identifier:
 
-2. Using the oraclePrompt from the result, invoke @oracle to analyze the stories.
-
-3. Parse Oracle's response and count findings by category and severity.
-
-4. Determine which BMAD agents should participate based on findings:
-   - Security issues → Architect (Winston), DEV (Amelia), TEA (Murat)
-   - Logic gaps → Analyst (Mary), DEV (Amelia), TEA (Murat)
-   - Performance issues → Architect (Winston), DEV (Amelia)
-   - Best practices → DEV (Amelia), Tech Writer (Paige)
-   - High severity issues → PM (John) always required
-
-5. Save the review document to: docs/reviews/party-review-{scope}-{identifier}-{date}.md
-
-6. Return a JSON summary:
-   {
-     "success": true,
-     "scope": "epic|story",
-     "identifier": "...",
-     "reviewDocumentPath": "...",
-     "findings": {
-       "total": N,
-       "high": N,
-       "medium": N,
-       "low": N,
-       "byCategory": { "security": N, "logic": N, "bestPractices": N, "performance": N }
-     },
-     "recommendedAgents": [
-       { "agent": "architect", "reason": "...", "priority": "required|recommended|optional" },
-       ...
-     ],
-     "oracleAnalysis": "..." 
-   }
-`
-})
+```json
+{
+  "identifier": "{parsed_identifier}"
+}
 ```
 
-### Step 1.3: Wait for Background Result
+The tool spawns Oracle internally, analyzes stories, saves a review document, and returns findings with recommended BMAD agents.
 
-Wait for the background task to complete and retrieve the Phase 1 result.
+If `success` is false, show the error and exit.
 
-```
-background_output({ task_id: "<task_id_from_step_1.2>" })
-```
+### Step 2: Present Summary and Get User Choice
 
-### Step 1.4: Present Summary to User
+Display Phase 1 results:
+- Finding counts by severity (high, medium, low)
+- Finding counts by category (security, logic, best practices, performance)
+- Review document path
+- Recommended BMAD agents
 
+Ask the user:
 ```
-📋 **Phase 1 Complete: Automated Review**
-
-**Scope**: {Epic/Story} {identifier}
-**Review Document**: {reviewDocumentPath}
-
-**Findings Summary**:
-- 🔴 High: {high} issues (must address)
-- 🟡 Medium: {medium} issues (should address)
-- 🟢 Low: {low} issues (nice to have)
-
-**By Category**:
-- 🔒 Security: {security}
-- 🧠 Logic: {logic}
-- ✨ Best Practices: {bestPractices}
-- ⚡ Performance: {performance}
-
-**Recommended BMAD Agents for Discussion**:
-{list recommended agents with reasons}
-
----
-
-**Options**:
-[Q] Quick review - Accept/Defer/Reject findings without discussion
-[D] Discuss with team - Launch Phase 2 parallel analysis + Phase 3 party mode
-[V] View full report - Open the review document
+[Q] Quick review - Simple accept/defer/reject without agent discussion
+[D] Discuss with team - Run parallel agent analysis + party discussion
+[V] View full report - Show the review document
 [E] Exit - End review session
 ```
 
-**If user selects [Q]**: Skip to Quick Decision Flow (below)
-**If user selects [D]**: Continue to Phase 2
-**If user selects [V]**: Display the review document, then return to options
-**If user selects [E]**: End session
+### Step 3: Handle User Choice
 
----
-
-## Phase 2: Parallel Agent Pre-Analysis
-
-When user selects [D], spawn parallel background agents for each recommended BMAD agent.
-
-### Step 2.1: Spawn Parallel Agent Analyses
-
-For each recommended agent, spawn a background task:
-
-```
-# Spawn in parallel - all at once
-background_task({
-  agent: "oracle",
-  description: "Architect analysis of {identifier}",
-  prompt: `
-You are Winston, the Software Architect from BMAD.
+**If [V]**: Read and display the review document, then return to Step 2.
 
-**Your Expertise**: System design, security architecture, scalability, technical debt
-**Your Perspective**: Architecture and system design implications
+**If [E]**: Exit with message "Review document saved to {path}".
 
-**Review the following stories and findings**:
-{storiesContent}
-
-**Oracle's Findings**:
-{oracleAnalysis}
-
-**Your Task**:
-1. Analyze each finding from your architecture perspective
-2. Identify any cross-story patterns (shared components, dependencies)
-3. Prioritize issues based on architectural impact
-4. Note any findings you agree with, disagree with, or want to add to
-
-**Return JSON**:
+**If [Q]**: Call `athena_party_discussion` with only Phase 1 results (quick mode):
+```json
 {
-  "agent": "architect",
-  "perspective": "architecture and system design",
-  "findings": {
-    "agreements": ["I agree with finding X because..."],
-    "concerns": ["From an architecture view, Y is concerning because..."],
-    "suggestions": ["Consider also addressing Z..."]
-  },
-  "crossStoryPatterns": [
-    { "pattern": "...", "affectedStories": ["2.1", "2.3"], "recommendation": "..." }
-  ],
-  "prioritizedIssues": [
-    { "findingId": "...", "priority": "critical|important|minor", "rationale": "..." }
-  ],
-  "summary": "Brief 2-3 sentence summary of my analysis"
+  "action": "start",
+  "phase1Result": "{JSON.stringify(phase1Result)}"
 }
-`
-})
-
-# Similar for DEV (Amelia), TEA (Murat), PM (John), etc.
-```
-
-### Step 2.2: Collect All Agent Analyses
-
-```
-# Wait for all parallel tasks
-architect_result = background_output({ task_id: "..." })
-dev_result = background_output({ task_id: "..." })
-tea_result = background_output({ task_id: "..." })
-pm_result = background_output({ task_id: "..." })
 ```
+Skip to Step 5 (interactive discussion).
 
-### Step 2.3: Synthesize Agent Perspectives
+**If [D]**: Continue to Step 4.
 
-Combine all agent analyses into a discussion context:
+### Step 4: Phase 2 - Parallel Agent Consultation
 
-```
-**Agent Analysis Summary**:
-
-**Consensus Points** (agents agree):
-- {list points where multiple agents agree}
-
-**Debate Points** (agents disagree):
-- {topic}: 
-  - Winston (Architect): {position}
-  - Amelia (DEV): {different position}
-
-**Priority Votes**:
-| Finding | Architect | DEV | TEA | PM | Consensus |
-|---------|-----------|-----|-----|----|-----------| 
-| SEC-001 | Critical  | Critical | Important | Critical | Strong |
-| LOG-002 | Minor     | Important | Critical | Important | Disputed |
-```
-
----
-
-## Phase 3: Informed Discussion (Athena Party Discussion)
-
-### Step 3.1: Start Party Discussion
-
-Initialize the party discussion with Phase 1 and Phase 2 results:
-
-```
-athena_party_discussion({
-  action: "start",
-  phase1Result: JSON.stringify(phase1Result),
-  phase2Result: JSON.stringify(phase2Result)
-})
-```
-
-This returns:
-- `sessionId` - Use this for subsequent calls
-- `currentItem` - First agenda item to discuss
-- `currentResponses` - Agent responses for the current item
-- `hasMoreItems` - Whether there are more items to discuss
-
-### Step 3.2: Present Finding and Agent Responses
-
-For each agenda item, display:
-
-```
-🎉 **Party Discussion: {currentItem.topic}**
-
-**Severity**: {currentItem.severity} | **Category**: {currentItem.category}
-**Type**: {currentItem.type}
-
----
-
-**Agent Perspectives:**
-
-{For each response in currentResponses:}
-{response.icon} **{response.agentName}**: {response.response}
-
----
-
-**Your Decision:**
-[A] Accept - Add to acceptance criteria
-[D] Defer - Move to another story
-[R] Reject - Won't address
-[S] Skip - Discuss later
-[N] Next - Continue to next finding without deciding
-```
-
-### Step 3.3: Record User Decision
-
-When user decides:
-
-```
-athena_party_discussion({
-  action: "decide",
-  sessionId: "{sessionId}",
-  findingId: "{currentItem.findingId}",
-  decision: "accept|defer|reject",
-  reason: "{optional reason from user}",
-  deferredTo: "{story ID if deferred}"
-})
-```
-
-If user selects Skip:
-```
-athena_party_discussion({
-  action: "skip",
-  sessionId: "{sessionId}",
-  findingId: "{currentItem.findingId}"
-})
-```
-
-### Step 3.4: Continue or Complete
-
-If `hasMoreItems` is true:
-```
-athena_party_discussion({
-  action: "continue",
-  sessionId: "{sessionId}"
-})
-```
-
-Display the next finding and repeat Step 3.2.
-
-If `hasMoreItems` is false, the tool returns a summary:
-
-```
-📋 **Discussion Complete**
-
-**Decisions Made**:
-- ✅ Accepted: {summary.decisions.accepted} findings
-- ⏸️ Deferred: {summary.decisions.deferred} findings
-- ❌ Rejected: {summary.decisions.rejected} findings
-- ⏳ Pending: {summary.decisions.pending} findings
-
-**Stories to Update**:
-{For each in summary.storyUpdatesNeeded:}
-- Story {storyId}: {additions.length} items to add
-
-Would you like me to update the story files now? [Y/N]
-```
-
-### Step 3.5: Apply Story Updates
-
-If user confirms, the story files will be updated with:
-- New acceptance criteria for accepted findings
-- Implementation notes for all decisions
-- Updated review document with decision log
-
-End the session:
-```
-athena_party_discussion({
-  action: "end",
-  sessionId: "{sessionId}"
-})
-```
-
----
-
-## Quick Decision Flow
-
-If user selected [Q] in Phase 1, skip Phases 2-3 and go directly to decisions:
-
-```
-Let's go through the findings quickly.
-
-🔴 **HIGH SEVERITY** ({count}):
-
-1. [{category}] {title}
-   Impact: {impact}
-   Suggestion: {suggestion}
-   
-   [A]ccept / [D]efer / [R]eject? 
-
-{Continue for each finding}
-
----
-
-Summary:
-- Accepted: {count}
-- Deferred: {count}  
-- Rejected: {count}
-
-Update stories now? [Y/N]
+Call `athena_story_review_consult` with Phase 1 results:
+```json
+{
+  "phase1Result": "{JSON.stringify(phase1Result)}"
+}
 ```
 
----
+The tool spawns all recommended agents in parallel, waits for completion, synthesizes responses, and returns consensus/debate points.
 
-## Story Update Flow
+Display Phase 2 summary (agents consulted, consensus points, debate points).
 
-After decisions are captured:
+### Step 5: Phase 3 - Party Discussion
 
-1. Load each affected story file
-2. Add new acceptance criteria for accepted findings
-3. Add notes for deferred items (with target)
-4. Update the review document with decisions
-5. Report completion
+Call `athena_party_discussion` to start interactive discussion:
 
+**Full mode** (with Phase 2):
+```json
+{
+  "action": "start",
+  "phase1Result": "{JSON.stringify(phase1Result)}",
+  "phase2Result": "{JSON.stringify(phase2Result)}"
+}
 ```
-✅ **Updates Complete**
-
-**Modified Files**:
-- docs/stories/story-2-1.md (added 2 ACs)
-- docs/stories/story-2-3.md (added 1 AC, 1 note)
-- docs/reviews/party-review-epic-2-2025-12-23.md (decisions recorded)
 
-🚀 Stories are ready for development!
+**Quick mode** (Phase 1 only - already called in Step 3):
+```json
+{
+  "action": "start",
+  "phase1Result": "{JSON.stringify(phase1Result)}"
+}
 ```
 
----
-
-## Usage Examples
-
-```bash
-# Epic review with full 3-phase workflow
-/athena-review-story epic-2
+For each agenda item:
+1. Present the finding with agent perspectives
+2. Ask user: [A]ccept / [D]efer / [R]eject / [S]kip
+3. Call `athena_party_discussion` with action "decide" or "skip"
+4. Call `athena_party_discussion` with action "continue" to get next item
 
-# Story review (focused)
-/athena-review-story 2.3
+When `hasMoreItems` is false, display final summary:
+- Decisions made (accepted, deferred, rejected, skipped)
+- Stories that need updates
 
-# Force thorough analysis
-/athena-review-story 2.3 --thorough
-```
-
----
+Call `athena_party_discussion` with action "end" to finalize.
 
-## Tips
+## Done
 
-- **Phase 1 runs in background** - Your main session stays responsive
-- **Phase 2 agents run in parallel** - Faster than sequential analysis
-- **Phase 3 uses real BMAD party mode** - Familiar interactive experience
-- **Skip to quick review** for simple stories with few findings
-- **Use --thorough** for security-critical or complex stories
+Review complete! Stories are ready for development.

package/dist/cli/index.js

@@ -13,6 +13,7 @@ import { promisify } from 'util';
 import 'yaml';
 import { z } from 'zod';
 import * as semver from 'semver';
+import semver__default from 'semver';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -3044,9 +3045,14 @@ async function uninstall(options) {
 // src/cli/commands/update.ts
 init_esm_shims();
 var execAsync3 = promisify(exec);
-async function getLatestVersion(packageName) {
+function detectReleaseChannel(version) {
+  if (version.includes("-beta")) return "beta";
+  if (version.includes("-alpha")) return "alpha";
+  return "latest";
+}
+async function getLatestVersion(packageName, tag = "latest") {
   try {
-    const { stdout } = await execAsync3(`npm view ${packageName} version`);
+    const { stdout } = await execAsync3(`npm view ${packageName}@${tag} version`);
     return stdout.trim();
   } catch {
     return null;
@@ -3054,11 +3060,12 @@ async function getLatestVersion(packageName) {
 }
 async function checkPackageUpdate(name, currentVersion) {
   const latest = await getLatestVersion(name);
+  const hasUpdate = latest !== null && semver__default.valid(latest) && semver__default.valid(currentVersion) ? semver__default.gt(latest, currentVersion) : latest !== null && latest !== currentVersion;
   return {
     name,
     current: currentVersion,
     latest: latest || currentVersion,
-    updateAvailable: latest !== null && latest !== currentVersion
+    updateAvailable: hasUpdate
   };
 }
 async function update(options) {
@@ -3072,13 +3079,15 @@ async function update(options) {
     "opencode-openai-codex-auth"
   ];
   const updates = [];
-  const athenaLatest = await getLatestVersion("opencode-athena");
+  const athenaChannel = detectReleaseChannel(VERSION);
+  const athenaLatest = await getLatestVersion("opencode-athena", athenaChannel);
   if (athenaLatest) {
+    const athenaHasUpdate = semver__default.valid(athenaLatest) && semver__default.valid(VERSION) ? semver__default.gt(athenaLatest, VERSION) : athenaLatest !== VERSION;
     updates.push({
       name: "opencode-athena",
       current: VERSION,
       latest: athenaLatest,
-      updateAvailable: athenaLatest !== VERSION
+      updateAvailable: athenaHasUpdate
     });
   }
   for (const pkgName of packagesToCheck) {
@@ -3120,7 +3129,8 @@ async function update(options) {
   if (athenaUpdate) {
     const athenaSpinner = ora2("Updating opencode-athena...").start();
     try {
-      await execAsync3("npm install -g opencode-athena@latest");
+      const channel = detectReleaseChannel(VERSION);
+      await fileManager.installDependencies([`opencode-athena@${channel}`]);
       athenaSpinner.succeed(`opencode-athena updated to ${athenaUpdate.latest}`);
     } catch (err) {
       athenaSpinner.fail("Failed to update opencode-athena");