@agenticprimitives/ontology 1.0.0-alpha.21 → 1.0.0-alpha.23

package/dist/party-roles.d.ts

@@ -0,0 +1,106 @@
+/** An ontology class an agent must be an instance of, by IRI. */
+export type ClassIri = string;
+/** The T-box classes a party role may require. Names mirror `tbox/core.ttl` exactly. */
+export declare const AGENT_CLASS: {
+    readonly Agent: string;
+    readonly PersonAgent: string;
+    readonly OrganizationAgent: string;
+    readonly TeamAgent: string;
+    readonly WorkspaceAgent: string;
+    readonly ServiceAgent: string;
+    readonly Treasury: string;
+    readonly RegistryAgent: string;
+    readonly ChurchAgent: string;
+    readonly CircleAgent: string;
+    /** Spec 368 — the family's own agent: an organization-class agent chartered under a person. */
+    readonly HouseholdAgent: string;
+};
+/** The relationship a resolver may traverse to get from one agent to another. */
+/**
+ * THE VALUE RAIL — the classes that can be an end of a value move (spec 373).
+ *
+ * Money moves between ACCOUNTS. A person is who it is for; a treasury is where it goes; an organization
+ * pays from and is paid into the treasury it charters. This is the whole rule, said once, and
+ * `check:ontology-bindings` holds every `movesValue: true` role to it — so widening one back is a build
+ * failure rather than a payment that lands on somebody's person agent.
+ *
+ * It is a DECLARATION, and a declaration authorizes nothing. The gate that cannot be bypassed reads the
+ * payee's on-chain `atl:agentType` at the moment of acting (ADR-0061: the record is the authority, the
+ * typed name is a claim) and refuses when it is not a treasury.
+ */
+export declare const VALUE_HOLDING_CLASSES: readonly ClassIri[];
+/** May this class hold value — that is, be an end of a transfer? */
+export declare const holdsValue: (iri: string) => boolean;
+export declare const AGENT_RELATION: {
+    /** Child → the agent it was created under and belongs to. NEVER authority. */
+    readonly charteredUnder: string;
+    /** Parent → the agents created under it. The direction "what does alice hold" traverses. */
+    readonly charters: string;
+};
+/**
+ * The typed name suffix that names each class (ADR-0061). A suffix is a CLAIM about the derived type; the
+ * on-chain `ap:agentType` record is the authority and a mismatch fails closed. This map exists so a
+ * resolver can read a name's suffix as a class rather than as a magic string.
+ */
+export declare const CLASS_FOR_SUFFIX: Readonly<Record<string, ClassIri>>;
+export declare const SUFFIX_FOR_CLASS: Readonly<Record<ClassIri, string>>;
+/** The typed-name suffixes the rail admits (`treasury`), derived from the classes so the two cannot drift. */
+export declare const VALUE_HOLDING_SUFFIXES: readonly string[];
+/** Which side of the exchange a party is. */
+export type PartySide = 
+/** The agent whose authority the step spends. Defaults to the asker; never the counterparty. */
+'acting'
+/** The agent the step acts toward. Never the asker by default — "pay me" is not what "pay alice" means. */
+ | 'counterparty'
+/** The agent the step acts WITHIN — a parent an agent is chartered under. */
+ | 'context';
+export interface PartyRoleV1 {
+    /** The capability this role belongs to (`ap:capability` id, e.g. `treasury.payment.execute`). */
+    capability: string;
+    /** The argument that carries it. */
+    arg: string;
+    /** What it is called when a person is asked about it. */
+    word: string;
+    side: PartySide;
+    /**
+     * The classes this party may be, in the order a person means them. A resolver takes the first class
+     * anything answers to. ORDER IS SEMANTICS, not ranking: "an organization pays from its own balance"
+     * is why `OrganizationAgent` follows `Treasury` for a payer, and it is not a fallback.
+     */
+    requires: readonly ClassIri[];
+    /**
+     * The relationship to follow when the agent that WAS resolved is not one of `requires` — from the
+     * person you named to the thing of theirs the capability needs. Omitted ⇒ no traversal: the answer is
+     * the agent itself or a question.
+     */
+    traverse?: (typeof AGENT_RELATION)[keyof typeof AGENT_RELATION];
+    /**
+     * True when getting this party wrong cannot be undone. Such a party is never SUBSTITUTED silently: if
+     * nothing of the first required class answers, the person is asked, with what was found.
+     */
+    movesValue?: boolean;
+    /**
+     * A party that may be named by a CONTACT FACET rather than an agent — today, an email address. The
+     * person behind it has no agent yet; the resolver binds the agent their Home WILL deploy for that
+     * email (a counterfactual address, deterministic from the custodian derivation), and the act carries
+     * the address so the invitation can reach them. Declared per role: an email is a way to reach a
+     * person, so it names a PersonAgent party and nothing else.
+     */
+    alsoAccepts?: readonly ('email')[];
+}
+/**
+ * Every capability's parties. The Ask reads this to resolve names; the harness reads `side: 'acting'` to
+ * know whose authority a step spends.
+ */
+export declare const PARTY_ROLES: readonly PartyRoleV1[];
+/** The role for one capability argument, or undefined when the capability declares none. */
+export declare function partyRole(capability: string, arg: string): PartyRoleV1 | undefined;
+/** The typed-name suffixes a party may be, in order — what a name-based resolver filters on. */
+export declare function suffixesFor(role: PartyRoleV1 | undefined): readonly string[];
+/** Every argument whose party is the one acting — the authority a step spends. */
+export declare const ACTING_ARGS: ReadonlySet<string>;
+/** Arguments that are never the asker: you do not pay, message or invite yourself by saying someone's name. */
+export declare const COUNTERPARTY_ARGS: ReadonlySet<string>;
+/** Arguments where a wrong answer cannot be undone. */
+export declare const VALUE_ARGS: ReadonlySet<string>;
+//# sourceMappingURL=party-roles.d.ts.map

