@vellumai/assistant 0.6.0 → 0.6.2

package/src/util/platform.ts

@@ -25,16 +25,6 @@ export function getPlatformName(): string {
   return process.platform;
 }
 
-/**
- * Returns the platform-specific clipboard copy command, or null if
- * clipboard access is not supported on the current platform.
- */
-export function getClipboardCommand(): string | null {
-  if (isMacOS()) return "pbcopy";
-  if (isLinux()) return "xclip -selection clipboard";
-  return null;
-}
-
 /**
  * Normalize an assistant ID to its canonical form for DB operations.
  *
@@ -105,13 +95,25 @@ export function getInterfacesDir(): string {
 
 /**
  * Returns the sounds directory (~/.vellum/workspace/data/sounds).
- * Custom sound files and sound configuration live here. Sound files
- * can be large, so this directory is excluded from diagnostic exports.
+ * Custom sound files and sound configuration live here.
  */
 export function getSoundsDir(): string {
   return join(getWorkspaceDir(), "data", "sounds");
 }
 
+/** Returns the avatar directory ($VELLUM_WORKSPACE_DIR/data/avatar). */
+export function getAvatarDir(): string {
+  return join(getWorkspaceDir(), "data", "avatar");
+}
+
+/** Canonical filename for the custom avatar PNG. */
+export const AVATAR_IMAGE_FILENAME = "avatar-image.png";
+
+/** Returns the canonical avatar image path (~/.vellum/workspace/data/avatar/avatar-image.png). */
+export function getAvatarImagePath(): string {
+  return join(getAvatarDir(), AVATAR_IMAGE_FILENAME);
+}
+
 /**
  * Returns the TCP port the daemon should listen on for iOS clients.
  * Hardcoded default: 8765.
@@ -218,7 +220,7 @@ export function getHistoryPath(): string {
  * overrides, device approval lists — live here.
  *
  * This directory is:
- * - Outside the workspace (not included in diagnostic exports)
+ * - Outside the workspace
  * - Outside the sandbox write boundary (tools cannot modify it)
  * - Skipped in containerized mode (credentials via CES, trust via gateway)
  */
