yarramate 1.34.0 → 1.36.0

package/catalogues/core-enrichment.yaml

@@ -907,9 +907,6 @@ questions:
     subjects:
       kinds:
         - yarramate/policy@0.3#risk
-      statuses:
-        - planned
-        - current
     trigger:
       - condition: missing-linkage
         kinds:
@@ -939,8 +936,6 @@ questions:
     subjects:
       kinds:
         - yarramate/policy@0.3#risk
-      statuses:
-        - current
     trigger:
       - condition: missing-linkage
         kinds:
@@ -955,11 +950,11 @@ questions:
     question: >-
       What mitigates {subject.name}?
     askPlain: >-
-      "{subject.name}" is live. What work, deliverable, rule or decision is in
-      place to reduce it?
+      "{subject.name}" is on the log. What work, deliverable, rule or decision
+      is in place, or planned, to reduce it?
     materiality: >-
-      A live risk with no mitigation is a bet the engagement is making without
-      saying so; the log exists to make that visible.
+      A risk on the log with no mitigation is a bet the engagement is making
+      without saying so; the log exists to make that visible.
     authority: either
     resolution: >-
       Add an `influence` relationship from the work package, deliverable,
@@ -971,9 +966,6 @@ questions:
     subjects:
       kinds:
         - yarramate/policy@0.3#risk
-      statuses:
-        - planned
-        - current
     trigger:
       - condition: missing-claim
         predicate: yarramate/ownership/owner
@@ -995,9 +987,6 @@ questions:
     subjects:
       kinds:
         - yarramate/policy@0.3#assumption
-      statuses:
-        - planned
-        - current
     trigger:
       - condition: missing-attestation
         topic: assumption-confirmed
@@ -1021,9 +1010,6 @@ questions:
     subjects:
       kinds:
         - yarramate/policy@0.3#assumption
-      statuses:
-        - planned
-        - current
     trigger:
       - condition: missing-relationship
         kinds:

package/dist/adapters/visual/protocol-contract.d.ts

@@ -255,6 +255,16 @@ export interface VisualFilterQueryPayload {
      * exactly as it did before.
      */
     readonly nesting?: readonly NestingKind[];
+    /**
+     * Whether the view shows responsibility edges (#563, ADR 0161).
+     *
+     * Only the `connected` walk reads it: a responsibility edge the canvas hides
+     * must not bring a person into the picture, and one the canvas shows must.
+     * Optional, so an older browser and every filter that does not send it
+     * evaluate as a view with the flag off, which is what the canvas draws by
+     * default.
+     */
+    readonly showResponsibility?: boolean;
 }
 export interface VisualFilterResultPayload {
     readonly query: ProjectionQuery;

package/dist/adapters/visual/session-server.js

@@ -680,7 +680,7 @@ export const startVisualServer = async (options) => {
         if (!started.ok)
             standingDiagnostics = started.diagnostics;
     }
-    const filterMatchedIds = (query, nesting) => compiledWorkspace === undefined
+    const filterMatchedIds = (query, nesting, showResponsibility) => compiledWorkspace === undefined
         ? []
         : matchedIdsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext, 
         // A view's query can name `instances`, and the facet resolves to the
@@ -688,7 +688,9 @@ export const startVisualServer = async (options) => {
         compiledWorkspace.patternMemberships, 
         // And it resolves the WRONG closure without the nesting the canvas is
         // drawing with, which is a wrong number rather than a missing one.
-        nesting);
+        nesting, 
+        // And the walk reads the responsibility flag (#563).
+        showResponsibility);
     /**
      * Why a query dropped what it dropped, as the editor's "excluded, and why"
      * list reads it (#248).
@@ -700,9 +702,9 @@ export const startVisualServer = async (options) => {
      * the reason the editor shows and the set the canvas draws cannot come from
      * two readings of the same query.
      */
