@vellumai/assistant 0.8.5 → 0.8.7

package/src/api/responses/disk-pressure-status.ts

@@ -0,0 +1,26 @@
+/**
+ * Wire contract for the disk-pressure REST endpoints
+ * (`GET /disk-pressure/status`, `POST /disk-pressure/acknowledge`,
+ * `POST /disk-pressure/override`). All three return the current
+ * snapshot wrapped as `{ status }`.
+ *
+ * Reuses the canonical `DiskPressureStatusSchema` defined alongside the
+ * `disk_pressure_status_changed` SSE event so the polled REST fetch and
+ * the streamed update share a single shape.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers
+ * (web client, gateway, evals) import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+import { DiskPressureStatusSchema } from "../events/disk-pressure-status-changed.js";
+
+export const DiskPressureStatusResponseSchema = z.object({
+  status: DiskPressureStatusSchema,
+});
+
+export type DiskPressureStatusResponse = z.infer<
+  typeof DiskPressureStatusResponseSchema
+>;

package/src/api/responses/home.ts

@@ -0,0 +1,217 @@
+/**
+ * Wire contract for the Home REST endpoints.
+ *
+ *   - `GET /v1/home/feed`   → `HomeFeedResponse`
+ *   - `PATCH /v1/home/feed/:id` → `FeedItem`
+ *   - `GET /v1/home/state`  → `RelationshipState`
+ *
+ * Holds the canonical feed-item, suggested-prompt, and relationship-state
+ * shapes shared by the daemon route handlers, the on-disk feed-file parser
+ * (`home/feed-types.ts`), and every external client. Defining them here —
+ * rather than inline in the route files — means the daemon, the OpenAPI
+ * generator, and the web/CLI clients all derive from one source and cannot
+ * drift.
+ *
+ * A structurally compatible Swift mirror lives at
+ * `clients/shared/Network/FeedItem.swift`. Any change to the feed-item
+ * shape must be mirrored there.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers
+ * (web client, gateway, evals) import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// Feed item
+// ---------------------------------------------------------------------------
+
+/** High-level kind of feed item — drives which client view renders it. */
+export const FeedItemTypeSchema = z.literal("notification");
+export type FeedItemType = z.infer<typeof FeedItemTypeSchema>;
+
+/** User-facing lifecycle of a feed item. */
+export const FeedItemStatusSchema = z.enum([
+  "new",
+  "seen",
+  "acted_on",
+  "dismissed",
+]);
+export type FeedItemStatus = z.infer<typeof FeedItemStatusSchema>;
+
+/** Visual urgency treatment — controls badge color independently of sort priority. */
+export const FeedItemUrgencySchema = z.enum([
+  "low",
+  "medium",
+  "high",
+  "critical",
+]);
+export type FeedItemUrgency = z.infer<typeof FeedItemUrgencySchema>;
+
+/** Broad category for grouping and filtering feed items. */
+export const FeedItemCategorySchema = z.enum([
+  "security",
+  "scheduling",
+  "background",
+  "email",
+  "system",
+]);
+export type FeedItemCategory = z.infer<typeof FeedItemCategorySchema>;
+
+/**
+ * A single action button attached to a feed item.
+ *
+ * `prompt` is the pre-seeded user message the action sends to the
+ * assistant when triggered — the HTTP route creates a new conversation
+ * with this prompt as the first user turn.
+ */
+export const FeedActionSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  prompt: z.string(),
+});
+export type FeedAction = z.infer<typeof FeedActionSchema>;
+
+/** Which detail panel the client should open for this feed item. */
+export const FeedItemDetailPanelKindSchema = z.enum([
+  "emailDraft",
+  "documentPreview",
+  "permissionChat",
+  "paymentAuth",
+  "toolPermission",
+  "updatesList",
+]);
+export type FeedItemDetailPanelKind = z.infer<
+  typeof FeedItemDetailPanelKindSchema
+>;
+
+/** Server-driven detail panel descriptor attached to a feed item. */
+export const FeedItemDetailPanelSchema = z.object({
+  kind: FeedItemDetailPanelKindSchema,
+});
+export type FeedItemDetailPanel = z.infer<typeof FeedItemDetailPanelSchema>;
+
+/**
+ * A single item rendered in the Home feed.
+ *
+ * Notes:
+ *   - `priority` must be an integer in [0, 100]; string numerics
+ *     (e.g. `"5"`) are rejected — we want deterministic ordering and
+ *     silent coercion tends to mask writer bugs.
+ *   - `status` defaults to `"new"` so the writer does not need to set it
+ *     on every append.
+ *   - `createdAt` is the writer-record time (distinct from `timestamp`,
+ *     the event time). Used for TTL sweeps and stable ordering.
+ *   - `expiresAt` is an absolute ISO-8601 expiry timestamp.
+ *   - `title` is optional — clients fall back to `summary` when a row has
+ *     no header.
+ */
+export const FeedItemSchema = z.object({
+  id: z.string(),
+  type: FeedItemTypeSchema,
+  priority: z.number().int().min(0).max(100),
+  title: z.string().optional(),
+  summary: z.string(),
+  timestamp: z.string(),
+  status: FeedItemStatusSchema.default("new"),
+  expiresAt: z.string().optional(),
+  actions: z.array(FeedActionSchema).optional(),
+  urgency: FeedItemUrgencySchema.optional(),
+  conversationId: z.string().optional(),
+  detailPanel: FeedItemDetailPanelSchema.optional(),
+  category: FeedItemCategorySchema.optional(),
+  noteworthy: z.boolean().optional(),
+  fromAssistant: z.boolean().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  createdAt: z.string(),
+});
+export type FeedItem = z.infer<typeof FeedItemSchema>;
+
+// ---------------------------------------------------------------------------
+// Suggested prompt
+// ---------------------------------------------------------------------------
+
+/**
+ * Origin of a suggested prompt — whether it was deterministically derived
+ * (e.g. from a missing OAuth connection) or generated by the assistant.
+ */
+export const SuggestedPromptSourceSchema = z.enum([
+  "deterministic",
+  "assistant",
+]);
+export type SuggestedPromptSource = z.infer<typeof SuggestedPromptSourceSchema>;
+
+/** A prompt suggestion shown at the top of the Home page. */
+export const SuggestedPromptSchema = z.object({
+  id: z.string(),
+  label: z.string(),
+  icon: z.string().optional(),
+  prompt: z.string(),
+  source: SuggestedPromptSourceSchema,
+});
+export type SuggestedPrompt = z.infer<typeof SuggestedPromptSchema>;
+
+// ---------------------------------------------------------------------------
+// GET /v1/home/feed
+// ---------------------------------------------------------------------------
+
+/** Greeting + relative time-away label + new-item count banner. */
+export const ContextBannerSchema = z.object({
+  greeting: z.string(),
+  timeAwayLabel: z.string(),
+  newCount: z.number().int().min(0),
+});
+export type ContextBanner = z.infer<typeof ContextBannerSchema>;
+
+export const HomeFeedResponseSchema = z.object({
+  items: z.array(FeedItemSchema),
+  updatedAt: z.string(),
+  contextBanner: ContextBannerSchema,
+  suggestedPrompts: z.array(SuggestedPromptSchema),
+});
+export type HomeFeedResponse = z.infer<typeof HomeFeedResponseSchema>;
+
+// ---------------------------------------------------------------------------
+// GET /v1/home/state
+// ---------------------------------------------------------------------------
+
+export const FactSchema = z.object({
+  id: z.string(),
+  category: z.enum(["voice", "world", "priorities"]),
+  text: z.string(),
+  confidence: z.enum(["strong", "uncertain"]),
+  source: z.enum(["onboarding", "inferred"]),
+});
+export type Fact = z.infer<typeof FactSchema>;
+export type FactCategory = Fact["category"];
+export type FactConfidence = Fact["confidence"];
+export type FactSource = Fact["source"];
+
+export const CapabilitySchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  description: z.string(),
+  tier: z.enum(["unlocked", "next-up", "earned"]),
+  gate: z.string(),
+  unlockHint: z.string().optional(),
+  ctaLabel: z.string().optional(),
+});
+export type Capability = z.infer<typeof CapabilitySchema>;
+export type CapabilityTier = Capability["tier"];
+
+export const RelationshipStateSchema = z.object({
+  version: z.literal(1),
+  assistantId: z.string(),
+  tier: z.union([z.literal(1), z.literal(2), z.literal(3), z.literal(4)]),
+  progressPercent: z.number(),
+  facts: z.array(FactSchema),
+  capabilities: z.array(CapabilitySchema),
+  conversationCount: z.number(),
+  hatchedDate: z.string(),
+  assistantName: z.string(),
+  userName: z.string().optional(),
+  updatedAt: z.string(),
+});
+export type RelationshipState = z.infer<typeof RelationshipStateSchema>;
+export type RelationshipTier = RelationshipState["tier"];