package/dist/party-roles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"party-roles.d.ts","sourceRoot":"","sources":["../src/party-roles.ts"],"names":[],"mappings":"AAuBA,iEAAiE;AACjE,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAC;AAQ9B,wFAAwF;AACxF,eAAO,MAAM,WAAW;;;;;;;;;;;IAWtB,+FAA+F;;CAEvF,CAAC;AAEX,iFAAiF;AACjF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,SAAS,QAAQ,EAA2B,CAAC;AAEjF,oEAAoE;AACpE,eAAO,MAAM,UAAU,QAAS,MAAM,KAAG,OAAqE,CAAC;AAG/G,eAAO,MAAM,cAAc;IACzB,8EAA8E;;IAE9E,4FAA4F;;CAEpF,CAAC;AAEX;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAW/D,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAE/D,CAAC;AAEF,8GAA8G;AAC9G,eAAO,MAAM,sBAAsB,EAAE,SAAS,MAAM,EAEA,CAAC;AAErD,6CAA6C;AAC7C,MAAM,MAAM,SAAS;AACnB,gGAAgG;AAC9F,QAAQ;AACV,2GAA2G;GACzG,cAAc;AAChB,6EAA6E;GAC3E,SAAS,CAAC;AAEd,MAAM,WAAW,WAAW;IAC1B,iGAAiG;IACjG,UAAU,EAAE,MAAM,CAAC;IACnB,oCAAoC;IACpC,GAAG,EAAE,MAAM,CAAC;IACZ,yDAAyD;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,SAAS,CAAC;IAChB;;;;OAIG;IACH,QAAQ,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,OAAO,cAAc,CAAC,CAAC;IAChE;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,SAAS,CAAC,OAAO,CAAC,EAAE,CAAC;CACpC;AAED;;;GAGG;AACH,eAAO,MAAM,WAAW,EAAE,SAAS,WAAW,EAuN7C,CAAC;AAEF,4FAA4F;AAC5F,wBAAgB,SAAS,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,WAAW,GAAG,SAAS,CAElF;AAED,gGAAgG;AAChG,wBAAgB,WAAW,CAAC,IAAI,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,MAAM,EAAE,CAM5E;AAED,kFAAkF;AAClF,eAAO,MAAM,WAAW,EAAE,WAAW,CAAC,MAAM,CAA6E,CAAC;AAC1H,+GAA+G;AAC/G,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAmF,CAAC;AACtI,uDAAuD;AACvD,eAAO,MAAM,UAAU,EAAE,WAAW,CAAC,MAAM,CAAsE,CAAC"}

package/dist/party-roles.js

