create-windy 0.6.12 → 0.6.14

package/template/apps/server/src/agent-workflow/delegation-execution-authorization.ts

@@ -0,0 +1,218 @@
+import type { ModuleManifest } from "@southwind-ai/modules";
+import type { GovernedToolRegistry } from "../agent/tool-registry.js";
+import { captureAuthorizationScope } from "../data-access/scope-snapshot.js";
+import type { RequestActor } from "../guards.js";
+import type { createServerRuntime } from "../runtime.js";
+import { captureAgentWorkflowAuthorization } from "./authorization.js";
+import {
+  authorizeDelegationPolicy,
+  type EffectiveDelegationPolicy,
+} from "./delegation-policy.js";
+import type { CanonicalAgentWorkflowModelExecutionPort } from "./canonical-agent-run-port.js";
+import type { AgentWorkflowDelegationExecutionPort } from "./node-execution-ports.js";
+import type { AgentWorkflowRepository } from "./repository.js";
+import type { AgentWorkflowWorkspacePolicyPort } from "./workspace-policy.js";
+import { SameScopeDelegationAuthorizer } from "./production-delegation-scope.js";
+import { workflowId } from "./service-support.js";
+
+type ReserveInput = Parameters<
+  AgentWorkflowDelegationExecutionPort["reserve"]
+>[0];
+
+export class ProductionDelegationAuthorization {
+  readonly #scopeAuthorizer = new SameScopeDelegationAuthorizer();
+  constructor(
+    private readonly tools: GovernedToolRegistry,
+    private readonly runtime: ReturnType<typeof createServerRuntime>,
+    private readonly workspacePolicies: AgentWorkflowWorkspacePolicyPort,
+    private readonly modules: readonly ModuleManifest[],
+    private readonly agentRuns: CanonicalAgentWorkflowModelExecutionPort,
+    private readonly repository: AgentWorkflowRepository,
+  ) {}
+
+  async authorize(input: ReserveInput): Promise<{
+    readonly policy: EffectiveDelegationPolicy;
+    readonly workspaceId: string;
+  }> {
+    const capturedScope = captureAuthorizationScope(
+      input.context.actor.scopeContext,
+    );
+    const scope = `sha256:${capturedScope.hash}`;
+    if (
+      input.context.actor.id !== input.parentActorId ||
+      scope !== input.parentScopeDigest
+    ) {
+      throw new Error("DELEGATION_SCOPE_EXPANSION");
+    }
+    if (
+      [
+        input.parentAuthorizationSnapshotDigest,
+        input.parentToolPolicyDigest,
+        input.parentWorkspacePolicyDigest,
+        input.parentExecutionPolicyDigest,
+      ].some((value) => !/^sha256:[a-f0-9]{64}$/.test(value))
+    ) {
+      throw new Error("DELEGATION_PARENT_POLICY_INVALID");
+    }
+    const current = await this.assertFrozenAuthorization(input);
+    const operation = this.assertOperation(input);
+    const workspaceGrantId = workflowId(
+      "workflow_workspace",
+      input.parentNodeRunId,
+    );
+    const workspace = await this.workspacePolicies.authorize({
+      workspacePolicyKey: input.workspacePolicyKey,
+      scopePolicyKey: input.scopePolicyKey,
+      parentScopeDigest: input.parentScopeDigest,
+      workspaceGrantId,
+      context: input.context,
+    });
+    if (!workspace.allowed || !workspace.workspaceId) {
+      throw new Error(workspace.safeCode ?? "DELEGATION_WORKSPACE_DENIED");
+    }
+    const currentAllowedTools: string[] = [];
+    for (const key of operation.allowedToolKeys) {
+      if (await this.tools.allowed(key, input.context)) {
+        currentAllowedTools.push(key);
+      }
+    }
+    const licenseVersion =
+      input.context.licenseEnforced === false
+        ? "license-not-enforced"
+        : (input.context.license?.versionKey ?? "license-missing");
+    const policy = await authorizeDelegationPolicy({
+      request: {
+        actorId: input.parentActorId,
+        allowedToolKeys: input.allowedToolKeys,
+        scope: {
+          resourceType: "authorization-scope",
+          objectIds: [input.parentScopeDigest],
+        },
+      },
+      releaseRequirements: {
+        capabilityKey: input.capabilityKey,
+        allowedToolKeys: input.allowedToolKeys,
+        requiredFeatureKeys: input.requiredFeatureKeys,
+        requiredPermissionKeys: input.requiredPermissionKeys,
+        ...(input.allowedLicenseVersions
+          ? { allowedLicenseVersions: input.allowedLicenseVersions }
+          : {}),
+        workspacePolicyKey: input.workspacePolicyKey,
+        scopePolicyKey: input.scopePolicyKey,
+      },
+      ceiling: {
+        capabilityKey: input.capabilityKey,
+        allowedToolKeys: input.allowedToolKeys,
+        requiredFeatureKeys: input.requiredFeatureKeys,
+        requiredPermissionKeys: input.requiredPermissionKeys,
+        ...(input.allowedLicenseVersions
+          ? { allowedLicenseVersions: input.allowedLicenseVersions }
+          : {}),
+        workspacePolicyKey: input.workspacePolicyKey,
+        workspaceId: workspace.workspaceId,
+        scopeSnapshot: capturedScope.snapshot,
+        scopePolicyDigest: workspace.policyDigest,
+        policyDigest: input.parentExecutionPolicyDigest,
+        authorizationProofId: current.fence.proofId,
+        runPolicyDigest: input.parentExecutionPolicyDigest,
+        scopeDigest: input.parentScopeDigest,
+        authorizationSnapshotDigest: input.parentAuthorizationSnapshotDigest,
+      },
+      pinnedParentScope: capturedScope.snapshot,
+      current: {
+        actorId: input.parentActorId,
+        capabilityKeys: operation.requiredCapabilities,
+        allowedToolKeys: currentAllowedTools,
+        enabledFeatureKeys: input.requiredFeatureKeys,
+        permissionKeys: input.requiredPermissionKeys,
+        licenseVersion,
+        workspacePolicyKeys: [input.workspacePolicyKey],
+        scopeSnapshot: capturedScope.snapshot,
+        authorizationSnapshotDigest: current.authorizationSnapshotDigest,
+        runPolicyDigest: current.executionPolicyDigest,
+        authorizationProofId: current.fence.proofId,
+        checkedAt: current.fence.checkedAt,
+        expiresAt: current.fence.expiresAt,
+      },
+      parentDeadlineAt: (await this.repository.getSnapshot(input.parentRunId))!
+        .run.deadlineAt,
+      scopeAuthorizer: this.#scopeAuthorizer,
+      signal: input.signal,
+    });
+    return {
+      policy,
+      workspaceId: workspace.workspaceId,
+    };
+  }
+
+  createGuardContext(actor: RequestActor, signal: AbortSignal) {
+    return this.runtime.createGuardContextForActor(
+      new Request("http://agent-workflow.internal/delegation", { signal }),
+      actor,
+    );
+  }
+
+  private async assertFrozenAuthorization(input: ReserveInput) {
+    const snapshot = await this.repository.getSnapshot(input.parentRunId);
+    const release = snapshot
+      ? await this.repository.getRelease(snapshot.run.releaseId)
+      : undefined;
+    if (!snapshot || !release) throw new Error("DELEGATION_PARENT_NOT_FOUND");
+    const current = await captureAgentWorkflowAuthorization({
+      context: input.context,
+      release,
+      modules: this.modules,
+      runtime: this.runtime,
+      tools: this.tools,
+      workspacePolicies: this.workspacePolicies,
+    });
+    const expected = [
+      input.parentActorId,
+      input.parentScopeDigest,
+      input.parentAuthorizationSnapshotDigest,
+      input.parentToolPolicyDigest,
+      input.parentWorkspacePolicyDigest,
+      input.parentExecutionPolicyDigest,
+    ];
+    const observed = [
+      current.actorId,
+      current.scopeDigest,
+      current.authorizationSnapshotDigest,
+      current.toolPolicyDigest,
+      current.workspacePolicyDigest,
+      current.executionPolicyDigest,
+    ];
+    const frozen = [
+      snapshot.run.actorId,
+      snapshot.run.scopeDigest,
+      snapshot.run.authorizationSnapshotDigest,
+      snapshot.run.toolPolicyDigest,
+      snapshot.run.workspacePolicyDigest,
+      snapshot.run.executionPolicyDigest,
+    ];
+    if (
+      expected.some((value, index) => value !== observed[index]) ||
+      expected.some((value, index) => value !== frozen[index])
+    ) {
+      throw new Error("DELEGATION_PARENT_AUTHORIZATION_STALE");
+    }
+    return current;
+  }
+
+  private assertOperation(input: ReserveInput) {
+    const operation = this.agentRuns.operationPolicy(input.operationKey);
+    if (
+      !operation ||
+      operation.requiredCapabilities.length !== 1 ||
+      operation.requiredCapabilities[0] !== input.capabilityKey ||
+      input.allowedToolKeys.some(
+        (key) => !operation.allowedToolKeys.includes(key),
+      ) ||
+      !input.requiredFeatureKeys.includes(operation.featureKey) ||
+      !input.requiredPermissionKeys.includes(operation.permissionKey)
+    ) {
+      throw new Error("DELEGATION_CAPABILITY_EXPANSION");
+    }
+    return operation;
+  }
+}

