@agent-native/core 0.100.2 → 0.101.3

package/corpus/core/src/client/review/index.ts

@@ -1,3 +1,7 @@
+export {
+  ReviewCommentComposer,
+  type ReviewCommentComposerProps,
+} from "./ReviewCommentComposer.js";
 export {
   ReviewStatusBadge,
   type ReviewStatusBadgeProps,
@@ -6,6 +10,8 @@ export {
   ReviewThreadPanel,
   buildReviewThreads,
   type ReviewThread,
+  type ReviewCommentCapability,
+  type ReviewThreadCapability,
   type ReviewThreadPanelProps,
 } from "./ReviewThreadPanel.js";
 export {
@@ -17,6 +23,7 @@ export {
   useReviewComments,
   useReviewFeedback,
   useSetReviewStatus,
+  useSendReviewThreadToAgent,
   type ConsumeReviewFeedbackInput,
   type CreateReviewCommentInput,
   type DeleteReviewCommentInput,
@@ -27,4 +34,5 @@ export {
   type ReplyReviewCommentInput,
   type ResolveReviewThreadInput,
   type SetReviewStatusInput,
+  type SendReviewThreadToAgentInput,
 } from "./use-review.js";

package/corpus/core/src/client/review/use-review.ts

@@ -20,6 +20,10 @@ export interface ListReviewCommentsParams {
 export interface ListReviewCommentsResult {
   comments: ReviewComment[];
   reviewStatus: ReviewStatusEntry | null;
+  summary: {
+    openCount: number;
+    agentQueueCount: number;
+  };
 }
 
 export interface GetReviewFeedbackParams {
@@ -62,6 +66,7 @@ export interface ResolveReviewThreadInput {
   resourceId: string;
   threadId?: string;
   commentId?: string;
+  resolutionNote?: string;
 }
 
 export interface DeleteReviewCommentInput {
@@ -76,6 +81,12 @@ export interface ConsumeReviewFeedbackInput {
   commentIds: string[];
 }
 
+export interface SendReviewThreadToAgentInput {
+  resourceType: string;
+  resourceId: string;
+  threadId: string;
+}
+
 export interface SetReviewStatusInput {
   resourceType: string;
   resourceId: string;
@@ -126,7 +137,13 @@ export function useReplyReviewComment() {
 
 export function useResolveReviewThread() {
   return useActionMutation<
-    { threadId: string; resolved: true; updatedCount: number },
+    {
+      threadId: string;
+      resolved: true;
+      updatedCount: number;
+      resolutionNote: string | null;
+      comment: ReviewComment;
+    },
     ResolveReviewThreadInput
   >("resolve-review-thread");
 }
@@ -145,6 +162,23 @@ export function useConsumeReviewFeedback() {
   >("consume-review-feedback");
 }
 
+export function useSendReviewThreadToAgent() {
+  return useActionMutation<
+    {
+      resourceType: string;
+      resourceId: string;
+      threadId: string;
+      resolutionTarget: "agent";
+      consumedAt: null;
+      updatedCount: number;
+      ownerEmail: string | null;
+      orgId: string | null;
+      visibility: "private" | "org" | "public";
+    },
+    SendReviewThreadToAgentInput
+  >("send-review-thread-to-agent");
+}
+
 export function useSetReviewStatus() {
   return useActionMutation<ReviewStatusEntry, SetReviewStatusInput>(
     "set-review-status",

package/corpus/core/src/client/use-agent-chat-context.ts

@@ -26,7 +26,7 @@ export interface UseAgentChatContextResult extends AgentChatContextState {
  * composer's staged context chips. Simple send/prefill flows should use
  * `sendToAgentChat({ message, context, submit })` directly.
  */
-export function useAgentChatContext(): UseAgentChatContextResult {
+export function useAgentChatContext(enabled = true): UseAgentChatContextResult {
   const appStateVersion = useChangeVersion("app-state");
   const state = useSyncExternalStore(
     subscribeAgentChatContext,
@@ -35,8 +35,9 @@ export function useAgentChatContext(): UseAgentChatContextResult {
   );
 
   useEffect(() => {
+    if (!enabled) return;
     void refreshAgentChatContext();
-  }, [appStateVersion]);
+  }, [appStateVersion, enabled]);
 
   const set = useCallback((item: AgentChatContextSetOptions) => {
     setAgentChatContextItem(item);

package/corpus/core/src/credentials/index.ts

@@ -3,6 +3,7 @@ import {
   decryptSecretValue,
   isEncryptedSecretValue,
 } from "../secrets/crypto.js";
+import { readAppSecret, type SecretRef } from "../secrets/storage.js";
 import { getSetting, putSetting, deleteSetting } from "../settings/store.js";
 
 const SETTING_PREFIX = "credential:";
@@ -41,6 +42,20 @@ async function readCredentialSetting(
   }
 }
 
+async function readScopedAppSecret(
+  key: string,
+  scope: SecretRef["scope"],
+  scopeId: string,
+): Promise<string | undefined> {
+  try {
+    return (await readAppSecret({ key, scope, scopeId }))?.value;
+  } catch {
+    // Older databases may not have app_secrets yet. Keep the legacy
+    // credential store available while the table bootstraps.
+    return undefined;
+  }
+}
+
 /**
  * Resolve a credential from one explicit legacy SQL credential scope.
  *
@@ -61,16 +76,21 @@ export async function resolveCredentialForScope(
 }
 
 /**
- * Resolve a credential, scoped to the caller's user (and falling back to
- * the active org's shared credential, if any).
+ * Resolve a credential across the encrypted app_secrets store and the legacy
+ * settings-backed credential store. User overrides win, followed by the
+ * active org/workspace shared value.
  *
  * SECURITY: NEVER reads from process.env. Env vars are global to the
- * deployment and would leak across users in a multi-tenant app. The only
- * sources are per-user / per-org rows in the SQL `settings` table.
+ * deployment and would leak across users in a multi-tenant app.
+ *
+ * Read order:
+ *   1. user-scoped app_secrets
+ *   2. user-scoped legacy settings credential
+ *   3. org-scoped app_secrets
+ *   4. legacy workspace-scoped app_secrets for the org
+ *   5. org-scoped legacy settings credential
  *
- * Storage keys (priority order):
- *   1. u:<email>:credential:<KEY>   — per-user override
- *   2. o:<orgId>:credential:<KEY>   — per-org shared credential (if orgId given)
+ * Without an active org, step 3 is replaced by the solo workspace scope.
  */
 export async function resolveCredential(
   key: string,
@@ -78,6 +98,9 @@ export async function resolveCredential(
 ): Promise<string | undefined> {
   if (!ctx?.userEmail) return undefined;
 
+  const userSecret = await readScopedAppSecret(key, "user", ctx.userEmail);
+  if (userSecret) return userSecret;
+
   const userSetting = await resolveCredentialForScope(key, {
     ...ctx,
     scope: "user",
@@ -85,10 +108,20 @@ export async function resolveCredential(
   if (userSetting) return userSetting;
 
   if (ctx.orgId) {
+    const orgSecret = await readScopedAppSecret(key, "org", ctx.orgId);
+    if (orgSecret) return orgSecret;
+
+    const workspaceSecret = await readScopedAppSecret(
+      key,
+      "workspace",
+      ctx.orgId,
+    );
+    if (workspaceSecret) return workspaceSecret;
+
     return resolveCredentialForScope(key, { ...ctx, scope: "org" });
   }
 
-  return undefined;
+  return readScopedAppSecret(key, "workspace", `solo:${ctx.userEmail}`);
 }
 
 /**

package/corpus/core/src/extensions/fetch-tool.ts

@@ -11,6 +11,7 @@
  */
 
 import type { ActionEntry } from "../agent/production-agent.js";
+import type { ResolvedKeyReference } from "../secrets/substitution.js";
 import {
   collectSecretValues,
   MAX_EXTENSION_PROXY_RESPONSE_SIZE,
@@ -77,9 +78,23 @@ export interface FetchToolOptions {
     resolved: string;
     usedKeys: string[];
     secretValues?: string[];
+    /**
+     * Optional: which scope (user/org/workspace) each used key actually
+     * resolved at. Populated by resolvers like
+     * `resolveKeyReferencesWithRequestScopes` so `validateUrl` can look up
+     * the allowlist at the scope the value came from rather than assuming
+     * user scope. Backwards compatible — callers that omit this (or a
+     * resolver that doesn't report it) are unaffected.
+     */
+    resolvedKeys?: ResolvedKeyReference[];
   }>;
   /** Validate URL against per-key allowlists. */
-  validateUrl?: (url: string, usedKeys: string[]) => Promise<boolean>;
+  validateUrl?: (
+    url: string,
+    usedKeys: string[],
+    /** Accumulated `resolvedKeys` from every `resolveKeys` call this request made, when the resolver reported them. */
+    resolvedKeys?: ResolvedKeyReference[],
+  ) => Promise<boolean>;
 }
 
 /**
@@ -207,6 +222,7 @@ export function createFetchToolEntry(
         let resolvedBody = rawBody;
         const allUsedKeys: string[] = [];
         const allSecretValues: string[] = [];
+        const allResolvedKeys: ResolvedKeyReference[] = [];
 
         if (opts.resolveKeys) {
           try {
@@ -214,23 +230,29 @@ export function createFetchToolEntry(
             resolvedUrl = urlResult.resolved;
             allUsedKeys.push(...urlResult.usedKeys);
             allSecretValues.push(...(urlResult.secretValues ?? []));
+            allResolvedKeys.push(...(urlResult.resolvedKeys ?? []));
 
             const headerResult = await opts.resolveKeys(rawHeaders);
             resolvedHeaders = headerResult.resolved;
             allUsedKeys.push(...headerResult.usedKeys);
             allSecretValues.push(...(headerResult.secretValues ?? []));
+            allResolvedKeys.push(...(headerResult.resolvedKeys ?? []));
 
             if (rawBody) {
               const bodyResult = await opts.resolveKeys(rawBody);
               resolvedBody = bodyResult.resolved;
               allUsedKeys.push(...bodyResult.usedKeys);
               allSecretValues.push(...(bodyResult.secretValues ?? []));
+              allResolvedKeys.push(...(bodyResult.resolvedKeys ?? []));
             }
           } catch (err: any) {
             return `Error resolving key references: ${err?.message ?? err}`;
           }
         }
         const secretValues = collectSecretValues(allSecretValues);
+        const resolvedKeys = allResolvedKeys.length
+          ? allResolvedKeys
+          : undefined;
 
         // Block SSRF targets regardless of key usage
         if (await isBlockedExtensionUrlWithDns(resolvedUrl)) {
@@ -240,7 +262,11 @@ export function createFetchToolEntry(
         // Validate URL against per-key allowlists
         if (opts.validateUrl && allUsedKeys.length > 0) {
           try {
-            const allowed = await opts.validateUrl(resolvedUrl, allUsedKeys);
+            const allowed = await opts.validateUrl(
+              resolvedUrl,
+              allUsedKeys,
+              resolvedKeys,
+            );
             if (!allowed) {
               return `URL "${rawUrl}" is not in the allowlist for the referenced keys. Check your key settings.`;
             }
@@ -298,7 +324,11 @@ export function createFetchToolEntry(
               return "Redirect to private/internal address blocked.";
             }
             if (redirectUrl && opts.validateUrl && allUsedKeys.length > 0) {
-              const allowed = await opts.validateUrl(redirectUrl, allUsedKeys);
+              const allowed = await opts.validateUrl(
+                redirectUrl,
+                allUsedKeys,
+                resolvedKeys,
+              );
               if (!allowed) {
                 return "Redirect URL is not in the allowlist for the referenced keys.";
               }

package/corpus/core/src/notifications/channels.ts

@@ -29,7 +29,7 @@
 
 import { ssrfSafeFetch } from "../extensions/url-safety.js";
 import {
-  resolveKeyReferences,
+  resolveKeyReferencesWithRequestScopes,
   validateUrlAllowlist,
   getKeyAllowlist,
 } from "../secrets/substitution.js";
@@ -215,21 +215,30 @@ async function resolveWebhookRequest(
   owner: string,
   label: string,
 ): Promise<{ url: string; headers: Record<string, string> }> {
-  // Resolve `${keys.NAME}` references against the owner's user-scope secrets.
+  // Resolve `${keys.NAME}` references through the same request-scope
+  // cascade already used by extension fetches (extensions/routes.ts) and
+  // automation connector headers (automation/index.ts): user scope first
+  // (a personal override always wins), then the active org scope — where
+  // the Dispatch vault syncs workspace secrets — then workspace scope.
+  // Org/workspace vault rows are write-gated (org-admin + Dispatch vault
+  // UI), so reading them here is safe by default; this is unrelated to the
+  // opt-in-only user→workspace fallback in resolveKeyReferences (audit 05
+  // H2 in secrets/substitution.ts), which stays off. In headless contexts
+  // (e.g. a scheduled monitor check) getRequestOrgId() may be unset, in
+  // which case the cascade checks user + solo-workspace scopes only — a
+  // strict superset of the previous user-scope-only behavior.
   // Missing keys throw — the error surfaces in logs and the channel is marked
   // un-delivered, but other channels still run.
-  const { resolved: url } = await resolveKeyReferences(
+  const { resolved: url } = await resolveKeyReferencesWithRequestScopes(
     urlTemplate,
-    "user",
     owner,
   );
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
   if (authTemplate) {
-    const { resolved: auth } = await resolveKeyReferences(
+    const { resolved: auth } = await resolveKeyReferencesWithRequestScopes(
       authTemplate,
-      "user",
       owner,
     );
     headers.Authorization = auth;
@@ -237,6 +246,11 @@ async function resolveWebhookRequest(
 
   // If the user set an allowlist on a referenced key, enforce it here —
   // origin-level check, same rule the automations fetch-tool applies.
+  // NOTE: this still checks the allowlist at user scope only (unlike the
+  // fetch tool's validateUrl, which now consults getResolvedKeyAllowlist at
+  // the scope the key actually resolved at — see agent-chat-plugin.ts). A
+  // key that resolves at org/workspace scope with an allowlist configured
+  // on that org/workspace row will not have it enforced here.
   const keyNames = Array.from(
     new Set(
       Array.from(urlTemplate.matchAll(/\$\{keys\.([A-Za-z0-9_-]+)\}/g), (m) =>

package/corpus/core/src/review/actions/create-review-comment.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import { reviewAuthorNameFromContext } from "../identity.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
 import {
   assertReviewableResourceAccess,
@@ -68,7 +69,7 @@ export default defineAction({
       anchor: args.anchor ?? null,
       body: args.body,
       authorEmail: actionCtx?.userEmail ?? null,
-      authorName: args.authorName ?? actionCtx?.userEmail ?? null,
+      authorName: args.authorName ?? reviewAuthorNameFromContext(actionCtx),
       createdBy: actorKindFromContext(actionCtx),
       resolutionTarget,
       mentions,

package/corpus/core/src/review/actions/get-review-feedback.ts

@@ -37,18 +37,13 @@ export default defineAction({
       bypassScope: true,
       includeResolved: false,
       includeDeleted: false,
+      rootOnly: true,
+      resolutionTargets: args.includeHumanTargeted
+        ? undefined
+        : ["agent", null],
+      unconsumedOnly: true,
       limit: args.limit,
     });
-    return {
-      comments: comments.filter((comment) => {
-        if (comment.consumedAt) {
-          return false;
-        }
-        if (args.includeHumanTargeted) {
-          return true;
-        }
-        return comment.resolutionTarget !== "human";
-      }),
-    };
+    return { comments };
   },
 });

package/corpus/core/src/review/actions/list-review-comments.ts

@@ -1,8 +1,17 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import {
+  redactPublicReviewCommentIdentity,
+  redactPublicReviewStatusIdentity,
+  shouldRedactReviewIdentity,
+} from "../identity.js";
 import { assertReviewableResourceAccess } from "../registry.js";
-import { getReviewStatus, queryReviewComments } from "../store.js";
+import {
+  getReviewStatus,
+  getReviewThreadSummary,
+  queryReviewComments,
+} from "../store.js";
 import type { ReviewResourceContext } from "../types.js";
 
 const schema = z.object({
@@ -19,11 +28,12 @@ export default defineAction({
     "List inline comments, annotations, and review threads for a resource.",
   schema,
   http: { method: "GET" },
+  requiresAuth: false,
   readOnly: true,
   parallelSafe: true,
   run: async (args, ctx) => {
     const actionCtx = ctx as ReviewResourceContext | undefined;
-    await assertReviewableResourceAccess(
+    const access = await assertReviewableResourceAccess(
       args.resourceType,
       args.resourceId,
       actionCtx,
@@ -33,7 +43,7 @@ export default defineAction({
       userEmail: actionCtx?.userEmail ?? null,
       orgId: actionCtx?.orgId ?? null,
     };
-    const [comments, reviewStatus] = await Promise.all([
+    const [comments, reviewStatus, summary] = await Promise.all([
       queryReviewComments({
         resourceType: args.resourceType,
         resourceId: args.resourceId,
@@ -47,7 +57,31 @@ export default defineAction({
       getReviewStatus(args.resourceType, args.resourceId, scope, {
         bypassScope: true,
       }),
+      getReviewThreadSummary({
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+        scope,
+        bypassScope: true,
+        targetId: args.targetId,
+      }),
     ]);
-    return { comments, reviewStatus };
+    const redactIdentity = shouldRedactReviewIdentity(actionCtx, access);
+    const commentsWithCapabilities = comments.map((comment) => ({
+      ...comment,
+      canDelete:
+        access.role !== "viewer" ||
+        Boolean(
+          actionCtx?.userEmail && comment.authorEmail === actionCtx.userEmail,
+        ),
+    }));
+    return redactIdentity
+      ? {
+          comments: commentsWithCapabilities.map(
+            redactPublicReviewCommentIdentity,
+          ),
+          reviewStatus: redactPublicReviewStatusIdentity(reviewStatus),
+          summary,
+        }
+      : { comments: commentsWithCapabilities, reviewStatus, summary };
   },
 });

package/corpus/core/src/review/actions/reply-review-comment.ts

@@ -1,12 +1,13 @@
 import { z } from "zod";
 
 import { defineAction } from "../../action.js";
+import { reviewAuthorNameFromContext } from "../identity.js";
 import { extractReviewMentions, normalizeReviewMentions } from "../mentions.js";
 import {
   assertReviewableResourceAccess,
   normalizeReviewVisibility,
 } from "../registry.js";
-import { getReviewCommentById, insertReviewComment } from "../store.js";
+import { getReviewCommentById, insertReviewReply } from "../store.js";
 import type { ReviewActorKind, ReviewResourceContext } from "../types.js";
 
 const mentionSchema = z.object({
@@ -51,32 +52,42 @@ export default defineAction({
     ) {
       throw new Error("Review comment not found");
     }
+    if (parent.status !== "open") {
+      throw new Error("Review thread is not open");
+    }
     const mentions = normalizeReviewMentions([
       ...normalizeReviewMentions(args.mentions),
       ...extractReviewMentions(args.body),
     ]);
 
-    return insertReviewComment({
-      resourceType: args.resourceType,
-      resourceId: args.resourceId,
-      threadId: parent.threadId,
-      parentCommentId: parent.id,
-      targetId: parent.targetId,
-      kind: parent.kind,
-      anchor: parent.anchor,
-      body: args.body,
-      authorEmail: actionCtx?.userEmail ?? null,
-      authorName: args.authorName ?? actionCtx?.userEmail ?? null,
-      createdBy: actorKindFromContext(actionCtx),
-      resolutionTarget:
-        args.resolutionTarget ??
-        (mentions.length > 0 ? "human" : parent.resolutionTarget),
-      mentions,
-      ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
-      orgId: access.orgId ?? actionCtx?.orgId ?? null,
-      visibility: normalizeReviewVisibility(access.visibility),
-      metadata: args.metadata,
-    });
+    const routeTarget =
+      args.resolutionTarget ?? (mentions.length > 0 ? "human" : null);
+    return insertReviewReply(
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+        threadId: parent.threadId,
+        parentCommentId: parent.id,
+        targetId: parent.targetId,
+        kind: parent.kind,
+        anchor: parent.anchor,
+        body: args.body,
+        authorEmail: actionCtx?.userEmail ?? null,
+        authorName: args.authorName ?? reviewAuthorNameFromContext(actionCtx),
+        createdBy: actorKindFromContext(actionCtx),
+        resolutionTarget: null,
+        mentions,
+        ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
+        orgId: access.orgId ?? actionCtx?.orgId ?? null,
+        visibility: normalizeReviewVisibility(access.visibility),
+        metadata: args.metadata,
+      },
+      routeTarget,
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+      },
+    );
   },
   audit: {
     target: (args, result) => {

package/corpus/core/src/review/actions/resolve-review-thread.ts

@@ -2,7 +2,11 @@ import { z } from "zod";
 
 import { defineAction } from "../../action.js";
 import { assertReviewableResourceAccess } from "../registry.js";
-import { getReviewCommentById, resolveReviewThread } from "../store.js";
+import {
+  getReviewCommentById,
+  getReviewThreadRoot,
+  resolveReviewThread,
+} from "../store.js";
 import type { ReviewResourceContext } from "../types.js";
 
 const schema = z.object({
@@ -10,6 +14,7 @@ const schema = z.object({
   resourceId: z.string().min(1),
   threadId: z.string().optional(),
   commentId: z.string().optional(),
+  resolutionNote: z.string().trim().min(1).max(2_000).optional(),
 });
 
 export default defineAction({
@@ -52,11 +57,33 @@ export default defineAction({
         resourceType: args.resourceType,
         resourceId: args.resourceId,
       },
+      args.resolutionNote,
     );
     if (updatedCount < 1) {
       throw new Error("Review thread not found");
     }
-    return { threadId, resolved: true as const, updatedCount };
+    const comment = await getReviewThreadRoot(
+      threadId,
+      {
+        resourceType: args.resourceType,
+        resourceId: args.resourceId,
+      },
+      {
+        userEmail: actionCtx?.userEmail ?? null,
+        orgId: actionCtx?.orgId ?? null,
+      },
+      { bypassScope: true },
+    );
+    if (!comment) {
+      throw new Error("Resolved review thread could not be verified");
+    }
+    return {
+      threadId,
+      resolved: true as const,
+      updatedCount,
+      resolutionNote: comment.resolutionNote ?? null,
+      comment,
+    };
   },
   audit: {
     target: (args) => ({

package/corpus/core/src/review/actions/send-review-thread-to-agent.ts

@@ -0,0 +1,62 @@
+import { z } from "zod";
+
+import { defineAction } from "../../action.js";
+import { assertReviewableResourceAccess } from "../registry.js";
+import { sendReviewThreadToAgent } from "../store.js";
+import type { ReviewResourceContext } from "../types.js";
+
+const schema = z.object({
+  resourceType: z.string().min(1),
+  resourceId: z.string().min(1),
+  threadId: z.string().min(1),
+});
+
+export default defineAction({
+  description:
+    "Send one open review thread to the agent queue without routing other threads.",
+  schema,
+  run: async (args, ctx) => {
+    const actionCtx = ctx as ReviewResourceContext | undefined;
+    const access = await assertReviewableResourceAccess(
+      args.resourceType,
+      args.resourceId,
+      actionCtx,
+      "editor",
+    );
+    const updatedCount = await sendReviewThreadToAgent(args.threadId, {
+      resourceType: args.resourceType,
+      resourceId: args.resourceId,
+    });
+    if (updatedCount < 1) {
+      throw new Error("Open review thread not found");
+    }
+    return {
+      resourceType: args.resourceType,
+      resourceId: args.resourceId,
+      threadId: args.threadId,
+      resolutionTarget: "agent" as const,
+      consumedAt: null,
+      updatedCount,
+      ownerEmail: access.ownerEmail ?? actionCtx?.userEmail ?? null,
+      orgId: access.orgId ?? actionCtx?.orgId ?? null,
+      visibility: access.visibility ?? "private",
+    };
+  },
+  audit: {
+    target: (args, result) => {
+      const routed = result as {
+        ownerEmail?: string | null;
+        orgId?: string | null;
+        visibility?: "private" | "org" | "public";
+      };
+      return {
+        type: args.resourceType,
+        id: args.resourceId,
+        ownerEmail: routed.ownerEmail,
+        orgId: routed.orgId,
+        visibility: routed.visibility,
+      };
+    },
+    summary: (args) => `Sent review thread ${args.threadId} to the agent`,
+  },
+});