@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/model/ai-page-job.js

@@ -0,0 +1,159 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { AI_BUILD_PLAN_CREATION_NOUNS, aiPlanUndeclaredRefs } from "./ai-build-plan.js";
+export const AI_PAGE_TYPES = [
+    {
+        id: 'landing',
+        label: 'Landing',
+        purpose: 'a landing page that makes one offer and asks for one action'
+    },
+    {
+        id: 'about',
+        label: 'About',
+        purpose: 'an about page: who the business is, what it stands for and who is behind it'
+    },
+    {
+        id: 'pricing',
+        label: 'Pricing',
+        purpose: 'a pricing page: the plans or packages, what each includes and how to start'
+    },
+    {
+        id: 'contact',
+        label: 'Contact',
+        purpose: 'a contact page: how to reach the business, and where and when'
+    },
+    {
+        id: 'blogIndex',
+        label: 'Blog index',
+        purpose: 'a blog index that lists the posts of the site’s content collection'
+    },
+    {
+        id: 'product',
+        label: 'Product',
+        purpose: 'a page about one product: what it is, who it is for and how to get it'
+    },
+    {
+        id: 'service',
+        label: 'Service',
+        purpose: 'a page about one service: what it covers, how it works and how to book it'
+    },
+    {
+        id: 'event',
+        label: 'Event',
+        purpose: 'an event page: what it is, when and where, and how to attend'
+    }
+];
+const PAGE_TYPE_BY_ID = new Map(AI_PAGE_TYPES.map((type)=>[
+        type.id,
+        type
+    ]));
+/** The definition of a page type id, or `null` for anything else. */ export function aiPageTypeDefinition(id) {
+    var _PAGE_TYPE_BY_ID_get;
+    return typeof id === 'string' ? (_PAGE_TYPE_BY_ID_get = PAGE_TYPE_BY_ID.get(id)) != null ? _PAGE_TYPE_BY_ID_get : null : null;
+}
+/** A page job's inputs, or the sentence the door refuses them with. */ export function parseAiPageJobInputs(inputs) {
+    const raw = inputs == null ? void 0 : inputs['pageType'];
+    if (raw === undefined || raw === null || raw === '') return {
+        pageType: null
+    };
+    const definition = aiPageTypeDefinition(raw);
+    return definition ? {
+        pageType: definition.id
+    } : `pageType must be one of ${AI_PAGE_TYPES.map((type)=>type.id).join(', ')}`;
+}
+/**
+ * What the plan asks to be created that a page job does not build, in the
+ * order the plan lists it, each named once: every entry is something a
+ * member makes first.
+ */ export function aiPagePlanPrerequisites(plan) {
+    const seen = new Set();
+    const prerequisites = [];
+    const add = (kind, name)=>{
+        const key = `${kind}:${name.toLowerCase()}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        prerequisites.push({
+            kind,
+            name
+        });
+    };
+    for (const entry of plan.create){
+        if (!AI_PAGE_CREATE_KINDS.includes(entry.kind)) add(entry.kind, entry.name);
+    }
+    // A reference the create list does not carry is refused by the plan rules
+    // before a plan is kept: rule 2 for a screen's layout, rule 7 for anything
+    // else (`plan-creation-undeclared`, AGL-3040). A plan confirmed before that
+    // rule existed can still carry one. It is named as a component: the
+    // reference carries no kind, and the refusal must say where one is made.
+    for (const { name } of aiPlanUndeclaredRefs(plan))add('component', name);
+    return prerequisites;
+}
+/**
+ * The creations a page job builds itself from its own plan (AGL-3031): the
+ * layout the page renders inside, and the forms and components it places.
+ * Each is built before the page, as a draft, by the step that builds that
+ * kind on its own. The plan step is told this list before it answers, and
+ * the plan rules refuse a creation outside it with the one re-ask every rule
+ * gets, so a plan that needs another never reaches a member's Confirm.
+ */ export const AI_PAGE_CREATE_KINDS = [
+    'layout',
+    'form',
+    'component'
+];
+/**
+ * Why a page job cannot build a plan of this SHAPE — no page, several pages,
+ * a page with no sections — in a sentence a member reads; `null` when the
+ * shape is one it builds. The plan step holds a plan to it with a re-ask, and
+ * the doors hold a confirmed plan to it again through `aiPagePlanRefusal`.
+ */ export function aiPagePlanShapeRefusal(plan) {
+    if (plan.screens.length === 0) {
+        return 'This plan has no page to build. Describe the page again.';
+    }
+    if (plan.screens.length > 1) {
+        return `This plan builds ${plan.screens.length} pages, and a page job builds one. Describe each page on its own.`;
+    }
+    if (!plan.screens[0].sections.length) {
+        return 'This plan’s page has no sections to build. Describe the page again.';
+    }
+    return null;
+}
+/**
+ * Why a page job cannot build this plan, in a sentence a member reads when
+ * confirming it; `null` when it can. A page job builds exactly one screen,
+ * from what the site already has.
+ */ export function aiPagePlanRefusal(plan) {
+    const shape = aiPagePlanShapeRefusal(plan);
+    if (shape) return shape;
+    const prerequisites = aiPagePlanPrerequisites(plan);
+    if (!prerequisites.length) return null;
+    const parts = prerequisites.map(({ kind, name })=>`the ${AI_BUILD_PLAN_CREATION_NOUNS[kind].noun} “${name}” ${AI_BUILD_PLAN_CREATION_NOUNS[kind].where}`);
+    const listed = parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`;
+    return `This page needs what the site does not have yet. Create ${listed}, then describe the page again.`;
+}
+/**
+ * Why a page job cannot build the creations its plan names ON THIS SITE NOW,
+ * in a sentence a member reads when confirming it: what the workspace's plan
+ * does not include, or what the site has no room left for. The plan step was
+ * told what could be created, so this is the site changing between the plan
+ * and its confirmation.
+ */ export function aiPageCreationRefusal(refused) {
+    if (!refused.length) return null;
+    const parts = refused.map(({ kind, name, reason })=>`the ${AI_BUILD_PLAN_CREATION_NOUNS[kind].noun} “${name}”, because ${reason}`);
+    const listed = parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join('; ')}; and ${parts[parts.length - 1]}`;
+    return `This page cannot be built as planned: it creates ${listed}. Describe the page again.`;
+}
+
+//# sourceMappingURL=ai-page-job.js.map

package/src/lib/model/ai-page-job.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/model/ai-page-job.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AI_BUILD_PLAN_CREATION_NOUNS,\n  aiPlanUndeclaredRefs,\n  type AiBuildPlan,\n  type AiBuildPlanCreateKind,\n} from './ai-build-plan'\nimport type { AiPlanUncreatable } from './ai-plan-capabilities'\n\n/**\n * What a page job is (AGL-2907): the page types a brief may name, the inputs\n * the job doors admit, and the plans a page generator can build.\n *\n * A page job builds ONE screen. It places the site's components by id, binds\n * its forms by id, and renders inside a layout — and since AGL-3031 it first\n * builds the layout, forms and components its own plan creates, in the same\n * job, through the steps that own them, so a doctrine-correct plan is one it\n * finishes rather than one it sends the member away from. Anything else a\n * plan creates — a template, a theme change, a dataset, an email — is another\n * job's work, and such a plan is refused before anything is spent, with a\n * sentence naming what to make first.\n *\n * This module imports nothing at runtime, so the doors, the step, the console\n * dialog and the specs read one vocabulary.\n */\n\nexport type AiPageType =\n  | 'landing'\n  | 'about'\n  | 'pricing'\n  | 'contact'\n  | 'blogIndex'\n  | 'product'\n  | 'service'\n  | 'event'\n\nexport interface AiPageTypeDefinition {\n  id: AiPageType\n  /** The chip's label in the Describe dialog. */\n  label: string\n  /** What the page is for, as the plan and the generation are told. */\n  purpose: string\n}\n\nexport const AI_PAGE_TYPES: readonly AiPageTypeDefinition[] = [\n  {\n    id: 'landing',\n    label: 'Landing',\n    purpose: 'a landing page that makes one offer and asks for one action',\n  },\n  {\n    id: 'about',\n    label: 'About',\n    purpose: 'an about page: who the business is, what it stands for and who is behind it',\n  },\n  {\n    id: 'pricing',\n    label: 'Pricing',\n    purpose: 'a pricing page: the plans or packages, what each includes and how to start',\n  },\n  {\n    id: 'contact',\n    label: 'Contact',\n    purpose: 'a contact page: how to reach the business, and where and when',\n  },\n  {\n    id: 'blogIndex',\n    label: 'Blog index',\n    purpose: 'a blog index that lists the posts of the site’s content collection',\n  },\n  {\n    id: 'product',\n    label: 'Product',\n    purpose: 'a page about one product: what it is, who it is for and how to get it',\n  },\n  {\n    id: 'service',\n    label: 'Service',\n    purpose: 'a page about one service: what it covers, how it works and how to book it',\n  },\n  {\n    id: 'event',\n    label: 'Event',\n    purpose: 'an event page: what it is, when and where, and how to attend',\n  },\n]\n\nconst PAGE_TYPE_BY_ID = new Map(AI_PAGE_TYPES.map((type) => [type.id, type]))\n\n/** The definition of a page type id, or `null` for anything else. */\nexport function aiPageTypeDefinition(id: unknown): AiPageTypeDefinition | null {\n  return typeof id === 'string' ? (PAGE_TYPE_BY_ID.get(id as AiPageType) ?? null) : null\n}\n\nexport interface AiPageJobInputs {\n  /** The type the member picked; `null` when they picked none. */\n  pageType: AiPageType | null\n}\n\n/** A page job's inputs, or the sentence the door refuses them with. */\nexport function parseAiPageJobInputs(\n  inputs: Readonly<Record<string, unknown>> | null | undefined,\n): AiPageJobInputs | string {\n  const raw = inputs?.['pageType']\n  if (raw === undefined || raw === null || raw === '') return { pageType: null }\n  const definition = aiPageTypeDefinition(raw)\n  return definition\n    ? { pageType: definition.id }\n    : `pageType must be one of ${AI_PAGE_TYPES.map((type) => type.id).join(', ')}`\n}\n\n/** A creation a plan names, as the refusal lists it. */\nexport interface AiPagePrerequisite {\n  kind: AiBuildPlanCreateKind\n  name: string\n}\n\n/**\n * What the plan asks to be created that a page job does not build, in the\n * order the plan lists it, each named once: every entry is something a\n * member makes first.\n */\nexport function aiPagePlanPrerequisites(plan: AiBuildPlan): AiPagePrerequisite[] {\n  const seen = new Set<string>()\n  const prerequisites: AiPagePrerequisite[] = []\n  const add = (kind: AiBuildPlanCreateKind, name: string) => {\n    const key = `${kind}:${name.toLowerCase()}`\n    if (seen.has(key)) return\n    seen.add(key)\n    prerequisites.push({ kind, name })\n  }\n  for (const entry of plan.create) {\n    if (!AI_PAGE_CREATE_KINDS.includes(entry.kind)) add(entry.kind, entry.name)\n  }\n  // A reference the create list does not carry is refused by the plan rules\n  // before a plan is kept: rule 2 for a screen's layout, rule 7 for anything\n  // else (`plan-creation-undeclared`, AGL-3040). A plan confirmed before that\n  // rule existed can still carry one. It is named as a component: the\n  // reference carries no kind, and the refusal must say where one is made.\n  for (const { name } of aiPlanUndeclaredRefs(plan)) add('component', name)\n  return prerequisites\n}\n\n/**\n * The creations a page job builds itself from its own plan (AGL-3031): the\n * layout the page renders inside, and the forms and components it places.\n * Each is built before the page, as a draft, by the step that builds that\n * kind on its own. The plan step is told this list before it answers, and\n * the plan rules refuse a creation outside it with the one re-ask every rule\n * gets, so a plan that needs another never reaches a member's Confirm.\n */\nexport const AI_PAGE_CREATE_KINDS: readonly AiBuildPlanCreateKind[] = ['layout', 'form', 'component']\n\n/**\n * Why a page job cannot build a plan of this SHAPE — no page, several pages,\n * a page with no sections — in a sentence a member reads; `null` when the\n * shape is one it builds. The plan step holds a plan to it with a re-ask, and\n * the doors hold a confirmed plan to it again through `aiPagePlanRefusal`.\n */\nexport function aiPagePlanShapeRefusal(plan: AiBuildPlan): string | null {\n  if (plan.screens.length === 0) {\n    return 'This plan has no page to build. Describe the page again.'\n  }\n  if (plan.screens.length > 1) {\n    return `This plan builds ${plan.screens.length} pages, and a page job builds one. Describe each page on its own.`\n  }\n  if (!plan.screens[0].sections.length) {\n    return 'This plan’s page has no sections to build. Describe the page again.'\n  }\n  return null\n}\n\n/**\n * Why a page job cannot build this plan, in a sentence a member reads when\n * confirming it; `null` when it can. A page job builds exactly one screen,\n * from what the site already has.\n */\nexport function aiPagePlanRefusal(plan: AiBuildPlan): string | null {\n  const shape = aiPagePlanShapeRefusal(plan)\n  if (shape) return shape\n  const prerequisites = aiPagePlanPrerequisites(plan)\n  if (!prerequisites.length) return null\n  const parts = prerequisites.map(\n    ({ kind, name }) => `the ${AI_BUILD_PLAN_CREATION_NOUNS[kind].noun} “${name}” ${AI_BUILD_PLAN_CREATION_NOUNS[kind].where}`,\n  )\n  const listed =\n    parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join(', ')} and ${parts[parts.length - 1]}`\n  return `This page needs what the site does not have yet. Create ${listed}, then describe the page again.`\n}\n\n/**\n * Why a page job cannot build the creations its plan names ON THIS SITE NOW,\n * in a sentence a member reads when confirming it: what the workspace's plan\n * does not include, or what the site has no room left for. The plan step was\n * told what could be created, so this is the site changing between the plan\n * and its confirmation.\n */\nexport function aiPageCreationRefusal(refused: readonly AiPlanUncreatable[]): string | null {\n  if (!refused.length) return null\n  const parts = refused.map(\n    ({ kind, name, reason }) => `the ${AI_BUILD_PLAN_CREATION_NOUNS[kind].noun} “${name}”, because ${reason}`,\n  )\n  const listed =\n    parts.length === 1 ? parts[0] : `${parts.slice(0, -1).join('; ')}; and ${parts[parts.length - 1]}`\n  return `This page cannot be built as planned: it creates ${listed}. Describe the page again.`\n}\n"],"names":["AI_BUILD_PLAN_CREATION_NOUNS","aiPlanUndeclaredRefs","AI_PAGE_TYPES","id","label","purpose","PAGE_TYPE_BY_ID","Map","map","type","aiPageTypeDefinition","get","parseAiPageJobInputs","inputs","raw","undefined","pageType","definition","join","aiPagePlanPrerequisites","plan","seen","Set","prerequisites","add","kind","name","key","toLowerCase","has","push","entry","create","AI_PAGE_CREATE_KINDS","includes","aiPagePlanShapeRefusal","screens","length","sections","aiPagePlanRefusal","shape","parts","noun","where","listed","slice","aiPageCreationRefusal","refused","reason"],"mappings":"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"}

