yarramate 0.22.0 → 0.23.0

package/catalogues/core-enrichment.yaml

@@ -1,12 +1,13 @@
 format: yarramate/question-catalogue/v1
 id: core-enrichment
-version: "0.8"
+version: "0.9"
 profile: yarramate/core@0.1
 presentation:
   title: Core enrichment interview
   description: >-
-    The guided design path: motivation, business, application, technology,
-    and implementation waves plus cross-cutting hygiene. Each question
+    The guided design path: motivation, interaction, business, application,
+    technology, and implementation waves plus cross-cutting hygiene. Each
+    question
     states the decision its answer changes; a question that cannot is
     deleted, not softened. Adequacy is enforced by linkage depth and
     attestation, never by reading words. Versioning is additive within a
@@ -18,6 +19,12 @@ waves:
   - id: motivation
     name: Motivation
     description: Why the system exists and what constrains it.
+  - id: interaction
+    name: Interaction
+    description: >-
+      Load-bearing hops: the behavior a component is assigned to, the
+      serving/triggering/flow mechanism, payload, trust, reliability, and
+      capacity. Hygiene waits.
   - id: business
     name: Business
     description: Who acts, what is served, and what information matters.
@@ -333,6 +340,398 @@ questions:
       attestation with topic "adequacy" (revoke by deleting it; Git
       reviews both).
 
