yarramate 0.6.0 → 0.7.0

package/dist/interrogate-command.js

@@ -0,0 +1,268 @@
+import Ajv2020Module from 'ajv/dist/2020.js';
+import { loadSourceDocument, locateSourcePath, } from './source-document.js';
+import catalogueSchema from '../schema/yarramate-question-catalogue.schema.json' with {
+    type: 'json'
+};
+const Ajv2020 = Ajv2020Module.default;
+const validateCatalogue = new Ajv2020({ allErrors: true }).compile(catalogueSchema);
+const indexGraph = (graph) => {
+    const relationshipIds = new Set(graph.subjects
+        .filter(({ type }) => type === 'relationship')
+        .map(({ id }) => id));
+    const stateSubjects = new Set(graph.claims
+        .filter(({ predicate }) => predicate === 'yarramate/state/type')
+        .map(({ subject }) => subject));
+    // Architecture states carry concept subjects in the graph but are not
+    // enrichment targets; the catalogue interrogates the model, not the
+    // planning overlay.
+    const concepts = new Set(graph.subjects
+        .filter(({ id, type }) => type === 'concept' && !stateSubjects.has(id))
+        .map(({ id }) => id));
+    const claimsBySubject = new Map();
+    const kindOf = new Map();
+    const nameOf = new Map();
+    const statusOf = new Map();
+    const relationshipClaims = [];
+    const referenceClaims = [];
+    for (const claim of graph.claims) {
+        const forSubject = claimsBySubject.get(claim.subject);
+        if (forSubject === undefined) {
+            claimsBySubject.set(claim.subject, [claim]);
+        }
+        else {
+            forSubject.push(claim);
+        }
+        if (relationshipIds.has(claim.id) && 'ref' in claim.object) {
+            relationshipClaims.push(claim);
+        }
+        else if ('ref' in claim.object) {
+            referenceClaims.push(claim);
+        }
+        if ('value' in claim.object) {
+            if (claim.predicate === 'yarramate/concept/kind') {
+                kindOf.set(claim.subject, claim.object.value);
+            }
+            else if (claim.predicate === 'yarramate/concept/name') {
+                nameOf.set(claim.subject, claim.object.value);
+            }
+            else if (claim.predicate === 'yarramate/lifecycle/status') {
+                statusOf.set(claim.subject, claim.object.value);
+            }
+        }
+    }
+    return {
+        concepts,
+        claimsBySubject,
+        relationshipClaims,
+        referenceClaims,
+        kindOf,
+        nameOf,
+        statusOf,
+        hasStates: stateSubjects.size > 0,
+    };
+};
+const kindMatches = (subjectKind, selectedKinds, matching, profileContext) => {
+    if (subjectKind === undefined)
+        return false;
+    return selectedKinds.some((selected) => selected === subjectKind ||
+        (matching === 'descendants' &&
+            profileContext?.conceptKindLineages
+                .get(subjectKind)
+                ?.includes(selected) === true));
+};
+const selectSubjects = (index, selector, profileContext) => {
+    // The schema's declared default for kindMatching is descendants, so a
+    // profile-derived kind satisfies a catalogue written against its parent.
+    const matching = selector.kindMatching ?? 'descendants';
+    let ids = [...index.concepts].filter((id) => kindMatches(index.kindOf.get(id), selector.kinds, matching, profileContext));
+    if (selector.statuses !== undefined) {
+        const statuses = new Set(selector.statuses);
+        ids = ids.filter((id) => {
+            const status = index.statusOf.get(id);
+            return status !== undefined && statuses.has(status);
+        });
+    }
+    if (selector.documents !== undefined) {
+        const documents = new Set(selector.documents);
+        ids = ids.filter((id) => documents.has(id.slice(0, id.indexOf('#'))));
+    }
+    return ids.sort((left, right) => left.localeCompare(right));
+};
+const relationshipKindMatches = (predicate, selectedKinds, matching, profileContext) => selectedKinds.some((selected) => selected === predicate ||
+    (matching === 'descendants' &&
+        profileContext?.relationshipKindLineages
+            .get(predicate)
+            ?.includes(selected) === true));
+const conditionHolds = (index, condition, subjectId, profileContext) => {
+    switch (condition.condition) {
+        case 'missing-claim':
+            return !(index.claimsBySubject.get(subjectId) ?? []).some(({ predicate }) => predicate === condition.predicate);
+        case 'missing-relationship': {
+            // Relationship kinds resolve through profile lineage by default, the
+            // same rule as selectors: a catalogue written against core kinds must
+            // see a profile-derived kind such as implements (realization child).
+            const matching = condition.kindMatching ?? 'descendants';
+            const touching = index.relationshipClaims.filter(({ predicate }) => relationshipKindMatches(predicate, condition.kinds, matching, profileContext));
+            const outgoing = touching.some(({ subject }) => subject === subjectId);
+            const incoming = touching.some(({ object }) => 'ref' in object && object.ref === subjectId);
+            if (condition.direction === 'outgoing')
+                return !outgoing;
+            if (condition.direction === 'incoming')
+                return !incoming;
+            return !outgoing && !incoming;
+        }
+        case 'isolated':
+            // Participation includes reference-bearing claims (ownership,
+            // constraints, identified references), not only relationships.
+            return (!index.relationshipClaims.some(({ subject, object }) => subject === subjectId ||
+                ('ref' in object && object.ref === subjectId)) &&
+                !index.referenceClaims.some(({ object }) => 'ref' in object && object.ref === subjectId));
+        case 'no-subject-of-kind':
+            return ![...index.concepts].some((id) => condition.kinds.includes(index.kindOf.get(id) ?? ''));
+        case 'no-state-defined':
+            return !index.hasStates;
+        case 'missing-linkage': {
+            // The linkage-depth primitive: the subject lacks a relationship of
+            // these kinds, in this direction, whose counterpart is of one of
+            // these kinds. Both relationship and counterpart kinds resolve
+            // through profile lineage by default, matching the selector rule.
+            const matching = condition.kindMatching ?? 'descendants';
+            return !index.relationshipClaims.some((claim) => {
+                if (!('ref' in claim.object))
+                    return false;
+                if (!relationshipKindMatches(claim.predicate, condition.kinds, matching, profileContext)) {
+                    return false;
+                }
+                const counterpart = condition.direction === 'outgoing'
+                    ? claim.subject === subjectId
+                        ? claim.object.ref
+                        : undefined
+                    : claim.object.ref === subjectId
+                        ? claim.subject
+                        : undefined;
+                return (counterpart !== undefined &&
+                    kindMatches(index.kindOf.get(counterpart), condition.counterpartKinds, matching, profileContext));
+            });
+        }
+        case 'missing-reference':
+            return !index.referenceClaims.some((claim) => claim.predicate === condition.predicate &&
+                'ref' in claim.object &&
+                (condition.direction === 'outgoing'
+                    ? claim.subject === subjectId
+                    : claim.object.ref === subjectId));
+        case 'missing-attestation':
+            return !(index.claimsBySubject.get(subjectId) ?? []).some(({ predicate }) => predicate === `yarramate/attestation/${condition.topic}`);
+    }
+};
+const renderQuestion = (template, subjectId, subjectName) => template
+    .trim()
+    .replaceAll('{subject.name}', subjectName ?? subjectId)
+    .replaceAll('{subject.id}', subjectId);
+export function evaluateCatalogue(catalogue, graph, profileContext) {
+    const index = indexGraph(graph);
+    let open = 0;
+    let openQuestions = 0;
+    const waves = catalogue.waves.map((wave) => ({
+        id: wave.id,
+        name: wave.name,
+        questions: catalogue.questions
+            .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(),
+            };
+            if (question.scope === 'workspace') {
+                const isOpen = question.trigger.every((condition) => conditionHolds(index, condition, undefined, profileContext));
+                if (isOpen) {
+                    open += 1;
+                    openQuestions += 1;
+                }
+                return { ...base, open: isOpen };
+            }
+            const matches = selectSubjects(index, question.subjects, profileContext).filter((id) => question.trigger.every((condition) => conditionHolds(index, condition, id, profileContext)));
+            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),
+                    };
+                }),
+            };
+        }),
+    }));
+    return {
+        format: 'yarramate/interrogation-report/v1',
+        catalogue: `${catalogue.id}@${catalogue.version}`,
+        summary: {
+            questions: catalogue.questions.length,
+            openQuestions,
+            open,
+        },
+        waves,
+    };
+}
+// Shared by interrogate and design: schema validation plus the YM911
+// undeclared-wave check, both source-located against the catalogue file.
+export function loadQuestionCatalogue(catalogueSource) {
+    const loadedCatalogue = loadSourceDocument(catalogueSource, validateCatalogue, 'Question catalogue');
+    if (!loadedCatalogue.ok) {
+        return { ok: false, diagnostics: loadedCatalogue.diagnostics };
+    }
+    const catalogue = loadedCatalogue.document.value;
+    const waveIds = new Set(catalogue.waves.map(({ id }) => id));
+    const waveDiagnostics = catalogue.questions.flatMap((question, questionIndex) => waveIds.has(question.wave)
+        ? []
+        : [
+            {
+                severity: 'error',
+                code: 'YM911',
+                message: `Question "${question.id}" references undeclared wave "${question.wave}"`,
+                ...locateSourcePath(catalogueSource.path, loadedCatalogue.document.yaml, loadedCatalogue.document.lineCounter, ['questions', questionIndex, 'wave'], `/questions/${questionIndex}/wave`),
+            },
+        ]);
+    if (waveDiagnostics.length > 0) {
+        return { ok: false, diagnostics: waveDiagnostics };
+    }
+    return { ok: true, catalogue };
+}
+// Shared by interrogate and `ask --open`: the wave-by-wave human report.
+export function renderInterrogationReport(report) {
+    const lines = [
+        `Catalogue ${report.catalogue} on workspace ${report.workspace}: ` +
+            `${report.summary.open} open ` +
+            `(${report.summary.openQuestions} of ${report.summary.questions} questions)`,
+    ];
+    for (const wave of report.waves) {
+        lines.push('', `== ${wave.name} ==`);
+        for (const question of wave.questions) {
+            if (!question.open) {
+                lines.push(`  closed ${question.id}`);
+                continue;
+            }
+            if (question.subjects === undefined) {
+                lines.push(`  OPEN   ${question.id} — ${question.question}`);
+                lines.push(`         why: ${question.materiality}`);
+                continue;
+            }
+            lines.push(`  OPEN   ${question.id} (${question.subjects.length} ${question.subjects.length === 1 ? 'subject' : 'subjects'})`);
+            for (const subject of question.subjects) {
+                lines.push(`         ask: "${subject.question}" [authority: ${question.authority}]`);
+            }
+        }
+    }
+    return `${lines.join('\n')}\n`;
+}

