@mindfoldhq/trellis 0.6.8 → 0.6.9

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

@@ -8,7 +8,13 @@
 
 import { existsSync, readdirSync } from "fs"
 import { join } from "path"
-import { TrellisContext, debugLog } from "../lib/trellis-context.js"
+import {
+  TrellisContext,
+  debugLog,
+  readContextInjectionLimits,
+  ContextBudget,
+  materializeArtifact,
+} from "../lib/trellis-context.js"
 
 // Supported subagent types
 const AGENTS_ALL = ["implement", "check", "research"]
@@ -29,64 +35,112 @@ function extractActiveTaskHint(prompt) {
  * Get context for implement agent. `taskDir` may be relative
  * (`.trellis/tasks/foo`) or absolute; both are resolved via
  * `ctx.resolveTaskDir`.
+ *
+ * Read order (mirrors Python `get_implement_context`):
+ *   1. All files in implement.jsonl (spec/research manifests)
+ *   2. prd.md (requirements)
+ *   3. design.md if present (technical design)
+ *   4. implement.md if present (execution plan)
+ * All blocks share one total budget (issue #441).
  */
 function getImplementContext(ctx, taskDir) {
   const parts = []
   const taskDirFull = ctx.resolveTaskDir(taskDir)
   if (!taskDirFull) return ""
 
-  const jsonlPath = join(taskDirFull, "implement.jsonl")
-  const entries = ctx.readJsonlWithFiles(jsonlPath)
-  if (entries.length > 0) {
-    parts.push(ctx.buildContextFromEntries(entries))
-  }
-
-  const prd = ctx.readFile(join(taskDirFull, "prd.md"))
-  if (prd) {
-    parts.push(`=== ${taskDir}/prd.md (Requirements) ===\n${prd}`)
-  }
+  const limits = readContextInjectionLimits(ctx.directory)
+  const budget = new ContextBudget(limits.max_total_bytes)
 
-  const design = ctx.readFile(join(taskDirFull, "design.md"))
-  if (design) {
-    parts.push(`=== ${taskDir}/design.md (Technical Design) ===\n${design}`)
+  // 1. Read implement.jsonl
+  const jsonlPath = join(taskDirFull, "implement.jsonl")
+  const blocks = ctx.readJsonlWithFiles(jsonlPath, limits, budget)
+  if (blocks.length > 0) {
+    parts.push(ctx.buildContextFromEntries(blocks))
   }
 
-  const implementPlan = ctx.readFile(join(taskDirFull, "implement.md"))
-  if (implementPlan) {
-    parts.push(`=== ${taskDir}/implement.md (Execution Plan) ===\n${implementPlan}`)
-  }
+  // 2. Requirements document
+  const prdBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/prd.md`,
+    `${taskDir}/prd.md (Requirements)`,
+    "Requirements document",
+    limits,
+    budget,
+  )
+  if (prdBlock) parts.push(prdBlock)
+
+  // 3. Technical design for complex tasks
+  const designBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/design.md`,
+    `${taskDir}/design.md (Technical Design)`,
+    "Technical design document",
+    limits,
+    budget,
+  )
+  if (designBlock) parts.push(designBlock)
+
+  // 4. Execution plan for complex tasks
+  const implementPlanBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/implement.md`,
+    `${taskDir}/implement.md (Execution Plan)`,
+    "Execution plan document",
+    limits,
+    budget,
+  )
+  if (implementPlanBlock) parts.push(implementPlanBlock)
 
   return parts.join("\n\n")
 }
 
 /**
  * Get context for check agent. `taskDir` may be relative or absolute.
+ * Same read order and shared budget as the implement context.
  */
 function getCheckContext(ctx, taskDir) {
   const parts = []
   const taskDirFull = ctx.resolveTaskDir(taskDir)
   if (!taskDirFull) return ""
 
-  const jsonlPath = join(taskDirFull, "check.jsonl")
-  const entries = ctx.readJsonlWithFiles(jsonlPath)
-  if (entries.length > 0) {
-    parts.push(ctx.buildContextFromEntries(entries))
-  }
+  const limits = readContextInjectionLimits(ctx.directory)
+  const budget = new ContextBudget(limits.max_total_bytes)
 
-  const prd = ctx.readFile(join(taskDirFull, "prd.md"))
-  if (prd) {
-    parts.push(`=== ${taskDir}/prd.md (Requirements) ===\n${prd}`)
-  }
-
-  const design = ctx.readFile(join(taskDirFull, "design.md"))
-  if (design) {
-    parts.push(`=== ${taskDir}/design.md (Technical Design) ===\n${design}`)
+  const jsonlPath = join(taskDirFull, "check.jsonl")
+  const blocks = ctx.readJsonlWithFiles(jsonlPath, limits, budget)
+  if (blocks.length > 0) {
+    parts.push(ctx.buildContextFromEntries(blocks))
   }
 
-  const implementPlan = ctx.readFile(join(taskDirFull, "implement.md"))
-  if (implementPlan) {
-    parts.push(`=== ${taskDir}/implement.md (Execution Plan) ===\n${implementPlan}`)
-  }
+  const prdBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/prd.md`,
+    `${taskDir}/prd.md (Requirements)`,
+    "Requirements document",
+    limits,
+    budget,
+  )
+  if (prdBlock) parts.push(prdBlock)
+
+  const designBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/design.md`,
+    `${taskDir}/design.md (Technical Design)`,
+    "Technical design document",
+    limits,
+    budget,
+  )
+  if (designBlock) parts.push(designBlock)
+
+  const implementPlanBlock = materializeArtifact(
+    ctx.directory,
+    `${taskDir}/implement.md`,
+    `${taskDir}/implement.md (Execution Plan)`,
+    "Execution plan document",
+    limits,
+    budget,
+  )
+  if (implementPlanBlock) parts.push(implementPlanBlock)
 
   return parts.join("\n\n")
 }

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

@@ -31,6 +31,82 @@ import { TrellisContext, debugLog, isTrellisSubagent } from "../lib/trellis-cont
 // (so "in-review" / "blocked-by-team" work alongside "in_progress").
 const TAG_RE = /\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n([\s\S]*?)\n\s*\[\/workflow-state:\1\]/g
 
+// Escape hatch for the per-turn breadcrumb (issue #427). Mirrors
+// `common.config.get_prompt_injection_config()` / the shared Python hook's
+// `_resolve_skip_keyword()` + `prompt_has_skip_keyword()`.
+const DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD = "no-trellis"
+
+function stripInlineComment(value) {
+  let inQuote = null
+  for (let idx = 0; idx < value.length; idx++) {
+    const ch = value[idx]
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null
+      continue
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch
+      continue
+    }
+    if (ch === "#" && (idx === 0 || /\s/.test(value[idx - 1]))) return value.slice(0, idx)
+  }
+  return value
+}
+
+function unquoteYaml(s) {
+  if (s.length >= 2 && s[0] === s[s.length - 1] && (s[0] === '"' || s[0] === "'")) return s.slice(1, -1)
+  return s
+}
+
+/**
+ * Line-based parser for ONLY the `prompt_injection:` block of
+ * `.trellis/config.yaml`. Not a general YAML parser — mirrors
+ * `common.config.get_prompt_injection_config()` semantics for this section
+ * only (missing key keeps the default; non-string value keeps the default).
+ */
+function readSkipKeyword(directory) {
+  const path = join(directory, ".trellis", "config.yaml")
+  if (!existsSync(path)) return DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD
+  let text
+  try {
+    text = readFileSync(path, "utf-8")
+  } catch {
+    return DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD
+  }
+
+  let inSection = false
+  let sectionIndent = -1
+  for (const rawLine of text.split(/\r?\n/)) {
+    const trimmed = rawLine.trim()
+    if (!inSection) {
+      if (/^prompt_injection\s*:\s*(#.*)?$/.test(trimmed)) {
+        inSection = true
+        sectionIndent = rawLine.length - rawLine.trimStart().length
+      }
+      continue
+    }
+    if (!trimmed || trimmed.startsWith("#")) continue
+    const indent = rawLine.length - rawLine.trimStart().length
+    if (indent <= sectionIndent) break
+    const m = trimmed.match(/^skip_keyword\s*:\s*(.*)$/)
+    if (!m) continue
+    return unquoteYaml(stripInlineComment(m[1]).trim())
+  }
+  return DEFAULT_PROMPT_INJECTION_SKIP_KEYWORD
+}
+
+/**
+ * Case-insensitive, word-boundary match of `keyword` in `text`. Hyphen
+ * counts as a word char so "no-trellisx" / "xno-trellis" don't match, but
+ * punctuation/whitespace boundaries do. Empty keyword never matches.
+ */
+function promptHasSkipKeyword(text, keyword) {
+  if (!keyword || typeof text !== "string") return false
+  const escaped = keyword.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
+  const pattern = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, "i")
+  return pattern.test(text)
+}
+
 /**
  * Parse workflow.md for [workflow-state:STATUS] blocks.
  *
@@ -124,18 +200,27 @@ export default async ({ directory }) => {
           if (!ctx.isTrellisProject()) {
             return
           }
+
+          const parts = output?.parts || []
+          const textPartIndex = parts.findIndex(
+            p => p.type === "text" && p.text !== undefined,
+          )
+          const originalText = textPartIndex !== -1 ? (parts[textPartIndex].text || "") : ""
+
+          // Escape hatch (issue #427): user prompt contains the skip keyword
+          // as a standalone word — emit nothing for this turn only.
+          if (promptHasSkipKeyword(originalText, readSkipKeyword(directory))) {
+            debugLog("workflow-state", "Skipping turn: skip keyword present in prompt")
+            return
+          }
+
           const templates = loadBreadcrumbs(directory)
           const task = getActiveTask(ctx, input)
           const breadcrumb = task
             ? buildBreadcrumb(task.id, task.status, templates, task.source)
             : buildBreadcrumb(null, "no_task", templates)
 
-          const parts = output?.parts || []
-          const textPartIndex = parts.findIndex(
-            p => p.type === "text" && p.text !== undefined,
-          )
           if (textPartIndex !== -1) {
-            const originalText = parts[textPartIndex].text || ""
             parts[textPartIndex].text = `${breadcrumb}\n\n${originalText}`
           } else {
             parts.unshift({ type: "text", text: breadcrumb })

package/dist/templates/pi/extensions/trellis/index.ts.txt

@@ -1,7 +1,15 @@
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { createHash, randomBytes } from "node:crypto";
-import { delimiter, dirname, isAbsolute, join, resolve } from "node:path";
+import {
+  delimiter,
+  dirname,
+  isAbsolute,
+  join,
+  relative,
+  resolve,
+} from "node:path";
 import { spawn, spawnSync } from "node:child_process";
+import { isUtf8 } from "node:buffer";
 
 // ── Types ──────────────────────────────────────────────────────────────
 type JsonObject = Record<string, unknown>;
@@ -722,6 +730,222 @@ class BBC {
   }
 }
 
+// ── Context Injection Limits (issue #441) ───────────────────────────────
+//
+// Notice text and behavior mirrored byte-for-byte from the shared-hooks
+// Python sub-agent context injection hook. Changing wording there requires
+// changing it here too.
+interface ContextInjectionLimits {
+  max_file_bytes: number;
+  max_artifact_bytes: number;
+  max_total_bytes: number;
+}
+const DEFAULT_CONTEXT_INJECTION_LIMITS: ContextInjectionLimits = {
+  max_file_bytes: 32768,
+  max_artifact_bytes: 65536,
+  max_total_bytes: 131072,
+};
+
+function truncateUtf8(buf: Buffer, cap: number): Buffer {
+  if (cap <= 0 || buf.length <= cap) return buf;
+  let i = cap;
+  // Back off over continuation bytes (10xxxxxx) to find the lead byte.
+  while (i > 0 && (buf[i - 1]! & 0xc0) === 0x80) i--;
+  if (i === 0) return Buffer.alloc(0);
+  const lead = buf[i - 1]!;
+  if (lead & 0x80) {
+    let seqLen = 1;
+    if ((lead & 0xe0) === 0xc0) seqLen = 2;
+    else if ((lead & 0xf0) === 0xe0) seqLen = 3;
+    else if ((lead & 0xf8) === 0xf0) seqLen = 4;
+    // Drop the lead byte too if its full sequence didn't fit.
+    if (i - 1 + seqLen > cap) i--;
+  }
+  return buf.subarray(0, i);
+}
+
+function stripInlineComment(value: string): string {
+  let inQuote: string | null = null;
+  for (let idx = 0; idx < value.length; idx++) {
+    const ch = value[idx]!;
+    if (inQuote) {
+      if (ch === inQuote) inQuote = null;
+      continue;
+    }
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      continue;
+    }
+    if (ch === "#" && (idx === 0 || /\s/.test(value[idx - 1]!)))
+      return value.slice(0, idx);
+  }
+  return value;
+}
+function unquoteYaml(s: string): string {
+  if (s.length >= 2 && s[0] === s[s.length - 1] && (s[0] === '"' || s[0] === "'"))
+    return s.slice(1, -1);
+  return s;
+}
+
+/** Line-based parser for ONLY the `context_injection:` block of
+ * `.trellis/config.yaml`. Not a general YAML parser — mirrors
+ * `common.config.get_context_injection_limits()` semantics for this
+ * section only (missing keys keep the default; invalid/negative values
+ * fall back to the default for that key). */
+function readContextInjectionLimits(repoRoot: string): ContextInjectionLimits {
+  const limits: ContextInjectionLimits = { ...DEFAULT_CONTEXT_INJECTION_LIMITS };
+  const text = readText(join(repoRoot, ".trellis", "config.yaml"));
+  if (!text) return limits;
+
+  let inSection = false;
+  let sectionIndent = -1;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const trimmed = rawLine.trim();
+    if (!inSection) {
+      if (/^context_injection\s*:\s*(#.*)?$/.test(trimmed)) {
+        inSection = true;
+        sectionIndent = rawLine.length - rawLine.trimStart().length;
+      }
+      continue;
+    }
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = rawLine.length - rawLine.trimStart().length;
+    if (indent <= sectionIndent) break;
+    const m = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)\s*:\s*(.*)$/);
+    if (!m) continue;
+    const key = m[1]!;
+    if (!(key in limits)) continue;
+    const raw = unquoteYaml(stripInlineComment(m[2]!).trim()).trim();
+    if (!/^-?\d+$/.test(raw)) continue; // invalid -> keep default
+    const value = parseInt(raw, 10);
+    if (value < 0) continue; // negative -> keep default
+    (limits as unknown as Record<string, number>)[key] = value;
+  }
+  return limits;
+}
+
+class ContextBudget {
+  used = 0;
+  constructor(private maxTotalBytes: number) {}
+  hasRoom(size: number): boolean {
+    if (this.maxTotalBytes <= 0) return true;
+    return this.used + size <= this.maxTotalBytes;
+  }
+  add(size: number): void {
+    this.used += size;
+  }
+}
+
+function truncateNotice(path: string, cap: number): string {
+  return `\n[Trellis: truncated at ${cap} bytes — read ${path} for the full content]`;
+}
+function isBinaryContent(data: Buffer): boolean {
+  return data.includes(0) || !isUtf8(data);
+}
+function binaryNotice(path: string, size: number, reason: string): string {
+  return `[Trellis: not inlined (binary file) — ${path} (${size} bytes): ${reason}]`;
+}
+function indexNotice(path: string, size: number, reason: string): string {
+  return `[Trellis: not inlined (total context limit reached) — ${path} (${size} bytes): ${reason}]`;
+}
+function budgetedBlock(
+  budget: ContextBudget,
+  header: string,
+  plainPath: string,
+  content: string,
+  reason: string,
+  sizeForIndex: number,
+): string {
+  const block = `=== ${header} ===\n${content}`;
+  const blockBytes = Buffer.byteLength(block, "utf-8");
+  if (!budget.hasRoom(blockBytes)) {
+    const notice = indexNotice(plainPath, sizeForIndex, reason);
+    budget.add(Buffer.byteLength(notice, "utf-8"));
+    return notice;
+  }
+  budget.add(blockBytes);
+  return block;
+}
+function readFileBytes(basePath: string, filePath: string): Buffer | null {
+  const full = join(basePath, filePath);
+  try {
+    if (!statSync(full).isFile()) return null;
+  } catch {
+    return null;
+  }
+  try {
+    return readFileSync(full);
+  } catch {
+    return null;
+  }
+}
+function materializeFile(
+  basePath: string,
+  filePath: string,
+  reason: string,
+  limits: ContextInjectionLimits,
+  budget: ContextBudget,
+): string | null {
+  const data = readFileBytes(basePath, filePath);
+  if (data === null) return null;
+  const size = data.length;
+  if (isBinaryContent(data)) {
+    const notice = binaryNotice(filePath, size, reason);
+    budget.add(Buffer.byteLength(notice, "utf-8"));
+    return notice;
+  }
+  const cap = limits.max_file_bytes;
+  const truncated = truncateUtf8(data, cap);
+  let content = truncated.toString("utf-8");
+  if (truncated.length < size) content += truncateNotice(filePath, cap);
+  return budgetedBlock(budget, filePath, filePath, content, reason, size);
+}
+function materializeArtifact(
+  basePath: string,
+  filePath: string,
+  headerLabel: string,
+  reason: string,
+  limits: ContextInjectionLimits,
+  budget: ContextBudget,
+): string | null {
+  const data = readFileBytes(basePath, filePath);
+  if (data === null) return null;
+  const size = data.length;
+  const cap = limits.max_artifact_bytes;
+  const truncated = truncateUtf8(data, cap);
+  let content = truncated.toString("utf-8");
+  if (truncated.length < size) content += truncateNotice(filePath, cap);
+  return budgetedBlock(budget, headerLabel, filePath, content, reason, size);
+}
+interface JsonlEntry {
+  file: string;
+  type: string;
+  reason: string;
+}
+function readJsonlEntries(basePath: string, jsonlPath: string): JsonlEntry[] {
+  const text = readText(join(basePath, jsonlPath));
+  if (!text) return [];
+  const entries: JsonlEntry[] = [];
+  for (const line of text.split(/\r?\n/)) {
+    const t = line.trim();
+    if (!t) continue;
+    try {
+      const item = JSON.parse(t) as JsonObject;
+      const filePath =
+        (typeof item.file === "string" && item.file) ||
+        (typeof item.path === "string" && item.path) ||
+        "";
+      if (!filePath) continue;
+      entries.push({
+        file: filePath,
+        type: typeof item.type === "string" ? item.type : "file",
+        reason: (typeof item.reason === "string" && item.reason) || "-",
+      });
+    } catch {}
+  }
+  return entries;
+}
+
 // ── Trellis Context ────────────────────────────────────────────────────
 function findRoot(start: string): string {
   let c = resolve(start);
@@ -942,35 +1166,59 @@ function buildContext(root: string, agent: string, key: string | null): string {
   const dir = readTaskDir(root, key);
   if (!dir)
     return "No active Trellis task found. Read .trellis/ before proceeding.";
-  const prd = readText(join(dir, "prd.md"));
-  const design = readText(join(dir, "design.md"));
-  const impl = readText(join(dir, "implement.md"));
+  const relTaskDir = relative(root, dir).replace(/\\/g, "/");
+  const limits = readContextInjectionLimits(root);
+  const budget = new ContextBudget(limits.max_total_bytes);
+
+  // 1. Curated spec/research files from {agent}.jsonl (same order, budget
+  //    processed first, matching Python's get_agent_context()).
   const jsonlName = TRELLIS_AGENT_JSONL[agent] ?? "";
-  let spec = "";
+  const specBlocks: string[] = [];
   if (jsonlName) {
-    const chunks: string[] = [];
-    for (const line of readText(join(dir, jsonlName)).split(/\r?\n/)) {
-      const t = line.trim();
-      if (!t) continue;
-      try {
-        const r = JSON.parse(t) as JsonObject;
-        const f = typeof r.file === "string" ? r.file : "";
-        if (f) {
-          const c = readText(join(root, f));
-          if (c) chunks.push(`## ${f}\n\n${c}`);
-        }
-      } catch {}
+    for (const entry of readJsonlEntries(dir, jsonlName)) {
+      if (entry.type === "directory") continue;
+      const block = materializeFile(root, entry.file, entry.reason, limits, budget);
+      if (block) specBlocks.push(block);
     }
