yarramate 1.3.0 → 1.4.0

package/dist/design-command.js

@@ -282,9 +282,20 @@ export function runDesignCommand(options, cwd) {
             '',
         ];
         if (step === null) {
-            lines.push(subjectFilter === undefined
-                ? 'Interview complete: no open questions. The model answers everything the catalogue asks.'
-                : `Interview complete for ${subjectFilter}: no open questions touch it.`);
+            // "No open questions" has two causes and only one of them is complete
+            // (#334). Every wave gated shut asks NOTHING, so a blank model reaches
+            // zero without a single question having been put - and claiming the
+            // model answers everything the catalogue asks is then flatly false
+            // about a catalogue that asked nothing. Completion inferred from an
+            // empty set is the same fault the wave rail and the report renderer
+            // each carried; this is the sentence an agent reads to decide it is
+            // done, so it is the worst place for it.
+            const asked = report.waves.some((wave) => wave.questions.length > 0);
+            lines.push(!asked
+                ? 'No wave has opened yet: this catalogue asks nothing until the model has substance. Declare a subject and run this again.'
+                : subjectFilter === undefined
+                    ? 'Interview complete: no open questions. The model answers everything the catalogue asks.'
+                    : `Interview complete for ${subjectFilter}: no open questions touch it.`);
         }
         else {
             // --facilitate prefers the workshop phrasing and falls back to the

package/dist/graph-projection.d.ts

@@ -14,6 +14,16 @@ export interface CanvasNode {
      * profile kind it was authored as.
      */
     readonly coreKindLabel: string;
+    /**
+     * The core relationship kinds this node's PATTERN ports, or `[]` where its
+     * kind has no pattern with ports (#268 phase 3, ADR 0124).
+     *
+     * A macro edge needs both ends to port its kind, so an editor offering a
+     * palette between two instances intersects the two lists. Two raw groupings
+     * permit ten of the eleven kinds, which is no guidance at all; this is what
+     * restores the narrowing the relationship table gives everywhere else.
+     */
+    readonly portKinds: readonly string[];
     readonly layer: Layer | null;
     readonly aspect: Aspect | null;
     readonly name: string;

package/dist/graph-projection.js

@@ -119,6 +119,7 @@ const projectConcept = (subjectId, claims, profileContext) => {
         kind,
         kindLabel: kindLabelOf(kind),
         coreKindLabel: kindLabelOf(profileContext.conceptKindLineages.get(kind)?.[0] ?? kind),
+        portKinds: profileContext.patternPortKinds.get(kind) ?? [],
         layer: profileContext.conceptKindLayers.get(kind) ?? null,
         aspect: profileContext.conceptKindAspects.get(kind) ?? null,
         name: claimValue(nameClaim),

package/dist/interrogate-command.d.ts

@@ -87,6 +87,8 @@ export type CatalogueCondition = {
     readonly condition: 'unscoped-succession';
 } | {
     readonly condition: 'unchallenged-evidence';
+} | {
+    readonly condition: 'has-any-subject';
 };
 /**
  * One observation from the workspace's evidence overlay, reduced to what
@@ -131,6 +133,11 @@ export interface QuestionCatalogue {
         readonly id: string;
         readonly name: string;
         readonly description?: string;
+        /**
+         * Conditions that must all hold before this wave opens (#334, ADR 0125).
+         * Absent means always open, which is what every wave did before this.
+         */
+        readonly opensWhen?: readonly CatalogueCondition[];
     }[];
     readonly questions: readonly CatalogueQuestion[];
 }
@@ -161,6 +168,16 @@ export interface ReportQuestion {
 export interface ReportWave {
     readonly id: string;
     readonly name: string;
+    /**
+     * Whether the wave's gate is met (#334, ADR 0125). A wave with no
+     * `opensWhen` is always open.
+     *
+     * A wave reported `false` carries NO questions and contributes nothing to
+     * the summary. Its questions are premature rather than answered, and a
+     * progress rail that counted them as answered would flatter itself exactly
+     * where someone is most likely to trust it.
+     */
+    readonly opened: boolean;
     readonly questions: readonly ReportQuestion[];
 }
 export interface InterrogationSummary {

package/dist/interrogate-command.js

@@ -238,6 +238,13 @@ const linkageHits = (index, condition, subjectId, profileContext) => {
 };
 const conditionHolds = (index, condition, subjectId, profileContext, evidence) => {
     switch (condition.condition) {
+        case 'has-any-subject':
+            // The guard a late wave needs to say "only once the model has
+            // substance" (#334). An empty model is not an architecture at rest -
+            // ADR 0120's reading, which stays true for a model that HAS started -
+            // it has not begun, and asking it how the planned architecture becomes
+            // real greets someone ahead of question one.
+            return index.concepts.size > 0;
         case 'unchallenged-evidence':
             // Fires where the overlay records observations and every one is a
             // frictionless confirmation: no contradicted, unknown, or
@@ -449,56 +456,71 @@ export function evaluateCatalogue(catalogue, graph, profileContext, evidence) {
     let open = 0;
     let openQuestions = 0;
     const applicableQuestions = catalogue.questions.filter((question) => questionIsApplicable(question, graph.profiles));
+    const waveOpens = (wave) => wave.opensWhen === undefined ||
+        wave.opensWhen.every((condition) => conditionHolds(index, condition, undefined, profileContext, evidence));
     const waves = catalogue.waves.map((wave) => ({
         id: wave.id,
         name: wave.name,
-        questions: applicableQuestions
-            .filter((question) => question.wave === wave.id)
-            .map((question) => {
-            const base = {
-                id: question.id,
-                scope: question.scope,
-                authority: question.authority,
-                question: question.question.trim(),
-                materiality: question.materiality.trim(),
-                resolution: question.resolution.trim(),
-                trigger: question.trigger,
-                ...(question.since === undefined ? {} : { since: question.since }),
-            };
-            if (question.scope === 'workspace') {
-                const isOpen = question.trigger.every((condition) => conditionHolds(index, condition, undefined, profileContext, evidence));
-                if (isOpen) {
-                    open += 1;
-                    openQuestions += 1;
+        opened: waveOpens(wave),
+        // A closed wave asks nothing. Its questions are not evaluated at all,
+        // rather than evaluated and reported closed - the latter would say they
+        // had been asked and answered - so they reach neither the report nor the
+        // summary.
+        questions: !waveOpens(wave)
+            ? []
+            : applicableQuestions
+                .filter((question) => question.wave === wave.id)
+                .map((question) => {
+                const base = {
+                    id: question.id,
+                    scope: question.scope,
+                    authority: question.authority,
+                    question: question.question.trim(),
+                    materiality: question.materiality.trim(),
+                    resolution: question.resolution.trim(),
+                    trigger: question.trigger,
+                    ...(question.since === undefined ? {} : { since: question.since }),
+                };
+                if (question.scope === 'workspace') {
+                    const isOpen = question.trigger.every((condition) => conditionHolds(index, condition, undefined, profileContext, evidence));
+                    if (isOpen) {
+                        open += 1;
+                        openQuestions += 1;
+                    }
+                    return { ...base, open: isOpen };
                 }
-                return { ...base, open: isOpen };
-            }
-            const matches = selectSubjects(index, question.subjects, profileContext).filter((id) => question.trigger.every((condition) => conditionHolds(index, condition, id, profileContext, evidence)));
-            if (matches.length === 0) {
-                return { ...base, open: false };
-            }
-            open += matches.length;
-            openQuestions += 1;
-            return {
-                ...base,
-                open: true,
-                subjects: matches.map((id) => {
-                    const name = index.nameOf.get(id);
-                    return {
-                        id,
-                        ...(name === undefined ? {} : { name }),
-                        question: renderQuestion(question.question, id, name, describeCounterparts(index, question, id)),
-                    };
-                }),
-            };
-        }),
+                const matches = selectSubjects(index, question.subjects, profileContext).filter((id) => question.trigger.every((condition) => conditionHolds(index, condition, id, profileContext, evidence)));
+                if (matches.length === 0) {
+                    return { ...base, open: false };
+                }
+                open += matches.length;
+                openQuestions += 1;
+                return {
+                    ...base,
+                    open: true,
+                    subjects: matches.map((id) => {
+                        const name = index.nameOf.get(id);
+                        return {
+                            id,
+                            ...(name === undefined ? {} : { name }),
+                            question: renderQuestion(question.question, id, name, describeCounterparts(index, question, id)),
+                        };
+                    }),
+                };
+            }),
     }));
     return {
         format: 'yarramate/interrogation-report/v1',
         catalogue: `${catalogue.id}@${catalogue.version}`,
         semantics: INTERROGATION_SEMANTICS_VERSION,
         summary: {
-            questions: applicableQuestions.length,
+            // Questions in OPENED waves only (#334, ADR 0125). A closed wave's
+            // questions have not been asked, so counting them in the denominator
+            // would report them as answered - "3 of 51" reading as forty-eight
+            // done when forty-eight were never put. The denominator grows as the
+            // model gains substance and waves open, which is the interview
+            // revealing itself rather than a rail filling up.
+            questions: waves.reduce((total, wave) => total + wave.questions.length, 0),
             openQuestions,
             open,
         },
@@ -538,6 +560,16 @@ export function renderInterrogationReport(report) {
     ];
     for (const wave of report.waves) {
         lines.push('', `== ${wave.name} ==`);
+        // A wave that has not opened must not read like one whose questions are
+        // all closed (#334). Both carry no OPEN questions, and a bare heading with
+        // nothing under it is the more flattering of the two readings: "nothing
+        // outstanding here" rather than "nobody has been asked anything here".
+        // The same shape - completion inferred from an empty set - was found in a
+        // consuming product's wave rail on the same day.
+        if (!wave.opened) {
+            lines.push('  not yet — this wave has not opened');
+            continue;
+        }
         for (const question of wave.questions) {
             if (!question.open) {
                 lines.push(`  closed ${question.id}`);

package/dist/relationship-drafting.js

@@ -33,9 +33,24 @@ export const connectableKinds = (graph, fromId, toId) => {
         !isCoreConceptKindId(to.coreKindLabel)) {
         return [];
     }
-    return [
+    const permitted = [
         ...permittedRelationshipKinds(from.coreKindLabel, to.coreKindLabel),
     ].sort();
+    // Between two PATTERN INSTANCES the ports are the narrowing (#268 phase 3,
+    // ADR 0124). Two raw groupings permit ten of the eleven kinds, which is no
+    // guidance at all, and an edge between two instances is a macro edge -
+    // which phase 2 expands only where BOTH patterns port its kind, so an
+    // offer wider than the intersection would propose edges that expand into
+    // nothing. Where either end has no ports there is no macro grain to speak
+    // of, and the table's own answer stands.
+    if (from.portKinds.length === 0 || to.portKinds.length === 0)
+        return permitted;
+    const ported = new Set(to.portKinds);
+    const narrowed = permitted.filter((kind) => from.portKinds.includes(kind) && ported.has(kind));
+    // A pattern whose ports the table forbids between these two would narrow to
+    // nothing, and an empty palette makes the edge undrawable rather than
+    // guided. The table's answer is the honest fallback.
+    return narrowed.length === 0 ? permitted : narrowed;
 };
 /**
  * An id for a new relationship, unique across the graph.