yarramate 1.32.0 → 1.33.0

package/catalogues/core-enrichment.yaml

@@ -830,6 +830,76 @@ questions:
       Add an owner reference to an accountable actor (evidence such as
       CODEOWNERS may propose it; a human confirms accountability).
 
+  - id: responsible-missing
+    wave: business
+    since: "1.33"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#businessService
+        - yarramate/core@0.1#applicationService
+        - yarramate/core@0.1#applicationComponent
+        - yarramate/core@0.1#capability
+    trigger:
+      - condition: missing-linkage
+        kinds:
+          - yarramate/policy@0.2#responsible
+        direction: incoming
+        counterpartKinds:
+          - yarramate/core@0.1#businessActor
+          - yarramate/core@0.1#businessRole
+          - yarramate/core@0.1#businessCollaboration
+          - yarramate/core@0.1#stakeholder
+    question: >-
+      Who is responsible for {subject.name}?
+    askPlain: >-
+      Who actually builds, runs or delivers "{subject.name}" day to day?
+    materiality: >-
+      Accountability says whose desk a failure lands on; responsibility says
+      whose hands are on it. A subject with nobody responsible has nobody to
+      hand the work to, and a RACI row with no R is a gap the matrix reports.
+    authority: either
+    resolution: >-
+      Add a `responsible` relationship from the actor, role or collaboration
+      that does the work to the subject (a support contract or CODEOWNERS may
+      propose it; a person confirms it).
+  - id: role-idle
+    wave: business
+    since: "1.33"
+    scope: subject
+    subjects:
+      kinds:
+        - yarramate/core@0.1#businessActor
+        - yarramate/core@0.1#businessRole
+        - yarramate/core@0.1#businessCollaboration
+    trigger:
+      - condition: missing-reference
+        predicate: yarramate/ownership/owner
+        direction: incoming
+      - condition: missing-relationship
+        kinds:
+          - yarramate/policy@0.2#responsible
+          - yarramate/policy@0.2#consulted
+          - yarramate/policy@0.2#informed
+        direction: outgoing
+      - condition: missing-relationship
+        kinds:
+          - yarramate/core@0.1#serving
+        direction: incoming
+    question: >-
+      What does {subject.name} answer for?
+    askPlain: >-
+      "{subject.name}" is in the model but owns nothing, is responsible for
+      nothing, and is neither consulted nor informed about anything. What is
+      their part, or should they go?
+    materiality: >-
+      A person with no letter is either missing the edges a delivery depends
+      on or a name that outlived its role. A served actor is a consumer, not
+      a responsibility holder, and is not asked.
+    authority: human
+    resolution: >-
+      Give the person a letter (an owner claim on what they answer for, or a
+      responsible, consulted or informed relationship) or retire the subject.
   - id: actor-unassigned
     wave: business
     since: "0.1"

package/dist/adapters/mcp-cli.js

@@ -148,8 +148,8 @@ const runExport = (input, tool, root) => {
             stderr: '',
         };
     }
-    // A text kind under `out`: markdown and graph are one file, rtm and
-    // briefs a directory, as the CLI lays them out.
+    // A text kind under `out`: markdown and graph are one file, rtm,
+    // responsibility and briefs a directory, as the CLI lays them out.
     if (kind === 'markdown' || kind === 'graph') {
         mkdirSync(dirname(target), { recursive: true });
         writeFileSync(target, outcome.text, 'utf8');
@@ -172,6 +172,19 @@ const runExport = (input, tool, root) => {
             stderr: '',
         };
     }