package/src/lib/model/ai-permissions.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type { HostAccessRole } from '@aglyn/aglyn/foundation/definitions/organization.types';
+import type { PluginOrgPermissionDeclaration } from '@aglyn/aglyn/plugin-manager/plugin-entitlements';
+/**
+ * The two AI keys (AGL-2927): `ai.use` for the assistants, `ai.generate` for
+ * generation jobs and AI edits.
+ */
+export type AiPermission = 'ai.use' | 'ai.generate';
+/** The AI keys, in the order the editors render them. */
+export declare const AI_PERMISSION_KEYS: readonly AiPermission[];
+export declare function isAiPermission(value: unknown): value is AiPermission;
+/** One verdict per AI key. */
+export type AiPermissionVerdict = Record<AiPermission, boolean>;
+/**
+ * The AI keys as this plugin declares them into the org permission catalog
+ * (AGL-2927, AGL-2984): listed on the role editor, stored on custom roles and
+ * per-member overrides, and decided per site for a collaborator.
+ *
+ * Both are enforced at the AI doors themselves — the chat and copy
+ * assistant doors through `memberHasPermissionOnHost`, and every door built
+ * on `aiGateLadder` through its `permission` option — so a role that unticks
+ * one closes the door, not only the button.
+ *
+ * Owners, admins and editors hold both by default: editors work on content,
+ * the AI doors included. A viewer holds neither, because read-only includes
+ * asking the assistant nothing: a viewer spends none of the workspace's AI
+ * credits. A site collaborator holds both on a site where their host role
+ * may change content.
+ */
+export declare const AI_ORG_PERMISSIONS: readonly PluginOrgPermissionDeclaration[];
+/** What each host role grants of the AI keys, before any per-site toggle. */
+export declare const HOST_ROLE_AI_PERMISSIONS: Readonly<Record<HostAccessRole, AiPermissionVerdict>>;
+/** The AI keys of a verdict map the shell resolved; an absent key is refused. */
+export declare function aiPermissionsOf(granted: Readonly<Record<string, boolean>> | null | undefined): AiPermissionVerdict;