@@ -0,0 +1,305 @@
+// Namespace base INLINED, not imported from ./index — index.ts re-exports this file, so importing NS back
+// reads it in TDZ and every IRI here becomes `undefined#Treasury` at module-eval. Identical to `NS.ap`,
+// and identical to the reason `grounded-vocabulary.ts` inlines the same constant.
+const AP_NS = 'https://agenticprimitives.dev/ns/core#';
+const AP = (local) => `${AP_NS}${local}`;
+/** The T-box classes a party role may require. Names mirror `tbox/core.ttl` exactly. */
+export const AGENT_CLASS = {
+    Agent: AP('Agent'),
+    PersonAgent: AP('PersonAgent'),
+    OrganizationAgent: AP('OrganizationAgent'),
+    TeamAgent: AP('TeamAgent'),
+    WorkspaceAgent: AP('WorkspaceAgent'),
+    ServiceAgent: AP('ServiceAgent'),
+    Treasury: AP('Treasury'),
+    RegistryAgent: AP('RegistryAgent'),
+    ChurchAgent: AP('ChurchAgent'),
+    CircleAgent: AP('CircleAgent'),
+    /** Spec 368 — the family's own agent: an organization-class agent chartered under a person. */
+    HouseholdAgent: AP('HouseholdAgent'),
+};
+/** The relationship a resolver may traverse to get from one agent to another. */
+/**
+ * THE VALUE RAIL — the classes that can be an end of a value move (spec 373).
+ *
+ * Money moves between ACCOUNTS. A person is who it is for; a treasury is where it goes; an organization
+ * pays from and is paid into the treasury it charters. This is the whole rule, said once, and
+ * `check:ontology-bindings` holds every `movesValue: true` role to it — so widening one back is a build
+ * failure rather than a payment that lands on somebody's person agent.
+ *
+ * It is a DECLARATION, and a declaration authorizes nothing. The gate that cannot be bypassed reads the
+ * payee's on-chain `atl:agentType` at the moment of acting (ADR-0061: the record is the authority, the
+ * typed name is a claim) and refuses when it is not a treasury.
+ */
+export const VALUE_HOLDING_CLASSES = [AGENT_CLASS.Treasury];
+/** May this class hold value — that is, be an end of a transfer? */
+export const holdsValue = (iri) => VALUE_HOLDING_CLASSES.includes(iri);
+export const AGENT_RELATION = {
+    /** Child → the agent it was created under and belongs to. NEVER authority. */
+    charteredUnder: AP('charteredUnder'),
+    /** Parent → the agents created under it. The direction "what does alice hold" traverses. */
+    charters: AP('charters'),
+};
+/**
+ * The typed name suffix that names each class (ADR-0061). A suffix is a CLAIM about the derived type; the
+ * on-chain `ap:agentType` record is the authority and a mismatch fails closed. This map exists so a
+ * resolver can read a name's suffix as a class rather than as a magic string.
+ */
+export const CLASS_FOR_SUFFIX = {
+    me: AGENT_CLASS.PersonAgent,
+    org: AGENT_CLASS.OrganizationAgent,
+    team: AGENT_CLASS.TeamAgent,
+    workspace: AGENT_CLASS.WorkspaceAgent,
+    treasury: AGENT_CLASS.Treasury,
+    svc: AGENT_CLASS.ServiceAgent,
+    registry: AGENT_CLASS.RegistryAgent,
+    church: AGENT_CLASS.ChurchAgent,
+    circle: AGENT_CLASS.CircleAgent,
+    household: AGENT_CLASS.HouseholdAgent,
+};
+export const SUFFIX_FOR_CLASS = Object.fromEntries(Object.entries(CLASS_FOR_SUFFIX).map(([suffix, iri]) => [iri, suffix]));
+/** The typed-name suffixes the rail admits (`treasury`), derived from the classes so the two cannot drift. */
+export const VALUE_HOLDING_SUFFIXES = VALUE_HOLDING_CLASSES
+    .map((c) => SUFFIX_FOR_CLASS[c])
+    .filter((s) => typeof s === 'string');
+/**
+ * Every capability's parties. The Ask reads this to resolve names; the harness reads `side: 'acting'` to
+ * know whose authority a step spends.
+ */
+export const PARTY_ROLES = [
+    {
+        capability: 'treasury.payment.execute', arg: 'payer', word: 'paying from', side: 'acting',
+        // THE VALUE RAIL (spec 373): an account pays. An organization is no exception — it pays from the
+        // treasury it charters, which `traverse` finds, and that is one hop, not a different kind of payer.
+        requires: VALUE_HOLDING_CLASSES,
+        traverse: AGENT_RELATION.charters,
+        movesValue: true,
+    },
+    {
+        capability: 'treasury.payment.execute', arg: 'payee', word: 'being paid', side: 'counterparty',
+        // AND AN ACCOUNT IS PAID. This read `[Treasury, OrganizationAgent, PersonAgent]` with the comment
+        // "paying a person directly is ordinary", and on 2026-09-08 it paid `carol.me` — a person, not an
+        // account — because the `aphh:householdPayee` chain landed on nothing and the resolver fell through to
+        // her. A person is who money is FOR; a treasury is where it GOES. "Send alice 20 USDC" means her
+        // treasury, and when she has marked none that is a question, never a payment to her.
+        requires: VALUE_HOLDING_CLASSES,
+        traverse: AGENT_RELATION.charters,
+        movesValue: true,
+    },
+    {
+        // CREDITED, NOT ACTING. The authority a funding spends is the FUNDER's (the next entry); the treasury
+        // is the account the act is about, inside the person's own tree. It read `acting` until
+        // `treasury.primary.declare` declared the same word `context` and the one-word-one-side gate made the
+        // disagreement visible — two honest local readings of one word is exactly the drift this table ends.
+        capability: 'treasury.fund', arg: 'treasury', word: 'the treasury', side: 'context',
+        requires: [AGENT_CLASS.Treasury],
+        traverse: AGENT_RELATION.charters,
+        movesValue: true,
+    },
+    {
+        // WHOSE AUTHORITY A FUNDING SPENDS. The tool declares `authorityArg: 'funder'`, and the word for it
+        // lived in a hand-kept map in the app — which is precisely the duplication this table exists to end.
+        // A faucet mint debits nobody, so this moves no value; it is still the party the mandate is read from.
+        capability: 'treasury.fund', arg: 'funder', word: 'funding it', side: 'acting',
+        requires: [AGENT_CLASS.Agent],
+        movesValue: false,
+    },
+    {
+        // "WHEN SOMEONE PAYS ME, IT GOES HERE" — the `ap:primaryPayee` role on the public charteredUnder
+        // edge (spec 355). The treasury is the party being MARKED, not one spending anything: declaring a
+        // preference moves no value and lets nobody spend. It must still be one of the owner's treasuries,
+        // which is what `requires` says and what a wrong answer is refused against.
+        // The treasury is the agent this statement is ABOUT and the one it is made WITHIN — your own tree,
+        // never someone else's. Not `counterparty`: a counterparty is somebody else, and "mark my treasury"
+        // is not an exchange with anyone.
+        capability: 'treasury.primary.declare', arg: 'treasury', word: 'to receive payments', side: 'context',
+        requires: [AGENT_CLASS.Treasury],
+        traverse: AGENT_RELATION.charters,
+        movesValue: false,
+    },
+    {
+        // WHOSE PREFERENCE IT IS. The holder is the object side of the edge, which is the only party the
+        // contract lets set a role on it — saying where your money should go is your say and nobody else's.
+        //
+        // NOT `owner`: that argument is already declared a COUNTERPARTY by `resolution.invitation.request`
+        // ("the person to ask"), and the derived sets are keyed by argument NAME across capabilities — so
+        // reusing it would have made this step's acting party one the resolver refuses to let be the asker.
+        // One word, one side, estate-wide; `check:ontology-bindings` now fails when that is broken.
+        capability: 'treasury.primary.declare', arg: 'holder', word: 'whose preference this is', side: 'acting',
+        requires: [AGENT_CLASS.Agent],
+        movesValue: false,
+    },
+    {
+        // WHO IS BEING RECORDED as living with you. Their own agent — a household member is a person, and a
+        // record naming an address nobody holds is a note to nobody.
+        capability: 'household.member.record', arg: 'member', word: 'in your household', side: 'context',
+        requires: [AGENT_CLASS.PersonAgent],
+        movesValue: false,
+    },
+    {
+        capability: 'messaging.direct.send', arg: 'sender', word: 'sending it', side: 'acting',
+        // Sending as you is acting as you. No traversal: a person's inbox is their own.
+        requires: [AGENT_CLASS.Agent],
+    },
+    {
+        capability: 'messaging.direct.send', arg: 'recipient', word: 'the person to message', side: 'counterparty',
+        // An inbox belongs to a person first. Someone who means the organization says so.
+        requires: [
+            AGENT_CLASS.PersonAgent, AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent,
+            AGENT_CLASS.CircleAgent, AGENT_CLASS.ChurchAgent, AGENT_CLASS.HouseholdAgent, AGENT_CLASS.ServiceAgent,
+        ],
+    },
+    {
+        // A STANDING INSTRUCTION IS THE OWNER'S OWN NOTE (spec 394): who declares it is the person asking — the
+        // record is theirs and nobody else's to write. Self-acting like the household record.
+        capability: 'context.instruction.declare', arg: 'holder', word: 'whose instruction this is', side: 'acting',
+        requires: [AGENT_CLASS.Agent],
+        movesValue: false,
+    },
+    {
+        // WHAT THE DEFAULT IS — an agent of theirs (a treasury to pay from, an organization to act as). Any agent:
+        // the role's kind is the CAPABILITY's to say, and the resolver revalidates at every use.
+        capability: 'context.instruction.declare', arg: 'value', word: 'the default', side: 'context',
+        requires: [AGENT_CLASS.Agent],
+        movesValue: false,
+    },
+    {
+        // A REQUEST IS THE REQUESTER'S OWN ACT (spec 393 W2 tail). Any agent may ask an organization to take on a
+        // goal; the organization is the CONTEXT (`org`, the resource) — "asking as you is an act of yours".
+        capability: 'coordination.endeavor.request', arg: 'requester', word: 'asking', side: 'acting',
+        requires: [AGENT_CLASS.Agent],
+    },
+    {
+        // AN OFFER IS THE OFFERER'S OWN ACT (spec 393 W2). Any agent may offer; the organization is the CONTEXT
+        // (`org`, the resource), never the party spending authority — a steward asked "I'll take the flyer step"
+        // at their organization offers as themselves, not as it.
+        capability: 'coordination.contribution.propose', arg: 'proposer', word: 'offering', side: 'acting',
+        requires: [AGENT_CLASS.Agent],
+    },
+    {
+        capability: 'resolution.invitation.request', arg: 'requester', word: 'asking', side: 'acting',
+        // Asking is an act of yours, bounded like any other. Any agent may ask.
+        requires: [AGENT_CLASS.Agent],
+    },
+    {
+        capability: 'resolution.invitation.request', arg: 'owner', word: 'the person to ask', side: 'counterparty',
+        // You ask the AGENT THAT HOLDS the thing you cannot reach — a person, or the organization whose
+        // treasury it is. Not the unlisted agent itself: if you could name that, you would not be asking.
+        requires: [AGENT_CLASS.PersonAgent, AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent],
+    },
+    {
+        capability: 'organization.membership.invite', arg: 'org', word: 'the organization', side: 'acting',
+        requires: [
+            AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent, AGENT_CLASS.WorkspaceAgent,
+            AGENT_CLASS.CircleAgent, AGENT_CLASS.ChurchAgent, AGENT_CLASS.HouseholdAgent,
+        ],
+    },
+    {
+        capability: 'organization.membership.invite', arg: 'invitee', word: 'being invited', side: 'counterparty',
+        // A member is ordinarily a person — and, spec 372 S3, may be a SERVICE agent: the identity an outside
+        // runtime acts as joins an organization the way anyone does, by invitation its steward signs, and what
+        // it may then do is the scoped grant that invitation carries. Order is semantics: inviting a person is
+        // the ordinary reading of a name, and a runtime is named by its typed `.svc` name.
+        requires: [AGENT_CLASS.PersonAgent, AGENT_CLASS.ServiceAgent],
+        // An invitation may go to someone with no agent yet: their email names the person, and the agent
+        // their Home will deploy for it is bound in its place (spec 315/321 email invite, now one flow).
+        alsoAccepts: ['email'],
+    },
+    {
+        // WHOSE ROSTER IS BEING READ. A read spends no authority, but it names a subject, and the subject is
+        // resolved like every other party: in the asker's PRIVATE tier ("Missio Nexus" is a name in their own
+        // links), or asked. Before this row the tool resolved its own argument — a naming-service lookup with
+        // the ADDRESSEE as the fallback — so a display name the naming service does not know silently became
+        // "the agent being asked", and a person asking about an organization was answered with their own
+        // (empty) roster. `acting`, not `context`: the arg NAME `org` is declared `acting` by the invite
+        // capability, and one word carries one side estate-wide (`check:ontology-bindings`).
+        capability: 'organization.membership.list', arg: 'org', word: 'the organization', side: 'acting',
+        requires: [
+            AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent, AGENT_CLASS.WorkspaceAgent,
+            AGENT_CLASS.CircleAgent, AGENT_CLASS.ChurchAgent, AGENT_CLASS.HouseholdAgent,
+        ],
+    },
+    {
+        // Spec 380 — WHOSE MEMBERS ARE CONSULTED. The organization is the acting side (its own roster, its own
+        // consult wire); resolved in the asker's private tier like the roster read above.
+        capability: 'organization.member.consult', arg: 'org', word: 'the organization', side: 'acting',
+        requires: [
+            AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent, AGENT_CLASS.WorkspaceAgent,
+            AGENT_CLASS.CircleAgent, AGENT_CLASS.ChurchAgent, AGENT_CLASS.HouseholdAgent,
+        ],
+    },
+    {
+        // Spec 380 — THE MEMBER ASKED. A person, answering through their own agent under their own opt-in;
+        // it arrives as an address from the roster's fan-out, never as a name to resolve.
+        capability: 'organization.member.consult', arg: 'respondent', word: 'the member being asked', side: 'counterparty',
+        requires: [AGENT_CLASS.PersonAgent],
+    },
+    // ── Spec 370 P4 — Work & Planning (specs 332–334) bound thinly onto the Endeavor substrate. ────────
+    // WHOSE WORK. Every coordination capability names the organization whose endeavors these are — the same
+    // word, the same side and the same classes as the roster read, so a display name resolves in the
+    // asker's private tier or is asked, never guessed from the addressee. The realm you stand in fills it
+    // (spec 367 §7) because these roles admit the organization classes.
+    ...['coordination.endeavor.list', 'coordination.endeavor.get', 'coordination.endeavor.request', 'coordination.contribution.propose', 'coordination.contribution.allocate', 'coordination.endeavor.satisfy'].map((capability) => ({
+        capability, arg: 'org', word: 'the organization', side: 'acting',
+        requires: [
+            AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent, AGENT_CLASS.WorkspaceAgent,
+            AGENT_CLASS.CircleAgent, AGENT_CLASS.ChurchAgent, AGENT_CLASS.HouseholdAgent,
+        ],
+    })),
+    {
+        // Spec 371 — WHOSE BALANCE. A treasury or an organization (an organization pays from its own balance —
+        // the same classes the payer role admits); unnamed ⇒ the asker's own treasuries, decided by the read.
+        capability: 'treasury.balance.read', arg: 'account', word: 'the account', side: 'acting',
+        requires: [AGENT_CLASS.Treasury, AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent, AGENT_CLASS.ChurchAgent, AGENT_CLASS.CircleAgent, AGENT_CLASS.HouseholdAgent],
+    },
+    {
+        // WHO IS ALLOCATED. A person — resolved among the asker's own links or the organization's roster.
+        capability: 'coordination.contribution.allocate', arg: 'participant', word: 'being allocated', side: 'counterparty',
+        requires: [AGENT_CLASS.PersonAgent],
+    },
+    {
+        // Spec 368 — a household is chartered under a PERSON, never inside an organization: it is the family's
+        // own agent, and the person who charters it is its first steward.
+        capability: 'household.create', arg: 'parent', word: 'the parent', side: 'context',
+        requires: [AGENT_CLASS.PersonAgent],
+    },
+    {
+        capability: 'organization.team.create', arg: 'parent', word: 'the parent', side: 'context',
+        requires: [AGENT_CLASS.WorkspaceAgent, AGENT_CLASS.OrganizationAgent],
+    },
+    {
+        capability: 'organization.create', arg: 'parent', word: 'the parent', side: 'context',
+        requires: [AGENT_CLASS.WorkspaceAgent, AGENT_CLASS.OrganizationAgent, AGENT_CLASS.PersonAgent],
+    },
+    {
+        capability: 'treasury.create', arg: 'parent', word: 'the parent', side: 'context',
+        requires: [AGENT_CLASS.PersonAgent, AGENT_CLASS.OrganizationAgent, AGENT_CLASS.TeamAgent, AGENT_CLASS.HouseholdAgent],
+    },
+    {
+        // Spec 372 S3 — a service agent (the identity an outside runtime acts as) belongs to the person or the
+        // organization that chartered it; a team or household charters none (their parent does).
+        capability: 'service.create', arg: 'parent', word: 'the parent', side: 'context',
+        requires: [AGENT_CLASS.PersonAgent, AGENT_CLASS.OrganizationAgent],
+    },
+];
+/** The role for one capability argument, or undefined when the capability declares none. */
+export function partyRole(capability, arg) {
+    return PARTY_ROLES.find((r) => r.capability === capability && r.arg === arg);
+}
+/** The typed-name suffixes a party may be, in order — what a name-based resolver filters on. */
+export function suffixesFor(role) {
+    if (!role)
+        return [];
+    // `ap:Agent` means "any agent", which narrows nothing — an empty list, not every suffix, because a
+    // resolver reads empty as "no constraint" and a full list as "these nine and no others".
+    if (role.requires.includes(AGENT_CLASS.Agent))
+        return [];
+    return role.requires.map((iri) => SUFFIX_FOR_CLASS[iri]).filter((s) => !!s);
+}
+/** Every argument whose party is the one acting — the authority a step spends. */
+export const ACTING_ARGS = new Set(PARTY_ROLES.filter((r) => r.side === 'acting').map((r) => r.arg));
+/** Arguments that are never the asker: you do not pay, message or invite yourself by saying someone's name. */
+export const COUNTERPARTY_ARGS = new Set(PARTY_ROLES.filter((r) => r.side === 'counterparty').map((r) => r.arg));
+/** Arguments where a wrong answer cannot be undone. */
+export const VALUE_ARGS = new Set(PARTY_ROLES.filter((r) => r.movesValue).map((r) => r.arg));
+//# sourceMappingURL=party-roles.js.map