package/src/api/responses/llm-context-response.ts

@@ -0,0 +1,41 @@
+/**
+ * Wire contract for the full payload returned by
+ * `GET /v1/conversations/llm-context`. Hydrates the Overview / Memory
+ * / Prompt / Response tabs from a single fetch.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers
+ * (web client, gateway, evals) import via `@vellumai/assistant-api`.
+ *
+ * The route is reachable on web through the gateway's runtime-proxy
+ * wildcard at
+ * `/v1/assistants/{assistantId}/conversations/llm-context/`. The
+ * response is built in `assistant/src/runtime/routes/conversation-query-routes.ts`.
+ *
+ * `conversationTotalEstimatedCostUsd` is the running total of priced
+ * LLM costs across every call in the conversation, sourced from the
+ * daemon's `conversations.total_estimated_cost` column. The field is
+ * optional because older daemons predate it — treat undefined / null
+ * as "unavailable".
+ */
+
+import { z } from "zod";
+
+import { LLMRequestLogEntrySchema } from "./llm-request-log-entry.js";
+import { MemoryRecallLogSchema } from "./memory-recall-log.js";
+import { MemoryV2ActivationLogSchema } from "./memory-v2-activation-log.js";
+import { MemoryV3SelectionLogSchema } from "./memory-v3-selection-log.js";
+
+export const LlmContextResponseSchema = z.object({
+  messageId: z.string().nullish(),
+  conversationKey: z.string().nullish(),
+  conversationId: z.string().nullish(),
+  conversationKind: z.string(),
+  conversationTotalEstimatedCostUsd: z.number().nullish(),
+  logs: z.array(LLMRequestLogEntrySchema),
+  memoryRecall: MemoryRecallLogSchema.nullable(),
+  memoryV2Activation: MemoryV2ActivationLogSchema.nullable(),
+  memoryV3Selection: MemoryV3SelectionLogSchema.nullish(),
+});
+
+export type LlmContextResponse = z.infer<typeof LlmContextResponseSchema>;

