@mindfoldhq/trellis 0.4.0-beta.8 → 0.4.0-rc.0

package/dist/templates/opencode/agents/dispatch.md

@@ -71,6 +71,10 @@ Execute each step in `phase` order.
 
 > Hook will auto-inject all specs, requirements, and technical design to subagent context.
 > Dispatch only needs to issue simple call commands.
+>
+> **OpenCode dispatch rule**: Call subagents synchronously (`run_in_background: false`).
+> Do NOT use `TaskOutput` or background polling as the completion signal for child phases.
+> The background wrapper can finish before the real subagent session is actually done.
 
 ### action: "implement"
 
@@ -79,7 +83,7 @@ Task(
   subagent_type: "implement",
   prompt: "Implement the feature described in prd.md in the task directory",
   model: "opus",
-  run_in_background: true
+  run_in_background: false
 )
 ```
 
@@ -98,7 +102,7 @@ Task(
   subagent_type: "check",
   prompt: "Check code changes, fix issues yourself",
   model: "opus",
-  run_in_background: true
+  run_in_background: false
 )
 ```
 
@@ -116,7 +120,7 @@ Task(
   subagent_type: "debug",
   prompt: "Fix the issues described in the task context",
   model: "opus",
-  run_in_background: true
+  run_in_background: false
 )
 ```
 
@@ -132,7 +136,7 @@ Task(
   subagent_type: "check",
   prompt: "[finish] Execute final completion check before PR",
   model: "opus",
-  run_in_background: true
+  run_in_background: false
 )
 ```
 
@@ -168,27 +172,23 @@ This will:
 ### Basic Pattern
 
 ```
-task_id = Task(
+result = Task(
   subagent_type: "implement",  // or "check", "debug"
   prompt: "Simple task description",
   model: "opus",
-  run_in_background: true
+  run_in_background: false
 )
 
-// Poll for completion
-for i in 1..N:
-    result = TaskOutput(task_id, block=true, timeout=300000)
-    if result.status == "completed":
-        break
+// Wait for the Task call to return before starting the next phase.
+// Do NOT call TaskOutput or use background polling inside OpenCode dispatch.
 ```
 
-### Timeout Settings
+### Execution Rule
 
-| Phase | Max Time | Poll Count |
-|-------|----------|------------|
-| implement | 30 min | 6 times |
-| check | 15 min | 3 times |
-| debug | 20 min | 4 times |
+- Run one phase at a time
+- Start the next phase only after the current `Task(...)` call returns
+- If a phase returns a clear timeout or failure, handle that result explicitly
+- Do **not** simulate completion by polling a background task wrapper
 
 ---
 
@@ -196,7 +196,7 @@ for i in 1..N:
 
 ### Timeout
 
