@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/workspace-migration-064-unwind-main-agent-opus-seed.test.ts

@@ -0,0 +1,225 @@
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { unwindMainAgentOpusSeedMigration } from "../workspace/migrations/064-unwind-main-agent-opus-seed.js";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-064-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  rmSync(workspaceDir, { recursive: true, force: true });
+});
+
+describe("064-unwind-main-agent-opus-seed migration", () => {
+  test("has correct migration id", () => {
+    expect(unwindMainAgentOpusSeedMigration.id).toBe(
+      "064-unwind-main-agent-opus-seed",
+    );
+  });
+
+  test("removes exact seeded mainAgent override and sets balanced when activeProfile is missing", () => {
+    writeConfig({
+      llm: {
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        activeProfile: string;
+        callSites: Record<string, unknown>;
+      };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toBeUndefined();
+  });
+
+  test("preserves balanced activeProfile (set by migration 052) while removing seed", () => {
+    // migration 052 sets activeProfile="balanced" before 064 runs; 064 must
+    // not override it — balanced is the intentional default, not a signal
+    // that the user wants the Opus quality tier.
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toBeUndefined();
+  });
+
+  test("preserves custom activeProfile while removing the stale seed", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "gpt-5-5",
+        callSites: {
+          mainAgent: { model: "claude-opus-4-7", maxTokens: 32000 },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("gpt-5-5");
+    expect(config.llm.callSites.mainAgent).toBeUndefined();
+  });
+
+  test("removes only seeded model and maxTokens when user fields are present, preserves balanced", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: {
+          mainAgent: {
+            model: "claude-opus-4-7",
+            maxTokens: 32000,
+            effort: "low",
+            thinking: { enabled: false },
+          },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: {
+        activeProfile: string;
+        callSites: Record<string, Record<string, unknown>>;
+      };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual({
+      effort: "low",
+      thinking: { enabled: false },
+    });
+  });
+
+  test("does not mutate mainAgent entries with explicit provider", () => {
+    const mainAgent = {
+      provider: "anthropic",
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    };
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: { mainAgent },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual(mainAgent);
+  });
+
+  test("does not mutate mainAgent entries with explicit profile", () => {
+    const mainAgent = {
+      profile: "quality-optimized",
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    };
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: { mainAgent },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual(mainAgent);
+  });
+
+  test("does not mutate explicit user pins with different maxTokens", () => {
+    const mainAgent = {
+      model: "claude-opus-4-7",
+      maxTokens: 64000,
+    };
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: { mainAgent },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.mainAgent).toEqual(mainAgent);
+  });
+
+  test("does not mutate non-main-agent call sites", () => {
+    writeConfig({
+      llm: {
+        activeProfile: "balanced",
+        callSites: {
+          interactionClassifier: {
+            model: "claude-opus-4-7",
+            maxTokens: 32000,
+          },
+        },
+      },
+    });
+
+    unwindMainAgentOpusSeedMigration.run(workspaceDir);
+
+    const config = readConfig() as {
+      llm: { activeProfile: string; callSites: Record<string, unknown> };
+    };
+    expect(config.llm.activeProfile).toBe("balanced");
+    expect(config.llm.callSites.interactionClassifier).toEqual({
+      model: "claude-opus-4-7",
+      maxTokens: 32000,
+    });
+  });
+});

package/src/__tests__/workspace-migration-memory-v2-init.test.ts

@@ -3,9 +3,10 @@
  *
  * The migration seeds the `memory/` directory tree used by the v2 memory
  * subsystem: `memory/`, `memory/concepts/`, `memory/archive/`,
- * `memory/.v2-state/`, plus an empty `edges.json` and the four prose files
- * (`essentials.md`, `threads.md`, `recent.md`, `buffer.md`). It must be
- * idempotent and must not touch existing files.
+ * `memory/.v2-state/`, plus the four prose files (`essentials.md`,
+ * `threads.md`, `recent.md`, `buffer.md`). It must be idempotent and must
+ * not touch existing files. Outgoing edges live directly in concept-page
+ * frontmatter — there is no separate edges-index file to seed.
  */
 
 import {
@@ -90,11 +91,9 @@ describe("060-memory-v2-init migration", () => {
     expect(statSync(join(memoryDir, "archive")).isDirectory()).toBe(true);
     expect(statSync(join(memoryDir, ".v2-state")).isDirectory()).toBe(true);
 
-    // edges.json is seeded with the canonical empty index.
-    const edgesPath = join(memoryDir, "edges.json");
-    expect(existsSync(edgesPath)).toBe(true);
-    const edges = JSON.parse(readFileSync(edgesPath, "utf-8"));
-    expect(edges).toEqual({ version: 1, edges: [] });
+    // No edges-index file is seeded — outgoing edges live in concept-page
+    // frontmatter under the directed-edges model.
+    expect(existsSync(join(memoryDir, "edges.json"))).toBe(false);
 
     // Each prose file is created and empty.
     for (const filename of [
@@ -126,26 +125,6 @@ describe("060-memory-v2-init migration", () => {
     }
   });
 
-  test("preserves an existing edges.json with prior content", () => {
-    const memoryDir = join(workspaceDir, "memory");
-    mkdirSync(memoryDir, { recursive: true });
-
-    const customEdges = {
-      version: 1,
-      edges: [
-        ["alice-preferences", "bob-handoff"],
-        ["bob-handoff", "team-rituals"],
-      ],
-    };
-    const edgesPath = join(memoryDir, "edges.json");
-    writeFileSync(edgesPath, JSON.stringify(customEdges, null, 2), "utf-8");
-
-    memoryV2InitMigration.run(workspaceDir);
-
-    const reread = JSON.parse(readFileSync(edgesPath, "utf-8"));
-    expect(reread).toEqual(customEdges);
-  });
-
   test("preserves existing prose files with content", () => {
     const memoryDir = join(workspaceDir, "memory");
     mkdirSync(memoryDir, { recursive: true });
@@ -247,8 +226,7 @@ describe("060-memory-v2-init migration", () => {
       // .v2-state/ is gone.
       expect(existsSync(join(memoryDir, ".v2-state"))).toBe(false);
 
-      // Prose files and edges.json remain.
-      expect(existsSync(join(memoryDir, "edges.json"))).toBe(true);
+      // Prose files remain.
       expect(existsSync(join(memoryDir, "essentials.md"))).toBe(true);
       expect(existsSync(join(memoryDir, "threads.md"))).toBe(true);
       expect(existsSync(join(memoryDir, "recent.md"))).toBe(true);

package/src/acp/index.ts

@@ -1,8 +1,6 @@
-export { AcpSessionManager } from "./session-manager.js";
 export type { AcpAgentConfig, AcpSessionState } from "./types.js";
 
 import { getConfig } from "../config/loader.js";
-import type { ServerMessage } from "../daemon/message-protocol.js";
 import { AcpSessionManager } from "./session-manager.js";
 
 /** Singleton AcpSessionManager instance shared across the daemon. */
@@ -29,16 +27,3 @@ export function disposeAcpSessionManager(): void {
     manager = null;
   }
 }
-
-/**
- * Broadcast callback set by DaemonServer constructor so ACP session events
- * reach all connected SSE clients. Same pattern as
- * `getSubagentManager().broadcastToAllClients` in server.ts.
- */
-export let broadcastToAllClients: ((msg: ServerMessage) => void) | null = null;
-
-export function setBroadcastToAllClients(
-  fn: (msg: ServerMessage) => void,
-): void {
-  broadcastToAllClients = fn;
-}

package/src/acp/session-manager.ts

@@ -7,6 +7,7 @@ import { randomUUID } from "node:crypto";
 
 import { inArray } from "drizzle-orm";
 
+import { findConversation } from "../daemon/conversation-store.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { AcpSessionUpdate } from "../daemon/message-types/acp.js";
 import { getDb } from "../memory/db-connection.js";
@@ -55,19 +56,6 @@ export class AcpSessionManager {
    */
   private eventBuffers = new Map<string, BufferedAcpUpdate[]>();
 
-  /**
-   * Optional callback to inject a completion/failure message into the parent
-   * conversation so the LLM sees the agent's output.
-   * Wired by DaemonServer at startup.
-   */
-  onAcpSessionFinished:
-    | ((
-        parentConversationId: string,
-        message: string,
-        sendToClient: (msg: ServerMessage) => void,
-      ) => Promise<void>)
-    | null = null;
-
   constructor(private readonly maxConcurrent: number) {
     this.cleanupStaleRunningRows();
   }
@@ -446,28 +434,43 @@ export class AcpSessionManager {
           this.teardownSession(acpSessionId, current);
 
           // Notify parent session so the LLM sees the agent's output
-          if (this.onAcpSessionFinished) {
-            const agentLabel = current.state.agentId;
-            const responseText = current.clientHandler.responseText;
-            const sessionId = current.state.acpSessionId;
-            // `claude --resume <id>` is Claude Code-specific (the
-            // claude-agent-acp adapter binary). Other adapters resume
-            // differently or not at all, so the hint is gated.
-            const resumeHint =
-              current.command === "claude-agent-acp"
-                ? `\n\nTo resume: cd ${current.cwd} && claude --resume ${sessionId}`
-                : "";
-            const notifyMessage = `[ACP agent "${agentLabel}" completed]\n\n${responseText}${resumeHint}`;
-            this.onAcpSessionFinished(
-              current.parentConversationId,
+          const agentLabel = current.state.agentId;
+          const responseText = current.clientHandler.responseText;
+          const sessionId = current.state.acpSessionId;
+          const resumeHint =
+            current.command === "claude-agent-acp"
+              ? `\n\nTo resume: cd ${current.cwd} && claude --resume ${sessionId}`
+              : "";
+          const notifyMessage = `[ACP agent "${agentLabel}" completed]\n\n${responseText}${resumeHint}`;
+          const parentConversation = findConversation(
+            current.parentConversationId,
+          );
+          if (parentConversation) {
+            const enqueueResult = parentConversation.enqueueMessage(
               notifyMessage,
-              current.sendToVellum,
-            ).catch((notifyErr) => {
-              log.error(
-                { acpSessionId, notifyErr },
-                "Failed to notify parent of ACP completion",
-              );
-            });
+              [],
+            );
+            if (!enqueueResult.queued && !enqueueResult.rejected) {
+              parentConversation
+                .persistUserMessage(notifyMessage, [])
+                .then((messageId) =>
+                  parentConversation.runAgentLoop(notifyMessage, messageId),
+                )
+                .catch((err) => {
+                  log.error(
+                    {
+                      parentConversationId: current.parentConversationId,
+                      err,
+                    },
+                    "Failed to process ACP notification in parent",
+                  );
+                });
+            }
+          } else {
+            log.warn(
+              { parentConversationId: current.parentConversationId },
+              "ACP agent finished but parent conversation not found",
+            );
           }
         }
       })

package/src/agent/loop.ts

@@ -93,9 +93,13 @@ export type AgentEvent =
       contentBlocks?: ContentBlock[];
       riskLevel?: string;
       riskReason?: string;
+      matchedTrustRuleId?: string;
       isContainerized?: boolean;
       riskScopeOptions?: Array<{ pattern: string; label: string }>;
       riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
+      approvalMode?: string;
+      approvalReason?: string;
+      riskThreshold?: string;
     }
   | { type: "tool_use_preview_start"; toolUseId: string; toolName: string }
   | {
@@ -275,9 +279,13 @@ export type LoopToolExecutor = (
   yieldToUser?: boolean;
   riskLevel?: string;
   riskReason?: string;
+  matchedTrustRuleId?: string;
   isContainerized?: boolean;
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
   riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
+  approvalMode?: string;
+  approvalReason?: string;
+  riskThreshold?: string;
 }>;
 
 export class AgentLoop {
@@ -364,6 +372,7 @@ export class AgentLoop {
      * default for the lifetime of an agent loop run.
      */
     overrideProfile?: string,
+    effectiveMaxInputTokens?: number,
   ): Promise<Message[]> {
     const history = [...messages];
     const initialHistoryLength = messages.length;
@@ -462,6 +471,7 @@ export class AgentLoop {
         // analyze, etc.) pass their own `callSite`.
         if (callSite) {
           providerConfig.callSite = callSite;
+          providerConfig.usageTracking = "manual";
         }
 
         // Per-call inference-profile override. The resolver layers
@@ -919,7 +929,8 @@ export class AgentLoop {
         // plugin pipeline so downstream plugins can swap in a smarter
         // truncation strategy (e.g. a summariser) while the default
         // middleware preserves the historical tail-drop behaviour.
-        const contextWindowTokens = this.config.maxInputTokens ?? 180_000;
+        const contextWindowTokens =
+          effectiveMaxInputTokens ?? this.config.maxInputTokens ?? 180_000;
         const maxChars = calculateMaxToolResultChars(contextWindowTokens);
         const truncateMiddlewares = getMiddlewaresFor("toolResultTruncate");
 
@@ -987,9 +998,13 @@ export class AgentLoop {
             contentBlocks: result.contentBlocks,
             riskLevel: result.riskLevel,
             riskReason: result.riskReason,
+            matchedTrustRuleId: result.matchedTrustRuleId,
             isContainerized: result.isContainerized,
             riskScopeOptions: result.riskScopeOptions,
             riskDirectoryScopeOptions: result.riskDirectoryScopeOptions,
+            approvalMode: result.approvalMode,
+            approvalReason: result.approvalReason,
+            riskThreshold: result.riskThreshold,
           });
         }
 

package/src/approvals/AGENTS.md

@@ -8,6 +8,10 @@
 - **Requester self-cancel:** A requester with a pending guardian approval must be able to cancel their own request (but not self-approve).
 - **Unified guardian decision primitive:** All guardian decision paths (callback buttons, conversational engine, requester self-cancel) must route through `applyGuardianDecision()` in `assistant/src/approvals/guardian-decision-primitive.ts`. Do not inline decision logic (approval record updates, grant minting) at individual callsites.
 
+## Single-Guardian Invariant
+
+Each assistant instance serves exactly one guardian. Multi-guardian is not supported and will never be. All connections, browser sessions, approval channels, and trust contexts within a single assistant process belong to the same guardian principal. Do not introduce guardian-keyed maps, per-guardian routing logic, or multi-guardian multiplexing — they add complexity without a real use case and create the false impression that cross-guardian isolation is required.
+
 ## Guardian Verification Invariant
 
 Guardian verification consumption must be identity-bound to the expected recipient identity. Every outbound verification session stores the expected identity (phone E.164, Telegram user/chat ID), and the consume path rejects attempts where the responding actor's identity does not match.

package/src/approvals/__tests__/guardian-feed-event.test.ts

@@ -88,6 +88,11 @@ mock.module("../../runtime/gateway-client.js", () => ({
   deliverChannelReply: async () => {},
 }));
 
+let _mockConversation: Record<string, unknown> | null = null;
+mock.module("../../daemon/conversation-store.js", () => ({
+  findConversation: () => _mockConversation,
+}));
+
 // Stub pending-interactions so tool_approval resolver can find/resolve.
 let mockInteraction: Record<string, unknown> | null = null;
 let mockResolved: Record<string, unknown> | null = null;
@@ -155,16 +160,18 @@ describe("guardian approval feed events", () => {
     mockInteraction = {
       confirmationDetails: { toolName: "web_fetch" },
     };
+    _mockConversation = {
+      handleConfirmationResponse: () => {},
+    };
     mockResolved = {
-      conversation: {
-        handleConfirmationResponse: () => {},
-      },
+      conversationId: "conv-test",
     };
   });
 
   afterEach(() => {
     mockInteraction = null;
     mockResolved = null;
+    _mockConversation = null;
   });
 
   // -----------------------------------------------------------------------

package/src/approvals/guardian-request-resolvers.ts

@@ -14,6 +14,7 @@
 import { answerCall } from "../calls/call-domain.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
+import { findConversation } from "../daemon/conversation-store.js";
 import { emitFeedEvent } from "../home/emit-feed-event.js";
 import {
   type CanonicalGuardianRequest,
@@ -203,7 +204,14 @@ const pendingInteractionResolver: GuardianRequestResolver = {
     // Map action to the permission system's UserDecision type and notify session.
     const userDecision: UserDecision =
       decision.action === "reject" ? "deny" : "allow";
-    resolved.conversation!.handleConfirmationResponse(
+    const conversation = findConversation(resolved.conversationId);
+    if (!conversation) {
+      return {
+        ok: false,
+        reason: `conversation_not_found: ${resolved.conversationId}`,
+      };
+    }
+    conversation.handleConfirmationResponse(
       request.id,
       userDecision,
       undefined,
@@ -982,7 +990,7 @@ const toolGrantRequestResolver: GuardianRequestResolver = {
 const resolverRegistry = new Map<string, GuardianRequestResolver>();
 
 /** Register a resolver for a given request kind. */
-export function registerResolver(resolver: GuardianRequestResolver): void {
+function registerResolver(resolver: GuardianRequestResolver): void {
   resolverRegistry.set(resolver.kind, resolver);
 }
 

package/src/backup/__tests__/backup-worker.test.ts

@@ -115,12 +115,23 @@ function makeStreamExportStub(): {
       tempPath,
       size: 16,
       manifest: {
-        schema_version: "1.0",
+        schema_version: 1,
+        bundle_id: "00000000-0000-4000-8000-000000000000",
         created_at: new Date().toISOString(),
-        source: "test",
-        description: "test stub",
-        files: [],
-        manifest_sha256: "0".repeat(64),
+        assistant: { id: "self", name: "Test", runtime_version: "0.0.0-test" },
+        origin: { mode: "self-hosted-local" },
+        compatibility: {
+          min_runtime_version: "0.0.0-test",
+          max_runtime_version: null,
+        },
+        contents: [],
+        checksum: "0".repeat(64),
+        secrets_redacted: false,
+        export_options: {
+          include_logs: false,
+          include_browser_state: false,
+          include_memory_vectors: false,
+        },
       },
       cleanup: async () => {
         try {
@@ -539,10 +550,27 @@ describe("createSnapshotNow", () => {
         tempPath,
         size: 7,
         manifest: {
-          schema_version: "1.0",
+          schema_version: 1,
+          bundle_id: "00000000-0000-4000-8000-000000000000",
           created_at: new Date().toISOString(),
-          files: [],
-          manifest_sha256: "0".repeat(64),
+          assistant: {
+            id: "self",
+            name: "Test",
+            runtime_version: "0.0.0-test",
+          },
+          origin: { mode: "self-hosted-local" },
+          compatibility: {
+            min_runtime_version: "0.0.0-test",
+            max_runtime_version: null,
+          },
+          contents: [],
+          checksum: "0".repeat(64),
+          secrets_redacted: false,
+          export_options: {
+            include_logs: false,
+            include_browser_state: false,
+            include_memory_vectors: false,
+          },
         },
         cleanup: async () => {
           try {

package/src/backup/__tests__/paths.test.ts

@@ -173,9 +173,9 @@ describe("getBackupKeyPath", () => {
     }
   });
 
-  test("ends with /protected/backup.key when env var is unset", () => {
+  test("ends with /.backup.key when env var is unset", () => {
     delete process.env.VELLUM_BACKUP_KEY_PATH;
-    expect(getBackupKeyPath().endsWith("/protected/backup.key")).toBe(true);
+    expect(getBackupKeyPath().endsWith("/.backup.key")).toBe(true);
   });
 
   test("returns the env var override when VELLUM_BACKUP_KEY_PATH is set", () => {