package/src/api/responses/llm-request-log-entry.ts

@@ -0,0 +1,93 @@
+/**
+ * Wire contract for a single LLM request log row, as returned by
+ * `GET /v1/conversations/llm-context`. Hydrates each call rail entry
+ * + tab in the inspector.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers (web
+ * client, gateway, evals) import via `@vellumai/assistant-api`.
+ *
+ * The route is implemented in
+ * `assistant/src/runtime/routes/conversation-query-routes.ts` and the
+ * row shape is constructed by `normalizeLlmContextLog` there. Keep the
+ * schemas here aligned with that constructor — the schema IS the
+ * contract; types are `z.infer`-derived.
+ *
+ * `requestPayload` / `responsePayload` are always `null` on the list
+ * endpoint; raw JSON is fetched lazily through
+ * `/v1/llm-request-logs/{logId}/payload`.
+ */
+
+import { z } from "zod";
+
+/**
+ * Provider-normalized summary attached to each request log. `null` /
+ * missing fields are common — formatters fall back to a shared
+ * "Unavailable" placeholder.
+ *
+ * `durationMs` isn't in the macOS reference shape today but the daemon
+ * already populates it for some providers — surfaced when present so
+ * web debugging gets the extra signal.
+ */
+export const LLMCallSummarySchema = z.object({
+  provider: z.string().nullish(),
+  model: z.string().nullish(),
+  status: z.string().nullish(),
+  inputTokens: z.number().nullish(),
+  outputTokens: z.number().nullish(),
+  cacheCreationInputTokens: z.number().nullish(),
+  cacheReadInputTokens: z.number().nullish(),
+  stopReason: z.string().nullish(),
+  requestMessageCount: z.number().nullish(),
+  requestToolCount: z.number().nullish(),
+  responseMessageCount: z.number().nullish(),
+  responseToolCallCount: z.number().nullish(),
+  responsePreview: z.string().nullish(),
+  toolCallNames: z.array(z.string()).nullish(),
+  estimatedCostUsd: z.number().nullish(),
+  durationMs: z.number().nullish(),
+});
+
+export type LLMCallSummary = z.infer<typeof LLMCallSummarySchema>;
+
+/**
+ * A single normalized request- or response-side section. The daemon
+ * splits a provider payload into kind-tagged blocks before returning;
+ * each block becomes one card in the Prompt / Response tabs.
+ */
+export const LLMContextSectionSchema = z.object({
+  kind: z.string(),
+  label: z.string().nullish(),
+  role: z.string().nullish(),
+  text: z.string().nullish(),
+  toolName: z.string().nullish(),
+  data: z.unknown().optional(),
+  language: z.string().nullish(),
+});
+
+export type LLMContextSection = z.infer<typeof LLMContextSectionSchema>;
+
+/**
+ * One LLM request log row.
+ *
+ * `callSite` is the logical call site that produced this row —
+ * `mainAgent`, `compactionAgent`, `syntheticAgentErrorMessage`, etc.
+ * `null` on pre-migration-264 rows or callers that hadn't been wired
+ * through yet. The inspector branches on this value alone to
+ * distinguish real LLM calls from synthetic error-message rows. See
+ * `../constants/call-sites.ts` for the canonical identifiers.
+ */
+export const LLMRequestLogEntrySchema = z.object({
+  id: z.string(),
+  createdAt: z.number(),
+  requestPayload: z.null(),
+  responsePayload: z.null(),
+  provider: z.string().nullish(),
+  summary: LLMCallSummarySchema.nullish(),
+  requestSections: z.array(LLMContextSectionSchema).nullish(),
+  responseSections: z.array(LLMContextSectionSchema).nullish(),
+  agentLoopExitReason: z.string().nullish(),
+  callSite: z.string().nullish(),
+});
+
+export type LLMRequestLogEntry = z.infer<typeof LLMRequestLogEntrySchema>;

