@vellumai/assistant 0.6.3 → 0.6.4

package/src/platform/sync-identity.ts

@@ -0,0 +1,129 @@
+/**
+ * Sync assistant identity fields to the platform Assistant record.
+ *
+ * When IDENTITY.md changes on disk the daemon broadcasts an
+ * `identity_changed` event to connected clients.  This module hooks into
+ * that same change signal and PATCHes the platform `Assistant` record so
+ * the name (and, in future, other fields) stays in sync.
+ *
+ * Requests are serialized so that rapid name changes (A → B) never race:
+ * only the most recently requested name is sent, and a stale in-flight
+ * response cannot overwrite a newer value.
+ *
+ * The sync is best-effort and fire-and-forget — network failures are
+ * logged but never surface to callers.
+ */
+
+import { getLogger } from "../util/logger.js";
+import { VellumPlatformClient } from "./client.js";
+
+const log = getLogger("sync-identity");
+
+/** Track the last successfully synced name (used inside doSync to skip redundant PATCHes). */
+let lastSyncedName: string | null = null;
+
+/** Track the last requested name (used for dedup at enqueue time). */
+let lastRequestedName: string | null = null;
+
+/**
+ * Monotonically increasing sequence number.  Each call to
+ * `syncIdentityNameToPlatform` bumps this; after a PATCH completes we
+ * only update `lastSyncedName` when `seq` still matches, guaranteeing
+ * the newest name always wins.
+ */
+let seq = 0;
+
+/** Chain promise that serializes in-flight PATCH requests. */
+let pending: Promise<void> = Promise.resolve();
+
+/**
+ * Push the current assistant name to the platform `Assistant` record.
+ *
+ * No-op when:
+ * - The platform client cannot be created (not platform-hosted / missing creds).
+ * - No assistant ID is configured.
+ * - The name is empty or unchanged since the last request.
+ */
+export function syncIdentityNameToPlatform(name: string): void {
+  if (!name || name === lastRequestedName) return;
+
+  lastRequestedName = name;
+
+  const mySeq = ++seq;
+
+  pending = pending
+    .then(() => doSync(name, mySeq))
+    .catch(() => {
+      // swallowed — doSync already logs internally
+    });
+}
+
+async function doSync(name: string, requestSeq: number): Promise<void> {
+  try {
+    // A newer call has already been enqueued — skip this stale request.
+    if (requestSeq !== seq) return;
+
+    // Re-check after awaiting the previous request in the chain.
+    if (name === lastSyncedName) return;
+
+    const client = await VellumPlatformClient.create();
+    if (!client) {
+      clearRequestedIfLatest(requestSeq);
+      return;
+    }
+
+    const assistantId = client.platformAssistantId;
+    if (!assistantId) {
+      clearRequestedIfLatest(requestSeq);
+      return;
+    }
+
+    const resp = await client.fetch(
+      `/v1/assistants/${encodeURIComponent(assistantId)}/`,
+      {
+        method: "PATCH",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+        signal: AbortSignal.timeout(15_000),
+      },
+    );
+
+    if (resp.ok) {
+      // Only update cache if no newer request has been enqueued since we
+      // started this PATCH — prevents a slow response from overwriting a
+      // fresher value.
+      if (requestSeq === seq) {
+        lastSyncedName = name;
+      }
+      log.info({ name, assistantId }, "Synced assistant name to platform");
+    } else {
+      clearRequestedIfLatest(requestSeq);
+      const text = await resp.text();
+      log.warn(
+        { status: resp.status, body: text, assistantId },
+        "Failed to sync assistant name to platform",
+      );
+    }
+  } catch (err) {
+    clearRequestedIfLatest(requestSeq);
+    log.warn({ err }, "Error syncing assistant name to platform");
+  }
+}
+
+/**
+ * Reset `lastRequestedName` when the latest request failed, so that the
+ * next call with the same name is allowed through instead of being deduped.
+ */
+function clearRequestedIfLatest(requestSeq: number): void {
+  if (requestSeq === seq) {
+    lastRequestedName = lastSyncedName;
+  }
+}
+
+/** Reset cached state (for testing). */
+export function _resetSyncState(): void {
+  lastSyncedName = null;
+  lastRequestedName = null;
+  seq = 0;
+  pending = Promise.resolve();
+}

