@vellumai/assistant 0.8.1 → 0.8.2

package/src/proactive-artifact/job.test.ts

@@ -1,5 +1,10 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
+import {
+  conversationMessagesSyncTag,
+  SYNC_TAGS,
+} from "../daemon/message-types/sync.js";
+
 // ── Mock state ──────────────────────────────────────────────────────────
 
 // Provider mock
@@ -691,7 +696,7 @@ describe("runProactiveArtifactJob", () => {
 });
 
 describe("injectAuxAssistantMessage", () => {
-  test("idle conversation: persists with skipIndexing, pushes to getMessages(), broadcasts delta + complete(aux) + list_invalidated", async () => {
+  test("idle conversation: persists with skipIndexing, pushes to getMessages(), broadcasts delta + complete(aux) + list sync", async () => {
     const messages: unknown[] = [];
     mockConversations.set("conv-inject-1", {
       processing: false,
@@ -714,7 +719,7 @@ describe("injectAuxAssistantMessage", () => {
     // Pushed to in-memory messages
     expect(messages).toHaveLength(1);
 
-    // Broadcasts: delta, complete(aux), list_invalidated
+    // Broadcasts: delta, complete(aux), list invalidation + sync tag
     const deltaMsg = broadcastCalls.find(
       (c) => c.type === "assistant_text_delta",
     );
@@ -734,6 +739,15 @@ describe("injectAuxAssistantMessage", () => {
     );
     expect(listMsg).toBeDefined();
     expect(listMsg!.reason).toBe("reordered");
+
+    const syncMsg = broadcastCalls.find((c) => c.type === "sync_changed");
+    expect(syncMsg).toEqual({
+      type: "sync_changed",
+      tags: [
+        SYNC_TAGS.conversationsList,
+        conversationMessagesSyncTag("conv-inject-1"),
+      ],
+    });
   });
 
   test("processing → idle: waits for processing to become false before persisting", async () => {
@@ -824,13 +838,22 @@ describe("injectAuxAssistantMessage", () => {
       broadcastCalls.filter((c) => c.type === "message_complete"),
     ).toHaveLength(0);
 
-    // But list_invalidated IS sent (always sent regardless of processing state)
+    // But list invalidation + sync tag ARE sent regardless of processing state.
     expect(
       broadcastCalls.filter((c) => c.type === "conversation_list_invalidated"),
     ).toHaveLength(1);
+    expect(broadcastCalls.filter((c) => c.type === "sync_changed")).toEqual([
+      {
+        type: "sync_changed",
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMessagesSyncTag("conv-inject-3"),
+        ],
+      },
+    ]);
   });
 
-  test("inactive/unloaded conversation: persists + list_invalidated only", async () => {
+  test("inactive/unloaded conversation: persists + list sync only", async () => {
     // No conversation in the store
     await injectAuxAssistantMessage({
       conversationId: "conv-inject-4",
@@ -850,10 +873,19 @@ describe("injectAuxAssistantMessage", () => {
       broadcastCalls.filter((c) => c.type === "message_complete"),
     ).toHaveLength(0);
 
-    // But list_invalidated IS sent
+    // But list invalidation + sync tag ARE sent
     expect(
       broadcastCalls.filter((c) => c.type === "conversation_list_invalidated"),
     ).toHaveLength(1);
+    expect(broadcastCalls.filter((c) => c.type === "sync_changed")).toEqual([
+      {
+        type: "sync_changed",
+        tags: [
+          SYNC_TAGS.conversationsList,
+          conversationMessagesSyncTag("conv-inject-4"),
+        ],
+      },
+    ]);
   });
 });
 

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

@@ -103,3 +103,15 @@ describe("buildSystemPrompt — Background Conversation gating", () => {
     expect(dynamicBlock).not.toContain("## Background Conversation");
   });
 });
+
+describe("buildSystemPrompt — tool routing guidance", () => {
+  beforeEach(() => {
+    mkdirSync(TEST_DIR, { recursive: true });
+  });
+
+  test("does not include ask_question routing guidance", () => {
+    const result = buildSystemPrompt({});
+    expect(result).not.toContain("## Clarifying questions");
+    expect(result).not.toContain("ask_question");
+  });
+});

package/src/prompts/__tests__/task-progress-hint-section.test.ts

@@ -0,0 +1,99 @@
+/**
+ * Tests for the task_progress hint in the 01-parallel-tool-calls workspace
+ * system prompt section.
+ *
+ * Verifies that the task_progress guidance renders unconditionally in the
+ * system prompt — no `enabled` frontmatter gating, no options dependency.
+ */
+
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+const noopLogger: Record<string, unknown> = new Proxy(
+  {} as Record<string, unknown>,
+  {
+    get: (_target, prop) => (prop === "child" ? () => noopLogger : () => {}),
+  },
+);
+
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const realLogger = require("../../util/logger.js");
+mock.module("../../util/logger.js", () => ({
+  ...realLogger,
+  getLogger: () => noopLogger,
+  getCliLogger: () => noopLogger,
+  truncateForLog: (v: string) => v,
+  initLogger: () => {},
+  pruneOldLogFiles: () => 0,
+}));
+
+const mockLoadedConfig: Record<string, unknown> = {};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => ({
+    ui: {},
+    services: {
+      inference: {
+        mode: "your-own",
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      },
+      "image-generation": {
+        mode: "your-own",
+        provider: "gemini",
+        model: "gemini-3.1-flash-image-preview",
+      },
+      "web-search": { mode: "your-own", provider: "inference-provider-native" },
+    },
+  }),
+  loadConfig: () => mockLoadedConfig,
+  loadRawConfig: () => ({}),
+  saveConfig: () => {},
+  saveRawConfig: () => {},
+  invalidateConfigCache: () => {},
+  getNestedValue: () => undefined,
+  setNestedValue: () => {},
+}));
+
+const { buildSystemPrompt, ensurePromptFiles, SYSTEM_PROMPT_CACHE_BOUNDARY } =
+  await import("../system-prompt.js");
+
+describe("task_progress hint in parallel-tool-calls section", () => {
+  beforeEach(() => {
+    ensurePromptFiles();
+  });
+
+  test("buildSystemPrompt() includes task_progress guidance", () => {
+    const result = buildSystemPrompt();
+    expect(result).toContain("task_progress");
+    expect(result).toContain("No exceptions");
+  });
+
+  test("renders unconditionally — no options required", () => {
+    const result = buildSystemPrompt(undefined);
+    expect(result).toContain("task_progress");
+  });
+
+  test("renders regardless of options passed", () => {
+    const withBackground = buildSystemPrompt({
+      isBackgroundConversation: true,
+    });
+    const withoutBackground = buildSystemPrompt({
+      isBackgroundConversation: false,
+    });
+    const withExcludePrefix = buildSystemPrompt({
+      excludeCustomPrefix: true,
+    });
+
+    expect(withBackground).toContain("task_progress");
+    expect(withoutBackground).toContain("task_progress");
+    expect(withExcludePrefix).toContain("task_progress");
+  });
+
+  test("hint lives in the static (cached) block before SYSTEM_PROMPT_CACHE_BOUNDARY", () => {
+    const result = buildSystemPrompt();
+    const boundaryIdx = result.indexOf(SYSTEM_PROMPT_CACHE_BOUNDARY);
+    expect(boundaryIdx).toBeGreaterThan(-1);
+    const staticBlock = result.slice(0, boundaryIdx);
+    expect(staticBlock).toContain("task_progress");
+  });
+});

package/src/prompts/normalize-onboarding.ts

@@ -62,6 +62,29 @@ export interface NormalizedOnboarding {
   dailyTools: string[];
   tone?: string;
   assistantName?: string;
+  googleConnected?: boolean;
+  googleServices?: string[];
+}
+
+const SCOPE_SERVICE_MAP: Record<string, string> = {
+  "gmail.readonly": "Gmail",
+  "gmail.modify": "Gmail",
+  "gmail.send": "Gmail",
+  "gmail.settings.basic": "Gmail",
+  "calendar.readonly": "Calendar",
+  "calendar.events": "Calendar",
+  drive: "Drive",
+};
+
+export function deriveGoogleServices(scopes?: string[]): string[] {
+  if (!scopes?.length) return ["Gmail", "Calendar", "Drive"];
+  const services = new Set<string>();
+  for (const scope of scopes) {
+    const suffix = scope.replace("https://www.googleapis.com/auth/", "");
+    const service = SCOPE_SERVICE_MAP[suffix];
+    if (service) services.add(service);
+  }
+  return services.size > 0 ? [...services] : ["Gmail", "Calendar", "Drive"];
 }
 
 /**
@@ -76,5 +99,9 @@ export function normalizeOnboardingContext(
     dailyTools: normalizeTools(ctx.tools),
     tone: ctx.tone,
     assistantName: ctx.assistantName,
+    googleConnected: ctx.googleConnected,
+    googleServices: ctx.googleConnected
+      ? deriveGoogleServices(ctx.googleScopes)
+      : undefined,
   };
 }

package/src/prompts/sections.ts

@@ -0,0 +1,302 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { parseFrontmatterFields } from "../skills/frontmatter.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir, getWorkspacePromptPath } from "../util/platform.js";
+import { stripCommentLines } from "../util/strip-comment-lines.js";
+import {
+  BUNDLED_SYSTEM_SECTIONS,
+  type BundledSection,
+} from "./templates/system-sections.js";
+
+const log = getLogger("system-prompt-sections");
+
+/**
+ * Render context passed by the caller of `renderWorkspaceSections`. Sections
+ * declare their `enabled` predicate as a context key (or `!key`), and the
+ * predicate is evaluated against fields on this object.
+ *
+ * Intentionally an open record — the registry never references specific keys.
+ * Callers (currently `buildSystemPrompt`) hand in the same options object
+ * they received, so any field on `BuildSystemPromptOptions` can be
+ * referenced by name in a section's `enabled` predicate or `{{variable}}`
+ * interpolation.
+ */
+export type SectionRenderContext = Record<string, unknown>;
+
+/**
+ * Workspace override location for user-authored system prompt sections.
+ * Layout: `<workspace>/prompts/system/<NN-name>.md`.
+ *
+ * The bundled section registry (`templates/system-sections.ts`) is the
+ * source of default truth; this directory is an optional override layer.
+ * Drop a file with the same id as a bundled section to replace its body,
+ * or drop a file with a brand-new `<NN-name>` to add a workspace-only
+ * section.  Either path is opt-in — the directory may not exist on a
+ * fresh install, and the renderer will simply use bundled defaults.
+ */
+export function getWorkspaceSystemPromptDir(): string {
+  return join(getWorkspaceDir(), "prompts", "system");
+}
+
+/**
+ * Render every section in id-sort order, returning the trimmed body of
+ * each enabled section.  Discovery walks the bundled registry plus any
+ * `.md` files in the workspace override dir, and takes the union of ids.
+ *
+ * Resolution per id:
+ *   - workspace `.md` file present → use workspace body (override)
+ *   - workspace file absent        → use bundled registry entry (default)
+ *
+ * Bundled is the source of default truth.  Workspace acts as an override
+ * layer — a user can replace a bundled section by writing the same id in
+ * their workspace, or add a brand-new section by writing an id that
+ * doesn't appear in the bundled registry.  Workspace-only ids skip the
+ * bundled lookup entirely.
+ *
+ * Render contract per section:
+ *   1. resolve `{ enabled, body }` (workspace .md wins over bundled TS)
+ *   2. evaluate `enabled` against `ctx`; falsy → skip
+ *   3. apply mustache section / inverted-section / variable interpolation
+ *   4. strip lines starting with `_` (legacy inline-comment convention)
+ *   5. trim; emit if non-empty, otherwise skip
+ *
+ * The empty-body case is intentional — a user can silence a bundled
+ * section by overriding it with a file that strips down to nothing
+ * (frontmatter `enabled: false`, or a frontmatter-only file, or a body
+ * of only `_`-comments).  This is the supported "disable a bundled
+ * default" path.
+ *
+ * The numeric prefix on each id is load-bearing for sort order; pick a
+ * number that places the section where it should appear in the final
+ * prompt.
+ */
+export function renderWorkspaceSections(ctx: SectionRenderContext): string[] {
+  const workspaceDir = getWorkspaceSystemPromptDir();
+  const ids = collectSectionIds(workspaceDir);
+
+  const out: string[] = [];
+  for (const id of ids) {
+    const rendered = renderSection(id, ctx, workspaceDir);
+    if (rendered) out.push(rendered);
+  }
+  return out;
+}
+
+function collectSectionIds(workspaceDir: string): string[] {
+  const ids = new Set<string>();
+  for (const section of BUNDLED_SYSTEM_SECTIONS) ids.add(section.id);
+  if (existsSync(workspaceDir)) {
+    try {
+      for (const name of readdirSync(workspaceDir)) {
+        if (name.endsWith(".md")) ids.add(name.slice(0, -".md".length));
+      }
+    } catch (err) {
+      log.warn({ err, workspaceDir }, "Failed to list workspace system prompt dir");
+    }
+  }
+  return [...ids].sort();
+}
+
+interface ResolvedSection {
+  enabled: string | boolean | undefined;
+  body: string;
+}
+
+function resolveSection(
+  id: string,
+  workspaceDir: string,
+): ResolvedSection | null {
+  const workspacePath = join(workspaceDir, `${id}.md`);
+  if (existsSync(workspacePath)) {
+    let raw: string;
+    try {
+      raw = readFileSync(workspacePath, "utf-8");
+    } catch (err) {
+      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;
+    return { enabled: fields["enabled"] as string | boolean | undefined, body };
+  }
+  const bundled = BUNDLED_SYSTEM_SECTIONS.find((s) => s.id === id);
+  if (!bundled) return null;
+
+  // 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.
+  if (bundled.workspacePath) {
+    const filePath = getWorkspacePromptPath(bundled.workspacePath);
+    let body = "";
+    if (existsSync(filePath)) {
+      try {
+        body = readFileSync(filePath, "utf-8");
+      } catch (err) {
+        log.warn(
+          { err, filePath, id },
+          "Failed to read section workspacePath",
+        );
+      }
+    }
+    return { enabled: bundled.enabled, body };
+  }
+
+  return { enabled: bundled.enabled, body: bundled.body };
+}
+
+function renderSection(
+  id: string,
+  ctx: SectionRenderContext,
+  workspaceDir: string,
+): string | null {
+  const section = resolveSection(id, workspaceDir);
+  if (section === null) return null;
+
+  if (!isEnabled(section.enabled, ctx)) return null;
+
+  const stripped = stripCommentLines(section.body).trim();
+  if (stripped.length === 0) return null;
+  return interpolateVariables(stripped, ctx);
+}
+
+const IDENT_REGEX = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+
+/**
+ * Apply mustache-style interpolation to `body` against `ctx`, in this order:
+ *
+ *   1. **Standalone-tag normalization.** A section open/close tag occupying
+ *      its own line (only whitespace on either side) absorbs the trailing
+ *      newline.  This lets authors write block-style templates without
+ *      orphan blank lines bleeding through into the rendered output.
+ *   2. **Sections** — `{{#flag}}body{{/flag}}` renders `body` when
+ *      `ctx[flag]` is truthy, empty otherwise.  **Inverted sections** —
+ *      `{{^flag}}body{{/flag}}` — render the opposite.  The close tag's
+ *      name must match the open tag's; bodies are matched non-greedily so
+ *      sibling sections stay independent.  Nested same-named sections are
+ *      *not* supported (no use case yet).
+ *   3. **Variables** — `{{key}}` substitutes `String(ctx[key])`.
+ *
+ * Section *keys* are valid JS identifiers (`[A-Za-z_$][A-Za-z0-9_$]*`) so
+ * the construct can't be confused with code-block braces in the markdown.
+ * Section keys are coerced via `Boolean(ctx[key])` — `undefined`, `null`,
+ * `false`, `0`, and `""` all gate the body off; everything else gates it
+ * on.  This means callers can pass through optional flags without
+ * normalizing each one to a defined boolean first.  **Variable** keys
+ * whose `ctx` value is `undefined` or `null` stay literal (so an authoring
+ * typo on a `{{key}}` substitution surfaces at the warn log rather than
+ * inlining the string `"undefined"`).
+ */
+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");
+
+  // Evaluate `{{#flag}}` / `{{^flag}}` blocks before variables, so a
+  // section body may itself contain `{{var}}` substitutions.  Section
+  // keys are pure gates — the body is either in or out, never inlined —
+  // so we treat any falsy value (including `undefined`) as "gate off"
+  // rather than surfacing typos.  This keeps optional `BuildSystemPromptOptions`
+  // flags working when the caller omits them.
+  const sectionsResolved = collapsed.replace(
+    SECTION,
+    (_match, kind: string, key: string, sectionBody: string) => {
+      const truthy = Boolean(ctx[key]);
+      const include = kind === "#" ? truthy : !truthy;
+      return include ? sectionBody : "";
+    },
+  );
+
+  return sectionsResolved.replace(VARIABLE, (match, key: string) => {
+    const value = ctx[key];
+    if (value === undefined || value === null) {
+      log.warn(
+        { key },
+        "Unresolved {{variable}} in workspace system prompt section; leaving literal",
+      );
+      return match;
+    }
+    return String(value);
+  });
+}
+
+const IDENT_PATTERN = "[A-Za-z_$][A-Za-z0-9_$]*";
+
+/**
+ * Matches a section open/close tag that sits alone on its line (optional
+ * whitespace on either side, followed by a line terminator or end of
+ * input).  The replacement keeps the tag itself and discards the
+ * surrounding whitespace + newline.
+ */
+const STANDALONE_TAG_LINE = new RegExp(
+  `^[ \\t]*(\\{\\{[#^/]${IDENT_PATTERN}\\}\\})[ \\t]*(?:\\r?\\n|$)`,
+  "gm",
+);
+
+/**
+ * Matches a section block `{{#name}}body{{/name}}` or its inverted form
+ * `{{^name}}body{{/name}}`.  The backreference forces the close tag to
+ * name the same key as the open tag; `[\s\S]*?` lets the body span
+ * multiple lines without greedy-matching across sibling sections.
+ */
+const SECTION = new RegExp(
+  `\\{\\{([#^])(${IDENT_PATTERN})\\}\\}([\\s\\S]*?)\\{\\{\\/\\2\\}\\}`,
+  "g",
+);
+
+const VARIABLE = new RegExp(`\\{\\{(${IDENT_PATTERN})\\}\\}`, "g");
+
+/**
+ * Evaluate an `enabled:` predicate.  Supported shapes:
+ *
+ *   - omitted / undefined  → always enabled
+ *   - boolean              → use as-is
+ *   - `<key>`              → render when `ctx[key]` is truthy
+ *   - `!<key>`             → render when `ctx[key]` is falsy
+ *
+ * Predicate forms are intentionally limited to a single identifier (with
+ * optional leading `!`).  Anything more elaborate is rejected so the
+ * predicate stays declarative — if a section needs richer logic, route a
+ * pre-computed boolean through the context map and reference that.
+ */
+function isEnabled(value: unknown, ctx: SectionRenderContext): boolean {
+  if (value === undefined) return true;
+  if (typeof value === "boolean") return value;
+  if (typeof value !== "string") {
+    log.warn(
+      { value },
+      "Unsupported `enabled` type in section frontmatter; treating as disabled",
+    );
+    return false;
+  }
+
+  let trimmed = value.trim();
+  if (trimmed.length === 0) return true;
+
+  let negate = false;
+  if (trimmed.startsWith("!")) {
+    negate = true;
+    trimmed = trimmed.slice(1).trim();
+  }
+
+  if (!IDENT_REGEX.test(trimmed)) {
+    log.warn(
+      { value },
+      "Unsupported `enabled` expression in section frontmatter; treating as disabled",
+    );
+    return false;
+  }
+
+  const result = Boolean(ctx[trimmed]);
+  return negate ? !result : result;
+}
+
+// Re-export the registry type so callers (rare) can introspect bundled
+// content without reaching into the templates directory directly.
+export type { BundledSection };