package/src/api/responses/memory-recall-log.ts

@@ -0,0 +1,65 @@
+/**
+ * Wire contract for the memory-recall log surfaced in the inspector's
+ * Memory tab. Mirrors `MemoryRecallLog` from
+ * `assistant/src/memory/memory-recall-log-store.ts`.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers
+ * (web client, gateway, evals) import via `@vellumai/assistant-api`.
+ *
+ * Returned as part of `LlmContextResponse` — see
+ * `./llm-context-response.ts`.
+ */
+
+import { z } from "zod";
+
+/**
+ * A single recalled memory candidate, normalized by the daemon from
+ * the SSE-event format into inspector format.
+ */
+export const MemoryCandidateSchema = z.object({
+  nodeId: z.string(),
+  score: z.number(),
+  semanticSimilarity: z.number(),
+  recencyBoost: z.number(),
+  type: z.string().optional(),
+});
+
+export type MemoryCandidate = z.infer<typeof MemoryCandidateSchema>;
+
+/**
+ * Degradation details when memory recall ran in a degraded mode.
+ */
+export const MemoryDegradationSchema = z.object({
+  reason: z.string(),
+  semanticUnavailable: z.boolean(),
+  fallbackSources: z.array(z.string()),
+});
+
+export type MemoryDegradation = z.infer<typeof MemoryDegradationSchema>;
+
+/**
+ * Memory recall log shape.
+ */
+export const MemoryRecallLogSchema = z.object({
+  enabled: z.boolean(),
+  degraded: z.boolean(),
+  provider: z.string().nullable(),
+  model: z.string().nullable(),
+  degradation: MemoryDegradationSchema.nullable(),
+  semanticHits: z.number().nullish(),
+  mergedCount: z.number().nullish(),
+  selectedCount: z.number().nullish(),
+  tier1Count: z.number().nullish(),
+  tier2Count: z.number().nullish(),
+  hybridSearchLatencyMs: z.number().nullish(),
+  sparseVectorUsed: z.boolean().nullish(),
+  injectedTokens: z.number().nullish(),
+  latencyMs: z.number().nullish(),
+  topCandidates: z.array(MemoryCandidateSchema),
+  injectedText: z.string().nullable(),
+  reason: z.string().nullable(),
+  queryContext: z.string().nullable(),
+});
+
+export type MemoryRecallLog = z.infer<typeof MemoryRecallLogSchema>;