package/src/prompts/persona-resolver.ts

@@ -1,5 +1,10 @@
-import { existsSync, readFileSync } from "node:fs";
-import { basename, join } from "node:path";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+} from "node:fs";
+import { basename, dirname, join } from "node:path";
 
 import {
   findContactByChannelExternalId,
@@ -16,6 +21,28 @@ import { stripCommentLines } from "../util/strip-comment-lines.js";
 
 const log = getLogger("persona-resolver");
 
+// ── Guardian persona template ─────────────────────────────────────
+//
+// Scaffold written to `users/<slug>.md` when a guardian is resolved
+// but no per-user persona file yet exists. Kept in sync with the
+// legacy workspace USER.md template so that upgrading users preserve
+// the same editable shape. Exported so consumers can detect the
+// unmodified scaffold (e.g. heartbeat's `isShallowProfile`).
+export const GUARDIAN_PERSONA_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the system prompt
+
+# User Profile
+
+Store details about your user here. Edit freely - build this over time as you learn about them. Don't be pushy about seeking details, but when you learn something, write it down. More context makes you more useful.
+
+- Preferred name/reference:
+- Pronouns:
+- Locale:
+- Work role:
+- Goals:
+- Hobbies/fun:
+- Daily tools:
+`;
+
 // ── Types ──────────────────────────────────────────────────────────
 
 export interface PersonaContext {
@@ -98,6 +125,22 @@ function resolveUserFilename(
   return null;
 }
 
+/**
+ * Resolve the absolute on-disk path to the guardian's per-user persona
+ * file (e.g. `<workspace>/users/sidd.md`). Returns `null` when no
+ * guardian is resolvable (no guardian contact, or its `userFile` is
+ * unusable / fails basename validation).
+ *
+ * This does not check whether the file exists — it only resolves the
+ * path. Callers use it alongside `ensureGuardianPersonaFile` to open
+ * or scaffold the file.
+ */
+export function resolveGuardianPersonaPath(): string | null {
+  const filename = resolveUserFilename(undefined);
+  if (!filename) return null;
+  return join(getWorkspaceDir(), "users", filename);
+}
+
 /**
  * Resolve a short slug identifying the current user, derived from
  * their contact's userFile. Used to scope per-user workspace directories
@@ -192,3 +235,84 @@ export function resolvePersonaContext(
 export function resolveGuardianPersona(): string | null {
   return resolveUserPersona(undefined);
 }
+
+/**
+ * Resolve the guardian's user persona strictly from their own
+ * `users/<slug>.md` file, with NO fallback to `users/default.md`.
+ *
+ * Returns `null` when no guardian contact is resolvable, the
+ * guardian's userFile is unset, or the file is missing / empty.
+ *
+ * Used by callers that derive guardian-specific attributes (name,
+ * pronouns) where `default.md` content would incorrectly override an
+ * intentional caller-supplied fallback such as `Contact.displayName`.
+ * System-prompt callers that want the default.md fallback should
+ * continue to use `resolveGuardianPersona`.
+ */
+export function resolveGuardianPersonaStrict(): string | null {
+  const filename = resolveUserFilename(undefined);
+  if (!filename) return null;
+  const filePath = join(getWorkspaceDir(), "users", filename);
+  if (!existsSync(filePath)) return null;
+  return readPersonaFile(filePath);
+}
+
+/**
+ * Write the guardian persona template scaffold to `users/<userFile>`
+ * when the file does not yet exist. No-op when the file already
+ * exists (safe against clobbering user edits).
+ *
+ * @param userFile - A filename (not a bare slug), matching the shape
+ *   of `Contact.userFile` — a basename with a `.md` suffix
+ *   (e.g. `"sidd.md"`). The path traversal guard rejects values that
+ *   are not a clean basename.
+ *
+ * Creates the parent `users/` directory if missing.
+ */
+export function ensureGuardianPersonaFile(userFile: string): void {
+  if (basename(userFile) !== userFile || userFile === ".." || userFile === ".") {
+    log.warn(
+      { userFile },
+      "Guardian persona userFile contains path traversal; refusing to write",
+    );
+    return;
+  }
+
+  const filePath = join(getWorkspaceDir(), "users", userFile);
+  if (existsSync(filePath)) return;
+
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, GUARDIAN_PERSONA_TEMPLATE, "utf-8");
+  log.debug({ path: filePath }, "Wrote guardian persona scaffold");
+}
+
+/**
+ * Return `true` when the persona file at `filePath` has been edited by
+ * the user (its stripped content differs from the bare scaffold
+ * template). Returns `false` when the file is missing, unreadable,
+ * empty after stripping, or byte-identical to the template after
+ * stripping comment lines.
+ *
+ * Used by the vbundle importer to decide whether a legacy
+ * `prompts/USER.md` entry may safely overwrite `users/<slug>.md`.
+ */
+export function isGuardianPersonaCustomized(filePath: string): boolean {
+  if (!existsSync(filePath)) return false;
+
+  let content: string;
+  try {
+    content = readFileSync(filePath, "utf-8");
+  } catch (err) {
+    log.warn(
+      { err, path: filePath },
+      "Failed to read persona file while checking customization",
+    );
+    return false;
+  }
+
+  const stripped = stripCommentLines(content);
+  if (stripped.length === 0) return false;
+
+  const templateStripped = stripCommentLines(GUARDIAN_PERSONA_TEMPLATE);
+  return stripped !== templateStripped;
+}

package/src/prompts/system-prompt.ts

@@ -11,6 +11,7 @@ import { join } from "node:path";
 import { getIsContainerized } from "../config/env-registry.js";
 import { loadConfig } from "../config/loader.js";
 import { listConnections } from "../oauth/oauth-store.js";
+import type { OnboardingContext } from "../types/onboarding-context.js";
 import { resolveBundledDir } from "../util/bundled-asset.js";
 import { getLogger } from "../util/logger.js";
 import {
@@ -25,7 +26,27 @@ export { SYSTEM_PROMPT_CACHE_BOUNDARY };
 
 const log = getLogger("system-prompt");
 
-const PROMPT_FILES = ["SOUL.md", "IDENTITY.md", "USER.md"] as const;
+const PROMPT_FILES = ["SOUL.md", "IDENTITY.md"] as const;
+
+function hasPopulatedUsersDir(): boolean {
+  try {
+    const usersDir = join(getWorkspaceDir(), "users");
+    if (!existsSync(usersDir)) return false;
+    return readdirSync(usersDir).length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function hasExistingConversations(): boolean {
+  try {
+    const convDir = getConversationsDir();
+    if (!existsSync(convDir)) return false;
+    return readdirSync(convDir).length > 0;
+  } catch {
+    return false;
+  }
+}
 
 /**
  * Copy template prompt files into the data directory if they don't already exist.
@@ -43,10 +64,16 @@ export function ensurePromptFiles(): void {
     "templates",
   );
 
-  // Track whether this is a fresh workspace (no core prompt files exist yet).
-  const isFirstRun = PROMPT_FILES.every(
-    (file) => !existsSync(getWorkspacePromptPath(file)),
-  );
+  // Track whether this is a fresh workspace.  A workspace counts as fresh
+  // only when none of these signals are present: core prompt files, a
+  // populated `users/` directory, or existing conversations.  Upgraded
+  // workspaces that dropped USER.md but still carry personas or history
+  // would otherwise be mistaken for fresh installs and re-trigger
+  // onboarding.
+  const isFirstRun =
+    PROMPT_FILES.every((file) => !existsSync(getWorkspacePromptPath(file))) &&
+    !hasPopulatedUsersDir() &&
+    !hasExistingConversations();
 
   for (const file of PROMPT_FILES) {
     const dest = getWorkspacePromptPath(file);
@@ -190,7 +217,7 @@ export function ensurePromptFiles(): void {
  *
  * Composition:
  *   1. Base prompt: IDENTITY.md + SOUL.md (guaranteed to exist after ensurePromptFiles)
- *   2. Append USER.md (user profile)
+ *   2. Append the resolved user persona from users/<slug>.md (via options.userPersona)
  *   3. If BOOTSTRAP.md exists, append first-run ritual instructions
  */
 export interface BuildSystemPromptOptions {
@@ -199,6 +226,7 @@ export interface BuildSystemPromptOptions {
   userPersona?: string | null;
   channelPersona?: string | null;
   userSlug?: string | null;
+  onboardingContext?: OnboardingContext;
 }
 
 /**
@@ -215,7 +243,7 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   // ── Static instruction sections (stable across turns) ──
   // These sections are deterministic within a process lifetime.  They form
   // the first cache block so they remain cached even when workspace files
-  // (IDENTITY.md, SOUL.md, USER.md, etc.) are edited between turns.
+  // (IDENTITY.md, SOUL.md, users/<slug>.md, etc.) are edited between turns.
   const staticParts: string[] = [];
   const customPrefix = readCustomSystemPromptPrefix();
   if (customPrefix) staticParts.push(customPrefix);
@@ -242,13 +270,11 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
 
   const soulPath = getWorkspacePromptPath("SOUL.md");
   const identityPath = getWorkspacePromptPath("IDENTITY.md");
-  const userPath = getWorkspacePromptPath("USER.md");
   const bootstrapPath = getWorkspacePromptPath("BOOTSTRAP.md");
   const updatesPath = getWorkspacePromptPath("UPDATES.md");
 
   const soul = readPromptFile(soulPath);
   const identity = readPromptFile(identityPath);
-  const user = readPromptFile(userPath);
   const bootstrap = readPromptFile(bootstrapPath);
   const updates = readPromptFile(updatesPath);
 
@@ -262,7 +288,6 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   // source and skip them — SOUL.md provides sufficient personality defaults
   // until onboarding completes.
   const identityIsTemplate = isTemplateContent(identity, "IDENTITY.md");
-  const userIsTemplate = isTemplateContent(user, "USER.md");
 
   if (identity && !identityIsTemplate) {
     // Strip placeholder lines (e.g. "- **Name:** _(not yet chosen)_") so
@@ -278,13 +303,28 @@ export function buildSystemPrompt(options?: BuildSystemPromptOptions): string {
   if (soul) dynamicParts.push(soul);
   if (options?.userPersona) dynamicParts.push(options.userPersona);
   if (options?.channelPersona) dynamicParts.push(options.channelPersona);
-  if (user && !userIsTemplate && !options?.userPersona) dynamicParts.push(user);
   if (includeBootstrap) {
+    const userSlug = options?.userSlug ?? "default";
+    const bootstrapWithSlug = bootstrap.replaceAll(
+      "{{USER_PERSONA_FILE}}",
+      `${userSlug}.md`,
+    );
     dynamicParts.push(
       "# First-Run Ritual\n\n" +
         "BOOTSTRAP.md is present — this is your first conversation. Follow its instructions.\n\n" +
-        bootstrap,
+        bootstrapWithSlug,
     );
+
+    if (options?.onboardingContext) {
+      dynamicParts.push(
+        "## Pre-chat Onboarding Context\n\n" +
+          "The user completed the native pre-chat onboarding. Here is their context:\n\n" +
+          "```json\n" +
+          JSON.stringify(options.onboardingContext, null, 2) +
+          "\n```\n\n" +
+          "Use this to personalize your opener and skip redundant discovery.",
+      );
+    }
   }
   if (updates) {
     dynamicParts.push(
@@ -423,9 +463,11 @@ function buildContainerizedSection(): string {
 function buildParallelToolCallsSection(): string {
   return [
     "<use_parallel_tool_calls>",
-    "For maximum efficiency, whenever you perform multiple independent operations, invoke all relevant tools simultaneously rather than sequentially. Prioritize calling tools in parallel whenever possible. For example, when reading 3 files, run 3 tool calls in parallel to read all 3 files into context at the same time. When running multiple read-only commands like `ls` or `list_dir`, always run all of the commands in parallel. Err on the side of maximizing parallel tool calls rather than running too many tools sequentially.",
+    "Batch independent tool calls into the same response. An extra LLM round trip costs orders of magnitude more than a few wasted tool calls — err on the side of parallelizing when calls are independent. Reading multiple files, `glob`/`grep`, `ls`, `git status`/`diff`/`log`, type-checks, and tests should be batched.",
+    "",
+    "Before emitting a single tool call, ask whether your next turn would be another tool call that doesn't consume this one's output — if so, they belong together. Serialized tool calls without a real data dependency are a bug.",
     "",
-    "For non-trivial independent workstreams — research, coding tasks, multi-step investigations — aggressively delegate to subagents (load the `subagent` skill for tools and instructions). Spawn subagents early and often; the cost of an unnecessary subagent is far lower than the cost of serializing work you could have parallelized.",
+    "For non-trivial independent workstreams — research, coding, multi-step investigations — delegate to subagents (load the `subagent` skill) and spawn them early and in parallel; an unnecessary subagent is cheaper than serialized work.",
     "</use_parallel_tool_calls>",
   ].join("\n");
 }
@@ -490,7 +532,7 @@ function readPromptFile(path: string): string | null {
 }
 
 /**
- * Reads the core identity/personality prompt files (SOUL.md, IDENTITY.md, USER.md)
+ * Reads the core identity/personality prompt files (SOUL.md, IDENTITY.md)
  * and concatenates whichever exist. Returns null if none are present.
  *
  * This is useful for injecting identity context into subsystems (e.g. memory
@@ -504,10 +546,9 @@ export function buildCoreIdentityContext(opts?: {
     const content = readPromptFile(getWorkspacePromptPath(file));
     if (!content) continue;
     // SOUL.md is always included — it provides personality defaults even
-    // before onboarding completes.  Only skip IDENTITY.md and USER.md when
-    // they are still unmodified templates (matching buildSystemPrompt).
+    // before onboarding completes.  Only skip IDENTITY.md when it is still
+    // an unmodified template (matching buildSystemPrompt).
     if (file !== "SOUL.md" && isTemplateContent(content, file)) continue;
-    if (file === "USER.md" && opts?.userPersona) continue;
     parts.push(content);
   }
   if (opts?.userPersona) parts.push(opts.userPersona);

package/src/prompts/templates/BOOTSTRAP.md

@@ -16,7 +16,7 @@ This is your first conversation. This document gives you goals and constraints
 
 5. **Offer the next level** — once you know something, offer a capability it enables. Not as a reward — as a natural relationship step.
 
-6. **Write everything immediately** — every fact learned gets saved to USER.md the same turn. Style observations go to SOUL.md. No batching.
+6. **Write everything immediately** — every fact learned gets saved to users/{{USER_PERSONA_FILE}} the same turn. Style observations go to SOUL.md. No batching.
 
 7. **Clean up** — delete BOOTSTRAP.md and BOOTSTRAP-REFERENCE.md at the end of this conversation, regardless of how far you got. One-shot.
 
@@ -37,15 +37,15 @@ This is your first conversation. This document gives you goals and constraints
 
 ## Technical Contract (what must be prescribed)
 
-**Files to create/update:** IDENTITY.md, SOUL.md, USER.md
+**Files to create/update:** IDENTITY.md, SOUL.md, users/{{USER_PERSONA_FILE}}
 
 **File format:** preserve existing field structure:
 - IDENTITY.md: Name, Emoji, Nature, Personality, Role
-- USER.md: Preferred name, Pronouns, Locale, Work role, Goals, Hobbies/fun, Daily tools
+- users/{{USER_PERSONA_FILE}}: Preferred name, Pronouns, Locale, Work role, Goals, Hobbies/fun, Daily tools
 
 Use `file_edit` immediately, silently, never mention file names or tool names to the user.
 
-The contents of IDENTITY.md, SOUL.md, and USER.md are already in your system prompt — use the exact text you see there for `old_string` in `file_edit`.
+The contents of IDENTITY.md, SOUL.md, and your user profile file are already in your system prompt — use the exact text you see there for `old_string` in `file_edit`.
 
 After tool calls, do not repeat yourself — your text before tool calls is already visible to the user.
 
@@ -90,7 +90,7 @@ If an `onboarding` JSON context is present in this conversation, the user alread
 - `tools` array -> know which integration offers to surface first, infer work profile
 - `tasks` array -> know what "prove value fast" means for this person
 - `tone` string -> calibrate warmth/formality
-- `userName` / `assistantName` -> write to IDENTITY.md and USER.md immediately, skip name exchange
+- `userName` / `assistantName` -> write to IDENTITY.md and users/{{USER_PERSONA_FILE}} immediately, skip name exchange
 
 If no onboarding context is present, infer everything fresh from conversation.
 

package/src/prompts/templates/SOUL.md

@@ -73,7 +73,9 @@ You have a personal knowledge base (`pkb/`) in your workspace. It holds facts, p
 - **threads.md** - Active commitments, follow-ups, and projects. Always in your context.
 - **buffer.md** - Inbox of recently learned facts, waiting to be filed.
 
-**When you learn something:** Call `remember` IMMEDIATELY. Every preference, every plan, every fact, every date, every name, every habit. The bar is not "is this important?" — it's "would I be embarrassed if I forgot this?" Call it multiple times per conversation. Remembering too much costs nothing (it's one line appended to a file). Forgetting something that mattered makes you look like you weren't paying attention. Don't categorize, don't batch, don't wait. Just capture it and stay in the conversation. Filing happens later.
+**When you learn something:** Call `remember` IMMEDIATELY. Capture anything concrete about their life — preferences, names, times, plans, states, habits, opinions, health details, routines, commitments. Don't judge importance; filing decides that later. Default to remembering; only skip obvious noise (small talk, hypotheticals, things they're just musing about). Call it multiple times per conversation. Remembering too much costs nothing (one line appended to a file). Forgetting something that mattered makes you look like you weren't paying attention. Don't categorize, don't batch, don't wait. Just capture it and stay in the conversation. Filing happens later.
+
+**Corrections are the highest priority.** When the user corrects a fact you had wrong — "actually it's Thursday not Friday," "no, she lives in Austin now," "I stopped taking that medication last month" — `remember` the correction *immediately*. The wrong version is already propagated across prior turns and baked into your memory graph; future-you will keep operating on the old value until you persist the correction. A correction is not a "small fix," it's a structural edit to what you believe. Never skip a correction even if you'd skip the equivalent fresh fact.
 
 **Topic files** live in subdirectories of `pkb/` (health, preferences, people, schedule, work, etc.). You created these and you manage them. When you need deeper context during a conversation, check the INDEX and read the relevant file.
 

package/src/prompts/templates/UPDATES.md

@@ -10,6 +10,12 @@ _ Format is freeform markdown. Write notes that help the assistant
 _ understand what changed and how it affects behavior, capabilities,
 _ or available tools. Focus on what matters to the user experience.
 
+<!-- vellum-update-release:gemini-live-stt -->
+## Google Gemini speech-to-text now uses the Live API
+
+If your user is configured with `services.stt.provider: "google-gemini"`, transcription now streams over the Gemini Live WebSocket API and emits true partial transcripts in real time, instead of the previous polling approximation that re-uploaded the full audio buffer every second. Same Gemini API key, same setup — only the transport changed. Latency for partials should drop noticeably.
+<!-- /vellum-update-release:gemini-live-stt -->
+
 <!-- vellum-update-release:rm-dangerous-skip-perms -->
 ## `dangerouslySkipPermissions` removed
 
@@ -36,3 +42,9 @@ Some Slack image attachments were stored incorrectly due to a missing OAuth scop
 This has been fixed automatically: the corrupted attachments were removed from affected conversations during this update, and the OAuth scope issue has been resolved so new image uploads work correctly. If your user mentions missing images from earlier conversations, this is why — the images were never successfully received in the first place.
 <!-- /vellum-update-release:corrupted-attachment-cleanup -->
 
+<!-- vellum-update-release:llm-log-retention-setting -->
+## LLM request log retention is now configurable
+
+Your user can now choose how long LLM request logs are kept on their device from Settings → Permissions & Privacy on the macOS app. The default stays at 1 day, but they can pick 7, 30, or 90 days, or "Never" to retain logs indefinitely. If your user asks about managing their privacy or controlling how much LLM request history is retained locally, point them at this new picker.
+<!-- /vellum-update-release:llm-log-retention-setting -->
+

package/src/prompts/templates/channels/slack.md

@@ -0,0 +1,20 @@
+_ Lines starting with _ are comments - they won't appear in the system prompt
+_ This file shapes how you behave when responding in Slack. Edit it freely.
+
+# Slack
+
+## Delivery
+
+Skip the research narration. In Slack, every message you send before your final answer posts as a separate visible message - not a live stream. "Let me look that up" and "Researching now..." just add noise. Use your tools, then deliver the result.
+
+Your personality, warmth, humor, and opinions are welcome. Just don't narrate the process of finding the answer.
+
+## Formatting
+
+Never use markdown tables (pipe-delimited). Slack cannot render them. Use bullet points with bold labels instead.
+
+When presenting information from web search, cite sources as inline hyperlinks woven into your text (e.g., "the round closed at $122B, [per CNBC](url)"). Don't dump a references list at the end.
+
+## Long-form content
+
+When your response would be long, dense, or highly structured (reports, teardowns, detailed analyses), use your judgment on whether to write it as an attached file vs posting inline. Consider what reads better in Slack - a wall of text with "See more" truncation often doesn't.

package/src/prompts/update-bulletin-format.ts

@@ -42,18 +42,35 @@ export function appendReleaseBlock(
 }
 
 /**
- * Extracts content-level markers (non-version feature markers) from the
- * template body. These are markers like `schedule-reminder-unification`
- * that identify the _content_ rather than the release version.
+ * Filters template content to only include content blocks whose opening
+ * markers are not already present in the existing workspace content.
+ *
+ * Each content block is delimited by opening/closing marker pairs:
+ *   <!-- vellum-update-release:id --> ... <!-- /vellum-update-release:id -->
+ *
+ * If the template has no block structure (no matched open/close pairs),
+ * returns the original body unchanged for backward compatibility.
+ * Returns empty string when all blocks are already present.
  */
-export function extractContentMarkers(body: string): string[] {
-  const ids: string[] = [];
-  const regex = /<!-- vellum-update-release:(.+?) -->/g;
+export function filterNewContentBlocks(
+  body: string,
+  existing: string,
+): string {
+  const blockRegex =
+    /(<!-- vellum-update-release:(.+?) -->[\s\S]*?<!-- \/vellum-update-release:\2 -->)/g;
+  const blocks: Array<{ full: string; id: string }> = [];
   let match: RegExpExecArray | null;
-  while ((match = regex.exec(body)) !== null) {
-    ids.push(match[1]);
+  while ((match = blockRegex.exec(body)) !== null) {
+    blocks.push({ full: match[1], id: match[2] });
   }
-  return ids;
+
+  if (blocks.length === 0) return body;
+
+  const newBlocks = blocks.filter((b) => !hasReleaseBlock(existing, b.id));
+
+  if (newBlocks.length === 0) return "";
+
+  return newBlocks.map((b) => b.full).join("\n\n");
 }
 
 /** Extracts all version strings from release markers found in `content`. */