@vellumai/assistant 0.8.3 → 0.8.4

package/src/notifications/home-feed-side-effect.ts

@@ -22,11 +22,7 @@ import { getConversation } from "../memory/conversation-crud.js";
 import { isBackgroundConversationType } from "../memory/conversation-types.js";
 import { getLogger } from "../util/logger.js";
 import type { NotificationSignal } from "./signal.js";
-import type {
-  NotificationDecision,
-  NotificationDeliveryResult,
-  RenderedChannelCopy,
-} from "./types.js";
+import type { NotificationDecision, RenderedChannelCopy } from "./types.js";
 
 const log = getLogger("home-feed-side-effect");
 
@@ -41,6 +37,16 @@ const FEED_ITEM_URGENCIES: ReadonlySet<string> = new Set<FeedItemUrgency>([
  * Append a `FeedItem` for the given notification signal when the
  * filter criteria pass.
  *
+ * `fallbackConversationId` is used as the feed item's "Go to Convo"
+ * navigation target when `signal.sourceContextId` doesn't resolve to a
+ * real conversation row. The notification broadcaster pairs the vellum
+ * delivery with a conversation (newly created or reused) before this
+ * function runs, so callers can thread that paired id through here for
+ * producers whose `sourceContextId` is a sentinel (heartbeat startup,
+ * credential health, watcher emits, scheduler retries-exhausted) — the
+ * feed item will then carry the paired delivery conversation and the
+ * "Go to Convo" button can render.
+ *
  * Returns the persisted `FeedItem`, or `null` if the signal does not
  * qualify for home-feed mirroring (non-background origin AND no
  * `isAsyncBackground` hint) or if schema validation fails.
@@ -48,9 +54,13 @@ const FEED_ITEM_URGENCIES: ReadonlySet<string> = new Set<FeedItemUrgency>([
 export async function writeHomeFeedItemForSignal(
   signal: NotificationSignal,
   decision: NotificationDecision,
-  deliveryResults: NotificationDeliveryResult[],
+  fallbackConversationId?: string,
 ): Promise<FeedItem | null> {
-  if (!shouldMirrorToHomeFeed(signal)) return null;
+  const { mirror, sourceConversationId } = resolveHomeFeedMirror(
+    signal,
+    fallbackConversationId,
+  );
+  if (!mirror) return null;
 
   const renderedCopy =
     decision.renderedCopy.vellum ??
@@ -77,9 +87,6 @@ export async function writeHomeFeedItemForSignal(
     return null;
   }
 
-  const conversationId = deliveryResults.find(
-    (r) => r.channel === "vellum",
-  )?.conversationId;
   const urgency = FEED_ITEM_URGENCIES.has(signal.attentionHints.urgency)
     ? (signal.attentionHints.urgency as FeedItemUrgency)
     : undefined;
@@ -107,7 +114,7 @@ export async function writeHomeFeedItemForSignal(
     noteworthy: deriveNoteworthy(signal),
     fromAssistant: signal.sourceChannel === "assistant_tool",
     ...(urgency ? { urgency } : {}),
-    ...(conversationId ? { conversationId } : {}),
+    ...(sourceConversationId ? { conversationId: sourceConversationId } : {}),
     ...(panelKind ? { detailPanel: { kind: panelKind } } : {}),
     ...(metadata ? { metadata } : {}),
   };
@@ -166,28 +173,51 @@ function deriveDetailPanelKind(
 }
 
 /**
- * `sourceContextId` is best-effort — it may not be a conversation id
- * (e.g. scheduler job id, watcher event id), so a lookup failure
- * falls through to "not a background conversation" rather than throwing.
+ * The lookup is best-effort and unified: a single `getConversation` call
+ * both gates the "background conversation" mirror branch and populates
+ * `sourceConversationId` for the "Go to Thread" navigation target. Misses
+ * (scheduler job ids, watcher event ids, CLI tool-call ids) leave
+ * `sourceConversationId` undefined so the client hides the affordance.
  *
- * `assistant_tool` is the source channel used by the `notifications send`
- * skill (and by background-job failure emits). These signals represent
- * the assistant actively choosing to share, so we mirror them into the
- * home feed without requiring a background-typed conversation or the
- * `isAsyncBackground` hint — the documented (SKILL.md) CLI surface
- * intentionally does not expose either; internal call sites that still set
- * the hint keep working unchanged.
+ * `assistant_tool` mirrors unconditionally because the documented
+ * `notifications send` skill (and background-job failure emits) deliberately
+ * does not require a background-typed conversation or the
+ * `isAsyncBackground` hint.
  */
-function shouldMirrorToHomeFeed(signal: NotificationSignal): boolean {
-  if (signal.sourceChannel === "assistant_tool") return true;
-  if (signal.attentionHints.isAsyncBackground) return true;
-  if (!signal.sourceContextId) return false;
-  try {
-    const row = getConversation(signal.sourceContextId);
-    return isBackgroundConversationType(row?.conversationType);
-  } catch {
-    return false;
+function resolveHomeFeedMirror(
+  signal: NotificationSignal,
+  fallbackConversationId?: string,
+): {
+  mirror: boolean;
+  sourceConversationId?: string;
+} {
+  let sourceRow: { conversationType?: string } | null = null;
+  if (signal.sourceContextId) {
+    try {
+      sourceRow = getConversation(signal.sourceContextId) ?? null;
+    } catch {
+      sourceRow = null;
+    }
+  }
+  // Prefer the producer's source context (e.g. the heartbeat / background
+  // job conversation that emitted the signal) for the "Go to Convo" target,
+  // since that's where the work actually happened. Fall back to the paired
+  // delivery conversation only when the source context didn't resolve —
+  // covers producers whose `sourceContextId` is a sentinel string.
+  const sourceConversationId = sourceRow
+    ? signal.sourceContextId
+    : fallbackConversationId;
+
+  if (signal.sourceChannel === "assistant_tool") {
+    return { mirror: true, sourceConversationId };
+  }
+  if (signal.attentionHints.isAsyncBackground) {
+    return { mirror: true, sourceConversationId };
+  }
+  if (isBackgroundConversationType(sourceRow?.conversationType)) {
+    return { mirror: true, sourceConversationId };
   }
+  return { mirror: false };
 }
 
 function readPayloadString(payload: unknown, key: string): string | undefined {

package/src/oauth/connect-orchestrator.ts

@@ -20,6 +20,7 @@
  */
 
 import { emitPostConnectNudge } from "../home/post-connect-feed.js";
+import { invalidateAssistantSuggestedPromptsCache } from "../home/suggested-prompts.js";
 import type { TokenEndpointAuthMethod } from "../security/oauth2.js";
 import { prepareOAuth2Flow, startOAuth2Flow } from "../security/oauth2.js";
 import { getLogger } from "../util/logger.js";
@@ -252,6 +253,7 @@ export async function orchestrateOAuthConnect(
               },
               "Deferred OAuth2 flow completed — tokens stored",
             );
+            invalidateAssistantSuggestedPromptsCache();
             void emitPostConnectNudge(options.service);
             options.onDeferredComplete?.({
               success: true,
@@ -375,6 +377,7 @@ export async function orchestrateOAuthConnect(
       "orchestrateOAuthConnect: tokens stored, connect complete",
     );
 
+    invalidateAssistantSuggestedPromptsCache();
     void emitPostConnectNudge(options.service);
 
     return {

package/src/oauth/credential-token-resolver.ts

@@ -49,6 +49,8 @@ function manualTokenAccessCredentialKey(provider: string): string | null {
       return credentialKey("slack_channel", "bot_token");
     case "telegram":
       return credentialKey("telegram", "bot_token");
+    case "sanity":
+      return credentialKey("sanity", "api_token");
     default:
       return null;
   }

package/src/oauth/manual-token-connection.ts

@@ -122,6 +122,24 @@ export async function syncManualTokenConnection(
       return;
     }
 
+    case "sanity": {
+      const tokenResult = await getSecureKeyResultAsync(
+        credentialKey("sanity", "api_token"),
+      );
+      if (tokenResult.unreachable) {
+        log.warn(
+          "Skipping sanity manual-token reconciliation — credential backend unreachable",
+        );
+        return;
+      }
+      if (tokenResult.value) {
+        await ensureManualTokenConnection(provider, accountInfo);
+      } else {
+        removeManualTokenConnection(provider);
+      }
+      return;
+    }
+
     default:
       return;
   }
@@ -142,4 +160,5 @@ export async function syncManualTokenConnection(
 export async function backfillManualTokenConnections(): Promise<void> {
   await syncManualTokenConnection("telegram");
   await syncManualTokenConnection("slack_channel");
+  await syncManualTokenConnection("sanity");
 }

package/src/oauth/oauth-store.ts

@@ -1100,5 +1100,17 @@ export async function disconnectOAuthProvider(
 
   deleteConnection(conn.id);
 
+  // Dynamic import: `suggested-prompts.ts` imports from this module, so a
+  // static import here would create a cycle. The cache invalidation is
+  // best-effort — failures must not block disconnect.
+  void import("../home/suggested-prompts.js")
+    .then((m) => m.invalidateAssistantSuggestedPromptsCache())
+    .catch((err) => {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err) },
+        "Failed to invalidate suggested-prompts cache after disconnect",
+      );
+    });
+
   return "disconnected";
 }

package/src/oauth/seed-providers.ts

@@ -746,6 +746,28 @@ export const PROVIDER_SEED_DATA: Record<
     logoUrl: "https://cdn.simpleicons.org/telegram",
     defaultScopes: [],
   },
+
+  sanity: {
+    provider: "sanity",
+    authorizeUrl: "urn:manual-token",
+    tokenExchangeUrl: "urn:manual-token",
+    baseUrl: "https://api.sanity.io",
+    displayLabel: "Sanity",
+    description: "Content management platform",
+    dashboardUrl: "https://www.sanity.io/manage",
+    clientIdPlaceholder: null,
+    requiresClientSecret: false,
+    logoUrl: "https://cdn.simpleicons.org/sanity",
+    defaultScopes: [],
+    injectionTemplates: [
+      {
+        hostPattern: "*.sanity.io",
+        injectionType: "header",
+        headerName: "Authorization",
+        valuePrefix: "Bearer ",
+      },
+    ],
+  },
 };
 
 export const SEEDED_PROVIDER_KEYS = new Set(Object.keys(PROVIDER_SEED_DATA));

package/src/permissions/prompter.ts

@@ -196,7 +196,10 @@ export class PermissionPrompter {
     }
     // The prompter owns deregistration; all callers use get() to peek before
     // routing to resolveConfirmation, which fires the rpcResolve callback.
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(
+      requestId,
+      decision === "allow" ? "approved" : "rejected",
+    );
     this.ownedIds.delete(requestId);
     (interaction?.rpcResolve as ((v: ConfirmResult) => void) | undefined)?.(
       { decision, selectedPattern, selectedScope, decisionContext },
@@ -210,7 +213,7 @@ export class PermissionPrompter {
    */
   denyAllPending(): void {
     for (const requestId of [...this.ownedIds]) {
-      const interaction = pendingInteractions.resolve(requestId);
+      const interaction = pendingInteractions.resolve(requestId, "superseded");
       this.ownedIds.delete(requestId);
       (interaction?.rpcResolve as ((v: ConfirmResult) => void) | undefined)?.(
         {

package/src/permissions/secret-prompter.ts

@@ -130,7 +130,10 @@ export class SecretPrompter {
     }
     // approval-routes calls pendingInteractions.get() before routing here;
     // the prompter owns deregistration so it fires the Promise callback cleanly.
-    const interaction = pendingInteractions.resolve(requestId);
+    const interaction = pendingInteractions.resolve(
+      requestId,
+      value === undefined ? "cancelled" : "answered",
+    );
     this.ownedIds.delete(requestId);
     (interaction?.rpcResolve as ((v: SecretPromptResult) => void) | undefined)?.(
       { value: value ?? null, delivery: delivery ?? "store" },

package/src/plugins/defaults/injectors.ts

@@ -20,6 +20,7 @@
  * | `memory-v2-static`       | 38    | after-memory-prefix     |
  * | `now-md`                 | 40    | after-memory-prefix     |
  * | `active-documents`       | 45    | prepend-user-tail       |
+ * | `document-comments`      | 46    | prepend-user-tail       |
  * | `subagent-status`        | 50    | append-user-tail        |
  * | `slack-messages`         | 60    | replace-run-messages    |
  * | `thread-focus`           | 70    | append-user-tail        |
@@ -51,6 +52,7 @@ import { isAssistantFeatureFlagEnabled } from "../../config/assistant-feature-fl
 import { getConfig } from "../../config/loader.js";
 import { getInContextPkbPaths } from "../../daemon/pkb-context-tracker.js";
 import { buildPkbReminder } from "../../daemon/pkb-reminder-builder.js";
+import { listComments } from "../../documents/document-comments-store.js";
 import { searchPkbFiles } from "../../memory/pkb/pkb-search.js";
 import { getLogger } from "../../util/logger.js";
 import { registerPlugin } from "../registry.js";
@@ -94,6 +96,7 @@ export const DEFAULT_INJECTOR_ORDER = {
   memoryV2Static: 38,
   nowMd: 40,
   activeDocuments: 45,
+  documentComments: 46,
   subagentStatus: 50,
   slackMessages: 60,
   threadFocus: 70,
@@ -133,12 +136,11 @@ const diskPressureWarningInjector: Injector = {
 };
 
 /**
- * v2 read-side cutover guard. The `pkb-context` injector silences itself
- * under v2 because the `<knowledge_base>` block surfaces PKB content the v2
- * activation block already covers. The `pkb-reminder` injector still fires
- * (its body is generic recall/remember guidance) but skips the hybrid-search
- * hints — those name PKB paths v2 is moving away from. NOW.md is workspace
- * state independent of PKB and fires unchanged.
+ * v2 read-side cutover guard. Under v2 both `pkb-context` and `pkb-reminder`
+ * silence themselves entirely — the `<knowledge_base>` content and the
+ * generic recall/remember nudge are both supplanted by the v2 static
+ * `<memory>` block. NOW.md is workspace state independent of PKB and fires
+ * unchanged.
  */
 function isPkbInjectionSilencedByV2(): boolean {
   return getConfig().memory.v2.enabled;
@@ -287,9 +289,8 @@ const pkbReminderInjector: Injector = {
     const mode = inputs.mode ?? "full";
     if (mode !== "full") return null;
     if (!inputs.pkbActive) return null;
-    const reminder = isPkbInjectionSilencedByV2()
-      ? buildPkbReminder([])
-      : await buildPkbReminderWithHints(inputs);
+    if (isPkbInjectionSilencedByV2()) return null;
+    const reminder = await buildPkbReminderWithHints(inputs);
     return {
       id: "pkb-reminder",
       text: reminder,
@@ -491,6 +492,77 @@ const activeDocumentsInjector: Injector = {
   },
 };
 
+/** Maximum open comments surfaced per document to limit context bloat. */
+const DOCUMENT_COMMENTS_CAP = 10;
+
+/**
+ * Escape closing `</document_comments>` inside user-controlled strings so
+ * they cannot break out of the XML wrapper — same pattern as
+ * {@link buildPkbContextBlock} and {@link buildMemoryV2StaticBlock}.
+ */
+function escapeDocCommentTag(s: string): string {
+  return s.replace(/<\/document_comments\s*>/gi, "&lt;/document_comments&gt;");
+}
+
+/**
+ * `document-comments` injector — order 46, prepend-user-tail.
+ *
+ * Surfaces open top-level comments on active documents so the assistant
+ * knows what feedback to address. For each active document, queries the
+ * comment store for open top-level comments (capped at
+ * {@link DOCUMENT_COMMENTS_CAP} most recent per document). Inline comments
+ * include the quoted anchor text; doc-level comments are labelled as such.
+ *
+ * Gating:
+ *  - `mode === "full"`.
+ *  - `activeDocuments` has at least one entry.
+ *  - At least one document has open comments (returns null otherwise).
+ */
+const documentCommentsInjector: Injector = {
+  name: "document-comments",
+  order: DEFAULT_INJECTOR_ORDER.documentComments,
+  async produce(ctx: TurnContext): Promise<InjectionBlock | null> {
+    const inputs = readInjectionInputs(ctx);
+    const mode = inputs.mode ?? "full";
+    if (mode !== "full") return null;
+    const docs = inputs.activeDocuments;
+    if (!docs || docs.length === 0) return null;
+
+    const sections: string[] = [];
+    for (const doc of docs) {
+      const comments = listComments(doc.surfaceId, {
+        status: "open",
+        topLevelOnly: true,
+      }).slice(-DOCUMENT_COMMENTS_CAP);
+      if (comments.length === 0) continue;
+
+      const lines = comments.map((c) => {
+        const anchor =
+          c.anchorText != null ? escapeDocCommentTag(c.anchorText) : null;
+        const label =
+          anchor != null ? `inline, anchored to "${anchor}"` : "doc-level";
+        return `- Comment #${c.id} (${label}): "${escapeDocCommentTag(c.content)}"`;
+      });
+      sections.push(
+        `Document: "${escapeDocCommentTag(doc.title)}" (surface_id: "${doc.surfaceId}")\n${lines.join("\n")}`,
+      );
+    }
+
+    if (sections.length === 0) return null;
+
+    const text = `<document_comments>
+Open comments on your documents. Address these by editing the document, then use comment_resolve to mark each resolved.
+
+${sections.join("\n\n")}
+</document_comments>`;
+    return {
+      id: "document-comments",
+      text,
+      placement: "prepend-user-tail",
+    };
+  },
+};
+
 /**
  * `subagent-status` injector — order 50, append-user-tail.
  *
@@ -626,6 +698,7 @@ export const defaultInjectorsPlugin: Plugin = {
     memoryV2StaticInjector,
     nowMdInjector,
     activeDocumentsInjector,
+    documentCommentsInjector,
     subagentStatusInjector,
     slackMessagesInjector,
     threadFocusInjector,

package/src/prompts/__tests__/system-prompt.test.ts

@@ -6,7 +6,8 @@
  * user-message injection that replaced it.
  */
 
-import { mkdirSync } from "node:fs";
+import { copyFileSync, mkdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 const TEST_DIR = process.env.VELLUM_WORKSPACE_DIR!;
@@ -57,7 +58,8 @@ mock.module("../../config/loader.js", () => ({
   setNestedValue: () => {},
 }));
 
-const { buildSystemPrompt } = await import("../system-prompt.js");
+const { buildSystemPrompt, maybeReseedBootstrapForCohort } =
+  await import("../system-prompt.js");
 
 describe("buildSystemPrompt — tool routing guidance", () => {
   beforeEach(() => {
@@ -70,3 +72,45 @@ describe("buildSystemPrompt — tool routing guidance", () => {
     expect(result).not.toContain("ask_question");
   });
 });
+
+describe("maybeReseedBootstrapForCohort — content-automation template", () => {
+  const templatesDir = join(import.meta.dirname!, "..", "templates");
+
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+    // Seed the workspace with the generic BOOTSTRAP.md so the cohort
+    // reseed detects it as an unmodified template and overwrites it.
+    copyFileSync(
+      join(templatesDir, "BOOTSTRAP.md"),
+      join(TEST_DIR, "BOOTSTRAP.md"),
+    );
+  });
+
+  function reseedAndRead(): string {
+    maybeReseedBootstrapForCohort("content-automation");
+    return readFileSync(join(TEST_DIR, "BOOTSTRAP.md"), "utf-8");
+  }
+
+  test("loads the geo-writing skill on first turn", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("geo-writing");
+  });
+
+  test("uses skill-first onboarding approach", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("Skill-First Onboarding");
+    expect(content).toContain("The skill is the onboarding");
+  });
+
+  test("includes comment-driven edit loop", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("comment-driven");
+    expect(content).toContain("comment_resolve");
+    expect(content).toContain("document_update");
+  });
+
+  test("references VOICE.md for voice capture", () => {
+    const content = reseedAndRead();
+    expect(content).toContain("VOICE.md");
+  });
+});

package/src/prompts/normalize-onboarding.ts

@@ -19,6 +19,20 @@ export const TOOL_DISPLAY_NAMES: Record<string, string> = {
   "apple-notes": "Apple Notes",
 };
 
+/**
+ * Map of known prior-assistant IDs (from the client onboarding UI) to display names.
+ * Unknown IDs pass through with first-letter capitalization via `normalizePriorAssistants`.
+ */
+export const PRIOR_ASSISTANT_DISPLAY_NAMES: Record<string, string> = {
+  chatgpt: "ChatGPT",
+  claude: "Claude",
+  openclaw: "OpenClaw",
+  hermes: "Hermes",
+  manus: "Manus",
+  gemini: "Gemini",
+  copilot: "Copilot",
+};
+
 /**
  * Map of known task IDs to plain-language labels describing what the assistant
  * does for each task category.
@@ -56,14 +70,28 @@ export function normalizeTasks(tasks: string[]): string[] {
   return tasks.map((id) => TASK_DISPLAY_LABELS[id] ?? id);
 }
 
+/**
+ * Maps each prior-assistant ID through `PRIOR_ASSISTANT_DISPLAY_NAMES`,
+ * falling back to first-letter capitalization for unknown IDs.
+ */
+export function normalizePriorAssistants(assistants: string[]): string[] {
+  return assistants.map(
+    (id) => PRIOR_ASSISTANT_DISPLAY_NAMES[id] ?? capitalizeFirst(id),
+  );
+}
+
 export interface NormalizedOnboarding {
   preferredName?: string;
   commonWork: string[];
   dailyTools: string[];
   tone?: string;
   assistantName?: string;
+  priorAssistants?: string[];
   googleConnected?: boolean;
   googleServices?: string[];
+  cohort?: string;
+  websiteUrl?: string;
+  contentSourceUrl?: string;
 }
 
 const SCOPE_SERVICE_MAP: Record<string, string> = {
@@ -103,5 +131,17 @@ export function normalizeOnboardingContext(
     googleServices: ctx.googleConnected
       ? deriveGoogleServices(ctx.googleScopes)
       : undefined,
+    priorAssistants: ctx.priorAssistants?.length
+      ? normalizePriorAssistants(ctx.priorAssistants)
+      : undefined,
+    cohort: ctx.cohort,
+    websiteUrl:
+      typeof ctx.websiteUrl === "string"
+        ? ctx.websiteUrl.trim().replace(/[\r\n\t]/g, "") || undefined
+        : undefined,
+    contentSourceUrl:
+      typeof ctx.contentSourceUrl === "string"
+        ? ctx.contentSourceUrl.trim().replace(/[\r\n\t]/g, "") || undefined
+        : undefined,
   };
 }

package/src/prompts/sections.ts

@@ -93,7 +93,10 @@ function collectSectionIds(workspaceDir: string): string[] {
         if (name.endsWith(".md")) ids.add(name.slice(0, -".md".length));
       }
     } catch (err) {
-      log.warn({ err, workspaceDir }, "Failed to list workspace system prompt dir");
+      log.warn(
+        { err, workspaceDir },
+        "Failed to list workspace system prompt dir",
+      );
     }
   }
   return [...ids].sort();
@@ -102,6 +105,7 @@ function collectSectionIds(workspaceDir: string): string[] {
 interface ResolvedSection {
   enabled: string | boolean | undefined;
   body: string;
+  transform?: BundledSection["transform"];
 }
 
 function resolveSection(
@@ -114,12 +118,20 @@ function resolveSection(
     try {
       raw = readFileSync(workspacePath, "utf-8");
     } catch (err) {
-      log.warn({ err, workspacePath }, "Failed to read workspace section override");
+      log.warn(
+        { err, workspacePath },
+        "Failed to read workspace section override",
+      );
       return null;
     }
     const parsed = parseFrontmatterFields(raw);
     const fields = parsed?.fields ?? {};
     const body = parsed?.body ?? raw;
+    // Workspace override skips the bundled transform: when the user has
+    // written their own `prompts/system/<id>.md` they've taken full
+    // control of the body shape, and re-running the bundled transform
+    // (e.g. unmodified-template detection on IDENTITY.md) would
+    // misclassify their override.
     return { enabled: fields["enabled"] as string | boolean | undefined, body };
   }
   const bundled = BUNDLED_SYSTEM_SECTIONS.find((s) => s.id === id);
@@ -128,7 +140,8 @@ function resolveSection(
   // A bundled section may delegate its body to a workspace file outside
   // the section override directory (e.g. `SOUL.md` at the workspace
   // root).  Read it now; missing/empty files yield "", which
-  // `renderSection` then gates off via its empty-body check.
+  // `renderSection` then gates off via its empty-body check (or via the
+  // section's `transform`, if set).
   if (bundled.workspacePath) {
     const filePath = getWorkspacePromptPath(bundled.workspacePath);
     let body = "";
@@ -136,16 +149,17 @@ function resolveSection(
       try {
         body = readFileSync(filePath, "utf-8");
       } catch (err) {
-        log.warn(
-          { err, filePath, id },
-          "Failed to read section workspacePath",
-        );
+        log.warn({ err, filePath, id }, "Failed to read section workspacePath");
       }
     }
-    return { enabled: bundled.enabled, body };
+    return { enabled: bundled.enabled, body, transform: bundled.transform };
   }
 
-  return { enabled: bundled.enabled, body: bundled.body };
+  return {
+    enabled: bundled.enabled,
+    body: bundled.body,
+    transform: bundled.transform,
+  };
 }
 
 function renderSection(
@@ -158,7 +172,14 @@ function renderSection(
 
   if (!isEnabled(section.enabled, ctx)) return null;
 
-  const stripped = stripCommentLines(section.body).trim();
+  let body = section.body;
+  if (section.transform) {
+    const transformed = section.transform(body, ctx);
+    if (transformed === null) return null;
+    body = transformed;
+  }
+
+  const stripped = stripCommentLines(body).trim();
   if (stripped.length === 0) return null;
   return interpolateVariables(stripped, ctx);
 }
@@ -190,10 +211,7 @@ const IDENT_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
  * typo on a `{{key}}` substitution surfaces at the warn log rather than
  * inlining the string `"undefined"`).
  */
-function interpolateVariables(
-  body: string,
-  ctx: SectionRenderContext,
-): string {
+function interpolateVariables(body: string, ctx: SectionRenderContext): string {
   // Collapse standalone tag lines so multiline section templates render
   // without phantom blank lines from the layout markers.
   const collapsed = body.replace(STANDALONE_TAG_LINE, "$1");