package/template/apps/server/src/agent-workflow/delegation-policy-validation.ts

@@ -0,0 +1,253 @@
+import type { AuthorizationScopeSnapshot } from "@southwind-ai/shared";
+import { hashAuthorizationScope } from "../data-access/scope-snapshot.js";
+import type {
+  AuthorizeDelegationPolicyInput,
+  CurrentDelegationAuthorization,
+  DelegationScopeRequest,
+  DelegationScopeSubsetProof,
+} from "./delegation-policy.js";
+
+export function assertDelegationEnvelope(
+  input: AuthorizeDelegationPolicyInput,
+  now: Date,
+) {
+  assertActorBinding(input.request.actorId, input.pinnedParentScope, input.current);
+  assertDigest(input.ceiling.scopeDigest, "父级 Scope digest");
+  assertDigest(
+    input.ceiling.authorizationSnapshotDigest,
+    "父级授权快照 digest",
+  );
+  assertCurrentAuthorization(input.current, now);
+  if (
+    scopeDigest(input.pinnedParentScope) !== input.ceiling.scopeDigest ||
+    input.ceiling.capabilityKey !== input.releaseRequirements.capabilityKey ||
+    !input.current.capabilityKeys.includes(input.releaseRequirements.capabilityKey)
+  ) {
+    throw denied("子 Agent Capability 超出父级或当前 Host 授权");
+  }
+  const allowedToolKeys = requireRequestedIntersection(
+    input.request.allowedToolKeys,
+    input.releaseRequirements.allowedToolKeys,
+    input.ceiling.allowedToolKeys,
+    input.current.allowedToolKeys,
+    "Tool allowlist",
+  );
+  // Immutable Release guards are mandatory and never caller-selectable.
+  const requiredFeatureKeys = requireImmutableGuards(
+    input.releaseRequirements.requiredFeatureKeys,
+    input.ceiling.requiredFeatureKeys,
+    input.current.enabledFeatureKeys,
+    "Feature",
+  );
+  const requiredPermissionKeys = requireImmutableGuards(
+    input.releaseRequirements.requiredPermissionKeys,
+    input.ceiling.requiredPermissionKeys,
+    input.current.permissionKeys,
+    "Permission",
+  );
+  if (
+    input.releaseRequirements.workspacePolicyKey !==
+      input.ceiling.workspacePolicyKey ||
+    !input.current.workspacePolicyKeys.includes(
+      input.releaseRequirements.workspacePolicyKey,
+    )
+  ) {
+    throw denied("子 Agent Workspace Policy 未获授权");
+  }
+  if (
+    !licenseAllowed(
+      input.current.licenseVersion,
+      input.releaseRequirements.allowedLicenseVersions,
+    ) ||
+    !licenseAllowed(
+      input.current.licenseVersion,
+      input.ceiling.allowedLicenseVersions,
+    )
+  ) {
+    throw denied("当前 License 版本不允许子 Agent 执行");
+  }
+  if (input.signal.aborted) throw unavailable();
+  return { allowedToolKeys, requiredFeatureKeys, requiredPermissionKeys };
+}
+
+export function assertScopeSubsetProof(
+  proof: DelegationScopeSubsetProof,
+  input: AuthorizeDelegationPolicyInput,
+  now: Date,
+) {
+  const request = normalizedScopeRequest(
+    input.request.scope,
+    input.releaseRequirements.scopePolicyKey,
+  );
+  const currentDigest = scopeDigest(input.current.scopeSnapshot);
+  const childDigest = scopeDigest(proof.childScopeSnapshot);
+  if (
+    input.signal.aborted ||
+    !proof.proofId.trim() ||
+    proof.policyKey !== request.policyKey ||
+    proof.resourceType !== request.resourceType ||
+    !sameSet(proof.objectIds, request.objectIds) ||
+    proof.pinnedParentScopeDigest !== input.ceiling.scopeDigest ||
+    proof.currentParentScopeDigest !== currentDigest ||
+    proof.childScopeDigest !== childDigest ||
+    proof.childScopeSnapshot.actorId !== input.request.actorId ||
+    proof.childScopeSnapshot.tenantId !== input.current.scopeSnapshot.tenantId ||
+    !proof.scopePolicyDigest.trim() ||
+    !Number.isFinite(Date.parse(proof.checkedAt)) ||
+    (proof.expiresAt !== undefined &&
+      (!Number.isFinite(Date.parse(proof.expiresAt)) ||
+        Date.parse(proof.expiresAt) <= now.getTime()))
+  ) {
+    throw denied("子 Agent Scope 子集证明无效");
+  }
+}
+
+export function childDeadline(
+  parentDeadlineAt: string,
+  requestedDeadlineAt: string | undefined,
+  now = new Date(),
+): string {
+  const parent = timestamp(parentDeadlineAt, "父级 deadline");
+  const requested = requestedDeadlineAt
+    ? timestamp(requestedDeadlineAt, "子级 deadline")
+    : parent;
+  const deadline = Math.min(parent, requested);
+  if (deadline <= now.getTime()) throw denied("子 Agent deadline 已到期");
+  return new Date(deadline).toISOString();
+}
+
+export function normalizedScopeRequest(
+  request: DelegationScopeRequest,
+  releaseScopePolicyKey: string,
+) {
+  if (!releaseScopePolicyKey.trim() || !request.resourceType.trim()) {
+    throw denied("子 Agent Scope Policy 坐标无效");
+  }
+  const objectIds = unique(request.objectIds);
+  if (!objectIds.length || objectIds.length !== request.objectIds.length) {
+    throw denied("子 Agent Scope 对象集合无效或重复");
+  }
+  return { ...request, policyKey: releaseScopePolicyKey, objectIds };
+}
+
+function assertCurrentAuthorization(
+  current: CurrentDelegationAuthorization,
+  now: Date,
+) {
+  assertDigest(current.authorizationSnapshotDigest, "当前授权快照 digest");
+  assertDigest(current.runPolicyDigest, "当前 Run Policy digest");
+  const checkedAt = timestamp(current.checkedAt, "当前授权检查时间");
+  const expiresAt = timestamp(current.expiresAt, "当前授权证明期限");
+  if (
+    !current.authorizationProofId.trim() ||
+    checkedAt > now.getTime() ||
+    expiresAt <= now.getTime()
+  ) {
+    throw unavailable();
+  }
+}
+
+function assertActorBinding(
+  actorId: string,
+  pinned: AuthorizationScopeSnapshot,
+  current: CurrentDelegationAuthorization,
+) {
+  if (
+    !actorId.trim() ||
+    pinned.actorId !== actorId ||
+    current.actorId !== actorId ||
+    current.scopeSnapshot.actorId !== actorId ||
+    pinned.tenantId !== current.scopeSnapshot.tenantId
+  ) {
+    throw denied("Delegation Actor 或 Tenant 坐标不一致");
+  }
+}
+
+function requireRequestedIntersection(
+  requested: readonly string[],
+  releaseAllowed: readonly string[],
+  ceiling: readonly string[],
+  current: readonly string[],
+  label: string,
+): readonly string[] {
+  const normalized = unique(requested);
+  const releaseSet = new Set(unique(releaseAllowed));
+  const ceilingSet = new Set(unique(ceiling));
+  const currentSet = new Set(unique(current));
+  const effective = normalized.filter(
+    (key) => releaseSet.has(key) && ceilingSet.has(key) && currentSet.has(key),
+  );
+  if (effective.length !== normalized.length) {
+    throw denied(`子 Agent ${label} 超出父级或当前 Host 授权`);
+  }
+  return Object.freeze(effective);
+}
+
+function licenseAllowed(
+  current: string,
+  allowed: readonly string[] | undefined,
+) {
+  return !allowed?.length || unique(allowed).includes(current);
+}
+
+function requireImmutableGuards(
+  releaseDeclared: readonly string[],
+  ceiling: readonly string[],
+  current: readonly string[],
+  label: string,
+): readonly string[] {
+  const declared = unique(releaseDeclared);
+  const ceilingKeys = unique(ceiling);
+  const currentSet = new Set(unique(current));
+  if (
+    !sameSet(declared, ceilingKeys) ||
+    declared.some((key) => !currentSet.has(key))
+  ) {
+    throw denied(`父级或当前 Host 缺少 Immutable Release 声明的 ${label} Guard`);
+  }
+  return Object.freeze(declared);
+}
+
+function unique(values: readonly string[]) {
+  if (values.some((value) => !value.trim())) throw denied("授权 Key 不能为空");
+  return [...new Set(values)].sort();
+}
+
+function sameSet(left: readonly string[], right: readonly string[]) {
+  return JSON.stringify(unique(left)) === JSON.stringify(unique(right));
+}
+
+function scopeDigest(snapshot: AuthorizationScopeSnapshot) {
+  return `sha256:${hashAuthorizationScope(snapshot)}`;
+}
+
+function assertDigest(value: string, label: string) {
+  if (!/^sha256:[a-f0-9]{64}$/.test(value)) throw denied(`${label} 无效`);
+}
+
+function timestamp(value: string, label: string) {
+  const result = Date.parse(value);
+  if (!Number.isFinite(result)) throw denied(`${label} 无效`);
+  return result;
+}
+
+export class DelegationPolicyError extends Error {
+  constructor(
+    readonly code: "DELEGATION_DENIED" | "DELEGATION_AUTHORIZATION_UNAVAILABLE",
+    message: string,
+  ) {
+    super(message);
+    this.name = "DelegationPolicyError";
+  }
+}
+
+function denied(message: string) {
+  return new DelegationPolicyError("DELEGATION_DENIED", message);
+}
+
+function unavailable() {
+  return new DelegationPolicyError(
+    "DELEGATION_AUTHORIZATION_UNAVAILABLE",
+    "子 Agent 授权已取消或暂不可用",
+  );
+}