package/src/lib/model/ai-permissions.js

@@ -0,0 +1,97 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ /** The AI keys, in the order the editors render them. */ export const AI_PERMISSION_KEYS = [
+    'ai.use',
+    'ai.generate'
+];
+export function isAiPermission(value) {
+    return value === 'ai.use' || value === 'ai.generate';
+}
+/**
+ * The host roles that may change a site's content may also ask a model to
+ * change it. A viewer who cannot edit has nothing for a generation to land
+ * on, and would spend the workspace's credits producing it anyway.
+ */ const CONTENT_ROLES = {
+    admin: true,
+    editor: true,
+    author: true,
+    viewer: false
+};
+/**
+ * The AI keys as this plugin declares them into the org permission catalog
+ * (AGL-2927, AGL-2984): listed on the role editor, stored on custom roles and
+ * per-member overrides, and decided per site for a collaborator.
+ *
+ * Both are enforced at the AI doors themselves — the chat and copy
+ * assistant doors through `memberHasPermissionOnHost`, and every door built
+ * on `aiGateLadder` through its `permission` option — so a role that unticks
+ * one closes the door, not only the button.
+ *
+ * Owners, admins and editors hold both by default: editors work on content,
+ * the AI doors included. A viewer holds neither, because read-only includes
+ * asking the assistant nothing: a viewer spends none of the workspace's AI
+ * credits. A site collaborator holds both on a site where their host role
+ * may change content.
+ */ export const AI_ORG_PERMISSIONS = [
+    {
+        key: 'ai.use',
+        label: 'Use AI assistance',
+        description: 'Ask the assistant, rewrite copy with AI, and generate a section.',
+        roleDefaults: {
+            owner: true,
+            admin: true,
+            editor: true,
+            viewer: false
+        },
+        hostRoleDefaults: CONTENT_ROLES
+    },
+    {
+        key: 'ai.generate',
+        label: 'Generate with AI',
+        description: 'Run AI generation jobs and AI edits: pages, components, emails, campaigns, products, CRM, insights, workflows.',
+        roleDefaults: {
+            owner: true,
+            admin: true,
+            editor: true,
+            viewer: false
+        },
+        hostRoleDefaults: CONTENT_ROLES
+    }
+];
+const HOST_ROLES = [
+    'admin',
+    'editor',
+    'author',
+    'viewer'
+];
+/** What each host role grants of the AI keys, before any per-site toggle. */ export const HOST_ROLE_AI_PERMISSIONS = Object.fromEntries(HOST_ROLES.map((role)=>[
+        role,
+        Object.fromEntries(AI_ORG_PERMISSIONS.map((permission)=>{
+            var _permission_hostRoleDefaults;
+            return [
+                permission.key,
+                ((_permission_hostRoleDefaults = permission.hostRoleDefaults) == null ? void 0 : _permission_hostRoleDefaults[role]) === true
+            ];
+        }))
+    ]));
+/** The AI keys of a verdict map the shell resolved; an absent key is refused. */ export function aiPermissionsOf(granted) {
+    return {
+        'ai.use': (granted == null ? void 0 : granted['ai.use']) === true,
+        'ai.generate': (granted == null ? void 0 : granted['ai.generate']) === true
+    };
+}
+
+//# sourceMappingURL=ai-permissions.js.map

