@highflame/policy 2.2.45 → 2.4.0

package/_schemas/guardrails/templates/single_use_sensitive_tools.cedar

@@ -0,0 +1,54 @@
+// =============================================================================
+// Single-Use for Sensitive Tools
+// =============================================================================
+// Permits sensitive tool calls, but only once per grant. @single_use makes
+// Shield record the first allow in an atomic consume store and deny any replay
+// of the same grant ("grant_consumed"). Bare @single_use means per tool: one
+// allow covers any call to the same action and tool. Use
+// @single_use("request") instead to bind the allow to one exact set of
+// arguments.
+//
+// @single_use is only valid on a permit. Deny, DEFER and step-up outcomes
+// never consume. If the consume store is unavailable the request is denied
+// ("single_use_store_unavailable") unless the operator opted into fail-open.
+//
+// Requests that carry no bearer token, such as gateway and internal-service
+// traffic, have no token id to record the use against. Shield denies every
+// sensitive call_tool from them ("single_use_unbound"), whatever the
+// fail-open setting. Until the gateway forwards the caller's token to Shield
+// (ADR 0041 D16, ADR 0042 D10), that means every sensitive gateway call.
+//
+// Try it with request-level monitor mode (guard requests sent with
+// mode=monitor): single_use.would_deny on each response shows what enforcing
+// would deny. Per-policy monitor mode does NOT exercise @single_use, because
+// Shield reads it only from enforcing policies; a monitor-mode copy of this
+// template reports nothing, and switching it to enforce takes effect at once.
+//
+// Adopted alone, this permit also allows every sensitive call_tool (once per
+// grant). Pair it with the policies that decide which sensitive calls are
+// allowed at all.
+//
+// Context keys consumed:
+//   - tool_is_sensitive: Bool
+//
+// Compliance:
+//   - OWASP ASI02
+//
+// Category:  agent-identity
+// Namespace: Guardrails
+// =============================================================================
+
+@id("agent-identity.permit-single-use-sensitive-tools")
+@name("Permit sensitive tools once per grant")
+@description("Permits call_tool on a sensitive tool once per grant.")
+@severity("medium")
+@tags("category:agent-identity,surface:call-tool,scope:per-tool,owasp:asi02,single-use")
+@single_use
+permit (
+    principal,
+    action == Guardrails::Action::"call_tool",
+    resource
+)
+when {
+    context has tool_is_sensitive && context.tool_is_sensitive
+};

package/_schemas/guardrails/templates/templates.json

@@ -637,7 +637,7 @@
     {
       "id": "agent-identity.dual-attribution",
       "name": "Dual Attribution",
-      "description": "Block privileged agent actions that cannot be attributed to a human. Deploy in monitor mode first; a service key is unverified until the agent is adopted.",
+      "description": "Require human approval or an explicit allow grant for sensitive agent tool calls that no human answers for (no acting human, e.g. autonomous or workload agents); calls with an acting human pass. Customize the approver role. Deploy in enforce mode: the approval gate does not exist in monitor mode. Adopt agents first (a service key is unverified until then), or trial the unverified-agent block as its own monitor-mode policy.",
       "category": "agent-identity",
       "file": "dual_attribution.cedar",
       "severity": "critical",
@@ -647,7 +647,39 @@
         "surface:call-tool",
         "scope:per-agent",
         "posture:deny-default",
-        "owasp:asi01"
+        "owasp:asi01",
+        "step-up"
+      ]
+    },
+    {
+      "id": "agent-identity.block-unadopted-agent-sensitive-tools",
+      "name": "Unadopted Agents: No Sensitive Tool Calls",
+      "description": "Block sensitive tool calls from agents whose lifecycle status is not active (discovered or pending). Deploy in monitor mode first to see which discovered agents already call sensitive tools.",
+      "category": "agent-identity",
+      "file": "unadopted_agents.cedar",
+      "severity": "high",
+      "tags": [
+        "category:agent-identity",
+        "detection:rule",
+        "surface:call-tool",
+        "scope:per-agent",
+        "posture:deny-default",
+        "owasp:asi04"
+      ]
+    },
+    {
+      "id": "agent-identity.permit-single-use-sensitive-tools",
+      "name": "Single-Use for Sensitive Tools",
+      "description": "Permit sensitive tool calls once per grant: the first allow is recorded and a replay of the same grant is denied. Bare @single_use means per tool; use @single_use(\"request\") to bind to one set of arguments. Requests without a bearer token (gateway and internal-service traffic, until the gateway forwards the caller token) are denied (single_use_unbound). Try it with request-level mode=monitor: per-policy monitor mode does not exercise @single_use. Adopted alone, it also permits every sensitive call.",
+      "category": "agent-identity",
+      "file": "single_use_sensitive_tools.cedar",
+      "severity": "medium",
+      "tags": [
+        "category:agent-identity",
+        "surface:call-tool",
+        "scope:per-tool",
+        "owasp:asi02",
+        "single-use"
       ]
     }
   ]