-    spec = chunks.join("\n\n---\n\n");
   }
+  const spec = specBlocks.join("\n\n");
+
+  // 2-4. Task artifacts, in order: prd.md -> design.md -> implement.md.
+  const prd = materializeArtifact(
+    root,
+    `${relTaskDir}/prd.md`,
+    `${relTaskDir}/prd.md (Requirements)`,
+    "Requirements document",
+    limits,
+    budget,
+  );
+  const design = materializeArtifact(
+    root,
+    `${relTaskDir}/design.md`,
+    `${relTaskDir}/design.md (Technical Design)`,
+    "Technical design document",
+    limits,
+    budget,
+  );
+  const impl = materializeArtifact(
+    root,
+    `${relTaskDir}/implement.md`,
+    `${relTaskDir}/implement.md (Execution Plan)`,
+    "Execution plan document",
+    limits,
+    budget,
+  );
+
+  // prd/design/impl already carry their own "=== path (label) ===" header
+  // (from materializeArtifact) — no extra "### x.md" wrapper needed, that
+  // would just double the header.
   return [
     `## Trellis Task Context`,
     `Task directory: ${dir}`,
     "",
-    "### prd.md",
-    prd || "(missing)",
-    design ? "\n### design.md\n" + design : "",
-    impl ? "\n### implement.md\n" + impl : "",
+    prd ?? `(missing) ${relTaskDir}/prd.md`,
+    design ? "\n" + design : "",
+    impl ? "\n" + impl : "",
     spec ? "\n### Curated Spec / Research Context\n" + spec : "",
   ].join("\n");
 }