yarramate 1.6.0 → 1.8.0

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

@@ -124,6 +124,28 @@ const shippedCatalogue = (() => {
         return undefined;
     }
 })();
+/**
+ * The shipped catalogue plus the ones the workspace carries (#345, ADR 0129).
+ *
+ * A catalogue that cannot be read is SKIPPED rather than failing the session,
+ * which is what the shipped one already did: an interrogation overlay is a
+ * garnish on a model, and losing a session over it would be worse than losing
+ * the questions. `check` is where a broken catalogue is refused.
+ */
+const catalogueSetFor = (workspace) => {
+    if (shippedCatalogue === undefined)
+        return [];
+    const carried = [];
+    for (const path of workspace.questions ?? []) {
+        try {
+            carried.push({ path, source: readFileSync(path, "utf8") });
+        }
+        catch {
+            // Skipped, as above.
+        }
+    }
+    return [shippedCatalogue, ...carried];
+};
 /**
  * Takes one session terminal, whatever caused it: a reviewer's End, a child
  * that failed, a browser that never came back, a cancelling main agent, or a
@@ -598,6 +620,9 @@ export const startVisualServer = async (options) => {
             compiledWorkspace = {
                 graph: compiled.graph,
                 profileContext: compiled.profileContext,
+                // Threaded whole (ADR 0131): a narrow copy here is how a slot
+                // question would silently never fire in the embedded pane.
+                patternMemberships: compiled.patternMemberships,
             };
             const workspaceModel = renderedWorkspaceOf(compiledWorkspace, views, {
                 authority: rendered.authority,
@@ -612,7 +637,11 @@ export const startVisualServer = async (options) => {
                 // that. A staged view operation pins against these (ADR 0103), and a
                 // projection missing from the map is one the commit will create.
                 projectionDigests: projectionDigestsNow(),
-            }, shippedCatalogue);
+                // The shipped catalogue plus whatever this workspace carries (#345),
+                // so the pane asks the interview `design` asks over the same files.
+                // Read on each recompile rather than once per process, because a
+                // consultant authoring a question mid-session is the whole point.
+            }, catalogueSetFor(resolvedWorkspace));
             // Closures below retain this array, so refresh its contents without
             // replacing the identity the session started with.
             views.splice(0, views.length, ...workspaceModel.views);

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

@@ -4,6 +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 { VisualKindOption, VisualViewSummary } from "./protocol-contract.js";
 import type { VisualInterrogationOverlay, VisualRenderedModel } from "./wire.js";
 /**
@@ -57,10 +58,22 @@ export interface DismissedQuestion {
 export declare const interrogationOverlayOf: (compiled: {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
-}, catalogue: {
+    /** From the compilation (ADR 0131); absent, slot questions stay quiet. */
+    readonly patternMemberships?: readonly CataloguePatternMembership[];
+}, 
+/**
+ * The catalogue, or the composed SET a workspace carries (#345, ADR 0129).
+ * A set rather than one document so the pane asks the same interview the
+ * CLI does over the same workspace: an editor showing fewer questions than
+ * `design` does over the same files is a disagreement with no symptom.
+ */
+catalogue: {
     readonly path: string;
     readonly source: string;
-}, 
+} | readonly {
+    readonly path: string;
+    readonly source: string;
+}[], 
 /**
  * What the host has already dealt with (#328). Evaluation is unchanged and
  * the model is untouched: this decides only what the pane draws, because a
@@ -80,10 +93,14 @@ dismissed?: readonly DismissedQuestion[]) => VisualInterrogationOverlay | undefi
 export declare const renderedWorkspaceOf: (compiled: {
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
+    readonly patternMemberships?: readonly CataloguePatternMembership[];
 }, views: readonly VisualViewSummary[], metadata: Omit<VisualRenderedModel, "graph" | "vocabulary" | "interrogation">, catalogue?: {
     readonly path: string;
     readonly source: string;
-}, dismissed?: readonly DismissedQuestion[]) => {
+} | readonly {
+    readonly path: string;
+    readonly source: string;
+}[], dismissed?: readonly DismissedQuestion[]) => {
     readonly model: VisualRenderedModel;
     readonly views: readonly VisualViewSummary[];
 };

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

@@ -6,7 +6,7 @@ import { projectGraphForCanvas } from "../../graph-projection.js";
 import { DEFAULT_PROJECTION_DIRECTORY } from "./view-identity.js";
 import { evaluateProjection, explainProjection } from "../../projection.js";
 import { kindLabelOf } from "../../kind-label.js";
-import { evaluateCatalogue, loadQuestionCatalogue, } from "../../interrogate-command.js";
+import { evaluateCatalogue, composeCatalogues, } from "../../interrogate-command.js";
 /**
  * What a workspace looks like to the editor, however the editor is being run
  * (#252).
@@ -46,7 +46,14 @@ export const kindOptionsOf = (lineages) => [...lineages.keys()].map((id) => ({
  * them would read as five, and the reviewer counting boxes would find three.
  */
 export const conceptCountOf = (graph, query, profileContext) => evaluateProjection(graph, adHoc(query), profileContext).subjects.filter(({ type }) => type === "concept").length;
