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

package/src/subagent/manager.ts

@@ -20,6 +20,11 @@ import {
 } from "../daemon/conversation-registry.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import { bootstrapConversation } from "../persistence/conversation-bootstrap.js";
+import {
+  deleteSubagentRecord,
+  loadAllSubagentRecords,
+  upsertSubagentRecord,
+} from "../persistence/subagent-store.js";
 import { wrapWithCallSiteRouting } from "../providers/call-site-routing.js";
 import { resolveDefaultProvider } from "../providers/connection-resolution.js";
 import { RateLimitProvider } from "../providers/ratelimit.js";
@@ -117,6 +122,73 @@ function buildSubagentSystemPrompt(
   return sections.join("\n");
 }
 
+/**
+ * Build the message injected into the parent conversation when a subagent
+ * reaches a terminal state.
+ *
+ * For a completed subagent the final synthesis is inlined directly, so the
+ * parent acts on the result without a `subagent_read` round-trip and has
+ * nothing left to re-spawn. The `subagent_read` pointer survives only as a
+ * fallback for the rare run that ends with no trailing assistant text.
+ *
+ * Exported for unit testing.
+ */
+export function buildSubagentTerminalMessage(opts: {
+  label: string;
+  subagentId: string;
+  isFork: boolean;
+  outcome: "completed" | "failed";
+  silent: boolean;
+  finalText?: string;
+  error?: string;
+  /** A follow-up turn is still queued, so the current synthesis is a snapshot. */
+  deferred?: boolean;
+}): string {
+  const {
+    label,
+    subagentId,
+    isFork,
+    outcome,
+    silent,
+    finalText,
+    error,
+    deferred,
+  } = opts;
+  const prefix = isFork ? "Fork" : "Subagent";
+
+  if (outcome === "failed") {
+    return (
+      `[${prefix} "${label}" failed]\n\n` +
+      `Error: ${error ?? "Unknown error"}\n` +
+      `Do NOT re-spawn or retry this ${prefix.toLowerCase()} unless the user explicitly asks.`
+    );
+  }
+
+  const trimmed = finalText?.trim() ?? "";
+  if (trimmed && !deferred) {
+    return (
+      `[${prefix} "${label}" completed — result below]\n\n` +
+      `${trimmed}\n\n` +
+      (silent
+        ? `(Use these findings internally; do not relay the raw ${prefix.toLowerCase()} output to the user.)`
+        : `(Incorporate this into your reply to the user as appropriate.)`)
+    );
+  }
+
+  // Read-pointer path: either the run left no trailing assistant text to inline,
+  // or a queued follow-up turn is still draining — so the current synthesis is a
+  // stale snapshot and the parent should read the latest output instead.
+  const lastN = isFork ? " and last_n: 1" : "";
+  const reason = deferred
+    ? `Queued follow-up guidance is still being processed`
+    : `The ${prefix.toLowerCase()} produced no final text`;
+  return (
+    `[${prefix} "${label}" completed]\n\n` +
+    `${reason}. Use subagent_read with subagent_id "${subagentId}"${lastN} for the latest output.` +
+    (silent ? ` Keep the result internal.` : ``)
+  );
+}
+
 // ── Manager ─────────────────────────────────────────────────────────────
 
 interface ManagedSubagent {
@@ -190,6 +262,13 @@ export class SubagentManager {
   /** `${parentConversationId}:${normalizedLabel}` → subagentId */
   private labelIndex = new Map<string, string>();
 
+  /**
+   * Set during `disposeAll()` (shutdown) so `dispose()` keeps the durable rows
+   * instead of deleting them — an in-flight subagent must survive as a row to
+   * be rehydrated as `interrupted` on the next boot.
+   */
+  private shuttingDown = false;
+
   /**
    * Cross-conversation rate-limit window. The conversation store reads this
    * same array when building its per-conversation RateLimitProvider, so
@@ -433,6 +512,17 @@ export class SubagentManager {
     if (parentConversation?.assistantId) {
       conversation.setAssistantId(parentConversation.assistantId);
     }
+    // Inherit the parent chat's per-conversation plugin scope so a subagent
+    // spawned from a scoped chat can't see or execute plugins the user
+    // deselected. `null` (no per-chat restriction) is the default and
+    // propagates unchanged; a materialized scope is copied by value.
+    if (parentConversation) {
+      conversation.setEnabledPlugins(
+        parentConversation.enabledPlugins
+          ? [...parentConversation.enabledPlugins]
+          : null,
+      );
+    }
 
     if (isFork && !config.systemPromptOverride) {
       // A verbatim-prompt fork pins the parent's system prompt as-is, skipping
@@ -485,6 +575,9 @@ export class SubagentManager {
     }
     this.parentToChildren.get(config.parentConversationId)!.add(subagentId);
 
+    // Persist the initial record so the subagent survives a daemon restart.
+    this.persistState(managed.state);
+
     // Notify client that a subagent was spawned.
     parentSendToClient({
       type: "subagent_spawned",
@@ -599,8 +692,11 @@ export class SubagentManager {
     // Read the current parent sender so reconnects are picked up.
     const getSender = () => managed.parentSendToClient;
 
-    this.setStatus(subagentId, "running", getSender());
+    // Stamp startedAt before the status transition so the persistence hook
+    // inside setStatus captures it on the running row (otherwise a crash mid-run
+    // rehydrates as interrupted with no start time).
     managed.state.startedAt = Date.now();
+    this.setStatus(subagentId, "running", getSender());
 
     try {
       // For forks, inject the parent's message history before the first message.
@@ -669,12 +765,12 @@ export class SubagentManager {
 
         log.info({ subagentId }, "Subagent completed");
 
-        // Notify the parent conversation so the LLM can call subagent_read.
-        // Skipped on the synchronous path — the awaiting caller receives the
-        // final text directly, so re-injecting a "read the result" prompt
-        // would be redundant noise in the parent.
+        // Notify the parent conversation, inlining the subagent's final
+        // synthesis so the LLM acts on the result without a subagent_read
+        // round-trip. Skipped on the synchronous path — the awaiting caller
+        // receives the final text directly.
         if (!managed.synchronous) {
-          this.notifyParentTerminal(managed, "completed");
+          this.notifyParentTerminal(managed, "completed", finalText);
         }
       }
     } catch (err) {
@@ -805,6 +901,7 @@ export class SubagentManager {
       }
     } else {
       managed.state.status = "aborted";
+      this.persistState(managed.state);
     }
 
     log.info({ subagentId }, "Subagent aborted");
@@ -915,8 +1012,12 @@ export class SubagentManager {
   }
 
   /**
-   * Update the parent sender for all active children of a conversation.
-   * Called when the parent client reconnects to a new socket.
+   * Update the parent sender for all active children of a conversation and
+   * re-emit each child's current status to it. Called when the parent client
+   * reconnects to a new socket, so a reconnecting client resyncs any status it
+   * missed while disconnected (e.g. a subagent marked `interrupted` during
+   * rehydration after a daemon restart, whose card would otherwise stay stuck
+   * on a stale `running`).
    */
   updateParentSender(
     parentConversationId: string,
@@ -927,9 +1028,19 @@ export class SubagentManager {
 
     for (const childId of children) {
       const managed = this.subagents.get(childId);
-      if (managed && !TERMINAL_STATUSES.has(managed.state.status)) {
+      if (!managed) continue;
+      if (!TERMINAL_STATUSES.has(managed.state.status)) {
         managed.parentSendToClient = newSendToClient;
       }
+      // Re-emit the current status so the reconnecting client corrects any card
+      // it left in a stale state while disconnected.
+      newSendToClient({
+        type: "subagent_status_changed",
+        subagentId: childId,
+        status: managed.state.status,
+        error: managed.state.error,
+        usage: managed.state.usage,
+      } as ServerMessage);
     }
   }
 
@@ -981,6 +1092,17 @@ export class SubagentManager {
     }
     this.subagents.delete(subagentId);
 
+    // Drop the durable record too — but only during normal operation. On
+    // shutdown we keep rows so a subagent that was in flight can rehydrate as
+    // `interrupted` on the next boot.
+    if (!this.shuttingDown) {
+      try {
+        deleteSubagentRecord(subagentId);
+      } catch (err) {
+        log.warn({ subagentId, err }, "Failed to delete subagent record");
+      }
+    }
+
     // Remove from label index only if it still maps to this subagent
     // (guards against stale delete when a newer subagent reused the label).
     const label = managed.state.config.label;
@@ -1003,12 +1125,122 @@ export class SubagentManager {
 
   /** Dispose all subagents. Called on daemon shutdown. */
   disposeAll(): void {
+    // Mark shutdown so dispose() keeps the durable rows: an in-flight subagent
+    // must survive as a row to be rehydrated as `interrupted` on the next boot.
+    this.shuttingDown = true;
     this.stopSweep();
     for (const id of [...this.subagents.keys()]) {
       this.dispose(id);
     }
   }
 
+  // ── Persistence / rehydration ─────────────────────────────────────────
+
+  /**
+   * Write the subagent's current state to the durable `subagents` table.
+   * Best-effort: persistence failures are logged, never thrown — a background
+   * subagent must not fail because its bookkeeping row could not be written.
+   */
+  private persistState(state: SubagentState): void {
+    try {
+      upsertSubagentRecord({
+        id: state.config.id,
+        parentConversationId: state.config.parentConversationId,
+        conversationId: state.conversationId,
+        label: state.config.label,
+        objective: state.config.objective,
+        role: state.config.role ?? "general",
+        isFork: state.isFork,
+        sendResultToUser: state.config.sendResultToUser ?? null,
+        status: state.status,
+        error: state.error ?? null,
+        createdAt: state.createdAt,
+        startedAt: state.startedAt ?? null,
+        completedAt: state.completedAt ?? null,
+        inputTokens: state.usage.inputTokens,
+        outputTokens: state.usage.outputTokens,
+        estimatedCost: state.usage.estimatedCost,
+      });
+    } catch (err) {
+      log.warn(
+        { subagentId: state.config.id, err },
+        "Failed to persist subagent record",
+      );
+    }
+  }
+
+  /**
+   * Rebuild in-memory subagent metadata from the durable table after a restart.
+   * Terminal records load as-is so `subagent_read`/`getState` keep working
+   * (output is read from the child conversation's persisted messages). Records
+   * still in flight when the process died are marked `interrupted` — the run is
+   * not resumed; the parent decides whether to re-spawn. Rehydrated entries
+   * carry a no-op sender and no live conversation, and are swept on the normal
+   * TTL like any other terminal subagent.
+   *
+   * Best-effort and idempotent: a second restart re-reads `interrupted` rows
+   * and leaves them unchanged.
+   */
+  rehydrateFromDb(): { rehydrated: number; interrupted: number } {
+    const records = loadAllSubagentRecords();
+    let interrupted = 0;
+    const now = Date.now();
+    for (const rec of records) {
+      const wasInFlight = !TERMINAL_STATUSES.has(rec.status as SubagentStatus);
+      const status: SubagentStatus = wasInFlight
+        ? "interrupted"
+        : (rec.status as SubagentStatus);
+      if (wasInFlight) interrupted++;
+
+      const state: SubagentState = {
+        config: {
+          id: rec.id,
+          parentConversationId: rec.parentConversationId,
+          label: rec.label,
+          objective: rec.objective,
+          role: rec.role as SubagentRole,
+          fork: rec.isFork,
+          ...(rec.sendResultToUser != null
+            ? { sendResultToUser: rec.sendResultToUser }
+            : {}),
+        },
+        status,
+        conversationId: rec.conversationId,
+        isFork: rec.isFork,
+        ...(rec.error != null ? { error: rec.error } : {}),
+        createdAt: rec.createdAt,
+        ...(rec.startedAt != null ? { startedAt: rec.startedAt } : {}),
+        ...(rec.completedAt != null ? { completedAt: rec.completedAt } : {}),
+        usage: {
+          inputTokens: rec.inputTokens,
+          outputTokens: rec.outputTokens,
+          estimatedCost: rec.estimatedCost,
+        },
+      };
+
+      const managed: ManagedSubagent = {
+        conversation: null,
+        state,
+        parentSendToClient: () => {},
+        retainedUntil: now + TERMINAL_RETENTION_MS,
+      };
+      this.subagents.set(rec.id, managed);
+
+      const labelKey = `${rec.parentConversationId}:${rec.label.toLowerCase().trim()}`;
+      this.labelIndex.set(labelKey, rec.id);
+
+      if (!this.parentToChildren.has(rec.parentConversationId)) {
+        this.parentToChildren.set(rec.parentConversationId, new Set());
+      }
+      this.parentToChildren.get(rec.parentConversationId)!.add(rec.id);
+
+      // Persist the interrupted transition so a second restart is a no-op.
+      if (wasInFlight) this.persistState(state);
+    }
+    if (records.length > 0) this.ensureSweepRunning();
+    return { rehydrated: records.length, interrupted };
+  }
+
   // ── TTL sweep for terminal metadata ──────────────────────────────────
 
   private sweepTimer?: ReturnType<typeof setInterval>;
@@ -1097,6 +1329,9 @@ export class SubagentManager {
       error,
       usage: managed.state.usage,
     } as ServerMessage);
+
+    // Mirror the transition to the durable record.
+    this.persistState(managed.state);
   }
 
   // ── Child → Parent notification ────────────────────────────────────
@@ -1165,43 +1400,36 @@ export class SubagentManager {
   }
 
   /**
-   * Inject a completion/failure notification into the parent conversation
-   * so the LLM automatically informs the user.
+   * Inject a completion/failure notification into the parent conversation so
+   * the LLM automatically informs the user. On completion the subagent's final
+   * synthesis is inlined (via `buildSubagentTerminalMessage`) so the parent acts
+   * on the result directly rather than issuing a `subagent_read` call.
    */
   private notifyParentTerminal(
     managed: ManagedSubagent,
     outcome: "completed" | "failed",
+    finalText?: string,
   ): void {
     const { config } = managed.state;
     const isFork = managed.state.isFork;
-    let message: string;
-
-    if (outcome === "completed") {
-      if (isFork) {
-        const silent = config.sendResultToUser !== true;
-        message =
-          `[Fork "${config.label}" completed]\n\n` +
-          `Use subagent_read with subagent_id "${config.id}" and last_n: 1 to retrieve the final synthesis.\n` +
-          (silent
-            ? `This fork was spawned for internal processing. Process the findings internally — do NOT share raw fork output with the user.`
-            : `Do NOT re-spawn this fork — just read and share the results.`);
-      } else {
-        const silent = config.sendResultToUser === false;
-        message =
-          `[Subagent "${config.label}" completed]\n\n` +
-          `Use subagent_read with subagent_id "${config.id}" to retrieve the full output.\n` +
-          (silent
-            ? `This subagent was spawned for internal processing. Read the result for your own use but do NOT share it with the user.\nDo NOT re-spawn this subagent.`
-            : `Do NOT re-spawn this subagent — just read and share the results.`);
-      }
-    } else {
-      const error = managed.state.error ?? "Unknown error";
-      const prefix = isFork ? "Fork" : "Subagent";
-      message =
-        `[${prefix} "${config.label}" failed]\n\n` +
-        `Error: ${error}\n` +
-        `Do NOT re-spawn or retry this ${prefix.toLowerCase()} unless the user explicitly asks.`;
-    }
+    // Forks default to internal/silent unless explicitly shared; regular
+    // subagents share with the user unless explicitly silenced.
+    const silent = isFork
+      ? config.sendResultToUser !== true
+      : config.sendResultToUser === false;
+
+    const message = buildSubagentTerminalMessage({
+      label: config.label,
+      subagentId: config.id,
+      isFork,
+      outcome,
+      silent,
+      finalText,
+      error: managed.state.error,
+      // A queued follow-up turn means the snapshot we hold is stale; defer to a
+      // read pointer so the parent picks up the queued turn's output instead.
+      deferred: managed.hadEnqueuedMessages === true,
+    });
 
     const notification: SubagentNotificationInfo = {
       subagentId: config.id,

package/src/subagent/types.ts

@@ -17,11 +17,15 @@ export type SubagentStatus =
   | "awaiting_input"
   | "completed"
   | "failed"
-  | "aborted";
+  | "aborted"
+  // Assigned on daemon restart to a subagent that was still in flight when the
+  // process died. Terminal — the run is not auto-resumed; the parent is left to
+  // decide whether to re-spawn.
+  | "interrupted";
 
 /** Terminal states — once entered, a subagent cannot transition out. */
 export const TERMINAL_STATUSES: ReadonlySet<SubagentStatus> =
-  new Set<SubagentStatus>(["completed", "failed", "aborted"]);
+  new Set<SubagentStatus>(["completed", "failed", "aborted", "interrupted"]);
 
 // ── Config (spawn-time) ─────────────────────────────────────────────────
 

package/src/subagent/validate-allowlists.ts

@@ -0,0 +1,65 @@
+/**
+ * Boot-time validation that every tool named in a subagent role's allowlist
+ * resolves to a real registered tool.
+ *
+ * A role allowlist (`SUBAGENT_ROLE_REGISTRY[role].allowedTools` in ./types.ts)
+ * is a list of plain tool-name strings. The names are matched against the live
+ * tool set purely by string equality (`subagentAllowedTools.has(name)`), so if
+ * a tool is renamed in the registry without updating the allowlist, the role
+ * silently loses access to it — the stale name simply never matches anything.
+ * This check surfaces that drift as a startup warning instead of a silent
+ * capability gap.
+ */
+
+import { getAllTools } from "../tools/registry.js";
+import { getLogger } from "../util/logger.js";
+import { SUBAGENT_ROLE_REGISTRY } from "./types.js";
+
+const log = getLogger("subagent-allowlist");
+
+/** A role allowlist entry that has no matching registered tool. */
+export interface UnknownAllowlistTool {
+  role: string;
+  tool: string;
+}
+
+/**
+ * Pure core: given the set of registered tool names, return every allowlist
+ * entry that has no matching registered tool. Roles with no allowlist
+ * (`allowedTools: undefined`, e.g. `general`) impose no filter and contribute
+ * nothing. Exported for direct unit testing without standing up the real tool
+ * registry.
+ */
+export function findUnknownAllowlistTools(
+  registeredToolNames: ReadonlySet<string>,
+): UnknownAllowlistTool[] {
+  const unknown: UnknownAllowlistTool[] = [];
+  for (const [role, config] of Object.entries(SUBAGENT_ROLE_REGISTRY)) {
+    if (!config.allowedTools) continue;
+    for (const tool of config.allowedTools) {
+      if (!registeredToolNames.has(tool)) unknown.push({ role, tool });
+    }
+  }
+  return unknown;
+}
+
+/**
+ * Validate every subagent role allowlist against the live tool registry,
+ * logging a warning for each unknown tool name. Uses `getAllTools()` — the raw
+ * registry, including tools owned by disabled plugins — rather than
+ * `getEnabledTools()`, so a legitimately-disabled plugin does not produce a
+ * false-positive warning: we are checking that the *name* exists, not that the
+ * tool is currently enabled. Never throws; returns the list of unknown
+ * `${role}:${tool}` entries (empty when every allowlist entry resolves).
+ */
+export function validateSubagentRoleAllowlists(): string[] {
+  const registered = new Set(getAllTools().map((tool) => tool.name));
+  const unknown = findUnknownAllowlistTools(registered);
+  for (const { role, tool } of unknown) {
+    log.warn(
+      { role, tool },
+      "Subagent role allowlist references unknown tool — role will silently lack access to it",
+    );
+  }
+  return unknown.map(({ role, tool }) => `${role}:${tool}`);
+}

package/src/telemetry/watchdog-direct-emit.test.ts

@@ -0,0 +1,109 @@
+/**
+ * Tests for the direct (unbuffered) watchdog telemetry emit.
+ *
+ * Unlike the batched reporter, this POSTs a single event straight to the
+ * platform ingest. It must honor the `share_analytics` opt-out and the
+ * platform-features gate, skip cleanly when credentials aren't resolved yet,
+ * and otherwise send a well-formed single-event payload.
+ */
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
+}));
+
+let shareAnalytics = true;
+mock.module("../platform/consent-cache.js", () => ({
+  getCachedShareAnalytics: () => shareAnalytics,
+}));
+
+let platformEnabled = true;
+mock.module("../platform/feature-gate.js", () => ({
+  arePlatformFeaturesEnabled: () => platformEnabled,
+}));
+
+const fetchCalls: Array<{ path: string; body: string }> = [];
+let clientAvailable = true;
+mock.module("../platform/client.js", () => ({
+  VellumPlatformClient: {
+    create: async () =>
+      clientAvailable
+        ? {
+            fetch: async (path: string, init: { body: string }) => {
+              fetchCalls.push({ path, body: init.body });
+              return new Response("", { status: 200 });
+            },
+          }
+        : null,
+  },
+}));
+
+mock.module("../config/env.js", () => ({
+  getPlatformOrganizationId: () => "org-1",
+  getPlatformUserId: () => "user-1",
+}));
+mock.module("../util/device-id.js", () => ({
+  getDeviceId: () => "device-xyz",
+}));
+mock.module("../version.js", () => ({ APP_VERSION: "9.9.9" }));
+
+import { emitWatchdogEventDirect } from "./watchdog-direct-emit.js";
+
+describe("emitWatchdogEventDirect", () => {
+  beforeEach(() => {
+    fetchCalls.length = 0;
+    shareAnalytics = true;
+    platformEnabled = true;
+    clientAvailable = true;
+  });
+
+  test("POSTs a single well-formed watchdog event when opted in", async () => {
+    await emitWatchdogEventDirect("sqlite_corrupted", {
+      database: "main",
+      error: "database disk image is malformed",
+    });
+
+    expect(fetchCalls).toHaveLength(1);
+    expect(fetchCalls[0].path).toBe("/v1/telemetry/ingest/");
+    const payload = JSON.parse(fetchCalls[0].body) as {
+      device_id: string;
+      assistant_version: string;
+      organization_id?: string;
+      user_id?: string;
+      events: Array<Record<string, unknown>>;
+    };
+    expect(payload.device_id).toBe("device-xyz");
+    expect(payload.assistant_version).toBe("9.9.9");
+    expect(payload.organization_id).toBe("org-1");
+    expect(payload.user_id).toBe("user-1");
+    expect(payload.events).toHaveLength(1);
+    const event = payload.events[0];
+    expect(event.type).toBe("watchdog");
+    expect(event.check_name).toBe("sqlite_corrupted");
+    expect(event.value).toBeNull();
+    expect(event.daemon_event_id).toBeString();
+    expect(event.detail).toMatchObject({
+      database: "main",
+      error: "database disk image is malformed",
+    });
+  });
+
+  test("sends nothing when share_analytics is opted out", async () => {
+    shareAnalytics = false;
+    await emitWatchdogEventDirect("sqlite_corrupted", { database: "main" });
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("sends nothing when platform features are disabled", async () => {
+    platformEnabled = false;
+    await emitWatchdogEventDirect("sqlite_corrupted", { database: "main" });
+    expect(fetchCalls).toHaveLength(0);
+  });
+
+  test("sends nothing (no throw) when credentials aren't resolved yet", async () => {
+    clientAvailable = false;
+    await emitWatchdogEventDirect("sqlite_corrupted", { database: "main" });
+    expect(fetchCalls).toHaveLength(0);
+  });
+});