@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/agent/image-optimize.ts

@@ -1,18 +1,5 @@
-import { execFileSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-  unlinkSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
 import { parseImageDimensions } from "../context/image-dimensions.js";
+import { convertImageToJpeg } from "../util/image-conversion.js";
 
 // Anthropic's documented max dimension — images larger than this are scaled
 // down server-side anyway, so pre-scaling is zero quality loss.
@@ -28,110 +15,6 @@ const MAX_TRANSPORT_BYTES = Math.floor(3.5 * 1024 * 1024); // ~3.5 MB raw
 
 const JPEG_QUALITY = 80;
 
-// Content-addressed disk cache to avoid re-running sips on the same image.
-const CACHE_MAX_ENTRIES = 500;
-
-function getCacheDir(): string {
-  return join(tmpdir(), "vellum-optimized-images");
-}
-
-function readFromCache(
-  key: string,
-): { data: string; mediaType: string } | null {
-  try {
-    const cachePath = join(getCacheDir(), `${key}.jpg`);
-    if (!existsSync(cachePath)) return null;
-    const buf = readFileSync(cachePath) as Buffer;
-    return { data: buf.toString("base64"), mediaType: "image/jpeg" };
-  } catch {
-    return null;
-  }
-}
-
-function writeToCache(key: string, optimizedBytes: Buffer): void {
-  try {
-    const dir = getCacheDir();
-    mkdirSync(dir, { recursive: true });
-    writeFileSync(join(dir, `${key}.jpg`), optimizedBytes);
-    evictIfNeeded(dir);
-  } catch {
-    // Cache write failure is non-fatal.
-  }
-}
-
-function evictIfNeeded(dir: string): void {
-  try {
-    const entries = readdirSync(dir)
-      .filter((f) => f.endsWith(".jpg"))
-      .map((f) => {
-        const full = join(dir, f);
-        return { path: full, mtimeMs: statSync(full).mtimeMs };
-      })
-      .sort((a, b) => a.mtimeMs - b.mtimeMs);
-    const excess = entries.length - CACHE_MAX_ENTRIES;
-    for (let i = 0; i < excess; i++) {
-      try {
-        unlinkSync(entries[i]!.path);
-      } catch {
-        /* ignore */
-      }
-    }
-  } catch {
-    /* ignore */
-  }
-}
-
-function runSips(inputBytes: Buffer): Buffer | null {
-  const srcPath = join(tmpdir(), `vellum-img-opt-${Date.now()}-src`);
-  const outPath = join(tmpdir(), `vellum-img-opt-${Date.now()}-out.jpg`);
-  try {
-    writeFileSync(srcPath, inputBytes);
-    execFileSync(
-      "sips",
-      [
-        "--resampleHeightWidthMax",
-        String(MAX_DIMENSION),
-        "-s",
-        "format",
-        "jpeg",
-        "-s",
-        "formatOptions",
-        String(JPEG_QUALITY),
-        srcPath,
-        "--out",
-        outPath,
-      ],
-      { stdio: "pipe", timeout: 15_000 },
-    );
-    return readFileSync(outPath) as Buffer;
-  } catch {
-    return null;
-  } finally {
-    try {
-      unlinkSync(srcPath);
-    } catch {
-      /* ignore */
-    }
-    try {
-      unlinkSync(outPath);
-    } catch {
-      /* ignore */
-    }
-  }
-}
-
-/**
- * Downscale a base64 image to fit within Anthropic's recommended dimensions
- * (1568px max side). Returns the original data unchanged if the image is
- * already small enough or if optimization fails.
- *
- * Anthropic applies the same scaling server-side, so this is zero quality
- * loss — we just do it pre-flight to keep request payloads small and avoid
- * 413 "request too large" errors when many images accumulate in context.
- *
- * Results are cached on disk by content hash so repeated sends of the same
- * image (or daemon restarts) skip the sips call entirely.
- */
 /**
  * Decide whether an image needs to be rescaled before sending.
  *
@@ -157,6 +40,18 @@ export function shouldRescaleImage(
   return byteLength > OPTIMIZE_THRESHOLD_BYTES;
 }
 
+/**
+ * Downscale a base64 image to fit within Anthropic's recommended dimensions
+ * (1568px max side). Returns the original data unchanged if the image is
+ * already small enough or if optimization fails.
+ *
+ * Anthropic applies the same scaling server-side, so this is zero quality
+ * loss — we just do it pre-flight to keep request payloads small and avoid
+ * 413 "request too large" errors when many images accumulate in context.
+ *
+ * Conversion (and its content-addressed disk cache) is shared with attachment
+ * storage normalization — see `util/image-conversion.ts`.
+ */
 export function optimizeImageForTransport(
   base64Data: string,
   mediaType: string,
@@ -168,18 +63,13 @@ export function optimizeImageForTransport(
     return { data: base64Data, mediaType };
   }
 
-  // Content-addressed cache lookup.
-  const hash = createHash("sha256").update(rawBytes).digest("hex");
-  const cacheKey = hash.slice(0, 16);
-  const cached = readFromCache(cacheKey);
-  if (cached) return cached;
-
-  // Run sips (macOS). On other platforms this gracefully returns null.
-  const optimized = runSips(rawBytes);
+  const optimized = convertImageToJpeg(rawBytes, {
+    maxDimensionPx: MAX_DIMENSION,
+    quality: JPEG_QUALITY,
+  });
   if (!optimized) {
     return { data: base64Data, mediaType };
   }
 
-  writeToCache(cacheKey, optimized);
   return { data: optimized.toString("base64"), mediaType: "image/jpeg" };
 }

package/src/agent/loop.ts

@@ -4,6 +4,7 @@ import { getConfig } from "../config/loader.js";
 import { isMemoryV3Live } from "../config/memory-v3-gate.js";
 import type { LLMCallSite } from "../config/schemas/llm.js";
 import { recordEstimate } from "../context/estimator-calibration.js";
+import { preModelCallSanitize } from "../context/outbound-sanitize.js";
 import {
   estimatePromptTokensRaw,
   estimatePromptTokensWithTools,
@@ -14,7 +15,10 @@ import { spoolAndStubOversizedToolResults } from "../context/tool-result-spool.j
 import type { ToolActivityMetadata } from "../daemon/message-types/web-activity.js";
 import { parseActualTokensFromError } from "../daemon/parse-actual-tokens-from-error.js";
 import type { TrustContext } from "../daemon/trust-context.js";
-import { stripHistoricalWebSearchResults } from "../daemon/web-search-history.js";
+import {
+  timeSyncSection,
+  traceAsyncSection,
+} from "../persistence/slow-sync-log.js";
 import { HOOKS } from "../plugin-api/constants.js";
 import type {
   AgentLoopExitReason,
@@ -818,6 +822,19 @@ export class AgentLoop {
     this.compactionCircuit = new CompactionCircuit(this.conversationId);
   }
 
+  /**
+   * Replace the system prompt used by subsequent runs. The conversation pushes
+   * a freshly resolved prompt here between turns when its persona context
+   * (trust, channel, persona override) changed, so a conversation that binds
+   * that context after construction (e.g. a voice call resolving the caller's
+   * identity after the loop is built) does not stay pinned to the
+   * construction-time persona. An in-flight `run()` keeps its own snapshot
+   * (`runSystemPrompt`), so this never changes the prompt mid-run.
+   */
+  setSystemPrompt(systemPrompt: string): void {
+    this.systemPrompt = systemPrompt;
+  }
+
   /**
    * Resolve the tool definitions sent to the provider for the given turn.
    *
@@ -1494,15 +1511,20 @@ export class AgentLoop {
         // the existing correction) so the calibrator learns the true
         // bias against provider ground truth instead of ratcheting a
         // feedback loop against its own corrected output.
-        const toolTokenBudget =
-          currentTools.length > 0 ? estimateToolsTokens(currentTools) : 0;
-        const preSendEstimatedTokens = estimatePromptTokensRaw(
-          history,
-          runSystemPrompt,
-          {
-            providerName: getCalibrationProviderKey(this.provider),
-            toolTokenBudget,
+        const preSendEstimatedTokens = timeSyncSection(
+          "agent-loop:estimate-prompt-tokens",
+          () => {
+            const toolTokenBudget =
+              currentTools.length > 0 ? estimateToolsTokens(currentTools) : 0;
+            return estimatePromptTokensRaw(history, runSystemPrompt, {
+              providerName: getCalibrationProviderKey(this.provider),
+              toolTokenBudget,
+            });
           },
+          (estimatedTokens) => ({
+            estimatedTokens,
+            messageCount: history.length,
+          }),
         );
         lastPreSendEstimatedTokens = preSendEstimatedTokens;
         rlog.info({ turn: toolUseTurns }, "LLM call start");
@@ -1510,7 +1532,11 @@ export class AgentLoop {
         // Sanitize the outbound history right before sending: drop accumulated
         // media, collapse old AX-tree snapshots, and convert historical
         // web-search results to text. See {@link preModelCallSanitize}.
-        const providerHistory = preModelCallSanitize(history);
+        const providerHistory = timeSyncSection(
+          "agent-loop:pre-model-call-sanitize",
+          () => preModelCallSanitize(history),
+          (sanitized) => ({ messageCount: sanitized.length }),
+        );
 
         // A `pre-model-call` hook (below) can defer this turn's assistant
         // output; when set, the live text stream is held so an
@@ -1621,9 +1647,9 @@ export class AgentLoop {
             deferAssistantOutput: false,
             logger: rlog,
           };
-          const finalPreModelCtx = await runHook(
-            HOOKS.PRE_MODEL_CALL,
-            preModelCtx,
+          const finalPreModelCtx = await traceAsyncSection(
+            "agent-loop:pre-model-call-hook",
+            () => runHook(HOOKS.PRE_MODEL_CALL, preModelCtx),
           );
           // Emit a changed event when the hook mutated the prompt. Compare
           // against the pre-hook value from providerOptions, not
@@ -1692,9 +1718,8 @@ export class AgentLoop {
         latencyTracker?.mark("request_sent");
         let response: ProviderResponse;
         try {
-          response = await this.provider.sendMessage(
-            providerHistory,
-            providerOptions,
+          response = await traceAsyncSection("agent-loop:provider-send", () =>
+            this.provider.sendMessage(providerHistory, providerOptions),
           );
         } catch (llmCallError) {
           // Skip recording on abort — the user cancelled the request and
@@ -1790,7 +1815,10 @@ export class AgentLoop {
               decision: "stop",
               logger: rlog,
             };
-            const result = await runHook(HOOKS.POST_MODEL_CALL, ctx);
+            const result = await traceAsyncSection(
+              "agent-loop:post-model-call-hook",
+              () => runHook(HOOKS.POST_MODEL_CALL, ctx),
+            );
             return {
               finalized: { role: "assistant", content: result.content },
               decision: result.decision,
@@ -2492,178 +2520,3 @@ export class AgentLoop {
     };
   }
 }
-
-/** Number of most-recent AX tree snapshots to keep in conversation history. */
-const MAX_AX_TREES_IN_HISTORY = 2;
-
-/** Regex that matches the `<ax-tree>...</ax-tree>` markers. */
-const AX_TREE_PATTERN = /<ax-tree>[\s\S]*?<\/ax-tree>/g;
-const AX_TREE_PLACEHOLDER = "<ax_tree_omitted />";
-
-/**
- * Escapes any literal `</ax-tree>` occurrences inside AX tree content so
- * that the non-greedy compaction regex (`AX_TREE_PATTERN`) does not stop
- * prematurely when the user happens to be viewing XML/HTML source that
- * contains the closing tag.  The escaped content does not need to be
- * unescaped because compaction replaces the entire block with a placeholder.
- */
-export function escapeAxTreeContent(content: string): string {
-  return content.replace(/<\/ax-tree>/gi, "&lt;/ax-tree&gt;");
-}
-
-/**
- * Returns a shallow copy of `messages` where all but the most recent
- * `MAX_AX_TREES_IN_HISTORY` `<ax-tree>` blocks have been replaced with a
- * short placeholder.  This keeps the conversation context small so that
- * TTFT does not grow linearly with step count in computer-use sessions.
- *
- * Counting is per-block, not per-message — a single user message can
- * contain multiple tool_result blocks each with their own AX tree snapshot.
- */
-export function compactAxTreeHistory(messages: Message[]): Message[] {
-  // Collect (messageIndex, blockIndex) for every tool_result block with <ax-tree>
-  const axBlocks: Array<{ msgIdx: number; blockIdx: number }> = [];
-  for (let i = 0; i < messages.length; i++) {
-    const msg = messages[i];
-    if (msg.role !== "user") continue;
-    for (let j = 0; j < msg.content.length; j++) {
-      const block = msg.content[j];
-      if (
-        block.type === "tool_result" &&
-        typeof block.content === "string" &&
-        block.content.includes("<ax-tree>")
-      ) {
-        axBlocks.push({ msgIdx: i, blockIdx: j });
-      }
-    }
-  }
-
-  if (axBlocks.length <= MAX_AX_TREES_IN_HISTORY) {
-    return messages;
-  }
-
-  // Build a set of "msgIdx:blockIdx" keys for blocks that should be stripped
-  const toStrip = new Set(
-    axBlocks
-      .slice(0, -MAX_AX_TREES_IN_HISTORY)
-      .map((b) => `${b.msgIdx}:${b.blockIdx}`),
-  );
-
-  return messages.map((msg, idx) => {
-    // Quick check: does this message have any blocks to strip?
-    const hasStripTarget = msg.content.some((_, j) =>
-      toStrip.has(`${idx}:${j}`),
-    );
-    if (!hasStripTarget) return msg;
-
-    return {
-      ...msg,
-      content: msg.content.map((block, j) => {
-        if (
-          toStrip.has(`${idx}:${j}`) &&
-          block.type === "tool_result" &&
-          typeof block.content === "string"
-        ) {
-          return {
-            ...block,
-            content: block.content.replace(
-              AX_TREE_PATTERN,
-              AX_TREE_PLACEHOLDER,
-            ),
-          };
-        }
-        return block;
-      }),
-    };
-  });
-}
-
-/**
- * Strip image contentBlocks from all tool_result blocks except those in the
- * most recent user message that contains tool_result blocks. This prevents
- * screenshots from accumulating in the context window — each image is seen
- * once by the LLM on the turn it was captured, then replaced with a text
- * placeholder on subsequent turns.
- *
- * We target the last user message with tool_results (not just the last user
- * message) because a plain-text user message may follow the tool-result
- * turn. Using the last user message unconditionally would leave the most
- * recent tool screenshots unprotected from stripping.
- */
-function stripOldMediaBlocks(history: Message[]): Message[] {
-  // Find the last user message that contains tool_result blocks.
-  let lastToolResultUserIdx = -1;
-  for (let i = history.length - 1; i >= 0; i--) {
-    if (
-      history[i].role === "user" &&
-      history[i].content.some((b) => b.type === "tool_result")
-    ) {
-      lastToolResultUserIdx = i;
-      break;
-    }
-  }
-
-  return history.map((msg, idx) => {
-    // Keep the most recent tool-result user message intact (current turn)
-    if (idx === lastToolResultUserIdx || msg.role !== "user") return msg;
-
-    // Check if any tool_result blocks carry embedded media (image or audio).
-    const isMedia = (cb: ContentBlock) =>
-      cb.type === "image" || cb.type === "file";
-    const hasMedia = msg.content.some(
-      (b) =>
-        b.type === "tool_result" &&
-        (b as ToolResultContent).contentBlocks?.some(isMedia),
-    );
-    if (!hasMedia) return msg;
-
-    // Strip media from tool_result blocks, replacing with a text marker. The
-    // model already saw/heard the media in the turn it was captured; resending
-    // the bytes every turn (a 12 MB audio clip isn't optimized like images)
-    // bloats the request until compaction.
-    return {
-      ...msg,
-      content: msg.content.map((b) => {
-        if (b.type !== "tool_result") return b;
-        const tr = b as ToolResultContent;
-        if (!tr.contentBlocks?.some(isMedia)) return b;
-        return {
-          ...tr,
-          contentBlocks: undefined,
-          content:
-            (tr.content || "") +
-            "\n[Media (image/audio) was captured and shown previously — binary data removed to save context.]",
-        };
-      }),
-    };
-  });
-}
-
-/**
- * Sanitize the outbound history immediately before a provider call, bundling
- * the pre-send transforms the loop applies to every request:
- * - {@link stripOldMediaBlocks} drops accumulated screenshot/audio bytes from
- *   older tool results — the model saw the media on the turn it was captured.
- * - {@link compactAxTreeHistory} collapses all but the most recent few
- *   `<ax-tree>` snapshots so TTFT does not grow linearly with step count.
- * - {@link stripHistoricalWebSearchResults} converts historical
- *   `web_search_tool_result` blocks to text summaries; Anthropic's opaque
- *   `encrypted_content` tokens expire / are route-scoped, and replaying a stale
- *   one is rejected with `Invalid encrypted_content in search_result block`.
- *
- * Transforms the outbound copy only — the durable history keeps the rich
- * originals and each send re-derives the sanitized projection (every transform
- * is idempotent). Because it runs unconditionally before every provider call,
- * it is the single place where oversized media and expired web-search tokens
- * are guaranteed to be removed from a request.
- *
- * This is outbound-request preparation and should eventually move to a default
- * `pre-model-call` plugin hook ({@link HOOKS.PRE_MODEL_CALL}) once that hook's
- * context carries the outbound message list; for now it lives inline next to
- * the provider call it guards.
- */
-export function preModelCallSanitize(history: Message[]): Message[] {
-  const mediaStripped = stripOldMediaBlocks(history);
-  const axCompacted = compactAxTreeHistory(mediaStripped);
-  return stripHistoricalWebSearchResults(axCompacted).messages;
-}

package/src/api/events/background-tool-completed.test.ts

@@ -0,0 +1,51 @@
+import { describe, expect, test } from "bun:test";
+
+import { BackgroundToolCompletedEventSchema } from "./background-tool-completed.js";
+
+describe("BackgroundToolCompletedEventSchema", () => {
+  test("parses a completed event with exit code and output", () => {
+    const event = {
+      type: "background_tool_completed" as const,
+      id: "bg-1a2b3c4d",
+      conversationId: "conv-abc",
+      status: "completed" as const,
+      exitCode: 0,
+      output: "done\n",
+      completedAt: 1_700_000_001_000,
+    };
+
+    const result = BackgroundToolCompletedEventSchema.safeParse(event);
+
+    expect(result.success).toBe(true);
+    expect(result.success && result.data).toEqual(event);
+  });
+
+  test("parses a completed event without the optional fields", () => {
+    const event = {
+      type: "background_tool_completed" as const,
+      id: "bg-1a2b3c4d",
+      conversationId: "conv-abc",
+      status: "cancelled" as const,
+      completedAt: 1_700_000_001_000,
+    };
+
+    const result = BackgroundToolCompletedEventSchema.safeParse(event);
+
+    expect(result.success).toBe(true);
+    expect(result.success && result.data).toEqual(event);
+  });
+
+  test("strips an unrecognized field for forward compatibility", () => {
+    const result = BackgroundToolCompletedEventSchema.safeParse({
+      type: "background_tool_completed",
+      id: "bg-1a2b3c4d",
+      conversationId: "conv-abc",
+      status: "failed",
+      completedAt: 1_700_000_001_000,
+      unexpected: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.success && "unexpected" in result.data).toBe(false);
+  });
+});

package/src/api/events/background-tool-completed.ts

@@ -0,0 +1,29 @@
+/**
+ * `background_tool_completed` SSE event.
+ *
+ * Server → client notification that a background bash/host_bash command
+ * has finished. Carries the background-tool identity (`id`), scoping
+ * (`conversationId`), the terminal `status`, the optional `exitCode` and
+ * captured `output`, and the `completedAt` timestamp.
+ *
+ * Canonical wire-contract source. Re-exported to external consumers via
+ * `@vellumai/assistant-api` (the `api/index.ts` barrel).
+ */
+
+import { z } from "zod";
+
+// No `.strict()`: unknown server-added fields are stripped, not rejected, so a
+// future field can't make older clients drop the whole lifecycle event.
+export const BackgroundToolCompletedEventSchema = z.object({
+  type: z.literal("background_tool_completed"),
+  id: z.string(),
+  conversationId: z.string(),
+  status: z.enum(["completed", "failed", "cancelled"]),
+  exitCode: z.number().nullable().optional(),
+  output: z.string().optional(),
+  completedAt: z.number(),
+});
+
+export type BackgroundToolCompletedEvent = z.infer<
+  typeof BackgroundToolCompletedEventSchema
+>;

package/src/api/events/background-tool-started.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test";
+
+import { BackgroundToolStartedEventSchema } from "./background-tool-started.js";
+
+describe("BackgroundToolStartedEventSchema", () => {
+  test("parses a started event", () => {
+    const event = {
+      type: "background_tool_started" as const,
+      id: "bg-1a2b3c4d",
+      toolName: "bash",
+      conversationId: "conv-abc",
+      command: "sleep 30 && echo done",
+      startedAt: 1_700_000_000_000,
+    };
+
+    const result = BackgroundToolStartedEventSchema.safeParse(event);
+
+    expect(result.success).toBe(true);
+    expect(result.success && result.data).toEqual(event);
+  });
+
+  test("strips an unrecognized field for forward compatibility", () => {
+    const result = BackgroundToolStartedEventSchema.safeParse({
+      type: "background_tool_started",
+      id: "bg-1a2b3c4d",
+      toolName: "bash",
+      conversationId: "conv-abc",
+      command: "echo hi",
+      startedAt: 1_700_000_000_000,
+      unexpected: true,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.success && "unexpected" in result.data).toBe(false);
+  });
+});

package/src/api/events/background-tool-started.ts

@@ -0,0 +1,28 @@
+/**
+ * `background_tool_started` SSE event.
+ *
+ * Server → client notification that a background bash/host_bash command
+ * has started. Carries the background-tool identity (`id`, a `bg-xxxxxxxx`
+ * id), the `toolName`, scoping (`conversationId`), the `command` being run,
+ * and the `startedAt` timestamp.
+ *
+ * Canonical wire-contract source. Re-exported to external consumers via
+ * `@vellumai/assistant-api` (the `api/index.ts` barrel).
+ */
+
+import { z } from "zod";
+
+// No `.strict()`: unknown server-added fields are stripped, not rejected, so a
+// future field can't make older clients drop the whole lifecycle event.
+export const BackgroundToolStartedEventSchema = z.object({
+  type: z.literal("background_tool_started"),
+  id: z.string(),
+  toolName: z.string(),
+  conversationId: z.string(),
+  command: z.string(),
+  startedAt: z.number(),
+});
+
+export type BackgroundToolStartedEvent = z.infer<
+  typeof BackgroundToolStartedEventSchema
+>;

package/src/api/events/conversation-error.ts

@@ -43,7 +43,6 @@ export const ConversationErrorCodeSchema = z.enum([
   "CONVERSATION_ABORTED",
   "CONVERSATION_PROCESSING_FAILED",
   "DISK_SPACE_CRITICAL",
-  "REGENERATE_FAILED",
   "UNKNOWN",
 ]);
 

package/src/api/events/open-panel.ts

@@ -0,0 +1,33 @@
+/**
+ * `open_panel` SSE event.
+ *
+ * Side-effect-only command: tells the client to open a panel or drawer
+ * without rendering anything in the chat transcript. Analogous to
+ * `open_url` and `navigate_settings` — the rolling-snapshot reducer
+ * has no case for it, so it naturally falls through to "no change."
+ *
+ * `panelType` identifies which panel to open; `data` carries
+ * panel-specific payload (validated by the handler, not the schema).
+ *
+ * `surfaceId` is the acknowledgment correlation id: the daemon holds the
+ * emitting tool call open until the client confirms the panel rendered by
+ * POSTing a surface action (`actionId: "ack"` / `"nack"`) with this id.
+ * Clients that receive an event without a `surfaceId` have nothing to
+ * acknowledge.
+ *
+ * Canonical wire-contract source. Daemon code imports the type
+ * directly from this file; external consumers import via
+ * `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+export const OpenPanelEventSchema = z.object({
+  type: z.literal("open_panel"),
+  panelType: z.string(),
+  data: z.record(z.string(), z.unknown()).optional(),
+  conversationId: z.string().optional(),
+  surfaceId: z.string().optional(),
+});
+
+export type OpenPanelEvent = z.infer<typeof OpenPanelEventSchema>;

package/src/api/events/subagent-status-changed.ts

@@ -22,7 +22,9 @@ import { z } from "zod";
 /**
  * Subagent lifecycle status. Mirrors `SubagentStatus` in
  * `assistant/src/subagent/types.ts`. `aborted` is a terminal state
- * reached via explicit `subagent_abort` request.
+ * reached via explicit `subagent_abort` request; `interrupted` is a
+ * terminal state assigned on daemon restart to a subagent that was
+ * still in flight (it is not auto-resumed).
  */
 export const SubagentStatusSchema = z.enum([
   "pending",
@@ -31,6 +33,7 @@ export const SubagentStatusSchema = z.enum([
   "completed",
   "failed",
   "aborted",
+  "interrupted",
 ]);
 
 export type SubagentStatus = z.infer<typeof SubagentStatusSchema>;