package/src/api/responses/memory-v2-activation-log.ts

@@ -0,0 +1,78 @@
+/**
+ * Wire contract for the memory v2 activation log surfaced in the
+ * inspector's Memory tab. Mirrors the return value of
+ * `getMemoryV2ActivationLogByMessageIds` in
+ * `assistant/src/memory/memory-v2-activation-log-store.ts`.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers
+ * (web client, gateway, evals) import via `@vellumai/assistant-api`.
+ *
+ * Returned as part of `LlmContextResponse` — see
+ * `./llm-context-response.ts`.
+ *
+ * Note: daemon emits the `config` block with snake_case keys; the
+ * schema below preserves that on the wire.
+ */
+
+import { z } from "zod";
+
+/**
+ * One concept row in the V2 activation log. Mirrors
+ * `MemoryV2ConceptRowRecord` from
+ * `assistant/src/memory/memory-v2-activation-log-store.ts`.
+ *
+ * `source` and `status` are open-ended strings on the wire — the
+ * daemon emits known values like `prior_state`, `ann_top50`, `both`
+ * for `source` and `in_context`, `injected`, `not_injected`,
+ * `page_missing` for `status`, but the schema stays permissive so a
+ * new daemon value doesn't break parsing on the FE.
+ */
+export const MemoryV2ConceptRowSchema = z.object({
+  slug: z.string(),
+  finalActivation: z.number(),
+  ownActivation: z.number(),
+  priorActivation: z.number(),
+  simUser: z.number(),
+  simAssistant: z.number(),
+  simNow: z.number(),
+  simUserRerankBoost: z.number().optional(),
+  simAssistantRerankBoost: z.number().optional(),
+  inRerankPool: z.boolean().optional(),
+  spreadContribution: z.number(),
+  source: z.string(),
+  status: z.string(),
+});
+
+export type MemoryV2ConceptRow = z.infer<typeof MemoryV2ConceptRowSchema>;
+
+/**
+ * Config snapshot used when the V2 activation ran. Mirrors
+ * `MemoryV2ConfigSnapshot` (daemon uses snake_case keys).
+ */
+export const MemoryV2ConfigSnapshotSchema = z.object({
+  d: z.number(),
+  c_user: z.number(),
+  c_assistant: z.number(),
+  c_now: z.number(),
+  k: z.number(),
+  hops: z.number(),
+  top_k: z.number(),
+  epsilon: z.number(),
+});
+
+export type MemoryV2ConfigSnapshot = z.infer<
+  typeof MemoryV2ConfigSnapshotSchema
+>;
+
+/**
+ * Memory v2 activation log shape.
+ */
+export const MemoryV2ActivationLogSchema = z.object({
+  turn: z.number(),
+  mode: z.string(),
+  concepts: z.array(MemoryV2ConceptRowSchema),
+  config: MemoryV2ConfigSnapshotSchema,
+});
+
+export type MemoryV2ActivationLog = z.infer<typeof MemoryV2ActivationLogSchema>;

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

@@ -0,0 +1,50 @@
+/**
+ * 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`.
+ *
+ * Canonical wire-contract source. Assistant code imports the types directly
+ * from this file via relative paths; external consumers (web client, gateway,
+ * evals) import via `@vellumai/assistant-api`.
+ *
+ * Returned as part of `LlmContextResponse` — see `./llm-context-response.ts`.
+ *
+ * `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.
+ */
+
+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.
+ */
+export const MemoryV3SelectionRowSchema = z.object({
+  slug: z.string(),
+  source: z.string(),
+  pinned: z.boolean(),
+});
+
+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).
+ */
+export const MemoryV3SelectionLogSchema = z.object({
+  turn: z.number(),
+  live: z.boolean(),
+  shadow: z.boolean(),
+  selections: z.array(MemoryV3SelectionRowSchema),
+  injectedText: z.string(),
+});
+
+export type MemoryV3SelectionLog = z.infer<typeof MemoryV3SelectionLogSchema>;

