@vellumai/assistant 0.6.6 → 0.7.0

package/src/acp/session-manager.ts

@@ -5,7 +5,12 @@
 
 import { randomUUID } from "node:crypto";
 
+import { inArray } from "drizzle-orm";
+
 import type { ServerMessage } from "../daemon/message-protocol.js";
+import type { AcpSessionUpdate } from "../daemon/message-types/acp.js";
+import { getDb } from "../memory/db-connection.js";
+import { acpSessionHistory } from "../memory/schema.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 import { getLogger } from "../util/logger.js";
 import { AcpAgentProcess } from "./agent-process.js";
@@ -14,18 +19,41 @@ import type { AcpAgentConfig, AcpSessionState } from "./types.js";
 
 const log = getLogger("acp:session-manager");
 
+/** Maximum number of update events kept in a session's ring buffer. */
+const MAX_BUFFER_EVENTS = 200;
+/** Maximum aggregate JSON size of a session's ring buffer, in bytes. */
+const MAX_BUFFER_BYTES = 256 * 1024;
+
+interface BufferedAcpUpdate {
+  /** The wire-shaped update — exactly what was forwarded to clients. */
+  update: AcpSessionUpdate;
+  /** Cached UTF-8 byte length of `JSON.stringify(update)` for cap math. */
+  byteSize: number;
+}
+
 interface SessionEntry {
   process: AcpAgentProcess;
   state: AcpSessionState;
   clientHandler: VellumAcpClientHandler;
+  /** Wrapped sender that also appends to the ring buffer. */
   sendToVellum: (msg: ServerMessage) => void;
   currentPrompt: Promise<unknown> | null;
   parentConversationId: string;
   cwd: string;
+  /** The adapter binary that was spawned. Used to gate resume hints to
+   *  the only adapter (claude-agent-acp) whose CLI accepts `--resume`. */
+  command: string;
 }
 
 export class AcpSessionManager {
   private sessions = new Map<string, SessionEntry>();
+  /**
+   * Per-session ring buffer of wire-shaped update events forwarded to
+   * clients. Bounded by event count and aggregate JSON byte size; oldest
+   * events are dropped first when caps are exceeded. Persisted to
+   * `acp_session_history` on terminal transition, then cleared.
+   */
+  private eventBuffers = new Map<string, BufferedAcpUpdate[]>();
 
   /**
    * Optional callback to inject a completion/failure message into the parent
@@ -40,7 +68,40 @@ export class AcpSessionManager {
       ) => Promise<void>)
     | null = null;
 
-  constructor(private readonly maxConcurrent: number) {}
+  constructor(private readonly maxConcurrent: number) {
+    this.cleanupStaleRunningRows();
+  }
+
+  /**
+   * On daemon boot, flip any `running`/`initializing` rows in
+   * `acp_session_history` to `cancelled` with a `daemon_restarted` stop
+   * reason. The in-memory ACP sessions they represent died with the
+   * previous daemon process, so the persisted rows would otherwise lie to
+   * the sessions UI about their status.
+   *
+   * Idempotent: a second invocation finds no matching rows (status is
+   * already `cancelled`) and is a no-op. Best-effort: a DB failure is
+   * logged but does not propagate, since failing to clean up stale rows
+   * must not block daemon startup.
+   */
+  private cleanupStaleRunningRows(): void {
+    try {
+      getDb()
+        .update(acpSessionHistory)
+        .set({
+          status: "cancelled",
+          stopReason: "daemon_restarted",
+          completedAt: Date.now(),
+        })
+        .where(inArray(acpSessionHistory.status, ["running", "initializing"]))
+        .run();
+    } catch (err) {
+      log.error(
+        { err },
+        "Failed to mark stale ACP sessions as daemon_restarted",
+      );
+    }
+  }
 
   /**
    * Spawns a new ACP agent session. Returns the generated acpSessionId.
@@ -75,9 +136,22 @@ export class AcpSessionManager {
       "ACP spawn requested",
     );
 
+    // Initialize the per-session ring buffer before any update can fire.
+    this.eventBuffers.set(acpSessionId, []);
+
+    // Wrap the sender so every emitted message is mirrored into the buffer
+    // when it's an `acp_session_update`. The wrapper preserves the original
+    // call semantics — it forwards every message unchanged.
+    const wrappedSend = (msg: ServerMessage) => {
+      if (msg.type === "acp_session_update") {
+        this.appendToBuffer(acpSessionId, msg);
+      }
+      sendToVellum(msg);
+    };
+
     const clientHandler = new VellumAcpClientHandler(
       acpSessionId,
-      sendToVellum,
+      wrappedSend,
       parentConversationId,
     );
 
@@ -93,6 +167,7 @@ export class AcpSessionManager {
       id: acpSessionId,
       agentId,
       acpSessionId: "", // placeholder until createSession resolves
+      parentConversationId,
       status: "initializing",
       startedAt: Date.now(),
     };
@@ -101,10 +176,11 @@ export class AcpSessionManager {
       process: agentProcess,
       state,
       clientHandler,
-      sendToVellum,
+      sendToVellum: wrappedSend,
       currentPrompt: null,
       parentConversationId,
       cwd,
+      command: agentConfig.command,
     };
 
     this.sessions.set(acpSessionId, entry);
@@ -130,10 +206,11 @@ export class AcpSessionManager {
       // Kill the orphaned child process and remove the reserved slot.
       agentProcess.kill();
       this.sessions.delete(acpSessionId);
+      this.eventBuffers.delete(acpSessionId);
       throw err;
     }
 
-    sendToVellum({
+    wrappedSend({
       type: "acp_session_spawned",
       acpSessionId,
       agent: agentId,
@@ -195,6 +272,11 @@ export class AcpSessionManager {
 
   /**
    * Cancels an ongoing prompt in the specified session.
+   *
+   * The session's in-flight `prompt()` will reject in response, and the
+   * catch handler in `firePromptInBackground` performs the terminal
+   * persistence + teardown. We just flip the status here so that handler
+   * preserves "cancelled" instead of overwriting with "failed".
    */
   async cancel(acpSessionId: string): Promise<void> {
     const entry = this.sessions.get(acpSessionId);
@@ -229,6 +311,9 @@ export class AcpSessionManager {
     }
     entry.process.kill();
     this.sessions.delete(acpSessionId);
+    // Free the buffer in case persistTerminal hasn't already (e.g. close()
+    // before terminal transition).
+    this.eventBuffers.delete(acpSessionId);
   }
 
   /**
@@ -255,6 +340,68 @@ export class AcpSessionManager {
     return Array.from(this.sessions.values()).map((e) => e.state);
   }
 
+  /**
+   * Appends a wire-shaped update to the ring buffer, evicting oldest events
+   * when either the count or aggregate-byte cap is exceeded. Byte
+   * accounting tracks the sum of element JSON sizes; the cap is a soft
+   * target (off by at most `buffer.length` for delimiters in the eventual
+   * `JSON.stringify(buffer)` output).
+   */
+  private appendToBuffer(acpSessionId: string, update: AcpSessionUpdate): void {
+    const buffer = this.eventBuffers.get(acpSessionId);
+    if (!buffer) return; // Session already torn down.
+    const byteSize = Buffer.byteLength(JSON.stringify(update), "utf8");
+    buffer.push({ update, byteSize });
+    let totalBytes = 0;
+    for (const entry of buffer) totalBytes += entry.byteSize;
+
+    while (
+      buffer.length > 0 &&
+      (buffer.length > MAX_BUFFER_EVENTS || totalBytes > MAX_BUFFER_BYTES)
+    ) {
+      const dropped = buffer.shift();
+      if (dropped !== undefined) totalBytes -= dropped.byteSize;
+    }
+  }
+
+  /**
+   * Persists the session's final state + buffered event log to
+   * `acp_session_history`, then frees the buffer entry. Best-effort: a DB
+   * failure is logged but does not propagate, since the session has already
+   * reached a terminal state and clients have been notified.
+   */
+  private persistTerminal(acpSessionId: string, entry: SessionEntry): void {
+    const buffer = this.eventBuffers.get(acpSessionId) ?? [];
+    // Serialize only the wire-shaped updates — drop the byte-size accounting
+    // metadata so persisted rows match the protocol shape clients receive.
+    const wireUpdates = buffer.map((buffered) => buffered.update);
+    try {
+      getDb()
+        .insert(acpSessionHistory)
+        .values({
+          id: acpSessionId,
+          agentId: entry.state.agentId,
+          acpSessionId: entry.state.acpSessionId,
+          parentConversationId: entry.parentConversationId,
+          startedAt: entry.state.startedAt,
+          completedAt: entry.state.completedAt ?? null,
+          status: entry.state.status,
+          stopReason: entry.state.stopReason ?? null,
+          error: entry.state.error ?? null,
+          eventLogJson: JSON.stringify(wireUpdates),
+        })
+        .onConflictDoNothing()
+        .run();
+    } catch (err) {
+      log.error(
+        { acpSessionId, err },
+        "Failed to persist ACP session history row",
+      );
+    }
+    // Drop the buffer entry to free memory regardless of write outcome.
+    this.eventBuffers.delete(acpSessionId);
+  }
+
   /**
    * Fires a prompt in the background and wires up completion/error event
    * handlers. Returns the promise so callers can track in-flight state.
@@ -290,6 +437,10 @@ export class AcpSessionManager {
             stopReason: response.stopReason,
           });
 
+          // Persist the terminal row + buffered event log before tearing
+          // down (teardown deletes the buffer entry).
+          this.persistTerminal(acpSessionId, current);
+
           // Free the session slot, deny any pending permissions, and
           // kill the agent process.
           this.teardownSession(acpSessionId, current);
@@ -299,9 +450,14 @@ export class AcpSessionManager {
             const agentLabel = current.state.agentId;
             const responseText = current.clientHandler.responseText;
             const sessionId = current.state.acpSessionId;
-            const notifyMessage =
-              `[ACP agent "${agentLabel}" completed]\n\n${responseText}\n\n` +
-              `To resume: cd ${current.cwd} && claude --resume ${sessionId}`;
+            // `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,
               notifyMessage,
@@ -333,6 +489,9 @@ export class AcpSessionManager {
             error: err.message,
           });
 
+          // Persist the terminal row before teardown clears the buffer.
+          this.persistTerminal(acpSessionId, current);
+
           // Free the session slot and deny any pending permissions.
           this.teardownSession(acpSessionId, current);
         }

package/src/acp/types.ts

@@ -2,34 +2,8 @@
  * ACP (Agent Client Protocol) types for agent session management and configuration.
  */
 
-// Import StopReason for use in AcpSessionState
 import type { StopReason } from "@agentclientprotocol/sdk";
 
-// Re-export relevant types from the ACP SDK for convenience
-export type {
-  AgentCapabilities,
-  ClientCapabilities,
-  InitializeRequest,
-  InitializeResponse,
-  NewSessionRequest,
-  NewSessionResponse,
-  PromptRequest,
-  PromptResponse,
-  SessionId,
-  SessionInfo,
-  SessionNotification,
-  SessionUpdate,
-  StopReason,
-  ToolCall,
-  ToolCallContent,
-  ToolCallId,
-  ToolCallStatus,
-} from "@agentclientprotocol/sdk";
-export {
-  AgentSideConnection,
-  ClientSideConnection,
-} from "@agentclientprotocol/sdk";
-
 /**
  * Configuration for a single ACP agent process.
  */
@@ -40,15 +14,6 @@ export interface AcpAgentConfig {
   env?: Record<string, string>;
 }
 
-/**
- * Top-level ACP configuration.
- */
-export interface AcpConfig {
-  enabled: boolean;
-  maxConcurrentSessions: number;
-  agents: Record<string, AcpAgentConfig>;
-}
-
 /**
  * Runtime state of an ACP session.
  */
@@ -56,24 +21,11 @@ export interface AcpSessionState {
   id: string;
   agentId: string;
   acpSessionId: string;
+  /** Conversation that spawned this session. */
+  parentConversationId: string;
   status: "initializing" | "running" | "completed" | "failed" | "cancelled";
   startedAt: number;
   completedAt?: number;
   error?: string;
   stopReason?: StopReason;
 }
-
-/**
- * Classification of a tool call's operation kind.
- */
-export type ToolCallKind =
-  | "read"
-  | "edit"
-  | "delete"
-  | "move"
-  | "search"
-  | "execute"
-  | "think"
-  | "fetch"
-  | "switch_mode"
-  | "other";

package/src/agent/loop.ts

@@ -23,13 +23,14 @@ import type {
   ToolResultTruncateResult,
   TurnContext,
 } from "../plugins/types.js";
+import { normalizeThinkingConfigForWire } from "../providers/thinking-config.js";
 import type {
   ContentBlock,
   Message,
   Provider,
   ToolDefinition,
+  ToolResultContent,
 } from "../providers/types.js";
-import type { ToolResultContent } from "../providers/types.js";
 import type { SensitiveOutputBinding } from "../tools/sensitive-output-placeholders.js";
 import {
   applyStreamingSubstitution,
@@ -45,7 +46,7 @@ export interface AgentLoopConfig {
   maxTokens: number;
   maxInputTokens?: number; // context window size for tool result truncation
   thinking?: { enabled: boolean };
-  effort: "low" | "medium" | "high" | "xhigh" | "max";
+  effort: "none" | "low" | "medium" | "high" | "xhigh" | "max";
   speed?: "standard" | "fast";
   toolChoice?:
     | { type: "auto" }
@@ -94,6 +95,7 @@ export type AgentEvent =
       riskReason?: string;
       isContainerized?: boolean;
       riskScopeOptions?: Array<{ pattern: string; label: string }>;
+      riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
     }
   | { type: "tool_use_preview_start"; toolUseId: string; toolName: string }
   | {
@@ -275,6 +277,7 @@ export type LoopToolExecutor = (
   riskReason?: string;
   isContainerized?: boolean;
   riskScopeOptions?: Array<{ pattern: string; label: string }>;
+  riskDirectoryScopeOptions?: Array<{ scope: string; label: string }>;
 }>;
 
 export class AgentLoop {
@@ -351,6 +354,16 @@ export class AgentLoop {
      * in unit tests.
      */
     turnContext?: TurnContext,
+    /**
+     * Optional ad-hoc inference-profile override applied to every LLM call
+     * the loop issues. When set, each `SendMessageOptions.config` carries
+     * `overrideProfile = <name>` so the provider's resolver layers
+     * `llm.profiles[<name>]` between the workspace `activeProfile` and any
+     * call-site named profile. Missing profile names silently fall through.
+     * Used by per-conversation pinned profiles to override the workspace
+     * default for the lifetime of an agent loop run.
+     */
+    overrideProfile?: string,
   ): Promise<Message[]> {
     const history = [...messages];
     const initialHistoryLength = messages.length;
@@ -420,8 +433,9 @@ export class AgentLoop {
         }
 
         if (!callSite) {
-          if (this.config.thinking?.enabled) {
-            providerConfig.thinking = { type: "adaptive" };
+          const thinking = normalizeThinkingConfigForWire(this.config.thinking);
+          if (thinking !== undefined) {
+            providerConfig.thinking = thinking;
           }
           if (this.config.effort) {
             providerConfig.effort = this.config.effort;
@@ -450,6 +464,16 @@ export class AgentLoop {
           providerConfig.callSite = callSite;
         }
 
+        // Per-call inference-profile override. The resolver layers
+        // `llm.profiles[overrideProfile]` between the workspace's
+        // `activeProfile` and any call-site named profile. Threading it on
+        // every send (rather than once at construction) keeps subagents that
+        // share an `AgentLoop` instance but ought to inherit a different
+        // profile correct — and matches how `callSite` is plumbed.
+        if (overrideProfile) {
+          providerConfig.overrideProfile = overrideProfile;
+        }
+
         // Rate-limit consecutive LLM calls to prevent spin when tools return instantly
         const minInterval = this.config.minTurnIntervalMs ?? 0;
         if (minInterval > 0 && lastLlmCallTime > 0) {
@@ -494,14 +518,13 @@ export class AgentLoop {
         // Wrap the provider call in the `llmCall` pipeline so middleware
         // contributed by plugins may observe, rewrite, short-circuit, or
         // post-process every LLM request. The terminal below is the real
-        // `provider.sendMessage(...)` call; middleware that call `next(args)`
-        // eventually reach it. The default `defaultLlmCallPlugin` contributes
-        // only a passthrough middleware that forwards to `next(args)` —
-        // registered at module load, it sits at the outermost layer in the
-        // onion, so short-circuiting there would silently disable every
-        // user-registered `llmCall` middleware. Timeout is `null`
-        // (`DEFAULT_TIMEOUTS.llmCall`) — the provider layer already enforces
-        // its own HTTP-level budgets.
+        // `provider.sendMessage(...)` call; middleware reach it by calling
+        // `next(args)`. The default `defaultLlmCallPlugin` contributes a
+        // passthrough middleware that forwards to `next(args)` — it
+        // registers at module load and sits at the outermost onion layer,
+        // so it must yield to keep user-registered `llmCall` middleware
+        // reachable. Timeout is `null` (`DEFAULT_TIMEOUTS.llmCall`) — the
+        // provider layer already enforces its own HTTP-level budgets.
         //
         // The `onEvent` wrapping is kept inside `args.options` so substitution
         // and streaming behavior exactly match the pre-pipeline call site.
@@ -966,6 +989,7 @@ export class AgentLoop {
             riskReason: result.riskReason,
             isContainerized: result.isContainerized,
             riskScopeOptions: result.riskScopeOptions,
+            riskDirectoryScopeOptions: result.riskDirectoryScopeOptions,
           });
         }
 
@@ -1016,8 +1040,7 @@ export class AgentLoop {
           // middleware is a passthrough (so later-registered user plugins
           // aren't shadowed), so this terminal is what actually produces
           // the decision when no user plugin overrides it. Wiring the
-          // decision here — rather than inside the default plugin's
-          // middleware — also preserves the legacy nudge for direct
+          // decision here also ensures the nudge fires for direct
           // AgentLoop callers (tests, benchmarks) that skip
           // `bootstrapPlugins()` and therefore never register the default.
           async (args) => defaultToolErrorTerminal(args),

package/src/agent/message-types.ts

@@ -4,8 +4,6 @@ import {
   type MessageAttachmentInput,
 } from "./attachments.js";
 
-export type { ContentBlock, Message, TextContent } from "../providers/types.js";
-
 export function createUserMessage(
   text: string,
   attachments: MessageAttachmentInput[] = [],

package/src/approvals/AGENTS.md

@@ -6,7 +6,7 @@
 - **Non-rich channels** (http-api) receive plain-text approval prompts. The conversational approval engine handles free-text responses.
 - **Race conditions:** Always check whether a decision has already been resolved before delivering the engine's optimistic reply. If `handleChannelDecision` returns `applied: false`, deliver an "already resolved" notice and return `stale_ignored`.
 - **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 (approve_always downgrade, approval record updates, grant minting) at individual callsites.
+- **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.
 
 ## Guardian Verification Invariant
 

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

@@ -67,21 +67,13 @@ mock.module("../../notifications/signal.js", () => ({
   isNotificationSourceChannel: () => false,
 }));
 
-mock.module("../../permissions/trust-store.js", () => ({
-  addRule: () => {},
-}));
 
-mock.module("../../permissions/v2-consent-policy.js", () => ({
-  isPermissionControlsV2Enabled: () => false,
-}));
 
 mock.module("../../runtime/assistant-scope.js", () => ({
   DAEMON_INTERNAL_ASSISTANT_ID: "self",
 }));
 
-mock.module("../../runtime/auth/token-service.js", () => ({
-  mintDaemonDeliveryToken: () => "mock-token",
-}));
+mock.module("../../runtime/auth/token-service.js", () => ({}));
 
 mock.module("../../runtime/channel-approval-types.js", () => ({}));
 

package/src/approvals/approval-primitive.ts

@@ -46,7 +46,7 @@ export interface MintGrantParams {
   expiresAt: number;
 }
 
-export type MintGrantResult =
+type MintGrantResult =
   | { ok: true; grant: ScopedApprovalGrant }
   | {
       ok: false;
@@ -153,24 +153,7 @@ export function mintGrantFromDecision(
 // Consume
 // ---------------------------------------------------------------------------
 
-export interface ConsumeByRequestIdParams {
-  requestId: string;
-  consumingRequestId: string;
-  now?: number;
-}
-
-export interface ConsumeByToolSignatureParams {
-  toolName: string;
-  inputDigest: string;
-  consumingRequestId: string;
-  executionChannel?: string;
-  conversationId?: string;
-  callSessionId?: string;
-  requesterExternalUserId?: string;
-  now?: number;
-}
-
-export type ConsumeGrantResult =
+type ConsumeGrantResult =
   | { ok: true; grant: ScopedApprovalGrant }
   | {
       ok: false;
@@ -182,7 +165,7 @@ export type ConsumeGrantResult =
         | "aborted";
     };
 
-export interface ConsumeGrantParams {
+interface ConsumeGrantParams {
   requestId?: string;
   toolName: string;
   inputDigest: string;