package/dist/party-roles.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"party-roles.js","sourceRoot":"","sources":["../src/party-roles.ts"],"names":[],"mappings":"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"}

package/dist/plan-shapes.d.ts

@@ -0,0 +1,18 @@
+export interface FanOutRelation {
+    /** The relation whose object set may be enumerated — an ObjectProperty the T-box declares. */
+    relation: string;
+    /** Why this one is safe to fan out over, in a sentence a refusal can quote. */
+    because: string;
+    /** The most items one sentence may become. A cap is part of the meaning: "every member" of a
+     *  25-person org is a plan; of a 10,000-row search result it is an incident. */
+    maxItems: number;
+}
+/** Relations a plan step may fan out over. Everything else is refused BY NAME — absence is a decision
+ *  here, not an oversight, because an unlisted relation fails closed in the loop. */
+export declare const FAN_OUT_RELATIONS: readonly FanOutRelation[];
+/** Relations that resolve to ONE object by their meaning. A plan that fans out over one of these has
+ *  misread the domain — `primaryPayee` is "the one they want paid", and iterating it is a bug. */
+export declare const RESOLVE_TO_ONE_RELATIONS: readonly string[];
+/** The binding for a relation, or null — and null must FAIL CLOSED in the consumer. */
+export declare function fanOutBindingFor(relation: string): FanOutRelation | null;
+//# sourceMappingURL=plan-shapes.d.ts.map

