@vellumai/assistant 0.8.8 → 0.8.9-dev.202606091926.ebb2d62

package/src/api/events/tool-result.ts

@@ -124,6 +124,15 @@ export const ToolResultEventSchema = z.object({
   approvalReason: z.string().optional(),
   riskThreshold: z.string().optional(),
   activityMetadata: ToolActivityMetadataSchema.optional(),
+  /**
+   * Unix ms when the daemon finished executing the tool. Pairs with
+   * `ToolUseStartEvent.startedAt` so clients can render a final duration that
+   * stays on the daemon's clock, matching the live elapsed-time counter and
+   * avoiding skew between a server-stamped start and a browser-stamped end.
+   * Absent on streams from older daemons; clients fall back to their own
+   * receipt time.
+   */
+  completedAt: z.number().optional(),
 });
 
 export type ToolResultEvent = z.infer<typeof ToolResultEventSchema>;

package/src/api/events/tool-use-start.ts

@@ -25,6 +25,13 @@ export const ToolUseStartEventSchema = z.object({
   toolUseId: z.string().optional(),
   messageId: z.string().optional(),
   conversationId: z.string().optional(),
+  /**
+   * Unix ms when the daemon began executing the tool. Lets clients anchor a
+   * live elapsed-time counter to the server clock instead of the moment the
+   * event was received over SSE. Absent on streams from older daemons that
+   * pre-date this field; clients fall back to their own receipt time.
+   */
+  startedAt: z.number().optional(),
 });
 
 export type ToolUseStartEvent = z.infer<typeof ToolUseStartEventSchema>;

package/src/api/responses/conversation-message.ts