package/src/lib/model/ai-permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../libs/plugins/ai/src/lib/model/ai-permissions.ts"],"sourcesContent":["/**\n * @license\n * Copyright 2026 Aglyn LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport type { HostAccessRole } from '@aglyn/aglyn/foundation/definitions/organization.types'\nimport type { PluginOrgPermissionDeclaration } from '@aglyn/aglyn/plugin-manager/plugin-entitlements'\n\n/**\n * The two AI keys (AGL-2927): `ai.use` for the assistants, `ai.generate` for\n * generation jobs and AI edits.\n */\nexport type AiPermission = 'ai.use' | 'ai.generate'\n\n/** The AI keys, in the order the editors render them. */\nexport const AI_PERMISSION_KEYS: readonly AiPermission[] = ['ai.use', 'ai.generate']\n\nexport function isAiPermission(value: unknown): value is AiPermission {\n  return value === 'ai.use' || value === 'ai.generate'\n}\n\n/** One verdict per AI key. */\nexport type AiPermissionVerdict = Record<AiPermission, boolean>\n\n/**\n * The host roles that may change a site's content may also ask a model to\n * change it. A viewer who cannot edit has nothing for a generation to land\n * on, and would spend the workspace's credits producing it anyway.\n */\nconst CONTENT_ROLES: Readonly<Record<HostAccessRole, boolean>> = {\n  admin: true,\n  editor: true,\n  author: true,\n  viewer: false,\n}\n\n/**\n * The AI keys as this plugin declares them into the org permission catalog\n * (AGL-2927, AGL-2984): listed on the role editor, stored on custom roles and\n * per-member overrides, and decided per site for a collaborator.\n *\n * Both are enforced at the AI doors themselves — the chat and copy\n * assistant doors through `memberHasPermissionOnHost`, and every door built\n * on `aiGateLadder` through its `permission` option — so a role that unticks\n * one closes the door, not only the button.\n *\n * Owners, admins and editors hold both by default: editors work on content,\n * the AI doors included. A viewer holds neither, because read-only includes\n * asking the assistant nothing: a viewer spends none of the workspace's AI\n * credits. A site collaborator holds both on a site where their host role\n * may change content.\n */\nexport const AI_ORG_PERMISSIONS: readonly PluginOrgPermissionDeclaration[] = [\n  {\n    key: 'ai.use',\n    label: 'Use AI assistance',\n    description: 'Ask the assistant, rewrite copy with AI, and generate a section.',\n    roleDefaults: { owner: true, admin: true, editor: true, viewer: false },\n    hostRoleDefaults: CONTENT_ROLES,\n  },\n  {\n    key: 'ai.generate',\n    label: 'Generate with AI',\n    description:\n      'Run AI generation jobs and AI edits: pages, components, emails, campaigns, products, CRM, insights, workflows.',\n    roleDefaults: { owner: true, admin: true, editor: true, viewer: false },\n    hostRoleDefaults: CONTENT_ROLES,\n  },\n]\n\nconst HOST_ROLES: readonly HostAccessRole[] = ['admin', 'editor', 'author', 'viewer']\n\n/** What each host role grants of the AI keys, before any per-site toggle. */\nexport const HOST_ROLE_AI_PERMISSIONS: Readonly<Record<HostAccessRole, AiPermissionVerdict>> =\n  Object.fromEntries(\n    HOST_ROLES.map((role) => [\n      role,\n      Object.fromEntries(\n        AI_ORG_PERMISSIONS.map((permission) => [\n          permission.key,\n          permission.hostRoleDefaults?.[role] === true,\n        ]),\n      ) as AiPermissionVerdict,\n    ]),\n  ) as Record<HostAccessRole, AiPermissionVerdict>\n\n/** The AI keys of a verdict map the shell resolved; an absent key is refused. */\nexport function aiPermissionsOf(\n  granted: Readonly<Record<string, boolean>> | null | undefined,\n): AiPermissionVerdict {\n  return {\n    'ai.use': granted?.['ai.use'] === true,\n    'ai.generate': granted?.['ai.generate'] === true,\n  }\n}\n"],"names":["AI_PERMISSION_KEYS","isAiPermission","value","CONTENT_ROLES","admin","editor","author","viewer","AI_ORG_PERMISSIONS","key","label","description","roleDefaults","owner","hostRoleDefaults","HOST_ROLES","HOST_ROLE_AI_PERMISSIONS","Object","fromEntries","map","role","permission","aiPermissionsOf","granted"],"mappings":"AAAA;;;;;;;;;;;;;;;CAeC,GAWD,uDAAuD,GACvD,OAAO,MAAMA,qBAA8C;IAAC;IAAU;CAAc,CAAA;AAEpF,OAAO,SAASC,eAAeC,KAAc;IAC3C,OAAOA,UAAU,YAAYA,UAAU;AACzC;AAKA;;;;CAIC,GACD,MAAMC,gBAA2D;IAC/DC,OAAO;IACPC,QAAQ;IACRC,QAAQ;IACRC,QAAQ;AACV;AAEA;;;;;;;;;;;;;;;CAeC,GACD,OAAO,MAAMC,qBAAgE;IAC3E;QACEC,KAAK;QACLC,OAAO;QACPC,aAAa;QACbC,cAAc;YAAEC,OAAO;YAAMT,OAAO;YAAMC,QAAQ;YAAME,QAAQ;QAAM;QACtEO,kBAAkBX;IACpB;IACA;QACEM,KAAK;QACLC,OAAO;QACPC,aACE;QACFC,cAAc;YAAEC,OAAO;YAAMT,OAAO;YAAMC,QAAQ;YAAME,QAAQ;QAAM;QACtEO,kBAAkBX;IACpB;CACD,CAAA;AAED,MAAMY,aAAwC;IAAC;IAAS;IAAU;IAAU;CAAS;AAErF,2EAA2E,GAC3E,OAAO,MAAMC,2BACXC,OAAOC,WAAW,CAChBH,WAAWI,GAAG,CAAC,CAACC,OAAS;QACvBA;QACAH,OAAOC,WAAW,CAChBV,mBAAmBW,GAAG,CAAC,CAACE;gBAEtBA;mBAFqC;gBACrCA,WAAWZ,GAAG;gBACdY,EAAAA,+BAAAA,WAAWP,gBAAgB,qBAA3BO,4BAA6B,CAACD,KAAK,MAAK;aACzC;;KAEJ,GAC6C;AAElD,+EAA+E,GAC/E,OAAO,SAASE,gBACdC,OAA6D;IAE7D,OAAO;QACL,UAAUA,CAAAA,2BAAAA,OAAS,CAAC,SAAS,MAAK;QAClC,eAAeA,CAAAA,2BAAAA,OAAS,CAAC,cAAc,MAAK;IAC9C;AACF"}

