@vellumai/assistant 0.8.1 → 0.8.3

package/src/providers/retry.ts

@@ -72,6 +72,40 @@ const RETRYABLE_STREAM_PATTERNS = [
  */
 const RETRYABLE_PROVIDER_MESSAGE_PATTERNS = [/overloaded/i];
 
+/**
+ * Patterns that indicate the Anthropic provider SDK reported a transport-level
+ * abort (TCP close mid-stream, edge LB idle cutoff, Bun fetch deadline) rather
+ * than a caller-initiated cancellation or inner-timeout deadline. The SDK
+ * surfaces all three cases as ``Request was aborted`` with ``error.status ===
+ * undefined``; the catch-site in ``providers/anthropic/client.ts`` separates
+ * them by:
+ *   - tagging caller cancellations with ``abortReason`` (short-circuits in
+ *     {@link isRetryableError} before reaching this predicate)
+ *   - rewriting the inner-timeout message to ``"Anthropic stream timed out
+ *     after Xs (inner streamTimeoutMs)"`` (doesn't start with ``Anthropic API
+ *     error:`` so it falls through to network-error classification)
+ *   - leaving the transport-abort message verbatim as
+ *     ``"Anthropic API error: Request was aborted."``
+ *
+ * Pattern is intentionally anchored to the Anthropic-specific message prefix.
+ * The OpenAI / Gemini / OpenRouter catch-sites format their errors as
+ * ``"<Provider> API error (undefined): Request was aborted."`` (note the
+ * ``(undefined)`` parenthetical) and — crucially — do **not** rewrite
+ * inner-timeout failures, so a provider-agnostic ``/request was aborted/i``
+ * predicate would erroneously retry their 30-minute deadline failures three
+ * additional times. Once those catch-sites grow the same
+ * ``innerTimeoutFired`` distinction the Anthropic one has, the pattern set
+ * here can be expanded to cover them too.
+ *
+ * This is the daemon-side counterpart to the vembda graceful-close behavior
+ * for upstream disconnects (LUM-1536) — together they collapse the 45 s
+ * silent-stall window the web client used to observe whenever Anthropic's
+ * stream was cut mid-token.
+ */
+const RETRYABLE_TRANSPORT_ABORT_PATTERNS = [
+  /^anthropic api error:\s*request was aborted/i,
+];
+
 function isRetryableStreamError(error: unknown): boolean {
   if (!(error instanceof ProviderError)) return false;
   if (error.statusCode !== undefined) return false; // has a real HTTP status — not a stream error
@@ -84,6 +118,15 @@ function isRetryableProviderMessage(error: unknown): boolean {
   return RETRYABLE_PROVIDER_MESSAGE_PATTERNS.some((p) => p.test(error.message));
 }
 
+function isRetryableTransportAbort(error: unknown): boolean {
+  if (!(error instanceof ProviderError)) return false;
+  // Transport aborts surface with ``status === undefined`` (the SDK never
+  // saw an HTTP response). A real HTTP status here means a server error,
+  // which is handled by the status check.
+  if (error.statusCode !== undefined) return false;
+  return RETRYABLE_TRANSPORT_ABORT_PATTERNS.some((p) => p.test(error.message));
+}
+
 function isRetryableError(error: unknown): boolean {
   // Context overflow is deterministic — retrying the same oversized prompt
   // will never succeed. Short-circuit before the generic 429/5xx check so
@@ -103,6 +146,7 @@ function isRetryableError(error: unknown): boolean {
   }
   if (isRetryableProviderMessage(error)) return true;
   if (isRetryableStreamError(error)) return true;
+  if (isRetryableTransportAbort(error)) return true;
   return isRetryableNetworkError(error);
 }
 
@@ -482,7 +526,9 @@ export class RetryProvider implements Provider {
                   ? "provider_overloaded"
                   : isRetryableStreamError(error)
                     ? "stream_corruption"
-                    : "network_error";
+                    : isRetryableTransportAbort(error)
+                      ? "transport_abort"
+                      : "network_error";
           log.warn(
             {
               attempt: attempt + 1,

package/src/runtime/__tests__/agent-wake.test.ts

@@ -68,6 +68,33 @@ mock.module("../../daemon/disk-pressure-guard.js", () => ({
   getDiskPressureStatus: () => mockDiskPressureStatus,
 }));
 
+const recordRequestLogCalls: Array<{
+  conversationId: string;
+  requestPayload: string;
+  responsePayload: string;
+  messageId?: string;
+  provider?: string;
+}> = [];
+mock.module("../../memory/llm-request-log-store.js", () => ({
+  recordRequestLog: (
+    conversationId: string,
+    requestPayload: string,
+    responsePayload: string,
+    messageId?: string,
+    provider?: string,
+  ) => {
+    recordRequestLogCalls.push({
+      conversationId,
+      requestPayload,
+      responsePayload,
+      messageId,
+      provider,
+    });
+    return "log-id-test";
+  },
+  backfillMessageIdOnLogs: () => {},
+}));
+
 import type { AgentEvent } from "../../agent/loop.js";
 import type { Message } from "../../providers/types.js";
 import {
@@ -220,6 +247,7 @@ function makeTarget(options: {
 
 beforeEach(() => {
   __resetWakeChainForTests();
+  recordRequestLogCalls.length = 0;
   mockDiskPressureStatus = {
     enabled: false,
     state: "disabled",
@@ -1435,4 +1463,128 @@ describe("wakeAgentForOpportunity", () => {
       expect(uiBlock!.surfaceId).toBe(wakeProducedOutputCalls[0]);
     },
   );
+
+  test(
+    "silent no-op wake drops LLM request logs so a future backfillMessageIdOnLogs " +
+      "sweep cannot misattach them to an unrelated assistant reply",
+    async () => {
+      const usageEvent: AgentEvent = {
+        type: "usage",
+        inputTokens: 100,
+        outputTokens: 5,
+        model: "test-model",
+        actualProvider: "test-provider",
+        providerDurationMs: 10,
+        rawRequest: { request: "no-op wake" },
+        rawResponse: { response: "no output" },
+      };
+      const target = makeTarget({
+        baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+        scriptedEvents: [usageEvent],
+        // Empty assistant text → silent no-op.
+        scriptedAssistant: {
+          role: "assistant",
+          content: [{ type: "text", text: "" }],
+        },
+      });
+
+      const result = await wakeAgentForOpportunity(
+        {
+          conversationId: target.conversationId,
+          hint: "consider doing nothing",
+          source: "unit-test",
+        },
+        { resolveTarget: async () => target },
+      );
+
+      expect(result).toEqual({ invoked: true, producedToolCalls: false });
+      // Nothing emitted, nothing persisted to the conversation.
+      expect(target.emittedEvents).toHaveLength(0);
+      expect(target.persistedTailCalls).toHaveLength(0);
+      // Critical: the LLM request log must NOT be inserted with messageId=NULL,
+      // otherwise the next user turn's backfillMessageIdOnLogs sweep would
+      // misattach this row to an unrelated future assistant reply.
+      expect(recordRequestLogCalls).toHaveLength(0);
+    },
+  );
+
+  test("wake that produces output persists buffered LLM request logs", async () => {
+    const usageEvent: AgentEvent = {
+      type: "usage",
+      inputTokens: 100,
+      outputTokens: 5,
+      model: "test-model",
+      actualProvider: "test-provider",
+      providerDurationMs: 10,
+      rawRequest: { request: "produced wake" },
+      rawResponse: { response: "real reply" },
+    };
+    const target = makeTarget({
+      baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      scriptedEvents: [usageEvent],
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "real reply" }],
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "do reply",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    expect(recordRequestLogCalls).toHaveLength(1);
+    expect(recordRequestLogCalls[0]).toMatchObject({
+      conversationId: target.conversationId,
+      provider: "test-provider",
+      messageId: undefined,
+    });
+  });
+
+  test("non-serializable usage payload does not abort the wake", async () => {
+    // Circular reference in rawRequest — JSON.stringify throws on this.
+    // Serialization must happen inside persistLog's try/catch so the
+    // failure is swallowed as a non-fatal log warning rather than
+    // escaping and aborting the wake.
+    const circular: Record<string, unknown> = { request: "produced wake" };
+    circular.self = circular;
+    const usageEvent: AgentEvent = {
+      type: "usage",
+      inputTokens: 100,
+      outputTokens: 5,
+      model: "test-model",
+      actualProvider: "test-provider",
+      providerDurationMs: 10,
+      rawRequest: circular,
+      rawResponse: { response: "real reply" },
+    };
+    const target = makeTarget({
+      baseline: [{ role: "user", content: [{ type: "text", text: "hi" }] }],
+      scriptedEvents: [usageEvent],
+      scriptedAssistant: {
+        role: "assistant",
+        content: [{ type: "text", text: "real reply" }],
+      },
+    });
+
+    const result = await wakeAgentForOpportunity(
+      {
+        conversationId: target.conversationId,
+        hint: "do reply",
+        source: "unit-test",
+      },
+      { resolveTarget: async () => target },
+    );
+
+    expect(result).toEqual({ invoked: true, producedToolCalls: false });
+    // Wake still produced output even though logging failed.
+    expect(target.persistedTailCalls).toHaveLength(1);
+    // No log row was inserted because JSON.stringify threw.
+    expect(recordRequestLogCalls).toHaveLength(0);
+  });
 });

package/src/runtime/agent-wake.ts

@@ -57,7 +57,11 @@ import {
 } from "../daemon/disk-pressure-policy.js";
 import type { TrustContext } from "../daemon/trust-context.js";
 import { getConversationOverrideProfile } from "../memory/conversation-crud.js";
-import { recordRequestLog } from "../memory/llm-request-log-store.js";
+import {
+  buildProviderErrorResponsePayload,
+  recordRequestLog,
+  setAgentLoopExitReasonOnLatestLog,
+} from "../memory/llm-request-log-store.js";
 import type { TurnContext } from "../plugins/types.js";
 import type { Message } from "../providers/types.js";
 import { getLogger } from "../util/logger.js";
@@ -330,7 +334,7 @@ function classifyWakeDiskPressurePolicy(opts: WakeOptions): {
   const status = getDiskPressureStatus();
   const decision = classifyDiskPressureTurnPolicy(status, {
     conversationSource: opts.source,
-    callSite: "mainAgent",
+    callSite: opts.callSite ?? "mainAgent",
     isDirectWake: true,
     sourceChannel: opts.sourceChannel ?? opts.trustContext?.sourceChannel,
     sourceInterface: opts.sourceInterface,
@@ -537,6 +541,49 @@ export async function wakeAgentForOpportunity(
     // only after `agentLoop.run()` returns.
     let mode: "buffering" | "live" = "buffering";
     const buffered: AgentEvent[] = [];
+    // LLM request logs accumulated while buffering. Persisted only if the
+    // wake transitions to live (i.e. produced output). A silent no-op wake
+    // drops them — otherwise the next user-turn's `backfillMessageIdOnLogs`
+    // sweep would misattach these NULL-messageId rows to an unrelated
+    // future assistant message, contaminating inspector context.
+    type PendingLog = {
+      rawRequest: unknown;
+      rawResponse: unknown;
+      provider?: string;
+    };
+    const pendingLogs: PendingLog[] = [];
+    // Exit reason deferred alongside pendingLogs. Same drop-on-silent-
+    // wake guarantee: if the wake never goes live, this stays null and
+    // no DB row is touched. Applied after pendingLogs flush in goLive
+    // so the latest-row lookup in `setAgentLoopExitReasonOnLatestLog`
+    // can see the freshly-persisted final usage row.
+    let pendingExitReason: string | null = null;
+    const persistLog = (record: PendingLog): void => {
+      try {
+        recordRequestLog(
+          conversationId,
+          JSON.stringify(record.rawRequest),
+          JSON.stringify(record.rawResponse),
+          undefined,
+          record.provider,
+        );
+      } catch (err) {
+        log.warn(
+          { err, conversationId, source },
+          "agent-wake: failed to persist LLM request log (non-fatal)",
+        );
+      }
+    };
+    const persistExitReason = (reason: string): void => {
+      try {
+        setAgentLoopExitReasonOnLatestLog(conversationId, reason);
+      } catch (err) {
+        log.warn(
+          { err, conversationId, source, reason },
+          "agent-wake: failed to persist agent_loop_exit_reason (non-fatal)",
+        );
+      }
+    };
     const safeEmit = (event: AgentEvent): void => {
       try {
         target.emitAgentEvent(event);
@@ -550,20 +597,49 @@ export async function wakeAgentForOpportunity(
     const onEvent = (event: AgentEvent): void => {
       // Replicates the recordRequestLog side-effect in `handleUsage` because
       // wakes own their own onEvent and never reach `dispatchAgentEvent`.
+      // Defer persistence while buffering — see `pendingLogs` above.
       if (event.type === "usage" && event.rawRequest && event.rawResponse) {
-        try {
-          recordRequestLog(
-            conversationId,
-            JSON.stringify(event.rawRequest),
-            JSON.stringify(event.rawResponse),
-            undefined,
-            event.actualProvider,
-          );
-        } catch (err) {
-          log.warn(
-            { err, conversationId, source },
-            "agent-wake: failed to persist LLM request log (non-fatal)",
-          );
+        const record = {
+          rawRequest: event.rawRequest,
+          rawResponse: event.rawResponse,
+          provider: event.actualProvider,
+        };
+        if (mode === "buffering") {
+          pendingLogs.push(record);
+        } else {
+          persistLog(record);
+        }
+      }
+      // Mirror the same recording side-effect for provider-rejected calls.
+      // `handleProviderError` in the daemon dispatcher persists these on the
+      // normal turn path; the wake path owns its own onEvent and bypasses
+      // that dispatcher entirely, so we replicate here. Buffering rules
+      // match the success path: if the wake never goes live (silent no-op),
+      // the rows are dropped so a stale `messageId IS NULL` row doesn't get
+      // mis-backfilled onto an unrelated future assistant message.
+      if (event.type === "provider_error") {
+        const record: PendingLog = {
+          rawRequest: event.rawRequest,
+          rawResponse: buildProviderErrorResponsePayload(event.error),
+          provider: event.actualProvider,
+        };
+        if (mode === "buffering") {
+          pendingLogs.push(record);
+        } else {
+          persistLog(record);
+        }
+      }
+      // Replicates the setAgentLoopExitReasonOnLatestLog side-effect that
+      // `dispatchAgentEvent` does for the normal path. In live mode the
+      // final usage event of the run has already landed its row, so the
+      // latest-row lookup hits the right target. In buffering mode the
+      // reason is stashed and applied in `goLive` after pendingLogs are
+      // persisted, preserving the same ordering guarantee.
+      if (event.type === "agent_loop_exit") {
+        if (mode === "buffering") {
+          pendingExitReason = event.reason;
+        } else {
+          persistExitReason(event.reason);
         }
       }
       if (mode === "buffering") {
@@ -620,6 +696,18 @@ export async function wakeAgentForOpportunity(
         safeEmit(event);
       }
       buffered.length = 0;
+      for (const record of pendingLogs) {
+        persistLog(record);
+      }
+      pendingLogs.length = 0;
+      // Apply the deferred exit reason after pendingLogs are persisted —
+      // the latest-row lookup in `setAgentLoopExitReasonOnLatestLog`
+      // needs the final usage row to already exist. Cleared after use so
+      // an extremely unlikely double-goLive can't double-stamp.
+      if (pendingExitReason !== null) {
+        persistExitReason(pendingExitReason);
+        pendingExitReason = null;
+      }
       mode = "live";
     };
 

package/src/runtime/auth/route-policy.ts

@@ -164,6 +164,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "confirm", scopes: ["approval.write"] },
   { endpoint: "secret", scopes: ["approval.write"] },
   { endpoint: "trust-rules", scopes: ["approval.write"] },
+  { endpoint: "question-response", scopes: ["approval.write"] },
   { endpoint: "host-app-control-result", scopes: ["approval.write"] },
   { endpoint: "host-bash-result", scopes: ["approval.write"] },
   { endpoint: "host-browser-result", scopes: ["approval.write"] },
@@ -242,6 +243,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
     endpoint: "integrations/slack/channel/config:DELETE",
     scopes: ["settings.write"],
   },
+  { endpoint: "integrations/a2a/invite", scopes: ["settings.write"] },
   { endpoint: "channel-verification-sessions", scopes: ["settings.write"] },
   {
     endpoint: "channel-verification-sessions:DELETE",
@@ -285,7 +287,8 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
   { endpoint: "slack/channels", scopes: ["settings.read"] },
   { endpoint: "slack/share", scopes: ["settings.write"] },
 
-  // Channel readiness
+  // Channel availability + readiness
+  { endpoint: "channels/available", scopes: ["settings.read"] },
   { endpoint: "channels/readiness", scopes: ["settings.read"] },
   { endpoint: "channels/readiness/refresh", scopes: ["settings.write"] },
 
@@ -342,6 +345,7 @@ const ACTOR_ENDPOINTS: Array<{ endpoint: string; scopes: Scope[] }> = [
 
   // Lifecycle telemetry
   { endpoint: "telemetry/lifecycle", scopes: ["settings.write"] },
+  { endpoint: "telemetry/flush", scopes: ["settings.write"] },
 
   // Debug / introspection
   { endpoint: "clients", scopes: ["settings.read"] },
@@ -683,6 +687,18 @@ for (const endpoint of INTERNAL_ENDPOINTS) {
   });
 }
 
+// A2A invite completion: gateway-only (platform-orchestrated)
+registerPolicy("integrations/a2a/invite/complete", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
+// A2A invite redemption: gateway-only (platform-orchestrated)
+registerPolicy("integrations/a2a/invite/redeem", {
+  requiredScopes: ["internal.write"],
+  allowedPrincipalTypes: ["svc_gateway"],
+});
+
 // Admin control-plane endpoints: gateway-only
 registerPolicy("admin/upgrade-broadcast", {
   requiredScopes: ["internal.write"],
@@ -1079,6 +1095,10 @@ registerPolicy("oauth/mode.set", {
   requiredScopes: ["settings.write"],
   allowedPrincipalTypes: ["local"],
 });
+registerPolicy("oauth/connection-changed", {
+  requiredScopes: ["settings.write"],
+  allowedPrincipalTypes: ["local"],
+});
 registerPolicy("oauth/status", {
   requiredScopes: ["settings.read"],
   allowedPrincipalTypes: ["local"],

package/src/runtime/btw-sidechain.ts

@@ -70,6 +70,8 @@ export async function runBtwSidechain(
   const tools = params.tools;
   const history = params.messages ?? params.conversation?.getMessages() ?? [];
   const messages = [...history, userMessage(trimmedContent)];
+  // Side-chains force `tool_choice: { type: "none" }` below, so tool usage
+  // guidance must stay in tool descriptions rather than this system prompt.
   const systemPrompt =
     params.systemPrompt ??
     (params.conversation?.hasSystemPromptOverride

package/src/runtime/http-server.ts

@@ -28,6 +28,8 @@ import {
 import { isHttpAuthDisabled } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
+import { createApprovalCopyGenerator } from "../daemon/approval-generators.js";
+import { createGuardianActionCopyGenerator } from "../daemon/guardian-action-generators.js";
 import { processMessage } from "../daemon/process-message.js";
 import { createLiveVoiceSession } from "../live-voice/live-voice-session.js";
 import { LiveVoiceSessionManager } from "../live-voice/live-voice-session-manager.js";
@@ -96,10 +98,8 @@ import { matchSkillRoute } from "./skill-route-registry.js";
 export { isPrivateAddress } from "./middleware/auth.js";
 
 import type {
-  ApprovalConversationGenerator,
   ApprovalCopyGenerator,
   GuardianActionCopyGenerator,
-  GuardianFollowUpConversationGenerator,
   RuntimeHttpServerOptions,
 } from "./http-types.js";
 
@@ -161,10 +161,8 @@ export class RuntimeHttpServer {
   private port: number;
   private hostname: string;
 
-  private approvalCopyGenerator?: ApprovalCopyGenerator;
-  private approvalConversationGenerator?: ApprovalConversationGenerator;
-  private guardianActionCopyGenerator?: GuardianActionCopyGenerator;
-  private guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator;
+  private readonly approvalCopyGenerator: ApprovalCopyGenerator;
+  private readonly guardianActionCopyGenerator: GuardianActionCopyGenerator;
   private retrySweepTimer: ReturnType<typeof setInterval> | null = null;
   private sweepInProgress = false;
 
@@ -175,11 +173,8 @@ export class RuntimeHttpServer {
     this.port = options.port ?? DEFAULT_PORT;
     this.hostname = options.hostname ?? DEFAULT_HOSTNAME;
 
-    this.approvalCopyGenerator = options.approvalCopyGenerator;
-    this.approvalConversationGenerator = options.approvalConversationGenerator;
-    this.guardianActionCopyGenerator = options.guardianActionCopyGenerator;
-    this.guardianFollowUpConversationGenerator =
-      options.guardianFollowUpConversationGenerator;
+    this.approvalCopyGenerator = createApprovalCopyGenerator();
+    this.guardianActionCopyGenerator = createGuardianActionCopyGenerator();
     this.liveVoiceSessionManager = new LiveVoiceSessionManager({
       createSession: (context) => createLiveVoiceSession(context),
     });
@@ -560,11 +555,7 @@ export class RuntimeHttpServer {
       const endpoint = url.pathname.slice("/v1/".length).replace(/\/$/, "");
       meta = this.router.findLoggingMetadata(req.method, endpoint) ?? undefined;
     }
-    return withRequestLogging(
-      req,
-      () => this.routeRequest(req, server),
-      meta,
-    );
+    return withRequestLogging(req, () => this.routeRequest(req, server), meta);
   }
 
   private async routeRequest(

package/src/runtime/http-types.ts

@@ -14,10 +14,6 @@ import type {
 export type { SlackInboundMessageMetadata };
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { AssistantEventHub } from "./assistant-event-hub.js";
-import type {
-  ApprovalCopyGenerator,
-  GuardianActionCopyGenerator,
-} from "./message-composer-types.js";
 
 export type {
   ApprovalCopyGenerator,
@@ -61,41 +57,6 @@ export type ApprovalConversationGenerator = (
   context: ApprovalConversationContext,
 ) => Promise<ApprovalConversationResult>;
 
-// ---------------------------------------------------------------------------
-// Guardian follow-up conversation flow types
-// ---------------------------------------------------------------------------
-
-/** The disposition returned by the guardian follow-up conversation engine. */
-export type GuardianFollowUpDisposition =
-  | "call_back"
-  | "decline"
-  | "keep_pending";
-
-/** Structured result from a single turn of the guardian follow-up conversation. */
-export interface GuardianFollowUpTurnResult {
-  disposition: GuardianFollowUpDisposition;
-  replyText: string;
-}
-
-/** Input context for the guardian follow-up conversation engine. */
-export interface GuardianFollowUpConversationContext {
-  /** The original question that was asked during the voice call. */
-  questionText: string;
-  /** The guardian's late answer text that initiated the follow-up. */
-  lateAnswerText: string;
-  /** The guardian's latest reply in the follow-up conversation. */
-  guardianReply: string;
-}
-
-/**
- * Daemon-injected function that processes one turn of a guardian follow-up
- * conversation. Classifies the guardian's intent into a structured disposition
- * and produces a natural reply.
- */
-export type GuardianFollowUpConversationGenerator = (
-  context: GuardianFollowUpConversationContext,
-) => Promise<GuardianFollowUpTurnResult>;
-
 export interface RuntimeMessageConversationOptions {
   transport?: {
     channelId: ChannelId;
@@ -115,6 +76,11 @@ export interface RuntimeMessageConversationOptions {
   commandIntent?: { type: string; payload?: string; languageCode?: string };
   /** Slack-only non-persisted notice injected into the active model turn. */
   slackRuntimeContextNotice?: string;
+  /**
+   * Persisted user-facing content. When present, storage/UI use this value
+   * while the model-facing turn continues to use `content`.
+   */
+  displayContent?: string;
   /** Optional callback to receive real-time agent loop events (text deltas, tool starts, etc.). */
   onEvent?: (msg: ServerMessage) => void;
   /**
@@ -168,14 +134,6 @@ export interface RuntimeHttpServerOptions {
   port?: number;
   /** Hostname / IP to bind to. Defaults to '127.0.0.1' (loopback-only). */
   hostname?: string;
-  /** Daemon-injected generator for approval copy (provider-backed). */
-  approvalCopyGenerator?: ApprovalCopyGenerator;
-  /** Daemon-injected generator for conversational approval flow (provider-backed). */
-  approvalConversationGenerator?: ApprovalConversationGenerator;
-  /** Daemon-injected generator for guardian action copy (provider-backed). */
-  guardianActionCopyGenerator?: GuardianActionCopyGenerator;
-  /** Daemon-injected generator for guardian follow-up conversation (provider-backed). */
-  guardianFollowUpConversationGenerator?: GuardianFollowUpConversationGenerator;
 }
 
 export interface RuntimeAttachmentMetadata {
@@ -227,5 +185,19 @@ export interface RuntimeMessagePayload {
     status: string;
     error?: string;
     conversationId?: string;
+    objective?: string;
+  };
+  slackMessage?: {
+    channelId: string;
+    channelTs: string;
+    threadTs?: string;
+    messageLink?: {
+      appUrl?: string;
+      webUrl?: string;
+    };
+    threadLink?: {
+      appUrl?: string;
+      webUrl?: string;
+    };
   };
 }

package/src/runtime/migrations/origin-mode.ts

@@ -14,7 +14,7 @@
  * combination logic.
  */
 
-import { hasManagedProxyPrereqs } from "../../providers/managed-proxy/context.js";
+import { hasManagedProxyPrereqs } from "../../providers/platform-proxy/context.js";
 import { getDaemonRuntimeMode } from "../runtime-mode.js";
 
 export type VBundleOriginMode =

package/src/runtime/pending-interactions.ts

@@ -47,6 +47,7 @@ export interface PendingInteraction {
   kind:
     | "confirmation"
     | "secret"
+    | "question"
     | "host_bash"
     | "host_file"
     | "host_cu"

package/src/runtime/routes/__tests__/bookmark-routes.test.ts

@@ -241,6 +241,23 @@ describe("bookmark routes", () => {
     ).toBe("msg-6");
   });
 
+  test("duplicate POSTs only broadcast one bookmark.created event", async () => {
+    seedConversationAndMessage({
+      conversationId: "conv-dup",
+      messageId: "msg-dup",
+    });
+
+    await call(createHandler, {
+      body: { messageId: "msg-dup", conversationId: "conv-dup" },
+    });
+    await call(createHandler, {
+      body: { messageId: "msg-dup", conversationId: "conv-dup" },
+    });
+    await new Promise((r) => setTimeout(r, 0));
+
+    expect(publishedTypes()).toEqual(["bookmark.created"]);
+  });
+
   test("DELETE on a non-existent messageId does not publish", async () => {
     await call(deleteByMessageHandler, {
       pathParams: { messageId: "does-not-exist" },