+    if (kind === 'responsibility') {
+        const result = outcome.result;
+        mkdirSync(target, { recursive: true });
+        writeFileSync(join(target, 'RESPONSIBILITY.md'), outcome.text, 'utf8');
+        if (result !== undefined) {
+            writeFileSync(join(target, 'responsibility.json'), `${JSON.stringify(result.matrix, null, 2)}\n`, 'utf8');
+        }
+        return {
+            exitCode: 0,
+            stdout: `Wrote RESPONSIBILITY.md and responsibility.json to ${out}\n`,
+            stderr: '',
+        };
+    }
     if (kind === 'briefs') {
         const result = outcome.result;
         mkdirSync(target, { recursive: true });

package/dist/brief.js

@@ -1,5 +1,5 @@
 import { conceptKinds } from './profile.js';
-import { RELATIONSHIP_READING, humanizeKind } from './relationship-reading.js';
+import { EXTENSION_READING, RELATIONSHIP_READING, humanizeKind } from './relationship-reading.js';
 const coreKindNames = new Map(conceptKinds.map(({ id, name }) => [id, name]));
 const motivationKindIds = new Set(conceptKinds
     .filter(({ layer }) => layer === 'motivation')
@@ -66,6 +66,9 @@ const relationshipPhrase = (coreKind, fallbackKind, mode, content) => {
     if (coreKind === 'flow') {
         return content === undefined ? 'flows to' : `sends ${content} to`;
     }
+    const extension = EXTENSION_READING[fallbackKind];
+    if (extension !== undefined)
+        return extension;
     const reading = coreKind === undefined ? undefined : RELATIONSHIP_READING[coreKind];
     return reading ?? humanizeKind(fallbackKind);
 };

package/dist/cli-support.d.ts

@@ -7,7 +7,7 @@ export interface CliResult {
 export declare const isMainModule: (moduleUrl: string, entrypoint: string | undefined) => boolean;
 export declare const packageVersion: string;
 export declare const versionResult: (binary: string) => CliResult;
-export declare const usage = "Usage:\n  yarramate init <directory> [--no-pointer]\n  yarramate design <workspace.yaml> [--subject <subject-id>] [--catalogue <catalogue.yaml>] [--facilitate] [--json]\n  yarramate apply <operations.yaml> <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> \"<free text>\" | <subject-id> ... | <projection.yaml> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate ask <workspace.yaml> --subjects [--kind <term>] [--status <status>] [--json]\n  yarramate ask <workspace.yaml> --kinds [--json]\n  yarramate ask <workspace.yaml> --advise \"<topic>\" [--budget <tokens>] [--neighbours <n>] [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --where \"<free text>\" | <subject-id> ... [--json]\n  yarramate ask <workspace.yaml> --next [--json]\n  yarramate ask <workspace.yaml> --open [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --compare <from-state> <to-state> [--json]\n  yarramate ask <workspace.yaml> --changed <git-range> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate check <source.yaml> [source.yaml ...] [--json] [--strict]\n  yarramate reconcile <workspace.yaml> [--json | --text]\n  yarramate export graph <workspace.yaml> [--out <file>]\n  yarramate export markdown <projection.yaml> <workspace.yaml> [--out <file>]\n  yarramate export markdown --changed <git-range> <workspace.yaml> [--out <file>]\n  yarramate export briefs <projection.yaml> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export briefs --changed <git-range> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export rtm <workspace.yaml> --out <directory>\n  yarramate export xlsx <projection.yaml> <workspace.yaml> --out <file>\n  yarramate import xlsx <workbook.xlsx> <workspace.yaml> [--json]\n  yarramate export likec4 <likec4-project.yaml> <output-dir> <workspace.yaml> [--changed <git-range>]\n";
+export declare const usage = "Usage:\n  yarramate init <directory> [--no-pointer]\n  yarramate design <workspace.yaml> [--subject <subject-id>] [--catalogue <catalogue.yaml>] [--facilitate] [--json]\n  yarramate apply <operations.yaml> <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> \"<free text>\" | <subject-id> ... | <projection.yaml> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate ask <workspace.yaml> --subjects [--kind <term>] [--status <status>] [--json]\n  yarramate ask <workspace.yaml> --kinds [--json]\n  yarramate ask <workspace.yaml> --advise \"<topic>\" [--budget <tokens>] [--neighbours <n>] [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --where \"<free text>\" | <subject-id> ... [--json]\n  yarramate ask <workspace.yaml> --next [--json]\n  yarramate ask <workspace.yaml> --open [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --compare <from-state> <to-state> [--json]\n  yarramate ask <workspace.yaml> --changed <git-range> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate check <source.yaml> [source.yaml ...] [--json] [--strict]\n  yarramate reconcile <workspace.yaml> [--json | --text]\n  yarramate export graph <workspace.yaml> [--out <file>]\n  yarramate export markdown <projection.yaml> <workspace.yaml> [--out <file>]\n  yarramate export markdown --changed <git-range> <workspace.yaml> [--out <file>]\n  yarramate export briefs <projection.yaml> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export briefs --changed <git-range> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export rtm <workspace.yaml> --out <directory>\n  yarramate export responsibility <projection.yaml> <workspace.yaml> --out <directory>\n  yarramate export xlsx <projection.yaml> <workspace.yaml> --out <file>\n  yarramate import xlsx <workbook.xlsx> <workspace.yaml> [--json]\n  yarramate export likec4 <likec4-project.yaml> <output-dir> <workspace.yaml> [--changed <git-range>]\n";
 export declare const diagnosticJson: (diagnostics: unknown) => string;
 export declare const checkResultJson: (ok: boolean, diagnostics: unknown, counted?: {
     readonly documents: number;

package/dist/cli-support.js

@@ -22,7 +22,7 @@ export const versionResult = (binary) => ({
     stdout: `${binary} ${packageVersion}\n`,
     stderr: '',
 });
-export const usage = 'Usage:\n  yarramate init <directory> [--no-pointer]\n  yarramate design <workspace.yaml> [--subject <subject-id>] [--catalogue <catalogue.yaml>] [--facilitate] [--json]\n  yarramate apply <operations.yaml> <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> "<free text>" | <subject-id> ... | <projection.yaml> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate ask <workspace.yaml> --subjects [--kind <term>] [--status <status>] [--json]\n  yarramate ask <workspace.yaml> --kinds [--json]\n  yarramate ask <workspace.yaml> --advise "<topic>" [--budget <tokens>] [--neighbours <n>] [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --where "<free text>" | <subject-id> ... [--json]\n  yarramate ask <workspace.yaml> --next [--json]\n  yarramate ask <workspace.yaml> --open [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --compare <from-state> <to-state> [--json]\n  yarramate ask <workspace.yaml> --changed <git-range> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate check <source.yaml> [source.yaml ...] [--json] [--strict]\n  yarramate reconcile <workspace.yaml> [--json | --text]\n  yarramate export graph <workspace.yaml> [--out <file>]\n  yarramate export markdown <projection.yaml> <workspace.yaml> [--out <file>]\n  yarramate export markdown --changed <git-range> <workspace.yaml> [--out <file>]\n  yarramate export briefs <projection.yaml> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export briefs --changed <git-range> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export rtm <workspace.yaml> --out <directory>\n  yarramate export xlsx <projection.yaml> <workspace.yaml> --out <file>\n  yarramate import xlsx <workbook.xlsx> <workspace.yaml> [--json]\n  yarramate export likec4 <likec4-project.yaml> <output-dir> <workspace.yaml> [--changed <git-range>]\n';
+export const usage = 'Usage:\n  yarramate init <directory> [--no-pointer]\n  yarramate design <workspace.yaml> [--subject <subject-id>] [--catalogue <catalogue.yaml>] [--facilitate] [--json]\n  yarramate apply <operations.yaml> <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> [--json]\n  yarramate ask <workspace.yaml> "<free text>" | <subject-id> ... | <projection.yaml> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate ask <workspace.yaml> --subjects [--kind <term>] [--status <status>] [--json]\n  yarramate ask <workspace.yaml> --kinds [--json]\n  yarramate ask <workspace.yaml> --advise "<topic>" [--budget <tokens>] [--neighbours <n>] [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --where "<free text>" | <subject-id> ... [--json]\n  yarramate ask <workspace.yaml> --next [--json]\n  yarramate ask <workspace.yaml> --open [--catalogue <catalogue.yaml>] [--json]\n  yarramate ask <workspace.yaml> --compare <from-state> <to-state> [--json]\n  yarramate ask <workspace.yaml> --changed <git-range> [--budget <tokens>] [--neighbours <n>] [--json]\n  yarramate check <source.yaml> [source.yaml ...] [--json] [--strict]\n  yarramate reconcile <workspace.yaml> [--json | --text]\n  yarramate export graph <workspace.yaml> [--out <file>]\n  yarramate export markdown <projection.yaml> <workspace.yaml> [--out <file>]\n  yarramate export markdown --changed <git-range> <workspace.yaml> [--out <file>]\n  yarramate export briefs <projection.yaml> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export briefs --changed <git-range> <workspace.yaml> --out <directory> [--budget <tokens>]\n  yarramate export rtm <workspace.yaml> --out <directory>\n  yarramate export responsibility <projection.yaml> <workspace.yaml> --out <directory>\n  yarramate export xlsx <projection.yaml> <workspace.yaml> --out <file>\n  yarramate import xlsx <workbook.xlsx> <workspace.yaml> [--json]\n  yarramate export likec4 <likec4-project.yaml> <output-dir> <workspace.yaml> [--changed <git-range>]\n';
 export const diagnosticJson = (diagnostics) => `${JSON.stringify({
     format: 'yarramate/diagnostic-result/v1',
     diagnostics,

package/dist/compiler.js

@@ -3,7 +3,7 @@ import { conceptKinds, relationshipPolicies, } from './profile.js';
 import { isCoreConceptKindId, matrixEndpointAspects, permittedRelationshipKinds as tablePermittedKinds, } from './relationship-matrix.js';
 import { closestCandidate, describeSchemaViolation, } from './source-document.js';
 import { ATTESTATION_PREDICATE_PREFIX, attestationClaimValue } from './graph-claims.js';
-import { shippedPolicyIdentity, shippedPolicySource, } from './shipped-profile.js';
+import { shippedProfileOf } from './shipped-profile.js';
 import { validateDocument, validateProfile, validatePattern } from './schema-validation.js';
 const coreProfile = 'yarramate/core@0.1';
 /**
@@ -371,58 +371,78 @@ function compileWorkspaceResolved(parsed) {
         const identity = `${value.id}@${value.version}`;
         pendingProfiles.push({ input, value, identity, positionFor });
     }
-    const alreadyDeclaresPolicy = pendingProfiles.some(({ identity }) => identity === shippedPolicyIdentity);
-    if (!alreadyDeclaresPolicy) {
-        // This probe runs BEFORE the document gate that rejects a source whose
-        // schema check failed, so it has to hold its own precondition: a source
-        // that composes to anything but a mapping - an empty file, a comment-only
-        // one, a bare scalar - selects no profile at all. It used to read
-        // `.profile` through an `as` cast, which is what hid the null from the
-        // typechecker, and an empty document crashed the whole compile with a
-        // `TypeError` instead of the `YM201 must be object` its schema already
-        // produces. Every other consumer of a parsed entry checks its diagnostics
-        // first (the profile walk above, the pattern walk below); this one could
-        // not, because it runs before that gate exists, so it narrows instead.
-        const selected = documentInputs.some(({ entry }) => {
-            const value = entry.value;
-            return (typeof value === 'object' &&
-                value !== null &&
-                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),
+    // The shipped optional profiles (ADR 0095; policy@0.2 per ADR 0159). Each
+    // is injected when a document selects it or a profile extends it, and a
+    // shipped profile's own parent follows it in, so `extends:
+    // yarramate/policy@0.2` brings 0.1 along. A workspace file that declares
+    // the same identity wins; the shipped copy is not added beside it.
+    //
+    // This probe runs BEFORE the document gate that rejects a source whose
+    // schema check failed, so it has to hold its own precondition: a source
+    // that composes to anything but a mapping - an empty file, a comment-only
+    // one, a bare scalar - selects no profile at all. It used to read
+    // `.profile` through an `as` cast, which is what hid the null from the
+    // typechecker, and an empty document crashed the whole compile with a
+    // `TypeError` instead of the `YM201 must be object` its schema already
+    // produces. Every other consumer of a parsed entry checks its diagnostics
+    // first (the profile walk above, the pattern walk below); this one could
+    // not, because it runs before that gate exists, so it narrows instead.
+    const declaredIdentities = new Set(pendingProfiles.map(({ identity }) => identity));
+    const requestedIdentities = new Set();
+    for (const { entry } of documentInputs) {
+        const value = entry.value;
+        if (typeof value !== 'object' || value === null)
+            continue;
+        const profile = value.profile;
+        if (typeof profile === 'string')
+            requestedIdentities.add(profile);
+    }
+    for (const { value } of pendingProfiles)
+        requestedIdentities.add(value.extends);
+    const wantedShipped = [];
+    const want = (identity) => {
+        if (declaredIdentities.has(identity) || wantedShipped.includes(identity))
+            return;
+        const shipped = shippedProfileOf(identity);
+        if (shipped === undefined)
+            return;
+        wantedShipped.push(identity);
+        want(shipped.extends);
+    };
+    for (const identity of requestedIdentities)
+        want(identity);
+    for (const identity of wantedShipped) {
+        const shipped = shippedProfileOf(identity);
+        const input = {
+            path: `yarramate:profile:${identity}`,
+            source: shipped.source,
+        };
+        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,
+                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));

package/dist/export-command.js

@@ -8,7 +8,7 @@ import { humanDiagnostics, usage, } from './cli-support.js';
 import { evaluateProjection, renderProjectionMarkdown } from './projection.js';
 import { createFileSystemStore } from './source-store.js';
 import { posixDirectoryOf } from './apply-command.js';
-import { briefsFromResult, exportBriefs, exportGraph, exportMarkdown, exportRtm, exportWorkbook, } from './tools/export.js';
+import { briefsFromResult, exportBriefs, exportGraph, exportMarkdown, exportResponsibility, exportRtm, exportWorkbook, } from './tools/export.js';
 import { compileOf, readSource, } from './tools/workspace.js';
 import { loadWorkspaceManifest } from './workspace.js';
 // Every kind is derived in `tools/export.ts` (ADR 0156): this command
@@ -70,7 +70,15 @@ const parseExportOptions = (options) => {
 export function runExportCommand(options, cwd) {
     const [kind, ...rest] = options;
     if (kind === undefined ||
-        !['graph', 'markdown', 'briefs', 'rtm', 'likec4', 'xlsx'].includes(kind)) {
+        ![
+            'graph',
+            'markdown',
+            'briefs',
+            'rtm',
+            'responsibility',
+            'likec4',
+            'xlsx',
+        ].includes(kind)) {
         return { exitCode: 2, stdout: '', stderr: usage };
     }
     const parsed = parseExportOptions(rest);
@@ -121,9 +129,13 @@ export function runExportCommand(options, cwd) {
     if (parsed.positionals.length !== expectedPositionals ||
         workspacePath === undefined ||
         parsed.json ||
-        (usesChanged && (kind === 'graph' || kind === 'rtm')) ||
+        (usesChanged &&
+            (kind === 'graph' || kind === 'rtm' || kind === 'responsibility')) ||
         (parsed.budget !== undefined && kind !== 'briefs') ||
-        ((kind === 'briefs' || kind === 'rtm' || kind === 'xlsx') &&
+        ((kind === 'briefs' ||
+            kind === 'rtm' ||
+            kind === 'responsibility' ||
+            kind === 'xlsx') &&
             parsed.out === undefined)) {
         return { exitCode: 2, stdout: '', stderr: usage };
     }
@@ -171,6 +183,20 @@ export function runExportCommand(options, cwd) {
                 stderr: '',
             };
         }
+        if (kind === 'responsibility') {
+            const exported = exportResponsibility(tool, projectionPath);
+            if (!exported.ok)
+                return failedTool(exported);
+            const { markdown, matrix } = exported.result;
+            writeText(join(parsed.out, 'RESPONSIBILITY.md'), markdown);
+            writeText(join(parsed.out, 'responsibility.json'), `${JSON.stringify(matrix, null, 2)}\n`);
+            const gaps = matrix.summary.noAccountable + matrix.summary.noResponsible;
+            return {
+                exitCode: 0,
+                stdout: `Wrote RESPONSIBILITY.md and responsibility.json (${matrix.summary.rows} row${matrix.summary.rows === 1 ? '' : 's'}, ${gaps} gap${gaps === 1 ? '' : 's'}) to ${parsed.out}\n`,
+                stderr: '',
+            };
+        }
         if (kind === 'graph') {
             const exported = exportGraph(tool);
             if (!exported.ok)

package/dist/graph-projection.d.ts

@@ -67,6 +67,17 @@ export interface CanvasEdge {
     readonly kind: string;
     readonly kindLabel: string;
     readonly coreKindLabel: string;
+    /**
+     * The kind whose reading the edge label speaks (ADR 0159): an extension
+     * identity with a reading of its own, else `coreKindLabel`.
+     */
+    readonly readingKind?: string;
+    /**
+     * The responsibility letter this edge carries (#557): R, C or I for the
+     * shipped responsibility kinds and their subkinds, null for every other
+     * kind. The canvas draws these only when the view asks (`showResponsibility`).
+     */
+    readonly responsibility?: ResponsibilityLetter | null;
     readonly from: string;
     readonly to: string;
     readonly name: string | null;
@@ -84,4 +95,5 @@ export interface CanvasGraph {
     readonly nodes: readonly CanvasNode[];
     readonly edges: readonly CanvasEdge[];
 }
+import { type ResponsibilityLetter } from './responsibility-kinds.js';
 export declare function projectGraphForCanvas(graph: SemanticGraph, profileContext: ResolvedProfileContext): CanvasGraph;

package/dist/graph-projection.js

@@ -1,5 +1,7 @@
 import { ATTESTATION_PREDICATE_PREFIX, parseAttestationClaimValue, parseConstraintExpectsValue, } from './graph-claims.js';
 import { kindLabelOf } from './kind-label.js';
+import { readingKindOf } from './relationship-reading.js';
+import { responsibilityLetterOf } from './responsibility-kinds.js';
 const CONCEPT_KIND_PREDICATE = 'yarramate/concept/kind';
 const CONCEPT_NAME_PREDICATE = 'yarramate/concept/name';
 const CONCEPT_DESCRIPTION_PREDICATE = 'yarramate/concept/description';
@@ -170,6 +172,8 @@ const projectRelationship = (relationshipId, allClaims, ownClaims, profileContex
         throw new Error(`Relationship "${relationshipId}" is missing its defining claim`);
     }
     const kind = definingClaim.predicate;
+    const lineage = profileContext.relationshipKindLineages.get(kind);
+    const coreKindLabel = kindLabelOf(lineage?.[0] ?? kind);
     const nameClaim = ownClaims.find((claim) => claim.predicate === RELATIONSHIP_NAME_PREDICATE);
     const descriptionClaim = ownClaims.find((claim) => claim.predicate === RELATIONSHIP_DESCRIPTION_PREDICATE);
     const modeClaim = ownClaims.find((claim) => claim.predicate === ACCESS_MODE_PREDICATE);
@@ -181,7 +185,9 @@ const projectRelationship = (relationshipId, allClaims, ownClaims, profileContex
         document: definingClaim.source.path,
         kind,
         kindLabel: kindLabelOf(kind),
-        coreKindLabel: kindLabelOf(profileContext.relationshipKindLineages.get(kind)?.[0] ?? kind),
+        coreKindLabel,
+        readingKind: readingKindOf(lineage, coreKindLabel),
+        responsibility: responsibilityLetterOf(lineage, kind),
         from: definingClaim.subject,
         to: claimRef(definingClaim),
         name: nameClaim === undefined ? null : claimValue(nameClaim),

package/dist/index.d.ts

@@ -10,6 +10,8 @@ export { constraintExpectsPredicate, reconcileEvidenceReports, type AssertedRela
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { deriveArtifactCoverage, type ArtifactCoverage, type CoverageScopePattern, } from './artifact-coverage.js';
 export { buildRtm, renderRtmMarkdown, type RequirementsTraceabilityMatrix, type RtmAttestation, type RtmContextEntry, type RtmDescopedEntry, type RtmEvidenceVerdict, type RtmLineageEntry, type RtmRealizer, type RtmRow, type RtmSource, } from './rtm.js';
+export { buildResponsibilityMatrix, renderResponsibilityMarkdown, type RaciLetter, type ResponsibilityCell, type ResponsibilityCellSource, type ResponsibilityMatrix, type ResponsibilityOptions, type ResponsibilityPerson, type ResponsibilityRow, type ResponsibilitySource, } from './responsibility.js';
+export { PEOPLE_KINDS, RESPONSIBILITY_KINDS, RESPONSIBILITY_PROFILE, responsibilityLetterOf, type ResponsibilityLetter, } from './responsibility-kinds.js';
 export type { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, PatternMembership, PatternPortShape, PatternShape, PatternSlotShape, PatternVacancy, PatternWireShape, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
 export { canonicalProjection, evaluateProjection, explainProjection, instanceClosureOf, loadProjection, renderProjectionMarkdown, type ConceptFacet, type ProjectionExclusion, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, type AdapterMapping, type AdapterMappingLoadResult, type AdapterMappingValidationResult, type AdapterMappingsValidationResult, type AdapterSubjectMapping, } from './adapter-mapping.js';

package/dist/index.js

@@ -10,6 +10,8 @@ export { constraintExpectsPredicate, reconcileEvidenceReports, } from './reconci
 export { deriveAttestationStaleness } from './attestation-staleness.js';
 export { deriveArtifactCoverage, } from './artifact-coverage.js';
 export { buildRtm, renderRtmMarkdown, } from './rtm.js';
+export { buildResponsibilityMatrix, renderResponsibilityMarkdown, } from './responsibility.js';
+export { PEOPLE_KINDS, RESPONSIBILITY_KINDS, RESPONSIBILITY_PROFILE, responsibilityLetterOf, } from './responsibility-kinds.js';
 export { canonicalProjection, evaluateProjection, explainProjection, instanceClosureOf, loadProjection, renderProjectionMarkdown, } from './projection.js';
 export { loadAdapterMapping, validateAdapterMapping, validateAdapterMappings, } from './adapter-mapping.js';
 export { createFileSystemStore, } from './source-store.js';

package/dist/projection.d.ts

@@ -84,6 +84,11 @@ export interface ProjectionDefinition {
         readonly showLifecycle?: boolean;
         readonly showEvidence?: boolean;
         readonly showOwnership?: boolean;
+        /**
+         * Whether responsibility edges draw on the canvas (#557, ADR 0159). Off
+         * when absent: the subject's properties read the letters either way.
+         */
+        readonly showResponsibility?: boolean;
         /**
          * Whether an unnamed relationship is labelled with its reading - "serves",
          * "served by", "realizes" - or left to its line style and arrowhead

package/dist/projection.js

@@ -71,6 +71,7 @@ export function canonicalProjection(projection) {
                     ...(presentation.showLifecycle === undefined ? {} : { showLifecycle: presentation.showLifecycle }),
                     ...(presentation.showEvidence === undefined ? {} : { showEvidence: presentation.showEvidence }),
                     ...(presentation.showOwnership === undefined ? {} : { showOwnership: presentation.showOwnership }),
+                    ...(presentation.showResponsibility === undefined ? {} : { showResponsibility: presentation.showResponsibility }),
                     ...(presentation.showKindLabels === undefined ? {} : { showKindLabels: presentation.showKindLabels }),
                     ...(presentation.notation === undefined ? {} : { notation: presentation.notation }),
                 },
@@ -637,6 +638,9 @@ export function evaluateProjection(graph, projection, profileContext, membership
                     ...(projection.presentation.showOwnership === undefined
                         ? {}
                         : { showOwnership: projection.presentation.showOwnership }),
+                    ...(projection.presentation.showResponsibility === undefined
+                        ? {}
+                        : { showResponsibility: projection.presentation.showResponsibility }),
                     ...(projection.presentation.showKindLabels === undefined
                         ? {}
                         : { showKindLabels: projection.presentation.showKindLabels }),

package/dist/relationship-reading.d.ts

@@ -13,6 +13,17 @@
  * reads an access.
  */
 export declare const RELATIONSHIP_READING: Readonly<Record<string, string>>;
+/**
+ * Readings for the extension kinds the package ships (ADR 0159), keyed by
+ * their full identity: a profile's subkind of one of these reads the same,
+ * which `readingKindOf` resolves through the lineage.
+ */
+export declare const EXTENSION_READING: Readonly<Record<string, string>>;
+/**
+ * The kind whose reading an edge speaks: the most specific member of the
+ * lineage (ancestor-first) that has a reading of its own, else the core kind.
+ */
+export declare const readingKindOf: (lineage: readonly string[] | undefined, coreKind: string) => string;
 export declare const REVERSED_READING: Readonly<Record<string, string>>;
 /**
  * `acme/p@1#applicationComponent` reads "application component" and
@@ -25,4 +36,4 @@ export declare const humanizeKind: (kind: string) => string;
  * and gets it only where one exists; a kind with no passive reading keeps its
  * active one, so a caller can pass the layering's answer straight through.
  */
-export declare const relationshipReading: (coreKind: string, reversed?: boolean) => string;
+export declare const relationshipReading: (kind: string, reversed?: boolean) => string;

package/dist/relationship-reading.js

@@ -25,6 +25,30 @@ export const RELATIONSHIP_READING = {
     influence: 'influences',
     association: 'is associated with',
 };
+/**
+ * Readings for the extension kinds the package ships (ADR 0159), keyed by
+ * their full identity: a profile's subkind of one of these reads the same,
+ * which `readingKindOf` resolves through the lineage.
+ */
+export const EXTENSION_READING = {
+    'yarramate/policy@0.2#responsible': 'is responsible for',
+    'yarramate/policy@0.2#consulted': 'is consulted on',
+    'yarramate/policy@0.2#informed': 'is informed of',
+};
+/**
+ * The kind whose reading an edge speaks: the most specific member of the
+ * lineage (ancestor-first) that has a reading of its own, else the core kind.
+ */
+export const readingKindOf = (lineage, coreKind) => {
+    if (lineage !== undefined) {
+        for (let index = lineage.length - 1; index >= 0; index -= 1) {
+            const member = lineage[index];
+            if (EXTENSION_READING[member] !== undefined)
+                return member;
+        }
+    }
+    return coreKind;
+};
 export const REVERSED_READING = {
     serving: 'served by',
     realization: 'realized by',
@@ -47,6 +71,7 @@ export const humanizeKind = (kind) => {
  * and gets it only where one exists; a kind with no passive reading keeps its
  * active one, so a caller can pass the layering's answer straight through.
  */
-export const relationshipReading = (coreKind, reversed = false) => (reversed ? REVERSED_READING[coreKind] : undefined) ??
-    RELATIONSHIP_READING[coreKind] ??
-    humanizeKind(coreKind);
+export const relationshipReading = (kind, reversed = false) => (reversed ? REVERSED_READING[kind] : undefined) ??
+    EXTENSION_READING[kind] ??
+    RELATIONSHIP_READING[kind] ??
+    humanizeKind(kind);

package/dist/responsibility-kinds.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The three responsibility relationship kinds and the letters they carry
+ * (#557, ADR 0159): `yarramate/policy@0.2#responsible`, `#consulted` and
+ * `#informed`, each a subkind of core `association` from a person to the
+ * subject they answer for. Accountable is not a kind: it is the existing
+ * `yarramate/ownership/owner` claim. Pure, so the canvas projection, the
+ * matrix builder and the editor read one table.
+ */
+export declare const RESPONSIBILITY_PROFILE = "yarramate/policy@0.2";
+export type ResponsibilityLetter = 'R' | 'C' | 'I';
+export declare const RESPONSIBILITY_KINDS: Readonly<Record<'responsible' | 'consulted' | 'informed', string>>;
+export declare const RESPONSIBILITY_LETTERS: Readonly<Record<string, ResponsibilityLetter>>;
+export declare const OWNER_PREDICATE = "yarramate/ownership/owner";
+/** The core kinds a person subject may be, ancestors of any profile's own. */
+export declare const PEOPLE_KINDS: readonly string[];
+/**
+ * The letter a relationship kind carries, read through its lineage
+ * (ancestor-first) so a profile's own subkind of `responsible` is still an
+ * R; `null` for every other kind.
+ */
+export declare const responsibilityLetterOf: (lineage: readonly string[] | undefined, kind: string) => ResponsibilityLetter | null;
+/** Whether a concept kind is a person, read through its lineage. */
+export declare const isPeopleKind: (lineage: readonly string[] | undefined, kind: string) => boolean;

package/dist/responsibility-kinds.js

@@ -0,0 +1,43 @@
+/**
+ * The three responsibility relationship kinds and the letters they carry
+ * (#557, ADR 0159): `yarramate/policy@0.2#responsible`, `#consulted` and
+ * `#informed`, each a subkind of core `association` from a person to the
+ * subject they answer for. Accountable is not a kind: it is the existing
+ * `yarramate/ownership/owner` claim. Pure, so the canvas projection, the
+ * matrix builder and the editor read one table.
+ */
+export const RESPONSIBILITY_PROFILE = 'yarramate/policy@0.2';
+export const RESPONSIBILITY_KINDS = {
+    responsible: `${RESPONSIBILITY_PROFILE}#responsible`,
+    consulted: `${RESPONSIBILITY_PROFILE}#consulted`,
+    informed: `${RESPONSIBILITY_PROFILE}#informed`,
+};
+export const RESPONSIBILITY_LETTERS = {
+    [RESPONSIBILITY_KINDS.responsible]: 'R',
+    [RESPONSIBILITY_KINDS.consulted]: 'C',
+    [RESPONSIBILITY_KINDS.informed]: 'I',
+};
+export const OWNER_PREDICATE = 'yarramate/ownership/owner';
+/** The core kinds a person subject may be, ancestors of any profile's own. */
+export const PEOPLE_KINDS = [
+    'yarramate/core@0.1#businessActor',
+    'yarramate/core@0.1#businessRole',
+    'yarramate/core@0.1#businessCollaboration',
+    'yarramate/core@0.1#stakeholder',
+];
+/**
+ * The letter a relationship kind carries, read through its lineage
+ * (ancestor-first) so a profile's own subkind of `responsible` is still an
+ * R; `null` for every other kind.
+ */
+export const responsibilityLetterOf = (lineage, kind) => {
+    for (const member of lineage ?? [kind]) {
+        const letter = RESPONSIBILITY_LETTERS[member];
+        if (letter !== undefined)
+            return letter;
+    }
+    return RESPONSIBILITY_LETTERS[kind] ?? null;
+};
+/** Whether a concept kind is a person, read through its lineage. */
+export const isPeopleKind = (lineage, kind) => (lineage ?? [kind]).some((member) => PEOPLE_KINDS.includes(member)) ||
+    PEOPLE_KINDS.includes(kind);