@vellumai/assistant 0.9.0 → 0.10.0-staging.2

package/src/memory/__tests__/preloaded-apps.test.ts

@@ -1,85 +0,0 @@
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-
-import { setOverridesForTesting } from "../../__tests__/feature-flag-test-helpers.js";
-import type { AssistantConfig } from "../../config/schema.js";
-import { getAppsDir } from "../app-store.js";
-import {
-  ACTIVATION_FLOW_FLAG,
-  PERSONAL_PAGE_APP_ID,
-  PERSONAL_PAGE_ARM,
-  seedPreloadedApps,
-} from "../preloaded-apps.js";
-
-// The flag resolver reads the override cache and registry; the config
-// argument is part of the signature but not consulted for resolution.
-const config = {} as AssistantConfig;
-
-function definitionPath(): string {
-  return join(getAppsDir(), `${PERSONAL_PAGE_APP_ID}.json`);
-}
-
-function appDir(): string {
-  return join(getAppsDir(), PERSONAL_PAGE_APP_ID);
-}
-
-beforeEach(() => {
-  setOverridesForTesting({});
-});
-
-afterEach(() => {
-  setOverridesForTesting({});
-  rmSync(definitionPath(), { force: true });
-  rmSync(appDir(), { recursive: true, force: true });
-});
-
-describe("seedPreloadedApps gating", () => {
-  test("does not seed on the control arm", async () => {
-    setOverridesForTesting({ [ACTIVATION_FLOW_FLAG]: "control" });
-    await seedPreloadedApps(config);
-    expect(existsSync(definitionPath())).toBe(false);
-    expect(existsSync(appDir())).toBe(false);
-  });
-
-  test("does not seed on other treatment arms", async () => {
-    setOverridesForTesting({ [ACTIVATION_FLOW_FLAG]: "variant-a" });
-    await seedPreloadedApps(config);
-    expect(existsSync(definitionPath())).toBe(false);
-  });
-
-  test("does not seed when the flag resolves to the registry default", async () => {
-    // No override → declared default "control".
-    await seedPreloadedApps(config);
-    expect(existsSync(definitionPath())).toBe(false);
-  });
-
-  test("leaves an already-seeded, compiled app untouched", async () => {
-    setOverridesForTesting({ [ACTIVATION_FLOW_FLAG]: PERSONAL_PAGE_ARM });
-
-    const sentinelDefinition = JSON.stringify({
-      id: PERSONAL_PAGE_APP_ID,
-      userEdited: true,
-    });
-    mkdirSync(join(appDir(), "dist"), { recursive: true });
-    writeFileSync(definitionPath(), sentinelDefinition, "utf-8");
-    writeFileSync(
-      join(appDir(), "dist", "index.html"),
-      "<!-- compiled -->",
-      "utf-8",
-    );
-
-    await seedPreloadedApps(config);
-
-    // Seeding must not re-copy the template or rewrite the definition once
-    // the app exists — its content is considered user-owned.
-    expect(readFileSync(definitionPath(), "utf-8")).toBe(sentinelDefinition);
-    expect(existsSync(join(appDir(), "src"))).toBe(false);
-  });
-});

package/src/memory/preloaded-apps.ts