-If a subagent times out, notify the user and ask for guidance:
+If a synchronous subagent call times out, notify the user and ask for guidance:
 
 ```
 "Subagent {phase} timed out after {time}. Options:
@@ -207,10 +207,11 @@ If a subagent times out, notify the user and ask for guidance:
 
 ### Subagent Failure
 
-If a subagent reports failure, read the output and decide:
+If a synchronous subagent call reports failure, read the output and decide:
 
 - If recoverable: call debug agent to fix
 - If not recoverable: notify user and ask for guidance
+- Do not switch back to `TaskOutput` polling for the same phase
 
 ---
 

package/dist/templates/opencode/lib/trellis-context.js

@@ -1,23 +1,16 @@
 /**
  * Trellis Context Manager
  *
- * Unified context management for OpenCode plugins.
- * Handles detection of oh-my-opencode, .claude/hooks/, and other edge cases.
- *
- * Usage:
- *   import { TrellisContext } from "./trellis-context.js"
- *   const ctx = new TrellisContext(directory)
- *   if (ctx.shouldSkipHook("session-start")) return
+ * Utility class for OpenCode plugins providing file reading,
+ * JSONL parsing, and context building capabilities.
  */
 
 import { existsSync, readFileSync, appendFileSync, readdirSync } from "fs"
-import { join } from "path"
-import { homedir, platform } from "os"
+import { isAbsolute, join } from "path"
+import { platform } from "os"
 import { execSync } from "child_process"
 
-// Python command: Windows uses 'python', macOS/Linux use 'python3'
 const PYTHON_CMD = platform() === "win32" ? "python" : "python3"
-
 // Debug logging
 const DEBUG_LOG = "/tmp/trellis-plugin-debug.log"
 
@@ -33,151 +26,17 @@ function debugLog(prefix, ...args) {
 
 /**
  * Trellis Context Manager
- *
- * Centralized logic for:
- * - Detecting oh-my-opencode installation
- * - Checking .claude/hooks/ presence
- * - Determining which plugin should handle each hook
  */
 export class TrellisContext {
   constructor(directory) {
     this.directory = directory
-    this._omoInstalled = null
-    this._omoHooksEnabled = null
-    this._claudeHooksPresent = {}
-
     debugLog("context", "TrellisContext initialized", { directory })
   }
 
-  // ============================================================
-  // oh-my-opencode Detection
-  // ============================================================
-
-  /**
-   * Check if oh-my-opencode is installed
-   *
-   * Detection order:
-   * 1. Check if oh-my-opencode.json exists (most reliable)
-   * 2. Fallback: check opencode.json plugin list
-   */
-  isOmoInstalled() {
-    if (this._omoInstalled !== null) {
-      return this._omoInstalled
-    }
-
-    try {
-      const configDir = join(homedir(), ".config", "opencode")
-
-      // Method 1: Check oh-my-opencode.json existence (omo-specific config)
-      const omoConfigPath = join(configDir, "oh-my-opencode.json")
-      if (existsSync(omoConfigPath)) {
-        this._omoInstalled = true
-        debugLog("context", "omo installed: oh-my-opencode.json exists")
-        return true
-      }
-
-      // Method 2: Fallback to plugin list check
-      const configPath = join(configDir, "opencode.json")
-      if (!existsSync(configPath)) {
-        this._omoInstalled = false
-        debugLog("context", "omo not installed: no config files")
-        return false
-      }
-
-      const content = readFileSync(configPath, "utf-8")
-      const config = JSON.parse(content)
-      const plugins = config.plugin || []
-
-      this._omoInstalled = plugins.some(p =>
-        typeof p === "string" && p.toLowerCase().includes("oh-my-opencode")
-      )
-
-      debugLog("context", "omo installed (plugin list):", this._omoInstalled)
-      return this._omoInstalled
-    } catch (e) {
-      debugLog("context", "omo detection error:", e.message)
-      this._omoInstalled = false
-      return false
-    }
-  }
-
-  /**
-   * Check if omo's claude_code.hooks is enabled
-   * Reads oh-my-opencode.json or defaults to true
-   */
-  isOmoHooksEnabled() {
-    if (this._omoHooksEnabled !== null) {
-      return this._omoHooksEnabled
-    }
-
-    if (!this.isOmoInstalled()) {
-      this._omoHooksEnabled = false
-      return false
-    }
-
-    try {
-      // Check global config
-      const globalConfig = join(homedir(), ".config", "opencode", "oh-my-opencode.json")
-      if (existsSync(globalConfig)) {
-        const content = readFileSync(globalConfig, "utf-8")
-        const config = JSON.parse(content)
-        if (config.claude_code?.hooks === false) {
-          this._omoHooksEnabled = false
-          debugLog("context", "omo hooks disabled in global config")
-          return false
-        }
-      }
-
-      // Check project config
-      const projectConfig = join(this.directory, "oh-my-opencode.json")
-      if (existsSync(projectConfig)) {
-        const content = readFileSync(projectConfig, "utf-8")
-        const config = JSON.parse(content)
-        if (config.claude_code?.hooks === false) {
-          this._omoHooksEnabled = false
-          debugLog("context", "omo hooks disabled in project config")
-          return false
-        }
-      }
-
-      // Default: enabled
-      this._omoHooksEnabled = true
-      debugLog("context", "omo hooks enabled (default)")
-      return true
-    } catch (e) {
-      debugLog("context", "omo hooks detection error:", e.message)
-      this._omoHooksEnabled = true // Default to enabled
-      return true
-    }
-  }
-
-  // ============================================================
-  // .claude/hooks/ Detection
-  // ============================================================
-
-  /**
-   * Check if a specific .claude/hooks/ file exists
-   */
-  hasClaudeHook(hookName) {
-    if (hookName in this._claudeHooksPresent) {
-      return this._claudeHooksPresent[hookName]
-    }
-
-    const hookPath = join(this.directory, ".claude", "hooks", `${hookName}.py`)
-    const exists = existsSync(hookPath)
-
-    this._claudeHooksPresent[hookName] = exists
-    debugLog("context", `claude hook ${hookName}:`, exists)
-    return exists
-  }
-
   // ============================================================
   // Trellis Project Detection
   // ============================================================
 
-  /**
-   * Check if this is a Trellis-managed project
-   */
   isTrellisProject() {
     return existsSync(join(this.directory, ".trellis"))
   }
@@ -191,60 +50,56 @@ export class TrellisContext {
       if (!existsSync(currentTaskPath)) {
         return null
       }
-      return readFileSync(currentTaskPath, "utf-8").trim()
+      const taskRef = readFileSync(currentTaskPath, "utf-8").trim()
+      const normalized = this.normalizeTaskRef(taskRef)
+      return normalized || null
     } catch {
       return null
     }
   }
 
-  // ============================================================
-  // Hook Decision Logic
-  // ============================================================
+  normalizeTaskRef(taskRef) {
+    if (!taskRef) {
+      return ""
+    }
 
-  /**
-   * Determine if our plugin should skip this hook
-   * (because omo will handle it via .claude/hooks/)
-   *
-   * @param {string} hookName - Hook name without extension (e.g., "session-start")
-   * @returns {boolean} - true if we should skip, false if we should handle
-   */
-  shouldSkipHook(hookName) {
-    // Not a Trellis project? Skip.
-    if (!this.isTrellisProject()) {
-      debugLog("context", `shouldSkipHook(${hookName}): skip - not Trellis project`)
-      return true
+    if (isAbsolute(taskRef)) {
+      return taskRef.trim()
     }
 
-    // omo not installed? We handle it.
-    if (!this.isOmoInstalled()) {
-      debugLog("context", `shouldSkipHook(${hookName}): handle - omo not installed`)
-      return false
+    let normalized = taskRef.trim().replace(/\\/g, "/")
+    while (normalized.startsWith("./")) {
+      normalized = normalized.slice(2)
     }
 
-    // omo installed but hooks disabled? We handle it.
-    if (!this.isOmoHooksEnabled()) {
-      debugLog("context", `shouldSkipHook(${hookName}): handle - omo hooks disabled`)
-      return false
+    if (normalized.startsWith("tasks/")) {
+      return `.trellis/${normalized}`
     }
 
-    // omo installed + hooks enabled + .claude/hooks/ exists? Skip (omo handles).
-    if (this.hasClaudeHook(hookName)) {
-      debugLog("context", `shouldSkipHook(${hookName}): skip - omo will handle via .claude/hooks/`)
-      return true
+    return normalized
+  }
+
+  resolveTaskDir(taskRef) {
+    const normalized = this.normalizeTaskRef(taskRef)
+    if (!normalized) {
+      return null
     }
 
-    // omo installed but no .claude/hooks/ file? We handle it.
-    debugLog("context", `shouldSkipHook(${hookName}): handle - no .claude/hooks/ file`)
-    return false
+    if (isAbsolute(normalized)) {
+      return normalized
+    }
+
+    if (normalized.startsWith(".trellis/")) {
+      return join(this.directory, normalized)
+    }
+
+    return join(this.directory, ".trellis", "tasks", normalized)
   }
 
   // ============================================================
   // File Reading Utilities
   // ============================================================
 
-  /**
-   * Read a file, return null on error
-   */
   readFile(filePath) {
     try {
       if (existsSync(filePath)) {
@@ -256,16 +111,10 @@ export class TrellisContext {
     return null
   }
 
-  /**
-   * Read a file relative to project directory
-   */
   readProjectFile(relativePath) {
     return this.readFile(join(this.directory, relativePath))
   }
 
-  /**
-   * Run a Python script and return output
-   */
   runScript(scriptPath, cwd = null) {
     try {
       const result = execSync(`${PYTHON_CMD} "${scriptPath}"`, {
@@ -284,12 +133,6 @@ export class TrellisContext {
   // JSONL Reading
   // ============================================================
 
-  /**
-   * Read all .md files in a directory
-   * @param {string} dirPath - Directory path relative to project root
-   * @param {number} maxFiles - Max files to read (prevent huge directories)
-   * @returns {Array<{path: string, content: string}>}
-   */
   readDirectoryMdFiles(dirPath, maxFiles = 20) {
     const results = []
     const fullPath = join(this.directory, dirPath)
@@ -339,11 +182,9 @@ export class TrellisContext {
         if (!file) continue
 
         if (entryType === "directory") {
-          // Read all .md files in directory
           const dirEntries = this.readDirectoryMdFiles(file)
           results.push(...dirEntries)
         } else {
-          // Read single file
           const fullPath = join(this.directory, file)
           const fileContent = this.readFile(fullPath)
           if (fileContent) {
@@ -357,74 +198,29 @@ export class TrellisContext {
     return results
   }
 
-  /**
-   * Build context string from file entries
-   */
   buildContextFromEntries(entries) {
     return entries.map(e => `=== ${e.path} ===\n${e.content}`).join("\n\n")
   }
 }
 
 // ============================================================
-// Context Collector (for synthetic message injection)
+// Context Collector (for session deduplication)
 // ============================================================
 
-/**
- * Simple context collector for cross-hook communication
- * Similar to oh-my-opencode's contextCollector
- */
 class ContextCollector {
   constructor() {
-    this.pending = new Map()
     this.processed = new Set()
   }
 
-  /**
-   * Store context for a session
-   */
-  store(sessionID, content) {
-    this.pending.set(sessionID, {
-      content,
-      timestamp: Date.now()
-    })
-    debugLog("collector", "stored context for session:", sessionID, "length:", content.length)
-  }
-
-  /**
-   * Check if session has pending context
-   */
-  hasPending(sessionID) {
-    return this.pending.has(sessionID)
-  }
-
-  /**
-   * Get and consume pending context
-   */
-  consume(sessionID) {
-    const pending = this.pending.get(sessionID)
-    this.pending.delete(sessionID)
-    return pending
-  }
-
-  /**
-   * Mark session as processed (for first-message-only injection)
-   */
   markProcessed(sessionID) {
     this.processed.add(sessionID)
   }
 
-  /**
-   * Check if session was already processed
-   */
   isProcessed(sessionID) {
     return this.processed.has(sessionID)
   }
 
-  /**
-   * Clear session state
-   */
   clear(sessionID) {
-    this.pending.delete(sessionID)
     this.processed.delete(sessionID)
   }
 }