yarramate 1.13.1 → 1.14.0

package/catalogues/core-enrichment.yaml

@@ -1,6 +1,6 @@
 format: yarramate/question-catalogue/v1
 id: core-enrichment
-version: "1.3"
+version: "2.0"
 profile: yarramate/core@0.1
 presentation:
   title: Core enrichment interview
@@ -36,21 +36,35 @@ waves:
     name: Application
     description: >-
       How declared services are realized, performed, and fed with
-      information.
+      information. Waits for a declared service, because that is what this
+      wave asks about the realization of. The kinds here are exactly the ones
+      `no-service-declared` asks for, so this wave opens precisely when that
+      question closes.
     opensWhen:
-      - condition: has-any-subject
+      - condition: has-subject-of-kind
+        kinds:
+          - yarramate/core@0.1#businessService
+          - yarramate/core@0.1#applicationService
+          - yarramate/core@0.1#technologyService
   - id: technology
     name: Technology
     description: >-
       Where the declared applications actually run and what materializes
-      them.
+      them. Waits for a declared application component, because asking
+      where something runs before anything is declared to run is a question
+      with no subject.
     opensWhen:
-      - condition: has-any-subject
+      - condition: has-subject-of-kind
+        kinds:
+          - yarramate/core@0.1#applicationComponent
   - id: implementation
     name: Implementation
     description: >-
       How the planned architecture becomes real: work, deliverables, and
-      the plateaus between here and there.
+      the plateaus between here and there. NOT phase-gated, deliberately:
+      every candidate gate names something this wave exists to elicit, and
+      a declared state compiles to a plateau, which closes this wave's own
+      lead question. See ADR 0136.
     opensWhen:
       - condition: has-any-subject
   - id: hygiene
@@ -918,6 +932,26 @@ questions:
       seven usually carries the whole conversation — and relate each to
       the services or components that realize it with realization.
 
+  - id: no-component-declared
+    wave: business
+    since: "2.0"
+    scope: workspace
+    trigger:
+      - condition: no-subject-of-kind
+        kinds:
+          - yarramate/core@0.1#applicationComponent
+    question: >-
+      What software actually implements these services?
+    askPlain: >-
+      In plain terms: which applications or systems does this run on?
+    materiality: >-
+      A model with services and nothing implementing them cannot say where
+      anything runs, so the whole technology conversation has no subject.
+      This question exists to keep that conversation reachable: the
+      technology wave opens exactly when this question closes (ADR 0136).
+    authority: human
+    resolution: >-
+      Add the application components that implement the declared services.
   - id: no-contract-declared
     wave: business
     since: "1.2"

package/dist/interrogate-command.d.ts