-export const interrogationOverlayOf = (compiled, catalogue, 
+export const interrogationOverlayOf = (compiled, 
+/**
+ * The catalogue, or the composed SET a workspace carries (#345, ADR 0129).
+ * A set rather than one document so the pane asks the same interview the
+ * CLI does over the same workspace: an editor showing fewer questions than
+ * `design` does over the same files is a disagreement with no symptom.
+ */
+catalogue, 
 /**
  * What the host has already dealt with (#328). Evaluation is unchanged and
  * the model is untouched: this decides only what the pane draws, because a
@@ -54,10 +61,10 @@ export const interrogationOverlayOf = (compiled, catalogue,
  * a pane embedded in it.
  */
 dismissed = []) => {
-    const loaded = loadQuestionCatalogue(catalogue);
-    if (!loaded.ok)
+    const composed = composeCatalogues(Array.isArray(catalogue) ? catalogue : [catalogue]);
+    if (!composed.ok)
         return undefined;
-    const report = evaluateCatalogue(loaded.catalogue, compiled.graph, compiled.profileContext);
+    const report = evaluateCatalogue(composed.composed.catalogue, compiled.graph, compiled.profileContext, undefined, composed.composed.catalogues, compiled.patternMemberships);
     const dismissedEverywhere = new Set(dismissed
         .filter(({ subject }) => subject === undefined)
         .map(({ questionId }) => questionId));

package/dist/artifact-coverage.d.ts

@@ -0,0 +1,13 @@
+export interface CoverageScopePattern {
+    readonly pattern: string;
+    /** Repository-relative files the pattern selected, sorted. */
+    readonly artifacts: readonly string[];
+}
+export type ArtifactCoverage = {
+    readonly assessed: false;
+    readonly reason: string;
+} | {
+    readonly assessed: true;
+    readonly scope: readonly CoverageScopePattern[];
+};
+export declare function deriveArtifactCoverage(manifestDirectory: string, patterns: readonly string[] | undefined): ArtifactCoverage;

package/dist/artifact-coverage.js

@@ -0,0 +1,58 @@
+import { spawnSync } from 'node:child_process';
+import { globSync } from 'node:fs';
+import { sep } from 'node:path';
+const runGit = (cwd, args) => spawnSync('git', ['-C', cwd, ...args], { encoding: 'utf8' });
+export function deriveArtifactCoverage(manifestDirectory, patterns) {
+    if (patterns === undefined) {
+        return {
+            assessed: false,
+            reason: 'the workspace manifest declares no coverage scope',
+        };
+    }
+    // The root is the git toplevel of the manifest's directory, never the
+    // process cwd: the same command must report the same coverage wherever it
+    // was invoked (the #216 bug shape), and the repository boundary is git's
+    // to draw, not a directory-layout guess.
+    const toplevel = runGit(manifestDirectory, [
+        'rev-parse',
+        '--show-toplevel',
+    ]);
+    if (toplevel.status !== 0) {
+        return {
+            assessed: false,
+            reason: 'the workspace does not live in a git repository',
+        };
+    }
+    const root = toplevel.stdout.trim();
+    // An artifact is any file git can see: tracked, or untracked and not
+    // ignored. Tracked-only would blind the report to exactly the newest
+    // files — the recurrence this feature exists to catch (ADR 0130).
+    const listed = runGit(root, [
+        'ls-files',
+        '-z',
+        '--cached',
+        '--others',
+        '--exclude-standard',
+    ]);
+    if (listed.status !== 0) {
+        return {
+            assessed: false,
+            reason: `git ls-files failed: ${(listed.stderr ?? '').trim()}`,
+        };
+    }
+    const visible = new Set((listed.stdout ?? '').split('\0').filter((path) => path.length > 0));
+    // Glob matches are intersected with git's view, so a symlink escaping the
+    // repository or a build tree git ignores cannot enter the artifact set
+    // however broad the glob. The intersection also drops directories: git
+    // lists files only.
+    return {
+        assessed: true,
+        scope: patterns.map((pattern) => ({
+            pattern,
+            artifacts: globSync(pattern, { cwd: root })
+                .map((path) => path.split(sep).join('/'))
+                .filter((path) => visible.has(path))
+                .sort((left, right) => left.localeCompare(right)),
+        })),
+    };
+}

package/dist/ask-command.js

@@ -9,7 +9,8 @@ import { runCheckCommand } from './check-command.js';
 import { diagnosticJson, humanDiagnostics, usage, } from './cli-support.js';
 import { compileWorkspaceWithProfileContext, } from './compiler.js';
 import { evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
-import { evaluateCatalogue, loadQuestionCatalogue, renderInterrogationReport, } from './interrogate-command.js';
+import { catalogueSources } from './catalogue-sources.js';
+import { evaluateCatalogue, composeCatalogues, renderInterrogationReport, } from './interrogate-command.js';
 import { buildNextSubjects, coverageClause, } from './next-command.js';
 import { conceptKinds, relationshipPolicies, } from './profile.js';
 import { ARCHIMATE_RELATIONSHIPS_VERSION, CORE_CONCEPT_KIND_ORDER, PERMITTED_RELATIONSHIP_LETTERS, RELATIONSHIP_LETTERS, } from './archimate-relationships.generated.js';
@@ -468,13 +469,13 @@ export function runAskCommand(options, cwd) {
             const planned = buildNextSubjects(wholeWorkspace, compilation.graph, compilation.profileContext, evaluation.reports);
             const current = entries.filter(({ status }) => status === 'current');
             const retired = entries.filter(({ status }) => status === 'retired');
-            const loadedCatalogue = loadQuestionCatalogue({
+            const composed = composeCatalogues(catalogueSources({
                 path: shippedCataloguePath,
                 source: readFileSync(shippedCataloguePath, 'utf8'),
-            }, compilation.profileContext);
-            if (!loadedCatalogue.ok)
-                return failed(loadedCatalogue.diagnostics);
-            const report = evaluateCatalogue(loadedCatalogue.catalogue, compilation.graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations));
+            }, 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 result = {
                 format: 'yarramate/ask-result/v1',
                 workspace: workspace.id,
@@ -698,12 +699,12 @@ export function runAskCommand(options, cwd) {
             const resolvedCataloguePath = cataloguePath === undefined
                 ? shippedCataloguePath
                 : resolve(cwd, cataloguePath);
-            const loadedCatalogue = loadQuestionCatalogue({
+            const composed = composeCatalogues(catalogueSources({
                 path: cataloguePath ?? resolvedCataloguePath,
                 source: readFileSync(resolvedCataloguePath, 'utf8'),
-            }, compilation.profileContext);
-            if (!loadedCatalogue.ok)
-                return failed(loadedCatalogue.diagnostics);
+            }, workspace, cwd), compilation.profileContext);
+            if (!composed.ok)
+                return failed(composed.diagnostics);
             // The evidence overlay rides along for the one condition that
             // reads it (unchallenged-evidence); a workspace declaring no
             // evidence passes an overlay known to be empty.
@@ -718,13 +719,21 @@ export function runAskCommand(options, cwd) {
                 evidenceObservations.push(...loaded.evidence.observations);
             }
             const report = {
-                ...evaluateCatalogue(loadedCatalogue.catalogue, graph, compilation.profileContext, evidenceObservations),
+                ...evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceObservations, composed.composed.catalogues, compilation.patternMemberships),
                 workspace: workspace.id,
             };
+            // Field by field, to fix key ORDER in the emitted JSON. Every optional
+            // field has to be threaded through explicitly, which is why `catalogues`
+            // is here: a copier like this drops a new field silently and the only
+            // symptom is an absent one, which reads as "did not apply" rather than
+            // as "was lost".
             const ordered = {
                 format: report.format,
                 workspace: report.workspace,
                 catalogue: report.catalogue,
+                ...(report.catalogues === undefined
+                    ? {}
+                    : { catalogues: report.catalogues }),
                 semantics: report.semantics,
                 summary: report.summary,
                 waves: report.waves,
@@ -993,12 +1002,12 @@ export function runAskCommand(options, cwd) {
         const resolvedCataloguePath = cataloguePath === undefined
             ? shippedCataloguePath
             : resolve(cwd, cataloguePath);
-        const loadedCatalogue = loadQuestionCatalogue({
+        const composed = composeCatalogues(catalogueSources({
             path: cataloguePath ?? resolvedCataloguePath,
             source: readFileSync(resolvedCataloguePath, 'utf8'),
-        }, compilation.profileContext);
-        if (!loadedCatalogue.ok)
-            return failed(loadedCatalogue.diagnostics);
+        }, workspace, cwd), compilation.profileContext);
+        if (!composed.ok)
+            return failed(composed.diagnostics);
         // Loaded ahead of evaluation so the overlay feeds the one condition
         // that reads it (unchallenged-evidence), then reused for the
         // reconciliation summary below.
@@ -1012,7 +1021,7 @@ export function runAskCommand(options, cwd) {
                 return failed(loaded.diagnostics);
             evidenceDocuments.push(loaded.evidence);
         }
-        const report = evaluateCatalogue(loadedCatalogue.catalogue, graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations));
+        const report = evaluateCatalogue(composed.composed.catalogue, graph, compilation.profileContext, evidenceDocuments.flatMap(({ observations }) => observations), composed.composed.catalogues, compilation.patternMemberships);
         const openQuestions = [];
         for (const wave of report.waves) {
             for (const question of wave.questions) {

package/dist/catalogue-sources.d.ts

@@ -0,0 +1,20 @@
+import type { WorkspaceSource } from './compiler.js';
+import type { ResolvedWorkspace } from './workspace.js';
+export declare const shippedCataloguePath: string;
+/** The base catalogue as a source, read from disk. */
+export declare const shippedCatalogueSource: () => WorkspaceSource;
+/**
+ * The catalogues a verb should compose: the base, then whatever the workspace
+ * carries (#345, ADR 0129).
+ *
+ * Built in ONE place because every verb that interviews has to make the same
+ * choice, and a verb that forgot the workspace half would silently ask fewer
+ * questions than the workspace declares - a failure with no symptom, which is
+ * the shape this repository keeps being bitten by.
+ *
+ * The base is REPLACED by `--catalogue` and ADDED TO by `questions:`. Those
+ * are different powers on purpose: a host controls the catalogue that is not
+ * in the workspace (#328), and a consultant adds to it mid-engagement without
+ * a product release.
+ */
+export declare const catalogueSources: (base: WorkspaceSource, workspace: Pick<ResolvedWorkspace, 'questions'>, cwd: string) => readonly WorkspaceSource[];

package/dist/catalogue-sources.js

@@ -0,0 +1,39 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+// The catalogue ships inside the package, versioned with it, and harnesses
+// never pass catalogue paths. The relative hop works from both src/ (dev) and
+// dist/ (shipped). Defined ONCE: `design`, `ask` and `check` all need it, and
+// three copies of a path constant is three chances for them to disagree about
+// which catalogue is the base.
+const here = dirname(fileURLToPath(import.meta.url));
+export const shippedCataloguePath = join(here, '..', 'catalogues', 'core-enrichment.yaml');
+/** The base catalogue as a source, read from disk. */
+export const shippedCatalogueSource = () => ({
+    path: shippedCataloguePath,
+    source: readFileSync(shippedCataloguePath, 'utf8'),
+});
+/**
+ * The catalogues a verb should compose: the base, then whatever the workspace
+ * carries (#345, ADR 0129).
+ *
+ * Built in ONE place because every verb that interviews has to make the same
+ * choice, and a verb that forgot the workspace half would silently ask fewer
+ * questions than the workspace declares - a failure with no symptom, which is
+ * the shape this repository keeps being bitten by.
+ *
+ * The base is REPLACED by `--catalogue` and ADDED TO by `questions:`. Those
+ * are different powers on purpose: a host controls the catalogue that is not
+ * in the workspace (#328), and a consultant adds to it mid-engagement without
+ * a product release.
+ */
+export const catalogueSources = (base, workspace, cwd) => [
+    base,
+    // `?? []` because `questions` is optional on the published type: adding a
+    // required field to `ResolvedWorkspace` broke a consumer's production module
+    // once already.
+    ...(workspace.questions ?? []).map((path) => ({
+        path,
+        source: readFileSync(resolve(cwd, path), 'utf8'),
+    })),
+];

package/dist/check-command.js

@@ -1,13 +1,15 @@
 import { existsSync, readFileSync } from 'node:fs';
+import { catalogueSources, shippedCatalogueSource, } from './catalogue-sources.js';
+import { composeCatalogues } from './interrogate-command.js';
 import { resolve } from 'node:path';
 import Ajv2020Module from 'ajv/dist/2020.js';
 import { parseDocument } from 'yaml';
 import { loadAdapterMapping, validateAdapterMappings, } from './adapter-mapping.js';
 import { checkResultJson, humanDiagnostics, resolveCliWorkspaceSources, sortDiagnostics, usage, } from './cli-support.js';
-import { compileWorkspace, withDiagnosticSubjects } from './compiler.js';
+import { compileWorkspaceWithProfileContext, withDiagnosticSubjects, } from './compiler.js';
 import { checkCoreContract, loadCoreContract, } from './core-contract.js';
 import { evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
-import { loadProjection } from './projection.js';
+import { loadProjection, projectionReferenceDiagnostics, } from './projection.js';
 import { reconcileEvidenceReports, } from './reconciliation.js';
 // `.default ?? module`, not a bare `.default`: NodeNext sees the raw CJS
 // `module.exports` and a bundler the unwrapped class. One shape for all of
@@ -138,13 +140,15 @@ export function runCheckCommand(options, cwd) {
                 : humanDiagnostics(contractDiagnostics);
             return { exitCode: 1, stdout: output, stderr: '' };
         }
-        const projectionDiagnostics = sortDiagnostics(resolved.projections.flatMap((path) => {
-            const loaded = loadProjection({
-                path,
-                source: readFileSync(resolve(cwd, path), 'utf8'),
-            });
-            return loaded.ok ? [] : loaded.diagnostics;
+        const projectionSources = resolved.projections.map((path) => ({
+            path,
+            source: readFileSync(resolve(cwd, path), 'utf8'),
+        }));
+        const loadedProjections = projectionSources.map((source) => ({
+            source,
+            loaded: loadProjection(source),
         }));
+        const projectionDiagnostics = sortDiagnostics(loadedProjections.flatMap(({ loaded }) => loaded.ok ? [] : loaded.diagnostics));
         if (projectionDiagnostics.length > 0) {
             const output = json
                 ? checkResultJson(false, projectionDiagnostics)
@@ -177,7 +181,7 @@ export function runCheckCommand(options, cwd) {
                 : humanDiagnostics(mappingLoadDiagnostics);
             return { exitCode: 1, stdout: output, stderr: '' };
         }
-        const result = compileWorkspace(coreSources);
+        const result = compileWorkspaceWithProfileContext(coreSources);
         const mappingValidation = result.ok
             ? validateAdapterMappings(result.graph, loadedMappings.flatMap((loaded) => loaded.ok ? [loaded.mapping] : []))
             : undefined;
@@ -190,9 +194,34 @@ export function runCheckCommand(options, cwd) {
         const evidenceDiagnostics = evidenceEvaluation === undefined || evidenceEvaluation.ok
             ? []
             : evidenceEvaluation.diagnostics;
+        // A catalogue the manifest declares is workspace content, so `check`
+        // refuses a broken one (#345, ADR 0129). Composed rather than checked one
+        // by one, because the refusals that matter are CROSS-catalogue: a wave
+        // declared twice, and a question naming a wave nothing in the set
+        // declares. Checking each file alone would miss both and would refuse the
+        // one thing the feature exists to allow, a question joining a wave another
+        // catalogue declared.
+        const catalogueDiagnostics = result.ok && resolved.questions.length > 0
+            ? (() => {
+                const composed = composeCatalogues(catalogueSources(shippedCatalogueSource(), resolved, cwd), result.profileContext);
+                return composed.ok ? [] : composed.diagnostics;
+            })()
+            : [];
+        // A projection is a document, and a query holds references the same way a
+        // relationship does. Checked HERE rather than with the projection's own
+        // schema load above, because a reference can only be resolved against a
+        // model that compiled: reporting dangling names out of a workspace that
+        // does not build would bury the real failure under its consequences.
+        const referenceDiagnostics = result.ok
+            ? loadedProjections.flatMap(({ source, loaded }) => loaded.ok
+                ? projectionReferenceDiagnostics(source, loaded.projection, result.graph, result.profileContext)
+                : [])
+            : [];
         const optionalDiagnostics = sortDiagnostics([
             ...mappingDiagnostics,
             ...evidenceDiagnostics,
+            ...referenceDiagnostics,
+            ...catalogueDiagnostics,
         ]);
         const ok = result.ok && optionalDiagnostics.length === 0;
         // Published results name the subject a diagnostic is about wherever its

package/dist/cli-support.d.ts

@@ -30,6 +30,13 @@ export declare const resolveCliWorkspaceSources: (paths: readonly string[], cwd:
     readonly contracts: readonly string[];
     /** Pattern documents, which ride in `paths` and are not documents. */
     readonly patterns: readonly string[];
+    /**
+     * Question catalogues the workspace carries (#345). Handed over rather
+     * than resolved-and-dropped, which is the #268 failure recorded below:
+     * a category a manifest declares and no verb receives is ignored with
+     * no symptom.
+     */
+    readonly questions: readonly string[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];

package/dist/cli-support.js

@@ -51,6 +51,7 @@ export const resolveCliWorkspaceSources = (paths, cwd, options = {}) => {
             evidence: [],
             contracts: [],
             patterns: [],
+            questions: [],
         };
     }
     const manifestPath = paths[0];
@@ -62,6 +63,7 @@ export const resolveCliWorkspaceSources = (paths, cwd, options = {}) => {
             evidence: [],
             contracts: [],
             patterns: [],
+            questions: [],
         };
     }
     const source = readFileSync(resolve(cwd, manifestPath), 'utf8');
@@ -73,6 +75,7 @@ export const resolveCliWorkspaceSources = (paths, cwd, options = {}) => {
             evidence: [],
             contracts: [],
             patterns: [],
+            questions: [],
         };
     }
     const loaded = loadWorkspaceManifest({ path: manifestPath, source }, cwd);
@@ -99,6 +102,7 @@ export const resolveCliWorkspaceSources = (paths, cwd, options = {}) => {
             evidence: loaded.workspace.evidence,
             contracts: loaded.workspace.contracts,
             patterns: loaded.workspace.patterns,
+            questions: loaded.workspace.questions ?? [],
         }
         : { ok: false, diagnostics: loaded.diagnostics };
 };

package/dist/cli.js

@@ -10,6 +10,7 @@ import { runExportCommand } from './export-command.js';
 import { runApplyCommand } from './apply-cli.js';
 import { runDesignCommand } from './design-command.js';
 import { evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
+import { deriveArtifactCoverage } from './artifact-coverage.js';
 import { deriveAttestationStaleness } from './attestation-staleness.js';
 import { reconcileEvidenceReports } from './reconciliation.js';
 import { loadWorkspaceManifest } from './workspace.js';
@@ -84,9 +85,13 @@ const runReconciliation = (options, cwd) => {
             source: readFileSync(resolve(cwd, path), 'utf8'),
             documentId: documentIdByPath.get(path) ?? path,
         })));
+        // Coverage anchors on the manifest's own directory, not the process
+        // cwd, so the same command reports the same coverage wherever it was
+        // invoked (ADR 0130).
+        const coverage = deriveArtifactCoverage(dirname(resolve(cwd, workspacePath)), loadedWorkspace.manifest.coverage);
         return {
             exitCode: 0,
-            stdout: `${JSON.stringify(reconcileEvidenceReports(loadedWorkspace.workspace.id, evaluation.reports, compilation.graph, staleness), null, 2)}\n`,
+            stdout: `${JSON.stringify(reconcileEvidenceReports(loadedWorkspace.workspace.id, evaluation.reports, compilation.graph, staleness, coverage), null, 2)}\n`,
             stderr: '',
         };
     }

package/dist/compiler.d.ts

@@ -94,9 +94,31 @@ export interface ResolvedProfileContext {
      */
     readonly permittedRelationshipKinds: (fromKindIdentity: string, toKindIdentity: string) => ReadonlySet<RelationshipKind> | undefined;
 }
+/**
+ * One slot of one pattern instance, and the subject bound into it
+ * (ADR 0131). Compile CONTEXT, not graph content: `parts` binds existing
+ * subjects (#268), the binding is consumed during expansion, and the graph
+ * stays indistinguishable from a hand-authored one — so the compile result
+ * is the only place this fact survives. `pattern` is the kind identity
+ * (`yarrasys/api-led@1.0#api`), the naming ADR 0129 chose: identity that
+ * travels, never a document path.
+ */
+export interface PatternMembership {
+    readonly member: string;
+    readonly slot: string;
+    readonly instance: string;
+    readonly pattern: string;
+}
 export type CompilationResult = {
     readonly ok: true;
     readonly graph: SemanticGraph;
+    /**
+     * Optional in the type although the compiler always emits it: this
+     * shape is published, and a required addition is free for readers
+     * and a break for constructors. Read it as `?? []` — and thread it
+     * to `evaluateCatalogue`, or `fills-pattern-slot` never fires.
+     */
+    readonly patternMemberships?: readonly PatternMembership[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];
@@ -105,6 +127,7 @@ export type ContextualCompilationResult = {
     readonly ok: true;
     readonly graph: SemanticGraph;
     readonly profileContext: ResolvedProfileContext;
+    readonly patternMemberships?: readonly PatternMembership[];
 } | {
     readonly ok: false;
     readonly diagnostics: readonly Diagnostic[];

package/dist/compiler.js

@@ -2332,8 +2332,24 @@ function compileWorkspaceResolved(parsed) {
     if (diagnostics.length > 0) {
         return diagnosticFailure(diagnostics);
     }
+    // Membership survives the compile as context (ADR 0131): one entry per
+    // bound slot, sorted so the emission is deterministic. Always emitted,
+    // possibly empty — an empty array is a workspace with no bindings, while
+    // an evaluation missing the array is a caller that never looked.
+    const patternMemberships = patternInstances
+        .flatMap(({ instance, pattern, bindings }) => [...bindings].map(([slot, member]) => ({
+        member,
+        slot,
+        instance,
+        pattern: pattern.kindIdentity,
+    })))
+        .sort((left, right) => left.member.localeCompare(right.member) ||
+        left.pattern.localeCompare(right.pattern) ||
+        left.instance.localeCompare(right.instance) ||
+        left.slot.localeCompare(right.slot));
     return {
         ok: true,
+        patternMemberships,
         profileContext: {
             conceptKindLineages: immutableMap([...conceptKindByIdentity]
                 .sort(([left], [right]) => left.localeCompare(right))
@@ -2418,7 +2434,13 @@ function compileWorkspaceResolved(parsed) {
 }
 export function compileWorkspace(sources) {
     const result = compileWorkspaceResolved(parseSources(sources).parsed);
-    return result.ok ? { ok: true, graph: result.graph } : result;
+    return result.ok
+        ? {
+            ok: true,
+            graph: result.graph,
+            patternMemberships: result.patternMemberships,
+        }
+        : result;
 }
 export const compileWorkspaceWithProfileContext = (sources) => compileWorkspaceResolved(parseSources(sources).parsed);
 /**