package/dist/plan-shapes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-shapes.d.ts","sourceRoot":"","sources":["../src/plan-shapes.ts"],"names":[],"mappings":"AAkBA,MAAM,WAAW,cAAc;IAC7B,8FAA8F;IAC9F,QAAQ,EAAE,MAAM,CAAC;IACjB,+EAA+E;IAC/E,OAAO,EAAE,MAAM,CAAC;IAChB;oFACgF;IAChF,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;qFACqF;AACrF,eAAO,MAAM,iBAAiB,EAAE,SAAS,cAAc,EAWtD,CAAC;AAEF;kGACkG;AAClG,eAAO,MAAM,wBAAwB,EAAE,SAAS,MAAM,EAA0B,CAAC;AAEjF,uFAAuF;AACvF,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc,GAAG,IAAI,CAExE"}

package/dist/plan-shapes.js

@@ -0,0 +1,38 @@
+// WHAT A PLAN MAY FAN OUT OVER — spec 358 W4, in spec 355's discipline: the shape of the domain lives
+// here, bound by IRI, and the code that composes plans binds to it rather than knowing it.
+//
+// "Pay every member of the team 5 USDC" is one sentence and N acts. Whether the N is even ENUMERABLE is
+// a fact about the relation, not about the planner: a membership names a bounded, owner-recorded set an
+// organization can answer for; a public search result is an unbounded list of strangers and is not a
+// payee list, however array-shaped it arrives. Before this binding existed the difference lived nowhere,
+// and a planner that improvised a fan-out had nothing to refuse it.
+//
+// THE INVARIANT THIS SERVES (spec 351 §2.4.7): each fanned-out item re-enters the verifier as its own
+// step — a mandate per payment, judged alone. The binding never grants: it says which relations a plan
+// may ENUMERATE, and caps how many items one sentence may become. What each item may DO stays with the
+// mandate, exactly as if the person had asked N times.
+// Namespaces inlined for the same TDZ reason as every sibling binding in this package.
+const APORG = 'https://agenticprimitives.dev/ns/org#';
+const AP = 'https://agenticprimitives.dev/ns/core#';
+/** Relations a plan step may fan out over. Everything else is refused BY NAME — absence is a decision
+ *  here, not an oversight, because an unlisted relation fails closed in the loop. */
+export const FAN_OUT_RELATIONS = [
+    {
+        relation: `${APORG}memberAgent`,
+        because: 'a membership names a bounded, owner-recorded set the organization itself can answer for',
+        maxItems: 25,
+    },
+    {
+        relation: `${AP}charters`,
+        because: "the agents chartered under an owner are that owner's own bounded estate, recorded at genesis",
+        maxItems: 12,
+    },
+];
+/** Relations that resolve to ONE object by their meaning. A plan that fans out over one of these has
+ *  misread the domain — `primaryPayee` is "the one they want paid", and iterating it is a bug. */
+export const RESOLVE_TO_ONE_RELATIONS = [`${AP}primaryPayee`];
+/** The binding for a relation, or null — and null must FAIL CLOSED in the consumer. */
+export function fanOutBindingFor(relation) {
+    return FAN_OUT_RELATIONS.find((r) => r.relation === relation) ?? null;
+}
+//# sourceMappingURL=plan-shapes.js.map

