yarramate 1.34.0 → 1.35.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/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/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') {