+  # ---- interaction ---------------------------------------------------------
+  - id: authn-standard-missing
+    wave: interaction
+    since: "0.9"
+    scope: workspace
+    trigger:
+      - condition: exists-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#businessActor
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/policy@0.1#authentication-constraint
+    question: >-
+      What is the default authentication mechanism for interactions in this
+      architecture?
+    askPlain: >-
+      When one system talks to another here, how do they prove who they
+      are? Pick the default now so each hop is not inventing its own.
+    materiality: >-
+      An unauthenticated hop to another system is a trust-boundary decision
+      nobody recorded. Implementers will pick a mechanism in code, and the
+      next hop will assume a different one. This question does not cover
+      authorization or transport security.
+    authority: human
+    resolution: >-
+      Add an authentication-constraint (the standard, or a not-applicable
+      subject with the reason in its description) in a document that
+      selects yarramate/policy@0.1.
+
+  - id: ratelimit-standard-missing
+    wave: interaction
+    since: "0.9"
+    scope: workspace
+    trigger:
+      - condition: exists-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#businessActor
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/policy@0.1#rate-limit-constraint
+    question: >-
+      Where is rate limiting a requirement, and what is the default rule?
+    askPlain: >-
+      Do caller-facing APIs have a capacity cap? If yes, what is it? If
+      no, say so so we do not keep asking per hop.
+    materiality: >-
+      Caller-facing hops without a capacity rule are sized by whoever
+      implements first. An explicit none is a decision; silence is not.
+    authority: human
+    resolution: >-
+      Add a rate-limit-constraint for the default cap, or a
+      ratelimit-not-applicable subject. Bind hop-specific values with
+      expects on the binding.
+
+  - id: reliability-standard-missing
+    wave: interaction
+    since: "0.9"
+    scope: workspace
+    trigger:
+      - condition: exists-linkage
+        kinds:
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/policy@0.1#reliability-constraint
+    question: >-
+      What is the default delivery, retry, and idempotency rule for
+      asynchronous or content-moving interactions?
+    askPlain: >-
+      When a message or payload does not arrive, do we retry, and what
+      makes a retry safe to repeat?
+    materiality: >-
+      Retry without idempotency duplicates work; no retry without a
+      recorded choice leaves timeout behaviour to each implementer.
+    authority: human
+    resolution: >-
+      Add a reliability-constraint (the standard, or not-applicable with
+      the reason in its description).
+
+  - id: hop-unrealised
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationComponent
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#businessActor
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#assignment
+        direction: outgoing
+        counterpartKinds:
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#applicationInterface
+    question: >-
+      {subject.name} participates in an application interaction, but
+      nothing it is assigned to is that interaction. What process,
+      function, interaction, event, or interface is the hop?
+    askPlain: >-
+      {subject.name} talks to something else, but the model never names
+      the work it does in that talk. What is the actual step?
+    materiality: >-
+      A component-to-component edge with no assigned behavior is
+      inventory. Protocol, trust, payload, and failure have nowhere to
+      bind until the hop is a subject.
+    authority: either
+    resolution: >-
+      Add an application process, function, interaction, event, or
+      interface, assign this component to it, and relate that behavior
+      with serving, triggering, or flow to its counterpart. Do not answer
+      by deleting the component or adding a realization instead.
+
+  - id: interaction-protocol-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#mechanism-constraint
+    question: >-
+      {subject.name} is a serving hop. Which protocol is it — REST/HTTP,
+      SOAP, GraphQL, or something else?
+    askPlain: >-
+      When {subject.name} is called, what is the wire protocol?
+    materiality: >-
+      Serving names the pattern, not the contract. A REST hop and a SOAP
+      hop fail, version, and authenticate differently.
+    authority: either
+    resolution: >-
+      Bind a mechanism-constraint on this behavior (or a not-applicable
+      subject if the serving kind is already the whole answer).
+
+  - id: interaction-content-unknown
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: missing-flow-content
+    question: >-
+      {subject.name} sends a flow with no content. What moves?
+    askPlain: >-
+      {subject.name} sends something on. What is that something called?
+    materiality: >-
+      A flow with no content is an unnamed payload. Retry, scanning, and
+      the counterpart contract have nothing to name.
+    authority: either
+    resolution: >-
+      Set content on the flow relationship.
+
+  - id: interaction-contract-unknown
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-linkage
+        kinds:
+          - yarramate/core@0.1#access
+        direction: outgoing
+        counterpartKinds:
+          - yarramate/core@0.1#dataObject
+          - yarramate/core@0.1#contract
+    question: >-
+      {subject.name} participates in a hop but accesses no contract or
+      data object. What information does it read or write?
+    askPlain: >-
+      What record or contract is {subject.name} working with?
+    materiality: >-
+      Schema ownership, identifiers, and classification have nowhere to
+      attach until the hop names the information it moves.
+    authority: either
+    resolution: >-
+      Add access from this behavior to a dataObject or contract.
+
+  - id: interaction-trust-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+          - yarramate/core@0.1#flow
+          - yarramate/core@0.1#triggering
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#authentication-constraint
+    question: >-
+      How is trust established for {subject.name}?
+    askPlain: >-
+      Who does {subject.name} authenticate as, and with what?
+    materiality: >-
+      An unauthenticated hop to another system is a trust-boundary
+      decision nobody recorded. This is authentication only — not
+      authorization or transport security.
+    authority: either
+    resolution: >-
+      Bind an authentication-constraint on this behavior, or a
+      not-applicable subject if this hop is deliberately unauthenticated.
+
+  - id: interaction-reliability-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#triggering
+          - yarramate/core@0.1#flow
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#applicationComponent
+          - yarramate/core@0.1#applicationInterface
+          - yarramate/core@0.1#applicationProcess
+          - yarramate/core@0.1#applicationFunction
+          - yarramate/core@0.1#applicationInteraction
+          - yarramate/core@0.1#applicationEvent
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#reliability-constraint
+    question: >-
+      What happens when {subject.name} fails — retry, idempotency,
+      dead-letter, compensation?
+    askPlain: >-
+      If {subject.name} does not finish, do we retry, and what makes a
+      retry safe?
+    materiality: >-
+      A content-moving hop without a reliability rule duplicates or
+      drops work at the first timeout.
+    authority: either
+    resolution: >-
+      Bind a reliability-constraint. A named failure process is stronger
+      and may come later; the constraint is the 0.9 closer.
+
+  - id: interaction-capacity-unbound
+    wave: interaction
+    since: "0.9"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#applicationProcess
+        - yarramate/core@0.1#applicationFunction
+        - yarramate/core@0.1#applicationInteraction
+        - yarramate/core@0.1#applicationEvent
+        - yarramate/core@0.1#applicationInterface
+      statuses:
+        - planned
+        - current
+    trigger:
+      - condition: has-linkage
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: either
+        counterpartKinds:
+          - yarramate/core@0.1#businessActor
+      - condition: missing-constraint
+        kinds:
+          - yarramate/policy@0.1#rate-limit-constraint
+    question: >-
+      What is the capacity rule for {subject.name}?
+    askPlain: >-
+      How hard may callers hit {subject.name}, or is there no cap?
+    materiality: >-
+      An Experience-facing hop without a capacity rule is sized by
+      whoever implements first. Explicit none is a decision.
+    authority: either
+    resolution: >-
+      Bind a rate-limit-constraint, with expects on the binding for the
+      numeric cap, or a not-applicable subject.
+
   # ---- business ------------------------------------------------------------
   - id: service-consumer-unknown
     wave: business