package/dist/plan-shapes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-shapes.js","sourceRoot":"","sources":["../src/plan-shapes.ts"],"names":[],"mappings":"AAAA,sGAAsG;AACtG,2FAA2F;AAC3F,EAAE;AACF,wGAAwG;AACxG,wGAAwG;AACxG,qGAAqG;AACrG,yGAAyG;AACzG,oEAAoE;AACpE,EAAE;AACF,sGAAsG;AACtG,uGAAuG;AACvG,uGAAuG;AACvG,uDAAuD;AAEvD,uFAAuF;AACvF,MAAM,KAAK,GAAG,uCAAuC,CAAC;AACtD,MAAM,EAAE,GAAG,wCAAwC,CAAC;AAYpD;qFACqF;AACrF,MAAM,CAAC,MAAM,iBAAiB,GAA8B;IAC1D;QACE,QAAQ,EAAE,GAAG,KAAK,aAAa;QAC/B,OAAO,EAAE,yFAAyF;QAClG,QAAQ,EAAE,EAAE;KACb;IACD;QACE,QAAQ,EAAE,GAAG,EAAE,UAAU;QACzB,OAAO,EAAE,8FAA8F;QACvG,QAAQ,EAAE,EAAE;KACb;CACF,CAAC;AAEF;kGACkG;AAClG,MAAM,CAAC,MAAM,wBAAwB,GAAsB,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;AAEjF,uFAAuF;AACvF,MAAM,UAAU,gBAAgB,CAAC,QAAgB;IAC/C,OAAO,iBAAiB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,QAAQ,KAAK,QAAQ,CAAC,IAAI,IAAI,CAAC;AACxE,CAAC"}

