@vellumai/assistant 0.7.0 → 0.7.2

package/src/daemon/server.ts

@@ -1,13 +1,8 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
-import {
-  disposeAcpSessionManager,
-  getAcpSessionManager,
-  setBroadcastToAllClients,
-} from "../acp/index.js";
+import { disposeAcpSessionManager } from "../acp/index.js";
 import { compileApp } from "../bundler/app-compiler.js";
-import { supportsHostProxy } from "../channels/types.js";
 import { getConfig } from "../config/loader.js";
 import { onContactChange } from "../contacts/contact-events.js";
 import type { CesClient } from "../credential-execution/client.js";
@@ -15,31 +10,17 @@ import type { CesProcessManager } from "../credential-execution/process-manager.
 import { AssistantIpcServer } from "../ipc/assistant-server.js";
 import { SkillIpcServer } from "../ipc/skill-server.js";
 import { getApp, getAppDirPath, isMultifileApp } from "../memory/app-store.js";
-import {
-  uploadFileBackedAttachment,
-  validateAttachmentUpload,
-} from "../memory/attachments-store.js";
-import { getOrCreateConversation } from "../memory/conversation-key-store.js";
 import { syncIdentityNameToPlatform } from "../platform/sync-identity.js";
 import { initializeProviders } from "../providers/registry.js";
-import { buildAssistantEvent } from "../runtime/assistant-event.js";
-import { assistantEventHub } from "../runtime/assistant-event-hub.js";
-import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { getSigningKeyFingerprint } from "../runtime/auth/token-service.js";
-import { checkIngressForSecrets } from "../security/secret-ingress.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";
-import { registerUserMessageCallback } from "../signals/user-message.js";
 import { getSubagentManager } from "../subagent/index.js";
-import { createAbortReason } from "../util/abort-reasons.js";
 import { getLogger } from "../util/logger.js";
 import {
   getAvatarImagePath,
   getWorkspacePromptPath,
 } from "../util/platform.js";