@@ -62,6 +62,34 @@ export type CatalogueCondition = {
     readonly condition: 'has-subject-of-kind';
     readonly kinds: readonly string[];
     readonly kindMatching?: 'exact' | 'descendants';
+} | {
+    /**
+     * The cardinality member of the same family, workspace-scope like the
+     * other two (#411). Fires while FEWER than `atLeast` subjects of the
+     * named kinds exist, so `no-subject-of-kind` is its `atLeast: 1` case.
+     *
+     * It exists because a **vocabulary question** — "which data sensitivity
+     * classes does this platform recognise?" — had no way to say it wanted
+     * more than one term. `no-subject-of-kind` closes on the first
+     * instance, so a one-term vocabulary was indistinguishable from a
+     * complete one, and an adopter measured two live cases where a class
+     * authored incidentally to answer a different question closed the
+     * vocabulary question before it was ever asked.
+     *
+     * `atLeast` is required and must be at least 2 (`YM918`): 1 is
+     * `no-subject-of-kind` spelled a second way, and 0 is a condition that
+     * can never fire, which is what `YM914` exists to refuse.
+     *
+     * Deliberately NOT a general numeric comparison. A kind's population
+     * against a floor is the whole need, and the narrow condition is the
+     * same trade that kept `has-subject-of-kind` a twin rather than a
+     * predicate: a vocabulary of parameterised comparisons is a query
+     * language, which this design declines.
+     */
+    readonly condition: 'below-subject-count';
+    readonly kinds: readonly string[];
+    readonly atLeast: number;
+    readonly kindMatching?: 'exact' | 'descendants';
 } | {
     readonly condition: 'no-state-defined';
 } | {

package/dist/interrogate-command.js

@@ -200,6 +200,7 @@ const namedKinds = (question) => {
             case 'missing-relationship':
             case 'no-subject-of-kind':
             case 'has-subject-of-kind':
+            case 'below-subject-count':
             case 'missing-constraint':
                 kinds.push(...condition.kinds);
                 break;
@@ -263,6 +264,7 @@ const CONDITION_SCOPE = {
     'has-any-subject': 'workspace',
     'no-subject-of-kind': 'workspace',
     'has-subject-of-kind': 'workspace',
+    'below-subject-count': 'workspace',
     'no-state-defined': 'workspace',
     'exists-linkage': 'workspace',
     'missing-claim': 'subject',
@@ -377,6 +379,27 @@ const conditionHolds = (index, condition, subjectId, profileContext, evidence, m
             const matching = condition.kindMatching ?? 'descendants';
             return [...index.concepts].some((id) => kindMatches(index.kindOf.get(id), condition.kinds, matching, profileContext));
         }
+        case 'below-subject-count': {
+            // Counts, then compares. Written as its own count rather than as
+            // `!has-subject-of-kind` plus arithmetic so the degenerate reading
+            // stays visible: at `atLeast: 1` this IS `no-subject-of-kind`, which
+            // is why the loader refuses that spelling rather than quietly
+            // accepting two names for one condition.
+            //
+            // Stops at the threshold instead of counting the whole workspace: the
+            // answer is a comparison, not a tally, and a model with ten thousand
+            // subjects of a kind should cost the same as one with two.
+            const matching = condition.kindMatching ?? 'descendants';
+            let seen = 0;
+            for (const id of index.concepts) {
+                if (kindMatches(index.kindOf.get(id), condition.kinds, matching, profileContext)) {
+                    seen += 1;
+                    if (seen >= condition.atLeast)
+                        return false;
+                }
+            }
+            return true;
+        }
         case 'no-state-defined':
             return !index.hasStates;
         case 'missing-linkage':
@@ -633,6 +656,59 @@ patternMemberships) {
  * wave never opens and carries no questions at all - one typo silently
  * retiring a wave (#351).
  */
+/**
+ * Every condition the catalogue holds, gate and trigger alike, with the path
+ * that locates it. `kindReferencesOf` walks the same two places for kinds;
+ * this walks them for the conditions themselves, so a check about a
+ * condition's own shape does not have to re-derive where conditions live.
+ */
+const conditionsOf = (catalogue) => {
+    const found = [];
+    catalogue.waves.forEach((wave, waveIndex) => {
+        ;
+        (wave.opensWhen ?? []).forEach((condition, conditionIndex) => {
+            found.push({
+                condition,
+                path: ['waves', waveIndex, 'opensWhen', conditionIndex],
+            });
+        });
+    });
+    catalogue.questions.forEach((question, questionIndex) => {
+        question.trigger.forEach((condition, conditionIndex) => {
+            found.push({
+                condition,
+                path: ['questions', questionIndex, 'trigger', conditionIndex],
+            });
+        });
+    });
+    return found;
+};
+/**
+ * `YM918`: `below-subject-count` must ask for at least two (#411).
+ *
+ * `atLeast: 1` is `no-subject-of-kind` under a second name, and this design
+ * refuses second spellings of one meaning wherever it finds them. `atLeast: 0`
+ * is worse: the count can never be below zero, so the question can never fire,
+ * which is what `YM914` refuses from a different cause.
+ *
+ * The message names `no-subject-of-kind` rather than stating a bound, because
+ * an author who wrote `atLeast: 1` did not make an arithmetic mistake. They
+ * wanted the condition that already exists.
+ */
+const subjectCountFloorDiagnostics = ({ catalogue, locate, }) => conditionsOf(catalogue).flatMap(({ condition, path }) => condition.condition === 'below-subject-count' && condition.atLeast < 2
+    ? [
+        {
+            severity: 'error',
+            code: 'YM918',
+            message: `Condition "below-subject-count" asks for atLeast ${condition.atLeast}, ` +
+                (condition.atLeast === 1
+                    ? 'which is what "no-subject-of-kind" already asks. Use that condition instead.'
+                    : 'so a count could never fall below it and the question could never fire. ' +
+                        'Ask for at least 2, or use "no-subject-of-kind" for the presence case.'),
+            ...locate([...path, 'atLeast']),
+        },
+    ]
+    : []);
 const kindReferencesOf = (catalogue) => {
     const found = [];
     const fromCondition = (condition, path) => {
@@ -1037,6 +1113,7 @@ export function composeCatalogues(sources, profileContext) {
     const crossDiagnostics = documents.flatMap((document) => [
         ...undeclaredWaveDiagnostics(document, declaredWaves),
         ...gateScopeDiagnostics(document),
+        ...subjectCountFloorDiagnostics(document),
         ...unresolvableKindDiagnostics(document, profileContext),
         ...unauthorableOfferDiagnostics(document, profileContext),
     ]);
@@ -1078,6 +1155,12 @@ export function loadQuestionCatalogue(catalogueSource, profileContext) {
     if (scopeDiagnostics.length > 0) {
         return { ok: false, diagnostics: scopeDiagnostics };
     }
+    // Beside the scope check and for the same reason: a threshold below 2 is
+    // wrong on the condition's own terms, with no profile context needed.
+    const floorDiagnostics = subjectCountFloorDiagnostics(loaded.document);
+    if (floorDiagnostics.length > 0) {
+        return { ok: false, diagnostics: floorDiagnostics };
+    }
     const kindDiagnostics = unresolvableKindDiagnostics(loaded.document, profileContext);
     if (kindDiagnostics.length > 0) {
         return { ok: false, diagnostics: kindDiagnostics };