@@ -271,10 +273,6 @@ export function getEmbedWorkerPidPath(): string {
  * When the VELLUM_WORKSPACE_DIR env var is set, returns that value (used in
  * containerized deployments where the workspace is a separate volume).
  * Otherwise falls back to ~/.vellum/workspace.
- *
- * WARNING: The entire workspace directory is included in diagnostic log exports
- * ("Send logs to Vellum"). Do not store secrets, API keys, or sensitive
- * credentials here — use the credential store or ~/.vellum/protected/ instead.
  */
 export function getWorkspaceDir(): string {
   const override = getWorkspaceDirOverride();
@@ -315,6 +313,11 @@ export function getWorkspaceHooksDir(): string {
   return join(getWorkspaceDir(), "hooks");
 }
 
+/** Returns $VELLUM_WORKSPACE_DIR/routes — user-defined HTTP route handlers. */
+export function getWorkspaceRoutesDir(): string {
+  return join(getWorkspaceDir(), "routes");
+}
+
 /** Returns ~/.vellum/workspace/deprecated — transitional files slated for removal. */
 export function getDeprecatedDir(): string {
   return join(getWorkspaceDir(), "deprecated");
@@ -330,6 +333,35 @@ export function getWorkspacePromptPath(file: string): string {
   return join(getWorkspaceDir(), file);
 }
 
+// ── Profiler filesystem layout ──────────────────────────────────────────
+// Managed profiler runs live under <workspace>/data/profiler/. These
+// helpers enforce a single canonical layout so every runtime caller
+// resolves the same paths.
+
+/**
+ * Returns the profiler root directory (<workspace>/data/profiler).
+ * All profiler state (runs directory, global metadata) lives here.
+ */
+export function getProfilerRootDir(): string {
+  return join(getDataDir(), "profiler");
+}
+
+/**
+ * Returns the profiler runs directory (<workspace>/data/profiler/runs).
+ * Each completed or active profiler run gets its own sub-directory here.
+ */
+export function getProfilerRunsDir(): string {
+  return join(getProfilerRootDir(), "runs");
+}
+
+/**
+ * Returns the directory for a specific profiler run by ID
+ * (<workspace>/data/profiler/runs/<runId>).
+ */
+export function getProfilerRunDir(runId: string): string {
+  return join(getProfilerRunsDir(), runId);
+}
+
 export function ensureDataDir(): void {
   const root = vellumRoot();
   const workspace = getWorkspaceDir();
@@ -342,6 +374,7 @@ export function ensureDataDir(): void {
     join(workspace, "signals"),
     join(workspace, "hooks"),
     join(workspace, "skills"),
+    join(workspace, "routes"),
     join(workspace, "embedding-models"),
     join(workspace, "conversations"),
     join(workspace, "logs"),

package/src/watcher/provider-types.ts

@@ -28,7 +28,7 @@ export interface WatcherProvider {
   id: string;
   /** Human-readable name. */
   displayName: string;
-  /** Credential service required (e.g. 'integration:google'). */
+  /** Credential service required (e.g. 'google'). */
   requiredCredentialService: string;
 
   /**

package/src/workspace/migrations/023-move-config-files-to-workspace.ts

@@ -3,8 +3,8 @@
  *
  * Previously, dictation-profiles.json, email-guardrails.json, and
  * active-call-leases.json lived directly under getRootDir() (~/.vellum/).
- * This migration moves them into the workspace directory so they are
- * included in diagnostic exports and follow the workspace convention.
+ * This migration moves them into the workspace directory so they follow
+ * the workspace convention for organizational consistency.
  */
 
 import { existsSync, renameSync, unlinkSync } from "node:fs";

package/src/workspace/migrations/024-move-runtime-files-to-workspace.ts

@@ -40,8 +40,8 @@ function getRootDir(): string {
 const FILE_MOVES: Array<{ name: string; subdir?: string }> = [
   { name: "daemon-stderr.log", subdir: "logs" },
   { name: "daemon-startup.lock" },
-  // .env stays at root — it contains secrets (API keys) and the entire
-  // workspace directory is included in diagnostic log exports.
+  // .env stays at root — it contains secrets (API keys) and should not
+  // be in the sandbox working directory.
   { name: "embed-worker.pid" },
 ];
 

package/src/workspace/migrations/028-recover-conversations-from-disk-view.ts

@@ -0,0 +1,270 @@
+/**
+ * Workspace migration 028: Recover conversations from disk-view directories.
+ *
+ * If the SQLite database was recreated empty but the disk-view directories
+ * under `workspace/conversations/` still exist, this migration reads each
+ * conversation's `meta.json` and `messages.jsonl` and re-inserts the rows
+ * into the database.
+ *
+ * Idempotent: conversations already present in the DB are skipped.
+ * Malformed files are skipped with warnings — they do not crash the migration.
+ */
+
+import { randomUUID } from "node:crypto";
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import { join } from "node:path";
+
+import { eq } from "drizzle-orm";
+
+import { getDb } from "../../memory/db.js";
+import { conversations, messages } from "../../memory/schema/conversations.js";
+import { getLogger } from "../../util/logger.js";
+import type { WorkspaceMigration } from "./types.js";
+
+const log = getLogger("workspace-migrations");
+
+interface DiskMeta {
+  id: string;
+  title?: string;
+  type?: string;
+  channel?: string;
+  createdAt?: string;
+  updatedAt?: string;
+}
+
+interface DiskToolCall {
+  name?: string;
+  input?: unknown;
+}
+
+interface DiskToolResult {
+  content?: unknown;
+}
+
+interface DiskMessageRecord {
+  role: string;
+  ts?: string;
+  content?: string;
+  toolCalls?: DiskToolCall[];
+  toolResults?: DiskToolResult[];
+  attachments?: unknown[];
+}
+
+function parseEpochMs(isoString: string | undefined): number | null {
+  if (!isoString) return null;
+  const ms = new Date(isoString).getTime();
+  return Number.isNaN(ms) ? null : ms;
+}
+
+function buildContentBlocks(record: DiskMessageRecord): unknown[] {
+  const blocks: unknown[] = [];
+
+  if (record.content) {
+    blocks.push({ type: "text", text: record.content });
+  }
+
+  if (Array.isArray(record.toolCalls)) {
+    for (const tc of record.toolCalls) {
+      blocks.push({
+        type: "tool_use",
+        id: randomUUID(),
+        name: tc.name ?? "unknown",
+        input: tc.input ?? {},
+      });
+    }
+  }
+
+  if (Array.isArray(record.toolResults)) {
+    for (const tr of record.toolResults) {
+      blocks.push({
+        type: "tool_result",
+        tool_use_id: "",
+        content:
+          typeof tr.content === "string"
+            ? tr.content
+            : JSON.stringify(tr.content),
+      });
+    }
+  }
+
+  // content column is NOT NULL — ensure at least one block
+  if (blocks.length === 0) {
+    blocks.push({ type: "text", text: "" });
+  }
+
+  return blocks;
+}
+
+export const recoverConversationsFromDiskViewMigration: WorkspaceMigration = {
+  id: "028-recover-conversations-from-disk-view",
+  description:
+    "Recover conversations from disk-view directories into the database",
+
+  run(workspaceDir: string): void {
+    const conversationsDir = join(workspaceDir, "conversations");
+    if (!existsSync(conversationsDir)) return;
+
+    const db = getDb();
+
+    let entries: string[];
+    try {
+      entries = readdirSync(conversationsDir);
+    } catch (err) {
+      log.warn(`Failed to read conversations directory: ${err}`);
+      return;
+    }
+
+    let recovered = 0;
+    let skipped = 0;
+    let errors = 0;
+
+    for (const entry of entries) {
+      const dirPath = join(conversationsDir, entry);
+
+      // Skip non-directories
+      try {
+        if (!statSync(dirPath).isDirectory()) {
+          continue;
+        }
+      } catch {
+        continue;
+      }
+
+      // Read and parse meta.json
+      const metaPath = join(dirPath, "meta.json");
+      if (!existsSync(metaPath)) {
+        log.warn(
+          `Skipping ${entry}: missing meta.json`,
+        );
+        skipped++;
+        continue;
+      }
+
+      let meta: DiskMeta;
+      try {
+        meta = JSON.parse(readFileSync(metaPath, "utf-8")) as DiskMeta;
+      } catch (err) {
+        log.warn(
+          `Skipping ${entry}: malformed meta.json: ${err}`,
+        );
+        skipped++;
+        continue;
+      }
+
+      if (!meta.id) {
+        log.warn(
+          `Skipping ${entry}: meta.json missing id`,
+        );
+        skipped++;
+        continue;
+      }
+
+      // Check if conversation already exists in DB (idempotency)
+      const existing = db
+        .select()
+        .from(conversations)
+        .where(eq(conversations.id, meta.id))
+        .get();
+
+      if (existing) {
+        skipped++;
+        continue;
+      }
+
+      // Parse messages.jsonl
+      const messagesPath = join(dirPath, "messages.jsonl");
+      const messageRecords: DiskMessageRecord[] = [];
+
+      if (existsSync(messagesPath)) {
+        try {
+          const raw = readFileSync(messagesPath, "utf-8");
+          for (const line of raw.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed) continue;
+            try {
+              messageRecords.push(
+                JSON.parse(trimmed) as DiskMessageRecord,
+              );
+            } catch {
+              log.warn(
+                `Skipping malformed JSONL line in ${entry}/messages.jsonl`,
+              );
+            }
+          }
+        } catch (err) {
+          log.warn(
+            `Failed to read messages.jsonl for ${entry}: ${err}`,
+          );
+        }
+      }
+
+      // Compute timestamps
+      const createdAt = parseEpochMs(meta.createdAt) ?? Date.now();
+      const updatedAt = parseEpochMs(meta.updatedAt) ?? createdAt;
+
+      // Insert conversation + messages in a transaction
+      try {
+        db.transaction((tx) => {
+          tx.insert(conversations)
+            .values({
+              id: meta.id,
+              title: meta.title ?? null,
+              createdAt,
+              updatedAt,
+              conversationType: meta.type ?? "standard",
+              originChannel: meta.channel ?? null,
+              source: "user",
+              memoryScopeId: "default",
+              isAutoTitle: 1,
+              totalInputTokens: 0,
+              totalOutputTokens: 0,
+              totalEstimatedCost: 0,
+              contextSummary: null,
+              contextCompactedMessageCount: 0,
+              contextCompactedAt: null,
+              originInterface: null,
+              forkParentConversationId: null,
+              forkParentMessageId: null,
+              scheduleJobId: null,
+            })
+            .run();
+
+          for (const record of messageRecords) {
+            const contentBlocks = buildContentBlocks(record);
+            const msgCreatedAt =
+              parseEpochMs(record.ts) ?? createdAt;
+
+            tx.insert(messages)
+              .values({
+                id: randomUUID(),
+                conversationId: meta.id,
+                role: record.role,
+                content: JSON.stringify(contentBlocks),
+                createdAt: msgCreatedAt,
+                metadata: null,
+              })
+              .run();
+          }
+        });
+
+        recovered++;
+      } catch (err) {
+        log.warn(
+          `Failed to insert conversation ${meta.id} (${entry}): ${err}`,
+        );
+        errors++;
+      }
+    }
+
+    if (recovered > 0 || errors > 0) {
+      log.info(
+        `Recover conversations from disk-view: recovered=${recovered}, skipped=${skipped}, errors=${errors}`,
+      );
+    }
+  },
+
+  // No-op: deleting recovered conversation data from the database would cause
+  // data loss — the disk-view files are the only remaining copy after the
+  // original DB was lost.
+  down(_workspaceDir: string): void {},
+};

package/src/workspace/migrations/029-seed-pkb.ts

@@ -0,0 +1,85 @@
+import { existsSync, mkdirSync, rmdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const INDEX_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the injected context
+
+# Knowledge Base
+
+**Remember aggressively.** When you learn ANY fact — a preference, a name, a date, a habit, a plan, an opinion — call \`remember\` immediately. Don't filter, don't judge importance. Remembering too much costs nothing. Forgetting something that mattered costs trust.
+
+## Always Loaded
+- essentials.md — Core facts, patterns, and biographical info
+- threads.md — Active commitments, follow-ups, and projects in progress
+- buffer.md — Inbox of recently learned facts (filed periodically)
+
+
+## Topics
+`;
+
+const ESSENTIALS_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the injected context
+
+# Essentials
+
+_ The most important facts — things you'd be embarrassed to forget.
+_ This file is always loaded into every conversation. Keep it focused.
+_ Promote facts here from topic files when they come up constantly.
+_ Demote facts to topic files when they stop being essential.
+`;
+
+const THREADS_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the injected context
+
+# Active Threads
+
+_ Commitments, follow-ups, and projects in progress.
+_ This file is always loaded into every conversation.
+_ Remove items when they're completed or no longer relevant.
+`;
+
+export const seedPkbMigration: WorkspaceMigration = {
+  id: "029-seed-pkb",
+  description: "Create pkb/ knowledge base directory with seed files",
+
+  down(workspaceDir: string): void {
+    // Best-effort: only remove empty directories. Never delete user content.
+    const pkbDir = join(workspaceDir, "pkb");
+    if (!existsSync(pkbDir)) return;
+
+    try {
+      // Try removing subdirectories first, then the root. rmdirSync fails
+      // on non-empty directories, which is exactly what we want.
+      for (const sub of ["archive"]) {
+        try {
+          rmdirSync(join(pkbDir, sub));
+        } catch {
+          // Non-empty or doesn't exist — skip
+        }
+      }
+      rmdirSync(pkbDir);
+    } catch {
+      // Non-empty — leave it alone
+    }
+  },
+
+  run(workspaceDir: string): void {
+    const pkbDir = join(workspaceDir, "pkb");
+    mkdirSync(pkbDir, { recursive: true });
+    mkdirSync(join(pkbDir, "archive"), { recursive: true });
+
+    // Seed files only if they don't already exist (idempotent)
+    const seeds: Array<[string, string]> = [
+      ["INDEX.md", INDEX_TEMPLATE],
+      ["essentials.md", ESSENTIALS_TEMPLATE],
+      ["threads.md", THREADS_TEMPLATE],
+      ["buffer.md", ""],
+    ];
+
+    for (const [filename, content] of seeds) {
+      const filePath = join(pkbDir, filename);
+      if (!existsSync(filePath)) {
+        writeFileSync(filePath, content, "utf-8");
+      }
+    }
+  },
+};

package/src/workspace/migrations/030-seed-pkb-autoinject.ts

@@ -0,0 +1,73 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+import type { WorkspaceMigration } from "./types.js";
+
+const AUTOINJECT_TEMPLATE = `_ Lines starting with _ are comments - they won't appear in the injected context
+_ List one PKB filename per line. These files are loaded into every conversation.
+_ Remove a line to stop autoinjecting that file. Add new filenames to inject more.
+
+INDEX.md
+essentials.md
+threads.md
+buffer.md
+`;
+
+const INDEX_ENTRY = "- _autoinject.md — Controls which files are loaded into every conversation";
+
+export const seedPkbAutoinjectMigration: WorkspaceMigration = {
+  id: "030-seed-pkb-autoinject",
+  description: "Seed pkb/_autoinject.md for configurable PKB autoinjection",
+
+  run(workspaceDir: string): void {
+    const pkbDir = join(workspaceDir, "pkb");
+    if (!existsSync(pkbDir)) return;
+
+    // Seed _autoinject.md if it doesn't already exist
+    const autoinjectPath = join(pkbDir, "_autoinject.md");
+    if (!existsSync(autoinjectPath)) {
+      writeFileSync(autoinjectPath, AUTOINJECT_TEMPLATE, "utf-8");
+    }
+
+    // Append _autoinject.md entry to INDEX.md if not already present
+    const indexPath = join(pkbDir, "INDEX.md");
+    if (existsSync(indexPath)) {
+      try {
+        const indexContent = readFileSync(indexPath, "utf-8");
+        if (!indexContent.includes("_autoinject.md")) {
+          // Insert after the last "Always Loaded" entry (buffer.md line)
+          const bufferLine = "- buffer.md";
+          const bufferIdx = indexContent.indexOf(bufferLine);
+          if (bufferIdx !== -1) {
+            const endOfBufferLine = indexContent.indexOf("\n", bufferIdx);
+            const insertAt =
+              endOfBufferLine === -1 ? indexContent.length : endOfBufferLine;
+            const updated =
+              indexContent.slice(0, insertAt) +
+              "\n" +
+              INDEX_ENTRY +
+              indexContent.slice(insertAt);
+            writeFileSync(indexPath, updated, "utf-8");
+          }
+        }
+      } catch {
+        // INDEX.md unreadable — skip
+      }
+    }
+  },
+
+  down(workspaceDir: string): void {
+    const autoinjectPath = join(workspaceDir, "pkb", "_autoinject.md");
+    if (!existsSync(autoinjectPath)) return;
+
+    try {
+      const content = readFileSync(autoinjectPath, "utf-8");
+      // Only delete if content matches the template (preserve user edits)
+      if (content === AUTOINJECT_TEMPLATE) {
+        unlinkSync(autoinjectPath);
+      }
+    } catch {
+      // Unreadable — leave it alone
+    }
+  },
+};

package/src/workspace/migrations/registry.ts

@@ -24,6 +24,9 @@ import { moveRuntimeFilesToWorkspaceMigration } from "./024-move-runtime-files-t
 import { removeOauthAppSetupSkillsMigration } from "./025-remove-oauth-app-setup-skills.js";
 import { backfillInstallMetaMigration } from "./026-backfill-install-meta.js";
 import { removeOrphanedOptimizedImagesCacheMigration } from "./027-remove-orphaned-optimized-images-cache.js";
+import { recoverConversationsFromDiskViewMigration } from "./028-recover-conversations-from-disk-view.js";
+import { seedPkbMigration } from "./029-seed-pkb.js";
+import { seedPkbAutoinjectMigration } from "./030-seed-pkb-autoinject.js";
 import { migrateToWorkspaceVolumeMigration } from "./migrate-to-workspace-volume.js";
 import type { WorkspaceMigration } from "./types.js";
 
@@ -59,4 +62,7 @@ export const WORKSPACE_MIGRATIONS: WorkspaceMigration[] = [
   removeOauthAppSetupSkillsMigration,
   backfillInstallMetaMigration,
   removeOrphanedOptimizedImagesCacheMigration,
+  recoverConversationsFromDiskViewMigration,
+  seedPkbMigration,
+  seedPkbAutoinjectMigration,
 ];

package/src/workspace/top-level-renderer.ts

@@ -1,8 +1,7 @@
 import type { TopLevelSnapshot } from "./top-level-scanner.js";
 
 export interface WorkspaceTopLevelRenderOptions {
-  currentConversationPath?: string | null;
-  currentConversationAttachmentsPath?: string | null;
+  conversationAttachmentsPath?: string | null;
 }
 
 /**
@@ -15,19 +14,16 @@ export function renderWorkspaceTopLevelContext(
   snapshot: TopLevelSnapshot,
   options: WorkspaceTopLevelRenderOptions = {},
 ): string {
-  const lines: string[] = ["<workspace_top_level>"];
+  const lines: string[] = ["<workspace>"];
   lines.push(`Root: ${snapshot.rootPath}`);
   lines.push(`Directories: ${snapshot.directories.join(", ")}`);
   lines.push(`Files: ${snapshot.files.join(", ")}`);
-  if (options.currentConversationPath) {
-    lines.push(`Current conversation folder: ${options.currentConversationPath}`);
-  }
-  if (options.currentConversationAttachmentsPath) {
-    lines.push(`Attachment files: ${options.currentConversationAttachmentsPath}`);
+  if (options.conversationAttachmentsPath) {
+    lines.push(`Current conversation attachments: ${options.conversationAttachmentsPath}`);
   }
   if (snapshot.truncated) {
     lines.push("(list truncated — more entries exist)");
   }
-  lines.push("</workspace_top_level>");
+  lines.push("</workspace>");
   return lines.join("\n");
 }