package/dist/relations.d.ts

@@ -0,0 +1,44 @@
+export type RelationIri = string;
+export interface RelationAxiomV1 {
+    /** The relation, by IRI — the T-box must declare it as a property. */
+    iri: RelationIri;
+    /** Its inverse, when it has one. Declared `owl:inverseOf` in the T-box; both directions appear here
+     *  because a resolver walks whichever way the question is asked. */
+    inverseOf?: RelationIri;
+    /**
+     * The links this relation IS, in order, when it is a composition (`owl:propertyChainAxiom`).
+     *
+     * A chain is walked by following each link in turn. It is not a query language and will not become
+     * one: two links is what the domain has needed, the walker refuses a longer one than the axiom
+     * declares, and a relation that needs branching is a capability, not a cleverer chain.
+     */
+    chain?: readonly RelationIri[];
+    /** What the relation means in one line — for a person reading a trace, not for a reasoner. */
+    says: string;
+}
+/**
+ * Every relation a resolver may traverse.
+ *
+ * ONLY WHAT IS ACTUALLY WALKED. This is not a mirror of the ontology's properties — most of them are
+ * facts nobody follows at request time. A relation earns a row here when some capability's resolution
+ * depends on following it, which is also what makes the gate's demand reasonable.
+ */
+export declare const RELATION_AXIOMS: readonly RelationAxiomV1[];
+export declare function relationAxiom(iri: RelationIri): RelationAxiomV1 | undefined;
+/** The inverse of a relation, or undefined — undefined means "one direction only", not "unknown". */
+export declare function inverseOf(iri: RelationIri): RelationIri | undefined;
+/** The links a composed relation is, or null when it is primitive (which is most of them). */
+export declare function chainOf(iri: RelationIri): readonly RelationIri[] | null;
+/**
+ * Walk a declared chain from a subject, using a caller-supplied reader for each link.
+ *
+ * THE CALLER READS, THIS COMPOSES — the same split the decision plane uses. Only the caller knows where
+ * a link lives (a chain role, a vault record, a contract edge); only the axiom knows which links a
+ * relation is and in what order, and keeping that here is what stops a second capability writing its own
+ * two-step by hand.
+ *
+ * FAIL-CLOSED: a relation with no declared chain returns nothing rather than falling back to "just follow
+ * something" — an undeclared traversal is exactly the guess this table exists to remove.
+ */
+export declare function walkChain(iri: RelationIri, subject: string, follow: (link: RelationIri, from: string) => Promise<readonly string[]>): Promise<string[]>;
+//# sourceMappingURL=relations.d.ts.map