@@ -301,7 +301,14 @@ export type ConversationSlackMessage = z.infer<
  */
 export const ConversationContentBlockSchema = z.discriminatedUnion("type", [
   z.object({ type: z.literal("text"), text: z.string() }),
-  z.object({ type: z.literal("thinking"), thinking: z.string() }),
+  z.object({
+    type: z.literal("thinking"),
+    thinking: z.string(),
+    /** Unix ms when the model began emitting this reasoning block. */
+    startedAt: z.number().optional(),
+    /** Unix ms when this reasoning block completed. */
+    completedAt: z.number().optional(),
+  }),
   z.object({
     type: z.literal("tool_use"),
     toolCall: ConversationMessageToolCallSchema,
@@ -335,25 +342,77 @@ export const ConversationMessageSchema = z.object({
    * assistant messages were consolidated for history rendering.
    */
   mergedMessageIds: z.array(z.string()).optional(),
-  role: z.string(),
   /**
-   * Flat plain-text body (joined text segments). Redundant with
-   * `textSegments`/`contentOrder` for clients that render from the positional
-   * arrays (web, CLI), but the legacy Swift macOS client reads `content`
-   * directly and drops any history row missing it (its
-   * `HistoryReconstructionService` skips rows with empty text). The serializer
-   * always emits it — do not remove without updating that client.
+   * Client-generated idempotency nonce echoed back on the persisted row.
+   * Present only for messages a client sent with one (user sends); lets the
+   * client correlate an optimistic row with its confirmed server row by
+   * identity instead of matching message text.
+   */
+  clientMessageId: z.string().optional(),
+  /**
+   * Renderable conversation roles only. The messages endpoint emits a
+   * UI-facing transcript, so it excludes the `system` rows that the
+   * underlying `MessageRole` column also permits — those are agent-context
+   * scaffolding, never a displayed turn.
+   */
+  role: z.enum(["user", "assistant"]),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Flat plain-text body (joined
+   * text segments). Redundant with `textSegments`/`contentOrder` for clients
+   * that render from the positional arrays (web, CLI), but the legacy Swift
+   * macOS client reads `content` directly and drops any history row missing it
+   * (its `HistoryReconstructionService` skips rows with empty text). The
+   * serializer always emits it — do not remove without updating that client.
    */
-  content: z.string().optional(),
+  content: z
+    .string()
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks. Flat plain-text body (joined text segments).",
+    })
+    .optional(),
   /** Display timestamp as an ISO-8601 string. */
   timestamp: z.string(),
   attachments: z.array(ConversationMessageAttachmentSchema),
   toolCalls: z.array(ConversationMessageToolCallSchema).optional(),
   surfaces: z.array(ConversationMessageSurfaceSchema).optional(),
-  textSegments: z.array(z.string()).optional(),
-  thinkingSegments: z.array(z.string()).optional(),
-  /** Positional `"<type>:<index>"` content ordering (e.g. `"text:0"`, `"thinking:1"`). */
-  contentOrder: z.array(z.string()).optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Text split by tool-call
+   * boundaries; positional sibling of `contentOrder`.
+   */
+  textSegments: z
+    .array(z.string())
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks. Text segments split by tool-call boundaries.",
+    })
+    .optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Reasoning text extracted from
+   * thinking blocks; positional sibling of `contentOrder`.
+   */
+  thinkingSegments: z
+    .array(z.string())
+    .meta({
+      deprecated: true,
+      description:
+        "Deprecated: superseded by contentBlocks. Reasoning text extracted from thinking blocks.",
+    })
+    .optional(),
+  /**
+   * @deprecated Superseded by `contentBlocks`. Positional
+   * `"<type>:<index>"` content ordering (e.g. `"text:0"`, `"thinking:1"`).
+   */
+  contentOrder: z
+    .array(z.string())
+    .meta({
+      deprecated: true,
+      description:
+        'Deprecated: superseded by contentBlocks. Positional "<type>:<index>" content ordering (e.g. "text:0", "thinking:1").',
+    })
+    .optional(),
   /**
    * Unified ordered content blocks — the display-ready projection of the
    * row's model-native content. Ships alongside the positional

package/src/api/responses/memory-v3-selection-log.ts

@@ -1,7 +1,7 @@
 /**
  * Wire contract for the memory v3 selection set surfaced in the inspector's
  * Memory tab. Mirrors the return value of `getMemoryV3SelectionForInspector`
- * in `assistant/src/memory/v3/selection-log-store.ts`.
+ * in `assistant/src/plugins/defaults/memory-v3-shadow/selection-log-store.ts`.
  *
  * Canonical wire-contract source. Assistant code imports the types directly
  * from this file via relative paths; external consumers (web client, gateway,
@@ -12,19 +12,27 @@
  * `live` / `shadow` reflect the CURRENT `memory-v3-live` / `memory-v3-shadow`
  * flag state, not the per-turn history (the selection rows don't record which
  * mode was active when they were written). When `live` is true the rendered
- * `injectedText` block was actually injected into the turn; when only `shadow`
- * is true it is the block that WOULD have been injected. For stable-flag
- * shadow validation these coincide; recording per-turn `injected` is a
- * documented follow-up.
+ * `injectedText` reflects the live selection; when only `shadow` is true it is
+ * the block that WOULD have been injected.
+ *
+ * `injectedText` is APPROXIMATE, not a verbatim record. It is re-rendered from
+ * the persisted selection rows, which store slug/source/pinned but NOT the
+ * matched-section identity. A page that live injection sent as a single matched
+ * section is re-rendered here as its FULL page (the section ordinal isn't
+ * persisted), so the text can differ from what was actually sent to the model.
+ * The selected slug set is exact — only the rendered text is full-page
+ * approximate. Persisting the per-turn injected section is a documented
+ * follow-up.
  */
 
 import { z } from "zod";
 
 /**
  * One selected page in the v3 set. `source` is the lane that surfaced it —
- * the daemon emits `l1+l2`, `core+l2`, `needle`, or `carry-forward` — but the
- * schema stays a permissive string so a new lane label doesn't break parsing
- * on the FE. `pinned` marks a slug carried forward across turns.
+ * the daemon emits `needle`, `dense`, `edge`, or `carry-forward` — but the
+ * schema stays a permissive string so a new lane label (or a historical
+ * pre-lane row) doesn't break parsing on the FE. `pinned` marks a slug carried
+ * forward across turns.
  */
 export const MemoryV3SelectionRowSchema = z.object({
   slug: z.string(),
@@ -36,8 +44,9 @@ export type MemoryV3SelectionRow = z.infer<typeof MemoryV3SelectionRowSchema>;
 
 /**
  * Memory v3 selection log shape. `injectedText` is the rendered
- * `<memory>…</memory>` block for the selection (actual when `live`, would-be
- * when `shadow`-only).
+ * `<memory>…</memory>` block for the selection — APPROXIMATE: re-rendered from
+ * the persisted rows, with full pages where live injection used a matched
+ * section (the section identity isn't persisted). See the file header.
  */
 export const MemoryV3SelectionLogSchema = z.object({
   turn: z.number(),

package/src/approvals/guardian-request-resolvers.ts

@@ -14,7 +14,7 @@
 import { answerCall } from "../calls/call-domain.js";
 import { findContactChannel } from "../contacts/contact-store.js";
 import { upsertContactChannel } from "../contacts/contacts-write.js";
-import { findConversation } from "../daemon/conversation-store.js";
+import { findConversation } from "../daemon/conversation-registry.js";
 import {
   type CanonicalGuardianRequest,
   getCanonicalGuardianRequest,
@@ -196,6 +196,32 @@ const pendingInteractionResolver: GuardianRequestResolver = {
     // resolveConfirmation() owns pendingInteractions deregistration.
     const userDecision: UserDecision =
       decision.action === "reject" ? "deny" : "allow";
+
+    // Route-owned confirmations (e.g. the ACP spawn/steer approval gate in
+    // acp-routes.ts) carry a `directResolve` and are NOT owned by any
+    // Conversation.prompter, so handleConfirmationResponse below would no-op
+    // and the caller would block until timeout. Resolve them directly, exactly
+    // as the POST /v1/confirm route does (see approval-routes.ts).
+    if (interaction.directResolve) {
+      pendingInteractions.resolve(
+        request.id,
+        userDecision === "allow" ? "approved" : "rejected",
+      );
+      interaction.directResolve(userDecision);
+      log.info(
+        {
+          event: "resolver_tool_approval_applied",
+          requestId: request.id,
+          action: decision.action,
+          conversationId: request.conversationId,
+          toolName: request.toolName,
+          directResolve: true,
+        },
+        "Tool approval resolver: direct-resolve interaction resolved",
+      );
+      return { ok: true, applied: true };
+    }
+
     const conversation = findConversation(interaction.conversationId);
     if (!conversation) {
       return {

package/src/background-wake/next-wake.ts

@@ -97,6 +97,7 @@ function getHeartbeatWakeSource(now: number): HeartbeatWakeSource | null {
 
   const service = HeartbeatService.getInstance();
   if (service?.isConsecutiveRunCapReached) return null;
+  if (service?.isDailyCapReached) return null;
 
   const serviceNextRunAt = service?.nextRunAt ?? null;
   let nextRunAt = serviceNextRunAt;