package/dist/compiler.js

@@ -7,6 +7,7 @@ import documentSchema from '../schema/yarramate-document.schema.json' with { typ
 import profileSchema from '../schema/yarramate-profile.schema.json' with { type: 'json'
 };
 import { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue } from './graph-claims.js';
+import { shippedPolicyIdentity, shippedPolicySource, } from './shipped-profile.js';
 const coreProfile = 'yarramate/core@0.1';
 const require = createRequire(import.meta.url);
 const ajv2020Module = require('ajv/dist/2020.js');
@@ -283,6 +284,46 @@ function compileWorkspaceResolved(parsed) {
         const identity = `${value.id}@${value.version}`;
         pendingProfiles.push({ input, value, identity, positionFor });
     }
+    const alreadyDeclaresPolicy = pendingProfiles.some(({ identity }) => identity === shippedPolicyIdentity);
+    if (!alreadyDeclaresPolicy) {
+        const selected = documentInputs.some(({ entry }) => {
+            const value = entry.value;
+            return value.profile === shippedPolicyIdentity;
+        });
+        const extended = pendingProfiles.some(({ value }) => value.extends === shippedPolicyIdentity);
+        if (selected || extended) {
+            const input = {
+                path: 'yarramate:profile:yarramate/policy@0.1',
+                source: shippedPolicySource,
+            };
+            const { entry, fresh } = parseWorkspaceSource(input);
+            const value = entry.value;
+            if (entry.schemaDiagnostics.length > 0) {
+                profileDiagnostics.push(...entry.schemaDiagnostics);
+            }
+            else if (!validateProfile(value)) {
+                for (const error of validateProfile.errors ?? []) {
+                    profileDiagnostics.push({
+                        severity: 'error',
+                        code: 'YM201',
+                        message: `Profile schema violation: ${describeSchemaViolation(error)}`,
+                        path: input.path,
+                        pointer: error.instancePath || '/',
+                        line: 1,
+                        column: 1,
+                    });
+                }
+            }
+            else {
+                pendingProfiles.push({
+                    input,
+                    value,
+                    identity: shippedPolicyIdentity,
+                    positionFor: positionReader(input.source, entry.positions, fresh),
+                });
+            }
+        }
+    }
     let unresolvedProfiles = pendingProfiles.sort((left, right) => left.identity.localeCompare(right.identity) ||
         left.input.path.localeCompare(right.input.path));
     while (unresolvedProfiles.length > 0) {

package/dist/interrogate-command.d.ts

@@ -18,6 +18,7 @@ type CatalogueCondition = {
 } | {
     readonly condition: 'no-subject-of-kind';
     readonly kinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
 } | {
     readonly condition: 'no-state-defined';
 } | {
@@ -26,6 +27,24 @@ type CatalogueCondition = {
     readonly direction: 'incoming' | 'outgoing';
     readonly counterpartKinds: readonly string[];
     readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'has-linkage';
+    readonly kinds: readonly string[];
+    readonly direction: 'incoming' | 'outgoing' | 'either';
+    readonly counterpartKinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'exists-linkage';
+    readonly kinds: readonly string[];
+    readonly direction: 'incoming' | 'outgoing' | 'either';
+    readonly counterpartKinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'missing-constraint';
+    readonly kinds: readonly string[];
+    readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    readonly condition: 'missing-flow-content';
 } | {
     readonly condition: 'missing-reference';
     readonly predicate: string;

package/dist/interrogate-command.js

@@ -160,6 +160,54 @@ const relationshipKindMatches = (predicate, selectedKinds, matching, profileCont
         profileContext?.relationshipKindLineages
             .get(predicate)
             ?.includes(selected) === true));
+const profileIdentityOfKind = (qualifiedKind) => {
+    const separator = qualifiedKind.indexOf('#');
+    return separator === -1 ? qualifiedKind : qualifiedKind.slice(0, separator);
+};
+const namedKinds = (question) => {
+    const kinds = [...(question.subjects?.kinds ?? [])];
+    for (const condition of question.trigger) {
+        switch (condition.condition) {
+            case 'missing-relationship':
+            case 'no-subject-of-kind':
+            case 'missing-constraint':
+                kinds.push(...condition.kinds);
+                break;
+            case 'missing-linkage':
+            case 'has-linkage':
+            case 'exists-linkage':
+                kinds.push(...condition.kinds, ...condition.counterpartKinds);
+                break;
+            default:
+                break;
+        }
+    }
+    return kinds;
+};
+const questionIsApplicable = (question, selectedProfiles) => {
+    const selected = new Set(selectedProfiles);
+    return namedKinds(question).every((kind) => selected.has(profileIdentityOfKind(kind)));
+};
+const linkageHits = (index, condition, subjectId, profileContext) => {
+    const matching = condition.kindMatching ?? 'descendants';
+    return index.relationshipClaims.some((claim) => {
+        if (!('ref' in claim.object))
+            return false;
+        if (!relationshipKindMatches(claim.predicate, condition.kinds, matching, profileContext)) {
+            return false;
+        }
+        const counterparts = [];
+        if ((condition.direction === 'outgoing' || condition.direction === 'either') &&
+            claim.subject === subjectId) {
+            counterparts.push(claim.object.ref);
+        }
+        if ((condition.direction === 'incoming' || condition.direction === 'either') &&
+            claim.object.ref === subjectId) {
+            counterparts.push(claim.subject);
+        }
+        return counterparts.some((counterpart) => kindMatches(index.kindOf.get(counterpart), condition.counterpartKinds, matching, profileContext));
+    });
+};
 const conditionHolds = (index, condition, subjectId, profileContext) => {
     switch (condition.condition) {
         case 'missing-claim':
@@ -184,31 +232,43 @@ const conditionHolds = (index, condition, subjectId, profileContext) => {
             return (!index.relationshipClaims.some(({ subject, object }) => subject === subjectId ||
                 ('ref' in object && object.ref === subjectId)) &&
                 !index.referenceClaims.some(({ object }) => 'ref' in object && object.ref === subjectId));
-        case 'no-subject-of-kind':
-            return ![...index.concepts].some((id) => condition.kinds.includes(index.kindOf.get(id) ?? ''));
+        case 'no-subject-of-kind': {
+            const matching = condition.kindMatching ?? 'descendants';
+            return ![...index.concepts].some((id) => kindMatches(index.kindOf.get(id), condition.kinds, matching, profileContext));
+        }
         case 'no-state-defined':
             return !index.hasStates;
-        case 'missing-linkage': {
+        case 'missing-linkage':
             // The linkage-depth primitive: the subject lacks a relationship of
             // these kinds, in this direction, whose counterpart is of one of
             // these kinds. Both relationship and counterpart kinds resolve
             // through profile lineage by default, matching the selector rule.
+            return !linkageHits(index, condition, subjectId, profileContext);
+        case 'has-linkage':
+            return (subjectId !== undefined &&
+                linkageHits(index, condition, subjectId, profileContext));
+        case 'exists-linkage':
+            return [...index.concepts].some((id) => linkageHits(index, condition, id, profileContext));
+        case 'missing-constraint': {
             const matching = condition.kindMatching ?? 'descendants';
-            return !index.relationshipClaims.some((claim) => {
+            return !(index.claimsBySubject.get(subjectId) ?? []).some((claim) => claim.predicate === 'yarramate/constraint/requires' &&
+                'ref' in claim.object &&
+                kindMatches(index.kindOf.get(claim.object.ref), condition.kinds, matching, profileContext));
+        }
+        case 'missing-flow-content': {
+            if (subjectId === undefined)
+                return false;
+            const matching = 'descendants';
+            return index.relationshipClaims.some((claim) => {
                 if (!('ref' in claim.object))
                     return false;
-                if (!relationshipKindMatches(claim.predicate, condition.kinds, matching, profileContext)) {
+                if (!relationshipKindMatches(claim.predicate, ['yarramate/core@0.1#flow'], matching, profileContext)) {
                     return false;
                 }
-                const counterpart = condition.direction === 'outgoing'
-                    ? claim.subject === subjectId
-                        ? claim.object.ref
-                        : undefined
-                    : claim.object.ref === subjectId
-                        ? claim.subject
-                        : undefined;
-                return (counterpart !== undefined &&
-                    kindMatches(index.kindOf.get(counterpart), condition.counterpartKinds, matching, profileContext));
+                if (claim.subject !== subjectId && claim.object.ref !== subjectId) {
+                    return false;
+                }
+                return !(index.claimsBySubject.get(claim.id) ?? []).some(({ predicate, object }) => predicate === 'yarramate/flow/content' && 'value' in object);
             });
         }
         case 'missing-reference':
@@ -278,10 +338,11 @@ export function evaluateCatalogue(catalogue, graph, profileContext) {
     const index = indexGraph(graph);
     let open = 0;
     let openQuestions = 0;
+    const applicableQuestions = catalogue.questions.filter((question) => questionIsApplicable(question, graph.profiles));
     const waves = catalogue.waves.map((wave) => ({
         id: wave.id,
         name: wave.name,
-        questions: catalogue.questions
+        questions: applicableQuestions
             .filter((question) => question.wave === wave.id)
             .map((question) => {
             const base = {
@@ -325,7 +386,7 @@ export function evaluateCatalogue(catalogue, graph, profileContext) {
         format: 'yarramate/interrogation-report/v1',
         catalogue: `${catalogue.id}@${catalogue.version}`,
         summary: {
-            questions: catalogue.questions.length,
+            questions: applicableQuestions.length,
             openQuestions,
             open,
         },

package/dist/shipped-profile.d.ts

@@ -0,0 +1,2 @@
+export declare const shippedPolicyIdentity = "yarramate/policy@0.1";
+export declare const shippedPolicySource: string;

package/dist/shipped-profile.js

@@ -0,0 +1,6 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+export const shippedPolicyIdentity = 'yarramate/policy@0.1';
+const here = dirname(fileURLToPath(import.meta.url));
+export const shippedPolicySource = readFileSync(join(here, '..', 'profiles', 'yarramate-policy.yaml'), 'utf8');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {
@@ -26,6 +26,7 @@
     "assets/likec4",
     "schema",
     "catalogues",
+    "profiles",
     "skills/yarramate-architecture",
     "docs/CONSUMING-YARRAMATE.md"
   ],

package/profiles/yarramate-policy.yaml

@@ -0,0 +1,18 @@
+format: yarramate/profile/v1
+id: yarramate/policy
+version: "0.1"
+extends: yarramate/core@0.1
+conceptKinds:
+  - id: authentication-constraint
+    name: Authentication constraint
+    parent: yarramate/core@0.1#constraint
+  - id: rate-limit-constraint
+    name: Rate-limit constraint
+    parent: yarramate/core@0.1#constraint
+  - id: reliability-constraint
+    name: Reliability constraint
+    parent: yarramate/core@0.1#constraint
+  - id: mechanism-constraint
+    name: Mechanism constraint
+    parent: yarramate/core@0.1#constraint
+relationshipKinds: []

package/schema/yarramate-question-catalogue.schema.json

@@ -290,7 +290,139 @@
               "enum": [
                 "exact",
                 "descendants"
+              ],
+              "default": "descendants"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "condition",
+            "kinds",
+            "direction",
+            "counterpartKinds"
+          ],
+          "properties": {
+            "condition": {
+              "const": "has-linkage"
+            },
+            "kinds": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/qualifiedKind"
+              }
+            },
+            "direction": {
+              "enum": [
+                "outgoing",
+                "incoming",
+                "either"
               ]
+            },
+            "counterpartKinds": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/qualifiedKind"
+              }
+            },
+            "kindMatching": {
+              "enum": [
+                "exact",
+                "descendants"
+              ],
+              "default": "descendants"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "condition",
+            "kinds",
+            "direction",
+            "counterpartKinds"
+          ],
+          "properties": {
+            "condition": {
+              "const": "exists-linkage"
+            },
+            "kinds": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/qualifiedKind"
+              }
+            },
+            "direction": {
+              "enum": [
+                "outgoing",
+                "incoming",
+                "either"
+              ]
+            },
+            "counterpartKinds": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/qualifiedKind"
+              }
+            },
+            "kindMatching": {
+              "enum": [
+                "exact",
+                "descendants"
+              ],
+              "default": "descendants"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "required": [
+            "condition",
+            "kinds"
+          ],
+          "properties": {
+            "condition": {
+              "const": "missing-constraint"
+            },
+            "kinds": {
+              "type": "array",
+              "minItems": 1,
+              "uniqueItems": true,
+              "items": {
+                "$ref": "#/$defs/qualifiedKind"
+              }
+            },
+            "kindMatching": {
+              "enum": [
+                "exact",
+                "descendants"
+              ],
+              "default": "descendants"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "additionalProperties": false,
+          "description": "The subject is an endpoint of at least one flow relationship that has no yarramate/flow/content claim.",
+          "required": [
+            "condition"
+          ],
+          "properties": {
+            "condition": {
+              "const": "missing-flow-content"
             }
           }
         },

package/skills/yarramate-architecture/SKILL.md

@@ -140,15 +140,24 @@ yarramate design .yarramate/workspace.yaml
    or read catalogue files. Answer one question at a time: questions the
    model or evidence can answer, answer from your authority; questions
    marked `human`, relay verbatim with their materiality. Land each answer
-   as one atomic batch (`yarramate apply <operations.yaml>
-   .yarramate/workspace.yaml`), then re-run `design` — the next question is
-   recomputed from the model, so the loop is resumable across sessions and
-   agents with no handover. Use `--subject <id>` to focus the interview on
-   one element. When a step reports many `openSubjects` sharing one
-   question (ownership is the classic case), do not interview N times:
-   collect the policy answer once — "who owns what, by area" — and land it
-   across every listed subject as one apply batch. The interview is
-   complete when `design` says so.
+   as subjects and relationships in one atomic batch (`yarramate apply
+   <operations.yaml> .yarramate/workspace.yaml`), never as description
+   alone. Then re-run `design` — the next question is recomputed from the
+   model, so the loop is resumable across sessions and agents with no
+   handover. Use `--subject <id>` to focus the interview on one element.
+   When a step reports many `openSubjects` sharing one question (ownership
+   is the classic case), do not interview N times: collect the policy
+   answer once — "who owns what, by area" — and land it across every listed
+   subject as one apply batch.
+
+   After motivation, work the `interaction` wave (hops, mechanism, payload,
+   trust, reliability, capacity) before ownership and hygiene. Policy
+   subjects (`authentication-constraint`, `rate-limit-constraint`, and
+   siblings) live in a document that selects `yarramate/policy@0.1`; hops
+   bind them with qualified `constraints[].ref`. One batch may create and
+   bind. When `design --json` returns a step whose `wave` is not
+   `interaction` for the slice in focus, stop, render the brief, and do not
+   drain `owner-missing`. The interview is complete when `design` says so.
 5. Create:
    - an alternatives projection for the decision;
    - a bounded target projection for implementation agents.

package/skills/yarramate-architecture/references/native-authoring.md

@@ -200,6 +200,16 @@ rationale in the description and it becomes the non-goal record.
 Ownership is one accountable reference, not approval workflow. Constraints are
 identified references, not a policy engine or free-form metadata bag.
 
+Distinct NFR rules (authentication, rate limit, reliability, serving
+protocol) use `yarramate/policy@0.1` kinds, not Core `constraint` alone.
+Select that profile on the document that declares the policy subjects;
+other documents may keep their existing profile and bind with a
+qualified `constraints[].ref`. Do not copy a profile file into the
+workspace. A hop that must not have a rate limit binds a
+`ratelimit-not-applicable` subject of kind `rate-limit-constraint` with
+the reason in its description. Numeric caps go in `expects` on the
+binding.
+
 ## Attestations
 
 ```yaml