package/src/api/responses/subagent-detail.ts

@@ -0,0 +1,48 @@
+/**
+ * Wire contract for the subagent-detail REST endpoint
+ * (`GET /subagents/:id`). Returns a subagent's objective, live status,
+ * cumulative usage, and the reconstructed event history parsed from its
+ * stored message rows.
+ *
+ * Reuses the canonical `SubagentStatusSchema` and `SubagentUsageStatsSchema`
+ * defined alongside the `subagent_status_changed` SSE event so the polled
+ * REST detail and the streamed status update share one status/usage shape.
+ *
+ * Canonical wire-contract source. Assistant code imports the types
+ * directly from this file via relative paths; external consumers
+ * (web client, gateway, evals) import via `@vellumai/assistant-api`.
+ */
+
+import { z } from "zod";
+
+import {
+  SubagentStatusSchema,
+  SubagentUsageStatsSchema,
+} from "../events/subagent-status-changed.js";
+
+/**
+ * A single reconstructed event in a subagent's history. Built from the
+ * subagent conversation's stored message rows (assistant text, tool calls,
+ * tool results), so `type` is an open string rather than a closed enum.
+ */
+export const SubagentDetailEventSchema = z.object({
+  type: z.string(),
+  content: z.string(),
+  toolName: z.string().optional(),
+  isError: z.boolean().optional(),
+  messageId: z.string().optional(),
+});
+
+export type SubagentDetailEvent = z.infer<typeof SubagentDetailEventSchema>;
+
+export const SubagentDetailResponseSchema = z.object({
+  subagentId: z.string(),
+  objective: z.string().optional(),
+  status: SubagentStatusSchema.optional(),
+  usage: SubagentUsageStatsSchema.optional(),
+  events: z.array(SubagentDetailEventSchema),
+});
+
+export type SubagentDetailResponse = z.infer<
+  typeof SubagentDetailResponseSchema
+>;

package/src/approvals/guardian-decision-primitive.ts

@@ -198,19 +198,17 @@ export async function applyGuardianDecision(
     decisionContext,
   } = params;
 
-  const effectiveDecision: ApprovalDecisionResult = decision;
-
   // Capture pending approval info before handleChannelDecision resolves
   // (and removes) the pending interaction. Needed for grant minting.
   const approvalInfo = getApprovalInfoByConversation(approval.conversationId);
-  const matchedInfo = effectiveDecision.requestId
-    ? approvalInfo.find((a) => a.requestId === effectiveDecision.requestId)
+  const matchedInfo = decision.requestId
+    ? approvalInfo.find((a) => a.requestId === decision.requestId)
     : approvalInfo[0];
 
   // Apply the decision to the underlying session
   const result = await handleChannelDecision(
     approval.conversationId,
-    effectiveDecision,
+    decision,
     decisionContext,
   );
 
@@ -218,15 +216,13 @@ export async function applyGuardianDecision(
     return {
       applied: false,
       reason: "stale",
-      requestId: effectiveDecision.requestId,
+      requestId: decision.requestId,
     };
   }
 
   // Update the guardian approval request record
   const approvalStatus =
-    effectiveDecision.action === "reject"
-      ? ("denied" as const)
-      : ("approved" as const);
+    decision.action === "reject" ? ("denied" as const) : ("approved" as const);
   updateApprovalDecision(approval.id, {
     status: approvalStatus,
     decidedByExternalUserId: actorExternalUserId ?? actorPrincipalId,
@@ -236,17 +232,13 @@ export async function applyGuardianDecision(
   // Skip when neither actor identity is available -- minting a grant without
   // a known guardian identity is meaningless (e.g. requester self-cancel).
   const effectiveGuardianId = actorExternalUserId ?? actorPrincipalId;
-  if (
-    effectiveDecision.action !== "reject" &&
-    matchedInfo &&
-    effectiveGuardianId
-  ) {
+  if (decision.action !== "reject" && matchedInfo && effectiveGuardianId) {
     tryMintToolApprovalGrant({
       approvalInfo: matchedInfo,
       approval,
       decisionChannel: actorChannel,
       guardianExternalUserId: effectiveGuardianId,
-      effectiveAction: effectiveDecision.action,
+      effectiveAction: decision.action,
     });
   }