@k2b/cloud 0.6.0 → 0.8.0

package/src/services/logging/index.ts

@@ -4,6 +4,7 @@ import { escapeLikePattern, parsePgJsonRecord, toPgTextArray } from "../postgres
 import { registerSettings } from "../settings/defaults";
 import { redactMetadata } from "./redaction";
 import { observeSyncEvent, TRACE_STUCK_AFTER_MS, trace } from "./trace";
+import { readWebVitals } from "./web-vitals";
 
 export type {
   TraceAttributes,
@@ -129,7 +130,7 @@ function write(params: WriteParams): void {
       ${params.level},
       ${params.source},
       ${params.message},
-      ${safeMetadata ? JSON.stringify(safeMetadata) : null}::jsonb
+      (${safeMetadata ? JSON.stringify(safeMetadata) : null}::text)::jsonb
     )
   `.catch((err: Error) => console.error("[logging] DB write failed:", err.message));
 }
@@ -194,7 +195,7 @@ const list = async (
       WHERE source = ${filterSource}
         AND (${filterLevel}::text IS NULL OR level = ${filterLevel})
         AND (${filterSinceHours}::int IS NULL OR created_at >= now() - (${filterSinceHours}::int * INTERVAL '1 hour'))
-        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\')
+        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\\')
     `;
 
     dataRows = await sql`
@@ -203,7 +204,7 @@ const list = async (
       WHERE source = ${filterSource}
         AND (${filterLevel}::text IS NULL OR level = ${filterLevel})
         AND (${filterSinceHours}::int IS NULL OR created_at >= now() - (${filterSinceHours}::int * INTERVAL '1 hour'))
-        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\')
+        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\\')
       ORDER BY created_at DESC
       LIMIT ${perPage} OFFSET ${offset}
     `;
@@ -214,7 +215,7 @@ const list = async (
       WHERE source = ANY(${filterSourcesLiteral}::text[])
         AND (${filterLevel}::text IS NULL OR level = ${filterLevel})
         AND (${filterSinceHours}::int IS NULL OR created_at >= now() - (${filterSinceHours}::int * INTERVAL '1 hour'))
-        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\')
+        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\\')
     `;
 
     dataRows = await sql`
@@ -223,7 +224,7 @@ const list = async (
       WHERE source = ANY(${filterSourcesLiteral}::text[])
         AND (${filterLevel}::text IS NULL OR level = ${filterLevel})
         AND (${filterSinceHours}::int IS NULL OR created_at >= now() - (${filterSinceHours}::int * INTERVAL '1 hour'))
-        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\')
+        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\\')
       ORDER BY created_at DESC
       LIMIT ${perPage} OFFSET ${offset}
     `;
@@ -233,7 +234,7 @@ const list = async (
       FROM logging.entries
       WHERE (${filterLevel}::text IS NULL OR level = ${filterLevel})
         AND (${filterSinceHours}::int IS NULL OR created_at >= now() - (${filterSinceHours}::int * INTERVAL '1 hour'))
-        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\')
+        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\\')
     `;
 
     dataRows = await sql`
@@ -241,7 +242,7 @@ const list = async (
       FROM logging.entries
       WHERE (${filterLevel}::text IS NULL OR level = ${filterLevel})
         AND (${filterSinceHours}::int IS NULL OR created_at >= now() - (${filterSinceHours}::int * INTERVAL '1 hour'))
-        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\')
+        AND (${searchPattern}::text IS NULL OR message ILIKE ${searchPattern} ESCAPE '\\' OR metadata::text ILIKE ${searchPattern} ESCAPE '\\')
       ORDER BY created_at DESC
       LIMIT ${perPage} OFFSET ${offset}
     `;
@@ -321,8 +322,8 @@ const timeseries = async (
         AND (${level}::text IS NULL OR entries.level = ${level})
         AND (
           ${searchPattern}::text IS NULL
-          OR entries.message ILIKE ${searchPattern} ESCAPE '\'
-          OR entries.metadata::text ILIKE ${searchPattern} ESCAPE '\'
+          OR entries.message ILIKE ${searchPattern} ESCAPE '\\'
+          OR entries.metadata::text ILIKE ${searchPattern} ESCAPE '\\'
         )
       GROUP BY at, entries.level
     )
@@ -369,8 +370,8 @@ const statsBy = async (
         AND (${level}::text IS NULL OR level = ${level})
         AND (
           ${searchPattern}::text IS NULL
-          OR message ILIKE ${searchPattern} ESCAPE '\'
-          OR metadata::text ILIKE ${searchPattern} ESCAPE '\'
+          OR message ILIKE ${searchPattern} ESCAPE '\\'
+          OR metadata::text ILIKE ${searchPattern} ESCAPE '\\'
         )
       GROUP BY level
       ORDER BY count DESC, key ASC
@@ -387,8 +388,8 @@ const statsBy = async (
       AND (${level}::text IS NULL OR level = ${level})
       AND (
         ${searchPattern}::text IS NULL
-        OR message ILIKE ${searchPattern} ESCAPE '\'
-        OR metadata::text ILIKE ${searchPattern} ESCAPE '\'
+        OR message ILIKE ${searchPattern} ESCAPE '\\'
+        OR metadata::text ILIKE ${searchPattern} ESCAPE '\\'
       )
     GROUP BY source
     ORDER BY count DESC, key ASC
@@ -466,6 +467,7 @@ const summary = async (): Promise<LogSummary> => {
 
 /** Admin service object for querying/managing logs. */
 export const logging = {
+  webVitals: readWebVitals,
   list,
   getById,
   getSources,

package/src/services/logging/trace.ts

@@ -1,6 +1,7 @@
 import { createHash, randomBytes } from "node:crypto";
 import type { SyncEvent } from "@k2b/sync";
 import { sql } from "bun";
+import { getProcessApplicationId } from "../../_internal/process-identity";
 import type { PaginationParams } from "../../contracts/shared";
 import { escapeLikePattern, parsePgJsonRecord, toPgTextArray } from "../postgres";
 import { isSensitiveMetadataKey, REDACTED, redactMetadata } from "./redaction";
@@ -1034,7 +1035,7 @@ const detailAttributes = (detail: Record<string, unknown>): TraceAttributes => {
 };
 
 /** The app hosting this process; Sync events carry no app name. */
-const processAppId = (): string | undefined => process.env.APP_ID?.trim() || undefined;
+const processAppId = getProcessApplicationId;
 
 const traceSyncEvent = async (event: SyncEvent, application?: string): Promise<void> => {
   const resource = event.resource;

package/src/services/logging/web-vitals.ts

@@ -0,0 +1,81 @@
+import { sql } from "bun";
+import { z } from "zod";
+
+const ranges = {
+  "1h": { hours: 1, bucket: 60 },
+  "6h": { hours: 6, bucket: 300 },
+  "24h": { hours: 24, bucket: 900 },
+  "7d": { hours: 168, bucket: 3600 },
+  "30d": { hours: 720, bucket: 21600 },
+} as const;
+const querySchema = z.object({
+  range: z.enum(["1h", "6h", "24h", "7d", "30d"]).default("24h"),
+  appId: z.string().max(64).default(""),
+  route: z.string().max(200).default(""),
+  page: z.number().int().min(1).max(100000).default(1),
+});
+export type WebVitalsQuery = z.input<typeof querySchema>;
+export type WebVitalName = "LCP" | "INP" | "CLS";
+export type WebVitalMetric = { name: WebVitalName; count: number; p75: number };
+export type WebVitalsOverview = {
+  summary: WebVitalMetric[];
+  series: (WebVitalMetric & { bucket: number })[];
+  routes: (WebVitalMetric & { appId: string; route: string })[];
+  totalRoutes: number;
+  page: number;
+  perPage: number;
+};
+
+/** Admin diagnostics. Deduplicate the last valid report inside [since, until).
+ * Attribute it to its last receipt time; this is not navigation-start time.
+ * Only aggregates leave Postgres. Retention applies before this read.
+ */
+export async function readWebVitals(input: WebVitalsQuery, until = new Date()): Promise<WebVitalsOverview> {
+  const query = querySchema.parse(input);
+  const { hours, bucket } = ranges[query.range];
+  const since = new Date(until.getTime() - hours * 3600000);
+  const perPage = 50;
+  const [result] = await sql<Omit<WebVitalsOverview, "page" | "perPage">[]>`
+    WITH stored AS MATERIALIZED (
+      SELECT id, created_at,
+        logging.object_metadata(metadata) AS metadata
+      FROM logging.entries
+      WHERE source = 'web-vitals' AND level = 'info' AND created_at >= ${since} AND created_at < ${until}
+    ), candidates AS MATERIALIZED (
+      SELECT id, created_at, metadata->>'appId' AS app, metadata->>'routeTemplate' AS route,
+        metadata->>'name' AS name, metadata->>'id' AS metric_id,
+        CASE WHEN jsonb_typeof(metadata->'value') = 'number' THEN (metadata->>'value')::numeric END AS value
+      FROM stored
+      WHERE jsonb_typeof(metadata->'appId') = 'string' AND metadata->>'appId' ~ '^[a-z0-9-]{1,64}$'
+        AND jsonb_typeof(metadata->'routeTemplate') = 'string'
+        AND length(metadata->>'routeTemplate') BETWEEN 1 AND 200 AND metadata->>'routeTemplate' ~ '^/[a-zA-Z0-9_/:.*-]*$'
+        AND jsonb_typeof(metadata->'id') = 'string' AND length(metadata->>'id') BETWEEN 1 AND 100
+        AND metadata->>'name' IN ('LCP','INP','CLS')
+        AND (${query.appId} = '' OR metadata->>'appId' = ${query.appId})
+        AND (${query.route} = '' OR metadata->>'routeTemplate' = ${query.route})
+    ), latest AS MATERIALIZED (
+      SELECT DISTINCT ON (app, route, name, metric_id) app, route, name, value::double precision AS value, created_at
+      FROM candidates WHERE value >= 0 AND value <= 1.7976931348623157e308::numeric
+      ORDER BY app, route, name, metric_id, created_at DESC, id DESC
+    ), route_stats AS MATERIALIZED (
+      SELECT app, route, name, count(*)::int AS count,
+        percentile_cont(0.75) WITHIN GROUP (ORDER BY value) AS p75
+      FROM latest GROUP BY app, route, name
+    ), route_keys AS MATERIALIZED (
+      SELECT DISTINCT app, route FROM route_stats ORDER BY app, route LIMIT ${perPage} OFFSET ${(query.page - 1) * perPage}
+    )
+    SELECT
+      COALESCE((SELECT jsonb_agg(s) FROM (SELECT name, count(*)::int AS count, percentile_cont(0.75) WITHIN GROUP (ORDER BY value) AS p75 FROM latest GROUP BY name ORDER BY name) s), '[]'::jsonb) AS summary,
+      COALESCE((SELECT jsonb_agg(s ORDER BY s.bucket, s.name) FROM (SELECT name,
+        floor(extract(epoch FROM created_at) / ${bucket}) * ${bucket} * 1000 AS bucket,
+        count(*)::int AS count, percentile_cont(0.75) WITHIN GROUP (ORDER BY value) AS p75
+        FROM latest GROUP BY name, bucket) s), '[]'::jsonb) AS series,
+      COALESCE((SELECT jsonb_agg(s ORDER BY s."appId", s.route, s.name) FROM (
+        SELECT l.app AS "appId", l.route, l.name, l.count, l.p75
+        FROM route_stats l JOIN route_keys k USING (app, route)
+      ) s), '[]'::jsonb) AS routes,
+      (SELECT count(*)::int FROM (SELECT DISTINCT app, route FROM route_stats) r) AS "totalRoutes"
+  `;
+  if (!result) throw new Error("Web Vitals aggregation returned no result");
+  return { ...result, page: query.page, perPage };
+}

package/src/services/mandates/index.ts

@@ -9,6 +9,10 @@ import { parsePgJsonValue } from "../postgres";
 import { isMandatePolicyNarrowing, type MandatePolicyV1, MandatePolicyV1Schema, mandatePolicyAllows, parseMandatePolicy } from "./policy";
 
 export {
+  type CapabilityGrant,
+  CapabilityGrantSchema,
+  CapabilityGrantsSchema,
+  capabilityGrantAllows,
   isMandatePolicyNarrowing,
   MANDATE_POLICY_MAX_IDENTIFIERS,
   MANDATE_POLICY_VERSION,
@@ -16,6 +20,9 @@ export {
   MandatePolicyV1Schema,
   mandatePolicyAllows,
   parseMandatePolicy,
+  type TaskGrant,
+  TaskGrantSchema,
+  TaskGrantsSchema,
 } from "./policy";
 
 export type MandateState = "active" | "paused" | "revoked";
@@ -176,7 +183,7 @@ const mapMandate = (row: MandateRow): Mandate => ({
   revokeReason: row.revoke_reason,
 });
 
-const selectMandate = sql`
+const selectMandate = () => sql`
   SELECT id, subject_kind, subject_user_id, subject_service_account_id,
     owner_app_id, workload_type, workload_id, policy, state, revision, expires_at,
     confirmed_at, confirmation_deadline,
@@ -224,7 +231,7 @@ const parsePolicyForWorkload = (
 
 const load = async (mandateId: string, db: SQL): Promise<Mandate | null> => {
   if (!UUID.safeParse(mandateId).success) return null;
-  const [row] = await db<MandateRow[]>`${selectMandate} WHERE id = ${mandateId}::uuid`;
+  const [row] = await db<MandateRow[]>`${selectMandate()} WHERE id = ${mandateId}::uuid`;
   return row ? mapMandate(row) : null;
 };
 
@@ -437,7 +444,7 @@ export const listMandates = async (config: {
   const where = conditions.slice(1).reduce((combined, condition) => sql`${combined} AND ${condition}`, conditions[0]!);
   const [countRows, rows] = await Promise.all([
     db<{ count: number }[]>`SELECT COUNT(*)::int AS count FROM auth.mandates WHERE ${where}`,
-    db<MandateRow[]>`${selectMandate} WHERE ${where} ORDER BY created_at DESC, id DESC LIMIT ${perPage} OFFSET ${offset}`,
+    db<MandateRow[]>`${selectMandate()} WHERE ${where} ORDER BY created_at DESC, id DESC LIMIT ${perPage} OFFSET ${offset}`,
   ]);
   const total = countRows[0]?.count ?? 0;
   return { items: rows.map(mapMandate), page, perPage, total, hasNext: page * perPage < total };
@@ -616,6 +623,8 @@ export const validateMandateIssueAuthority = async (
     targetAppId: string;
     operation: string;
     actionApproval?: "none" | "approved";
+    input?: unknown;
+    capabilityApproval?: "none" | "rememberable" | "always";
     expectedRevision?: number;
     requestId?: string;
   },
@@ -669,7 +678,15 @@ export const validateMandateIssueAuthority = async (
   } catch {
     return denyMandateIssue(err.forbidden("Mandate policy is invalid"));
   }
-  if (!mandatePolicyAllows(policy, { appId: target.data, operation: operation.data, actionApproval: input.actionApproval ?? "none" })) {
+  if (
+    !mandatePolicyAllows(policy, {
+      appId: target.data,
+      operation: operation.data,
+      actionApproval: input.actionApproval ?? "none",
+      input: input.input,
+      capabilityApproval: input.capabilityApproval,
+    })
+  ) {
     return denyMandateIssue(err.forbidden("Mandate policy does not allow this operation"));
   }
   const mandate = mapMandate(row);

package/src/services/mandates/policy.ts

@@ -12,6 +12,8 @@ const identifierList = <T extends z.ZodType<string>>(schema: T) =>
 
 const operationSchema = z.union([
   z.literal("search.query"),
+  z.literal("runtime.http"),
+  z.literal("runtime.database"),
   z.string().refine((value) => {
     const [prefix, localId, extra] = value.split(":");
     return (
@@ -25,12 +27,121 @@ const operationSchema = z.union([
   }, "Expected a canonical mandate operation"),
 ]);
 
+export const CapabilityGrantSchema = z
+  .object({
+    appId: CapabilityAppIdSchema.describe("Exact discovered application ID."),
+    capabilityId: CapabilityLocalIdSchema.describe("Exact local capability ID from discovery, without application prefix."),
+    kind: z.enum(["query", "action"]).describe("Discovered capability kind."),
+    fixedInput: z.record(z.string(), z.json()).default({}).describe("Exact top-level input values. Omitted fields remain unrestricted."),
+  })
+  .strict();
+export const CapabilityGrantsSchema = z.array(CapabilityGrantSchema).max(MANDATE_POLICY_MAX_IDENTIFIERS / 2);
+export type CapabilityGrant = z.output<typeof CapabilityGrantSchema>;
+
+const httpsUrl = z
+  .string()
+  .url()
+  .max(2000)
+  .refine((value) => {
+    const url = new URL(value);
+    return url.protocol === "https:" && !url.username && !url.password && !url.hash;
+  }, "Use HTTPS without credentials or fragment");
+export const TaskGrantSchema = z.union([
+  CapabilityGrantSchema,
+  z
+    .object({
+      kind: z.literal("http").describe("Authorize scheduled Code Mode HTTP requests."),
+      fixedInput: z
+        .object({
+          origin: httpsUrl
+            .refine((value) => new URL(value).origin === value, "Use an exact origin without path")
+            .optional()
+            .describe("Exact HTTPS origin, without path, wildcard or trailing slash."),
+          url: httpsUrl.optional().describe("Exact full URL, including query parameters."),
+          method: z
+            .enum(["GET", "HEAD", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"])
+            .optional()
+            .describe("Exact HTTP method; omit to permit every supported method."),
+        })
+        .strict()
+        .default({})
+        .describe("Fixed input values. Omitted fields are unrestricted; empty input permits every supported target and operation."),
+    })
+    .strict(),
+  z
+    .object({
+      kind: z.literal("database").describe("Authorize scheduled Code Mode RSQL operations."),
+      fixedInput: z
+        .object({
+          resourceId: z.string().min(1).max(80).optional().describe("Exact Studio app ID whose database may be used."),
+          operation: z
+            .enum([
+              "connect",
+              "status",
+              "export",
+              "clear",
+              "reset",
+              "tables.list",
+              "tables.create",
+              "tables.update",
+              "tables.delete",
+              "schema.get",
+              "rows.list",
+              "rows.get",
+              "rows.insert",
+              "rows.update",
+              "rows.delete",
+              "query",
+            ])
+            .optional()
+            .describe("Exact database operation; connect needs its own grant when operation is fixed."),
+          table: z
+            .string()
+            .min(1)
+            .max(63)
+            .optional()
+            .describe("Exact table; applies to row and schema operations, not arbitrary SQL queries."),
+        })
+        .strict()
+        .default({})
+        .describe("Fixed input values. Omitted fields are unrestricted; empty input permits every supported target and operation."),
+    })
+    .strict(),
+]);
+export const TaskGrantsSchema = z.array(TaskGrantSchema).max(MANDATE_POLICY_MAX_IDENTIFIERS / 2);
+export type TaskGrant = z.output<typeof TaskGrantSchema>;
+
+const equalJson = (a: unknown, b: unknown): boolean => {
+  if (a === b) return true;
+  if (!a || !b || typeof a !== "object" || typeof b !== "object") return false;
+  if (Array.isArray(a) || Array.isArray(b))
+    return Array.isArray(a) && Array.isArray(b) && a.length === b.length && a.every((v, i) => equalJson(v, b[i]));
+  const ak = Object.keys(a),
+    bk = Object.keys(b);
+  return ak.length === bk.length && ak.every((key) => Object.hasOwn(b, key) && equalJson(Reflect.get(a, key), Reflect.get(b, key)));
+};
+export const capabilityGrantAllows = (
+  grant: CapabilityGrant,
+  input: { appId: string; capabilityId: string; kind: "query" | "action"; input: unknown },
+): boolean =>
+  grant.appId === input.appId &&
+  grant.capabilityId === input.capabilityId &&
+  grant.kind === input.kind &&
+  Object.entries(grant.fixedInput).every(
+    ([key, value]) =>
+      input.input !== null &&
+      typeof input.input === "object" &&
+      Object.hasOwn(input.input, key) &&
+      equalJson(value, Reflect.get(input.input, key)),
+  );
+
 export const MandatePolicyV1Schema = z
   .object({
     version: z.literal(MANDATE_POLICY_VERSION),
     apps: z.union([z.literal("*"), identifierList(CapabilityAppIdSchema)]),
     operations: z.union([z.literal("*"), identifierList(operationSchema)]),
     actions: z.enum(["deny", "require_approval", "preapproved"]),
+    grants: TaskGrantsSchema.optional(),
   })
   .strict()
   .superRefine((policy, context) => {
@@ -70,14 +181,66 @@ const ACTION_AUTHORITY = { deny: 0, require_approval: 1, preapproved: 2 } as con
 export const isMandatePolicyNarrowing = (current: MandatePolicyV1, next: MandatePolicyV1): boolean =>
   setAllows(current.apps, next.apps) &&
   setAllows(current.operations, next.operations) &&
-  ACTION_AUTHORITY[next.actions] <= ACTION_AUTHORITY[current.actions];
+  ACTION_AUTHORITY[next.actions] <= ACTION_AUTHORITY[current.actions] &&
+  (current.grants === undefined
+    ? !next.grants?.some((grant) => grant.kind === "http" || grant.kind === "database")
+    : next.grants !== undefined &&
+      next.grants.every((grant) =>
+        current.grants!.some((existing) => {
+          if (existing.kind !== grant.kind) return false;
+          if ("appId" in existing && "appId" in grant && (existing.appId !== grant.appId || existing.capabilityId !== grant.capabilityId))
+            return false;
+          return Object.entries(existing.fixedInput).every(([key, value]) => equalJson(value, Reflect.get(grant.fixedInput, key)));
+        }),
+      ));
 
 export const mandatePolicyAllows = (
   policy: MandatePolicyV1,
-  input: { appId: string; operation: string; actionApproval: "none" | "approved" },
+  input: {
+    appId: string;
+    operation: string;
+    actionApproval: "none" | "approved";
+    input?: unknown;
+    capabilityApproval?: "none" | "rememberable" | "always";
+  },
 ): boolean => {
   if (policy.apps !== "*" && !policy.apps.includes(input.appId)) return false;
   if (policy.operations !== "*" && !policy.operations.includes(input.operation)) return false;
+  if (input.operation === "runtime.http" || input.operation === "runtime.database") {
+    const kind = input.operation === "runtime.http" ? "http" : "database";
+    return (
+      input.appId === "assistant" &&
+      !!policy.grants?.some(
+        (grant) =>
+          grant.kind === kind &&
+          Object.entries(grant.fixedInput).every(
+            ([key, value]) =>
+              input.input !== null &&
+              typeof input.input === "object" &&
+              Object.hasOwn(input.input, key) &&
+              equalJson(value, Reflect.get(input.input, key)),
+          ),
+      )
+    );
+  }
+  if (policy.grants !== undefined) {
+    const [operation, capabilityId] = input.operation.split(":");
+    const kind =
+      operation === "capability.query"
+        ? "query"
+        : operation === "capability.action.run" || operation === "capability.action.review"
+          ? "action"
+          : null;
+    if (
+      !kind ||
+      !capabilityId ||
+      !policy.grants.some(
+        (grant) => "appId" in grant && capabilityGrantAllows(grant, { appId: input.appId, capabilityId, kind, input: input.input }),
+      )
+    )
+      return false;
+    if (kind === "action" && input.capabilityApproval !== "none" && input.capabilityApproval !== "rememberable") return false;
+  }
   if (!input.operation.startsWith("capability.action.run:")) return true;
   if (policy.actions === "deny") return false;
   if (policy.actions === "require_approval") return input.actionApproval === "approved";