yarramate 0.5.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

@@ -0,0 +1,22 @@
+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;
+    readonly contradicted: number;
+    readonly unknown: number;
+    readonly notObserved: number;
+}
+export interface NextSubject {
+    readonly id: string;
+    readonly kind: string;
+    readonly name?: string;
+    readonly dependsOn: readonly string[];
+    readonly requiredBy: readonly string[];
+    readonly evidence: EvidenceCoverage;
+    readonly cycle?: true;
+}
+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

@@ -0,0 +1,167 @@
+// 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
+// ordering edge rather than a guessed one.
+const corePrerequisiteEndpoints = new Map([
+    ['realization', 'source'],
+    ['serving', 'source'],
+    ['triggering', 'source'],
+    ['flow', 'source'],
+    ['composition', 'target'],
+    ['aggregation', 'target'],
+    ['access', 'target'],
+    ['specialization', 'target'],
+]);
+const prerequisiteEndpoint = (kind, profileContext) => {
+    const candidates = [
+        kind,
+        ...(profileContext?.relationshipKindLineages.get(kind) ?? []),
+    ];
+    for (const candidate of candidates) {
+        const separator = candidate.indexOf('#');
+        if (separator === -1 || !candidate.startsWith('yarramate/core@')) {
+            continue;
+        }
+        const orientation = corePrerequisiteEndpoints.get(candidate.slice(separator + 1));
+        if (orientation !== undefined)
+            return orientation;
+    }
+    return undefined;
+};
+const claimValue = (claims, subject, predicate) => {
+    const object = claims.find((claim) => claim.subject === subject && claim.predicate === predicate)?.object;
+    return object !== undefined && 'value' in object ? object.value : undefined;
+};
+const plural = (count, singular) => `${count} ${count === 1 ? singular : `${singular}s`}`;
+export const coverageClause = (coverage) => {
+    if (coverage.observations === 0)
+        return 'no evidence';
+    const parts = [
+        ...(coverage.confirmed > 0 ? [`${coverage.confirmed} confirmed`] : []),
+        ...(coverage.contradicted > 0
+            ? [`${coverage.contradicted} contradicted`]
+            : []),
+        ...(coverage.unknown > 0 ? [`${coverage.unknown} unknown`] : []),
+        ...(coverage.notObserved > 0
+            ? [`${coverage.notObserved} not observed`]
+            : []),
+    ];
+    return `${plural(coverage.observations, 'observation')} (${parts.join(', ')})`;
+};
+// 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;
+        }
+        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);
+                cycles.add(id);
+            }
+            break;
+        }
+        for (const id of ready) {
+            ordered.push(id);
+            emitted.add(id);
+            remaining.delete(id);
+        }
+    }
+    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]);
+        }
+    }
+    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,
+        });
+    }
+    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;
+                }
+            }
+        }
+    }
+    return 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 } : {}),
+        };
+    });
+}

package/dist/reconciliation.d.ts

@@ -28,7 +28,9 @@ export interface ReconciliationReport {
         readonly contradicted: number;
         readonly unknown: number;
         readonly notObserved: number;
+        readonly subjectsWithoutEvidence: number;
     };
     readonly findings: readonly ReconciliationFinding[];
+    readonly unobservedSubjects?: readonly string[];
 }
 export declare function reconcileEvidenceReports(workspace: string, reports: readonly EvidenceReport[], graph?: SemanticGraph): ReconciliationReport;

package/dist/reconciliation.js

@@ -25,8 +25,44 @@ const assertedRelationshipsByClaim = (graph) => {
     }
     return asserted;
 };