package/src/lib/model/ai-plan-capabilities.d.ts

@@ -0,0 +1,139 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { type AiBuildPlan, type AiBuildPlanCreateKind } from './ai-build-plan';
+/**
+ * What a plan may create on one site (AGL-3030): the workspace's plan and the
+ * site's counts against its limits, narrowed to what the job itself builds.
+ *
+ * A plan that names a creation nothing can make is a dead end the member pays
+ * for twice: once for the plan, and again for the plan they describe after
+ * being told to make the creation by hand — which, on a workspace whose plan
+ * does not include it, they cannot. So the plan step is TOLD what may be
+ * created before it answers, and the plan rules refuse a creation outside it
+ * with the one re-ask every other rule gets.
+ *
+ * ── Where the doctrine builds inline ─────────────────────────────────────
+ *
+ * The building doctrine makes a repeat a reusable component and a form a
+ * saved form placed by id. A workspace whose plan keeps no reusable
+ * components can do neither: the create route refuses a component and a
+ * saved form on that entitlement. There, and only there, the doctrine builds
+ * inline instead — a form is a Form element the page carries with its fields
+ * inside it, which the site's submit route collects like any other, and a
+ * list's repeated items are drawn in one section (AGL-3071).
+ * `reusableComponents` is the one flag every validator reads for that.
+ *
+ * ── Kept out of the cached prefix ────────────────────────────────────────
+ *
+ * The capabilities are per workspace and per site, so they ride the plan's
+ * USER turn, never a system block: the doctrine's cached prefix stays one
+ * entry for the platform. The doctrine states the rule once — create only
+ * what the request says may be created, and build inline where it says the
+ * workspace keeps no reusable components — and the request states the facts.
+ *
+ * This module imports nothing at runtime beyond the plan's own model, so the
+ * validators, the plan step, the doors and their specs read one vocabulary.
+ * What a workspace's plan and counts come to is read by
+ * `readAiPlanCapabilities` in `jobs/ai-job-drafts.ts`, beside the band
+ * arithmetic the create route and the draft writer share.
+ */
+/** One creation kind, as a job on this site may make it or not. */
+export interface AiPlanCreation {
+    allowed: boolean;
+    /** How many more the site may hold; `null` when the plan counts none. */
+    left: number | null;
+    /**
+     * Why not, as a clause a sentence completes: "this workspace's plan does
+     * not include reusable components". `null` when allowed.
+     */
+    reason: string | null;
+}
+export interface AiPlanCapabilities {
+    /**
+     * Whether the workspace keeps reusable components and saved forms. Where
+     * it does not, the doctrine builds inline: a form is a Form element holding
+     * its fields, and a list's repeated items are drawn in one section.
+     */
+    reusableComponents: boolean;
+    /** Every creation kind a plan may name, and whether this job may make one here. */
+    create: Readonly<Record<AiBuildPlanCreateKind, AiPlanCreation>>;
+    /**
+     * Whether the workspace spends the Free taste, whose monthly credits are a
+     * wall (AGL-2925): a plan is then held to the sections the wall's worst
+     * case pays for (AGL-3070). Absent is `false`.
+     */
+    freeTaste?: boolean;
+}
+/** What a job of one kind builds from its own plan, where it builds only some creations. */
+export interface AiPlanJobScope {
+    /** The job as a refusal names it: "a page job". */
+    noun: string;
+    /** The creation kinds the job builds itself; any other is refused before the plan is kept. */
+    creates: readonly AiBuildPlanCreateKind[];
+}
+/**
+ * Capabilities that restrict nothing: what a plan is held to when no
+ * workspace was read — an org-level job, an eval, a spec about something
+ * else. The doctrine applies whole.
+ */
+export declare function aiUnrestrictedPlanCapabilities(): AiPlanCapabilities;
+/**
+ * The workspace's capabilities narrowed to what a job of one kind builds.
+ * A creation the workspace itself cannot make keeps the workspace's reason,
+ * which is the one a member can act on; one the job does not build says so.
+ */
+export declare function aiPlanCapabilitiesForJob(capabilities: AiPlanCapabilities, scope: AiPlanJobScope | null | undefined): AiPlanCapabilities;
+/** "a layout", "an email design": a creation kind with its article. */
+export declare function aiCreationNoun(kind: AiBuildPlanCreateKind): string;
+/**
+ * The sentence a request states when the workspace keeps no reusable
+ * components. It says a list's repeated items go in one section (AGL-3071):
+ * "a repeated item in its own section" reads just as well as a section for
+ * each item, which is how a live About page's four practice areas came to be
+ * planned as four sections of one item.
+ */
+export declare const AI_PLAN_INLINE_SENTENCE = "This workspace keeps no reusable components or saved forms: draw a list's repeated items in one section, and a form as a Form element holding its Form Fields.";
+/**
+ * What the plan step's user turn says the job may create here: one line a
+ * kind, and the inline sentence where the workspace keeps no reusable
+ * components. Per workspace and per site, so it is never a system block.
+ */
+export declare function aiPlanCapabilityLines(capabilities: AiPlanCapabilities): string[];
+/** One creation a plan names that this job may not make here. */
+export interface AiPlanUncreatable {
+    kind: AiBuildPlanCreateKind;
+    name: string;
+    /** The plan path of the creation: `create[2]`. */
+    path: string;
+    /** Why not, as a clause: "this site has room for 1 more". */
+    reason: string;
+    /** One customer-safe sentence: what was refused, why, and what to do instead. */
+    message: string;
+}
+/** The creations a plan names that the capabilities refuse, in plan order. */
+export declare function aiPlanUncreatable(plan: Pick<AiBuildPlan, 'create'>, capabilities: AiPlanCapabilities): AiPlanUncreatable[];
+/**
+ * Why the plan could not add one more creation of a kind here, and what to
+ * do instead; `null` when it could (AGL-3040). Counted past the creations of
+ * that kind the plan already names, as `aiPlanUncreatable` counts them, so a
+ * plan told to declare a creation is never told to declare one the next
+ * answer is refused for.
+ */
+export declare function aiPlanUncreatableKind(plan: Pick<AiBuildPlan, 'create'>, kind: AiBuildPlanCreateKind, capabilities: AiPlanCapabilities): {
+    reason: string;
+    instead: string;
+} | null;