package/_schemas/guardrails/templates/unadopted_agents.cedar

@@ -0,0 +1,64 @@
+// =============================================================================
+// Unadopted Agents: No Sensitive Tool Calls
+// =============================================================================
+// Agents that an enterprise registers in its own IdP (Entra Agent ID, Okta AI
+// agents) are discovered by Highflame before anyone adopts them. A discovered
+// or pending agent has an identity but no owner-reviewed policy, so it should
+// not reach sensitive tools until it is adopted (status "active").
+//
+// `context.actor.status` carries the agent lifecycle status. When no actor
+// record is present the rule falls back to the legacy `context.principal.status`
+// profile. Absence means "unknown", not "active": the has-guards below make a
+// request with no status fall through to the other rules instead of being
+// matched here. Any status other than "active" is matched, so suspended and
+// deactivated agents are blocked too. The comparison is case-sensitive, like
+// ZeroID's lowercase status values.
+//
+// Today this template is forward-looking. ZeroID mints tokens only for active
+// identities and stamps "active" at mint, and every caller of Shield forwards
+// that value, so no live path reports another status yet. It takes effect when
+// a non-active status reaches Shield, as ADR 0042 plans for agents registered
+// in a customer IdP. The status is a mint-time snapshot: an identity suspended
+// after its token was minted reads "active" until the token expires.
+//
+// `tool_is_sensitive` is set by Shield's tool_validator from a fixed list of
+// tool names (shell, execute_command, write_file, http_post, send_email,
+// delete_file, run_sql, plus Shield's configured list); other tools are not
+// sensitive and are not matched.
+//
+// This copy covers Guardrails traffic. Gateway traffic (Firehog) is evaluated
+// in the AIGateway namespace; use the AIGateway copy for it.
+//
+// Deploy in MONITOR mode first to see which discovered agents already call
+// sensitive tools, adopt them, then switch to enforce.
+//
+// Context keys consumed:
+//   - actor, principal: records - status is the agent lifecycle status
+//   - tool_is_sensitive: Bool
+//
+// Compliance:
+//   - OWASP ASI04
+//
+// Category:  agent-identity
+// Namespace: Guardrails
+// =============================================================================
+
+@id("agent-identity.block-unadopted-agent-sensitive-tools")
+@name("Block unadopted agents from sensitive tools")
+@description("Blocks call_tool on a sensitive tool when actor.status (or, without an actor record, principal.status) is present and is not active.")
+@severity("high")
+@tags("category:agent-identity,detection:rule,surface:call-tool,scope:per-agent,posture:deny-default,owasp:asi04")
+@reject_message("Tool execution blocked: this agent has not been adopted, so it may not call sensitive tools. Adopt the agent to activate it.")
+forbid (
+    principal,
+    action == Guardrails::Action::"call_tool",
+    resource
+)
+when {
+    (
+        (context has actor && context.actor has status && context.actor.status != "active") ||
+        (!(context has actor) && context has principal && context.principal has status &&
+         context.principal.status != "active")
+    ) &&
+    context has tool_is_sensitive && context.tool_is_sensitive
+};