package/dist/next-command.d.ts

@@ -1,4 +1,6 @@
-import { type CliResult } from './cli-support.js';
+import { type ResolvedProfileContext, type SemanticGraph } from './compiler.js';
+import { type EvidenceReport } from './evidence.js';
+import { type ProjectionResult } from './projection.js';
 interface EvidenceCoverage {
     readonly observations: number;
     readonly confirmed: number;
@@ -15,11 +17,6 @@ export interface NextSubject {
     readonly evidence: EvidenceCoverage;
     readonly cycle?: true;
 }
-export interface NextResult {
-    readonly format: 'yarramate/next-result/v1';
-    readonly workspace: string;
-    readonly projection: string;
-    readonly subjects: readonly NextSubject[];
-}
-export declare function runNextCommand(options: readonly string[], cwd: string): CliResult;
+export declare const coverageClause: (coverage: EvidenceCoverage) => string;
+export declare function buildNextSubjects(result: ProjectionResult, graph: SemanticGraph, profileContext: ResolvedProfileContext | undefined, reports: readonly EvidenceReport[]): readonly NextSubject[];
 export {};

package/dist/next-command.js

@@ -1,11 +1,3 @@
-import { readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import { parseDocument } from 'yaml';
-import { diagnosticJson, humanDiagnostics, usage, } from './cli-support.js';
-import { compileWorkspaceWithProfileContext, } from './compiler.js';
-import { evaluateEvidenceWorkspace, loadEvidence, } from './evidence.js';
-import { evaluateProjection, loadProjection } from './projection.js';
-import { loadWorkspaceManifest } from './workspace.js';
 // Which endpoint of a declared relationship must exist before the other,
 // read off each core kind's declared intent (ADR 0048). Kinds without a
 // build-order reading (association, assignment, influence) contribute no
@@ -41,7 +33,7 @@ const claimValue = (claims, subject, predicate) => {
     return object !== undefined && 'value' in object ? object.value : undefined;
 };
 const plural = (count, singular) => `${count} ${count === 1 ? singular : `${singular}s`}`;
-const coverageClause = (coverage) => {
+export const coverageClause = (coverage) => {
     if (coverage.observations === 0)
         return 'no evidence';
     const parts = [
@@ -56,217 +48,120 @@ const coverageClause = (coverage) => {
     ];
     return `${plural(coverage.observations, 'observation')} (${parts.join(', ')})`;
 };
-export function runNextCommand(options, cwd) {
-    const json = options.includes('--json');
-    const rest = options.filter((option) => option !== '--json');
-    const [projectionPath, workspacePath] = rest;
-    if (rest.length !== 2 ||
-        projectionPath === undefined ||
-        workspacePath === undefined ||
-        rest.some((option) => option.startsWith('-'))) {
-        return { exitCode: 2, stdout: '', stderr: usage };
-    }
-    try {
-        const manifestSource = readFileSync(resolve(cwd, workspacePath), 'utf8');
-        if (parseDocument(manifestSource).get('format') !== 'yarramate/workspace/v1') {
-            return {
-                exitCode: 2,
-                stdout: '',
-                stderr: 'next requires an explicit workspace manifest (yarramate/workspace/v1)\n',
-            };
-        }
-        const failed = (diagnostics) => ({
-            exitCode: 1,
-            stdout: json ? diagnosticJson(diagnostics) : humanDiagnostics(diagnostics),
-            stderr: '',
-        });
-        const loadedWorkspace = loadWorkspaceManifest({ path: workspacePath, source: manifestSource }, cwd);
-        if (!loadedWorkspace.ok)
-            return failed(loadedWorkspace.diagnostics);
-        const workspace = loadedWorkspace.workspace;
-        const loadedProjection = loadProjection({
-            path: projectionPath,
-            source: readFileSync(resolve(cwd, projectionPath), 'utf8'),
-        });
-        if (!loadedProjection.ok)
-            return failed(loadedProjection.diagnostics);
-        const compilation = compileWorkspaceWithProfileContext([...workspace.profiles, ...workspace.documents].map((path) => ({
-            path,
-            source: readFileSync(resolve(cwd, path), 'utf8'),
-        })));
-        if (!compilation.ok)
-            return failed(compilation.diagnostics);
-        const graph = compilation.graph;
-        const evidenceDocuments = [];
-        for (const path of workspace.evidence) {
-            const loaded = loadEvidence({
-                path,
-                source: readFileSync(resolve(cwd, path), 'utf8'),
-            });
-            if (!loaded.ok)
-                return failed(loaded.diagnostics);
-            evidenceDocuments.push(loaded.evidence);
-        }
-        const evaluation = evaluateEvidenceWorkspace(graph, evidenceDocuments);
-        if (!evaluation.ok)
-            return failed(evaluation.diagnostics);
-        const result = evaluateProjection(graph, loadedProjection.projection, compilation.profileContext);
-        const planned = result.subjects
-            .filter(({ id, type }) => type === 'concept' &&
-            claimValue(result.claims, id, 'yarramate/lifecycle/status') ===
-                'planned')
-            .map(({ id }) => id);
-        const plannedIds = new Set(planned);
-        const dependsOn = new Map();
-        const requiredBy = new Map();
-        for (const subject of result.subjects) {
-            if (subject.type !== 'relationship')
-                continue;
-            const claim = result.claims.find(({ id, object }) => id === subject.id && 'ref' in object);
-            if (claim === undefined || !('ref' in claim.object))
-                continue;
-            const orientation = prerequisiteEndpoint(claim.predicate, compilation.profileContext);
-            if (orientation === undefined)
-                continue;
-            const prerequisite = orientation === 'source' ? claim.subject : claim.object.ref;
-            const dependent = orientation === 'source' ? claim.object.ref : claim.subject;
-            if (prerequisite === dependent ||
-                !plannedIds.has(prerequisite) ||
-                !plannedIds.has(dependent)) {
-                continue;
-            }
-            dependsOn.set(dependent, (dependsOn.get(dependent) ?? new Set()).add(prerequisite));
-            requiredBy.set(prerequisite, (requiredBy.get(prerequisite) ?? new Set()).add(dependent));
+// The build-ordering core, shared by `next` and `ask`: planned subjects in
+// deterministic Kahn order with dependency links and evidence coverage.
+export function buildNextSubjects(result, graph, profileContext, reports) {
+    const planned = result.subjects
+        .filter(({ id, type }) => type === 'concept' &&
+        claimValue(result.claims, id, 'yarramate/lifecycle/status') ===
+            'planned')
+        .map(({ id }) => id);
+    const plannedIds = new Set(planned);
+    const dependsOn = new Map();
+    const requiredBy = new Map();
+    for (const subject of result.subjects) {
+        if (subject.type !== 'relationship')
+            continue;
+        const claim = result.claims.find(({ id, object }) => id === subject.id && 'ref' in object);
+        if (claim === undefined || !('ref' in claim.object))
+            continue;
+        const orientation = prerequisiteEndpoint(claim.predicate, profileContext);
+        if (orientation === undefined)
+            continue;
+        const prerequisite = orientation === 'source' ? claim.subject : claim.object.ref;
+        const dependent = orientation === 'source' ? claim.object.ref : claim.subject;
+        if (prerequisite === dependent ||
+            !plannedIds.has(prerequisite) ||
+            !plannedIds.has(dependent)) {
+            continue;
         }
-        // Deterministic Kahn ordering: everything whose prerequisites are
-        // already emitted goes next, lexicographic within a round; a cycle
-        // cannot be ordered, so its members are appended sorted and marked.
-        const ordered = [];
-        const cycles = new Set();
-        const emitted = new Set();
-        const remaining = new Set([...planned].sort());
-        while (remaining.size > 0) {
-            const ready = [...remaining]
-                .filter((id) => [...(dependsOn.get(id) ?? [])].every((dependency) => emitted.has(dependency)))
-                .sort();
-            if (ready.length === 0) {
-                for (const id of [...remaining].sort()) {
-                    ordered.push(id);
-                    cycles.add(id);
-                }
-                break;
-            }
-            for (const id of ready) {
+        dependsOn.set(dependent, (dependsOn.get(dependent) ?? new Set()).add(prerequisite));
+        requiredBy.set(prerequisite, (requiredBy.get(prerequisite) ?? new Set()).add(dependent));
+    }
+    // Deterministic Kahn ordering: everything whose prerequisites are
+    // already emitted goes next, lexicographic within a round; a cycle
+    // cannot be ordered, so its members are appended sorted and marked.
+    const ordered = [];
+    const cycles = new Set();
+    const emitted = new Set();
+    const remaining = new Set([...planned].sort());
+    while (remaining.size > 0) {
+        const ready = [...remaining]
+            .filter((id) => [...(dependsOn.get(id) ?? [])].every((dependency) => emitted.has(dependency)))
+            .sort();
+        if (ready.length === 0) {
+            for (const id of [...remaining].sort()) {
                 ordered.push(id);
-                emitted.add(id);
-                remaining.delete(id);
+                cycles.add(id);
             }
+            break;
         }
-        const relationshipIds = new Set(graph.subjects
-            .filter(({ type }) => type === 'relationship')
-            .map(({ id }) => id));
-        const relationshipEndpoints = new Map();
-        const claimOwners = new Map();
-        for (const claim of graph.claims) {
-            claimOwners.set(claim.id, claim.subject);
-            if (relationshipIds.has(claim.id) && 'ref' in claim.object) {
-                relationshipEndpoints.set(claim.id, [claim.subject, claim.object.ref]);
-            }
+        for (const id of ready) {
+            ordered.push(id);
+            emitted.add(id);
+            remaining.delete(id);
         }
-        const coverageTargets = (observation) => {
-            const target = 'subject' in observation ? observation.subject : observation.claim;
-            const endpoints = relationshipEndpoints.get(target);
-            if (endpoints !== undefined)
-                return endpoints;
-            if ('claim' in observation) {
-                const owner = claimOwners.get(target);
-                if (owner === undefined)
-                    return [];
-                return relationshipEndpoints.get(owner) ?? [owner];
-            }
-            return [target];
-        };
-        const coverage = new Map();
-        for (const id of planned) {
-            coverage.set(id, {
-                observations: 0,
-                confirmed: 0,
-                contradicted: 0,
-                unknown: 0,
-                notObserved: 0,
-            });
+    }
+    const relationshipIds = new Set(graph.subjects
+        .filter(({ type }) => type === 'relationship')
+        .map(({ id }) => id));
+    const relationshipEndpoints = new Map();
+    const claimOwners = new Map();
+    for (const claim of graph.claims) {
+        claimOwners.set(claim.id, claim.subject);
+        if (relationshipIds.has(claim.id) && 'ref' in claim.object) {
+            relationshipEndpoints.set(claim.id, [claim.subject, claim.object.ref]);
         }
-        for (const report of evaluation.reports) {
-            for (const observation of report.observations) {
-                for (const target of coverageTargets(observation)) {
-                    const tally = coverage.get(target);
-                    if (tally === undefined)
-                        continue;
-                    tally.observations += 1;
-                    if (observation.result === 'not-observed') {
-                        tally.notObserved += 1;
-                    }
-                    else {
-                        tally[observation.result] += 1;
-                    }
-                }
-            }
+    }
+    const coverageTargets = (observation) => {
+        const target = 'subject' in observation ? observation.subject : observation.claim;
+        const endpoints = relationshipEndpoints.get(target);
+        if (endpoints !== undefined)
+            return endpoints;
+        if ('claim' in observation) {
+            const owner = claimOwners.get(target);
+            if (owner === undefined)
+                return [];
+            return relationshipEndpoints.get(owner) ?? [owner];
         }
-        const subjects = ordered.map((id) => {
-            const name = claimValue(result.claims, id, 'yarramate/concept/name');
-            return {
-                id,
-                kind: claimValue(result.claims, id, 'yarramate/concept/kind') ?? 'unknown',
-                ...(name === undefined ? {} : { name }),
-                dependsOn: [...(dependsOn.get(id) ?? [])].sort(),
-                requiredBy: [...(requiredBy.get(id) ?? [])].sort(),
-                evidence: coverage.get(id),
-                ...(cycles.has(id) ? { cycle: true } : {}),
-            };
+        return [target];
+    };
+    const coverage = new Map();
+    for (const id of planned) {
+        coverage.set(id, {
+            observations: 0,
+            confirmed: 0,
+            contradicted: 0,
+            unknown: 0,
+            notObserved: 0,
         });
-        const projectionLabel = `${loadedProjection.projection.id}@${loadedProjection.projection.version}`;
-        if (json) {
-            const payload = {
-                format: 'yarramate/next-result/v1',
-                workspace: workspace.id,
-                projection: projectionLabel,
-                subjects,
-            };
-            return {
-                exitCode: 0,
-                stdout: `${JSON.stringify(payload, null, 2)}\n`,
-                stderr: '',
-            };
-        }
-        if (subjects.length === 0) {
-            return {
-                exitCode: 0,
-                stdout: `No planned subjects in projection ${projectionLabel}.\n`,
-                stderr: '',
-            };
+    }
+    for (const report of reports) {
+        for (const observation of report.observations) {
+            for (const target of coverageTargets(observation)) {
+                const tally = coverage.get(target);
+                if (tally === undefined)
+                    continue;
+                tally.observations += 1;
+                if (observation.result === 'not-observed') {
+                    tally.notObserved += 1;
+                }
+                else {
+                    tally[observation.result] += 1;
+                }
+            }
         }
-        const width = Math.max(...subjects.map(({ id }) => id.length));
-        const lines = [
-            `Planned subjects in projection ${projectionLabel} (dependency order):`,
-            ...subjects.map((subject) => {
-                const clauses = [
-                    ...(subject.requiredBy.length > 0
-                        ? [`<- required by ${subject.requiredBy.join(', ')}`]
-                        : []),
-                    coverageClause(subject.evidence),
-                    ...(subject.cycle === true ? ['dependency cycle'] : []),
-                ];
-                return `  ${subject.id.padEnd(width)}  ${clauses.join('; ')}`;
-            }),
-        ];
+    }
+    return ordered.map((id) => {
+        const name = claimValue(result.claims, id, 'yarramate/concept/name');
         return {
-            exitCode: 0,
-            stdout: `${lines.join('\n')}\n`,
-            stderr: '',
+            id,
+            kind: claimValue(result.claims, id, 'yarramate/concept/kind') ?? 'unknown',
+            ...(name === undefined ? {} : { name }),
+            dependsOn: [...(dependsOn.get(id) ?? [])].sort(),
+            requiredBy: [...(requiredBy.get(id) ?? [])].sort(),
+            evidence: coverage.get(id),
+            ...(cycles.has(id) ? { cycle: true } : {}),
         };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return { exitCode: 2, stdout: '', stderr: `${message}\n` };
-    }
+    });
 }