package/src/lib/model/ai-plan-capabilities.js

@@ -0,0 +1,149 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { AI_BUILD_PLAN_CREATE_KINDS, AI_BUILD_PLAN_CREATION_NOUNS } from "./ai-build-plan.js";
+const ALLOWED = {
+    allowed: true,
+    left: null,
+    reason: null
+};
+/**
+ * Capabilities that restrict nothing: what a plan is held to when no
+ * workspace was read — an org-level job, an eval, a spec about something
+ * else. The doctrine applies whole.
+ */ export function aiUnrestrictedPlanCapabilities() {
+    return {
+        reusableComponents: true,
+        create: Object.fromEntries(AI_BUILD_PLAN_CREATE_KINDS.map((kind)=>[
+                kind,
+                ALLOWED
+            ]))
+    };
+}
+/**
+ * The workspace's capabilities narrowed to what a job of one kind builds.
+ * A creation the workspace itself cannot make keeps the workspace's reason,
+ * which is the one a member can act on; one the job does not build says so.
+ */ export function aiPlanCapabilitiesForJob(capabilities, scope) {
+    if (!scope) return capabilities;
+    const create = _extends({}, capabilities.create);
+    for (const kind of AI_BUILD_PLAN_CREATE_KINDS){
+        if (!create[kind].allowed || scope.creates.includes(kind)) continue;
+        create[kind] = {
+            allowed: false,
+            left: null,
+            reason: `${scope.noun} does not build one`
+        };
+    }
+    return _extends({}, capabilities, {
+        create
+    });
+}
+/** "a layout", "an email design": a creation kind with its article. */ export function aiCreationNoun(kind) {
+    const noun = AI_BUILD_PLAN_CREATION_NOUNS[kind].noun;
+    return `${/^[aeiou]/.test(noun) ? 'an' : 'a'} ${noun}`;
+}
+/**
+ * The sentence a request states when the workspace keeps no reusable
+ * components. It says a list's repeated items go in one section (AGL-3071):
+ * "a repeated item in its own section" reads just as well as a section for
+ * each item, which is how a live About page's four practice areas came to be
+ * planned as four sections of one item.
+ */ export const AI_PLAN_INLINE_SENTENCE = "This workspace keeps no reusable components or saved forms: draw a list's repeated items in one section, and a form as a Form element holding its Form Fields.";
+/**
+ * What the plan step's user turn says the job may create here: one line a
+ * kind, and the inline sentence where the workspace keeps no reusable
+ * components. Per workspace and per site, so it is never a system block.
+ */ export function aiPlanCapabilityLines(capabilities) {
+    const lines = [
+        'What this job may create on this site:'
+    ];
+    for (const kind of AI_BUILD_PLAN_CREATE_KINDS){
+        const entry = capabilities.create[kind];
+        const noun = AI_BUILD_PLAN_CREATION_NOUNS[kind].noun;
+        if (entry.allowed) {
+            lines.push(`- ${noun}: yes${entry.left === null ? '' : `, ${entry.left} more`}`);
+        } else {
+            var _entry_reason;
+            lines.push(`- ${noun}: no, because ${(_entry_reason = entry.reason) != null ? _entry_reason : 'it cannot be made here'}`);
+        }
+    }
+    if (!capabilities.reusableComponents) lines.push(AI_PLAN_INLINE_SENTENCE);
+    return lines;
+}
+/** What to do instead of a creation the job may not make, for the re-ask and the review. */ function insteadOf(kind, capabilities) {
+    switch(kind){
+        case 'component':
+            return capabilities.reusableComponents ? 'Place a component the site already has.' : "Draw a list's repeated items in one section instead.";
+        case 'form':
+            return capabilities.reusableComponents ? 'Place a form the site already has.' : 'Draw the form on the page instead, as a Form element holding its Form Fields.';
+        case 'layout':
+            return 'Put the page in a layout the site already has.';
+        case 'template':
+            return 'Build the page without a template.';
+        case 'theme-change':
+            return "Use the colors the theme already has.";
+        case 'dataset':
+            return 'Bind a dataset or collection the site already has, or keep the list short enough to write out.';
+        case 'email':
+            return 'Leave the email out of this job.';
+    }
+}
+/**
+ * Why the nth creation of a kind may not be made here, as a clause; `null`
+ * when it may. A kind the site may make only so many more of refuses the ones
+ * past that count, not the first of them.
+ */ function refusedReason(capability, nth) {
+    var _capability_reason;
+    const overCount = capability.allowed && capability.left !== null && nth > capability.left;
+    if (capability.allowed && !overCount) return null;
+    return overCount ? `this site has room for ${capability.left} more` : (_capability_reason = capability.reason) != null ? _capability_reason : 'it cannot be made here';
+}
+/** The creations a plan names that the capabilities refuse, in plan order. */ export function aiPlanUncreatable(plan, capabilities) {
+    const refused = [];
+    const counted = new Map();
+    plan.create.forEach((entry, index)=>{
+        var _counted_get;
+        const nth = ((_counted_get = counted.get(entry.kind)) != null ? _counted_get : 0) + 1;
+        counted.set(entry.kind, nth);
+        const reason = refusedReason(capabilities.create[entry.kind], nth);
+        if (reason === null) return;
+        refused.push({
+            kind: entry.kind,
+            name: entry.name,
+            path: `create[${index}]`,
+            reason,
+            message: `The plan creates ${aiCreationNoun(entry.kind)} named "${entry.name}", and ${reason}. ${insteadOf(entry.kind, capabilities)}`
+        });
+    });
+    return refused;
+}
+/**
+ * Why the plan could not add one more creation of a kind here, and what to
+ * do instead; `null` when it could (AGL-3040). Counted past the creations of
+ * that kind the plan already names, as `aiPlanUncreatable` counts them, so a
+ * plan told to declare a creation is never told to declare one the next
+ * answer is refused for.
+ */ export function aiPlanUncreatableKind(plan, kind, capabilities) {
+    const planned = plan.create.filter((entry)=>entry.kind === kind).length;
+    const reason = refusedReason(capabilities.create[kind], planned + 1);
+    return reason === null ? null : {
+        reason,
+        instead: insteadOf(kind, capabilities)
+    };
+}
+
+//# sourceMappingURL=ai-plan-capabilities.js.map