@agent-native/core 0.100.2 → 0.101.2

package/corpus/core/src/review/store.ts

@@ -1,4 +1,4 @@
-import { getDbExec, isPostgres } from "../db/client.js";
+import { getDbExec, isPostgres, type DbExec } from "../db/client.js";
 import { ensureIndexExists, ensureTableExists } from "../db/ddl-guard.js";
 import type { Visibility } from "../sharing/schema.js";
 import type {
@@ -43,9 +43,25 @@ export interface QueryReviewCommentsInput {
   includeResolved?: boolean;
   includeDeleted?: boolean;
   targetId?: string | null;
+  rootOnly?: boolean;
+  resolutionTargets?: readonly (ReviewResolutionTarget | null)[];
+  unconsumedOnly?: boolean;
   limit?: number;
 }
 
+export interface GetReviewThreadSummaryInput {
+  resourceType: string;
+  resourceId: string;
+  scope: ReviewScope;
+  bypassScope?: boolean;
+  targetId?: string | null;
+}
+
+export interface ReviewThreadSummary {
+  openCount: number;
+  agentQueueCount: number;
+}
+
 export interface UpsertReviewStatusInput {
   resourceType: string;
   resourceId: string;
@@ -112,6 +128,15 @@ export async function ensureReviewTables(): Promise<void> {
            ON agent_review_comments (owner_email, created_at)`,
         `CREATE INDEX IF NOT EXISTS idx_agent_review_comments_org
            ON agent_review_comments (org_id, created_at)`,
+        `CREATE INDEX IF NOT EXISTS idx_agent_review_comments_queue
+           ON agent_review_comments (
+             resource_type,
+             resource_id,
+             parent_comment_id,
+             resolution_target,
+             consumed_at,
+             created_at
+           )`,
         `CREATE INDEX IF NOT EXISTS idx_agent_review_statuses_resource
            ON agent_review_statuses (resource_type, resource_id)`,
       ];
@@ -126,9 +151,10 @@ export async function ensureReviewTables(): Promise<void> {
         await ensureIndexExists("idx_agent_review_comments_thread", indexes[1]);
         await ensureIndexExists("idx_agent_review_comments_owner", indexes[2]);
         await ensureIndexExists("idx_agent_review_comments_org", indexes[3]);
+        await ensureIndexExists("idx_agent_review_comments_queue", indexes[4]);
         await ensureIndexExists(
           "idx_agent_review_statuses_resource",
-          indexes[4],
+          indexes[5],
         );
       } else {
         await client.execute(createCommentsSql);
@@ -145,9 +171,62 @@ export async function ensureReviewTables(): Promise<void> {
 
 export async function insertReviewComment(
   input: InsertReviewCommentInput,
+): Promise<ReviewComment> {
+  await ensureReviewTables();
+  return insertReviewCommentWithClient(input, getDbExec());
+}
+
+export async function insertReviewReply(
+  input: InsertReviewCommentInput & {
+    threadId: string;
+    parentCommentId: string;
+  },
+  routeTarget: ReviewResolutionTarget | null,
+  resource: { resourceType: string; resourceId: string },
 ): Promise<ReviewComment> {
   await ensureReviewTables();
   const client = getDbExec();
+  const insertAndRoute = async (tx: DbExec) => {
+    if (routeTarget) {
+      const routedCount = await routeReviewThreadWithClient(
+        tx,
+        input.threadId,
+        routeTarget,
+        resource,
+      );
+      if (routedCount < 1) {
+        throw new Error("Open review thread not found");
+      }
+    }
+    return insertReviewCommentWithClient(input, tx);
+  };
+  if (client.transaction) return client.transaction(insertAndRoute);
+
+  const reply = await insertReviewCommentWithClient(input, client);
+  if (!routeTarget) return reply;
+  try {
+    const routedCount = await routeReviewThreadWithClient(
+      client,
+      input.threadId,
+      routeTarget,
+      resource,
+    );
+    if (routedCount < 1) throw new Error("Open review thread not found");
+    return reply;
+  } catch (error) {
+    await client.execute({
+      sql: `DELETE FROM agent_review_comments
+             WHERE id = ? AND resource_type = ? AND resource_id = ?`,
+      args: [reply.id, resource.resourceType, resource.resourceId],
+    });
+    throw error;
+  }
+}
+
+async function insertReviewCommentWithClient(
+  input: InsertReviewCommentInput,
+  client: DbExec,
+): Promise<ReviewComment> {
   const id = createReviewId("comment");
   const now = new Date().toISOString();
   const comment: ReviewComment = {
@@ -180,6 +259,10 @@ export async function insertReviewComment(
     createdAt: now,
     updatedAt: now,
     metadata: input.metadata ?? null,
+    resolutionNote:
+      typeof input.metadata?.resolutionNote === "string"
+        ? input.metadata.resolutionNote
+        : null,
   };
 
   await client.execute({
@@ -273,18 +356,107 @@ export async function queryReviewComments(
       filterParams.push(input.targetId);
     }
   }
+  if (input.rootOnly) {
+    filters.push("parent_comment_id IS NULL");
+  }
+  if (input.unconsumedOnly) {
+    filters.push("consumed_at IS NULL");
+  }
+  if (input.resolutionTargets !== undefined) {
+    const targets = Array.from(
+      new Set(
+        input.resolutionTargets.filter(
+          (target): target is ReviewResolutionTarget => target !== null,
+        ),
+      ),
+    );
+    const resolutionFilters: string[] = [];
+    if (targets.length > 0) {
+      resolutionFilters.push(
+        `resolution_target IN (${targets.map(() => "?").join(", ")})`,
+      );
+      filterParams.push(...targets);
+    }
+    if (input.resolutionTargets.includes(null)) {
+      resolutionFilters.push("resolution_target IS NULL");
+    }
+    filters.push(
+      resolutionFilters.length > 0
+        ? `(${resolutionFilters.join(" OR ")})`
+        : "1 = 0",
+    );
+  }
 
+  const selectSql = input.rootOnly
+    ? `SELECT ${commentColumns()}
+         FROM (
+           SELECT ${commentColumns()},
+                  ROW_NUMBER() OVER (
+                    PARTITION BY thread_id
+                    ORDER BY created_at ASC, id ASC
+                  ) AS review_thread_rank
+             FROM agent_review_comments
+            WHERE ${filters.join(" AND ")}
+         ) AS distinct_review_threads
+        WHERE review_thread_rank = 1`
+    : `SELECT ${commentColumns()}
+         FROM agent_review_comments
+        WHERE ${filters.join(" AND ")}`;
   const result = await client.execute({
-    sql: `SELECT ${commentColumns()}
-       FROM agent_review_comments
-      WHERE ${filters.join(" AND ")}
-      ORDER BY created_at ASC
+    sql: `${selectSql}
+      ORDER BY created_at ASC${input.rootOnly ? ", id ASC" : ""}
       LIMIT ?`,
     args: [...filterParams, clampLimit(input.limit)],
   });
   return (result.rows ?? []).map(mapCommentRow);
 }
 