+const unobservedCurrentConcepts = (graph, reports) => {
+    if (graph === undefined)
+        return [];
+    const relationshipIds = new Set(graph.subjects
+        .filter(({ type }) => type === 'relationship')
+        .map(({ id }) => id));
+    const claimsById = new Map(graph.claims.map((claim) => [claim.id, claim]));
+    const observed = new Set();
+    for (const report of reports) {
+        for (const observation of report.observations) {
+            if ('subject' in observation) {
+                observed.add(observation.subject);
+                continue;
+            }
+            const claim = claimsById.get(observation.claim);
+            if (claim === undefined)
+                continue;
+            observed.add(claim.subject);
+            if (relationshipIds.has(claim.id) && 'ref' in claim.object) {
+                observed.add(claim.object.ref);
+            }
+        }
+    }
+    const conceptIds = new Set(graph.subjects
+        .filter(({ type }) => type === 'concept')
+        .map(({ id }) => id));
+    return graph.claims
+        .filter((claim) => claim.predicate === 'yarramate/lifecycle/status' &&
+        'value' in claim.object &&
+        claim.object.value === 'current' &&
+        conceptIds.has(claim.subject) &&
+        !observed.has(claim.subject))
+        .map(({ subject }) => subject)
+        .sort((left, right) => left.localeCompare(right));
+};
 export function reconcileEvidenceReports(workspace, reports, graph) {
     const assertedByClaim = assertedRelationshipsByClaim(graph);
+    const unobservedSubjects = unobservedCurrentConcepts(graph, reports);
     const summary = {
         evidenceDocuments: reports.length,
         observations: 0,
@@ -35,6 +71,7 @@ export function reconcileEvidenceReports(workspace, reports, graph) {
         contradicted: 0,
         unknown: 0,
         notObserved: 0,
+        subjectsWithoutEvidence: unobservedSubjects.length,
     };
     const findings = [];
     for (const report of reports) {
@@ -74,5 +111,6 @@ export function reconcileEvidenceReports(workspace, reports, graph) {
         workspace,
         summary,
         findings,
+        ...(unobservedSubjects.length === 0 ? {} : { unobservedSubjects }),
     };
 }

package/docs/CONSUMING-YARRAMATE.md

@@ -63,7 +63,19 @@ self-model, source, tests, and fixtures.
 
 ## Install the agent skill
 
-After the repository is public, use the agent-skills installer:
+For Claude Code, the repository is its own plugin marketplace:
+
+```sh
+/plugin marketplace add yarrasys/yarramate
+/plugin install yarramate-architecture@yarramate
+```
+
+The marketplace entry points at `skills/yarramate-architecture` in this
+repository, so the installed plugin is the canonical skill rather than a
+copy. It declares no version, taking its version from the commit it was
+installed from.
+
+For other harnesses, use the agent-skills installer:
 
 ```sh
 npx skills add yarrasys/yarramate --skill yarramate-architecture
@@ -91,15 +103,13 @@ The skill will inspect repository evidence, propose native documents, and run:
 
 ```sh
 yarramate check .yarramate/workspace.yaml --json
-yarramate evidence \
-  .yarramate/evidence/<evidence>.yaml \
-  .yarramate/workspace.yaml
 yarramate reconcile .yarramate/workspace.yaml
-yarramate context \
-  .yarramate/projections/<projection>.yaml \
-  .yarramate/workspace.yaml
+yarramate ask .yarramate/workspace.yaml \
+  .yarramate/projections/<projection>.yaml
 ```
 
+Evidence overlays declared in the manifest are evaluated by `reconcile`
+(and gated by `check --strict`) rather than through a separate command.
 Evidence remains distinct from declared intent. A generated proposal becomes
 canonical only through the consuming repository's normal Git review.
 
@@ -111,15 +121,12 @@ implementation context, then runs:
 
 ```sh
 yarramate check .yarramate/workspace.yaml --json
-yarramate context \
-  .yarramate/projections/<alternatives>.yaml \
-  .yarramate/workspace.yaml
-yarramate context \
-  .yarramate/projections/<target>.yaml \
-  .yarramate/workspace.yaml
-yarramate compare \
-  <baseline-state> <target-state> \
-  .yarramate/workspace.yaml
+yarramate ask .yarramate/workspace.yaml \
+  .yarramate/projections/<alternatives>.yaml
+yarramate ask .yarramate/workspace.yaml \
+  .yarramate/projections/<target>.yaml
+yarramate ask .yarramate/workspace.yaml \
+  --compare <baseline-state> <target-state>
 ```
 
 The CLI verifies deterministic correctness. It does not approve the design or
@@ -158,11 +165,11 @@ Harnesses that load MCP servers can connect the bundled read-only adapter:
 }
 ```
 
-It exposes `yarramate_status`, `yarramate_check`, `yarramate_reconcile`,
-and `yarramate_context` (projection path or ad-hoc subjects, with an
-optional token budget). Every tool call executes the same stable CLI in
-the server's working directory; nothing mutates native documents, and
-authoring stays with the CLI and Git review.
+It exposes `yarramate_ask` (orientation, free text, subject ids, or a
+projection path, with an optional token budget), `yarramate_design`,
+`yarramate_check`, and `yarramate_reconcile`. Every tool call executes the
+same stable CLI in the server's working directory; nothing mutates native
+documents, and authoring stays with the CLI and Git review.
 
 ## Continuous drift signal in CI
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yarramate",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Tool-neutral semantic architecture engine and guided methodology",
   "license": "MIT",
   "repository": {
@@ -25,6 +25,7 @@
     "dist",
     "assets/likec4",
     "schema",
+    "catalogues",
     "skills/yarramate-architecture",
     "docs/CONSUMING-YARRAMATE.md"
   ],
@@ -58,14 +59,19 @@
     "./schema/likec4-kind-mapping": "./schema/yarramate-likec4-kind-mapping.schema.json",
     "./schema/likec4-check-result": "./schema/yarramate-likec4-check-result.schema.json",
     "./schema/state-comparison": "./schema/yarramate-state-comparison.schema.json",
-    "./schema/status-result": "./schema/yarramate-status-result.schema.json",
+    "./schema/question-catalogue": "./schema/yarramate-question-catalogue.schema.json",
+    "./schema/interrogation-report": "./schema/yarramate-interrogation-report.schema.json",
     "./schema/graph-v2": "./schema/yarramate-graph-v2.schema.json",
     "./schema/workspace": "./schema/yarramate-workspace.schema.json",
     "./schema/evidence": "./schema/yarramate-evidence.schema.json",
     "./schema/evidence-report": "./schema/yarramate-evidence-report.schema.json",
     "./schema/reconciliation-report": "./schema/yarramate-reconciliation-report.schema.json",
     "./schema/core-contract": "./schema/yarramate-core-contract.schema.json",
-    "./skill/yarramate-architecture": "./skills/yarramate-architecture/SKILL.md"
+    "./skill/yarramate-architecture": "./skills/yarramate-architecture/SKILL.md",
+    "./schema/operations": "./schema/yarramate-operations.schema.json",
+    "./schema/apply-result": "./schema/yarramate-apply-result.schema.json",
+    "./schema/design-step": "./schema/yarramate-design-step.schema.json",
+    "./schema/ask-result": "./schema/yarramate-ask-result.schema.json"
   },
   "bin": {
     "yarramate": "dist/cli.js",
@@ -84,13 +90,10 @@
     "format": "likec4 format assets/likec4",
     "self:check": "pnpm build && node dist/cli.js check .yarramate/workspace.yaml",
     "self:check:json": "pnpm build && node dist/cli.js check .yarramate/workspace.yaml --json",
-    "self:compile": "pnpm build && node dist/cli.js compile .yarramate/workspace.yaml",
-    "self:context": "pnpm build && node dist/cli.js context .yarramate/projections/current-engine.yaml .yarramate/workspace.yaml",
-    "self:view": "pnpm build && node dist/cli.js view .yarramate/projections/current-engine.yaml .yarramate/workspace.yaml",
-    "self:compare": "pnpm build && node dist/cli.js compare yarramate-evolution#native-foundation yarramate-evolution#state-foundation .yarramate/workspace.yaml",
-    "self:compare:contract": "pnpm build && node dist/cli.js compare yarramate-evolution#state-foundation yarramate-evolution#core-contract-foundation .yarramate/workspace.yaml",
-    "self:contract": "pnpm build && node dist/cli.js context .yarramate/projections/core-contract-foundation.yaml .yarramate/workspace.yaml",
-    "self:evidence": "pnpm build && node dist/cli.js evidence .yarramate/evidence/repository.yaml .yarramate/workspace.yaml",
+    "self:ask": "pnpm build && node dist/cli.js ask .yarramate/workspace.yaml",
+    "self:export:graph": "pnpm build && node dist/cli.js export graph .yarramate/workspace.yaml",
+    "self:export:markdown": "pnpm build && node dist/cli.js export markdown .yarramate/projections/current-engine.yaml .yarramate/workspace.yaml",
+    "self:compare": "pnpm build && node dist/cli.js ask .yarramate/workspace.yaml --compare yarramate-evolution#native-foundation yarramate-evolution#state-foundation",
     "self:reconcile": "pnpm build && node dist/cli.js reconcile .yarramate/workspace.yaml",
     "self:check:likec4": "pnpm build && node dist/adapters/likec4-cli.js check .yarramate/likec4-project.yaml .yarramate/workspace.yaml",
     "self:check:likec4:json": "pnpm build && node dist/adapters/likec4-cli.js check .yarramate/likec4-project.yaml --json .yarramate/workspace.yaml",