-    const filterExclusions = (query, nesting) => compiledWorkspace === undefined
+    const filterExclusions = (query, nesting, showResponsibility) => compiledWorkspace === undefined
         ? []
-        : exclusionsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext, compiledWorkspace.patternMemberships, nesting);
+        : exclusionsOf(compiledWorkspace.graph, query, compiledWorkspace.profileContext, compiledWorkspace.patternMemberships, nesting, showResponsibility);
     let listening = false;
     let bootstrapSpent = false;
     let agentAttached = false;
@@ -1255,8 +1257,8 @@ export const startVisualServer = async (options) => {
                     kind: "filter-result",
                     result: {
                         query: event.payload.query,
-                        matchedIds: filterMatchedIds(event.payload.query, event.payload.nesting),
-                        excluded: filterExclusions(event.payload.query, event.payload.nesting),
+                        matchedIds: filterMatchedIds(event.payload.query, event.payload.nesting, event.payload.showResponsibility),
+                        excluded: filterExclusions(event.payload.query, event.payload.nesting, event.payload.showResponsibility),
                     },
                 });
                 return;

package/dist/adapters/visual/workspace-model.d.ts

@@ -57,7 +57,7 @@ export declare const patternOptionsOf: (patterns: readonly PatternShape[], linea
  * subject count. A view over three components with two relationships between
  * them would read as five, and the reviewer counting boxes would find three.
  */
-export declare const conceptCountOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[]) => number;
+export declare const conceptCountOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[], showResponsibility?: boolean) => number;
 /**
  * Folds one interrogation report into what the canvas draws (#292).
  *
@@ -125,9 +125,9 @@ export declare const renderedWorkspaceOf: (compiled: {
     readonly views: readonly VisualViewSummary[];
 };
 /** Every subject a query draws, concepts and relationships alike. */
-export declare const matchedIdsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[]) => readonly string[];
+export declare const matchedIdsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[], showResponsibility?: boolean) => readonly string[];
 /** Every concept a query dropped, and the facet that dropped it (#248). */
-export declare const exclusionsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[]) => readonly ProjectionExclusion[];
+export declare const exclusionsOf: (graph: SemanticGraph, query: ProjectionQuery, profileContext: ResolvedProfileContext, memberships?: readonly CataloguePatternMembership[], nesting?: readonly NestingKind[], showResponsibility?: boolean) => readonly ProjectionExclusion[];
 /**
  * One saved view, as the rail reads it. `subjectCount` is the caller's,
  * because counting needs a compiled graph and a session builds its first list

package/dist/adapters/visual/workspace-model.js

@@ -104,7 +104,7 @@ const wiringOf = (pattern, slot) => {
  * subject count. A view over three components with two relationships between
  * them would read as five, and the reviewer counting boxes would find three.
  */
