@mindfoldhq/trellis 0.5.12 → 0.5.14

package/dist/templates/opencode/plugins/inject-subagent-context.js

@@ -14,24 +14,39 @@ import { TrellisContext, debugLog } from "../lib/trellis-context.js"
 const AGENTS_ALL = ["implement", "check", "research"]
 const AGENTS_REQUIRE_TASK = ["implement", "check"]
 
+// Match `Active task: <path>` on the first non-empty line of the dispatch
+// prompt. Mirrors the contract in workflow.md's [workflow-state:in_progress]
+// breadcrumb so multi-window users can disambiguate which task is targeted.
+const ACTIVE_TASK_HINT_RE = /^\s*Active task:\s*(\S+)\s*$/m
+
+function extractActiveTaskHint(prompt) {
+  if (typeof prompt !== "string" || !prompt) return null
+  const match = prompt.match(ACTIVE_TASK_HINT_RE)
+  return match ? match[1].trim() : null
+}
+
 /**
- * Get context for implement agent
+ * Get context for implement agent. `taskDir` may be relative
+ * (`.trellis/tasks/foo`) or absolute; both are resolved via
+ * `ctx.resolveTaskDir`.
  */
 function getImplementContext(ctx, taskDir) {
   const parts = []
+  const taskDirFull = ctx.resolveTaskDir(taskDir)
+  if (!taskDirFull) return ""
 
-  const jsonlPath = join(ctx.directory, taskDir, "implement.jsonl")
+  const jsonlPath = join(taskDirFull, "implement.jsonl")
   const entries = ctx.readJsonlWithFiles(jsonlPath)
   if (entries.length > 0) {
     parts.push(ctx.buildContextFromEntries(entries))
   }
 
-  const prd = ctx.readProjectFile(join(taskDir, "prd.md"))
+  const prd = ctx.readFile(join(taskDirFull, "prd.md"))
   if (prd) {
     parts.push(`=== ${taskDir}/prd.md (Requirements) ===\n${prd}`)
   }
 
-  const info = ctx.readProjectFile(join(taskDir, "info.md"))
+  const info = ctx.readFile(join(taskDirFull, "info.md"))
   if (info) {
     parts.push(`=== ${taskDir}/info.md (Technical Design) ===\n${info}`)
   }
@@ -40,18 +55,20 @@ function getImplementContext(ctx, taskDir) {
 }
 
 /**
- * Get context for check agent
+ * Get context for check agent. `taskDir` may be relative or absolute.
  */
 function getCheckContext(ctx, taskDir) {
   const parts = []
+  const taskDirFull = ctx.resolveTaskDir(taskDir)
+  if (!taskDirFull) return ""
 
-  const jsonlPath = join(ctx.directory, taskDir, "check.jsonl")
+  const jsonlPath = join(taskDirFull, "check.jsonl")
   const entries = ctx.readJsonlWithFiles(jsonlPath)
   if (entries.length > 0) {
     parts.push(ctx.buildContextFromEntries(entries))
   }
 
-  const prd = ctx.readProjectFile(join(taskDir, "prd.md"))
+  const prd = ctx.readFile(join(taskDirFull, "prd.md"))
   if (prd) {
     parts.push(`=== ${taskDir}/prd.md (Requirements) ===\n${prd}`)
   }
@@ -128,7 +145,8 @@ function getResearchContext(ctx) {
  */
 function buildPrompt(agentType, originalPrompt, context, isFinish = false) {
   const templates = {
-    implement: `# Implement Agent Task
+    implement: `<!-- trellis-hook-injected -->
+# Implement Agent Task
 
 You are the Implement Agent in the Multi-Agent Pipeline.
 
@@ -157,7 +175,8 @@ ${originalPrompt}
 - Follow all dev specs injected above
 - Report list of modified/created files when done`,
 
-    check: isFinish ? `# Finish Agent Task
+    check: isFinish ? `<!-- trellis-hook-injected -->
+# Finish Agent Task
 
 You are performing the final check before creating a PR.
 
@@ -191,7 +210,8 @@ ${originalPrompt}
 - Do NOT update specs for trivial changes (typos, formatting, obvious fixes)
 - If critical CODE issues found, report them clearly (fix specs, not code)
 - Verify all acceptance criteria in prd.md are met` :
-      `# Check Agent Task
+      `<!-- trellis-hook-injected -->
+# Check Agent Task
 
 You are the Check Agent in the Multi-Agent Pipeline.
 
@@ -219,7 +239,8 @@ ${originalPrompt}
 - Fix issues yourself, don't just report
 - Must execute complete checklist`,
 
-    research: `# Research Agent Task
+    research: `<!-- trellis-hook-injected -->
+# Research Agent Task
 
 You are the Research Agent in the Multi-Agent Pipeline.
 
@@ -264,9 +285,29 @@ function powershellQuote(value) {
   return `'${String(value).replace(/'/g, "''")}'`
 }
 
-function buildTrellisContextPrefix(contextKey, hostPlatform = process.platform) {
-  if (hostPlatform === "win32") {
-    // OpenCode's Windows Bash tool runs through PowerShell, not a POSIX shell.
+function envValue(env, key) {
+  const value = env?.[key]
+  return typeof value === "string" && value.trim() ? value.trim() : null
+}
+
+function shellBasename(value) {
+  return value.replace(/\\/g, "/").split("/").pop()?.toLowerCase() || ""
+}
+
+function isWindowsPosixShell(env = process.env) {
+  if (envValue(env, "MSYSTEM")) return true
+  if (envValue(env, "MINGW_PREFIX")) return true
+  if (envValue(env, "OPENCODE_GIT_BASH_PATH")) return true
+
+  const ostype = envValue(env, "OSTYPE")?.toLowerCase() || ""
+  if (/(msys|mingw|cygwin)/.test(ostype)) return true
+
+  const shell = shellBasename(envValue(env, "SHELL") || "")
+  return /^(bash|sh|zsh)(\.exe)?$/.test(shell)
+}
+
+function buildTrellisContextPrefix(contextKey, hostPlatform = process.platform, env = process.env) {
+  if (hostPlatform === "win32" && !isWindowsPosixShell(env)) {
     return `$env:TRELLIS_CONTEXT_ID = ${powershellQuote(contextKey)}; `
   }
 
@@ -285,7 +326,7 @@ function commandStartsWithTrellisContext(command) {
   return (
     /^TRELLIS_CONTEXT_ID\s*=/.test(firstCommand) ||
     /^export\s+TRELLIS_CONTEXT_ID\s*=/.test(firstCommand) ||
-    /^env\s+(?:[^\s=]+\s+)*TRELLIS_CONTEXT_ID\s*=/.test(firstCommand) ||
+    /^env\s+(?:(?:-\S+|[A-Za-z_][A-Za-z0-9_]*=\S*)\s+)*TRELLIS_CONTEXT_ID\s*=/.test(firstCommand) ||
     /^\$env:TRELLIS_CONTEXT_ID\s*=/i.test(firstCommand)
   )
 }
@@ -294,7 +335,7 @@ function commandStartsWithTrellisContext(command) {
  * OpenCode TUI may not expose OPENCODE_RUN_ID to Bash. The plugin hook still
  * receives session identity, so inject it into Bash commands before execution.
  */
-function injectTrellisContextIntoBash(ctx, input, output, hostPlatform) {
+function injectTrellisContextIntoBash(ctx, input, output, hostPlatform, env) {
   const args = output?.args
   const commandKey = getBashCommandKey(args)
   if (!commandKey) return false
@@ -306,7 +347,7 @@ function injectTrellisContextIntoBash(ctx, input, output, hostPlatform) {
   const contextKey = ctx.getContextKey(input)
   if (!contextKey) return false
 
-  args[commandKey] = `${buildTrellisContextPrefix(contextKey, hostPlatform)}${command}`
+  args[commandKey] = `${buildTrellisContextPrefix(contextKey, hostPlatform, env)}${command}`
   return true
 }
 
@@ -315,7 +356,7 @@ function injectTrellisContextIntoBash(ctx, input, output, hostPlatform) {
 // (packages/opencode/src/plugin/index.ts — `for ([_, fn] of Object.entries(mod)) await fn(input)`);
 // the previous `{ id, server }` object shape failed with
 // `TypeError: fn is not a function` in 1.2.x.
-export default async ({ directory, platform: hostPlatform = process.platform }) => {
+export default async ({ directory, platform: hostPlatform = process.platform, env = process.env }) => {
   const ctx = new TrellisContext(directory)
   debugLog("inject", "Plugin loaded, directory:", directory)
 
@@ -329,7 +370,7 @@ export default async ({ directory, platform: hostPlatform = process.platform })
 
           const toolName = input?.tool?.toLowerCase()
           if (toolName === "bash") {
-            if (injectTrellisContextIntoBash(ctx, input, output, hostPlatform)) {
+            if (injectTrellisContextIntoBash(ctx, input, output, hostPlatform, env)) {
               debugLog("inject", "Injected TRELLIS_CONTEXT_ID into Bash command")
             }
             return
@@ -354,8 +395,53 @@ export default async ({ directory, platform: hostPlatform = process.platform })
             return
           }
 
-          // Resolve active task through session runtime context.
-          const taskDir = ctx.getCurrentTask(input)
+          // Resolve active task in this priority order (only later steps
+          // run when earlier ones miss):
+          //   1. Exact session runtime context lookup for input.sessionID
+          //   2. `Active task: <path>` hint in the dispatch prompt
+          //      (explicit per-dispatch override — beats single-session
+          //      inference so multi-window users can disambiguate)
+          //   3. Single-session fallback — only when exactly 1 session
+          //      runtime file exists locally
+          let taskDir = null
+          let taskSource = null
+
+          const contextKey = ctx.getContextKey(input)
+          if (contextKey) {
+            const context = ctx.readContext(contextKey)
+            const exactRef = ctx.normalizeTaskRef(context?.current_task || "")
+            if (exactRef) {
+              taskDir = exactRef
+              taskSource = `session:${contextKey}`
+            }
+          }
+
+          if (!taskDir) {
+            const hintRef = extractActiveTaskHint(originalPrompt)
+            if (hintRef) {
+              const hintNormalized = ctx.normalizeTaskRef(hintRef)
+              if (hintNormalized) {
+                const hintDir = ctx.resolveTaskDir(hintNormalized)
+                if (hintDir && existsSync(hintDir)) {
+                  taskDir = hintNormalized
+                  taskSource = "prompt-hint"
+                  debugLog("inject", "Resolved task from Active task: hint:", hintNormalized)
+                }
+              }
+            }
+          }
+
+          if (!taskDir) {
+            const fallback = ctx._resolveSingleSessionFallback()
+            if (fallback?.taskPath) {
+              const fallbackDir = ctx.resolveTaskDir(fallback.taskPath)
+              if (fallbackDir && existsSync(fallbackDir)) {
+                taskDir = fallback.taskPath
+                taskSource = fallback.source
+                debugLog("inject", "Resolved task via single-session fallback:", taskDir, "source:", taskSource)
+              }
+            }
+          }
 
           // Agents requiring task directory
           if (AGENTS_REQUIRE_TASK.includes(subagentType)) {
@@ -364,8 +450,8 @@ export default async ({ directory, platform: hostPlatform = process.platform })
               debugLog("inject", "Skipping - no current task")
               return
             }
-            const taskDirFull = join(directory, taskDir)
-            if (!existsSync(taskDirFull)) {
+            const taskDirFull = ctx.resolveTaskDir(taskDir)
+            if (!taskDirFull || !existsSync(taskDirFull)) {
               debugLog("inject", "Skipping - task directory not found")
               return
             }

package/dist/templates/opencode/plugins/inject-workflow-state.js

@@ -25,7 +25,7 @@
 
 import { existsSync, readFileSync } from "fs"
 import { join } from "path"
-import { TrellisContext, debugLog } from "../lib/trellis-context.js"
+import { TrellisContext, debugLog, isTrellisSubagent } from "../lib/trellis-context.js"
 
 // Supports STATUS values with letters, digits, underscores, hyphens
 // (so "in-review" / "blocked-by-team" work alongside "in_progress").
@@ -111,6 +111,13 @@ export default async ({ directory }) => {
       // so it persists in conversation history.
       "chat.message": async (input, output) => {
         try {
+          // Skip Trellis sub-agent turns — the per-turn breadcrumb is for the
+          // main session only; sub-agent context comes from the parent's
+          // tool.execute.before injection.
+          if (isTrellisSubagent(input)) {
+            debugLog("workflow-state", "Skipping trellis subagent turn:", input?.agent)
+            return
+          }
           if (process.env.TRELLIS_HOOKS === "0" || process.env.TRELLIS_DISABLE_HOOKS === "1") {
             return
           }

package/dist/templates/opencode/plugins/session-start.js

@@ -6,7 +6,7 @@
  * Uses OpenCode's chat.message hook directly so the context persists in history.
  */
 
-import { TrellisContext, contextCollector, debugLog } from "../lib/trellis-context.js"
+import { TrellisContext, contextCollector, debugLog, isTrellisSubagent } from "../lib/trellis-context.js"
 import {
   buildSessionContext,
   hasPersistedInjectedContext,
@@ -43,6 +43,14 @@ export default async ({ directory, client }) => {
         const agent = input.agent || "unknown"
         debugLog("session", "chat.message called, sessionID:", sessionID, "agent:", agent)
 
+        // Skip Trellis sub-agent turns — sub-agent context is injected by
+        // `inject-subagent-context.js` on the parent's tool.execute.before;
+        // re-injecting the main-session SessionStart here would drown that.
+        if (isTrellisSubagent(input)) {
+          debugLog("session", "Skipping trellis subagent turn:", agent)
+          return
+        }
+
         if (process.env.TRELLIS_HOOKS === "0" || process.env.TRELLIS_DISABLE_HOOKS === "1") {
           debugLog("session", "Skipping - TRELLIS_HOOKS disabled")
           return

package/dist/templates/qoder/settings.json

@@ -7,7 +7,7 @@
           {
             "type": "command",
             "command": "{{PYTHON_CMD}} .qoder/hooks/session-start.py",
-            "timeout": 10
+            "timeout": 30
           }
         ]
       },
@@ -17,7 +17,7 @@
           {
             "type": "command",
             "command": "{{PYTHON_CMD}} .qoder/hooks/session-start.py",
-            "timeout": 10
+            "timeout": 30
           }
         ]
       },
@@ -27,7 +27,7 @@
           {
             "type": "command",
             "command": "{{PYTHON_CMD}} .qoder/hooks/session-start.py",
-            "timeout": 10
+            "timeout": 30
           }
         ]
       }
@@ -38,7 +38,7 @@
           {
             "type": "command",
             "command": "{{PYTHON_CMD}} .qoder/hooks/inject-workflow-state.py",
-            "timeout": 5
+            "timeout": 15
           }
         ]
       }

package/dist/templates/trellis/scripts/common/safe_commit.py

@@ -111,31 +111,61 @@ def safe_trellis_paths_to_add(repo_root: Path) -> list[str]:
     return paths
 
 
-def safe_archive_paths_to_add(repo_root: Path) -> list[str]:
+def safe_archive_paths_to_add(
+    repo_root: Path,
+    task_name: str | None = None,
+    modified_children: list[str] | None = None,
+) -> list[str]:
     """Return paths to stage after `task.py archive`.
 
-    Limited to the archive subtree (where the freshly-moved task lives) plus
-    the source task directory's parent area to capture the deletion in the
-    same commit. We pass the whole `.trellis/tasks/` path so deletions of the
-    pre-move path are tracked, but only as a SPECIFIC subpath — not the whole
-    `.trellis/` tree.
+    Scoped to ONLY the paths the archive operation actually touched:
+
+      - the archive subtree (where the freshly-moved task lives)
+      - the source task directory (for source-side deletes; caller pairs
+        this with `git rm --cached` since `git add` won't stage deletes
+        for a path that no longer exists in the working tree)
+      - any child task directories whose `task.json` was edited to drop
+        the archived parent (parent-children relationship update)
+
+    This narrow scope avoids "scope creep" — dirty changes in OTHER
+    active task dirs (parallel-window edits) are NOT bundled into the
+    archive commit. Callers handle each kind of change in its own
+    commit boundary.
+
+    Backwards-compat: with no arguments, the function walks the whole
+    `.trellis/tasks/` subtree the old way (active tasks + archive). New
+    callers should always pass `task_name`.
     """
     paths: list[str] = []
     tasks_dir = repo_root / DIR_WORKFLOW / DIR_TASKS
-    if tasks_dir.is_dir():
-        # The archive copy.
-        archive_dir = tasks_dir / DIR_ARCHIVE
+    if not tasks_dir.is_dir():
+        return paths
+
+    archive_dir = tasks_dir / DIR_ARCHIVE
+
+    if task_name is not None:
+        # Narrow scope — only paths that still exist on disk (so
+        # `git add` doesn't choke on the moved-away source). The caller
+        # handles the source-side deletes via `git rm --cached`
+        # explicitly.
         if archive_dir.is_dir():
-            paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}")
-        # Active tasks (some may have been re-touched, e.g. parent's
-        # children list). This captures the source-path deletion too because
-        # `git add` on a directory records removals.
-        for child in sorted(tasks_dir.iterdir()):
-            if not child.is_dir():
-                continue
-            if child.name == DIR_ARCHIVE:
-                continue
-            paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{child.name}")
+            paths.append(
+                f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}"
+            )
+        for child_name in modified_children or []:
+            paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{child_name}")
+        return paths
+
+    # Legacy wide scope (no task_name): preserve old behavior so callers
+    # that have not been updated keep working.
+    if archive_dir.is_dir():
+        paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{DIR_ARCHIVE}")
+    for child in sorted(tasks_dir.iterdir()):
+        if not child.is_dir():
+            continue
+        if child.name == DIR_ARCHIVE:
+            continue
+        paths.append(f"{DIR_WORKFLOW}/{DIR_TASKS}/{child.name}")
     return paths