@vellumai/assistant 0.6.0 → 0.6.1

package/src/daemon/server.ts

@@ -11,6 +11,7 @@ import {
   createAssistantMessage,
   createUserMessage,
 } from "../agent/message-types.js";
+import { compileApp } from "../bundler/app-compiler.js";
 import {
   type ChannelId,
   type InterfaceId,
@@ -22,6 +23,7 @@ import { onContactChange } from "../contacts/contact-events.js";
 import type { CesClient } from "../credential-execution/client.js";
 import type { CesProcessManager } from "../credential-execution/process-manager.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
+import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
 import * as attachmentsStore from "../memory/attachments-store.js";
 import {
   createCanonicalGuardianRequest,
@@ -49,6 +51,7 @@ import { bridgeConfirmationRequestToGuardian } from "../runtime/confirmation-req
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { checkIngressForSecrets } from "../security/secret-ingress.js";
 import { redactSecrets } from "../security/secret-scanner.js";
+import { updatePublishedAppDeployment } from "../services/published-app-updater.js";
 import { registerCancelCallback } from "../signals/cancel.js";
 import { registerConversationUndoCallback } from "../signals/conversation-undo.js";
 import { appendEventToStream } from "../signals/event-stream.js";
@@ -57,10 +60,12 @@ import { getSubagentManager } from "../subagent/index.js";
 import { summarizeToolInput } from "../tools/tool-input-summary.js";
 import { getLogger } from "../util/logger.js";
 import {
+  getAvatarImagePath,
   getSandboxWorkingDir,
   getWorkspacePromptPath,
 } from "../util/platform.js";
 import { registerDaemonCallbacks } from "../work-items/work-item-runner.js";
+import { AppSourceWatcher } from "./app-source-watcher.js";
 import { ConfigWatcher } from "./config-watcher.js";
 import {
   Conversation,
@@ -71,6 +76,7 @@ import { ConversationEvictor } from "./conversation-evictor.js";
 import { formatCompactResult } from "./conversation-process.js";
 import { resolveChannelCapabilities } from "./conversation-runtime-assembly.js";
 import { resolveSlash, type SlashContext } from "./conversation-slash.js";
+import { refreshSurfacesForApp } from "./conversation-surfaces.js";
 import { undoLastMessage } from "./handlers/conversations.js";
 import { parseIdentityFields } from "./handlers/identity.js";
 import type {
@@ -201,13 +207,10 @@ function makePendingInteractionRegistrar(
           guardianPrincipalId: trustContext?.guardianPrincipalId ?? undefined,
           toolName: msg.toolName,
           commandPreview:
-            redactSecrets(
-              summarizeToolInput(msg.toolName, inputRecord),
-            ) || undefined,
+            redactSecrets(summarizeToolInput(msg.toolName, inputRecord)) ||
+            undefined,
           riskLevel: msg.riskLevel,
-          activityText: activityRaw
-            ? redactSecrets(activityRaw)
-            : undefined,
+          activityText: activityRaw ? redactSecrets(activityRaw) : undefined,
           executionTarget: msg.executionTarget,
           status: "pending",
           requestCode: generateCanonicalRequestCode(),
@@ -271,6 +274,7 @@ export class DaemonServer {
 
   // Composed subsystems
   private configWatcher = new ConfigWatcher();
+  private appSourceWatcher = new AppSourceWatcher();
 
   // CES (Credential Execution Service) — process-level singleton.
   // Lifecycle is managed by startCesProcess() in lifecycle.ts; the server
@@ -369,7 +373,28 @@ export class DaemonServer {
       { channelId: transport.channelId },
       "Transport metadata received",
     );
-    conversation.setTransportHints(transport.hints);
+
+    // Build enriched hints: interface ID first, then host environment (macOS
+    // only), then any client-provided hints.
+    const enrichedHints: string[] = [];
+
+    const interfaceLabel = parseInterfaceId(transport.interfaceId) ?? "vellum";
+    enrichedHints.push(`User is messaging from interface: ${interfaceLabel}`);
+
+    if (transport.interfaceId === "macos") {
+      if (transport.hostHomeDir) {
+        enrichedHints.push(`Host home directory: ${transport.hostHomeDir}`);
+      }
+      if (transport.hostUsername) {
+        enrichedHints.push(`Host username: ${transport.hostUsername}`);
+      }
+    }
+
+    if (transport.hints) {
+      enrichedHints.push(...transport.hints);
+    }
+
+    conversation.setTransportHints(enrichedHints);
   }
 
   constructor() {
@@ -523,6 +548,55 @@ export class DaemonServer {
     }
   }
 
+  private broadcastSoundsConfigUpdated(): void {
+    this.broadcast({ type: "sounds_config_updated" });
+  }
+
+  private broadcastAvatarUpdated(): void {
+    this.broadcast({
+      type: "avatar_updated",
+      avatarPath: getAvatarImagePath(),
+    });
+  }
+
+  /**
+   * Handle a detected app source file change from the filesystem watcher.
+   * Recompiles multifile apps and refreshes surfaces across ALL conversations.
+   */
+  private handleAppSourceChange(appId: string): void {
+    const app = getApp(appId);
+    if (!app) return;
+
+    const doRefresh = () => {
+      for (const conversation of this.conversations.values()) {
+        refreshSurfacesForApp(conversation, appId, { fileChange: true });
+      }
+      this.broadcast({ type: "app_files_changed", appId });
+      void updatePublishedAppDeployment(appId);
+    };
+
+    if (isMultifileApp(app)) {
+      const appDir = getAppDirPath(appId);
+      void compileApp(appDir)
+        .then((result) => {
+          if (!result.ok) {
+            log.warn(
+              { appId, errors: result.errors },
+              "Recompile failed on app source change",
+            );
+          }
+          doRefresh();
+        })
+        .catch((err) => {
+          log.warn({ appId, err }, "Recompile threw on app source change");
+          doRefresh();
+        });
+      return;
+    }
+
+    doRefresh();
+  }
+
   // ── Server lifecycle ────────────────────────────────────────────────
 
   async start(): Promise<void> {
@@ -672,8 +746,12 @@ export class DaemonServer {
     this.configWatcher.start(
       () => this.evictConversationsForReload(),
       () => this.broadcastIdentityChanged(),
+      () => this.broadcastSoundsConfigUpdated(),
+      () => this.broadcastAvatarUpdated(),
     );
 
+    this.appSourceWatcher.start((appId) => this.handleAppSourceChange(appId));
+
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
       this.broadcast({ type: "contacts_changed" });
@@ -687,6 +765,7 @@ export class DaemonServer {
     disposeAcpSessionManager();
     this.evictor.stop();
     this.configWatcher.stop();
+    this.appSourceWatcher.stop();
     if (this.unsubscribeContactChange) {
       this.unsubscribeContactChange();
       this.unsubscribeContactChange = null;
@@ -1012,7 +1091,7 @@ export class DaemonServer {
     // Guard: don't replace an active proxy during concurrent turn races —
     // another request may have started processing between the isProcessing()
     // check above and the await on ensureActorScopedHistory().
-    if (resolvedInterface === "macos" || resolvedInterface === "ios") {
+    if (resolvedInterface === "macos") {
       if (!conversation.isProcessing() || !conversation.hostBashProxy) {
         conversation.setHostBashProxy(
           new HostBashProxy(conversation.getCurrentSender(), (requestId) => {
@@ -1369,8 +1448,9 @@ export class DaemonServer {
    */
   async getConversationForMessages(
     conversationId: string,
+    options?: ConversationCreateOptions,
   ): Promise<Conversation> {
-    return this.getOrCreateConversation(conversationId);
+    return this.getOrCreateConversation(conversationId, options);
   }
 
   /**

package/src/daemon/shutdown-handlers.ts

@@ -1,5 +1,6 @@
 import * as Sentry from "@sentry/node";
 
+import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { HookManager } from "../hooks/manager.js";
 import type { McpServerManager } from "../mcp/manager.js";
@@ -7,6 +8,7 @@ import { getSqlite, resetDb } from "../memory/db.js";
 import type { QdrantManager } from "../memory/qdrant-manager.js";
 import type { RuntimeHttpServer } from "../runtime/http-server.js";
 import { browserManager } from "../tools/browser/browser-manager.js";
+import { cleanupShellOutputTempFiles } from "../tools/shared/shell-output.js";
 import { getLogger } from "../util/logger.js";
 import { getEnrichmentService } from "../workspace/commit-message-enrichment-service.js";
 import type { WorkspaceHeartbeatService } from "../workspace/heartbeat-service.js";
@@ -18,6 +20,7 @@ export interface ShutdownDeps {
   server: DaemonServer;
   workspaceHeartbeat: WorkspaceHeartbeatService;
   heartbeat: HeartbeatService;
+  filing: FilingService;
   hookManager: HookManager;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
@@ -51,6 +54,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     await deps.workspaceHeartbeat.stop();
     await deps.heartbeat.stop();
+    await deps.filing.stop();
 
     try {
       await deps.hookManager.trigger("daemon-stop", { pid: process.pid });
@@ -105,6 +109,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     if (deps.runtimeHttp) await deps.runtimeHttp.stop();
     await browserManager.closeAllPages();
+    cleanupShellOutputTempFiles();
     deps.scheduler.stop();
     deps.getMemoryWorker()?.stop();
 

package/src/daemon/tool-side-effects.ts

@@ -158,12 +158,32 @@ registerHook(
   },
 );
 
-// Trigger compilation + surface refresh + broadcast when an app is refreshed.
+// Trigger surface refresh + broadcast when an app is refreshed.
+// If the executor already compiled (multifile path), skip the redundant
+// recompile and just refresh surfaces / broadcast / deploy directly.
 registerHook(
   "app_refresh",
-  (_name, input, _result, { ctx, broadcastToAllClients }) => {
+  (_name, input, result, { ctx, broadcastToAllClients }) => {
     const appId = input.app_id as string | undefined;
-    if (appId) {
+    if (!appId) return;
+
+    // executeAppRefresh already compiled multifile apps and included a
+    // "compiled" field in the result. Skip the expensive recompile and
+    // go straight to surface refresh + broadcast + deploy.
+    let alreadyCompiled = false;
+    try {
+      const parsed = JSON.parse(result.content) as { compiled?: boolean };
+      alreadyCompiled = parsed.compiled !== undefined;
+    } catch {
+      // Result wasn't valid JSON — fall through to handleAppChange.
+    }
+
+    if (alreadyCompiled) {
+      const opts = { fileChange: true };
+      refreshSurfacesForApp(ctx, appId, opts);
+      broadcastToAllClients?.({ type: "app_files_changed", appId });
+      void updatePublishedAppDeployment(appId);
+    } else {
       handleAppChange(ctx, appId, broadcastToAllClients, { fileChange: true });
     }
   },

package/src/export/transcript-formatter.ts

@@ -0,0 +1,148 @@
+/**
+ * Transcript formatter for conversation analysis.
+ *
+ * Builds a markdown transcript of a conversation, including inline
+ * subagent conversation sections when present in message metadata.
+ */
+
+import {
+  getConversation,
+  getMessages,
+  messageMetadataSchema,
+} from "../memory/conversation-crud.js";
+import { truncate } from "../util/truncate.js";
+
+interface ContentBlock {
+  type: string;
+  text?: string;
+  name?: string;
+  input?: Record<string, unknown>;
+  content?: string;
+  tool_use_id?: string;
+  is_error?: boolean;
+  source?: { media_type?: string; filename?: string };
+}
+
+function formatTimestamp(ms: number): string {
+  return new Date(ms).toISOString().replace("T", " ").slice(0, 19);
+}
+
+function extractAnalysisText(blocks: ContentBlock[]): string {
+  const parts: string[] = [];
+  for (const block of blocks) {
+    switch (block.type) {
+      case "text":
+        if (block.text) parts.push(block.text);
+        break;
+      case "tool_use":
+        parts.push(
+          `[Tool: ${block.name}] ${JSON.stringify(block.input ?? {})}`,
+        );
+        break;
+      case "tool_result":
+        if (block.is_error) {
+          parts.push(`[Error: ${block.content ?? ""}]`);
+        } else {
+          parts.push(`[Result: ${truncate(block.content ?? "", 500)}]`);
+        }
+        break;
+      case "server_tool_use":
+        parts.push(`[Web search: ${block.name ?? "web_search"}]`);
+        break;
+      case "web_search_tool_result":
+        parts.push("[Web search results]");
+        break;
+      case "image":
+        parts.push("[Image attachment]");
+        break;
+      case "file":
+        parts.push(`[File: ${block.source?.filename ?? "unknown"}]`);
+        break;
+      case "thinking":
+      case "redacted_thinking":
+        // Skip internal model reasoning blocks
+        break;
+    }
+  }
+  return parts.join("\n");
+}
+
+function formatRole(role: string): string {
+  return role === "user" ? "User" : "Assistant";
+}
+
+function formatSubagentMessages(msgs: ReturnType<typeof getMessages>): string {
+  const lines: string[] = [];
+  for (const msg of msgs) {
+    const role = formatRole(msg.role);
+    const time = formatTimestamp(msg.createdAt);
+    const content = parseContent(msg.content);
+    const text = extractAnalysisText(content);
+    if (text) {
+      lines.push(`> **${role}** (${time})`);
+      for (const line of text.split("\n")) {
+        lines.push(`> ${line}`);
+      }
+      lines.push(">");
+    }
+  }
+  return lines.join("\n");
+}
+
+function parseContent(raw: string): ContentBlock[] {
+  try {
+    return JSON.parse(raw) as ContentBlock[];
+  } catch {
+    return [{ type: "text", text: raw }];
+  }
+}
+
+export function buildAnalysisTranscript(conversationId: string): string {
+  const conversation = getConversation(conversationId);
+  if (!conversation) {
+    return `# Conversation not found: ${conversationId}\n`;
+  }
+
+  const allMessages = getMessages(conversationId);
+  const title = conversation.title ?? "Untitled";
+  const lines: string[] = [];
+
+  lines.push(`# Conversation: ${title}`);
+  lines.push(`Created: ${formatTimestamp(conversation.createdAt)}`);
+  lines.push("");
+
+  for (const msg of allMessages) {
+    const role = formatRole(msg.role);
+    const time = formatTimestamp(msg.createdAt);
+    const content = parseContent(msg.content);
+    const text = extractAnalysisText(content);
+
+    lines.push(`## ${role} (${time})`);
+    lines.push(text);
+    lines.push("");
+
+    // Check for subagent notifications in metadata
+    if (msg.metadata) {
+      try {
+        const parsed = messageMetadataSchema.safeParse(JSON.parse(msg.metadata));
+        if (parsed.success && parsed.data.subagentNotification) {
+          const notif = parsed.data.subagentNotification;
+          if (
+            (notif.status === "completed" || notif.status === "failed" || notif.status === "aborted") &&
+            notif.conversationId
+          ) {
+            const subMessages = getMessages(notif.conversationId);
+            lines.push(`### Subagent: ${notif.label} (${notif.status})`);
+            lines.push("");
+            lines.push(formatSubagentMessages(subMessages));
+            lines.push("");
+          }
+        }
+      } catch {
+        // Skip unparseable metadata
+      }
+    }
+  }
+
+  return lines.join("\n");
+}

package/src/filing/filing-service.ts

@@ -0,0 +1,228 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { getConfig } from "../config/loader.js";
+import type { Speed } from "../config/schemas/inference.js";
+import { bootstrapConversation } from "../memory/conversation-bootstrap.js";
+import { getLogger } from "../util/logger.js";
+import { getWorkspaceDir } from "../util/platform.js";
+import { stripCommentLines } from "../util/strip-comment-lines.js";
+
+const log = getLogger("filing-service");
+
+const FILING_TIMEOUT_MS = 15 * 60 * 1000; // 15 minutes
+
+const FILING_PROMPT_TEMPLATE = `You are running a periodic knowledge base filing job. This is a background maintenance task.
+
+## Part 1: File the buffer
+
+Read \`pkb/buffer.md\`. For each item in the buffer:
+1. Determine which topic file it belongs in. Check \`pkb/INDEX.md\` to see what topic files exist.
+2. Read the target topic file, then append or integrate the new fact.
+3. If the fact is important enough to always be in context, add it to \`pkb/essentials.md\` instead.
+4. If the fact is a commitment, follow-up, or active project, add it to \`pkb/threads.md\`.
+5. If no existing topic file fits, create a new one and update \`pkb/INDEX.md\`.
+
+After all items are filed, clear the processed items from \`pkb/buffer.md\` (leave the file empty, don't delete it).
+
+## Part 2: Nest
+
+Pick 1-2 topic files from your knowledge base and review them:
+- Is the information still accurate and up to date?
+- Are there duplicates that should be consolidated?
+- Is anything important enough to promote to \`pkb/essentials.md\`?
+- Is anything in \`pkb/essentials.md\` that's no longer essential? Demote it to a topic file.
+- Are any threads in \`pkb/threads.md\` completed or stale? Remove them.
+- Is any file getting too long? Consider splitting it.
+- Should any topic file be restructured for clarity?
+
+Make improvements as you see fit. This is your knowledge base — keep it sharp.`;
+
+export interface FilingDeps {
+  processMessage: (
+    conversationId: string,
+    content: string,
+    options?: { speed?: Speed },
+  ) => Promise<{ messageId: string }>;
+  onConversationCreated?: (info: {
+    conversationId: string;
+    title: string;
+  }) => void;
+  getCurrentHour?: () => number;
+}
+
+export class FilingService {
+  private readonly deps: FilingDeps;
+  private timer: ReturnType<typeof setInterval> | null = null;
+  private activeRun: Promise<void> | null = null;
+  private _lastRunAt: number | null = null;
+  private _nextRunAt: number | null = null;
+
+  constructor(deps: FilingDeps) {
+    this.deps = deps;
+  }
+
+  get lastRunAt(): number | null {
+    return this._lastRunAt;
+  }
+
+  get nextRunAt(): number | null {
+    return this._nextRunAt;
+  }
+
+  start(): void {
+    const config = getConfig().filing;
+    if (!config.enabled) {
+      log.info("Filing service disabled by config");
+      this._nextRunAt = null;
+      return;
+    }
+    if (this.timer) return;
+
+    log.info({ intervalMs: config.intervalMs }, "Filing service started");
+    this.scheduleNextRun(config.intervalMs);
+    this.timer = setInterval(() => {
+      this.runOnce().catch((err) => {
+        log.error({ err }, "Filing runOnce failed");
+      });
+    }, config.intervalMs);
+  }
+
+  reconfigure(): void {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this._nextRunAt = null;
+    this.start();
+  }
+
+  async stop(): Promise<void> {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    this._nextRunAt = null;
+    if (this.activeRun) {
+      let timerId: ReturnType<typeof setTimeout>;
+      const timeout = new Promise<void>((resolve) => {
+        timerId = setTimeout(resolve, 5_000);
+      });
+      await Promise.race([this.activeRun, timeout]);
+      clearTimeout(timerId!);
+    }
+    log.info("Filing service stopped");
+  }
+
+  async runOnce({ force = false }: { force?: boolean } = {}): Promise<boolean> {
+    const config = getConfig().filing;
+    if (!force && !config.enabled) return false;
+
+    if (
+      !force &&
+      config.activeHoursStart != null &&
+      config.activeHoursEnd != null
+    ) {
+      const hour = this.deps.getCurrentHour?.() ?? new Date().getHours();
+      if (
+        !isWithinActiveHours(
+          hour,
+          config.activeHoursStart,
+          config.activeHoursEnd,
+        )
+      ) {
+        log.debug("Outside active hours, skipping filing");
+        this.scheduleNextRun(config.intervalMs);
+        return false;
+      }
+    }
+
+    if (this.activeRun) {
+      log.debug("Previous filing run still active, skipping");
+      return false;
+    }
+
+    // Skip if buffer is empty — no work to do
+    if (!force && !this.hasBufferContent()) {
+      log.debug("Buffer is empty, skipping filing");
+      this.scheduleNextRun(config.intervalMs);
+      return false;
+    }
+
+    const run = this.executeRun();
+    this.activeRun = run;
+    try {
+      await Promise.race([
+        run,
+        new Promise<never>((_, reject) =>
+          setTimeout(
+            () => reject(new Error("Filing execution timed out")),
+            FILING_TIMEOUT_MS,
+          ),
+        ),
+      ]);
+    } finally {
+      this.activeRun = null;
+      this._lastRunAt = Date.now();
+      this.scheduleNextRun(getConfig().filing.intervalMs);
+    }
+    return true;
+  }
+
+  private scheduleNextRun(intervalMs: number): void {
+    this._nextRunAt = Date.now() + intervalMs;
+  }
+
+  private hasBufferContent(): boolean {
+    const bufferPath = join(getWorkspaceDir(), "pkb", "buffer.md");
+    if (!existsSync(bufferPath)) return false;
+    try {
+      const content = stripCommentLines(
+        readFileSync(bufferPath, "utf-8"),
+      ).trim();
+      return content.length > 0;
+    } catch {
+      return false;
+    }
+  }
+
+  private async executeRun(): Promise<void> {
+    log.info("Running filing job");
+
+    try {
+      const config = getConfig().filing;
+
+      const conversation = bootstrapConversation({
+        conversationType: "background",
+        source: "filing",
+        groupId: "system:background",
+        origin: "filing",
+        systemHint: "Filing",
+      });
+
+      this.deps.onConversationCreated?.({
+        conversationId: conversation.id,
+        title: "Filing",
+      });
+
+      await this.deps.processMessage(conversation.id, FILING_PROMPT_TEMPLATE, {
+        speed: config.speed,
+      });
+
+      log.info({ conversationId: conversation.id }, "Filing job completed");
+    } catch (err) {
+      log.error({ err }, "Filing job failed");
+    }
+  }
+}
+
+function isWithinActiveHours(
+  hour: number,
+  start: number,
+  end: number,
+): boolean {
+  if (start <= end) {
+    return hour >= start && hour < end;
+  }
+  return hour >= start || hour < end;
+}