yarramate 1.16.0 → 1.18.0

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

@@ -624,6 +624,8 @@ export const startVisualServer = async (options) => {
                 // Threaded whole (ADR 0131): a narrow copy here is how a slot
                 // question would silently never fire in the embedded pane.
                 patternMemberships: compiled.patternMemberships,
+                // The vacant half, on the same rule (#447).
+                patternVacancies: compiled.patternVacancies,
             };
             const workspaceModel = renderedWorkspaceOf(compiledWorkspace, views, {
                 authority: rendered.authority,

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

@@ -4,7 +4,7 @@ import type { ResolvedWorkspace } from "../../workspace.js";
 import type { VisualDiagnostic, VisualViewOperation } from "./protocol-contract.js";
 import type { ProjectionDefinition, ProjectionExclusion, ProjectionQuery } from "../../projection.js";
 import type { ResolvedProfileContext, SemanticGraph } from "../../compiler.js";
-import { type CataloguePatternMembership } from "../../interrogate-command.js";
+import { type CataloguePatternMembership, type CataloguePatternVacancy } from "../../interrogate-command.js";
 import type { VisualKindOption, VisualViewSummary } from "./protocol-contract.js";
 import type { VisualInterrogationOverlay, VisualRenderedModel } from "./wire.js";
 /**
@@ -60,6 +60,8 @@ export declare const interrogationOverlayOf: (compiled: {
     readonly profileContext: ResolvedProfileContext;
     /** From the compilation (ADR 0131); absent, slot questions stay quiet. */
     readonly patternMemberships?: readonly CataloguePatternMembership[];
+    /** From the compilation (#447); absent, `missing-part` stays quiet. */
+    readonly patternVacancies?: readonly CataloguePatternVacancy[];
 }, 
 /**
  * The catalogue, or the composed SET a workspace carries (#345, ADR 0129).
@@ -94,6 +96,8 @@ export declare const renderedWorkspaceOf: (compiled: {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
     readonly patternMemberships?: readonly CataloguePatternMembership[];
+    /** Threaded on to the overlay (#447); absent, `missing-part` stays quiet. */
+    readonly patternVacancies?: readonly CataloguePatternVacancy[];
 }, views: readonly VisualViewSummary[], metadata: Omit<VisualRenderedModel, "graph" | "vocabulary" | "interrogation">, catalogue?: {
     readonly path: string;
     readonly source: string;

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

@@ -64,7 +64,7 @@ dismissed = []) => {
     const composed = composeCatalogues(Array.isArray(catalogue) ? catalogue : [catalogue]);
     if (!composed.ok)
         return undefined;
-    const report = evaluateCatalogue(composed.composed.catalogue, compiled.graph, compiled.profileContext, undefined, composed.composed.catalogues, compiled.patternMemberships);
+    const report = evaluateCatalogue(composed.composed.catalogue, compiled.graph, compiled.profileContext, undefined, composed.composed.catalogues, compiled.patternMemberships, compiled.patternVacancies);
     const dismissedEverywhere = new Set(dismissed
         .filter(({ subject }) => subject === undefined)
         .map(({ questionId }) => questionId));

package/dist/ask-command.js

@@ -475,7 +475,7 @@ export function runAskCommand(options, cwd) {
             }, workspace, cwd), compilation.profileContext);
             if (!composed.ok)
                 return failed(composed.diagnostics);
-            const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships);
+            const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies);
             const result = {
                 format: 'yarramate/ask-result/v1',
                 workspace: workspace.id,
@@ -719,7 +719,7 @@ export function runAskCommand(options, cwd) {
                 evidenceObservations.push(...loaded.evidence.observations);
             }
             const report = {
-                ...evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships),
+                ...evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies),
                 workspace: workspace.id,
             };
             // Field by field, to fix key ORDER in the emitted JSON. Every optional
@@ -1021,7 +1021,7 @@ export function runAskCommand(options, cwd) {
                 return failed(loaded.diagnostics);
             evidenceDocuments.push(loaded.evidence);
         }
