@agent-native/core 0.100.2 → 0.101.3

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

@@ -0,0 +1,101 @@
+import type {
+  ReviewComment,
+  ReviewResourceAccess,
+  ReviewResourceContext,
+  ReviewStatusEntry,
+} from "./types.js";
+
+export function reviewAuthorNameFromContext(
+  ctx: ReviewResourceContext | undefined,
+): string | null {
+  const value = ctx?.userName;
+  if (typeof value !== "string") return null;
+  const name = value.trim();
+  if (!name || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(name)) return null;
+  return name;
+}
+
+export function shouldRedactReviewIdentity(
+  ctx: ReviewResourceContext | undefined,
+  access: Pick<ReviewResourceAccess, "role" | "visibility">,
+): boolean {
+  return (
+    !ctx?.userEmail ||
+    (access.visibility === "public" && access.role === "viewer")
+  );
+}
+
+export function redactPublicReviewCommentIdentity(
+  comment: ReviewComment,
+): ReviewComment {
+  return {
+    ...comment,
+    authorEmail: null,
+    authorName: safeReviewDisplayName(comment.authorName),
+    mentions: comment.mentions.map((mention) => ({
+      label: safeReviewDisplayName(mention.label) ?? "Mentioned user",
+    })),
+    ownerEmail: null,
+    orgId: null,
+    resolvedBy: null,
+    deletedBy: null,
+    metadata: redactPublicReviewMetadata(comment.metadata),
+  };
+}
+
+export function redactPublicReviewStatusIdentity(
+  status: ReviewStatusEntry | null,
+): ReviewStatusEntry | null {
+  return status
+    ? {
+        ...status,
+        updatedBy: null,
+        ownerEmail: null,
+        orgId: null,
+        metadata: redactPublicReviewMetadata(status.metadata),
+      }
+    : null;
+}
+
+function safeReviewDisplayName(
+  value: string | null | undefined,
+): string | null {
+  const name = value?.trim();
+  if (!name || /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(name)) {
+    return null;
+  }
+  return name;
+}
+
+function redactPublicReviewMetadata(
+  metadata: Record<string, unknown> | null,
+): Record<string, unknown> | null {
+  if (!metadata) {
+    return null;
+  }
+  return Object.fromEntries(
+    Object.entries(metadata).flatMap(([key, value]) =>
+      /^(authorEmail|ownerEmail|orgId|updatedBy|resolvedBy|deletedBy|email|userEmail|userId)$/i.test(
+        key,
+      )
+        ? []
+        : [[key, redactPublicReviewMetadataValue(value)]],
+    ),
+  );
+}
+
+function redactPublicReviewMetadataValue(value: unknown): unknown {
+  if (Array.isArray(value)) {
+    return value.map(redactPublicReviewMetadataValue);
+  }
+  if (typeof value === "object" && value !== null) {
+    return redactPublicReviewMetadata(value as Record<string, unknown>);
+  }
+  if (
+    typeof value === "string" &&
+    /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value.trim())
+  ) {
+    return null;
+  }
+  return value;
+}

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

@@ -13,6 +13,12 @@ export type {
   ReviewStatusEntry,
   ReviewableResourceRegistration,
 } from "./types.js";