-import { registerDaemonCallbacks } from "../work-items/work-item-runner.js";
 import {
   AppSourceWatcher,
   setEnsureAppSourceWatcher,
@@ -47,37 +28,20 @@ import {
 import { getConfigWatcher } from "./config-watcher.js";
 import { Conversation } from "./conversation.js";
 import { ConversationEvictor } from "./conversation-evictor.js";
-import { registerLaunchConversationDeps } from "./conversation-launch.js";
 import {
   allConversations,
-  clearAllActiveConversations,
   clearConversations,
   conversationEntries,
   deleteConversation,
-  findConversation,
   getConversationMap,
   getOrCreateConversation as getOrCreateActiveConversation,
   initConversationLifecycle,
   setCesClientPromise,
 } from "./conversation-store.js";
 import { refreshSurfacesForApp } from "./conversation-surfaces.js";
-import { undoLastMessage } from "./handlers/conversations.js";
 import { parseIdentityFields } from "./handlers/identity.js";
-import {
-  type ConversationCreateOptions,
-  type HandlerContext,
-} from "./handlers/shared.js";
+import type { ConversationCreateOptions } from "./handlers/shared.js";
 import { setGlobalSkillIpcSender } from "./meet-host-supervisor.js";
-import type {
-  ServerMessage,
-  UserMessageAttachment,
-} from "./message-protocol.js";
-import {
-  makePendingInteractionRegistrar,
-  prepareConversationForMessage,
-  resolveTurnChannel,
-  resolveTurnInterface,
-} from "./process-message.js";
 
 const log = getLogger("server");
 
@@ -99,7 +63,6 @@ export class DaemonServer {
   private sharedRequestTimestamps: number[] = [];
   private unsubscribeContactChange: (() => void) | null = null;
   private evictor: ConversationEvictor;
-  private _hubChain: Promise<void> = Promise.resolve();
 
   // Composed subsystems
   private configWatcher = getConfigWatcher();
@@ -117,11 +80,6 @@ export class DaemonServer {
   /** Monotonically increasing counter to detect stale client updates. */
   private cesClientGeneration = 0;
 
-  /**
-   * Logical assistant identifier used when publishing to the assistant-events hub.
-   */
-  assistantId: string = DAEMON_INTERNAL_ASSISTANT_ID;
-
   /**
    * Inject the CES client and process manager from the caller (lifecycle.ts).
    * Must be called before start().
@@ -175,12 +133,12 @@ export class DaemonServer {
   constructor() {
     this.evictor = new ConversationEvictor(getConversationMap());
     getSubagentManager().sharedRequestTimestamps = this.sharedRequestTimestamps;
-    getSubagentManager().broadcastToAllClients = (msg) => this.broadcast(msg);
+
     initConversationLifecycle({
       evictor: this.evictor,
       sharedRequestTimestamps: this.sharedRequestTimestamps,
     });
-    setBroadcastToAllClients((msg) => this.broadcast(msg));
+
     setEnsureAppSourceWatcher(() => this.appSourceWatcher.ensureStarted());
     // Wire the skill IPC server into the meet-host supervisor's lazy
     // dispatch path. The supervisor is constructed in
@@ -197,121 +155,6 @@ export class DaemonServer {
         (c) => c.status === "running" || c.status === "pending",
       );
     };
-    getSubagentManager().onSubagentFinished = async (
-      parentConversationId,
-      message,
-      sendToClient,
-      notification,
-    ) => {
-      const parentConversation = findConversation(parentConversationId);
-      if (!parentConversation) {
-        log.warn(
-          { parentConversationId },
-          "Subagent finished but parent conversation not found",
-        );
-        return;
-      }
-      const requestId = `subagent-notify-${Date.now()}`;
-      const metadata = { subagentNotification: notification };
-      const enqueueResult = parentConversation.enqueueMessage(
-        message,
-        [],
-        sendToClient,
-        requestId,
-        undefined,
-        undefined,
-        metadata,
-      );
-      if (!enqueueResult.queued && !enqueueResult.rejected) {
-        const messageId = await parentConversation.persistUserMessage(
-          message,
-          [],
-          undefined,
-          metadata,
-        );
-        parentConversation
-          .runAgentLoop(message, messageId, sendToClient)
-          .catch((err) => {
-            log.error(
-              { parentConversationId, err },
-              "Failed to process subagent notification in parent",
-            );
-          });
-      }
-    };
-    getAcpSessionManager().onAcpSessionFinished = async (
-      parentConversationId,
-      message,
-      sendToClient,
-    ) => {
-      const parentConversation = findConversation(parentConversationId);
-      if (!parentConversation) {
-        log.warn(
-          { parentConversationId },
-          "ACP agent finished but parent conversation not found",
-        );
-        return;
-      }
-      const requestId = `acp-notify-${Date.now()}`;
-      const enqueueResult = parentConversation.enqueueMessage(
-        message,
-        [],
-        sendToClient,
-        requestId,
-      );
-      if (!enqueueResult.queued && !enqueueResult.rejected) {
-        const messageId = await parentConversation.persistUserMessage(
-          message,
-          [],
-        );
-        parentConversation
-          .runAgentLoop(message, messageId, sendToClient)
-          .catch((err: unknown) => {
-            log.error(
-              { parentConversationId, err },
-              "Failed to process ACP notification in parent",
-            );
-          });
-      }
-    };
-  }
-
-  // ── Broadcast / Event publishing ──────────────────────────────────
-
-  /**
-   * Publish `msg` as an `AssistantEvent` to the process-level hub.
-   * Publications are serialized via a promise chain so subscribers
-   * always observe events in send order.
-   */
-  private publishAssistantEvent(
-    msg: ServerMessage,
-    conversationId?: string,
-  ): void {
-    const id = this.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
-    const event = buildAssistantEvent(id, msg, conversationId);
-    this._hubChain = this._hubChain
-      .then(() => assistantEventHub.publish(event))
-      .catch((err: unknown) => {
-        log.warn(
-          { err },
-          "assistant-events hub subscriber threw during broadcast",
-        );
-      });
-
-    // Dual-write to file-based stream for cross-process consumers.
-    // No-op when no subscriber files exist for this conversation.
-    if (conversationId) {
-      try {
-        appendEventToStream(conversationId, event);
-      } catch {
-        // Best-effort; file I/O failures must not block the hub chain.
-      }
-    }
-  }
-
-  broadcast(msg: ServerMessage): void {
-    const conversationId = extractConversationId(msg);
-    this.publishAssistantEvent(msg, conversationId);
   }
 
   private broadcastIdentityChanged(): void {
@@ -321,7 +164,7 @@ export class DaemonServer {
         ? readFileSync(identityPath, "utf-8")
         : "";
       const fields = parseIdentityFields(content);
-      this.broadcast({
+      broadcastMessage({
         type: "identity_changed",
         name: fields.name,
         role: fields.role,
@@ -356,15 +199,15 @@ export class DaemonServer {
   }
 
   private broadcastConfigChanged(): void {
-    this.broadcast({ type: "config_changed" });
+    broadcastMessage({ type: "config_changed" });
   }
 
   private broadcastSoundsConfigUpdated(): void {
-    this.broadcast({ type: "sounds_config_updated" });
+    broadcastMessage({ type: "sounds_config_updated" });
   }
 
   private broadcastAvatarUpdated(): void {
-    this.broadcast({
+    broadcastMessage({
       type: "avatar_updated",
       avatarPath: getAvatarImagePath(),
     });
@@ -382,7 +225,7 @@ export class DaemonServer {
       for (const conversation of allConversations()) {
         refreshSurfacesForApp(conversation, appId, { fileChange: true });
       }
-      this.broadcast({ type: "app_files_changed", appId });
+      broadcastMessage({ type: "app_files_changed", appId });
       void updatePublishedAppDeployment(appId);
     };
 
@@ -417,146 +260,6 @@ export class DaemonServer {
 
     this.evictor.start();
 
-    registerDaemonCallbacks({
-      getOrCreateConversation: (conversationId) =>
-        getOrCreateActiveConversation(conversationId),
-      broadcast: (msg) => this.broadcast(msg),
-    });
-
-    registerCancelCallback((conversationId) => {
-      const conversation = findConversation(conversationId);
-      if (!conversation) return false;
-      this.evictor.touch(conversationId);
-      conversation.abort(
-        createAbortReason(
-          "signal_cancel",
-          "registerCancelCallback",
-          conversationId,
-        ),
-      );
-      getSubagentManager().abortAllForParent(conversationId);
-      return true;
-    });
-
-    registerConversationUndoCallback((conversationId) =>
-      undoLastMessage(conversationId),
-    );
-
-    registerUserMessageCallback(async (params) => {
-      // Block messages containing known-format secrets before persistence
-      if (!params.bypassSecretCheck) {
-        const ingressResult = checkIngressForSecrets(params.content);
-        if (ingressResult.blocked) {
-          return {
-            accepted: false,
-            error: "secret_blocked" as const,
-            message: ingressResult.userNotice,
-          };
-        }
-      }
-
-      const { conversationId } = getOrCreateConversation(
-        params.conversationKey,
-      );
-      const conversation = await getOrCreateActiveConversation(conversationId);
-
-      // Register file-backed attachments so they flow through the send
-      // pipeline as images the LLM can see directly.
-      const attachmentIds: string[] = [];
-      const resolvedAttachments: UserMessageAttachment[] = [];
-      if (params.attachments && params.attachments.length > 0) {
-        for (const a of params.attachments) {
-          try {
-            const validation = validateAttachmentUpload(a.filename, a.mimeType);
-            if (!validation.ok) {
-              log.warn(
-                { error: validation.error, path: a.path },
-                "Signal attachment rejected by validation",
-              );
-              continue;
-            }
-            const size = statSync(a.path).size;
-            const stored = uploadFileBackedAttachment(
-              a.filename,
-              a.mimeType,
-              a.path,
-              size,
-            );
-            attachmentIds.push(stored.id);
-            resolvedAttachments.push({
-              id: stored.id,
-              filename: a.filename,
-              mimeType: a.mimeType,
-              data: "",
-              filePath: a.path,
-            });
-          } catch (err) {
-            log.warn(
-              { err, path: a.path },
-              "Failed to register signal attachment",
-            );
-          }
-        }
-      }
-
-      // Build a hub-publishing sender so events reach SSE clients.
-      const hubSender = (msg: ServerMessage) => {
-        const msgConversationId =
-          "conversationId" in msg &&
-          typeof (msg as { conversationId?: unknown }).conversationId ===
-            "string"
-            ? (msg as { conversationId: string }).conversationId
-            : undefined;
-        this.publishAssistantEvent(msg, msgConversationId ?? conversationId);
-      };
-
-      if (conversation.isProcessing()) {
-        // Hydrate file data now — the queue path won't re-read from
-        // the attachment store, so base64 content must be inline.
-        for (let i = resolvedAttachments.length - 1; i >= 0; i--) {
-          const att = resolvedAttachments[i];
-          if (att.filePath && !att.data) {
-            try {
-              att.data = readFileSync(att.filePath).toString("base64");
-            } catch (err) {
-              log.warn(
-                { err, path: att.filePath },
-                "Failed to read queued signal attachment, skipping",
-              );
-              resolvedAttachments.splice(i, 1);
-            }
-          }
-        }
-        const requestId = crypto.randomUUID();
-        const resolvedChannel = resolveTurnChannel(params.sourceChannel);
-        const resolvedInterface = resolveTurnInterface(params.sourceInterface);
-        const result = conversation.enqueueMessage(
-          params.content,
-          resolvedAttachments,
-          hubSender,
-          requestId,
-          undefined,
-          undefined,
-          {
-            userMessageChannel: resolvedChannel,
-            assistantMessageChannel: resolvedChannel,
-            userMessageInterface: resolvedInterface,
-            assistantMessageInterface: resolvedInterface,
-          },
-        );
-        return { accepted: !result.rejected };
-      }
-      await this.persistAndProcessMessage(
-        conversationId,
-        params.content,
-        attachmentIds.length > 0 ? attachmentIds : undefined,
-        { onEvent: hubSender },
-        params.sourceChannel,
-        params.sourceInterface,
-      );
-      return { accepted: true };
-    });
-
     await this.cliIpc.start();
 
     // Start the skill IPC server. First-party skill processes connect to this
@@ -565,32 +268,6 @@ export class DaemonServer {
     // subsequent PRs in the skill-isolation plan.
     await this.skillIpc.start();
 
-    // Wire the launchConversation helper to daemon-side state so
-    // handleSurfaceAction can spawn conversations through it.
-    registerLaunchConversationDeps({
-      getOrCreateConversation: (id, options) =>
-        getOrCreateActiveConversation(id, options),
-      persistAndProcessMessage: (
-        conversationId,
-        content,
-        attachmentIds,
-        options,
-        sourceChannel,
-        sourceInterface,
-      ) =>
-        this.persistAndProcessMessage(
-          conversationId,
-          content,
-          attachmentIds,
-          options,
-          sourceChannel,
-          sourceInterface,
-        ),
-      publishAssistantEvent: (msg, conversationId) =>
-        this.publishAssistantEvent(msg, conversationId),
-      getAssistantId: () => this.assistantId,
-    });
-
     this.configWatcher.start(
       () => this.evictConversationsForReload(),
       () => this.broadcastIdentityChanged(),
@@ -605,7 +282,7 @@ export class DaemonServer {
 
     // Broadcast contacts_changed to all clients when any contact mutation occurs.
     this.unsubscribeContactChange = onContactChange(() => {
-      this.broadcast({ type: "contacts_changed" });
+      broadcastMessage({ type: "contacts_changed" });
     });
 
     log.info("DaemonServer started (HTTP-only mode)");
@@ -664,7 +341,7 @@ export class DaemonServer {
   // ── Conversation management ──────────────────────────────────────────────
 
   broadcastStatus(): void {
-    this.broadcast({
+    broadcastMessage({
       type: "assistant_status",
       version: daemonVersion,
       keyFingerprint: getSigningKeyFingerprint(),
@@ -707,115 +384,6 @@ export class DaemonServer {
     this.evictConversationsForReload();
   }
 
-  // ── Handler context ────────────────────────────────────────────────
-
-  private handlerContext(): HandlerContext {
-    return {
-      sharedRequestTimestamps: this.sharedRequestTimestamps,
-      debounceTimers: this.configWatcher.timers,
-      suppressConfigReload: this.configWatcher.suppressConfigReload,
-      setSuppressConfigReload: (value: boolean) => {
-        this.configWatcher.suppressConfigReload = value;
-      },
-      updateConfigFingerprint: () => {
-        this.configWatcher.updateFingerprint();
-      },
-      send: (msg) => this.broadcast(msg),
-      broadcast: (msg) => this.broadcast(msg),
-      clearAllConversations: () => clearAllActiveConversations(),
-      getOrCreateConversation: (id, options?) =>
-        getOrCreateActiveConversation(id, options),
-      touchConversation: (id) => this.evictor.touch(id),
-    };
-  }
-
-  // ── HTTP message processing ─────────────────────────────────────────
-
-  async persistAndProcessMessage(
-    conversationId: string,
-    content: string,
-    attachmentIds?: string[],
-    options?: ConversationCreateOptions,
-    sourceChannel?: string,
-    sourceInterface?: string,
-  ): Promise<{ messageId: string }> {
-    const { conversation, attachments } = await prepareConversationForMessage(
-      conversationId,
-      content,
-      attachmentIds,
-      options,
-      sourceChannel,
-      sourceInterface,
-    );
-
-    const requestId = crypto.randomUUID();
-    const messageId = await conversation.persistUserMessage(
-      content,
-      attachments,
-      requestId,
-    );
-
-    // Register pending interactions so channel approval interception can
-    // find the conversation by requestId when confirmation/secret events fire.
-    const registrar = makePendingInteractionRegistrar(
-      conversation,
-      conversationId,
-    );
-    const onEvent = options?.onEvent
-      ? (msg: ServerMessage) => {
-          registrar(msg);
-          try {
-            options.onEvent!(msg);
-          } catch (err) {
-            log.error(
-              { err, conversationId },
-              "onEvent callback failed; continuing agent loop",
-            );
-          }
-        }
-      : registrar;
-    // Non-interactive interfaces that still have a connected client capable
-    // of handling host_browser_request events (e.g. chrome-extension) need
-    // their hostBrowserProxy explicitly marked connected. The proxy
-    // constructor defaults clientConnected = false, so without an explicit
-    // sender update the chrome-extension proxy would be created and
-    // immediately unavailable. We do NOT call updateClient(onEvent, false)
-    // for that case, because flipping hasNoClient false would also enable
-    // host_bash/host_file/host_cu tool gating for an interface that can't
-    // service them. Instead, provision just the browser proxy's sender.
-    const persistInterfaceCtx = conversation.getTurnInterfaceContext();
-    const persistInterface = persistInterfaceCtx?.userMessageInterface;
-    if (options?.isInteractive === true) {
-      conversation.updateClient(onEvent, false);
-    } else if (
-      persistInterface &&
-      !supportsHostProxy(persistInterface) &&
-      supportsHostProxy(persistInterface, "host_browser")
-    ) {
-      conversation.hostBrowserProxy?.updateSender(onEvent, true);
-    }
-
-    conversation
-      .runAgentLoop(content, messageId, onEvent, {
-        isInteractive: options?.isInteractive ?? false,
-        isUserMessage: true,
-        ...(options?.callSite ? { callSite: options.callSite } : {}),
-      })
-      .finally(() => {
-        if (
-          options?.isInteractive === true &&
-          conversation.getCurrentSender() === onEvent
-        ) {
-          conversation.updateClient(() => {}, true);
-        }
-      })
-      .catch((err) => {
-        log.error({ err, conversationId }, "Background agent loop failed");
-      });
-
-    return { messageId };
-  }
-
   /**
    * Expose conversation lookup for the POST /v1/messages handler.
    * The handler manages busy-state checking and queueing itself.
@@ -826,21 +394,4 @@ export class DaemonServer {
   ): Promise<Conversation> {
     return getOrCreateActiveConversation(conversationId, options);
   }
-
-  /**
-   * Expose the handler context for use by conversation management HTTP routes.
-   * The context is built on-the-fly so it always reflects the current server state.
-   */
-  getHandlerContext(): HandlerContext {
-    return this.handlerContext();
-  }
-}
-
-/** Extract conversationId from a ServerMessage if present. */
-function extractConversationId(msg: ServerMessage): string | undefined {
-  const record = msg as unknown as Record<string, unknown>;
-  if ("conversationId" in msg && typeof record.conversationId === "string") {
-    return record.conversationId as string;
-  }
-  return undefined;
 }

package/src/daemon/shutdown-handlers.ts

@@ -1,6 +1,5 @@
 import * as Sentry from "@sentry/node";
 
-import type { BackupWorkerHandle } from "../backup/backup-worker.js";
 import type { FilingService } from "../filing/filing-service.js";
 import type { HeartbeatService } from "../heartbeat/heartbeat-service.js";
 import type { McpServerManager } from "../mcp/manager.js";
@@ -21,12 +20,11 @@ export interface ShutdownDeps {
   server: DaemonServer;
   workspaceHeartbeat: WorkspaceHeartbeatService;
   heartbeat: HeartbeatService;
-  filing: FilingService;
+  filing: FilingService | null;
   runtimeHttp: RuntimeHttpServer | null;
   scheduler: { stop(): void };
   feedScheduler: { stop(): void } | null;
   getMemoryWorker: () => { stop(): void } | null;
-  getBackupWorker: () => BackupWorkerHandle | null;
   getQdrantManager: () => QdrantManager | null;
   mcpManager: McpServerManager | null;
   telemetryReporter: { stop(): Promise<void> } | null;
@@ -61,7 +59,7 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
 
     await deps.workspaceHeartbeat.stop();
     await deps.heartbeat.stop();
-    await deps.filing.stop();
+    if (deps.filing) await deps.filing.stop();
 
     // Run registered skill shutdown hooks (e.g. meet-join session teardown)
     // before stopping the server so any HTTP round-trips and SSE emissions
@@ -123,7 +121,6 @@ export function installShutdownHandlers(deps: ShutdownDeps): void {
     deps.scheduler.stop();
     deps.feedScheduler?.stop();
     deps.getMemoryWorker()?.stop();
-    deps.getBackupWorker()?.stop();
 
     if (deps.mcpManager) {
       try {

package/src/daemon/tool-setup-types.ts

@@ -0,0 +1,51 @@
+/**
+ * Types extracted from conversation-tool-setup.ts to break the
+ * tool-setup ↔ doordash-steps and tool-setup ↔ tool-side-effects cycles.
+ */
+
+import type { InterfaceId } from "../channels/types.js";
+import type { CesClient } from "../credential-execution/client.js";
+import type { SurfaceConversationContext } from "./conversation-surfaces.js";
+import type { TrustContext } from "./trust-context.js";
+
+/**
+ * Subset of Conversation state that the tool executor callback reads at
+ * call time (not construction time). These are captured by the
+ * returned closure, so they must be live references.
+ */
+export interface ToolSetupContext extends SurfaceConversationContext {
+  readonly conversationId: string;
+  assistantId?: string;
+  currentRequestId?: string;
+  workingDir: string;
+  abortController: AbortController | null;
+  /** When set, only tools in this set may execute during the current turn. */
+  allowedToolNames?: Set<string>;
+  /** Conversation memory policy used to propagate scopeId into ToolContext. */
+  memoryPolicy: { scopeId: string };
+  /** True when the conversation has no connected client (HTTP-only path). */
+  hasNoClient?: boolean;
+  /** When true, the conversation is executing a task run and must not become interactive. */
+  headlessLock?: boolean;
+  /** When set, this conversation is executing a task run. Used to retrieve ephemeral permission rules. */
+  taskRunId?: string;
+  /** Guardian runtime context for the conversation — trustClass is propagated into ToolContext for control-plane policy enforcement. */
+  trustContext?: TrustContext;
+  /** Voice/call session ID, if the conversation originates from a call. Propagated into ToolContext for scoped grant consumption. */
+  callSessionId?: string;
+  /** CES RPC client for credential execution operations. Injected when CES tools are enabled and the CES process is available. */
+  cesClient?: CesClient;
+  /** The interface ID of the connected client driving the current turn (e.g. "macos", "chrome-extension"). Propagated into ToolContext for browser backend selection. */
+  readonly transportInterface?: InterfaceId;
+
+  /** Turn-scoped flag: true when any tool call in the current turn received explicit user approval via interactive prompt. Cleared at turn end. */
+  approvedViaPromptThisTurn?: boolean;
+  /**
+   * Per-turn snapshot of the resolved inference-profile override, set by
+   * `runAgentLoopImpl`. Propagated into `ToolContext.overrideProfile` so
+   * tools that spawn nested invocations (e.g. `subagent_spawn`) can forward
+   * the override without round-tripping through a row read that would
+   * return `undefined` for the in-flight (background) subagent.
+   */
+  currentTurnOverrideProfile?: string;
+}