-        const report = evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships);
+        const report = evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies);
         const openQuestions = [];
         for (const wave of report.waves) {
             for (const question of wave.questions) {

package/dist/compiler.d.ts

@@ -109,6 +109,31 @@ export interface PatternMembership {
     readonly instance: string;
     readonly pattern: string;
 }
+/**
+ * One slot of one pattern instance that nothing is bound into (#447): the
+ * shape of a question a pattern already knows to ask. The mirror of
+ * {@link PatternMembership}, and it has to be a second array rather than a
+ * widening of that one, because a vacancy has no `member` and making that
+ * field optional would break every reader.
+ *
+ * `required` is here because a vacancy on a SUCCESSFUL compile can be a
+ * required slot after all. The first draft of this shape left the field out,
+ * reasoning that a required slot left unbound is `YM416` and so never reaches
+ * a result. That is true only of an instance that declares `parts`: a concept
+ * whose kind has a pattern but which declares no parts at all is not a
+ * `PatternInstance`, never reaches YM416, and compiles clean with every slot
+ * vacant. So the flag is load-bearing rather than permanently `false`, and it
+ * is the difference between "you have not decided this yet" and "this model
+ * does not stand up without it".
+ */
+export interface PatternVacancy {
+    readonly instance: string;
+    readonly pattern: string;
+    readonly slot: string;
+    readonly slotKind: string;
+    /** The pattern declares this part `required` (ADR 0123). */
+    readonly required: boolean;
+}
 export type CompilationResult = {
     readonly ok: true;
     readonly graph: SemanticGraph;
@@ -119,6 +144,8 @@ export type CompilationResult = {
      * to `evaluateCatalogue`, or `fills-pattern-slot` never fires.
      */
     readonly patternMemberships?: readonly PatternMembership[];
+    /** Same rule as `patternMemberships`, for the same reason (#447). */
+    readonly patternVacancies?: readonly PatternVacancy[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];
@@ -128,6 +155,7 @@ export type ContextualCompilationResult = {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
     readonly patternMemberships?: readonly PatternMembership[];
+    readonly patternVacancies?: readonly PatternVacancy[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];

package/dist/compiler.js

@@ -846,6 +846,18 @@ function compileWorkspaceResolved(parsed) {
         return diagnosticFailure(patternDiagnostics);
     }
     const patternInstances = [];
+    /**
+     * Concepts whose kind HAS a pattern but which declare no `parts` at all —
+     * the greenfield instance ADR 0123 named and left to a later phase, and the
+     * one an interview has the most to ask (#447).
+     *
+     * Deliberately NOT `patternInstances`. That list drives YM416, wiring
+     * expansion and membership, and adding these to it would start refusing
+     * workspaces that compile today. Instance-hood for the purpose of BEING
+     * ASKED is a wider question than instance-hood for the purpose of being
+     * expanded, so it gets its own list rather than a widened one.
+     */
+    const unbegunInstances = [];
     const documents = documentInputs.map(({ input, entry, fresh }) => {
         // Schema-checked by `parseWorkspaceSource`; the faults it found are the
         // `schemaDiagnostics` returned below, and they gate every later phase.
@@ -1562,9 +1574,17 @@ function compileWorkspaceResolved(parsed) {
             // A pattern instance is only COLLECTED here. What its slots bind may be
             // declared in any document, so the bindings cannot be checked until
             // every document has been read (#268, ADR 0123).
+            const conceptKindIdentity = selectedProfile.conceptKinds.get(concept.kind)?.identity ?? concept.kind;
+            if (concept.parts === undefined) {
+                // Nothing to bind and nothing to expand, but the kind still promises a
+                // shape, so the interview can still ask about it (#447).
+                const pattern = patternsByKind.get(conceptKindIdentity);
+                if (pattern !== undefined) {
+                    unbegunInstances.push({ instance: subject, pattern });
+                }
+            }
             if (concept.parts !== undefined) {
-                const kindIdentity = selectedProfile.conceptKinds.get(concept.kind)?.identity ??
-                    concept.kind;
+                const kindIdentity = conceptKindIdentity;
                 const pattern = patternsByKind.get(kindIdentity);
                 if (pattern === undefined) {
                     const where = location(['concepts', index, 'parts'], `/concepts/${index}/parts`);
@@ -2067,6 +2087,13 @@ function compileWorkspaceResolved(parsed) {
             else
                 group.push(entry);
         }
+        /**
+         * Every wire that wants to mint, keyed by the TRIPLE it names (#460).
+         * Collected across all instances before any is minted, because two wires
+         * belonging to different instances can name one triple and only one claim
+         * may survive.
+         */
+        const wireCandidates = new Map();
         for (const { instance, pattern, bindings, sourceOf } of patternInstances) {
             const boundTo = new Map();
             for (const [slot, target] of bindings) {
@@ -2173,36 +2200,89 @@ function compileWorkspaceResolved(parsed) {
                 }
                 if (satisfied)
                     continue;
-                const wireId = [
+                // Collected rather than minted, because whether this wire mints
+                // depends on wires belonging to OTHER instances (#460). Two wires can
+                // name one triple, and before this they both minted: two relationship
+                // claims for one relationship.
+                const key = `${from}\u0000${wire.kindIdentity}\u0000${to}`;
+                const candidate = {
                     instance,
-                    ...(wire.from === 'self' ? [] : [wire.from]),
-                    wire.coreKind,
-                    wire.to,
-                ].join('-');
-                if (declaredIds.has(wireId)) {
-                    diagnostics.push({
-                        severity: 'error',
-                        code: 'YM420',
-                        message: `The pattern for "${pattern.kindIdentity}" derives the wiring id ` +
-                            `"${wireId}" for "${instance}", which is already a declared subject`,
-                        path: where.path,
-                        pointer: where.pointer,
-                        line: where.line,
-                        column: where.column,
-                    });
-                    continue;
-                }
-                declaredIds.add(wireId);
-                subjects.push({ id: wireId, type: 'relationship' });
-                claims.push({
-                    id: wireId,
-                    subject: from,
-                    predicate: wire.kindIdentity,
-                    object: { ref: to },
-                    origin: 'declared',
-                    source: where,
+                    pattern,
+                    wire,
+                    from,
+                    to,
+                    where,
+                    owner: wire.from === 'self',
+                    wireId: [
+                        instance,
+                        ...(wire.from === 'self' ? [] : [wire.from]),
+                        wire.coreKind,
+                        wire.to,
+                    ].join('-'),
+                };
+                const group = wireCandidates.get(key);
+                if (group === undefined)
+                    wireCandidates.set(key, [candidate]);
+                else
+                    group.push(candidate);
+            }
+        }
+        // One claim per triple, whichever wires named it (#460, ADR 0141).
+        //
+        // OWNERSHIP decides the id, not walk order. A wire whose `from` is `self`
+        // owns the edge, because the edge leaves that instance; a wire whose
+        // `from` is a slot is a guest naming somebody else's edge, and defers. So
+        // an edge with an owner keeps the ADR 0123 id it has always had, and
+        // nothing moves for a workspace that compiles today.
+        //
+        // Where every wire is a guest the owner's wire is absent — typically its
+        // instance is greenfield, and an unbound slot wires nothing — so there is
+        // no ADR 0123 id to prefer and the id comes from the TRIPLE instead. That
+        // is stable under adding or removing further guests, which sorting a
+        // winner out of the guests would not be.
+        for (const [, group] of [...wireCandidates].sort(([left], [right]) => left.localeCompare(right))) {
+            const owners = group
+                .filter(({ owner }) => owner)
+                // Two owners on one triple cannot happen: `self` differs per instance,
+                // and within one instance YM315 already refuses two slots naming one
+                // subject. Sorted anyway rather than trusting that from a distance.
+                .sort((left, right) => left.wireId.localeCompare(right.wireId));
+            const winner = owners[0] ?? group[0];
+            if (winner === undefined)
+                continue;
+            // A group of ONE is not a collision and keeps its ADR 0123 id, always.
+            // This is the case that matters most, because a wire between two SLOTS
+            // of one pattern (`component --composition--> interface`) has no `self`
+            // endpoint and so no owner, yet nothing is competing with it. Deriving
+            // its id from the triple would rename every such edge in every
+            // workspace, which is exactly the migration ownership exists to avoid;
+            // ADR 0123's own worked example is one of them.
+            const wireId = group.length === 1 || owners.length > 0
+                ? winner.wireId
+                : [winner.from, winner.wire.coreKind, winner.to].join('-');
+            if (declaredIds.has(wireId)) {
+                diagnostics.push({
+                    severity: 'error',
+                    code: 'YM420',
+                    message: `The pattern for "${winner.pattern.kindIdentity}" derives the wiring id ` +
+                        `"${wireId}" for "${winner.instance}", which is already a declared subject`,
+                    path: winner.where.path,
+                    pointer: winner.where.pointer,
+                    line: winner.where.line,
+                    column: winner.where.column,
                 });
+                continue;
             }
+            declaredIds.add(wireId);
+            subjects.push({ id: wireId, type: 'relationship' });
+            claims.push({
+                id: wireId,
+                subject: winner.from,
+                predicate: winner.wire.kindIdentity,
+                object: { ref: winner.to },
+                origin: 'declared',
+                source: winner.where,
+            });
         }
     }
     // ---- macro edges through ports (#268 phase 2, ADR 0124) ------------------
@@ -2349,9 +2429,44 @@ function compileWorkspaceResolved(parsed) {
         left.pattern.localeCompare(right.pattern) ||
         left.instance.localeCompare(right.instance) ||
         left.slot.localeCompare(right.slot));
+    // The mirror (#447): one entry per slot nothing was bound into. Always
+    // emitted, possibly empty — an empty array is a workspace whose instances
+    // are fully bound, while a missing array is a caller that never looked.
+    //
+    // Derived from BOTH lists, and that is the substance of the thing. An
+    // instance that declares some parts is asked about the rest; an instance
+    // that declares none is asked about all of them, because a template nobody
+    // has begun filling in is the one with the most blanks, not the one with
+    // none. Reading only `patternInstances` here would have reported `[]` for
+    // it, and `[]` means "fully bound".
+    const patternVacancies = [
+        ...patternInstances.map(({ instance, pattern, bindings }) => ({
+            instance,
+            pattern,
+            bound: bindings,
+        })),
+        ...unbegunInstances.map(({ instance, pattern }) => ({
+            instance,
+            pattern,
+            bound: new Map(),
+        })),
+    ]
+        .flatMap(({ instance, pattern, bound }) => [...pattern.slots.values()]
+        .filter((slot) => !bound.has(slot.name))
+        .map((slot) => ({
+        instance,
+        pattern: pattern.kindIdentity,
+        slot: slot.name,
+        slotKind: slot.kindIdentity,
+        required: slot.required === true,
+    })))
+        .sort((left, right) => left.instance.localeCompare(right.instance) ||
+        left.pattern.localeCompare(right.pattern) ||
+        left.slot.localeCompare(right.slot));
     return {
         ok: true,
         patternMemberships,
+        patternVacancies,
         profileContext: {
             conceptKindLineages: immutableMap([...conceptKindByIdentity]
                 .sort(([left], [right]) => left.localeCompare(right))
@@ -2441,6 +2556,7 @@ export function compileWorkspace(sources) {
             ok: true,
             graph: result.graph,
             patternMemberships: result.patternMemberships,
+            patternVacancies: result.patternVacancies,
         }
         : result;
 }

package/dist/design-command.js

@@ -294,7 +294,7 @@ export function runDesignCommand(options, cwd) {
                 };
             }
         }
-        const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships);
+        const report = evaluateCatalogue(composed.composed.catalogue, compilation.graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships, compilation.patternVacancies);
         // Keyed by the QUALIFIED id, matching what the report now carries.
         const askPlainById = new Map(composed.composed.catalogue.questions.flatMap((question) => question.askPlain === undefined
             ? []

package/dist/index.d.ts

@@ -10,7 +10,7 @@ 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 type { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, PatternMembership, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
+export type { CompilationCache, CompilationResult, ContextualCompilationResult, IncrementalCompilationResult, ParsedWorkspaceSource, PatternMembership, PatternVacancy, Diagnostic, GraphClaim, GraphSource, SemanticGraph, ResolvedProfileContext, WorkspaceSource, } from './compiler.js';
 export { canonicalProjection, evaluateProjection, explainProjection, 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';
 export type { LifecycleStatus, ProjectionDefinition, ProjectionLoadResult, ProjectionResult, } from './projection.js';
@@ -19,4 +19,4 @@ export { applyOperations, landOperations, posixDirectoryOf, type ApplyInput, typ
 export { connectableKinds, draftRelationship, proposeRelationshipId, stagedSubjectIds, } from './relationship-drafting.js';
 export { draftConcept, proposeConceptId } from './concept-drafting.js';
 export { deletionBlockers, describeDeletion, draftDeletion, type DeletionBlocker, } from './deletion-drafting.js';
-export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, type CatalogueCondition, type CatalogueEvidenceObservation, type CataloguePatternMembership, type CatalogueLoadResult, type CatalogueQuestion, type CatalogueSelector, type InterrogationReport, type InterrogationSummary, type OpenSubject, type QuestionCatalogue, type ReportQuestion, type ReportWave, } from './interrogate-command.js';
+export { INTERROGATION_SEMANTICS_VERSION, composeCatalogues, qualifiedQuestionId, evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, renderQuestion, type CatalogueCondition, type CatalogueEvidenceObservation, type CataloguePatternMembership, type CataloguePatternVacancy, type CatalogueLoadResult, type CatalogueQuestion, type CatalogueSelector, type InterrogationReport, type InterrogationSummary, type OpenSubject, type QuestionCatalogue, type ReportQuestion, type ReportWave, } from './interrogate-command.js';

package/dist/interrogate-command.d.ts

@@ -174,6 +174,25 @@ export type CatalogueCondition = {
     readonly condition: 'fills-pattern-slot';
     readonly patternKinds?: readonly string[];
     readonly slots?: readonly string[];
+} | {
+    /**
+     * The subject is a pattern INSTANCE with a slot nothing is bound into
+     * (#447). The mirror of `fills-pattern-slot`, and the mechanism by which
+     * a pattern becomes a questionnaire: bare, it means any slot of this
+     * instance's pattern is unbound; `patternKinds` narrows by the pattern's
+     * kind identity and `slots` by part name, exactly as its mirror does.
+     *
+     * It fires for a REQUIRED slot too, but only where one can survive a
+     * compile: an instance that declares `parts` and omits a required one is
+     * YM416 and there is no result to read, while an instance that declares
+     * no `parts` at all never reaches YM416 and is exactly the greenfield
+     * case ADR 0123 left open. The vacancy row's `required` tells the two
+     * apart for the host; the condition itself does not read it, because a
+     * catalogue that wants only one of them says so with `slots`.
+     */
+    readonly condition: 'missing-part';
+    readonly patternKinds?: readonly string[];
+    readonly slots?: readonly string[];
 };
 /**
  * One observation from the workspace's evidence overlay, reduced to what
@@ -207,6 +226,26 @@ export interface CataloguePatternMembership {
     readonly instance: string;
     readonly pattern: string;
 }
+/**
+ * One vacant optional slot of one pattern instance, as interrogation reads
+ * it. Structural for the same reason {@link CataloguePatternMembership} is:
+ * a host passes `compilation.patternVacancies` and the compiler's types are
+ * never dragged into the pure engine entry. Only `missing-part` reads it.
+ */
+export interface CataloguePatternVacancy {
+    readonly instance: string;
+    readonly pattern: string;
+    readonly slot: string;
+    readonly slotKind: string;
+    /**
+     * The pattern declares this part required. The condition does NOT read it —
+     * a vacancy is a vacancy — but it travels because the host derives its
+     * answer shape from this row, and "you have not decided this yet" and "this
+     * model does not stand up without it" are different questions to put to a
+     * person (#447).
+     */
+    readonly required: boolean;
+}
 export interface CatalogueQuestion {
     readonly id: string;
     readonly wave: string;
@@ -329,7 +368,13 @@ catalogues?: readonly string[],
  * `catalogues` is a fifth: this signature is published and a consumer
  * already calls it.
  */
-patternMemberships?: readonly CataloguePatternMembership[]): Omit<InterrogationReport, 'workspace'>;
+patternMemberships?: readonly CataloguePatternMembership[], 
+/**
+ * Pattern vacancies from the compilation (#447) - pass
+ * `compilation.patternVacancies`, or `missing-part` conditions never fire.
+ * A seventh optional parameter for the same reason the sixth is one.
+ */
+patternVacancies?: readonly CataloguePatternVacancy[]): Omit<InterrogationReport, 'workspace'>;
 export type CatalogueLoadResult = {
     readonly ok: true;
     readonly catalogue: QuestionCatalogue;

package/dist/interrogate-command.js

@@ -274,10 +274,23 @@ const CONDITION_SCOPE = {
     'unscoped-succession': 'subject',
     'unchallenged-evidence': 'workspace',
     'fills-pattern-slot': 'subject',
+    'missing-part': 'subject',
 };
 export const conditionScope = (condition) => CONDITION_SCOPE[condition.condition];
-const conditionHolds = (index, condition, subjectId, profileContext, evidence, memberships) => {
+const conditionHolds = (index, condition, subjectId, profileContext, evidence, memberships, vacancies) => {
     switch (condition.condition) {
+        case 'missing-part':
+            // Absent vacancies stay quiet, exactly as absent memberships do below:
+            // the caller did not derive them, so what is unbound is unknown rather
+            // than nothing. An EMPTY array is the opposite and says so - every
+            // instance is fully bound (#447, CONTRIBUTING's second rule).
+            return (vacancies !== undefined &&
+                subjectId !== undefined &&
+                vacancies.some((vacancy) => vacancy.instance === subjectId &&
+                    (condition.patternKinds === undefined ||
+                        condition.patternKinds.includes(vacancy.pattern)) &&
+                    (condition.slots === undefined ||
+                        condition.slots.includes(vacancy.slot))));
         case 'fills-pattern-slot':
             // Absent memberships stay quiet: the caller did not derive them, so
             // participation is unknown, not absent — the same rule
@@ -553,13 +566,19 @@ catalogues,
  * `catalogues` is a fifth: this signature is published and a consumer
  * already calls it.
  */
-patternMemberships) {
+patternMemberships, 
+/**
+ * Pattern vacancies from the compilation (#447) - pass
+ * `compilation.patternVacancies`, or `missing-part` conditions never fire.
+ * A seventh optional parameter for the same reason the sixth is one.
+ */
+patternVacancies) {
     const index = indexGraph(graph);
     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, patternMemberships));
+        wave.opensWhen.every((condition) => conditionHolds(index, condition, undefined, profileContext, evidence, patternMemberships, patternVacancies));
     const waves = catalogue.waves.map((wave) => ({
         id: wave.id,
         name: wave.name,
@@ -584,7 +603,7 @@ patternMemberships) {
                     ...(question.since === undefined ? {} : { since: question.since }),
                 };
                 if (question.scope === 'workspace') {
-                    const isOpen = question.trigger.every((condition) => conditionHolds(index, condition, undefined, profileContext, evidence, patternMemberships));
+                    const isOpen = question.trigger.every((condition) => conditionHolds(index, condition, undefined, profileContext, evidence, patternMemberships, patternVacancies));
                     if (isOpen) {
                         open += 1;
                         openQuestions += 1;
@@ -600,7 +619,7 @@ patternMemberships) {
                 if (selected.length === 0) {
                     return { ...base, open: false, asked: false };
                 }
-                const matches = selected.filter((id) => question.trigger.every((condition) => conditionHolds(index, condition, id, profileContext, evidence, patternMemberships)));
+                const matches = selected.filter((id) => question.trigger.every((condition) => conditionHolds(index, condition, id, profileContext, evidence, patternMemberships, patternVacancies)));
                 if (matches.length === 0) {
                     return { ...base, open: false };
                 }