+export {
+  redactPublicReviewCommentIdentity,
+  redactPublicReviewStatusIdentity,
+  reviewAuthorNameFromContext,
+  shouldRedactReviewIdentity,
+} from "./identity.js";
 export { extractReviewMentions, normalizeReviewMentions } from "./mentions.js";
 export {
   __resetReviewableResourcesForTests,
@@ -27,5 +33,13 @@ export {
   ensureReviewTables,
   getReviewCommentById,
   getReviewStatus,
+  getReviewThreadSummary,
+  getReviewThreadRoot,
   queryReviewComments,
+  routeReviewThread,
+  sendReviewThreadToAgent,
+} from "./store.js";
+export type {
+  GetReviewThreadSummaryInput,
+  ReviewThreadSummary,
 } from "./store.js";

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/secrets/crypto.ts

@@ -14,15 +14,22 @@
  * `<APP_NAME>_SECRETS_ENCRYPTION_KEY` when set, then `SECRETS_ENCRYPTION_KEY`,
  * then `BETTER_AUTH_SECRET`. The app-scoped key lets a local multi-app
  * workspace read one app's encrypted production data without replacing the
- * shared local auth secret. In production we refuse to start without
- * configured key material — a CWD-derived fallback would be effectively
- * static (e.g. `/var/task` on Lambda), so anyone with read access to the DB
- * could decrypt every secret.
+ * shared local auth secret. Hosted workspace deploys (`AGENT_NATIVE_WORKSPACE`)
+ * typically set none of those literal env vars per app; in that case the
+ * shared-key variant falls back further to material derived from the
+ * workspace-wide `A2A_SECRET` (see `getWorkspaceA2ADerivedSecret`), so sibling
+ * apps in the same workspace still land on the same shared key without any
+ * extra configuration. In production we refuse to start without configured
+ * key material — a CWD-derived fallback would be effectively static (e.g.
+ * `/var/task` on Lambda), so anyone with read access to the DB could decrypt
+ * every secret.
  *
  * Encrypted values are tagged `v1:<iv-hex>:<ct-hex>:<tag-hex>`. The `v1:` prefix
  * lets readers distinguish ciphertext from legacy plaintext during migration.
  */
 
+import { getWorkspaceA2ADerivedSecret } from "../server/derived-secret.js";
+
 type NodeCryptoModule = typeof import("node:crypto");
 
 function getNodeCrypto(): NodeCryptoModule | undefined {
@@ -75,7 +82,11 @@ function appScopedEncryptionKey(): string | undefined {
 
 function sharedEncryptionKeyMaterial(): string | undefined {
   if (typeof process === "undefined") return undefined;
-  return process.env.SECRETS_ENCRYPTION_KEY || process.env.BETTER_AUTH_SECRET;
+  return (
+    process.env.SECRETS_ENCRYPTION_KEY ||
+    process.env.BETTER_AUTH_SECRET ||
+    getWorkspaceA2ADerivedSecret("secrets-encryption")
+  );
 }
 
 function deriveSecretEncryptionKey(
@@ -129,17 +140,22 @@ export function getSecretEncryptionKey(): Buffer {
  * Derive the preferred workspace-shared key used by `app_secrets` rows.
  * Unlike generic column-level encryption, workspace vault data should decrypt
  * in sibling apps, so `SECRETS_ENCRYPTION_KEY` / `BETTER_AUTH_SECRET` take
- * precedence. The app-scoped key remains a compatibility fallback for
- * deployments that have not configured shared material yet; once the shared
- * key is configured, writes use it and reads still fall back to old rows.
+ * precedence. Hosted workspace deploys (`AGENT_NATIVE_WORKSPACE`) that set
+ * neither literal var still get stable shared material derived from the
+ * workspace-wide `A2A_SECRET` before falling further back. The app-scoped key
+ * remains a compatibility fallback for deployments that have not configured
+ * shared material yet; once the shared key is configured, writes use it and
+ * reads still fall back to old rows.
  */
 export function getSharedSecretEncryptionKey(): Buffer {
   return deriveSecretEncryptionKey(
     sharedEncryptionKeyMaterial() || appScopedEncryptionKey(),
     "[agent-native/secrets] Refusing to start in production without encryption key material for workspace secrets. " +
-      "Set SECRETS_ENCRYPTION_KEY, BETTER_AUTH_SECRET, or the app-scoped *_SECRETS_ENCRYPTION_KEY in the deploy environment.",
+      "Set SECRETS_ENCRYPTION_KEY, BETTER_AUTH_SECRET, or the app-scoped *_SECRETS_ENCRYPTION_KEY in the deploy environment " +
+      "— or, on a hosted workspace deploy, ensure A2A_SECRET is set so shared material can be derived from it.",
     "[agent-native/secrets] SECRETS_ENCRYPTION_KEY not set — using app-scoped or machine-local fallback for workspace secrets. " +
-      "Set SECRETS_ENCRYPTION_KEY or BETTER_AUTH_SECRET in every workspace app so sibling apps share vault rows.",
+      "Set SECRETS_ENCRYPTION_KEY or BETTER_AUTH_SECRET in every workspace app so sibling apps share vault rows, " +
+      "or rely on A2A_SECRET-derived material on hosted workspace deploys.",
   );
 }
 

package/corpus/core/src/secrets/storage.ts

@@ -163,8 +163,9 @@ export async function writeAppSecret(args: WriteSecretArgs): Promise<string> {
   const now = Date.now();
   // Dual-write during rollout: old readers continue using encrypted_value,
   // while new readers prefer the nullable shared ciphertext. An app-only
-  // deployment leaves the shared column null; on an update, an existing
-  // shared ciphertext is preserved by the upsert below.
+  // deployment leaves the shared column null; on an update, a writer without
+  // shared key material clears any existing shared ciphertext rather than
+  // preserving it (see the upsert SQL below for why).
   const encrypted = encryptLegacyValue(value);
   const sharedEncrypted = hasSharedSecretEncryptionKeyMaterial()
     ? encryptValue(value)
@@ -182,11 +183,23 @@ export async function writeAppSecret(args: WriteSecretArgs): Promise<string> {
   // keeps its original id (any stored references stay stable); only a
   // genuinely new row gets the freshly generated `id`. This syntax is
   // portable across SQLite (UPSERT since 3.24) and Postgres.
+  //
+  // shared_encrypted_value is overwritten with `excluded.shared_encrypted_value`
+  // (NULL when this writer lacks shared key material) rather than preserved
+  // via COALESCE. Preserving an existing shared ciphertext across a value
+  // update would let a sibling app silently decrypt a STALE value after the
+  // owner rotates it — a material-less writer has no way to produce the new
+  // shared ciphertext, so it must clear the old one instead of leaving it
+  // pointing at data that's no longer current. Siblings then get an honest
+  // cache miss (falling back to the legacy column or reporting missing) until
+  // the owning app's next read repopulates shared_encrypted_value via
+  // `populateSharedAppSecret`, which only ever fills a NULL column. A
+  // temporary miss is safer than serving rotated-away plaintext.
   const upsertSql = `INSERT INTO app_secrets (id, scope, scope_id, key, encrypted_value, shared_encrypted_value, description, url_allowlist, created_at, updated_at)
     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     ON CONFLICT (scope, scope_id, key) DO UPDATE SET
       encrypted_value = excluded.encrypted_value,
-      shared_encrypted_value = COALESCE(excluded.shared_encrypted_value, app_secrets.shared_encrypted_value),
+      shared_encrypted_value = excluded.shared_encrypted_value,
       description = excluded.description,
       url_allowlist = excluded.url_allowlist,
       updated_at = excluded.updated_at`;

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.
     [