package/dist/relations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../src/relations.ts"],"names":[],"mappings":"AAyBA,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC;AAEjC,MAAM,WAAW,eAAe;IAC9B,sEAAsE;IACtE,GAAG,EAAE,WAAW,CAAC;IACjB;wEACoE;IACpE,SAAS,CAAC,EAAE,WAAW,CAAC;IACxB;;;;;;OAMG;IACH,KAAK,CAAC,EAAE,SAAS,WAAW,EAAE,CAAC;IAC/B,8FAA8F;IAC9F,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,SAAS,eAAe,EAoCrD,CAAC;AAEF,wBAAgB,aAAa,CAAC,GAAG,EAAE,WAAW,GAAG,eAAe,GAAG,SAAS,CAE3E;AAED,qGAAqG;AACrG,wBAAgB,SAAS,CAAC,GAAG,EAAE,WAAW,GAAG,WAAW,GAAG,SAAS,CAEnE;AAED,8FAA8F;AAC9F,wBAAgB,OAAO,CAAC,GAAG,EAAE,WAAW,GAAG,SAAS,WAAW,EAAE,GAAG,IAAI,CAGvE;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,SAAS,CAC7B,GAAG,EAAE,WAAW,EAChB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,CAAC,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,GACtE,OAAO,CAAC,MAAM,EAAE,CAAC,CAUnB"}