@mindfoldhq/trellis 0.6.7 → 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>;
@@ -84,8 +92,14 @@ const ABORT_KILL_GRACE_MS = 1500;
 const SESSION_OVERVIEW_TIMEOUT_MS = 1500;
 const THROTTLE_MS = 500;
 const FIRST_REPLY_NOTICE = `<first-reply-notice>
-First visible reply: say once in Chinese that Trellis SessionStart context is loaded, then answer directly.
-This notice is one-shot: do not repeat it after the first assistant reply in the same session.
+On the first visible assistant reply in this session, briefly acknowledge that Trellis SessionStart context loaded.
+Choose the acknowledgment language in this order:
+1. Use the language of the user's current request (the user message that triggered this reply).
+2. If that request has no clear natural language, use an explicitly established project communication language.
+3. If neither provides a language, output the language-neutral fallback exactly: \`Trellis SessionStart ✓\`.
+Continue directly with the user's request after the acknowledgment.
+The acknowledgment must not alter the language used for the remainder of the response.
+This notice is one-shot: do not repeat it after the first visible assistant reply in this session.
 </first-reply-notice>`;
 
 // ── State types ───────────────────────────────────────────────────────
@@ -716,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);
@@ -936,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");
 }

package/dist/templates/pi/settings.json

@@ -3,9 +3,6 @@
   "extensions": [
     "./extensions/trellis/index.ts"
   ],
-  "skills": [
-    "./skills"
-  ],
   "prompts": [
     "./prompts"
   ]

package/dist/templates/shared-hooks/index.d.ts

@@ -12,7 +12,7 @@ export interface HookScript {
     content: string;
 }
 export type SharedHookName = "session-start.py" | "inject-shell-session-context.py" | "inject-workflow-state.py" | "inject-subagent-context.py";
-export type SharedHookPlatform = "claude" | "cursor" | "codex" | "gemini" | "qoder" | "copilot" | "codebuddy" | "droid" | "kiro" | "trae";
+export type SharedHookPlatform = "claude" | "cursor" | "codex" | "gemini" | "qoder" | "copilot" | "codebuddy" | "droid" | "kiro" | "trae" | "zcode";
 /**
  * Which shared hooks each platform actually invokes. Single source of truth
  * for shared-hook distribution — both `writeSharedHooks` (runtime install)
@@ -25,10 +25,11 @@ export type SharedHookPlatform = "claude" | "cursor" | "codex" | "gemini" | "qod
  * - `inject-workflow-state.py` — every platform with a UserPromptSubmit
  *   (or equivalent) event. Kiro + codex self-included; platforms without
  *   per-turn main-session hooks are excluded.
- * - `inject-subagent-context.py` — class-1 (push-based) platforms only.
- *   Class-2 (pull-based) platforms (codex, copilot, gemini, qoder) can't
- *   have hooks mutate sub-agent prompts — their sub-agents load context
- *   via a prelude instead.
+ * - `inject-subagent-context.py` — platforms with native sub-agent context
+ *   delivery. Most use a PreToolUse prompt mutation; Codex uses its
+ *   SubagentStart `additionalContext` event. Class-2 (pull-based) platforms
+ *   such as copilot, gemini, qoder, and trae still load context from a
+ *   self-loading agent profile.
  * - Kiro supports per-turn + spawn hooks on both surfaces (per the official
  *   docs https://kiro.dev/docs/cli/hooks/): the CLI custom agent declares
  *   `hooks.userPromptSubmit` + `hooks.agentSpawn`, and the IDE declares a
@@ -42,6 +43,11 @@ export type SharedHookPlatform = "claude" | "cursor" | "codex" | "gemini" | "qod
  *   or opt in to the Trellis one via `trellis init --with-statusline`
  *   (installed from `templates/claude/hooks/`, not from this table — no
  *   other platform has a statusLine event).
+ * - ZCode (3.x) ships a workspace hook config at `.zcode/config.json` covering
+ *   SessionStart + UserPromptSubmit in the main session, plus PreToolUse for
+ *   `Agent|Task`. Live probing confirmed `hookSpecificOutput.updatedInput`
+ *   reaches the sub-agent prompt, so ZCode is class-1 and ships
+ *   `inject-subagent-context.py`.
  */
 export declare const SHARED_HOOKS_BY_PLATFORM: Record<SharedHookPlatform, readonly SharedHookName[]>;
 /**

package/dist/templates/shared-hooks/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/shared-hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,iCAAiC,GACjC,0BAA0B,GAC1B,4BAA4B,CAAC;AAEjC,MAAM,MAAM,kBAAkB,GAC1B,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,GACT,WAAW,GACX,OAAO,GACP,MAAM,GACN,MAAM,CAAC;AAEX;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C,kBAAkB,EAClB,SAAS,cAAc,EAAE,CAgC1B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,EAAE,CAWnD;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CAGd"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/shared-hooks/index.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH,MAAM,WAAW,UAAU;IACzB,0CAA0C;IAC1C,IAAI,EAAE,MAAM,CAAC;IACb,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,cAAc,GACtB,kBAAkB,GAClB,iCAAiC,GACjC,0BAA0B,GAC1B,4BAA4B,CAAC;AAEjC,MAAM,MAAM,kBAAkB,GAC1B,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,GACT,WAAW,GACX,OAAO,GACP,MAAM,GACN,MAAM,GACN,OAAO,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,wBAAwB,EAAE,MAAM,CAC3C,kBAAkB,EAClB,SAAS,cAAc,EAAE,CAqC1B,CAAC;AAEF;;;GAGG;AACH,wBAAgB,oBAAoB,IAAI,UAAU,EAAE,CAWnD;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CAGd"}