package/dist/aarm-annotation.d.ts

@@ -76,6 +76,39 @@ export interface RedactionStrategyDirective {
      */
     strategy: string;
 }
+/**
+ * Parsed form of `@step_up_scope`. Absent means a step-up approval authorizes
+ * exactly one call; "session" lets it cover repeated calls to the same tool
+ * for the life of the approval token. Only valid with `@step_up_required`.
+ */
+export interface StepUpScopeDirective {
+    /** Always "session" — the only legal value. */
+    scope: string;
+}
+/**
+ * Parsed form of `@step_up_four_eyes`. Marker: the approver must be a
+ * different person from the requesting agent's owner. Written bare or as
+ * `@step_up_four_eyes("true")`. Only valid with `@step_up_required`.
+ */
+export interface StepUpFourEyesDirective {
+}
+/**
+ * Parsed form of `@step_up_unless_granted`. Marker: an explicit agent grant
+ * satisfies this policy's step-up approval. When the call is explicitly
+ * allowed by an enforcing allow grant, Shield waives the challenge, provided
+ * every step-up policy matching the call carries it. Written bare or as
+ * `@step_up_unless_granted("true")`. Only valid with `@step_up_required`.
+ */
+export interface StepUpUnlessGrantedDirective {
+}
+/**
+ * Parsed form of `@single_use`. The allow produced by the permit carrying it
+ * can be spent once. Only valid on a permit (see validateAARMAnnotationsForEffect).
+ */
+export interface SingleUseDirective {
+    /** "tool" (default; what the bare annotation means) or "request" (same arguments). */
+    granularity: string;
+}
 /**
  * Every typed AARM directive parsed from a single policy's annotation map.
  * Each field is present iff the corresponding annotation was present and
@@ -87,6 +120,10 @@ export interface AARMDirectives {
     deferBelowConfidence?: DeferBelowConfidenceDirective;
     deferUntilContext?: DeferUntilContextDirective;
     redactionStrategy?: RedactionStrategyDirective;
+    stepUpScope?: StepUpScopeDirective;
+    stepUpFourEyes?: StepUpFourEyesDirective;
+    stepUpUnlessGranted?: StepUpUnlessGrantedDirective;
+    singleUse?: SingleUseDirective;
 }
 /** True iff at least one AARM directive was parsed. */
 export declare function hasAnyAARMDirective(d: AARMDirectives | null | undefined): boolean;
