@vellumai/assistant 0.11.4 → 0.11.5-staging.1

package/src/daemon/__tests__/provider-rejection-log-fields.test.ts

@@ -0,0 +1,272 @@
+/**
+ * Tests that an unclassified 4xx provider rejection logs the upstream
+ * response body (bounded) plus the offending request content-part coordinates,
+ * so the failing message can be identified from the daemon log alone.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { AssistantEvent } from "../../api/index.js";
+import { ProviderError } from "../../util/errors.js";
+import * as loggerModule from "../../util/logger.js";
+import type {
+  EventHandlerDeps,
+  EventHandlerState,
+} from "../conversation-agent-loop-handlers.js";
+import {
+  buildProviderRejectionLogFields,
+  MAX_LOGGED_UPSTREAM_BODY_CHARS,
+} from "../provider-rejection-log-fields.js";
+
+const logRecords: Record<string, unknown>[] = [];
+
+mock.module("../../util/logger.js", () => ({
+  ...loggerModule,
+  getLogger: () => ({
+    error: (record: Record<string, unknown>) => {
+      logRecords.push(record);
+    },
+    warn: () => {},
+    info: () => {},
+    debug: () => {},
+    trace: () => {},
+  }),
+}));
+
+// The handlers module binds its logger at import time, so it is loaded
+// dynamically once the logger stub is installed above.
+const { createEventHandlerState, dispatchAgentEvent } =
+  await import("../conversation-agent-loop-handlers.js");
+
+function createDeps(): EventHandlerDeps {
+  return {
+    ctx: {
+      conversationId: "conv-provider-rejection",
+      provider: { name: "openai" },
+      streamThinking: false,
+      emitActivityState: () => {},
+      markWorkspaceTopLevelDirty: () => {},
+      currentTurnSurfaces: [],
+    } as unknown as EventHandlerDeps["ctx"],
+    onEvent: (_msg: AssistantEvent) => {},
+    reqId: "req-provider-rejection",
+    isFirstMessage: false,
+    shouldGenerateTitle: false,
+    rlog: new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }) as unknown as EventHandlerDeps["rlog"],
+    turnChannelContext: {
+      userMessageChannel: "vellum",
+      assistantMessageChannel: "vellum",
+    } as EventHandlerDeps["turnChannelContext"],
+    turnInterfaceContext: {
+      userMessageInterface: "macos",
+      assistantMessageInterface: "macos",
+    } as EventHandlerDeps["turnInterfaceContext"],
+  } as EventHandlerDeps;
+}
+
+describe("buildProviderRejectionLogFields", () => {
+  test("carries the verbatim upstream body", () => {
+    // GIVEN a provider rejection that captured the upstream 400 body
+    const rawBody = JSON.stringify({
+      error: {
+        message: "Invalid body: failed to parse JSON value from the request.",
+        type: "invalid_request_error",
+        code: "invalid_body",
+      },
+    });
+    const error = new ProviderError(
+      "API error (400): Invalid body",
+      "openai",
+      400,
+      {
+        rawBody,
+        apiErrorCode: "invalid_body",
+        apiErrorType: "invalid_request_error",
+        requestId: "req_abc123",
+      },
+    );
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN the body and the upstream metadata ride the record
+    expect(fields.upstreamErrorBody).toBe(rawBody);
+    expect(fields.upstreamErrorBodyTruncated).toBeUndefined();
+    expect(fields.apiErrorCode).toBe("invalid_body");
+    expect(fields.apiErrorType).toBe("invalid_request_error");
+    expect(fields.requestId).toBe("req_abc123");
+  });
+
+  test("bounds the body to 4 KB and flags the truncation", () => {
+    // GIVEN an upstream body larger than the logged ceiling
+    const rawBody = "x".repeat(MAX_LOGGED_UPSTREAM_BODY_CHARS + 500);
+    const error = new ProviderError("API error (400): huge", "openai", 400, {
+      rawBody,
+    });
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN the logged body stops at the ceiling
+    expect(fields.upstreamErrorBody).toHaveLength(
+      MAX_LOGGED_UPSTREAM_BODY_CHARS,
+    );
+    // AND the record says the body was cut
+    expect(fields.upstreamErrorBodyTruncated).toBe(true);
+  });
+
+  test("parses the offending content-part coordinates for oversized strings", () => {
+    // GIVEN an oversized-content-part rejection naming the request position
+    const error = new ProviderError(
+      "API error (400): Invalid 'input[191].content[1].text': string too long. Expected a string with maximum length 10485760, but got a string with length 11436754 instead.",
+      "openai",
+      400,
+      { apiErrorCode: "string_above_max_length" },
+    );
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN the message and content indices are logged for a follow-up query
+    expect(fields.offendingMessageIndex).toBe(191);
+    expect(fields.offendingContentIndex).toBe(1);
+  });
+
+  test("parses coordinates out of the Chat Completions `messages[N]` shape", () => {
+    // GIVEN a rejection using the Chat Completions request shape
+    const error = new ProviderError(
+      "API error (400): Invalid 'messages[7].content[0].text': string too long.",
+      "openai",
+      400,
+      { apiErrorCode: "string_above_max_length" },
+    );
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN the same coordinates are extracted
+    expect(fields.offendingMessageIndex).toBe(7);
+    expect(fields.offendingContentIndex).toBe(0);
+  });
+
+  test("leaves coordinates absent for codes that carry no content-part pointer", () => {
+    // GIVEN a rejection whose code is outside the narrow tap
+    const error = new ProviderError(
+      "API error (400): Invalid 'input[3].content[0].text': something else.",
+      "openai",
+      400,
+      { apiErrorCode: "model_not_found" },
+    );
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN no coordinates are inferred from a coincidental match
+    expect(fields.offendingMessageIndex).toBeUndefined();
+    expect(fields.offendingContentIndex).toBeUndefined();
+  });
+
+  test("scrubs secrets out of the upstream body", () => {
+    // GIVEN an upstream body that echoed back a credential
+    const projectKey = `sk-proj-${"A".repeat(48)}`;
+    const error = new ProviderError("API error (400): bad key", "openai", 400, {
+      rawBody: JSON.stringify({
+        error: { message: `Incorrect API key provided: ${projectKey}` },
+        headers: { authorization: "Bearer some-token-value" },
+      }),
+    });
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN the credential never reaches the log record
+    expect(fields.upstreamErrorBody).not.toContain(projectKey);
+    expect(fields.upstreamErrorBody).not.toContain("some-token-value");
+    expect(fields.upstreamErrorBody).toContain("[REDACTED]");
+  });
+
+  test("reports a null body for errors that are not provider errors", () => {
+    // GIVEN a non-provider error
+    const error = new Error("socket hang up");
+
+    // WHEN diagnostic log fields are built for it
+    const fields = buildProviderRejectionLogFields(error);
+
+    // THEN the body is explicitly null rather than missing
+    expect(fields.upstreamErrorBody).toBeNull();
+  });
+});
+
+describe("unclassified 4xx log line", () => {
+  let state: EventHandlerState;
+
+  beforeEach(() => {
+    logRecords.length = 0;
+    state = createEventHandlerState();
+  });
+
+  test("includes the upstream response body", async () => {
+    // GIVEN an unclassified 4xx provider rejection carrying the upstream body
+    const rawBody = JSON.stringify({
+      error: {
+        message:
+          "Invalid body: failed to parse JSON value from the request. Common errors include trailing commas.",
+        type: "invalid_request_error",
+        code: "invalid_body",
+      },
+    });
+    const error = new ProviderError(
+      "API error (400): Invalid body: failed to parse JSON value from the request.",
+      "openai",
+      400,
+      { rawBody, apiErrorCode: "invalid_body" },
+    );
+
+    // WHEN the agent loop dispatches the error event
+    await dispatchAgentEvent(state, createDeps(), { type: "error", error });
+
+    // THEN the log record carries the body alongside the existing fields
+    const record = logRecords.find((r) => r.upstreamErrorBody !== undefined);
+    expect(record).toBeDefined();
+    expect(record?.upstreamErrorBody).toBe(rawBody);
+    expect(record?.conversationId).toBe("conv-provider-rejection");
+    expect(record?.statusCode).toBe(400);
+    expect(record?.provider).toBe("openai");
+  });
+
+  test("scrubs secrets out of the error message it logs", async () => {
+    // GIVEN a rejection whose normalized message echoes a credential
+    const error = new ProviderError(
+      "API error (400): rejected request with Authorization: Bearer some-token-value",
+      "openai",
+      400,
+      { rawBody: "{}" },
+    );
+
+    // WHEN the agent loop dispatches the error event
+    await dispatchAgentEvent(state, createDeps(), { type: "error", error });
+
+    // THEN the credential is redacted out of the logged message
+    const record = logRecords.find((r) => r.upstreamErrorBody !== undefined);
+    expect(record?.errorMessage).not.toContain("some-token-value");
+    expect(record?.errorMessage).toContain("Bearer [REDACTED]");
+  });
+
+  test("bounds a huge upstream body to 4 KB", async () => {
+    // GIVEN an unclassified 4xx rejection whose body exceeds the ceiling
+    const error = new ProviderError("API error (400): huge", "openai", 400, {
+      rawBody: "y".repeat(MAX_LOGGED_UPSTREAM_BODY_CHARS * 3),
+    });
+
+    // WHEN the agent loop dispatches the error event
+    await dispatchAgentEvent(state, createDeps(), { type: "error", error });
+
+    // THEN the logged body is capped
+    const record = logRecords.find((r) => r.upstreamErrorBody !== undefined);
+    expect(record?.upstreamErrorBody).toHaveLength(
+      MAX_LOGGED_UPSTREAM_BODY_CHARS,
+    );
+    expect(record?.upstreamErrorBodyTruncated).toBe(true);
+  });
+});

package/src/daemon/conversation-agent-loop-handlers.ts

@@ -89,6 +89,7 @@ import {
 } from "../usage/pricing.js";
 import { ProviderError } from "../util/errors.js";
 import { faviconUrlForDomain } from "../util/favicon.js";
+import { redactLogString } from "../util/log-redact.js";
 import { getLogger } from "../util/logger.js";
 import { withSqliteRetry } from "../util/sqlite-retry.js";
 import type { DirectiveRequest } from "./assistant-attachments.js";
@@ -143,6 +144,7 @@ import type {
   WebSearchResultItem,
 } from "./message-types/web-activity.js";
 import { referenceMediaBlocksForPersist } from "./persist-media-references.js";
+import { buildProviderRejectionLogFields } from "./provider-rejection-log-fields.js";
 import { turnOrRestingTrust } from "./trust-context-types.js";
 import type { TurnLatencyTracker } from "./turn-latency-tracker.js";
 
@@ -2708,7 +2710,8 @@ function handleError(
           event.error instanceof ProviderError
             ? event.error.provider
             : undefined,
-        errorMessage: event.error.message,
+        errorMessage: redactLogString(event.error.message),
+        ...buildProviderRejectionLogFields(event.error),
       },
       "Provider rejected request with unclassified 4xx error",
     );

package/src/daemon/conversation-error.ts

@@ -11,6 +11,7 @@ import {
   isImageDimensionsTooLargeError,
   isImageMediaTypeMismatchError,
   isImageUnprocessableError,
+  isImageUnsupportedFormatError,
 } from "../plugins/defaults/image-recovery/detect.js";
 import { ConnectionResolutionError } from "../providers/connection-resolution.js";
 import { PROVIDER_CATALOG } from "../providers/model-catalog.js";
@@ -539,6 +540,18 @@ function classifyCore(
           errorCategory: "image_media_type_mismatch",
         };
       }
+      if (isImageUnsupportedFormatError(message)) {
+        // Same wire-code reuse as image_unprocessable above. The provider read
+        // the bytes and found no image it accepts, so no relabel or resize can
+        // rescue the attachment: name the accepted formats instead.
+        return {
+          code: "IMAGE_TOO_LARGE",
+          userMessage:
+            "An image in this conversation is not in a format the AI provider accepts (PNG, JPEG, GIF, and WebP are). Remove or convert it and send your message again.",
+          retryable: false,
+          errorCategory: "image_unsupported_format",
+        };
+      }
       if (isVisionNotSupportedError(message)) {
         return visionNotSupportedClassification();
       }

package/src/daemon/conversation-messaging.ts

@@ -69,6 +69,7 @@ import type { UserMessageAttachment } from "./message-protocol.js";
 import type { ConversationTransportMetadata } from "./message-types/conversations.js";
 import type { TrustContext } from "./trust-context-types.js";
 import { restingTrust } from "./trust-context-types.js";
+import { postUnsendableImageNotice } from "./unsendable-image-notice.js";
 
 const log = getLogger("conversation-messaging");
 
@@ -855,7 +856,6 @@ export async function persistQueuedMessageBody(
       filePath: attachment.filePath,
     }),
   );
-  const cleanMessage = await createUserMessage(content, attachmentInputs);
   let pushedToHistory = false;
 
   try {
@@ -1015,6 +1015,14 @@ export async function persistQueuedMessageBody(
       attachmentInputs,
     );
 
+    // The turn sees exactly what was persisted: an attachment rejected during
+    // materialization is absent from both, so a file the store refused cannot
+    // reach the model through the in-memory message.
+    const sentAttachments = preparedAttachments.map(
+      (p) => attachmentInputs[p.position],
+    );
+    const cleanMessage = await createUserMessage(content, sentAttachments);
+
     // When displayContent is provided (e.g. original text before recording
     // intent stripping), persist that to DB so users see the full message
     // after restart. The in-memory userMessage (sent to the LLM) still uses
@@ -1119,7 +1127,7 @@ export async function persistQueuedMessageBody(
 
     const llmMessage = enrichMessageWithSourcePaths(
       cleanMessage,
-      attachmentInputs,
+      sentAttachments,
     );
     log.info(
       {
@@ -1144,6 +1152,18 @@ export async function persistQueuedMessageBody(
       );
     }
 
+    // Read after the content is final (including any link-failure repair), so
+    // the notice describes the blocks the send boundary will actually see.
+    const persistedImages = preparedAttachments.flatMap((p, idx) => {
+      const block = repairedBlocks?.[idx] ?? p.block;
+      if (block.type !== "image") {
+        return [];
+      }
+      const { filename } = attachmentInputs[p.position];
+      return [{ filename, source: block.source }];
+    });
+    await postUnsendableImageNotice(ctx.conversationId, persistedImages);
+
     return { id: persistedUserMessage.id, deduplicated: false };
   } catch (err) {
     if (pushedToHistory) {

package/src/daemon/conversation-process.ts

@@ -1827,6 +1827,13 @@ export interface ProcessMessageOptions {
   displayContent?: string;
   /** JWT-verified committer principal for turn-scoped host-proxy authorization. */
   sourceActorPrincipalId?: string;