package/template/apps/server/src/agent-workflow/delegation-policy.ts

@@ -0,0 +1,179 @@
+import { createHash } from "node:crypto";
+import type {
+  AgentDelegationGrant,
+  AuthorizationScopeSnapshot,
+} from "@southwind-ai/shared";
+import {
+  assertDelegationEnvelope,
+  assertScopeSubsetProof,
+  childDeadline,
+  normalizedScopeRequest,
+} from "./delegation-policy-validation.js";
+
+export type DelegationCapabilityCeiling =
+  AgentDelegationGrant["capabilityCeiling"];
+
+export interface DelegationScopeRequest {
+  readonly resourceType: string;
+  readonly objectIds: readonly string[];
+}
+
+export interface DelegationScopeProofRequest extends DelegationScopeRequest {
+  readonly policyKey: string;
+}
+
+export interface DelegationScopeSubsetProof {
+  readonly proofId: string;
+  readonly policyKey: string;
+  readonly resourceType: string;
+  readonly objectIds: readonly string[];
+  readonly pinnedParentScopeDigest: string;
+  readonly currentParentScopeDigest: string;
+  readonly childScopeSnapshot: AuthorizationScopeSnapshot;
+  readonly childScopeDigest: string;
+  readonly scopePolicyDigest: string;
+  readonly checkedAt: string;
+  readonly expiresAt?: string;
+}
+
+/**
+ * Implementations resolve canonical server-side object sets and policies. A
+ * digest comparison alone is never sufficient proof that the child is a
+ * subset of both the pinned parent ceiling and the parent's current scope.
+ */
+export interface DelegationScopeSubsetAuthorizerPort {
+  proveSubset(input: {
+    readonly actorId: string;
+    readonly pinnedParentScope: AuthorizationScopeSnapshot;
+    readonly currentParentScope: AuthorizationScopeSnapshot;
+    readonly request: DelegationScopeProofRequest;
+    readonly signal: AbortSignal;
+  }): Promise<DelegationScopeSubsetProof>;
+}
+
+export interface CurrentDelegationAuthorization {
+  readonly actorId: string;
+  readonly capabilityKeys: readonly string[];
+  readonly allowedToolKeys: readonly string[];
+  readonly enabledFeatureKeys: readonly string[];
+  readonly permissionKeys: readonly string[];
+  readonly licenseVersion: string;
+  readonly workspacePolicyKeys: readonly string[];
+  readonly scopeSnapshot: AuthorizationScopeSnapshot;
+  readonly authorizationSnapshotDigest: string;
+  readonly runPolicyDigest: string;
+  readonly authorizationProofId: string;
+  readonly checkedAt: string;
+  readonly expiresAt: string;
+}
+
+export interface DelegationPolicyRequest {
+  readonly actorId: string;
+  readonly allowedToolKeys: readonly string[];
+  readonly scope: DelegationScopeRequest;
+  readonly requestedDeadlineAt?: string;
+}
+
+export interface EffectiveDelegationPolicy {
+  readonly actorId: string;
+  readonly capabilityKey: string;
+  readonly allowedToolKeys: readonly string[];
+  readonly requiredFeatureKeys: readonly string[];
+  readonly requiredPermissionKeys: readonly string[];
+  readonly licenseVersion: string;
+  readonly workspacePolicyKey: string;
+  readonly deadlineAt: string;
+  readonly childScopeSnapshot: AuthorizationScopeSnapshot;
+  readonly childScopeDigest: string;
+  readonly scopeProofId: string;
+  readonly scopePolicyDigest: string;
+  readonly authorizationSnapshotDigest: string;
+  readonly runPolicyDigest: string;
+  readonly authorizationProofId: string;
+  readonly policyDigest: string;
+}
+
+export interface DelegationReleaseRequirements {
+  readonly capabilityKey: string;
+  readonly allowedToolKeys: readonly string[];
+  readonly requiredFeatureKeys: readonly string[];
+  readonly requiredPermissionKeys: readonly string[];
+  readonly allowedLicenseVersions?: readonly string[];
+  readonly workspacePolicyKey: string;
+  readonly scopePolicyKey: string;
+}
+
+export interface AuthorizeDelegationPolicyInput {
+  readonly request: DelegationPolicyRequest;
+  readonly releaseRequirements: DelegationReleaseRequirements;
+  readonly ceiling: DelegationCapabilityCeiling;
+  readonly pinnedParentScope: AuthorizationScopeSnapshot;
+  readonly current: CurrentDelegationAuthorization;
+  readonly parentDeadlineAt: string;
+  readonly scopeAuthorizer: DelegationScopeSubsetAuthorizerPort;
+  readonly signal: AbortSignal;
+  readonly now?: Date;
+}
+
+export async function authorizeDelegationPolicy(
+  input: AuthorizeDelegationPolicyInput,
+): Promise<EffectiveDelegationPolicy> {
+  const now = input.now ?? new Date();
+  const guards = assertDelegationEnvelope(input, now);
+
+  const proof = await input.scopeAuthorizer.proveSubset({
+    actorId: input.request.actorId,
+    pinnedParentScope: structuredClone(input.pinnedParentScope),
+    currentParentScope: structuredClone(input.current.scopeSnapshot),
+    request: normalizedScopeRequest(
+      input.request.scope,
+      input.releaseRequirements.scopePolicyKey,
+    ),
+    signal: input.signal,
+  });
+  assertScopeSubsetProof(proof, input, now);
+  const deadlineAt = childDeadline(
+    input.parentDeadlineAt,
+    input.request.requestedDeadlineAt,
+    now,
+  );
+  const effective = {
+    actorId: input.request.actorId,
+    capabilityKey: input.releaseRequirements.capabilityKey,
+    allowedToolKeys: guards.allowedToolKeys,
+    requiredFeatureKeys: guards.requiredFeatureKeys,
+    requiredPermissionKeys: guards.requiredPermissionKeys,
+    licenseVersion: input.current.licenseVersion,
+    workspacePolicyKey: input.releaseRequirements.workspacePolicyKey,
+    deadlineAt,
+    childScopeSnapshot: structuredClone(proof.childScopeSnapshot),
+    childScopeDigest: proof.childScopeDigest,
+    scopeProofId: proof.proofId,
+    scopePolicyDigest: proof.scopePolicyDigest,
+    authorizationSnapshotDigest: input.current.authorizationSnapshotDigest,
+    runPolicyDigest: input.current.runPolicyDigest,
+    authorizationProofId: input.current.authorizationProofId,
+  };
+  return Object.freeze({
+    ...effective,
+    policyDigest: stableDigest(effective),
+  });
+}
+
+function stableDigest(value: unknown) {
+  return `sha256:${createHash("sha256").update(stableJson(value)).digest("hex")}`;
+}
+
+function stableJson(value: unknown): string {
+  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.entries(value as Record<string, unknown>)
+      .filter(([, child]) => child !== undefined)
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([key, child]) => `${JSON.stringify(key)}:${stableJson(child)}`)
+      .join(",")}}`;
+  }
+  return JSON.stringify(value) ?? "null";
+}
+
+export { childDeadline, DelegationPolicyError } from "./delegation-policy-validation.js";