@@ -1,116 +0,0 @@
-/**
- * Seeds preloaded apps into the workspace apps directory at daemon startup.
- *
- * A preloaded app ships as plain source files under
- * `src/config/preloaded-apps/<dirName>/` and is copied into
- * `data/apps/<dirName>/` with a fixed, well-known app id, then compiled.
- * The assistant later populates it by overwriting designated content files
- * (e.g. the personal page's `src/profile-data.ts`) and calling app_refresh —
- * it never authors the layout itself.
- *
- * Seeding is idempotent and deliberately conservative: once the definition
- * JSON exists the app is considered user-owned (its content may have been
- * populated) and the template is never re-copied. A missing `dist/` triggers
- * a recompile only.
- *
- * Seeding is gated on the activation-flow experiment: only assistants in the
- * personal-page treatment arm get the app. The gate is evaluated once per
- * daemon startup — an assistant moved into the arm later picks it up on its
- * next restart, and an already-seeded app is never removed when the
- * assistant leaves the arm (it is user-owned by then).
- */
-
-import { cpSync, existsSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-import { compileApp } from "../bundler/app-compiler.js";
-import {
-  getAssistantFeatureFlagValue,
-  initFeatureFlagOverrides,
-} from "../config/assistant-feature-flags.js";
-import type { AssistantConfig } from "../config/schema.js";
-import { resolveBundledDir } from "../util/bundled-asset.js";
-import { getLogger } from "../util/logger.js";
-import { getAppsDir } from "./app-store.js";
-
-const log = getLogger("preloaded-apps");
-
-/** Well-known id (and dirName) of the personal landing page app. */
-export const PERSONAL_PAGE_APP_ID = "personal-page";
-
-/** Multivariate activation-flow experiment flag (scope "both"). */
-export const ACTIVATION_FLOW_FLAG = "experiment-activation-flow-2026-06-03";
-
-/** Arm of the activation-flow experiment that gets the preseeded page. */
-export const PERSONAL_PAGE_ARM = "personal-page";
-
-export async function seedPreloadedApps(
-  config: AssistantConfig,
-): Promise<void> {
-  // The lifecycle hook fires this early in startup, possibly before the
-  // gateway override fetch has completed. Await it here (no-op when already
-  // cached; bounded retries otherwise) so the arm read below sees the
-  // platform-assigned value rather than the registry default.
-  await initFeatureFlagOverrides();
-
-  const arm = getAssistantFeatureFlagValue(ACTIVATION_FLOW_FLAG, config);
-  if (arm !== PERSONAL_PAGE_ARM) return;
-
-  await seedPersonalPageApp();
-}
-
-async function seedPersonalPageApp(): Promise<void> {
-  const appsDir = getAppsDir();
-  const definitionPath = join(appsDir, `${PERSONAL_PAGE_APP_ID}.json`);
-  const appDir = join(appsDir, PERSONAL_PAGE_APP_ID);
-  const alreadySeeded = existsSync(definitionPath);
-
-  if (alreadySeeded && existsSync(join(appDir, "dist", "index.html"))) {
-    return;
-  }
-
-  if (!alreadySeeded) {
-    const templateDir = resolveBundledDir(
-      import.meta.dirname ?? __dirname,
-      "../config/preloaded-apps/personal-page",
-      "preloaded-apps/personal-page",
-    );
-    if (!existsSync(join(templateDir, "src"))) {
-      log.warn(
-        { templateDir },
-        "Personal page template not found — skipping preloaded app seeding",
-      );
-      return;
-    }
-
-    cpSync(join(templateDir, "src"), join(appDir, "src"), { recursive: true });
-    // Multifile (formatVersion 2) apps keep an empty root index.html; the
-    // real entrypoint is src/index.html compiled into dist/. Matches the
-    // on-disk shape produced by createApp().
-    writeFileSync(join(appDir, "index.html"), "", "utf-8");
-
-    const now = Date.now();
-    const definition = {
-      id: PERSONAL_PAGE_APP_ID,
-      name: "Your Page",
-      description:
-        "A personal landing page the assistant fills in with what it learns about you.",
-      icon: "✨",
-      schemaJson: "{}",
-      createdAt: now,
-      updatedAt: now,
-      formatVersion: 2,
-      dirName: PERSONAL_PAGE_APP_ID,
-    };
-    writeFileSync(definitionPath, JSON.stringify(definition, null, 2), "utf-8");
-    log.info({ appDir }, "Seeded personal page app");
-  }
-
-  const result = await compileApp(appDir);
-  if (!result.ok) {
-    log.warn(
-      { errors: result.errors },
-      "Personal page app failed to compile after seeding",
-    );
-  }
-}

package/src/notifications/tool-approval-copy.ts

@@ -1,142 +0,0 @@
-/**
- * Deterministic helpers for building guardian-facing tool-approval copy.
- *
- * Produces Surface card seed content blocks for `tool_approval`,
- * `tool_grant_request`, and voice/call `pending_question` (with `toolName`)
- * guardian questions, enabling Approve/Reject buttons in the Vellum in-app
- * channel (web/macOS/iOS).
- */
-
-import { buildApprovalCardBlocks } from "./approval-card-builder.js";
-import {
-  buildGuardianRequestCodeInstruction,
-  type GuardianQuestionPayload,
-  type LenientToolApprovalPayload,
-  LenientToolApprovalPayloadSchema,
-  parseGuardianQuestionPayload,
-  resolveGuardianInstructionModeFromFields,
-  resolveGuardianInstructionModeFromPayload,
-} from "./guardian-question-mode.js";
-import { nonEmpty, sanitizeIdentityField } from "./notification-utils.js";
-
-// ── Approval detection ──────────────────────────────────────────────────────
-
-/**
- * Determine whether a typed guardian.question payload represents a tool
- * approval (as opposed to a free-text answer). Uses the canonical mode
- * resolver in `guardian-question-mode.ts` — the single source of truth
- * for the requestKind → instructionMode mapping.
- */
-function isToolApprovalPayload(payload: GuardianQuestionPayload): boolean {
-  const { mode } = resolveGuardianInstructionModeFromPayload(payload);
-  return mode === "approval" && payload.requestKind !== "access_request";
-}
-
-/**
- * Lenient approval detection for partially-constructed payloads that don't
- * satisfy the strict discriminated union schema.
- */
-function isLenientToolApproval(payload: LenientToolApprovalPayload): boolean {
-  const modeResolution = resolveGuardianInstructionModeFromFields(
-    payload.requestKind,
-    payload.toolName,
-  );
-  if (!modeResolution) return false;
-  return (
-    modeResolution.mode === "approval" &&
-    payload.requestKind !== "access_request"
-  );
-}
-
-// ── Seed content blocks (Surface-based rendering) ───────────────────────────
-
-/**
- * Build structured content blocks for a tool approval/grant notification seed
- * message. Returns `null` when the payload does not represent a tool approval.
- *
- * Accepts both strict `GuardianQuestionPayload` (Zod-validated) and raw
- * `Record<string, unknown>` payloads. For raw payloads, attempts strict
- * parsing first, then falls back to lenient field extraction so cards
- * still render when optional fields are absent.
- */
-export function buildToolApprovalSeedContentBlocks(
-  payload: GuardianQuestionPayload,
-): unknown[] | null;
-export function buildToolApprovalSeedContentBlocks(
-  payload: Record<string, unknown>,
-): unknown[] | null;
-export function buildToolApprovalSeedContentBlocks(
-  payload: GuardianQuestionPayload | Record<string, unknown>,
-): unknown[] | null {
-  // Try strict Zod parsing first (full discriminated union).
-  const strict = parseGuardianQuestionPayload(
-    payload as Record<string, unknown>,
-  );
-  if (strict) {
-    if (!isToolApprovalPayload(strict)) return null;
-    return buildCardFromFields(strict);
-  }
-
-  // Fall back to lenient parsing — requires only `requestKind`.
-  const lenient = LenientToolApprovalPayloadSchema.safeParse(payload);
-  if (!lenient.success) return null;
-  if (!isLenientToolApproval(lenient.data)) return null;
-  return buildCardFromFields(lenient.data);
-}
-
-// ── Card construction (shared between strict and lenient paths) ─────────────
-
-function buildCardFromFields(
-  p: GuardianQuestionPayload | LenientToolApprovalPayload,
-): unknown[] {
-  const toolName =
-    ("toolName" in p ? nonEmpty(p.toolName) : undefined) ?? "unknown tool";
-  const rawRequester = nonEmpty(p.requesterIdentifier);
-  const requester = rawRequester
-    ? sanitizeIdentityField(rawRequester)
-    : "Someone";
-
-  const isGrant = p.requestKind === "tool_grant_request";
-
-  const metadata: Array<{ label: string; value: string }> = [];
-  metadata.push({ label: "Tool", value: toolName });
-  const sourceChannel = nonEmpty(p.sourceChannel);
-  if (sourceChannel) {
-    metadata.push({ label: "Source", value: sourceChannel });
-  }
-
-  const body = p.questionText
-    ? `> ${p.questionText}`
-    : "No additional context available.";
-
-  // Fallback text with request-code instructions for older clients.
-  const baseFallback =
-    p.questionText ?? `${requester} is requesting approval to use ${toolName}`;
-  let fallbackText = baseFallback;
-  const requestCode = nonEmpty(p.requestCode);
-  if (requestCode) {
-    const modeResolution = resolveGuardianInstructionModeFromFields(
-      p.requestKind,
-      "toolName" in p ? (p.toolName ?? undefined) : undefined,
-    );
-    const mode = modeResolution?.mode ?? "approval";
-    const instruction = buildGuardianRequestCodeInstruction(
-      requestCode.trim().toUpperCase(),
-      mode,
-    );
-    fallbackText = `${baseFallback}\n\n${instruction}`;
-  }
-
-  return buildApprovalCardBlocks({
-    surfaceIdPrefix: "tool-approval",
-    cardTitle: isGrant ? "Tool Grant Request" : "Tool Approval",
-    requesterName: requester,
-    subtitle: isGrant
-      ? "Requesting permission to use this tool"
-      : "Requesting approval to run this tool",
-    body,
-    metadata,
-    requestId: nonEmpty(p.requestId),
-    fallbackText,
-  });
-}

package/src/runtime/routes/approval-prompt-ts-tracker.ts

@@ -1,78 +0,0 @@
-/**
- * Persistent tracker for approval prompt message timestamps.
- *
- * Scopes guardian reaction approvals so only reactions on a known approval
- * prompt can resolve a pending request. Without this, a stray 👍/✅ on any
- * message in the guardian chat could approve a pending request (since
- * reactions are now admitted from any subscribed channel, not just tracked
- * bot threads).
- *
- * Entries are stored in the `approval_prompt_ts_tracker` table (created by
- * `createApprovalPromptTsTrackerTable`) so that a daemon restart between
- * prompt delivery and guardian reaction does not silently invalidate
- * reactions that are still within the 30-minute guardian approval TTL.
- * Entries expire after `APPROVAL_PROMPT_TS_TTL_MS` (guardian approval TTL
- * plus grace).
- */
-import { getSqlite } from "../../memory/db-connection.js";
-import { getLogger } from "../../util/logger.js";
-
-const log = getLogger("runtime-http");
-
-const APPROVAL_PROMPT_TS_TTL_MS = 35 * 60 * 1000;
-
-// Swallow errors: callers run this inside their delivery try/catch, so a
-// tracker throw would be misread as a delivery failure and trigger
-// fallback/retry, double-posting the guardian prompt.
-export function trackApprovalPromptTs(
-  channel: string,
-  chatId: string,
-  ts: string,
-): void {
-  try {
-    const now = Date.now();
-    const expiresAt = now + APPROVAL_PROMPT_TS_TTL_MS;
-    const db = getSqlite();
-    db.run(
-      /*sql*/ `DELETE FROM approval_prompt_ts_tracker WHERE expires_at <= ?`,
-      [now],
-    );
-    db.run(
-      /*sql*/ `INSERT OR REPLACE INTO approval_prompt_ts_tracker (channel, chat_id, ts, expires_at) VALUES (?, ?, ?, ?)`,
-      [channel, chatId, ts, expiresAt],
-    );
-  } catch (err) {
-    log.error(
-      { err, channel, chatId, ts },
-      "Failed to persist approval prompt ts tracker entry; continuing without tracking",
-    );
-  }
-}
-
-export function isTrackedApprovalPromptTs(
-  channel: string,
-  chatId: string,
-  ts: string,
-): boolean {
-  const now = Date.now();
-  const db = getSqlite();
-  const row = db
-    .query(
-      /*sql*/ `SELECT expires_at FROM approval_prompt_ts_tracker WHERE channel = ? AND chat_id = ? AND ts = ?`,
-    )
-    .get(channel, chatId, ts) as { expires_at: number } | null;
-  if (!row) return false;
-  if (row.expires_at <= now) {
-    db.run(
-      /*sql*/ `DELETE FROM approval_prompt_ts_tracker WHERE channel = ? AND chat_id = ? AND ts = ?`,
-      [channel, chatId, ts],
-    );
-    return false;
-  }
-  return true;
-}
-
-/** @internal Test-only — clear all tracked entries. */
-export function _clearApprovalPromptTsTrackerForTesting(): void {
-  getSqlite().run(/*sql*/ `DELETE FROM approval_prompt_ts_tracker`);
-}

package/src/runtime/routes/identity-intro-cache.ts

@@ -1,172 +0,0 @@
-/**
- * Caching layer for identity greetings.
- *
- * Greetings are sourced from (in priority order):
- * 1. A `## Greetings` section in SOUL.md (user-defined bullet list)
- * 2. A cached greetings array (populated by the empty-state greeting callsite)
- * 3. A generic fallback when generation is unavailable
- *
- * Cache invalidation is intentionally TTL-only. User-authored SOUL.md
- * greetings are read before cache, so manual overrides still take priority
- * without coupling cache validity to prompt-file edits.
- *
- * Storage uses the existing `memory_checkpoints` table (simple key-value store).
- */
-
-import { existsSync, readFileSync } from "node:fs";
-
-import {
-  getMemoryCheckpoint,
-  setMemoryCheckpoint,
-} from "../../memory/checkpoints.js";
-import { getWorkspacePromptPath } from "../../util/platform.js";
-
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-
-const CACHE_TTL_MS = 4 * 60 * 60 * 1000; // 4 hours
-
-const CHECKPOINT_KEY_GREETINGS = "identity:intro:greetings";
-const CHECKPOINT_KEY_TIMESTAMP = "identity:intro:cached_at";
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Read a workspace prompt file, returning empty string if missing. */
-function readWorkspaceFile(name: string): string {
-  try {
-    const path = getWorkspacePromptPath(name);
-    if (!existsSync(path)) return "";
-    return readFileSync(path, "utf-8");
-  } catch {
-    return "";
-  }
-}
-
-function parseIdentityIntroSection(content: string): string | null {
-  let inSection = false;
-
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (/^#+\s/.test(trimmed)) {
-      inSection = trimmed.toLowerCase().includes("identity intro");
-      continue;
-    }
-    if (inSection && trimmed.length > 0) {
-      return trimmed;
-    }
-  }
-
-  return null;
-}
-
-/**
- * Read the explicit `## Identity Intro` section from workspace prompt files.
- *
- * BOOTSTRAP.md instructs the assistant to write this section in IDENTITY.md.
- * SOUL.md remains a fallback for older workspaces that stored the intro there.
- */
-export function readWorkspaceIdentityIntro(): string | null {
-  return (
-    parseIdentityIntroSection(readWorkspaceFile("IDENTITY.md")) ??
-    parseIdentityIntroSection(readWorkspaceFile("SOUL.md"))
-  );
-}
-
-/**
- * Parse the `## Greetings` section from SOUL.md. Returns bullet items as an
- * array of strings, or `null` if the section is missing or empty.
- */
-export function parseGreetingsSection(content: string): string[] | null {
-  let inSection = false;
-  let sectionLevel: number | null = null;
-  const greetings: string[] = [];
-
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    const heading = /^(#{1,6})\s+(.+?)\s*#*$/.exec(trimmed);
-    if (heading) {
-      const level = heading[1]!.length;
-      const title = heading[2]!.trim();
-      if (inSection) {
-        if (sectionLevel !== null && level <= sectionLevel) break;
-        continue;
-      }
-      if (level === 2 && /^greetings$/i.test(title)) {
-        inSection = true;
-        sectionLevel = level;
-      }
-      continue;
-    }
-    if (!inSection) continue;
-    const bullet = /^(?:[-*+]\s+|\d+[.)]\s+)(.+)$/.exec(trimmed);
-    const greeting = bullet?.[1]?.trim();
-    if (greeting) {
-      greetings.push(greeting);
-    }
-  }
-
-  return greetings.length > 0 ? greetings : null;
-}
-
-/**
- * Read user-defined greetings from the `## Greetings` section of SOUL.md.
- */
-export function readWorkspaceGreetings(): string[] | null {
-  const soulContent = readWorkspaceFile("SOUL.md");
-  if (!soulContent) return null;
-  return parseGreetingsSection(soulContent);
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export interface CachedIntro {
-  greetings: string[];
-}
-
-/**
- * Retrieve the cached greetings array if it exists and is within the TTL
- * window.
- *
- * Returns `null` when the cache is missing or expired.
- */
-export function getCachedIntro(): CachedIntro | null {
-  try {
-    const raw = getMemoryCheckpoint(CHECKPOINT_KEY_GREETINGS);
-    const timestampStr = getMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP);
-
-    if (!raw || !timestampStr) return null;
-
-    // TTL check
-    const cachedAt = Number(timestampStr);
-    if (isNaN(cachedAt) || Date.now() - cachedAt > CACHE_TTL_MS) return null;
-
-    // Parse stored value — handles both JSON array and legacy single string
-    let greetings: string[];
-    try {
-      const parsed = JSON.parse(raw);
-      greetings = Array.isArray(parsed) ? parsed : [raw];
-    } catch {
-      greetings = [raw];
-    }
-
-    return { greetings };
-  } catch {
-    return null;
-  }
-}
-
-/** Store a greetings array in the cache along with the current timestamp. */
-export function setCachedIntro(greetings: string[]): void {
-  try {
-    const now = String(Date.now());
-    setMemoryCheckpoint(CHECKPOINT_KEY_GREETINGS, JSON.stringify(greetings));
-    setMemoryCheckpoint(CHECKPOINT_KEY_TIMESTAMP, now);
-  } catch {
-    // Cache write failure is non-fatal — next request will regenerate.
-  }
-}