+  /**
+   * The actor this turn is being started for. Stamped onto the conversation
+   * before history is scoped, so the run hydrates as its committer rather
+   * than as whoever last left the resting slot set. Callers with no actor of
+   * their own (internal dispatch) omit it and the resting actor stands.
+   */
+  trustContext?: TrustContext;
   /**
    * True when this turn was auto-sent on the user's behalf rather than typed
    * (see `PersistMessageOptions.scripted`). Forwarded to persistence so the
@@ -1873,7 +1880,11 @@ export async function processMessage(
     sourceActorPrincipalId,
     scripted,
     metadata: callerMetadata,
+    trustContext: committingTrustContext,
   } = options;
+  if (committingTrustContext) {
+    conversation.setTrustContext(committingTrustContext);
+  }
   await conversation.ensureActorScopedHistory();
   // Snapshot persona context at turn start so later tool turns can't pick up
   // a different actor's context if a concurrent request mutates the live fields.

package/src/daemon/conversation-store.ts

@@ -151,6 +151,13 @@ function applyTransportMetadata(
  *
  * Handles provider setup, rate limiting, system prompt, memory policy,
  * and conversation hydration.
+ *
+ * The in-memory Conversation snapshots the tool registry at construction.
+ * An empty snapshot is an empty tool list on the wire for the life of the
+ * instance, so the create path initializes the registry before that
+ * constructor runs. A hit in `findConversation` already has its snapshot.
+ * `initializeTools` is idempotent: a process that already initialized at
+ * boot awaits the settled promise.
  */
 export async function getOrCreateConversation(
   conversationId: string,
@@ -228,6 +235,9 @@ export async function getOrCreateConversation(
       const systemPrompt = await resolveInitialSystemPrompt(storedOptions);
       const maxTokens = storedOptions?.maxResponseTokens;
 
+      const { initializeTools } = await import("../tools/registry.js");
+      await initializeTools();
+
       const newConversation = new Conversation(
         conversationId,
         provider,

package/src/daemon/conversation-surfaces.ts

@@ -85,6 +85,8 @@ import type {
 } from "./message-protocol.js";
 import { INTERACTIVE_SURFACE_TYPES } from "./message-protocol.js";
 import { isRowVisibleToUntrustedActor } from "./message-provenance.js";
+import type { TrustContext } from "./trust-context-types.js";
+import { restingTrust } from "./trust-context-types.js";
 export {
   buildSurfaceShowPair,
   type CurrentTurnSurface,
@@ -1904,7 +1906,13 @@ export async function handleSurfaceAction(
   // reconstruct the same-user binding for host proxies (CU / app-control),
   // mirroring the normal message path.
   sourceActorPrincipalId?: string,
+  // Trust of the actor committing this action, resolved by the route from the
+  // verified requester. Passed rather than read back off the conversation so a
+  // click that lands mid-turn is attributed to its clicker instead of to
+  // whoever occupies the resting slot.
+  requesterTrustContext?: TrustContext,
 ): Promise<SurfaceActionResult> {
+  const actionTrustContext = requesterTrustContext ?? restingTrust(ctx);
   // ── Standalone surface interception ──────────────────────────────
   // Daemon-driven surfaces (from `requestInteractiveUi`) register a
   // pending entry in `pendingStandaloneSurfaces`. When the user clicks
@@ -2050,7 +2058,7 @@ export async function handleSurfaceAction(
     // `await` resolves as soon as the conversation is created + titled +
     // published to the event hub. The HTTP POST /v1/surface-actions
     // response returns promptly — the seed turn runs in the background.
-    const originTrustContext = ctx.trustContext;
+    const originTrustContext = actionTrustContext;
     const { conversationId } = await launchConversation({
       title,
       seedPrompt,
@@ -2069,14 +2077,11 @@ export async function handleSurfaceAction(
     return { accepted: true, conversationId };
   }
 
-  // Trust of the actor committing THIS action. `POST /v1/surface-actions`
-  // stamps the verified requester's trust onto the conversation before
-  // dispatching here, and `loadFromDb` derives the live history filter from
-  // the same value, so the completion path's persisted read stays scoped to
-  // exactly what this actor's live view would have held. Unresolvable trust
-  // fails closed to the untrusted filter.
+  // Trust of the actor committing THIS action, so the completion path's
+  // persisted read stays scoped to exactly what this actor's live view would
+  // have held. Unresolvable trust fails closed to the untrusted filter.
   const requesterCanAccessMemory = resolveCapabilities(
-    ctx.trustContext?.trustClass,
+    actionTrustContext?.trustClass,
   ).canAccessMemory;
 
   const pending = ctx.pendingSurfaceActions.get(surfaceId);
@@ -2222,6 +2227,7 @@ export async function handleSurfaceAction(
       activeSurfaceId: surfaceId,
       displayContent,
       sourceActorPrincipalId,
+      trustContext: actionTrustContext,
       isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
       // Rides the metadata bag rather than a typed option: the queue
       // round-trips `metadata` but not `PersistMessageOptions`.
@@ -2285,6 +2291,9 @@ export async function handleSurfaceAction(
         activeSurfaceId: surfaceId,
         displayContent,
         sourceActorPrincipalId,
+        // Reached only when `enqueueMessage` declined to queue: the click is
+        // starting this turn, so it is the actor the run belongs to.
+        trustContext: actionTrustContext,
         isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
         scripted: isSyntheticSurfaceActionContent(content),
       })
@@ -2472,6 +2481,7 @@ export async function handleSurfaceAction(
     activeSurfaceId: surfaceId,
     displayContent,
     sourceActorPrincipalId,
+    trustContext: actionTrustContext,
     isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
     // Rides the metadata bag rather than a typed option: the queue
     // round-trips `metadata` but not `PersistMessageOptions`.
@@ -2545,6 +2555,9 @@ export async function handleSurfaceAction(
       activeSurfaceId: surfaceId,
       displayContent,
       sourceActorPrincipalId,
+      // Same as the history-restored branch: the enqueue declined, so this
+      // click is the turn about to run.
+      trustContext: actionTrustContext,
       isInteractive: SURFACE_ACTION_TURN_IS_INTERACTIVE,
       scripted: isSyntheticSurfaceActionContent(content),
     })

package/src/daemon/conversation.ts

@@ -1119,11 +1119,10 @@ export class Conversation {
       preStrippedCount = boundary === -1 ? slicedDbMessages.length : boundary;
     }
 
-    // The injection-time personal-memory gate, so background/local
-    // conversations (sourceChannel `undefined` or `"vellum"`) can rehydrate
-    // the persisted v2 static memory block. The shared helper folds in the
-    // HTTP-auth-disabled dev bypass so rehydration and injection agree on the
-    // effective trust class.
+    // The injection-time personal-memory gate, so rehydration of the persisted
+    // blocks admits exactly the actors injection would. The shared helper folds
+    // in the HTTP-auth-disabled dev bypass, so a turn with no bound actor
+    // resolves the same way on both paths.
     const personalMemoryAllowed = isPersonalMemoryAllowed(this.trustContext);
     // Pruned v3 card slugs, read lazily on the first row that carries a v3
     // block (most conversations carry none, so most loads never query). The
@@ -1513,11 +1512,12 @@ export class Conversation {
 
   async ensureActorScopedHistory(): Promise<void> {
     const currentTrustClass = this.trustContext?.trustClass;
-    // `loadFromDb` gates personal-memory rehydration on `sourceChannel` too
-    // (via `isPersonalMemoryAllowed`), so a same-trust-class reuse from a
-    // different channel (e.g. internal `vellum` → remote channel) must also
-    // trigger a reload. Otherwise stale personal-memory blocks can leak to
-    // an untrusted remote turn, or be hidden when they should be present.
+    // Tracked alongside the trust class because `loadFromDb` gates
+    // personal-memory rehydration on `isPersonalMemoryAllowed`, which folds in
+    // the disabled-auth elevation of an unbound actor: two contexts can share a
+    // trust class and still differ here. A reuse that changes the answer has to
+    // reload, or stale personal-memory blocks persist into a turn that must not
+    // see them, or stay stripped from one that should.
     const currentPersonalMemoryAllowed = isPersonalMemoryAllowed(
       this.trustContext,
     );
@@ -2829,6 +2829,7 @@ export class Conversation {
     actionId: string,
     data?: Record<string, unknown>,
     sourceActorPrincipalId?: string,
+    requesterTrustContext?: TrustContext,
   ): Promise<SurfaceActionResult> {
     return handleSurfaceActionImpl(
       this,
@@ -2836,6 +2837,7 @@ export class Conversation {
       actionId,
       data,
       sourceActorPrincipalId,
+      requesterTrustContext,
     );
   }
 

package/src/daemon/lifecycle.ts

@@ -98,6 +98,7 @@ import {
   registerMessagingProviders,
   registerWatcherProviders,
 } from "./providers-setup.js";
+import { startResourcePressureGuardForLifecycle } from "./resource-pressure-guard-lifecycle.js";
 import { installShutdownHandlers } from "./shutdown-handlers.js";
 import { broadcastDaemonStatus } from "./status.js";
 
@@ -197,8 +198,10 @@ export async function runDaemon(): Promise<void> {
     }
   }
 
-  // Start the runtime HTTP server early so /healthz answers ASAP. A bind
-  // failure is non-fatal — the daemon falls back to IPC-only operation.
+  // Start the runtime HTTP server early so /healthz answers ASAP. Throws on
+  // EADDRINUSE to abort startup: another process holds the port every HTTP
+  // client (and the gateway's /v1/* proxy) targets, so an IPC-only daemon
+  // would look healthy while all HTTP traffic 502s.
   await startRuntimeHttpServer();
 
   // Warms the configured-probe cache (credential reads only, no DB). Fired
@@ -700,6 +703,7 @@ export async function runDaemon(): Promise<void> {
 
   startUsageTelemetryReporter();
   startDiskPressureGuardForLifecycle();
+  startResourcePressureGuardForLifecycle();
   startOrphanReaper();
   startEventLoopWatchdog();
 

package/src/daemon/message-types/conversations.ts

@@ -48,18 +48,16 @@ interface BaseTransportMetadata {
 }
 
 /**
- * Transport metadata for interfaces that support the full desktop host-proxy
- * set (see `HostProxyInterfaceId` / `supportsHostProxy`). Carries the host
+ * Transport metadata for interfaces that support desktop host-proxy tools
+ * (see `HostProxyInterfaceId` / `supportsHostProxy`). Carries the host
  * environment fields the client reports so the `<workspace>` block renders
  * the user's actual machine rather than a containerized daemon's own OS.
  *
- * Today this variant is populated only by the macOS client, but the shape
- * is capability-keyed (not interface-name-keyed) so future host-capable
- * clients (e.g. a native Linux or Windows desktop) get the same treatment
- * automatically when added to `HostProxyInterfaceId`.
+ * The shape is capability-keyed so each native desktop client gets the same
+ * host-environment treatment through `HostProxyInterfaceId`.
  */
 export interface HostProxyTransportMetadata extends BaseTransportMetadata {
-  /** Interface identifier — restricted to interfaces that support host proxies. */
+  /** Interface identifier restricted to interfaces that support host proxies. */
   interfaceId: HostProxyInterfaceId;
   /** Home directory of the user on the host machine (e.g. `NSHomeDirectory()`). */
   hostHomeDir?: string;