@@ -127,12 +164,29 @@ export interface ParseAARMResult {
  * offending annotation at once — Studio shows all squiggles in one pass.
  * Keys are processed in sorted order for stable error reporting.
  */
-export declare function parseAARMAnnotations(raw: Record<string, string> | null | undefined): ParseAARMResult;
+export declare function parseAARMAnnotations(raw: Record<string, string | null> | null | undefined): ParseAARMResult;
+/**
+ * THE authoring-time AARM check: run it on every rule of a policy before
+ * saving it (Studio's lint, Admin's policy-create/update), passing the rule's
+ * effect. It is validateAARMAnnotations plus the checks that depend on the
+ * effect: `@single_use` is only meaningful on a permit (a forbid never
+ * produces an allow to consume). validateAARMAnnotations alone is
+ * effect-blind and is not sufficient.
+ *
+ * Shield runs the same check at sync, but there an error is not always a
+ * reject: a permit with an invalid annotation is dropped (fail closed), while
+ * a forbid is loaded with the offending annotation ignored, since dropping a
+ * forbid would remove a block. Surface the error here, at save time.
+ *
+ * Exported from both the package root and the browser-safe `./types` entry.
+ */
+export declare function validateAARMAnnotationsForEffect(effect: 'permit' | 'forbid', raw: Record<string, string | null> | null | undefined): AARMAnnotationError[];
 /**
  * Validate-only variant: returns the error list without the typed
- * directives. Suitable for Admin's policy-create endpoint, which only needs
- * the yes/no verdict + error list.
+ * directives. Effect-blind: authoring checks that know the rule's effect
+ * (Admin's policy-create, Studio's lint) must use
+ * validateAARMAnnotationsForEffect instead.
  */
-export declare function validateAARMAnnotations(raw: Record<string, string> | null | undefined): AARMAnnotationError[];
+export declare function validateAARMAnnotations(raw: Record<string, string | null> | null | undefined): AARMAnnotationError[];
 /** True iff key is a platform-recognized AARM annotation. */
 export declare function isAARMAnnotationKey(key: string): boolean;

package/dist/aarm-annotation.js

@@ -45,7 +45,11 @@ export function hasAnyAARMDirective(d) {
         d.deferOnConflict !== undefined ||
         d.deferBelowConfidence !== undefined ||
         d.deferUntilContext !== undefined ||
-        d.redactionStrategy !== undefined);
+        d.redactionStrategy !== undefined ||
+        d.stepUpScope !== undefined ||
+        d.stepUpFourEyes !== undefined ||
+        d.stepUpUnlessGranted !== undefined ||
+        d.singleUse !== undefined);
 }
 /**
  * Structured error for a malformed AARM annotation. Mirrors Go's
@@ -100,7 +104,11 @@ export function parseAARMAnnotations(raw) {
         if (!def) {
             continue; // not an AARM-recognized annotation; ignore
         }
-        const value = raw[key];
+        // cedar-wasm reports a value-less annotation (`@single_use`) as null:
+        // treat it as bare, like Go and parseAnnotations do. undefined and
+        // non-strings still fail closed in parseAARMAnnotationParams.
+        const rawValue = raw[key];
+        const value = (rawValue === null ? '' : rawValue);
         const parsed = parseAARMAnnotationParams(def, value);
         if (parsed.error) {
             errors.push(parsed.error);
@@ -143,6 +151,38 @@ export function parseAARMAnnotations(raw) {
                     directives.redactionStrategy = r.directive;
                 break;
             }
+            case 'step_up_scope': {
+                const r = buildStepUpScope(def, params, value);
+                if (r.error)
+                    errors.push(r.error);
+                else
+                    directives.stepUpScope = r.directive;
+                break;
+            }
+            case 'step_up_four_eyes': {
+                const r = buildStepUpFourEyes(def, params, value);
+                if (r.error)
+                    errors.push(r.error);
+                else
+                    directives.stepUpFourEyes = r.directive;
+                break;
+            }
+            case 'step_up_unless_granted': {
+                const r = buildStepUpUnlessGranted(def, params, value);
+                if (r.error)
+                    errors.push(r.error);
+                else
+                    directives.stepUpUnlessGranted = r.directive;
+                break;
+            }
+            case 'single_use': {
+                const r = buildSingleUse(def, params, value);
+                if (r.error)
+                    errors.push(r.error);
+                else
+                    directives.singleUse = r.directive;
+                break;
+            }
             default:
                 // Registry entry exists but no typed extractor is wired here — a
                 // programming error in highflame-policy. Fail closed at runtime.
@@ -154,12 +194,64 @@ export function parseAARMAnnotations(raw) {
                 }));
         }
     }
+    // The step-up modifiers only mean something next to @step_up_required.
+    // Without it the policy would permit outright while its author believes a
+    // human approval is required, so reject rather than ignore.
+    if (!directives.stepUpRequired) {
+        for (const key of ['step_up_four_eyes', 'step_up_scope', 'step_up_unless_granted']) {
+            if (key in raw && !errors.some((e) => e.key === key)) {
+                errors.push(new AARMAnnotationError({
+                    key,
+                    rawValue: raw[key] ?? '',
+                    reason: 'requires @step_up_required on the same policy',
+                }));
+            }
+        }
+    }
+    // "self" routes the approval to the requesting identity's owner, and
+    // four-eyes forbids exactly that person from approving: every gated call
+    // would wait for an approval that cannot happen, then deny.
+    if (directives.stepUpRequired?.role === 'self' && directives.stepUpFourEyes) {
+        errors.push(new AARMAnnotationError({
+            key: 'step_up_four_eyes',
+            rawValue: raw.step_up_four_eyes ?? '',
+            reason: 'cannot be combined with @step_up_required("self"): self sends the approval ' +
+                'to the owner, whom four-eyes forbids from approving',
+        }));
+    }
     return { directives, errors };
 }
+/**
+ * THE authoring-time AARM check: run it on every rule of a policy before
+ * saving it (Studio's lint, Admin's policy-create/update), passing the rule's
+ * effect. It is validateAARMAnnotations plus the checks that depend on the
+ * effect: `@single_use` is only meaningful on a permit (a forbid never
+ * produces an allow to consume). validateAARMAnnotations alone is
+ * effect-blind and is not sufficient.
+ *
+ * Shield runs the same check at sync, but there an error is not always a
+ * reject: a permit with an invalid annotation is dropped (fail closed), while
+ * a forbid is loaded with the offending annotation ignored, since dropping a
+ * forbid would remove a block. Surface the error here, at save time.
+ *
+ * Exported from both the package root and the browser-safe `./types` entry.
+ */
+export function validateAARMAnnotationsForEffect(effect, raw) {
+    const errors = validateAARMAnnotations(raw);
+    if (raw && 'single_use' in raw && effect !== 'permit' && !errors.some((e) => e.key === 'single_use')) {
+        errors.push(new AARMAnnotationError({
+            key: 'single_use',
+            rawValue: raw.single_use ?? '',
+            reason: 'is only valid on a permit policy',
+        }));
+    }
+    return errors;
+}
 /**
  * Validate-only variant: returns the error list without the typed
- * directives. Suitable for Admin's policy-create endpoint, which only needs
- * the yes/no verdict + error list.
+ * directives. Effect-blind: authoring checks that know the rule's effect
+ * (Admin's policy-create, Studio's lint) must use
+ * validateAARMAnnotationsForEffect instead.
  */
 export function validateAARMAnnotations(raw) {
     return parseAARMAnnotations(raw).errors;
@@ -258,6 +350,16 @@ function parseAARMAnnotationParams(def, raw) {
     // Single-positional shorthand. Bind the whole value to the positional param.
     const pos = positionalParameter(def);
     if (!pos) {
+        // An annotation whose only parameter is optional accepts both the bare
+        // (value-less) form, meaning "use the default", and a bare value as
+        // shorthand for that parameter: @single_use, @single_use("request").
+        const sole = soleOptionalParameter(def);
+        if (sole) {
+            const v = raw.trim();
+            if (v !== '')
+                values[sole.name] = v;
+            return { params: values };
+        }
         return {
             params: {},
             error: new AARMAnnotationError({
@@ -321,6 +423,72 @@ function buildRedactionStrategy(def, params, raw) {
     }
     return { directive: { strategy: strategy.value } };
 }
+/** Mirrors the enums in schemas/annotations.json (the generated registry carries none). */
+const STEP_UP_SCOPES = ['session'];
+const SINGLE_USE_GRANULARITIES = ['tool', 'request'];
+function buildStepUpScope(def, params, raw) {
+    const scope = requireStringParam(def, params, 'scope', raw);
+    if ('error' in scope)
+        return { error: scope.error };
+    if (!STEP_UP_SCOPES.includes(scope.value)) {
+        return {
+            error: new AARMAnnotationError({
+                key: def.key,
+                parameter: 'scope',
+                rawValue: raw,
+                reason: 'scope must be "session"; omit the annotation for the one-call default',
+            }),
+        };
+    }
+    return { directive: { scope: scope.value } };
+}
+function buildStepUpFourEyes(def, params, raw) {
+    // Bare or "true" only: "false" would make the annotation present yet
+    // disabled, which consumers checking presence would misread.
+    const v = params.enabled;
+    if (v !== undefined && v !== '' && v !== 'true') {
+        return {
+            error: new AARMAnnotationError({
+                key: def.key,
+                parameter: 'enabled',
+                rawValue: raw,
+                reason: 'value must be omitted or "true"',
+            }),
+        };
+    }
+    return { directive: {} };
+}
+function buildStepUpUnlessGranted(def, params, raw) {
+    // Bare or "true" only, as for four-eyes: "false" would read as present
+    // (grant waives the approval) to a consumer checking presence.
+    const v = params.enabled;
+    if (v !== undefined && v !== '' && v !== 'true') {
+        return {
+            error: new AARMAnnotationError({
+                key: def.key,
+                parameter: 'enabled',
+                rawValue: raw,
+                reason: 'value must be omitted or "true"',
+            }),
+        };
+    }
+    return { directive: {} };
+}
+function buildSingleUse(def, params, raw) {
+    const gDef = mustLookupParam(def, 'granularity');
+    const granularity = params.granularity || (gDef.default?.kind === 'string' ? gDef.default.value : 'tool');
+    if (!SINGLE_USE_GRANULARITIES.includes(granularity)) {
+        return {
+            error: new AARMAnnotationError({
+                key: def.key,
+                parameter: 'granularity',
+                rawValue: raw,
+                reason: 'value must be "tool" or "request" (or omitted for "tool"); values are case-sensitive',
+            }),
+        };
+    }
+    return { directive: { granularity } };
+}
 function buildDeferUntilContext(def, params, raw) {
     const field = requireStringParam(def, params, 'field', raw);
     if ('error' in field)
@@ -510,6 +678,11 @@ function hasParameter(def, name) {
 function parameterNames(def) {
     return def.parameters.map((p) => p.name);
 }
+/** The annotation's only parameter when it is optional and non-positional. */
+function soleOptionalParameter(def) {
+    const [only] = def.parameters;
+    return def.parameters.length === 1 && !only.required && !only.positional ? only : undefined;
+}
 function positionalParameter(def) {
     return def.parameters.find((p) => p.positional);
 }

package/dist/aarm-annotations.gen.js

@@ -85,9 +85,51 @@ export const AARM_ANNOTATIONS = [
             },
         ],
     },
+    {
+        key: 'single_use',
+        description: 'Make an allow by this permit spendable exactly once. Shield records a consume key on the first allow and denies replays of the same grant. Bare means per tool; @single_use(\"tool\") and @single_use(\"request\") are explicit. Valid only on permit. A request without a bearer token (gateway or internal-service traffic) has no token id to record against and is denied single_use_unbound.',
+        aarmRequirement: 'R9',
+        promotesCapability: '',
+        decisionEffect: '',
+        parameters: [
+            {
+                name: 'granularity',
+                type: 'string',
+                required: false,
+                positional: false,
+                description: 'What one use covers. tool: any call to the same action and tool. request: only a call with the same canonicalized arguments. Case-sensitive.',
+                default: { kind: 'string', value: 'tool' },
+                min: null,
+                max: null,
+                pattern: '',
+                valueSource: '',
+            },
+        ],
+    },
+    {
+        key: 'step_up_four_eyes',
+        description: 'Require that the approver is a different person from the requesting agent\'s owner. Bare (value-less) or @step_up_four_eyes(\"true\"); no other value is legal. Requires @step_up_required on the same policy.',
+        aarmRequirement: 'R4',
+        promotesCapability: '',
+        decisionEffect: '',
+        parameters: [
+            {
+                name: 'enabled',
+                type: 'bool',
+                required: false,
+                positional: false,
+                description: 'Always true when present. Accepted spellings are the bare annotation and the string \"true\"; \"false\" is rejected so the annotation cannot be present yet disabled.',
+                default: { kind: 'bool', value: true },
+                min: null,
+                max: null,
+                pattern: '',
+                valueSource: '',
+            },
+        ],
+    },
     {
         key: 'step_up_required',
-        description: 'Suspend the action pending human approval from an approver with the named role. AARM R4 STEP_UP decision: Shield issues an OpenID CIBA bc-authorize challenge and the action does not execute until an approver carrying the role resolves it (POST /oauth2/bc-authorize/{auth_req_id}/approve via AuthN), OR timeout_seconds elapses (fail-closed: timeout DENYs the action, never permits).',
+        description: 'Suspend the action pending human approval from an approver with the named role. AARM R4 STEP_UP decision: Shield issues an OpenID CIBA bc-authorize challenge and the action does not execute until an approver carrying the role resolves it (POST /oauth2/bc-authorize/{auth_req_id}/approve via AuthN), OR timeout_seconds elapses (fail-closed: timeout DENYs the action, never permits). One approver role per matching call: when two or more enforce-mode step-up policies of the same effect match one call and name different roles (\"self\" excepted, since any named role outranks owner approval), no single approval satisfies them, so Shield denies the call with step_up_internal_error. Policy authoring lints this as a warning (step_up_role_conflict).',
         aarmRequirement: 'R4',
         promotesCapability: 'CAP-ENF-004',
         decisionEffect: 'step_up',
@@ -118,6 +160,48 @@ export const AARM_ANNOTATIONS = [
             },
         ],
     },
+    {
+        key: 'step_up_scope',
+        description: 'Widen a step-up approval from one call to the approved tool for the life of the approval token. Without this annotation an approval authorizes exactly one call. With scope session, repeated calls to the SAME tool are covered until the token expires; other tools are never covered. Requires @step_up_required on the same policy.',
+        aarmRequirement: 'R4',
+        promotesCapability: '',
+        decisionEffect: '',
+        parameters: [
+            {
+                name: 'scope',
+                type: 'string',
+                required: true,
+                positional: true,
+                description: 'Approval scope. The only legal value is \"session\"; omit the annotation for the one-call default. Case-sensitive.',
+                default: null,
+                min: null,
+                max: null,
+                pattern: '',
+                valueSource: '',
+            },
+        ],
+    },
+    {
+        key: 'step_up_unless_granted',
+        description: 'Let an explicit agent grant satisfy this policy\'s step-up approval. When the call is explicitly allowed by an enforcing allow grant on the agent\'s access table, Shield waives the challenge; otherwise the approval is required as usual. If another step-up policy matching the same call lacks this annotation, the challenge is still issued. Restrictions (deny grants) always deny. Bare (value-less) or @step_up_unless_granted(\"true\"); no other value is legal. Requires @step_up_required on the same policy.',
+        aarmRequirement: 'R4',
+        promotesCapability: '',
+        decisionEffect: '',
+        parameters: [
+            {
+                name: 'enabled',
+                type: 'bool',
+                required: false,
+                positional: false,
+                description: 'Always true when present. Accepted spellings are the bare annotation and the string \"true\"; \"false\" is rejected so the annotation cannot be present yet disabled.',
+                default: { kind: 'bool', value: true },
+                min: null,
+                max: null,
+                pattern: '',
+                valueSource: '',
+            },
+        ],
+    },
 ];
 /**
 * O(1) lookup over AARM_ANNOTATIONS. Use this when validating raw

package/dist/ai_gateway-defaults.gen.d.ts

@@ -2,7 +2,7 @@
  * AiGateway policy category identifiers.
  * Maps to UI tab names in Studio.
  */
-export type AiGatewayCategory = 'semantic' | 'tools' | 'agent-security' | 'data-protection' | 'privacy' | 'organization';
+export type AiGatewayCategory = 'semantic' | 'tools' | 'agent-security' | 'data-protection' | 'privacy' | 'agent-identity' | 'organization';
 /**
  * Category metadata for UI display.
  */