@mindfoldhq/trellis 0.6.5 → 0.6.7

package/dist/templates/omp/agents/trellis-implement.md

@@ -0,0 +1,45 @@
+---
+name: trellis-implement
+description: |
+  Code implementation expert. Understands Trellis specs and requirements, then implements features. No git commit allowed.
+tools: read, write, edit, bash, find, search, ast_grep, lsp
+model: pi/task
+---
+
+# Implement Agent
+
+You are the Implement Agent in the Trellis workflow.
+
+## Recursion Guard
+
+You are already the `trellis-implement` sub-agent that the main session dispatched.
+Do the implementation work directly.
+
+- Do NOT spawn another `trellis-implement` or `trellis-check` sub-agent via the `task` tool.
+- If injected workflow-state breadcrumbs say to dispatch `trellis-implement` / `trellis-check`,
+  treat that as a main-session instruction that is already satisfied by your current role.
+- Only the main session may dispatch Trellis implement/check agents. If more parallel work
+  is needed, report that recommendation instead of spawning.
+
+## Core Responsibilities
+
+1. Understand the active task requirements.
+2. Read and follow the spec and research files listed in the task's `implement.jsonl`.
+3. Implement the requested change using existing project patterns.
+4. Run the relevant lint, typecheck, and focused tests for the touched code.
+5. Report files changed and verification results.
+
+## Forbidden Operations
+
+Do not run:
+- `git commit`
+- `git push`
+- `git merge`
+
+## Working Rules
+
+- Read adjacent code and tests before editing.
+- Keep changes scoped to the task.
+- Do not revert unrelated user or concurrent changes.
+- Fix root causes rather than masking symptoms.
+- Prefer existing local helpers and platform patterns over new abstractions.

package/dist/templates/omp/agents/trellis-research.md

@@ -0,0 +1,30 @@
+---
+name: trellis-research
+description: |
+  Code and technical research expert. Finds relevant files, patterns, docs,
+  and persists findings to the current task's research/ directory.
+tools: read, write, bash, find, search, web_search
+model: pi/task
+---
+
+# Research Agent
+
+You are the Research Agent in the Trellis workflow.
+
+## Core Principle
+
+Persist every finding to a file. Chat context is temporary; files under the task
+directory survive compaction and handoff.
+
+## Core Responsibilities
+
+1. Resolve the active task with `python3 ./.trellis/scripts/task.py current --source`.
+2. Create `<task-dir>/research/` when it does not exist.
+3. Search internal code, specs, and relevant external documentation.
+4. Write each distinct topic to `<task-dir>/research/<topic-slug>.md`.
+5. Report only file paths and concise summaries to the caller.
+
+## Scope Limits
+
+Write only under the current task's `research/` directory.
+Do not edit code, specs, platform config, or task files outside research artifacts.

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