+export async function getReviewThreadSummary(
+  input: GetReviewThreadSummaryInput,
+): Promise<ReviewThreadSummary> {
+  await ensureReviewTables();
+  const { clause, params } = input.bypassScope
+    ? { clause: "1 = 1", params: [] as unknown[] }
+    : scopedReviewClause(input.scope);
+  const filters = [
+    "resource_type = ?",
+    "resource_id = ?",
+    clause,
+    "parent_comment_id IS NULL",
+    "deleted_at IS NULL",
+    "status = 'open'",
+  ];
+  const filterParams: unknown[] = [
+    input.resourceType,
+    input.resourceId,
+    ...params,
+  ];
+  if (input.targetId !== undefined) {
+    if (input.targetId === null) {
+      filters.push("target_id IS NULL");
+    } else {
+      filters.push("target_id = ?");
+      filterParams.push(input.targetId);
+    }
+  }
+  const result = await getDbExec().execute({
+    sql: `SELECT COUNT(DISTINCT thread_id) AS open_count,
+                 COUNT(DISTINCT CASE
+                   WHEN (resolution_target IS NULL OR resolution_target <> 'human')
+                    AND consumed_at IS NULL
+                   THEN thread_id
+                 END) AS agent_queue_count
+            FROM agent_review_comments
+           WHERE ${filters.join(" AND ")}`,
+    args: filterParams,
+  });
+  const row = result.rows?.[0];
+  return {
+    openCount: Number(row?.open_count ?? 0),
+    agentQueueCount: Number(row?.agent_queue_count ?? 0),
+  };
+}
+
 export async function getReviewCommentById(
   id: string,
   scope: ReviewScope,
@@ -306,27 +478,106 @@ export async function getReviewCommentById(
   return row ? mapCommentRow(row) : null;
 }
 
+export async function getReviewThreadRoot(
+  threadId: string,
+  resource: { resourceType: string; resourceId: string },
+  scope: ReviewScope,
+  options: { bypassScope?: boolean } = {},
+): Promise<ReviewComment | null> {
+  await ensureReviewTables();
+  const { clause, params } = options.bypassScope
+    ? { clause: "1 = 1", params: [] as unknown[] }
+    : scopedReviewClause(scope);
+  const result = await getDbExec().execute({
+    sql: `SELECT ${commentColumns()}
+       FROM agent_review_comments
+      WHERE thread_id = ?
+        AND resource_type = ?
+        AND resource_id = ?
+        AND parent_comment_id IS NULL
+        AND ${clause}
+      ORDER BY created_at ASC, id ASC
+      LIMIT 1`,
+    args: [threadId, resource.resourceType, resource.resourceId, ...params],
+  });
+  const row = result.rows?.[0];
+  return row ? mapCommentRow(row) : null;
+}
+
 export async function resolveReviewThread(
   threadId: string,
   resolvedBy?: string | null,
   resource?: { resourceType: string; resourceId: string },
+  resolutionNote?: string,
 ): Promise<number> {
   await ensureReviewTables();
+  const client = getDbExec();
+  const resolve = (tx: DbExec) =>
+    resolveReviewThreadWithClient(
+      tx,
+      threadId,
+      resolvedBy,
+      resource,
+      resolutionNote,
+    );
+  return client.transaction ? client.transaction(resolve) : resolve(client);
+}
+
+async function resolveReviewThreadWithClient(
+  client: DbExec,
+  threadId: string,
+  resolvedBy?: string | null,
+  resource?: { resourceType: string; resourceId: string },
+  resolutionNote?: string,
+): Promise<number> {
   const now = new Date().toISOString();
   const resourceClause = resource
     ? "AND resource_type = ? AND resource_id = ?"
     : "";
-  const result = await getDbExec().execute({
+  let rootMetadata: Record<string, unknown> | null = null;
+  if (resolutionNote !== undefined) {
+    const root = await client.execute({
+      sql: `SELECT metadata_json
+         FROM agent_review_comments
+        WHERE thread_id = ?
+          AND parent_comment_id IS NULL
+          AND deleted_at IS NULL
+          ${resourceClause}
+        ORDER BY created_at ASC, id ASC
+        LIMIT 1`,
+      args: [
+        threadId,
+        ...(resource ? [resource.resourceType, resource.resourceId] : []),
+      ],
+    });
+    if (!root.rows?.[0]) {
+      return 0;
+    }
+    rootMetadata = {
+      ...(parseObject(root.rows[0].metadata_json) ?? {}),
+      resolutionNote,
+    };
+  }
+
+  const metadataAssignment =
+    resolutionNote === undefined
+      ? ""
+      : ", metadata_json = CASE WHEN parent_comment_id IS NULL THEN ? ELSE metadata_json END";
+  const result = await client.execute({
     sql: `UPDATE agent_review_comments
         SET status = 'resolved',
             resolved_by = ?,
             resolved_at = ?,
             updated_at = ?
+            ${metadataAssignment}
       WHERE thread_id = ? AND deleted_at IS NULL ${resourceClause}`,
     args: [
       resolvedBy ?? null,
       now,
       now,
+      ...(resolutionNote === undefined
+        ? []
+        : [stringifyOptionalJson(rootMetadata)]),
       threadId,
       ...(resource ? [resource.resourceType, resource.resourceId] : []),
     ],
@@ -334,6 +585,57 @@ export async function resolveReviewThread(
   return result.rowsAffected ?? 0;
 }
 
+export async function routeReviewThread(
+  threadId: string,
+  resolutionTarget: ReviewResolutionTarget,
+  resource: { resourceType: string; resourceId: string },
+): Promise<number> {
+  await ensureReviewTables();
+  return routeReviewThreadWithClient(
+    getDbExec(),
+    threadId,
+    resolutionTarget,
+    resource,
+  );
+}
+
+async function routeReviewThreadWithClient(
+  client: DbExec,
+  threadId: string,
+  resolutionTarget: ReviewResolutionTarget,
+  resource: { resourceType: string; resourceId: string },
+): Promise<number> {
+  const now = new Date().toISOString();
+  const result = await client.execute({
+    sql: `UPDATE agent_review_comments
+        SET resolution_target = ?,
+            consumed_at = CASE WHEN ? = 'agent' THEN NULL ELSE consumed_at END,
+            updated_at = ?
+      WHERE thread_id = ?
+        AND resource_type = ?
+        AND resource_id = ?
+        AND parent_comment_id IS NULL
+        AND status = 'open'
+        AND deleted_at IS NULL`,
+    args: [
+      resolutionTarget,
+      resolutionTarget,
+      now,
+      threadId,
+      resource.resourceType,
+      resource.resourceId,
+    ],
+  });
+  return result.rowsAffected ?? 0;
+}
+
+export async function sendReviewThreadToAgent(
+  threadId: string,
+  resource: { resourceType: string; resourceId: string },
+): Promise<number> {
+  return routeReviewThread(threadId, "agent", resource);
+}
+
 export async function deleteReviewComment(
   id: string,
   deletedBy?: string | null,
@@ -560,6 +862,7 @@ function scopedReviewClause(scope: ReviewScope): {
 }
 
 function mapCommentRow(row: Record<string, unknown>): ReviewComment {
+  const metadata = parseObject(row.metadata_json);
   return {
     id: String(row.id),
     resourceType: String(row.resource_type),
@@ -586,7 +889,11 @@ function mapCommentRow(row: Record<string, unknown>): ReviewComment {
     deletedAt: nullableString(row.deleted_at),
     createdAt: String(row.created_at),
     updatedAt: String(row.updated_at),
-    metadata: parseObject(row.metadata_json),
+    metadata,
+    resolutionNote:
+      typeof metadata?.resolutionNote === "string"
+        ? metadata.resolutionNote
+        : null,
   };
 }
 

package/corpus/core/src/review/types.ts

@@ -75,6 +75,10 @@ export interface ReviewComment {
   createdAt: string;
   updatedAt: string;
   metadata: Record<string, unknown> | null;
+  /** Persisted on the root comment's metadata when a thread is resolved. */
+  resolutionNote?: string | null;
+  /** Caller-specific capability computed by list-review-comments. */
+  canDelete?: boolean;
 }
 
 export interface ReviewStatusEntry {

package/corpus/core/src/server/action-discovery.ts

@@ -686,6 +686,10 @@ export async function mergeCoreSharingActions(
       "set-review-status",
       () => import("../review/actions/set-review-status.js"),
     ],
+    [
+      "send-review-thread-to-agent",
+      () => import("../review/actions/send-review-thread-to-agent.js"),
+    ],
     // Org service tokens (CI credentials, e.g. PLAN_RECAP_TOKEN). Mint/revoke
     // are toolCallable:false — preserved via preserveActionFlags below.
     [

package/corpus/core/src/server/action-routes.ts

@@ -1,4 +1,5 @@
 import {
+  createError,
   defineEventHandler,
   setResponseStatus,
   setResponseHeader,
@@ -10,6 +11,7 @@ import {
 
 import { isAgentActionStopError } from "../action.js";
 import type { ActionEntry } from "../agent/production-agent.js";
+import { resolveOrgIdForEmail } from "../org/context.js";
 import { readBody } from "../server/h3-helpers.js";
 import { EMBED_TARGET_HEADER } from "../shared/embed-auth.js";
 import {
@@ -18,6 +20,10 @@ import {
   shouldAllowMcpEmbedCredentials,
 } from "../shared/mcp-embed-headers.js";
 import { notifyActionChange } from "./action-change.js";
+import {
+  seedAgentRunOwnerContext,
+  type AgentRunOwnerContext,
+} from "./agent-run-context.js";
 import {
   getAllowedCorsOrigin as resolveAllowedCorsOrigin,
   readCorsAllowedOrigins,
@@ -164,6 +170,51 @@ function handleOptionsRequest(event: any): string {
   return "";
 }
 
+/**
+ * Declarative auth adapter for the HTTP action route. Its `resolveCaller` runs
+ * BEFORE the framework's `getOwnerFromEvent` / `getSession` chain, letting an
+ * app accept caller identities `getSession` doesn't understand (e.g. an A2A
+ * JWT) without reaching into request context from a Nitro `request` hook.
+ *
+ * Scoped to `/_agent-native/actions/*` only — it does not affect other routes.
+ */
+export type ActionRouteResolvedCaller = AgentRunOwnerContext & {
+  /**
+   * Org to scope the request to, verified from the same credential as the
+   * caller identity (e.g. the A2A token's org claim). When omitted, the org
+   * is derived from the verified owner email via the framework's owner→org
+   * membership lookup. The ambient session/org state on the request is never
+   * consulted for adapter-resolved callers: a request can carry both a valid
+   * A2A bearer and an unrelated browser cookie, and the cookie user's org
+   * must not leak into the token caller's request context.
+   */
+  orgId?: string;
+};
+
+export interface ActionRouteAuthAdapter {
+  /**
+   * Resolve a caller from the raw event before the cookie/bearer chain.
+   *
+   * - Return the resolved caller to run the action scoped to that identity.
+   *   Org scoping comes exclusively from the caller: the returned `orgId` if
+   *   set, otherwise the owner-email membership lookup — never from the
+   *   request's session cookie or org context.
+   * - Return `null` when the credential isn't yours to judge — the request
+   *   defers to `getOwnerFromEvent` / `getSession`.
+   * - THROW to hard-reject: the credential is present but invalid (e.g. an
+   *   expired or forged A2A bearer). The action route responds 401 and does
+   *   NOT fall through to the cookie/session chain, so a valid same-origin
+   *   session cookie can't be used to execute the request as the logged-in
+   *   user. Do not throw merely to signal "not mine" — return `null` for that.
+   */
+  resolveCaller?: (
+    event: any,
+  ) =>
+    | ActionRouteResolvedCaller
+    | null
+    | Promise<ActionRouteResolvedCaller | null>;
+}
+
 export interface MountActionRoutesOptions {
   /** Resolve owner email from the H3 event (for data scoping). */
   getOwnerFromEvent?: (event: any) => string | Promise<string>;
@@ -173,6 +224,18 @@ export interface MountActionRoutesOptions {
   ) => string | undefined | Promise<string | undefined>;
   /** Resolve org ID from the H3 event (for org scoping). */
   resolveOrgId?: (event: any) => string | null | Promise<string | null>;
+  /**
+   * Optional caller resolver that runs before the `getOwnerFromEvent` /
+   * `getSession` chain. Lets apps accept A2A JWTs (or other bearer schemes) on
+   * the action route declaratively. See {@link ActionRouteAuthAdapter}.
+   */
+  actionRouteAuth?: ActionRouteAuthAdapter;
+}
+
+function normalizeOrgId(value: string | null | undefined): string | undefined {
+  return typeof value === "string" && value.trim().length > 0
+    ? value.trim()
+    : undefined;
 }
 
 function isAuthResolutionFailure(error: unknown): boolean {
@@ -259,7 +322,42 @@ export function mountActionRoutes(
         // Resolve auth context for per-request scoping
         let userEmail: string | undefined;
         let userName: string | undefined;
-        if (options?.getOwnerFromEvent) {
+        // An app-supplied auth adapter runs first: it can accept caller
+        // identities the framework's getSession chain doesn't understand (e.g.
+        // an A2A JWT). A resolved caller is seeded onto the event context so any
+        // downstream resolveAgentRunOwnerContext (nested agent runs) sees the
+        // same identity. The adapter is only consulted for the action route, so
+        // it can't affect other surfaces.
+        //
+        // Contract: `resolveCaller` returning `null` means "this credential
+        // isn't mine — defer to the cookie/session chain below". THROWING means
+        // "the credential is mine but invalid" (e.g. an expired/forged A2A
+        // bearer) and is a hard rejection: we surface a 401 instead of falling
+        // through, so a live same-origin session cookie can't silently execute
+        // the request as the logged-in user.
+        let resolvedCaller: ActionRouteResolvedCaller | null = null;
+        if (options?.actionRouteAuth?.resolveCaller) {
+          let caller: ActionRouteResolvedCaller | null;
+          try {
+            caller = await options.actionRouteAuth.resolveCaller(event);
+          } catch {
+            throw createError({
+              statusCode: 401,
+              statusMessage: "Unauthorized",
+            });
+          }
+          if (caller) {
+            seedAgentRunOwnerContext(event, {
+              owner: caller.owner,
+              anonymous: caller.anonymous,
+              name: caller.name,
+            });
+            userEmail = caller.owner;
+            userName = caller.name;
+            resolvedCaller = caller;
+          }
+        }
+        if (!resolvedCaller && options?.getOwnerFromEvent) {
           try {
             userEmail = await options.getOwnerFromEvent(event);
             userName = options?.getUserNameFromEvent
@@ -277,9 +375,32 @@ export function mountActionRoutes(
             }
           }
         }
-        const orgId = options?.resolveOrgId
-          ? ((await options.resolveOrgId(event)) ?? undefined)
-          : undefined;
+        // Org scoping. For adapter-resolved callers the org must come
+        // exclusively from the verified credential: the adapter-asserted
+        // orgId when present, otherwise the owner-email membership lookup.
+        // The request's ambient session/org state (`resolveOrgId`, usually
+        // getSession-backed) is deliberately NOT consulted — a request can
+        // carry both a valid A2A bearer and an unrelated same-origin browser
+        // cookie, and the cookie user's org must not become the org the
+        // token caller's actions execute under. Non-adapter callers keep the
+        // original resolveOrgId-only behavior.
+        let orgId: string | undefined;
+        if (resolvedCaller) {
+          orgId = normalizeOrgId(resolvedCaller.orgId);
+          if (!orgId && resolvedCaller.owner && !resolvedCaller.anonymous) {
+            try {
+              orgId = normalizeOrgId(
+                await resolveOrgIdForEmail(resolvedCaller.owner),
+              );
+            } catch {
+              // Org tables may not exist yet on first boot.
+            }
+          }
+        } else {
+          orgId = options?.resolveOrgId
+            ? ((await options.resolveOrgId(event)) ?? undefined)
+            : undefined;
+        }
         const timezone = readTimezoneHeader(event);
 
         return runWithRequestContext(

package/corpus/core/src/server/agent-chat/plugin-options.ts

@@ -109,6 +109,22 @@ export interface AgentChatPluginOptions {
    * agent mutations.
    */
   anonymousReadOnly?: boolean;
+  /**
+   * Optional auth adapter for the HTTP action route
+   * (`/_agent-native/actions/*`). Its `resolveCaller` runs before the
+   * cookie/bearer `getSession` chain, letting an app accept caller identities
+   * `getSession` doesn't understand (e.g. an A2A JWT verified with
+   * `verifyA2AToken`) declaratively, instead of pre-seeding request context
+   * from a Nitro `request` hook.
+   *
+   * Returning `null` defers to the normal chain; THROWING hard-rejects with a
+   * 401 (an invalid/forged credential must not fall through to a same-origin
+   * session cookie). A resolved caller's org comes exclusively from the
+   * verified credential — the returned `orgId` or the owner-email membership
+   * lookup — never from the request's session cookie.
+   * See {@link import("../action-routes.js").ActionRouteAuthAdapter}.
+   */
+  actionRouteAuth?: import("../action-routes.js").ActionRouteAuthAdapter;
   /**
    * Optional callback to append template-specific context to the system
    * prompt on each request. Runs after AGENTS.md / skills / memory are

package/corpus/core/src/server/agent-chat-plugin.ts

@@ -1804,6 +1804,7 @@ export function createAgentChatPlugin(
           getOwnerFromEvent,
           getUserNameFromEvent,
           resolveOrgId: options?.resolveOrgId,
+          actionRouteAuth: options?.actionRouteAuth,
         });
       }
 

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

@@ -241,6 +241,7 @@ export {
   renderAgentNativeOgImageSvg,
   type AgentNativeOgImageInput,
 } from "./social-og-image.js";
+export { resolveOgFontFiles } from "./og-fonts.js";
 export {
   createBrowserSessionActionEntries,
   type CreateBrowserSessionActionEntriesOptions,
@@ -320,7 +321,14 @@ export {
 export {
   mountActionRoutes,
   type MountActionRoutesOptions,
+  type ActionRouteAuthAdapter,
+  type ActionRouteResolvedCaller,
 } from "./action-routes.js";
+export {
+  AGENT_RUN_OWNER_CONTEXT_KEY,
+  seedAgentRunOwnerContext,
+  type AgentRunOwnerContext,
+} from "./agent-run-context.js";
 export {
   runWithRequestContext,
   hasRequestContext,

package/corpus/core/src/vite/action-types-plugin.ts

@@ -141,6 +141,10 @@ const CORE_SHARING_ACTIONS: Array<{ name: string; specifier: string }> = [
     name: "set-review-status",
     specifier: "@agent-native/core/review/actions/set-review-status",
   },
+  {
+    name: "send-review-thread-to-agent",
+    specifier: "@agent-native/core/review/actions/send-review-thread-to-agent",
+  },
 ];
 
 function isRuntimeSourceFile(filename: string): boolean {