-export const conceptCountOf = (graph, query, profileContext, memberships, nesting) => evaluateProjection(graph, adHoc(query, nesting), profileContext, memberships).subjects.filter(({ type }) => type === "concept").length;
+export const conceptCountOf = (graph, query, profileContext, memberships, nesting, showResponsibility) => evaluateProjection(graph, adHoc(query, nesting, showResponsibility), profileContext, memberships).subjects.filter(({ type }) => type === "concept").length;
 export const interrogationOverlayOf = (compiled, 
 /**
  * The catalogue, or the composed SET a workspace carries (#345, ADR 0129).
@@ -209,7 +209,10 @@ export const renderedWorkspaceOf = (compiled, views, metadata, catalogue, dismis
         // Each view's OWN nesting, because each view's closure is its own. A rail
         // sitting beside the canvas must not count a different tree than the
         // canvas draws.
-        view.presentation?.nesting),
+        view.presentation?.nesting, 
+        // And each view's own responsibility flag, for the same reason: the
+        // walk reads it (#563), and the rail must count what the canvas draws.
+        view.presentation?.showResponsibility),
     }));
     const interrogation = catalogue === undefined
         ? undefined
@@ -250,24 +253,33 @@ export const renderedWorkspaceOf = (compiled, views, metadata, catalogue, dismis
     };
 };
 /** Every subject a query draws, concepts and relationships alike. */
-export const matchedIdsOf = (graph, query, profileContext, memberships, nesting) => evaluateProjection(graph, adHoc(query, nesting), profileContext, memberships).subjects.map(({ id }) => id);
+export const matchedIdsOf = (graph, query, profileContext, memberships, nesting, showResponsibility) => evaluateProjection(graph, adHoc(query, nesting, showResponsibility), profileContext, memberships).subjects.map(({ id }) => id);
 /** Every concept a query dropped, and the facet that dropped it (#248). */
-export const exclusionsOf = (graph, query, profileContext, memberships, nesting) => explainProjection(graph, adHoc(query, nesting), profileContext, memberships);
+export const exclusionsOf = (graph, query, profileContext, memberships, nesting, showResponsibility) => explainProjection(graph, adHoc(query, nesting, showResponsibility), profileContext, memberships);
 /**
  * A query on its own is not a projection, and every evaluator here wants one.
  * The id is a placeholder that never reaches a document.
  */
-const adHoc = (query, nesting) => ({
-    format: "yarramate/projection/v1",
-    id: "ad-hoc",
-    version: "0",
-    query,
-    // `query.instances` resolves its closure through the view's nesting, so an
-    // ad-hoc projection that dropped the nesting would answer a DIFFERENT
-    // question than the canvas is drawing: 2 subjects against 15 on the
-    // ApertureX reference, with nothing to say it had (#473 phase 2).
-    ...(nesting === undefined ? {} : { presentation: { nesting } }),
-});
+const adHoc = (query, nesting, showResponsibility) => {
+    const presentation = {
+        // `query.instances` resolves its closure through the view's nesting, so an
+        // ad-hoc projection that dropped the nesting would answer a DIFFERENT
+        // question than the canvas is drawing: 2 subjects against 15 on the
+        // ApertureX reference, with nothing to say it had (#473 phase 2).
+        ...(nesting === undefined ? {} : { nesting }),
+        // And the `connected` walk reads this flag (#563, ADR 0161): dropped, the
+        // evaluation would walk a responsibility edge the canvas hides and stand a
+        // person in the picture with no line to anything.
+        ...(showResponsibility === undefined ? {} : { showResponsibility }),
+    };
+    return {
+        format: "yarramate/projection/v1",
+        id: "ad-hoc",
+        version: "0",
+        query,
+        ...(Object.keys(presentation).length === 0 ? {} : { presentation }),
+    };
+};
 /**
  * One saved view, as the rail reads it. `subjectCount` is the caller's,
  * because counting needs a compiled graph and a session builds its first list

package/dist/ask-command.js

@@ -605,6 +605,12 @@ export function runAskCommand(options, cwd) {
                 topic,
                 seeds: resolution.seeds,
                 matched: resolution.matched,
+                // The same document the tools entry emits, field for field (ADR 0156),
+                // and `test/tools-entry.test.ts` compares them. The ranked candidates
+                // ride on both (#569).
+                ...(resolution.addressing === 'free-text'
+                    ? { candidates: resolution.candidates }
+                    : {}),
                 ...(neighbourhood === undefined ? {} : { neighbourhood }),
                 result: evaluated,
             };

package/dist/governance.js

@@ -122,7 +122,16 @@ export function buildGovernanceLog(workspace, graph, profileContext, options = {
     });
     const ids = (predicate) => rows.filter(predicate).map(({ subject }) => subject);
     const unowned = ids((row) => row.owner === null);
-    const unmitigated = ids((row) => row.type === 'risk' && row.status === 'current' && row.mitigatedBy.length === 0);
+    const unmitigated = ids((row) => 
+    // Every risk still open, whatever its status says or does not say. The
+    // first cut counted only `status: current`, so a risk nobody had given a
+    // status, which is every freshly authored one, was never here and the
+    // tile read 0 over a log where every risk was unmitigated (#564). The
+    // engine's word for "open" is not-retired: that is what keeps unstatused
+    // subjects in a projection with `excludeStatuses: [retired]` and what
+    // the interrogation applies by default. A planned risk is asked for its
+    // mitigation too; a mitigation can be planned.
+    row.type === 'risk' && row.status !== 'retired' && row.mitigatedBy.length === 0);
     const unconfirmed = ids((row) => row.type === 'assumption' && row.review === null);
     const unreviewed = ids((row) => row.type === 'risk' && row.review === null);
     return {
@@ -159,6 +168,6 @@ export function renderGovernanceMarkdown(log) {
         }
         lines.push('');
     }
-    lines.push('## Gaps', '', `- Unowned: ${list(log.gaps.unowned)}`, `- Unmitigated (current risks): ${list(log.gaps.unmitigated)}`, `- Unconfirmed assumptions: ${list(log.gaps.unconfirmed)}`, `- Unreviewed risks: ${list(log.gaps.unreviewed)}`, '');
+    lines.push('## Gaps', '', `- Unowned: ${list(log.gaps.unowned)}`, `- Unmitigated risks: ${list(log.gaps.unmitigated)}`, `- Unconfirmed assumptions: ${list(log.gaps.unconfirmed)}`, `- Unreviewed risks: ${list(log.gaps.unreviewed)}`, '');
     return `${lines.join('\n')}\n`;
 }

package/dist/host/local-host.js

@@ -384,8 +384,8 @@ export const createLocalHost = (options) => {
                         kind: 'filter-result',
                         result: {
                             query: input.payload.query,
-                            matchedIds: matchedIdsOf(compiled.graph, input.payload.query, compiled.profileContext, compiled.patternMemberships, input.payload.nesting),
-                            excluded: exclusionsOf(compiled.graph, input.payload.query, compiled.profileContext, compiled.patternMemberships, input.payload.nesting),
+                            matchedIds: matchedIdsOf(compiled.graph, input.payload.query, compiled.profileContext, compiled.patternMemberships, input.payload.nesting, input.payload.showResponsibility),
+                            excluded: exclusionsOf(compiled.graph, input.payload.query, compiled.profileContext, compiled.patternMemberships, input.payload.nesting, input.payload.showResponsibility),
                         },
                     });
                     return;

package/dist/index.d.ts

@@ -21,6 +21,7 @@ export type { LifecycleStatus, ProjectionDefinition, ProjectionLoadResult, Proje
 export { createFileSystemStore, type PendingWrite, type SourceStore, type StoredSource, type WriteConflict, type WriteOutcome, } from './source-store.js';
 export { applyOperations, landOperations, posixDirectoryOf, type ApplyInput, type ApplyOutcome, } from './apply-command.js';
 export { connectableKinds, draftRelationship, proposeRelationshipId, stagedSubjectIds, } from './relationship-drafting.js';
+export { conventionalRelationshipKind, CONVENTION_RULES, type RelationshipConvention, } from './relationship-convention.js';
 export { draftConcept, proposeConceptId } from './concept-drafting.js';
 export { deletionBlockers, describeDeletion, draftDeletion, type DeletionBlocker, } from './deletion-drafting.js';
 export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, conditionInput, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, type CatalogueCondition, type CatalogueEvidenceObservation, type CataloguePatternMembership, type CataloguePatternVacancy, type CatalogueInput, type CatalogueLoadResult, type CatalogueQuestion, type CatalogueSelector, type InterrogationReport, type InterrogationSummary, type OpenSubject, type QuestionCatalogue, type ReportQuestion, type ReportWave, } from './interrogate-command.js';

package/dist/index.js

@@ -19,6 +19,7 @@ export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, }
 export { createFileSystemStore, } from './source-store.js';
 export { applyOperations, landOperations, posixDirectoryOf, } from './apply-command.js';
 export { connectableKinds, draftRelationship, proposeRelationshipId, stagedSubjectIds, } from './relationship-drafting.js';
+export { conventionalRelationshipKind, CONVENTION_RULES, } from './relationship-convention.js';
 export { draftConcept, proposeConceptId } from './concept-drafting.js';
 export { deletionBlockers, describeDeletion, draftDeletion, } from './deletion-drafting.js';
 export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, conditionInput, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, } from './interrogate-command.js';

package/dist/projection.js

@@ -18,6 +18,7 @@ export { DEFAULT_FOLD } from './fold-tree.js';
 import { DEFAULT_NESTING as NESTING_DEFAULT } from './nesting.js';
 import { foldTree } from './fold-tree.js';
 import { kindLabelOf } from './kind-label.js';
+import { responsibilityLetterOf } from './responsibility-kinds.js';
 /**
  * Which way a view runs, and the default. Split out for the same reason as the
  * nesting vocabulary above, and re-exported here on the same terms (ADR 0121).
@@ -563,10 +564,22 @@ export function evaluateProjection(graph, projection, profileContext, membership
                 endpointExcluded(relationship.object.ref)) {
                 continue;
             }
-            if ((relationshipMode === 'between' &&
-                sourceSelected &&
-                targetSelected) ||
+            const bothSelected = sourceSelected && targetSelected;
+            // A responsibility edge does not carry the `connected` walk unless the
+            // view shows responsibility (#563, ADR 0161). The canvas hides these
+            // edges while the flag is off (ADR 0159), so walking one stood a person
+            // in an application landscape with no line to anything: four of them on
+            // the ApertureX reference. Between two subjects the query selected on
+            // their own merits the edge is selected like any other, so a
+            // whole-workspace evaluation, the workbook and the matrix builders keep
+            // seeing every relationship; only the walk reads the flag. Read through
+            // the lineage, so an adopter's subkind of `responsible` is held back
+            // exactly as the shipped kind is.
+            const carriesTheWalk = projection.presentation?.showResponsibility === true ||
+                responsibilityLetterOf(profileContext?.relationshipKindLineages.get(relationship.predicate), relationship.predicate) === null;
+            if (bothSelected ||
                 (relationshipMode === 'connected' &&
+                    carriesTheWalk &&
                     (sourceSelected || targetSelected))) {
                 selectedRelationshipIds.add(subject.id);
                 if (relationshipMode === 'connected') {

package/dist/relationship-convention.d.ts

@@ -0,0 +1,25 @@
+import { type RelationshipKind } from './profile.js';
+/**
+ * One convention, as a named rule. The name is carried into the answer so a
+ * caller can say WHY, which is the difference between guidance a reviewer can
+ * argue with and a number they have to take on faith.
+ */
+export interface RelationshipConvention {
+    readonly kind: RelationshipKind;
+    readonly rule: string;
+    readonly because: string;
+}
+/**
+ * The kind practice expects from `from` to `to`, or `null` where practice has
+ * no expectation.
+ *
+ * Never contradicts the table: an answer is returned only when the table also
+ * permits it, so guidance can never point at an edge `check` would refuse.
+ */
+export declare const conventionalRelationshipKind: (from: string, to: string) => RelationshipConvention | null;
+/** Every rule's name and sentence, for documentation and for the test that checks them. */
+export declare const CONVENTION_RULES: readonly {
+    readonly name: string;
+    readonly kind: RelationshipKind;
+    readonly because: string;
+}[];

package/dist/relationship-convention.js

@@ -0,0 +1,176 @@
+import { conceptKinds, } from './profile.js';
+import { isCoreConceptKindId, permittedRelationshipKinds, } from './relationship-matrix.js';
+/**
+ * The relationship kind ArchiMate practice expects for a pair of core kinds,
+ * where practice has an expectation at all (#571).
+ *
+ * The relationship table is a PERMISSION table. It answers "may I draw this",
+ * and for an application component pointing at an application function it
+ * answers yes six times. Practice is much narrower: across this repository's
+ * own model and the ApertureX reference, 970 relationships over 72 core-kind
+ * pairs, the author used exactly one kind for 34 of the pairs the table lets
+ * them choose among, and used `assignment` for that particular pair 87 times
+ * out of 88. The engine knew the permission and never said the convention, so
+ * every palette offered six, every agent guessed, and a reviewer could never
+ * be told "this pair is usually X and yours is Y".
+ *
+ * ## Where these answers come from
+ *
+ * They are read off ArchiMate's own definitions of the relationships, NOT
+ * fitted to the two records. That direction matters. Both records agree, for
+ * instance, that a business actor points at a constraint with `association`,
+ * 87 times out of 87 - but that is one adopter's house convention for
+ * recording sign-off, not a rule of the language, and blessing it here would
+ * have told every other adopter their own style was wrong. The records are
+ * used as a CHECK: `test/relationship-convention.test.ts` asserts that every
+ * convention declared here matches real practice on a record that has enough
+ * of that pair to have a habit, and prints the disagreements when it does not.
+ *
+ * ## Silence is an answer
+ *
+ * `conventionalRelationshipKind` returns `null` far more often than not, and
+ * that is the point. A pair with no entry here is a pair where the language
+ * genuinely permits several readings and the author must choose: an artifact
+ * pointing at an application function is `realization` 41 times and
+ * `association` 16, a capability pointing at a goal splits evenly, and two
+ * application functions relate by composition, triggering, flow or serving
+ * depending on what the author means. Declaring a convention there would
+ * manufacture confidence the language does not have.
+ *
+ * Nothing here is a rule the compiler enforces. A permitted kind stays
+ * permitted; `check` never reads this file. It is guidance, offered to a
+ * palette, an agent, or a reviewer, and it says nothing when it has nothing
+ * to say.
+ */
+const KIND_META = new Map(conceptKinds.map((kind) => [kind.id, { layer: kind.layer, aspect: kind.aspect }]));
+/** The three service elements: external behaviour a layer offers outward. */
+const SERVICES = new Set([
+    'businessService',
+    'applicationService',
+    'technologyService',
+]);
+/** The three interface elements: the point at which a service is offered. */
+const INTERFACES = new Set([
+    'businessInterface',
+    'applicationInterface',
+    'technologyInterface',
+]);
+const isService = (kind) => SERVICES.has(kind);
+const isInterface = (kind) => INTERFACES.has(kind);
+const isInternalBehaviour = (kind) => KIND_META.get(kind)?.aspect === 'behavior' && !isService(kind);
+/**
+ * Ordered; the first rule that matches answers, and order is load-bearing
+ * twice. A service touching passive structure is `access` before it is
+ * anything else, because a service is behaviour first and an offering second.
+ * And an interface pointing at a service of its own layer is `assignment`,
+ * the interface exposing that service, while an interface pointing at
+ * anything else is `serving`. Both times the specific rule comes first.
+ */
+const RULES = [
+    {
+        name: 'behaviour-uses-data',
+        because: 'behaviour reads, writes or creates the passive structure it touches',
+        kind: 'access',
+        when: (from, to, f, t) => t.aspect === 'passive-structure' &&
+            (isInternalBehaviour(from) || isService(from)) &&
+            // An artifact is passive structure in the technology layer, and
+            // behaviour pointing at one is not "reading a file": both records write
+            // `association` there far more often than `access`. Left to the author.
+            to !== 'artifact',
+    },
+    {
+        name: 'interface-exposes-service',
+        because: 'an interface is assigned to the service it exposes, not to the behaviour that uses it',
+        kind: 'assignment',
+        when: (from, to, f, t) => isInterface(from) && isService(to) && f.layer === t.layer,
+    },
+    {
+        name: 'service-is-offered-outward',
+        because: 'a service is made available to whoever uses it',
+        kind: 'serving',
+        when: (from, _to, _f, t) => (isService(from) || isInterface(from)) &&
+            (t.aspect === 'active-structure' || t.aspect === 'behavior'),
+    },
+    {
+        name: 'grouping-collects-members',
+        because: 'a grouping aggregates what it collects; the members exist without it',
+        kind: 'aggregation',
+        when: (from) => from === 'grouping',
+    },
+    {
+        name: 'artifact-realizes-what-it-implements',
+        because: 'an artifact is the concrete file or deployable that fulfils the thing it stands for',
+        kind: 'realization',
+        when: (from, to, _f, t) => from === 'artifact' &&
+            (t.aspect === 'active-structure' || t.aspect === 'passive-structure') &&
+            to !== 'artifact',
+    },
+    {
+        name: 'active-structure-performs-behaviour',
+        because: 'an active structure element is assigned to the internal behaviour it performs',
+        kind: 'assignment',
+        when: (from, to, f, t) => f.aspect === 'active-structure' &&
+            isInternalBehaviour(to) &&
+            f.layer === t.layer,
+    },
+    {
+        name: 'internal-realizes-service',
+        because: 'the internal element is the concrete thing that fulfils the service its layer offers',
+        kind: 'realization',
+        when: (from, to, f, t) => isService(to) &&
+            f.layer === t.layer &&
+            (f.aspect === 'active-structure' || isInternalBehaviour(from)) &&
+            !isInterface(from),
+    },
+    {
+        name: 'technology-serves-application',
+        // The least certain rule here. The authoring reference lists this pair as
+        // "realizes or serves", two readings: realization when the node IS the
+        // implementation, serving when it hosts one. Both records are unanimous
+        // for `serving`, ten times in ten, so that is what is offered - and the
+        // other reading stays one click away, as every non-conventional kind does.
+        because: 'a technology element is not part of the application it runs; it serves it',
+        kind: 'serving',
+        when: (_from, _to, f, t) => f.layer === 'technology' &&
+            t.layer === 'application' &&
+            (t.aspect === 'active-structure' || t.aspect === 'behavior'),
+    },
+];
+const cache = new Map();
+/**
+ * The kind practice expects from `from` to `to`, or `null` where practice has
+ * no expectation.
+ *
+ * Never contradicts the table: an answer is returned only when the table also
+ * permits it, so guidance can never point at an edge `check` would refuse.
+ */
+export const conventionalRelationshipKind = (from, to) => {
+    const key = `${from}>${to}`;
+    const cached = cache.get(key);
+    if (cached !== undefined)
+        return cached;
+    const answer = compute(from, to);
+    cache.set(key, answer);
+    return answer;
+};
+const compute = (from, to) => {
+    if (!isCoreConceptKindId(from) || !isCoreConceptKindId(to))
+        return null;
+    const fromMeta = KIND_META.get(from);
+    const toMeta = KIND_META.get(to);
+    if (fromMeta === undefined || toMeta === undefined)
+        return null;
+    for (const rule of RULES) {
+        if (!rule.when(from, to, fromMeta, toMeta))
+            continue;
+        // Guidance that the table forbids would be worse than none: it would send
+        // an author at an edge `check` refuses. A rule that lands outside the
+        // permission is treated as having no answer for this pair.
+        if (!permittedRelationshipKinds(from, to).has(rule.kind))
+            return null;
+        return { kind: rule.kind, rule: rule.name, because: rule.because };
+    }
+    return null;
+};
+/** Every rule's name and sentence, for documentation and for the test that checks them. */
+export const CONVENTION_RULES = RULES.map(({ name, kind, because }) => ({ name, kind, because }));