@@ -0,0 +1,462 @@
+import type { ExtensionAPI } from "@oh-my-pi/pi-coding-agent";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { join, dirname, isAbsolute, relative, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+
+// ---------------------------------------------------------------------------
+// Project root detection
+// ---------------------------------------------------------------------------
+
+function findProjectRoot(startDir: string): string | null {
+   let current = startDir;
+   while (true) {
+      if (existsSync(join(current, ".trellis"))) return current;
+      const parent = dirname(current);
+      if (parent === current) break;
+      current = parent;
+   }
+   return null;
+}
+
+// ---------------------------------------------------------------------------
+// Session identity helpers (mirrors Python _sanitize_key / _hash_value / _context_key)
+// ---------------------------------------------------------------------------
+
+function sanitizeKey(raw: string): string {
+   const safe = raw.trim().replace(/[^A-Za-z0-9._-]+/g, "_").replace(/^[._-]+|[._-]+$/g, "");
+   return safe ? safe.slice(0, 160) : "";
+}
+
+function hashValue(raw: string): string {
+   return createHash("sha256").update(raw).digest("hex").slice(0, 24);
+}
+
+function buildContextKey(platformName: string, kind: string, value: string): string {
+   if (kind === "transcript") {
+      return `${platformName}_transcript_${hashValue(value)}`;
+   }
+   const safeValue = sanitizeKey(value);
+   return safeValue ? `${platformName}_${safeValue}` : `${platformName}_${hashValue(value)}`;
+}
+
+function deriveContextKey(ctx?: { sessionManager?: { getSessionId?: () => string; getSessionFile?: () => string } }): string | null {
+   const sessionId = ctx?.sessionManager?.getSessionId?.();
+   if (sessionId) {
+      return buildContextKey("omp", "session", sessionId);
+   }
+   const sessionFile = ctx?.sessionManager?.getSessionFile?.();
+   if (sessionFile) {
+      return buildContextKey("omp", "transcript", sessionFile);
+   }
+   const override = process.env.TRELLIS_CONTEXT_ID?.trim();
+   return override ? sanitizeKey(override) || hashValue(override) : null;
+}
+
+function isInsideRoot(root: string, candidate: string): boolean {
+   const rel = relative(root, candidate);
+   return rel === "" || (rel !== ".." && !rel.startsWith("../") && !rel.startsWith("..\\") && !isAbsolute(rel));
+}
+
+function resolveProjectFile(projectRoot: string, file: string): string | null {
+   try {
+      const rootReal = realpathSync(projectRoot);
+      const targetReal = realpathSync(resolve(projectRoot, file));
+      return isInsideRoot(rootReal, targetReal) ? targetReal : null;
+   } catch {
+      return null;
+   }
+}
+
+// ---------------------------------------------------------------------------
+// Active task resolution
+// ---------------------------------------------------------------------------
+
+function resolveActiveTaskStatus(
+   projectRoot: string,
+   contextKey: string | null,
+): { status: string; taskDir: string | null; taskTitle: string | null } {
+   const sessionsDir = join(projectRoot, ".trellis", ".runtime", "sessions");
+   if (!existsSync(sessionsDir)) return { status: "no_task", taskDir: null, taskTitle: null };
+
+   // --- 通过 context key 解析 session 文件 ---
+   let sessionFilePath: string | null = null;
+
+   if (contextKey) {
+      const candidate = join(sessionsDir, `${contextKey}.json`);
+      if (existsSync(candidate)) {
+         sessionFilePath = candidate;
+      } else {
+         return { status: "no_task", taskDir: null, taskTitle: null };
+      }
+   } else {
+      // No identity: use single-session fallback only when there is exactly one session file.
+      let sessionFiles: string[];
+      try {
+         sessionFiles = readdirSync(sessionsDir).filter((f) => f.endsWith(".json"));
+      } catch {
+         return { status: "no_task", taskDir: null, taskTitle: null };
+      }
+      if (sessionFiles.length === 1) {
+         sessionFilePath = join(sessionsDir, sessionFiles[0]);
+      } else {
+         return { status: "no_task", taskDir: null, taskTitle: null };
+      }
+   }
+
+   // --- 读取 session 数据 ---
+   let sessionData: Record<string, unknown>;
+   try {
+      sessionData = JSON.parse(readFileSync(sessionFilePath, "utf-8"));
+   } catch {
+      return { status: "no_task", taskDir: null, taskTitle: null };
+   }
+
+   const currentTask = sessionData.current_task;
+   if (typeof currentTask !== "string" || !currentTask)
+      return { status: "no_task", taskDir: null, taskTitle: null };
+
+   const taskDir = join(projectRoot, currentTask);
+   const taskJsonPath = join(taskDir, "task.json");
+   if (!existsSync(taskJsonPath)) return { status: "no_task", taskDir: null, taskTitle: null };
+
+   let taskData: Record<string, unknown>;
+   try {
+      taskData = JSON.parse(readFileSync(taskJsonPath, "utf-8"));
+   } catch {
+      return { status: "no_task", taskDir: null, taskTitle: null };
+   }
+
+   return {
+      status: typeof taskData.status === "string" ? taskData.status : "planning",
+      taskDir,
+      taskTitle: typeof taskData.title === "string" ? taskData.title : null,
+   };
+}
+
+// ---------------------------------------------------------------------------
+// Session context — spawns get_context.py default mode (same as Claude hook)
+// ---------------------------------------------------------------------------
+
+const SESSION_CONTEXT_TIMEOUT_MS = 5000;
+
+function buildSessionContext(projectRoot: string, contextKey: string | null): string {
+   const script = join(projectRoot, ".trellis", "scripts", "get_context.py");
+   if (!existsSync(script)) return "";
+
+   try {
+      const result = spawnSync("python3", [script], {
+         cwd: projectRoot,
+         encoding: "utf-8",
+         env: contextKey
+            ? { ...process.env, TRELLIS_CONTEXT_ID: contextKey }
+            : process.env,
+         timeout: SESSION_CONTEXT_TIMEOUT_MS,
+         windowsHide: true,
+      });
+      if (result.status !== 0 || !result.stdout?.trim()) {
+         return "";
+      }
+      return `<session-context>\n${result.stdout.trim()}\n</session-context>`;
+   } catch {
+      return "";
+   }
+}
+
+// ---------------------------------------------------------------------------
+// Task context — prd.md, info.md, and jsonl-referenced spec/research files
+// ---------------------------------------------------------------------------
+
+type AgentType = "trellis-implement" | "trellis-check" | "trellis-research" | null;
+
+function buildTaskContext(projectRoot: string, taskDir: string, agentType?: AgentType): string {
+   const parts: string[] = [];
+
+   // prd.md and info.md — always included
+   let prd = "";
+   try { prd = readFileSync(join(taskDir, "prd.md"), "utf-8"); } catch { }
+   if (prd.trim()) parts.push(`## PRD\n\n${prd.trim()}`);
+
+   let info = "";
+   try { info = readFileSync(join(taskDir, "info.md"), "utf-8"); } catch { }
+   if (info.trim()) parts.push(`## Info\n\n${info.trim()}`);
+
+   // Determine which jsonl files to read based on agent type
+   let jsonlNames: string[];
+   if (agentType === "trellis-implement") {
+      jsonlNames = ["implement.jsonl"];
+   } else if (agentType === "trellis-check") {
+      jsonlNames = ["check.jsonl"];
+   } else if (agentType === "trellis-research") {
+      jsonlNames = []; // research agent gets only prd + info
+   } else {
+      jsonlNames = ["implement.jsonl", "check.jsonl"]; // main session: all
+   }
+
+   for (const jsonlName of jsonlNames) {
+      const jsonlPath = join(taskDir, jsonlName);
+      if (!existsSync(jsonlPath)) continue;
+
+      let lines: string[];
+      try {
+         lines = readFileSync(jsonlPath, "utf-8").split(/\r?\n/);
+      } catch {
+         continue;
+      }
+
+      const fileChunks: string[] = [];
+      for (const line of lines) {
+         const trimmed = line.trim();
+         if (!trimmed) continue;
+         try {
+            const row = JSON.parse(trimmed) as Record<string, unknown>;
+            const file = typeof row.file === "string" ? row.file.trim() : "";
+            if (!file) continue;
+            const targetPath = resolveProjectFile(projectRoot, file);
+            if (!targetPath) continue;
+            let content = "";
+            try { content = readFileSync(targetPath, "utf-8"); } catch { }
+            if (content.trim()) {
+               fileChunks.push(`### ${file}\n\n${content.trim()}`);
+            }
+         } catch {
+            // seed rows and malformed lines are non-fatal
+         }
+      }
+
+      if (fileChunks.length > 0) {
+         parts.push(`## ${jsonlName}\n\n${fileChunks.join("\n\n---\n\n")}`);
+      }
+   }
+
+   return parts.length > 0
+      ? `<task-context>\n${parts.join("\n\n")}\n</task-context>`
+      : "";
+}
+
+// ---------------------------------------------------------------------------
+// Per-turn cache — prevents redundant workflow-state resolution within a
+// single event cascade (input, before_agent_start, and context fire closely)
+// ---------------------------------------------------------------------------
+
+const SESSION_OVERVIEW_TEXT =
+   "Trellis workflow system active. Use skills and agents as directed by the workflow state.";
+
+class TurnContextCache {
+   private key: string | null = null;
+   private timestamp = 0;
+   private workflowMsg = "";
+   private static readonly TTL_MS = 1500;
+
+   get(projectRoot: string, contextKey: string | null): { workflowMsg: string } {
+      const now = Date.now();
+      const cacheKey = `${projectRoot}:${contextKey ?? ""}`;
+      if (
+         this.key === cacheKey &&
+         now - this.timestamp < TurnContextCache.TTL_MS
+      ) {
+         return { workflowMsg: this.workflowMsg };
+      }
+
+      const { status } = resolveActiveTaskStatus(projectRoot, contextKey);
+
+      const workflowPath = join(projectRoot, ".trellis", "workflow.md");
+      let workflowMd = "";
+      try { workflowMd = readFileSync(workflowPath, "utf-8"); } catch { }
+
+      let workflowBody = "";
+      if (workflowMd) {
+         const blocks = parseWorkflowStateBlocks(workflowMd);
+         const activeBlock = blocks.find((b) => b.status === status);
+         if (activeBlock) {
+            workflowBody = `[workflow-state:${activeBlock.status}]\n${activeBlock.content}\n[/workflow-state:${activeBlock.status}]`;
+         }
+      }
+      if (!workflowBody) {
+         workflowBody = "Refer to workflow.md for current step.";
+      }
+
+      this.workflowMsg = `<workflow-state>\n${workflowBody}\n</workflow-state>\n\n<session-overview>\n${SESSION_OVERVIEW_TEXT}\n</session-overview>`;
+
+      this.key = cacheKey;
+      this.timestamp = now;
+      return { workflowMsg: this.workflowMsg };
+   }
+}
+
+// ---------------------------------------------------------------------------
+// Workflow-state tag parsing
+// ---------------------------------------------------------------------------
+
+const WORKFLOW_STATE_RE =
+   /\[workflow-state:([A-Za-z0-9_-]+)\]\s*\n([\s\S]*?)\n\s*\[\/workflow-state:\1\]/g;
+
+interface WorkflowStateBlock {
+   status: string;
+   content: string;
+}
+
+function parseWorkflowStateBlocks(markdown: string): WorkflowStateBlock[] {
+   const blocks: WorkflowStateBlock[] = [];
+   for (const match of markdown.matchAll(WORKFLOW_STATE_RE)) {
+      blocks.push({
+         status: match[1],
+         content: match[2].trim(),
+      });
+   }
+   return blocks;
+}
+
+// ---------------------------------------------------------------------------
+// Sub-agent detection
+// ---------------------------------------------------------------------------
+
+const TRELLIS_AGENTS = new Set(["trellis-implement", "trellis-check", "trellis-research"]);
+
+function detectAgentType(): AgentType {
+   const blocked = process.env.PI_BLOCKED_AGENT;
+   if (blocked && TRELLIS_AGENTS.has(blocked)) {
+      return blocked as AgentType;
+   }
+   return null;
+}
+
+// ---------------------------------------------------------------------------
+// Extension entry point
+// ---------------------------------------------------------------------------
+
+export default function(pi: ExtensionAPI): void {
+   let projectRoot: string | null = null;
+   const turnCache = new TurnContextCache();
+   const agentType = detectAgentType();
+   const isSubAgent = agentType !== null;
+
+   // Tracks compaction boundaries — context handler skips scanning when no
+   // compaction has occurred since last injection.
+   let lastCompactionTs = 0;
+   let lastInjectionTs = 0;
+
+   const rememberContextKey = (ctx?: { sessionManager?: { getSessionId?: () => string; getSessionFile?: () => string } }): string | null => {
+      const key = deriveContextKey(ctx);
+      if (!key) return null;
+      return key;
+   };
+
+   pi.on("session_start", async (_event, ctx) => {
+      projectRoot = findProjectRoot(ctx.cwd);
+      const contextKey = rememberContextKey(ctx);
+
+      if (!projectRoot) return;
+
+      if (isSubAgent) {
+         // Sub-agent: inject precise task context once
+         const { taskDir } = resolveActiveTaskStatus(projectRoot, contextKey);
+         if (taskDir) {
+            const taskContext = buildTaskContext(projectRoot, taskDir, agentType);
+            if (taskContext) {
+               await pi.sendMessage({
+                  customType: "trellis-task-context",
+                  content: taskContext,
+                  display: false,
+               });
+            }
+         }
+      } else {
+         // Main session: inject session context (global map) + task context
+         const sessionContext = buildSessionContext(projectRoot, contextKey);
+         if (sessionContext) {
+            await pi.sendMessage({
+               customType: "trellis-session-context",
+               content: sessionContext,
+               display: false,
+            });
+         }
+
+         const { taskDir } = resolveActiveTaskStatus(projectRoot, contextKey);
+         if (taskDir) {
+            const taskContext = buildTaskContext(projectRoot, taskDir);
+            if (taskContext) {
+               await pi.sendMessage({
+                  customType: "trellis-task-context",
+                  content: taskContext,
+                  display: false,
+               });
+            }
+         }
+
+         ctx.ui.notify("Trellis workflow system available", "info");
+      }
+   });
+
+   pi.on("session_before_compact", async () => {
+      lastCompactionTs = Date.now();
+   });
+
+   pi.on("before_agent_start", async (_event, ctx) => {
+      if (!projectRoot) {
+         projectRoot = findProjectRoot(ctx.cwd);
+      }
+      if (!projectRoot) return;
+      const contextKey = rememberContextKey(ctx);
+
+      // Persistent injection: workflow state for this turn
+      const cached = turnCache.get(projectRoot, contextKey);
+      lastInjectionTs = Date.now();
+
+      return {
+         message: {
+            customType: "trellis-workflow-state",
+            content: cached.workflowMsg,
+            display: false,
+         },
+      };
+   });
+
+   // context fires before EVERY LLM API call (including tool-use continuations
+   // and post-compaction agent.continue() paths). Acts as a safety net when
+   // before_agent_start's persisted message was removed by compaction.
+   pi.on("context", async (event, ctx) => {
+      if (!projectRoot) return;
+      const contextKey = rememberContextKey(ctx);
+
+      // Fast path: no compaction since last injection — message is still present
+      if (lastInjectionTs > lastCompactionTs) return;
+
+      const cached = turnCache.get(projectRoot, contextKey);
+      if (!cached.workflowMsg) return;
+
+      // Post-compaction: reverse-scan to confirm absence before injecting
+      const messages = event.messages as { role?: string; customType?: string }[];
+      for (let i = messages.length - 1; i >= 0; i--) {
+         if (messages[i].role === "custom" && messages[i].customType === "trellis-workflow-state") {
+            lastInjectionTs = Date.now();
+            return;
+         }
+      }
+
+      lastInjectionTs = Date.now();
+      return {
+         messages: [
+            ...event.messages,
+            {
+               role: "custom",
+               customType: "trellis-workflow-state",
+               content: cached.workflowMsg,
+               timestamp: Date.now(),
+            },
+         ],
+      };
+   });
+
+   pi.on("input", async (_event, ctx) => {
+      if (!projectRoot) {
+         projectRoot = findProjectRoot(ctx.cwd);
+      }
+      // Resolve projectRoot on first input if session_start missed it
+      if (!projectRoot) return { action: "continue" };
+      const contextKey = rememberContextKey(ctx);
+      // Pre-warm the cache so before_agent_start and context can use it
+      turnCache.get(projectRoot, contextKey);
+      return { action: "continue" };
+   });
+}

package/dist/templates/omp/index.d.ts

@@ -0,0 +1,4 @@
+import type { AgentTemplate } from "../template-utils.js";
+export declare function getAllAgents(): AgentTemplate[];
+export declare function getExtensionTemplate(): string;
+//# sourceMappingURL=index.d.ts.map

package/dist/templates/omp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/templates/omp/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAI1D,wBAAgB,YAAY,IAAI,aAAa,EAAE,CAE9C;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/templates/omp/index.js

@@ -0,0 +1,9 @@
+import { createTemplateReader } from "../template-utils.js";
+const { listMdAgents, readTemplate } = createTemplateReader(import.meta.url);
+export function getAllAgents() {
+    return listMdAgents();
+}
+export function getExtensionTemplate() {
+    return readTemplate("extensions/trellis/index.ts.txt");
+}
+//# sourceMappingURL=index.js.map

package/dist/templates/omp/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/templates/omp/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAG5D,MAAM,EAAE,YAAY,EAAE,YAAY,EAAE,GAAG,oBAAoB,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAE7E,MAAM,UAAU,YAAY;IAC1B,OAAO,YAAY,EAAE,CAAC;AACxB,CAAC;AAED,MAAM,UAAU,oBAAoB;IAClC,OAAO,YAAY,CAAC,iCAAiC,CAAC,CAAC;AACzD,CAAC"}

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

@@ -1422,16 +1422,26 @@ export default function trellisExtension(pi: {
     };
     return turnCache;
   };
-  const startupKeys = new Set<string>();
+  // Provider prefix caches invalidate from byte 0 whenever the system prompt
+  // changes, so everything injected into systemPrompt is memoized per context
+  // key and stays byte-identical for the life of the process. Volatile state
+  // travels through persisted custom messages instead (append-only history).
+  const startupCtxCache = new Map<string, string>();
   const getStartupCtx = (
     k: string | null,
     turn: { ov: string },
   ): string => {
     const key = k ?? "default";
-    if (startupKeys.has(key)) return "";
-    startupKeys.add(key);
-    return buildStartupContext(root, k, turn.ov);
+    let startup = startupCtxCache.get(key);
+    if (startup === undefined) {
+      startup = buildStartupContext(root, k, turn.ov);
+      startupCtxCache.set(key, startup);
+    }
+    return startup;
   };
+  const taskCtxSnapshot = new Map<string, string>();
+  const lastSentTaskCtx = new Map<string, string>();
+  const lastSentRuntimeCtx = new Map<string, string>();
 
   // Toggle only the latest subagent native card; do not use Pi global tool expansion.
   const toggleDetail = (ctx: PiExtensionContext) => {
@@ -1645,29 +1655,45 @@ export default function trellisExtension(pi: {
       return { isError: true };
     return undefined;
   });
-  pi.on?.("input", (event, ctx) => {
-    const k = getKey(event, ctx);
-    const ev = event as { text?: string };
-    if (typeof ev.text !== "string" || !ev.text.trim())
-      return { action: "continue" };
-    const { wf, ov } = getTurnCtx(k);
-    const injection = [wf, ov].filter(Boolean).join("\n\n");
-    if (!injection) return { action: "continue" };
-    return {
-      action: "transform",
-      text: [ev.text, injection].join("\n\n"),
-    };
-  });
   pi.on?.("before_agent_start", (event, ctx) => {
     const k = getKey(event, ctx);
+    const key = k ?? "default";
     const cur = (event as { systemPrompt?: string }).systemPrompt ?? "";
-    const ctxText = buildContext(root, "trellis-implement", k);
     const turn = getTurnCtx(k);
     const startup = getStartupCtx(k, turn);
+    // Task context is snapshotted into systemPrompt once; later on-disk
+    // changes are delivered as persisted messages so the prefix stays stable.
+    const freshTaskCtx = buildContext(root, "trellis-implement", k);
+    let taskCtx = taskCtxSnapshot.get(key);
+    if (taskCtx === undefined) {
+      taskCtx = freshTaskCtx;
+      taskCtxSnapshot.set(key, taskCtx);
+      lastSentTaskCtx.set(key, freshTaskCtx);
+    }
+    const updates: string[] = [];
+    const runtimeContext = [turn.wf, turn.ov].filter(Boolean).join("\n\n");
+    if (runtimeContext && runtimeContext !== lastSentRuntimeCtx.get(key)) {
+      lastSentRuntimeCtx.set(key, runtimeContext);
+      updates.push(runtimeContext);
+    }
+    if (freshTaskCtx !== lastSentTaskCtx.get(key)) {
+      lastSentTaskCtx.set(key, freshTaskCtx);
+      updates.push(
+        "<trellis-task-context-update>\nTask context changed on disk. This supersedes the Trellis Task Context in the system prompt.\n\n" +
+          freshTaskCtx +
+          "\n</trellis-task-context-update>",
+      );
+    }
+    const content = updates.join("\n\n");
     return {
-      systemPrompt: [cur, startup, ctxText, turn.wf, turn.ov]
-        .filter(Boolean)
-        .join("\n\n"),
+      message: content
+        ? {
+            customType: "trellis-runtime-context",
+            content,
+            display: false,
+          }
+        : undefined,
+      systemPrompt: [cur, startup, taskCtx].filter(Boolean).join("\n\n"),
     };
   });
   pi.on?.("context", (event, ctx) => {