@vellumai/assistant 0.8.6 → 0.8.7-dev.202606052118.34cd356

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

@@ -4,6 +4,9 @@
 
 export type SurfaceType =
   | "card"
+  | "choice"
+  | "copy_block"
+  | "oauth_connect"
   | "form"
   | "list"
   | "table"
@@ -11,9 +14,12 @@ export type SurfaceType =
   | "dynamic_page"
   | "file_upload"
   | "document_preview"
-  | "task_preferences";
+  | "task_preferences"
+  | "work_result";
 
 export const INTERACTIVE_SURFACE_TYPES: SurfaceType[] = [
+  "choice",
+  "oauth_connect",
   "form",
   "confirmation",
   "dynamic_page",
@@ -40,6 +46,45 @@ export interface CardSurfaceData {
   templateData?: Record<string, unknown>;
 }
 
+export interface ChoiceOption {
+  id: string;
+  title: string;
+  description?: string;
+  /** Visually highlight this option as the assistant's recommendation. */
+  recommended?: boolean;
+  /** Optional structured payload returned with this choice. */
+  data?: Record<string, unknown>;
+}
+
+export interface ChoiceSurfaceData {
+  description?: string;
+  options: ChoiceOption[];
+  selectionMode?: "single" | "multiple";
+  /**
+   * When true, clicking an option submits it immediately. Defaults to true for
+   * single-select choice surfaces.
+   */
+  commitOnSelect?: boolean;
+  submitLabel?: string;
+}
+
+export interface CopyBlockSurfaceData {
+  text: string;
+  label?: string;
+  language?: string;
+}
+
+export interface OAuthConnectSurfaceData {
+  /** OAuth provider key from the managed provider catalog, e.g. "google". */
+  providerKey: string;
+  /** Optional display label. The client falls back to the provider catalog. */
+  displayName?: string;
+  /** Optional helper text. The client falls back to the provider catalog. */
+  description?: string;
+  /** Optional provider logo URL. The client falls back to the provider catalog. */
+  logoUrl?: string | null;
+}
+
 export interface FormField {
   id: string;
   type: "text" | "textarea" | "select" | "toggle" | "number" | "password";
@@ -148,15 +193,79 @@ export interface DocumentPreviewSurfaceData {
   subtitle?: string;
 }
 
+export type WorkResultStatus =
+  | "completed"
+  | "partial"
+  | "failed"
+  | "in_progress";
+
+export type WorkResultTone = "neutral" | "positive" | "warning" | "negative";
+
+export type WorkResultSectionType =
+  | "items"
+  | "timeline"
+  | "diff"
+  | "artifacts"
+  | "warnings";
+
+export interface WorkResultMetric {
+  label: string;
+  value: string | number;
+  detail?: string;
+  tone?: WorkResultTone;
+}
+
+export interface WorkResultMetadata {
+  label: string;
+  value: string | number;
+}
+
+export interface WorkResultItem {
+  id?: string;
+  title: string;
+  description?: string;
+  status?: string;
+  tone?: WorkResultTone;
+  metadata?: WorkResultMetadata[];
+  href?: string;
+}
+
+export interface WorkResultDiff {
+  label?: string;
+  before?: string;
+  after?: string;
+}
+
+export interface WorkResultSection {
+  id?: string;
+  title: string;
+  description?: string;
+  type?: WorkResultSectionType;
+  items?: WorkResultItem[];
+  diffs?: WorkResultDiff[];
+}
+
+export interface WorkResultSurfaceData {
+  eyebrow?: string;
+  status?: WorkResultStatus;
+  summary?: string;
+  metrics?: WorkResultMetric[];
+  sections?: WorkResultSection[];
+}
+
 export type SurfaceData =
   | CardSurfaceData
+  | ChoiceSurfaceData
+  | CopyBlockSurfaceData
+  | OAuthConnectSurfaceData
   | FormSurfaceData
   | ListSurfaceData
   | TableSurfaceData
   | ConfirmationSurfaceData
   | DynamicPageSurfaceData
   | FileUploadSurfaceData
-  | DocumentPreviewSurfaceData;
+  | DocumentPreviewSurfaceData
+  | WorkResultSurfaceData;
 
 // === Client → Server ===
 
@@ -188,6 +297,8 @@ interface UiSurfaceShowBase {
   messageId?: string;
   /** When `true`, clicking an action does not dismiss the surface — the client keeps the card visible and only marks the clicked `actionId` as spent so siblings remain clickable. */
   persistent?: boolean;
+  /** Id of the tool call that produced this surface (the `ui_show` proxy tool). Lets the client gate app previews on the tool result's arrival rather than whole-turn streaming state. */
+  toolCallId?: string;
 }
 
 export interface UiSurfaceShowCard extends UiSurfaceShowBase {
@@ -195,6 +306,21 @@ export interface UiSurfaceShowCard extends UiSurfaceShowBase {
   data: CardSurfaceData;
 }
 
+export interface UiSurfaceShowChoice extends UiSurfaceShowBase {
+  surfaceType: "choice";
+  data: ChoiceSurfaceData;
+}
+
+export interface UiSurfaceShowCopyBlock extends UiSurfaceShowBase {
+  surfaceType: "copy_block";
+  data: CopyBlockSurfaceData;
+}
+
+export interface UiSurfaceShowOAuthConnect extends UiSurfaceShowBase {
+  surfaceType: "oauth_connect";
+  data: OAuthConnectSurfaceData;
+}
+
 export interface UiSurfaceShowForm extends UiSurfaceShowBase {
   surfaceType: "form";
   data: FormSurfaceData;
@@ -230,15 +356,24 @@ export interface UiSurfaceShowDocumentPreview extends UiSurfaceShowBase {
   data: DocumentPreviewSurfaceData;
 }
 
+export interface UiSurfaceShowWorkResult extends UiSurfaceShowBase {
+  surfaceType: "work_result";
+  data: WorkResultSurfaceData;
+}
+
 export type UiSurfaceShow =
   | UiSurfaceShowCard
+  | UiSurfaceShowChoice
+  | UiSurfaceShowCopyBlock
+  | UiSurfaceShowOAuthConnect
   | UiSurfaceShowForm
   | UiSurfaceShowList
   | UiSurfaceShowTable
   | UiSurfaceShowConfirmation
   | UiSurfaceShowDynamicPage
   | UiSurfaceShowFileUpload
-  | UiSurfaceShowDocumentPreview;
+  | UiSurfaceShowDocumentPreview
+  | UiSurfaceShowWorkResult;
 
 export interface UiSurfaceUpdate {
   type: "ui_surface_update";

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

@@ -1,11 +1,20 @@
 import { z } from "zod";
 
+import {
+  type SyncChangedEvent,
+  SyncChangedEventSchema,
+} from "../../api/events/sync-changed.js";
+
+export { type SyncChangedEvent, SyncChangedEventSchema };
+
 export const SYNC_TAGS = {
   assistantAvatar: "assistant:self:avatar",
   assistantIdentity: "assistant:self:identity",
+  assistantIdentityIntro: "assistant:self:identity-intro",
   assistantConfig: "assistant:self:config",
   assistantSounds: "assistant:self:sounds",
   assistantSchedules: "assistant:self:schedules",
+  appsList: "apps:list",
   conversationsList: "conversations:list",
   featureFlagsClient: "feature-flags:client",
   featureFlagsAssistant: "feature-flags:assistant",
@@ -23,29 +32,8 @@ export type SyncInvalidationTag =
   | ConversationSyncInvalidationTag
   | (string & {});
 
-export interface SyncChangedMessage {
-  type: "sync_changed";
-  tags: SyncInvalidationTag[];
-  /**
-   * Optional identifier of the client that originated the change. When set,
-   * the server fan-out and clients themselves can suppress self-echoes so
-   * the originating tab/process doesn't reinvalidate its own cache off its
-   * own mutation. Daemon-internal emits (agent loop, FS watcher, cron) leave
-   * this unset so the event fans out to every subscriber as before.
-   */
-  originClientId?: string;
-}
-
 export const SyncInvalidationTagSchema = z.string().min(1);
 
-export const SyncChangedMessageSchema = z
-  .object({
-    type: z.literal("sync_changed"),
-    tags: z.array(SyncInvalidationTagSchema).min(1),
-    originClientId: z.string().min(1).optional(),
-  })
-  .strict();
-
 export function conversationMessagesSyncTag(
   conversationId: string,
 ): ConversationSyncInvalidationTag {
@@ -61,15 +49,14 @@ export function conversationMetadataSyncTag(
 export function buildSyncChangedMessage(
   tags: SyncInvalidationTag[],
   originClientId?: string,
-): SyncChangedMessage {
+): SyncChangedEvent {
   const dedupedTags = Array.from(new Set(tags));
   const trimmedOrigin = originClientId?.trim();
-  const parsed = SyncChangedMessageSchema.parse({
+  return SyncChangedEventSchema.parse({
     type: "sync_changed",
     tags: dedupedTags,
     ...(trimmedOrigin ? { originClientId: trimmedOrigin } : {}),
   });
-  return parsed as SyncChangedMessage;
 }
 
-export type _SyncInvalidationServerMessages = SyncChangedMessage;
+export type _SyncInvalidationServerMessages = SyncChangedEvent;

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

@@ -1,5 +1,7 @@
 // Workspace file, identity, and tool permission types.
 
+import type { IdentityChangedEvent } from "../../api/events/identity-changed.js";
+
 // === Client → Server ===
 
 export interface WorkspaceFilesListRequest {
@@ -117,16 +119,6 @@ export interface ToolNamesListResponse {
   schemas?: Record<string, ToolInputSchema>;
 }
 
-/** Server push — broadcast when IDENTITY.md changes on disk. */
-export interface IdentityChanged {
-  type: "identity_changed";
-  name: string;
-  role: string;
-  personality: string;
-  emoji: string;
-  home: string;
-}
-
 // --- Domain-level union aliases (consumed by the barrel file) ---
 
 export type _WorkspaceClientMessages =
@@ -142,4 +134,4 @@ export type _WorkspaceServerMessages =
   | IdentityGetResponse
   | ToolPermissionSimulateResponse
   | ToolNamesListResponse
-  | IdentityChanged;
+  | IdentityChangedEvent;

package/src/daemon/now-scratchpad.ts

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync } from "node:fs";
+
+import { getWorkspacePromptPath } from "../util/platform.js";
+import { stripCommentLines } from "../util/strip-comment-lines.js";
+
+/**
+ * Read the NOW.md scratchpad from the workspace prompt directory.
+ *
+ * Returns the trimmed content with `_`-prefixed comment lines stripped,
+ * or `null` if the file is missing, empty, or unreadable.
+ */
+export function readNowScratchpad(): string | null {
+  const nowPath = getWorkspacePromptPath("NOW.md");
+  if (!existsSync(nowPath)) return null;
+  try {
+    const stripped = stripCommentLines(readFileSync(nowPath, "utf-8")).trim();
+    return stripped.length > 0 ? stripped : null;
+  } catch {
+    return null;
+  }
+}

package/src/daemon/orphan-reaper.test.ts

@@ -0,0 +1,210 @@
+/**
+ * Tests for the orphan subprocess reaper.
+ *
+ * - `parseProcStat` must read state/ppid correctly even when the executable
+ *   name (`comm`) contains spaces and parentheses.
+ * - `selectReapable` must defer a zombie for one full scan interval (so libuv
+ *   reaps its own tracked children first) and reap it on the next scan.
+ * - An integration test makes the test process a child subreaper via
+ *   `PR_SET_CHILD_SUBREAPER`, orphans a grandchild, and verifies the
+ *   exported logic defers-then-reaps the real `<defunct>` entry while libuv
+ *   independently reaps the directly-spawned (tracked) child.
+ */
+import { spawn } from "node:child_process";
+import { readdirSync, readFileSync } from "node:fs";
+import { dlopen, FFIType, ptr } from "bun:ffi";
+import { afterAll, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+const { parseProcStat, selectReapable } = await import("./orphan-reaper.js");
+const { DaemonConfigSchema } = await import("../config/schemas/platform.js");
+
+describe("parseProcStat", () => {
+  test("parses a normal stat line", () => {
+    // GIVEN a well-formed /proc/<pid>/stat line for a zombie
+    const line = "1234 (bash) Z 1 1234 1234 0 -1 ...";
+    // WHEN it is parsed
+    const parsed = parseProcStat(line);
+    // THEN comm, state, and ppid are extracted
+    expect(parsed).toEqual({ comm: "bash", state: "Z", ppid: 1 });
+  });
+
+  test("handles comm containing spaces and parentheses", () => {
+    // GIVEN a stat line whose comm field itself contains spaces and parens
+    const line = "42 (weird (name) x) Z 1 42 42 0 -1 4194560";
+    // WHEN it is parsed
+    const parsed = parseProcStat(line);
+    // THEN fields are read relative to the final ')', not naive splitting
+    expect(parsed).toEqual({ comm: "weird (name) x", state: "Z", ppid: 1 });
+  });
+
+  test("reads a non-zombie running state", () => {
+    // GIVEN a running (non-zombie) process line
+    const line = "77 (node) R 12 77 77";
+    // WHEN it is parsed
+    const parsed = parseProcStat(line);
+    // THEN the running state and parent pid are reported
+    expect(parsed?.state).toBe("R");
+    expect(parsed?.ppid).toBe(12);
+  });
+
+  test("returns null for malformed lines", () => {
+    // GIVEN malformed or truncated stat content
+    // WHEN each is parsed
+    // THEN null is returned rather than a bogus record
+    expect(parseProcStat("")).toBeNull();
+    expect(parseProcStat("no parens here")).toBeNull();
+    expect(parseProcStat("123 (proc)")).toBeNull();
+  });
+});
+
+describe("selectReapable", () => {
+  test("defers a newly-seen zombie for one interval", () => {
+    // GIVEN zombies never seen on a previous scan
+    // WHEN deciding what to reap with an empty seen set
+    const { reap, nextSeen } = selectReapable([100, 101], new Set());
+    // THEN nothing is reaped yet, but both are carried into the next scan
+    expect(reap).toEqual([]);
+    expect([...nextSeen].sort()).toEqual([100, 101]);
+  });
+
+  test("reaps a zombie that survived the previous scan", () => {
+    // GIVEN pid 100 was already seen on the prior scan and 101 is new
+    // WHEN deciding what to reap
+    const { reap } = selectReapable([100, 101], new Set([100]));
+    // THEN only the survivor (100) is reaped; the newcomer is deferred
+    expect(reap).toEqual([100]);
+  });
+
+  test("drops PIDs that have disappeared from the next seen set", () => {
+    // GIVEN pid 100 was seen before but is gone now
+    // WHEN computing the next seen set
+    const { nextSeen } = selectReapable([101], new Set([100, 101]));
+    // THEN only currently-present pids are retained
+    expect([...nextSeen]).toEqual([101]);
+  });
+});
+
+describe("daemon.reapOrphanedSubprocesses gate", () => {
+  test("defaults to off so the reaper is opt-in", () => {
+    // GIVEN a daemon config with the reaper flag unspecified
+    // WHEN it is parsed with schema defaults
+    const parsed = DaemonConfigSchema.parse({});
+    // THEN the reaper is disabled unless explicitly turned on
+    expect(parsed.reapOrphanedSubprocesses).toBe(false);
+  });
+
+  test("honors an explicit opt-in", () => {
+    // GIVEN a daemon config that explicitly enables the reaper
+    // WHEN it is parsed
+    const parsed = DaemonConfigSchema.parse({ reapOrphanedSubprocesses: true });
+    // THEN the flag is respected
+    expect(parsed.reapOrphanedSubprocesses).toBe(true);
+  });
+});
+
+// ── Integration: real reparented orphan on Linux ────────────────────────────
+const itLinux = process.platform === "linux" ? test : test.skip;
+
+// Bind libc only on Linux — "libc.so.6" does not exist on macOS, so binding it
+// unconditionally would throw at import and break the pure-function tests too.
+const lib =
+  process.platform === "linux"
+    ? dlopen("libc.so.6", {
+        waitpid: {
+          args: [FFIType.i32, FFIType.ptr, FFIType.i32],
+          returns: FFIType.i32,
+        },
+        prctl: {
+          args: [
+            FFIType.i32,
+            FFIType.u64,
+            FFIType.u64,
+            FFIType.u64,
+            FFIType.u64,
+          ],
+          returns: FFIType.i32,
+        },
+      })
+    : null;
+const WNOHANG = 1;
+const PR_SET_CHILD_SUBREAPER = 36;
+const statusBuf = new Int32Array(1);
+
+function zombieChildPids(): number[] {
+  const self = process.pid;
+  const out: number[] = [];
+  for (const entry of readdirSync("/proc")) {
+    const pid = Number(entry);
+    if (!Number.isInteger(pid) || pid <= 1) continue;
+    let stat: string;
+    try {
+      stat = readFileSync(`/proc/${pid}/stat`, "utf8");
+    } catch {
+      continue;
+    }
+    const parsed = parseProcStat(stat);
+    if (parsed && parsed.state === "Z" && parsed.ppid === self) out.push(pid);
+  }
+  return out;
+}
+
+const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
+
+afterAll(() => {
+  if (!lib) return;
+  // Reap anything still lingering so the test process leaves no zombies.
+  for (const pid of zombieChildPids())
+    lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG);
+});
+
+itLinux(
+  "defers then reaps a reparented orphan while libuv reaps the tracked child",
+  async () => {
+    if (!lib) return;
+    // GIVEN this process is a child subreaper, so orphaned grandchildren
+    // reparent here exactly as they reparent to a PID-1 daemon
+    expect(lib.symbols.prctl(PR_SET_CHILD_SUBREAPER, 1n, 0n, 0n, 0n)).toBe(0);
+
+    // AND a libuv-tracked child (A) that detaches a grandchild (B) into its
+    // own session and exits immediately; B reparents to us and, once it
+    // exits, becomes a zombie with our pid as its parent
+    let trackedChildExited = false;
+    const a = spawn("bash", ["-c", "setsid -f sleep 0.4; exit 0"], {
+      stdio: "ignore",
+    });
+    a.on("exit", () => {
+      trackedChildExited = true;
+    });
+
+    // AND we wait for that orphan to surface as our zombie child
+    let zombies: number[] = [];
+    for (let i = 0; i < 40 && zombies.length === 0; i++) {
+      await sleep(50);
+      zombies = zombieChildPids();
+    }
+    expect(zombies.length).toBeGreaterThan(0);
+    expect(trackedChildExited).toBe(true); // libuv reaped A independently
+
+    // WHEN we run the deferred-reap algorithm across two scans
+    // (scan #1 is the grace pass, scan #2 reaps the survivor)
+    const scan1 = selectReapable(zombieChildPids(), new Set<number>());
+    const scan2 = selectReapable(zombieChildPids(), scan1.nextSeen);
+    let reaped = 0;
+    for (const pid of scan2.reap) {
+      if (lib.symbols.waitpid(pid, ptr(statusBuf), WNOHANG) > 0) reaped++;
+    }
+    await sleep(50);
+
+    // THEN nothing is reaped on the grace pass, the survivor is reaped on the
+    // second pass, and no defunct child remains
+    expect(scan1.reap).toEqual([]);
+    expect(scan2.reap.length).toBeGreaterThan(0);
+    expect(reaped).toBeGreaterThan(0);
+    expect(zombieChildPids()).toEqual([]);
+  },
+);